[содержание] [назад] [пред] [вверх] [след] [вперед]
сейчас мы приведём и объясним три простые программы, написанные
с использованием bison: калькулятор обратной польской нотации, калькулятор
алгебраической (инфиксной) нотации, и многофункциональный калькулятор. все
три протестированы под bsd unix 4.3, каждая из них даёт пригодный для
использования, хотя и ограниченный, интерактивный настольный калькулятор.
эти примеры просты, но грамматики bison для реальных языков программирования
пишутся таким же образом.
первый пример -- это простой калькулятор с двойной точностью для выражений в
обратной польской нотации (использующий постфиксные операции). этот
пример является хорошей отправной точкой, поскольку приоритеты операций не
используются. обработка приоритетов будет показана во втором примере.
исходный код этого калькулятора называется `rpcalc.y'. по соглашению
для входных файлов bison используется расширение `.y'.
это объявления c и bison для калькулятора обратной польской нотации. как
и в c, комментарии помещаются между `/*...*/'.
/* калькулятор обратной польской нотации. */
%{
#define yystype double
#include <math.h>
%}
%token num
%% /* далее следуют правила грамматики и действия */
секция объявлений c (см. раздел 4.1.1 секция объявлений c содержит
две директивы препроцессора.
директива #define определяет макрос yystype. это задаёт тип
данных c для семантических значений как лексем, так и групп (см. раздел 4.5.1 типы данных семантических значений). анализатор bison будет
использовать любой тип, заданный yystype, а если вы не определили его
-- тип по умолчанию int. поскольку мы указали double, с каждой
лексемой и каждым выражением будет ассоциировано вещественное число.
директива #include используется для объявления функции возведения
в степень pow.
из второй секции, объявлений bison, bison получает информацию о типах лексем
(см. раздел 4.1.2 секция объявлений bison). здесь должен быть
объявлен любой терминальный символ, не являющийся однолитерной константой
(они, как правило, не нуждаются в объявлении). в этом примере все
арифметические операции обозначаются однолитерными константами, поэтому
нужно объявить только терминальный символ num, тип лексемы для числовых
констант.
это правила грамматики для калькулятора обратной польской нотации.
input: /* пусто */
| input line
;
line: '\n'
| exp '\n' { printf ("\t%.10g\n", $1); }
;
exp: num { $$ = $1; }
| exp exp '+' { $$ = $1 + $2; }
| exp exp '-' { $$ = $1 - $2; }
| exp exp '*' { $$ = $1 * $2; }
| exp exp '/' { $$ = $1 / $2; }
/* возведение в степень */
| exp exp '^' { $$ = pow ($1, $2); }
/* унарный минус */
| exp 'n' { $$ = -$1; }
;
%%
здесь определены группы "языка" rpcalc: выражение (названное exp),
строка ввода (line), и законченный входной текст (input). у
каждого из этих нетерминальных символов имеется несколько альтернативных
правил, объединённых знаком `|', читающимся "или". в последующих
разделах объясняется, что означают эти правила.
семантика языка определяется действиями, предпринимаемыми при распознавании
группы. действия -- это код на c, находящийся между фигурными скобками.
см. раздел 4.5.3 действия.
вы должны писать эти действия на c, однако bison предоставляет способ
передачи семантических значений между правилами. в каждом действии
псевдопеременная $$ обозначает семантическое значение группы,
которую собирает это правило. присвоение $$ значения -- основная
работа большинства действий. на семантические значения компонентов правила
можно ссылаться как на $1, $2 и т.д.
рассмотрим определение input:
input: /* пусто */
| input line
;
это определение читается следующим образом: "законченный входной текст
представляет собой пустую строку либо законченный входной текст, за
которым следует входная строка". обратите внимание, что "законченный
входной текст" определяется в терминах самого себя. это определение
называется леворекурсивным, поскольку input всегда является
самым левым символом последовательности. см. раздел 4.4 рекурсивные правила.
первая альтернатива пуста, поскольку между двоеточием и первым знаком
`|' нет символов. это означает, что input может соответствовать
пустой входной строке (без лексем). мы пишем так правило, потому что допустимо
нажатие клавиш ctrl-d сразу после запуска калькулятора. по соглашению
пустая альтернатива ставится первой и в ней пишется комментарий
`/* пусто */'.
второе альтернативное правило (input line) описывает любой
нетривиальный входной текст. оно означет "после прочтения любого количества
строк, прочитать ещё одну, если это возможно". левая рекурсия заставляет
это правило выполняться в цикле. поскольку первая альтернатива соответствует
пустому входному тексту, цикл будет выполняться ноль или более раз.
функция анализатора yyparse продолжает обработку входного текста
до тех пор, пока не будет обнаружена грамматическая ошибка или лексические
анализатор не скажет, что входных лексем больше нет -- мы условимся, что
это произойдёт по достижении конца файла.
теперь рассмотрим определение line:
line: '\n'
| exp '\n' { printf ("\t%.10g\n", $1); }
;
первая альтернатива -- это лексема литеры новой строки, это означает,
что rpcalc принимает пустую строку (и игнорирует её, поскольку там нет
никакого правила). вторая альтернатива -- это выражение, за которым следует
литера новой строки. именно эта альтернатива несёт основную пользу rpcalc.
семантическое значение группы exp -- это значение $1, потому
что искомое exp -- первый символ альтернативы. действие выводит это
значение, которое является результатом вычислений, заданных пользователем.
это действие необычно, потому что оно не присваивает значения $$.
вследствие этого семантическое значение line не инициализируется
(значение будет непредсказуемым). было бы ошибкой в программе, если бы
это значение когда-либо использовалось, но мы не пользуемся им -- после того,
как rpcalc вывел значение введённой пользователем входной строки, оно больше
не нужно.
группа exp имеет несколько правил, по одному на каждый вид выражений.
первое правило обрабатывает наиболее простым выражениям -- отдельным числам.
второе обрабатывает выражение сложения, которые выглядит как два выражения,
за которыми следует знак `плюс'. третье обрабатывает вычитание и т.д.
exp: num
| exp exp '+' { $$ = $1 + $2; }
| exp exp '-' { $$ = $1 - $2; }
...
;
мы используем `|' чтобы объединить все правила для exp, но мы
могли бы с тем же успехом написать их отдельно:
exp: num ;
exp: exp exp '+' { $$ = $1 + $2; } ;
exp: exp exp '-' { $$ = $1 - $2; } ;
...
у большей части правил есть действия, вычисляющие значение выражения из
значений его частей. например, в правиле для сложения $1 относится
к первому компоненту exp, а $2 -- ко второму. третий компонент,
'+' не имеет осмысленного ассоциированного семантического значения,
но если бы он имел его, на него можно было ссылаться как на $3. когда
yyparse, используя это правило, распознаёт выражение-сумму, сумма
значений двух подвыражений даст значение всего выражения. см. раздел 4.5.3 действия.
вы не обязаны приписывать действие каждому правилу. когда у правила нет
действия, по умолчанию bison копирует значение $1 в $$.
именно это происходит в первом правиле (используюшем num).
показанный здесь способ форматирования -- рекомендуемое соглашение, но
bison не требует этого. вы можете добавлять или изменять промежутки по
своему усмотрению. например, такая запись:
exp : num | exp exp '+' {$$ = $1 + $2; } | ...
означает то же, что и:
exp: num
| exp exp '+' { $$ = $1 + $2; }
| ...
однако последняя намного более наглядна.
задачей лексического анализатора является низкоуровневый разбор --
преобразование литер или последовательностей литер входного текста в
лексемы. анализатор bison получает эти лексемы, вызывая лексический
анализатор. см. раздел 5.2 функция лексического анализатора yylex.
для работы калькулятора обратной польской нотации нужен весьма простой
лексический анализатор. он пропускает пробелы и знаки табуляции, читает
числа как значения типа double и возвращает их как лексемы типа
num. любые другие литеры, не являющиеся частью числа, считаются
отдельными лексемами. имейте в виду, что код лексемы для таких однолитерных
лексем -- это сама литера.
возвращаемое значение функции лексического анализатора -- это числовой код,
представляющий тип лексемы. текст, используемый в правилах bison для
обозначения типа лексемы, также является выражением c для числового кода
этого типа. это может работать двумя способами. если тип лексемы является
литерой, её числовым кодом будет ascii-код этой литеры, вы можете использовать
в лексическом анализаторе в качестве числа ту же литеру. если тип лексемы --
идентификатор, этот идентификатор bison определяет как макрос c,
определением которого будет подходящее число. в этом примере, поэтому,
num становится макросом, используемым yylex.
семантическое значение лексемы (если оно у неё есть) сохраняется в глобальной
переменной yylval, где её и ищет анализатор bison (тип данных
yylval -- yystype, определяемый в начале грамматики;
см. раздел 3.1.1 объявления для rpcalc).
нулевой код типа лексемы возвращается, если обнаружен конец файла (bison
считает указателем конца входного файла любые неположительные значения).
ниже приведён код лексического анализатора:
/* лексический анализатор возвращает вещественное число
с двойной точностью в стеке и лексему num, или прочитанную
литеру ascii, если это не число. все пробелы и знаки
табуляции пропускаются, в случае конца файла возвращается 0. */
#include <ctype.h>
int
yylex (void)
{
int c;
/* пропустить промежутки */
while ((c = getchar ()) == ' ' || c == '\t')
;
/* обработка чисел */
if (c == '.' || isdigit (c))
{
ungetc (c, stdin);
scanf ("%lf", &yylval);
return num;
}
/* вернуть конец файла */
if (c == eof)
return 0;
/* вернуть одну литеру */
return c;
}
в соответствии c духом этого примера управляющая функция сведена к явному
минимуму. единственное требование -- она должна вызывать yyparse
чтобы запустить процесс разбора.
int
main (void)
{
return yyparse ();
}
когда yyparse обнаруживает синтаксическую ошибку, она вызывает
функцию сообщения об ошибках yyerror для вывода сообщения об
ошибке (обычно, но не всегда, "ошибка разбора"). предоставить эту
функцию должен программист (см. раздел 5. интерфейс анализатора на c),
поэтому приведём используемое нами определение:
#include <stdio.h>
void
yyerror (const char *s) /* вызывается yyparse в случае ошибки */
{
printf ("%s\n", s);
}
после возврата из функции yyerror анализатор bison може произвести
восстановление после ошибки и продолжить разбор, если грамматика содержит
подходящее правило ошибки (см. раздел 7. восстановление после ошибок). в противном
случае yyparse вернёт ненулевое значение. в этом примере мы не писали
никаких правил ошибки, поэтому любой неправильный входной текст приведёт
к завершению работы калькулятора. это поведение неудачно для настоящего
калькулятора, но вполне подходит для первого примера.
перед запуском bison для создания анализатора нам нужно решить, хранить
весь исходный код в одном или нескольких файлах. для такого простого примера
проще всего будет поместить всё в один файл. определение yylex,
yyerror и main находятся в конце файла, в секции
"дополнительного кода на c" (см. раздел 2.8 обзор схемы грамматики bison).
в больших проектах, скорее всего, у вас будет несколько файлов с исходным
кодом, и вы будет использовать make для их перекомпиляции.
если весь исходный код находится в одном файле, используйте следующую
команду для преобразования его в файл анализатора:
bison имя_файла.y
в этом примере файл называется `rpcalc.y' ("reverse polish calculator"
-- калькулятор обратной польской нотации). bison создаёт файл
`имя_файла.tab.c', убирая `.y' из названия исходного файла.
выходной файл bison содержит исходный код yyparse. дополнительные
функции (yylex, yyerror и main) в точности копируются
из входного файла в выходной.
так нужно компилировать и запускать файл анализатора:
# перечислить файлы в текущем каталоге.
$ ls
rpcalc.tab.c rpcalc.y
# компиляция анализатора bison.
# `-lm' указывает компилятору искать pow в
# математической библиотеке.
$ cc rpcalc.tab.c -lm -o rpcalc
# снова перечислить файлы.
$ ls
rpcalc rpcalc.tab.c rpcalc.y
файл `rpcalc' теперь содержит исполняемый код. вот пример сеанса
работы с rpcalc.
$ rpcalc
4 9 +
13
3 7 + 3 4 5 *+-
-13
3 7 + 3 4 5 * + - n обратите внимание на унарный минус
`n'
13
5 6 / 4 n +
-3.166666667
3 4 ^ возведение в степень
81
^d признак конца файла
$
теперь мы модифицируем rpcalc для обработки инфиксных, а не постфиксных
операций. инфиксная нотация предполагает принцип приоритета операций и
необходимость обработки скобок произвольной глубины вложенности. вот код
bison файла `calc.y' -- инфиксного настольного калькулятора.
/* калькулятор для выражени в инфиксной нотации -- calc */
%{
#define yystype double
#include <math.h>
%}
/* объявления bison */
%token num
%left '-' '+'
%left '*' '/'
%left neg /* обращение -- унарный минус */
%right '^' /* возведение в степень */
/* далее следует грамматика */
%%
input: /* пустая строка */
| input line
;
line: '\n'
| exp '\n' { printf ("\t%.10g\n", $1); }
;
exp: num { $$ = $1; }
| exp '+' exp { $$ = $1 + $3; }
| exp '-' exp { $$ = $1 - $3; }
| exp '*' exp { $$ = $1 * $3; }
| exp '/' exp { $$ = $1 / $3; }
| '-' exp %prec neg { $$ = -$2; }
| exp '^' exp { $$ = pow ($1, $3); }
| '(' exp ')' { $$ = $2; }
;
%%
функции yylex, yyerror и main могут быь теми же,
что и раньше.
в этом коде показаны две новые важные возможности.
во второй секции (объявления bison) %left объявляет типы лексем
и говорит, что они обозначают левоассоциативные операции. объявления
%left и %right (правая ассоциативность) используются вместо
%token, использующегося для объявления имени типа лексемы без
ассоциативности (эти лексемы являются однолитерными константами, которые
обычно не требуют объявления. мы объявляем их здесь для указания
ассоциативности).
приоритет операций определяется порядком строк с объявлениями -- чем больше
номер строки (чем ниже она на странице или на экране), тем выше приоритет.
отсюда, возведение в степень имеет наивысший приоритет, далее идут унарный
минус (neg), `*' и `/' и т.д. см. раздел 6.3 приоритет операций.
другая новая возможность -- %prec в секции грамматики для операции
унарного минуса. %prec просто указывает bison, что правило
`| '-' exp' имеет тот же приоритет, что и neg -- в данном случае
следующий за наивысшим. см. раздел 6.4 контекстно-зависимый приоритет.
вот пример работы с `calc.y':
$ calc
4 + 4.5 - (34/(8*3+-3))
6.880952381
-56 + 2
-54
3 ^ 2
9
до сих пор это руководство не касалось вопроса восстановления после
ошибок -- как продолжить разбор после того, как анализатор обнаружил
синтаксическую ошибку. всё, что мы предпринимали -- это выдача сообщения
об ошибке функцией yyerror. вспомним, что по умолчанию после вызова
yyerror yyparse завершает работу. это значит, что неправильный
ввод приведёт к завершению работы калькулятора. сейчас мы покажем, как
исправить этот недостаток.
язык bison содержит зарезервированное слово error, которое можно
включить в правило грамматики. в следующем примере оно добавлено к одной
из альтернатив line:
line: '\n'
| exp '\n' { printf ("\t%.10g\n", $1); }
| error '\n' { yyerrok; }
;
это добавление к грамматике допускает простое восстановление после
ошибок в случае ошибки разбора. если читается выражение, которое не может
быть вычислено, третьим правилом для line будет распознана ошибка, и
разбор продолжится (однако функция yyerror по-прежнему используется
для вывода сообщения). действие выполняет оператор yyerrok,
автоматически определяемый bison макрос. он означает, что восстановление после
ошибки завершено (см. раздел 7. восстановление после ошибок). обратите внимания на
различие между yyerrok и yyerror -- ни то, ни другое не
опечатка.
этот вид восстановления после ошибок работает с синтаксическими ошибками.
есть другие виды ошибок, например, деление на ноль, вызывающее сигнал
исключения, обычно являющегося фатальным. настоящая программа калькулятора
должна обрабатывать этот сигнал и использовать longjmp для возврата
в функцию main и продолжения разбора входных строк. ей следует также
отбросить остаток текущей строки входа. мы не будем далее обсуждать этот
вопрос, потому что он не характерен для программ bison.
этот пример расширяет калькулятор инфиксной нотации отслеживанием положений.
это свойство будет использоваться для улучшения сообщений об ошибках. для
большей ясности этот пример -- простой целочисленный калькулятор, поскольку
большая часть изменений, необходимых для использования положений, будет
сделана в лексическом анализаторе.
объявления c и bison для калькулятора с отслеживанием положение те же самые,
что и для калькулятора инфиксной нотации.
/* калькулятор с отслеживанием положений. */
%{
#define yystype int
#include <math.h>
%}
/* объявления bison. */
%token num
%left '-' '+'
%left '*' '/'
%left neg
%right '^'
%% /* далее следует грамматика */
заметьте, что специальных объявлений для работы с положениями нет. определять
тип данных для сохранения положений не нужно, мы будем использовать тип,
заданный по умолчанию (см. раздел 4.6.1 тип данных положений),
являющийся структурой с четырьмя следующими целочисленными полями:
first_line, first_column, last_line и last_column.
обрабатываются положения или нет, не влияет на синтаксис вашего языка.
поэтому правила грамматики языка в этом примере будут очень похожи на
правила в предыдущем примере, мы только модифицируем их для работы с
новой информацией.
в этом примере мы будем использовать положения для сообщения о делении
на ноль, и определения места неправильных выражений и подвыражений.
input : /* пусто */
| input line
;
line : '\n'
| exp '\n' { printf ("%d\n", $1); }
;
exp : num { $$ = $1; }
| exp '+' exp { $$ = $1 + $3; }
| exp '-' exp { $$ = $1 - $3; }
| exp '*' exp { $$ = $1 * $3; }
| exp '/' exp
{
if ($3)
$$ = $1 / $3;
else
{
$$ = 1;
fprintf (stderr, "%d.%d-%d.%d: деление на ноль",
@3.first_line, @3.first_column,
@3.last_line, @3.last_column);
}
}
| '-' exp %preс neg { $$ = -$2; }
| exp '^' exp { $$ = pow ($1, $3); }
| '(' exp ')' { $$ = $2; }
этот код показывает, как получать значения положений изнутри семантических
действий, используя псевдопеременные @n для компонентов правила
и @$ -- для групп.
нам не нужно присваивать значение @$, создаваемый анализатор делает
это автоматически. по умолчанию перед выполнением кода на c для каждого
действия @$ правила с n компонентами сопоставляется интервал
от начала @1 до конца @n. это поведение может быть
переопределено (см. раздел 4.6.3 действие по умолчанию для положений), а для очень специфических правил @$ может
вычисляться вручную.
до сих пор для отслеживания положений мы полагались на значения bison по
умолчанию. следующим шагом мы перепишем лексический анализатор и сделаем
его способным передавать в анализатор положения лексем, как он уже делает это
с их семантическими значениями.
для этой цели мы должны принимать в расчёт каждую литеру входного текста,
чтобы избежать того, что вычисленные положения будут неверными.
int
yylex (void)
{
int c;
/* пропустить промежутки */
while ((c = getchar ()) == ' ' || c == '\t')
++yylloc.last_column;
/* шаг */
yylloc.first_line = yylloc.last_line;
yylloc.first_column = yylloc.last_column;
/* обработка чисел */
if (isdigit (c))
{
yylval = c - '0';
++yylloc.last_column;
while (isdigit (c = getchar ()))
{
++yylloc.last_column;
yylval = yylval * 10 + c - '0';
}
ungetc (c, stdin);
return num;
}
/* вернуть конец файла */
if (c == eof)
return 0;
/* вернуть однц литеру и обновить положение */
if (c == '\n')
{
++yylloc.last_line;
yylloc.last_column = 0;
}
else
++yylloc.last_column;
return c;
}
в основном, лексический анализатор делает то же, что и раньше: пропускает
пробелы и знаки табуляции и читает числа или однолитерные лексемы.
дополнительно он обновляет yylloc, глобальную переменную (типа
yyltype), содержащую положение лексемы.
теперь, каждый раз, когда функция возвращет лексему, в распоряжении
анализатора находятся как её номер, так и семантическое значение и положение
в тексте. последнее необходимое изменение -- инициализация yylloc,
например, в управляющей функции.
int
main (void)
{
yylloc.first_line = yylloc.last_line = 1;
yylloc.first_column = yylloc.last_column = 0;
return yyparse ();
}
помните, что вычисление положений не касается синтаксиса. каждая литера
должна быть ассоциирована с обновлением информации о положении, независимо от
того, находится ли она в правильном входном тексте, в комментариях, в строковой
константе и т.д.
теперь, когда мы уже обсудили основы bison, пришло время перейти к более
сложной задаче. приведённые выше калькуляторы поддерживали только пять
функций: `+', `-', `*', `/' и `^'. было бы приятно
иметь калькулятор, предоставляющий другие математические функции, такие как
sin, cos и т.д.
добавить новые операции в инфиксный калькулятор, до тех пор, пока они
обозначаются односимвольными константами, несложно. лексический анализатор
yylex возвращает все нечисловые литеры как лексемы, так что для
добавления операции достаточно введения нового правила грамматики. но мы
хотим иметь нечто более гибкое, встроенные функции, синтаксис которых
выглядит так:
имя_функции (аргумент)
в то же время, мы добавим в калькулятор память, допуская создание
именованных переменных, сохранение в них значений и последующее использование.
вот пример сеанса работы многофункционального калькулятора:
$ mfcalc
pi = 3.141592653589
3.1415926536
sin(pi)
0.0000000000
alpha = beta1 = 2.3
2.3000000000
alpha
2.3000000000
ln(alpha)
0.8329091229
exp(ln(beta1))
2.3000000000
$
обратите внимание, что допускаются множественное присваивание и
вложенные вызовы функций.
вот объявления c и bison для многофункционального калькулятора.
%{
#include <math.h> /* математические функции: cos(), sin() и т.д. */
#include "calc.h" /* содержит определение `symrec' */
%}
%union {
double val; /* чтобы возвращать числа. */
symrec *tptr; /* чтобы возвращать указатели таблицы символов */
}
%token <val> num /* простое число двойной точности */
%token <tptr> var fnct /* переменная и функция */
%type <val> exp
%right '='
%left '-' '+'
%left '*' '/'
%left neg /* обращение -- унарный минус */
%right '^' /* возведение в степень */
/* далее следует грамматика */
%%
вышеприведённая грамматика вводит только две новые возможности языка bison.
эти возможности позволяют семантическим значениям иметь различные типы
данных (см. раздел 4.5.2 несколько типов значений).
объявление %union задаёт весь список возможных типов, это употребляется
вместо определения yystype. допустимые типы теперь: вещественные числа
двойной точности (для exp и num) и указатели на элементы
таблицы символов. см. раздел 4.7.3 набор типов значений.
поскольку значения теперь могут иметь различные типы, необходимо ассоциировать
тип с каждым символом грамматики, семантическое значение которого используется.
эти символы: num, var, fnct и exp. их объявления
дополнены информацией об их типах данных (помещённой в угловых скобках).
конструкция bison %type используется для объявления нетерминальных
символов, так же как %token используется для объявления типов лексем.
ранее мы не использовали %type, потому что нетерминальные символы обычно
неявно объявляются правилами, определяющими их. но exp должно быть
объявлено явно чтобы можно было задать тип его значения. см. раздел 4.7.4 нетерминальные символы.
вот правила грамматики многофункционального калькутора. большая их часть
напрямую скопирована из calc. введено три новых правила, использующие
var и fnct.
input: /* пусто */
| input line
;
line:
'\n'
| exp '\n' { printf ("\t%.10g\n", $1); }
| error '\n' { yyerrok; }
;
exp: num { $$ = $1; }
| var { $$ = $1->value.var; }
| var '=' exp { $$ = $3; $1->value.var = $3; }
| fnct '(' exp ')' { $$ = (*($1->value.fnctptr))($3); }
| exp '+' exp { $$ = $1 + $3; }
| exp '-' exp { $$ = $1 - $3; }
| exp '*' exp { $$ = $1 * $3; }
| exp '/' exp { $$ = $1 / $3; }
| '-' exp %prec neg { $$ = -$2; }
| exp '^' exp { $$ = pow ($1, $3); }
| '(' exp ')' { $$ = $2; }
;
/* end of grammar */
%%
многофункциональному калькулятору требуется таблица символов для отслеживания
имён и значений переменных и функций. это не влияет на правила грамматики
(за исключением действий) или объявления bison, но требует введения некоторых
дополнительных функций на c.
сама таблица символов состоит из связанного списка записей. её определение,
находящееся в заголовке `calc.h', приведено далее. оно позволяет
размещать в таблице как функции, так и переменные.
/* тип функций. */
typedef double (*func_t) (double);
/* тип данных для связей в цепочке символов. */
struct symrec
{
char *name; /* имя символа */
int type; /* тип символа: либо var, либо fnct */
union
{
double var; /* значение var */
func_t fnctptr; /* значение fnct */
} value;
struct symrec *next; /* поле связи */
};
typedef struct symrec symrec;
/* таблица символов: цепочка `struct symrec'. */
extern symrec *sym_table;
symrec *putsym (const char *, func_t);
symrec *getsym (const char *);
новая версия main включает вызов init_table, функции,
инициализирующей таблицу символов. вот текст этих двух функций
#include <stdio.h>
int
main (void)
{
init_table ();
return yyparse ();
}
void
yyerror (const char *s) /* вызывается yyparse в случае ошибки */
{
printf ("%s\n", s);
}
struct init
{
char *fname;
double (*fnct)(double);
};
struct init arith_fncts[] =
{
"sin", sin,
"cos", cos,
"atan", atan,
"ln", log,
"exp", exp,
"sqrt", sqrt,
0, 0
};
/* таблица символов: цепочка `struct symrec'. */
symrec *sym_table = (symrec *) 0;
/* поместить арифметические функции в таблицу. */
void
init_table (void)
{
int i;
symrec *ptr;
for (i = 0; arith_fncts[i].fname != 0; i++)
{
ptr = putsym (arith_fncts[i].fname, fnct);
ptr->value.fnctptr = arith_fncts[i].fnct;
}
}
вы можете добавить к калькулятору дополнительные функции, просто редактируя
список инициализации и включая необходимые файлы заголовков.
две важные функции позволяют просматривать символы в таблице и вводить новые.
функции putsym передаётся имя и тип (var или fnct)
заносимого объекта. объект включается в начало списка, и возвращается
указатель на объект. функции getsym передаётся имя искомого символа.
если он найден, возвращается указатель на него, иначе же ноль.
symrec *
putsym (char *sym_name, int sym_type)
{
symrec *ptr;
ptr = (symrec *) malloc (sizeof (symrec));
ptr->name = (char *) malloc (strlen (sym_name) + 1);
strcpy (ptr->name,sym_name);
ptr->type = sym_type;
ptr->value.var = 0; /* set value to 0 even if fctn. */
ptr->next = (struct symrec *)sym_table;
sym_table = ptr;
return ptr;
}
symrec *
getsym (const char *sym_name)
{
symrec *ptr;
for (ptr = sym_table; ptr != (symrec *) 0;
ptr = (symrec *)ptr->next)
if (strcmp (ptr->name,sym_name) == 0)
return ptr;
return 0;
}
функция yylex теперь должна распознавать переменные, числовые значения
и односимвольные арифметические операции. строки алфавитноцифровых литер,
начинающиеся не с цифры, распознаются или как переменные, или как функции, в
зависимости от того, что говорится о них в таблице символов.
строка передаётся функции getsym для поиска в таблице символов. если
имя встречается в таблице, в yyparse возвращаются указатель на его
положение и его тип (var или fnct). если в таблице его ещё нет,
оно заносится как var, используя putsym. опять же, указатель и
тип (который должен быть var) возвращаются в yyparse.
для обработки числовых значений и арифметических операций изменения в
yylex не нужны.
#include <ctype.h>
int
yylex (void)
{
int c;
/* игнорировать промежутки, получить первый непробельный символ. */
while ((c = getchar ()) == ' ' || c == '\t');
if (c == eof)
return 0;
/* с литеры начинается число => разобрать число. */
if (c == '.' || isdigit (c))
{
ungetc (c, stdin);
scanf ("%lf", &yylval.val);
return num;
}
/* с литеры начинается идентификатор => читать имя. */
if (isalpha (c))
{
symrec *s;
static char *symbuf = 0;
static int length = 0;
int i;
/* первоначально сделать буфер достаточно большим
для имени символа из 40 литер. */
if (length == 0)
length = 40, symbuf = (char *)malloc (length + 1);
i = 0;
do
{
/* если буфер полон, расширить его. */
if (i == length)
{
length *= 2;
symbuf = (char *)realloc (symbuf, length + 1);
}
/* добавить эту литеру в буфер. */
symbuf[i++] = c;
/* получить следующую литеру. */
c = getchar ();
}
while (c != eof && isalnum (c));
ungetc (c, stdin);
symbuf[i] = '\0';
s = getsym (symbuf);
if (s == 0)
s = putsym (symbuf, var);
yylval.tptr = s;
return s->type;
}
/* любая другая литера сама по себе является лексемой. */
return c;
}
эта программа одновременно и достаточно мощна, и гибка. вы можете легко
добавлять новые функции и также несложно модифицировать код для введения
предопределённых переменных, таких как pi и e.
-
добавьте несколько новых функций из `math.h' в список инициализации.
-
добавьте ещё один массив, содержащий константы и их значения. потом
модифицируйте
init_table чтобы внести эти константы в таблицу
символов. проще всего будет придать константам тип var.
-
заставьте программу выводить сообщение об ошибке, если пользователь
ссылается на неинициализированную переменную каким-либо образом, кроме
присвоения ей значения.
[содержание] [назад] [пред] [вверх] [след] [вперед]
| 