О чём не пишут в книгах по Delphi

4.7. Полноценный калькулятор

Последняя версия нашего калькулятора может считать сложные выражения, но чтобы он имел практическую ценность, этого мало. В этом разделе мы научим наш калькулятор использовать функции и переменные. Также будет введена операция возведения в степень, обозначающаяся значком "^".
Имена переменных и функций — это идентификаторы. Идентификатор определяется по общепринятым правилам: он должен начинаться с буквы латинского алфавита или символа "_", следующие символы должны быть буквами, цифрами или "_". Таким образом, грамматика идентификатора выглядит так.
<Letter> ::= 'А' | ... | ' Z' | 'а' ... | ' z' | '_'
<Identifier> ::= <Letter> {<Letter> | <Digit>}
Примечание
Следствием этой грамматики является то, что отдельно взятый символ "_" считается корректным идентификатором. И хотя это может на первый взгляд показаться абсурдным, тем не менее, именно таковы общепринятые правила. Легко убедиться, что, например, Delphi допускает объявление переменных с именами "_", "__" и т.п.
В нашей грамматике переменной будет называться отдельно стоящий идентификатор, функцией — идентификатор, после которого в скобках записан аргумент, в качестве которого может выступать любое допустимое выражение (для простоты мы будем рассматривать только функции с одним аргументом, т.к. обобщение грамматики на большее число аргументов очевидно). Другими словами, определение будет выглядеть так:
<Variable> ::= <Identifier>
<Function> ::= <Identifier> ' (' <Expr> ')'
Из приведенных определений видно, что грамматика, основанная на них, не относится к классу LR(1)-грамматик, т.к. обнаружив в выражении идентификатор, анализатор не может сразу решить, является ли этот идентификатор переменной или именем функции, это выяснится только при проверке следующего символа — скобка это или нет. Тем не менее реализация такой грамматики достаточно проста, и это не будет доставлять нам существенных неудобств.
Переменные и функции, так же, как и выражения, заключенные в скобки, выступают в роли множителей. Соответственно, их появление в грамматике учитывается расширением смысла символа <Factor>.
<Factor> ::= <UnaryOp> <Factor> |
 <Variable> |
 <Function> |
 <Number> |
 '(' <Expr> ')'
Теперь рассмотрим свойства оператора возведения в степень. Во-первых, его приоритет выше, чем у операций сложения и деления, т.е. выражение a*b^c трактуется как a*(b^c), а a^b*c — как (a^b)*c. Во-вторых, он правоассоциативен, т.е. a^b^c означает a^(b^c), а не (a^b)^c. В-третьих, его приоритет выше, чем приоритет унарных операций, т.е. -a^b означает -(a^b), а не (-а)^b. Тем не менее, a^-b означает a^(-b).
Таким образом, мы видим, что показателем степени может быть любой отдельно взятый множитель, а основанием — число, переменная, функция или выражение в скобках, т.е. любой множитель, за исключением начинающегося с унарного оператора. Запишем это в виде БНФ.
<Factor> ::= <UnaryOp> <Factor> | <Base> ['^' <Factor>]
<Base> ::= <Variable> | <Function> | <Number> | '(' <Expr> ')'
Правая ассоциативность также заложена в этих определениях. Рассмотрим, как будет разбираться выражение a^b^c. Сначала функция Factor (через вызов функции Base) выделит и вычислит множитель а, а потом вызовет саму себя для вычисления остатка b^c. Таким образом, а будет возведено в степень b^c, как это и требуют правила правой ассоциативности. Вообще, вопросы правой и левой ассоциативности операторов, которые мы здесь опустили, оказывают влияние на то, как определяется грамматика языка. Более подробно об этом написано в [5].
Так как определения символов <Expr> и <Term> в нашей новой грамматике не изменились, не изменятся и соответствующие функции. Для реализации нового синтаксиса нам потребуется изменить функцию Factor и ввести новые функции Base, Identifier и Func (примем такое сокращение, т.к. function в Delphi является зарезервированным словом). Идентификаторы будем полагать нечувствительными к регистру символов. 
Для простоты обойдемся тремя функциями: sin, cos и ln. Увеличение количества функций, допустимых в выражении, — простая техническая задача, не представляющая особого интереса.
Если у нас появились переменные, то мы должны как-то хранить их значения, чтобы при вычислении выражения использовать их. В нашем примере мы будем хранить их в объекте типа TStrings, получая доступ через свойство Values. С точки зрения производительности, этот способ — один из самых худших, поэтому при создании реального калькулятора лучше придумать что-нибудь другое. Мы здесь выбрали этот способ исключительно из соображений наглядности. Получившийся в итоге код показан в листинге 4.9.
Листинг 4.9. Реализация полноценного калькулятора
// вычисление функции, имя которой передается через FuncName
function Func(const FuncName, S: string; var Integer): Extended;
var
 Arg: Extended;
begin
 // Вычисляем аргумент
 Arg := Expr(S, P);
 // Сравниваем имя функции с одним из допустимых
 if AnsiCompareText(FuncName, 'sin') = 0 then
  Result := Sin(Arg)
 else if AnsiCompareText(FuncName, 'соs') = 0 then
  Result := Cos(Arg)
 else if AnsiCompareText(FuncName, 'ln') = 0 then
  Result := Ln(Arg)
 else
  raise ESyntaxError.Create('Неизвестная функция ' + FuncName);
end;

 

// Выделение из строки идентификатора и определение,
// является ли он переменной или функцией
function Identifier(const S: string: var P: Integer): Extended;
var
 InitP: Integer;
 IDStr, VarValue: string;
begin
 // Запоминаем начало идентификатора
 InitP := P;
 // Первый символ был проверен ещё в функции Base.
 // Сразу переходим к следующему
 Inc(P);
 while (P <= Length(S)) and
  (S[P] in ('A'..'Z', 'a'..'z', '_', '0'..'9']) do
  Inc(P);
 // Выделяем идентификатор из строки
 IDStr := Copy(S, InitP, P - InitP);
 // Если за ним стоит открываемая скобка — это функция
 if (Р <= Length(S)) and (S[P) - '(' then
 begin
  Inc(P);
  Result := Func(IDStr, S, P);
  // Проверяем, что скобка закрыта
  if (Р > Length(S)) or (S[P] <> ')') then
   raise ESyntaxError.Create(
    'Ожидается ")" в позиции ' + IntToStr(P));
  Inc(P);
 end
 // если скобки нет - переменная
 else
 begin
  VarValue := Form1.ListBoxVars.Items.Values[IDStr];
  if VarValue = '' then
   raise ESyntaxError.Create(
    'Необъявленная переменная ' + IDStr +
    ' в позиции ' + IntToStr(P))
  elsе Result := StrToFloat(VarValue);
 end;
end;

 

// Выделение подстроки, соответствующей <Base>,
// и ее вычисление
function Base(const S: string; var P: Integer): Extended;
begin
 if P > Length(S) then
  raise ESyntaxError.Create('Неожиданный конец строки');
 // По первому символу подстроки определяем,
 // какое это основание
 case S[P] of
 '(': // выражение в скобках
 begin
  Inc(Р);
  Result := Expr(S, Р);
  // Проверяем, что скобка закрыта
  if (Р > Length(S)) or (S[P) <> ')') then
   raise ESyntaxError.Create(
    'Ожидается ")" в позиции ' + IntToStr(Р));
  Inc(Р);
 end;
'0'..'9': // Числовая константа
  Result := Number(S, P);
 'A'..'Z', 'a'..'z', '_': // Идентификатор (переменная или функция)
  Result := Identifier(S, P);
 else
  raise ESyntaxError.Create(
   'Некорректный символ в позиции ' + IntToStr(Р));
 end;
end;

 

// Выделение подстроки, соответствующей <Factor>,
// и ее вычисление
function Factor(const S: string; var P: Integer): Extended;
begin
 if P > Length(S) then
  raise ESyntaxError.Create('Неожиданный конец строки');
 // По первому символу подстроки определяем,
 // какой это множитель
 case S[P] of
 '+'; // унарный "+"
 begin
  Inc(Р);
  Result := Factor(S, P);
 end;
 '-': // унарный "-"
 begin
  Inc(P);
  Result := -Factor(S, P);
 end;
 else
 begin
  Result := Base(S, P); 
  if (P <= Length(S)) and (S[P] = '^') then
  begin
   Inc(P);
   Result := Power(Result, Factor(S, P));
  end;
 end;
 end;
end;
Пример калькулятора называется FullCalcSample. Его интерфейс (рис. 4.2) содержит новые элементы, с помощью которых пользователь может задавать значения переменных. В левой нижней части окна находится список переменных с их значениями (при запуске программы этот список пустой). Правее расположены поля ввода Имя переменной и Значение переменной, а также кнопка Установить. В первое поле следует ввести имя переменной, во второе — ее значение. При нажатии на кнопку Установить переменная будет внесена в список, а если переменная с таким именем уже есть в списке, то ее значение будет обновлено. Все переменные, которые есть в списке, могут использоваться в выражении. Если требуемая переменная в списке не найдена, попытка вычислить выражение приводит к ошибке.
Рис. 4.2. Главное окно программы FullCalcSample

 

Заметим, что символ <Factor> можно было бы определить несколько иначе:
<Factor> ::= [<UnaryOp>] <Base> ['^' <Factor>]
В нашем случае, когда есть только два унарных оператора и применение срезу двух (разных или одинаковых) практически бессмысленно, такой синтаксис реализовать было бы проще (пример реализации такого синтаксиса дан в программе FullCalcSample в виде комментария). При этом исчезла бы возможность ставить несколько знаков унарных операций подряд. В общем случае такой подход неверен, т.к. при большем количестве унарных операций это может пригодиться, да и выглядит естественно. Поэтому в качестве основного был выбран несколько более сложный, но и более функциональный вариант.
Показать оглавление

Комментариев: 0

Оставить комментарий