8. обработка контекстных зависимостей

основной принцип bison в том, чтобы сначала разбираются лексемы, а затем они группируются в более крупные синтаксические единицы. во многих языках значение лексемы зависит от её контекста. хотя это и нарушает принципы bison, существуют определённые приёмы (известные как кладжи), которые дают вам возможность писать анализаторы bison для таких языков.

(на самом деле, "кладж" -- это всякий приём, который решает поставленную задачу, но не является ни чистым, ни надёжным.)

8.1 семантическая информация в типах лексем

язык c содержит контекстную зависимость -- способ использования идентификаторов зависит от его текущего смысла. например, рассмотрим:

foo (x);

это выглядит как оператор вызова функции, но если foo -- имя определения типа, то на самом деле это объявление x. как анализатор bison для c может решить, как разбирать такой входной текст?

в gnu c используется метод, состоящий в том, чтобы иметь два разных типа лексем: identifier и typename. когда yylex обнаруживает идентификатор, она ищёт текущее объявление идентификтора чтобы решить, какой тип лексемы возвращать: typename, если идентификатор объявлен как определение типа, и identifier в противном случае.

правила грамматики могут затем выражать контекстную зависимость выбором типа лексемы при распознавании. identifier допустима в выражении, а typename -- нет. объявление может начинаться с typename, но не с identifier. в контекстах, где смысл идентификатора не имеет значения, таких как в объявлениях, которые могут затенять имя определения типа, принимаются как typename, так и identifier -- для каждого из двух типов лексем есть своё правило.

этот приём просто использовать, если решение, какой тип идентификаторов допустим, принимается в месте, близком к тому, где разбирается этот идентификатор. но в c это не всегда так: c допускает, чтобы объявление переопределяло имя определения типа, при условии, что явный тип был задан ранее:

typedef int foo, bar, lose;
static foo (bar);        /* переопределить bar
                               как статическую переменную */
static int foo (lose);   /* переопределить foo
                               как функцию */

к сожалению, объявляемое имя отделено от самой объявляющей конструкции сложной синтаксической структурой -- "объявлятелем".

в результате часть анализатора bison для c должна быть продублирована с изменением имён всех нетерминалов: одно для разбора объявления, в котором имя определения типа может быть переопределено, и другое для разбора объявлений, в которых это невозможно. приведём часть такого дублирования, действия в котором опущены для краткости:

initdcl:
          declarator maybeasm '='
          init
        | declarator maybeasm
        ;

notype_initdcl:
          notype_declarator maybeasm '='
          init
        | notype_declarator maybeasm
        ;

здесь initdcl может переопределить имя определения типа, а notype_initdcl -- нет. та же разница между declarator и notype_declarator.

есть нечто общее между этим приёмом и лексической увязкой (описанной ниже), в том, что информация, изменяющая ход лексического анализа, изменяется во время разбора другим частями программы. различие в том, что здесь эта информация глобальна, и используется в программе для других целей. истинная лексическая увязка имеет флаг специального назначения, управляемый синтаксическим контекстом.

8.2 лексическая увязка

одним из способов обработки контекстной зависимости является лексическая увязка -- флаг, устанавливаемый действиями bison, предназначенный для изменения способа разбора лексем.

например, предположим, что у нас есть язык, смутно похожий на c, но со специальной конструкцией `hex (шестнадцатеричное_выражение)'. после ключевого слова hex идёт выражение в скобках, в котором все целые числа записаны в шестнадцатеричной системе счисления. в частности, при появлении в этом контекта лексема `a1b' должна рассматриваться как целое, а не как идентификатор. вот как вы можете это сделать:

%{
int hexflag;
%}
%%
...
expr:   identifier
        | constant
        | hex '('
                { hexflag = 1; }
          expr ')'
                { hexflag = 0;
                   $$ = $4; }
        | expr '+' expr
                { $$ = make_sum ($1, $3); }
        ...
        ;

constant:
          integer
        | string
        ;

здесь мы полагаем, что yylex проверяет значение hexflag, когда оно ненулевое, все числа рассматриваются как шестнадцатеричные, и лексемы, начинающиеся в букв, разбираются как целые, если это возможно.

объявление hexflag, показанное в секции объявлений c файла анализатора, необходимо чтобы оно было доступно для действий (см. раздел 4.1.1 секция объявлений c). вы также должны написать код yylex так, чтобы анализ подчинялся этому флагу.

8.3 лексическая увязка и восстановление после ошибок

лексическая увязка предъявляет строгие требования ко всем имеющимся у вас правилам восстановления после ошибок. см. раздел 7. восстановление после ошибок.

причина этого в том, что целью правил восстановления после ошибок является прервать анализ одной конструкии и возобновить анализ более крупных конструкций. например, в языках типа c типичное правило восстановления после ошибки пропускает лексемы до следующей точки с запятой, и затем начинает разбор нового оператора, как здесь:

stmt:   expr ';'
        | if '(' expr ')' stmt { ... }
        ...
        error ';'
                { hexflag = 0; }
        ;

если внутри конструкции `hex (выражение)' есть синтаксическая ошибка, будет применено это правило обработки ошибок, и тогда действия для законченного `hex (выражение)' никогда не будут выполнены. поэтому hexflag останется установленным для всего остального входного текста или до следующего ключевого слова hex, в результате чего идентификаторы будут ошибочно интерпретироваться как целые числа.

чтобы избежать этой проблемы, правило восстановления после ошибки само сбрасывает hexflag.

также могут существовать правила восстановления после ошибок, работающие внутри выражений. например, может быть правило, применяющееся внутри скобок и пропускающее всё до закрывающей скобки:

expr:   ...
        | '(' expr ')'
                { $$ = $2; }
        | '(' error ')'
        ...

если это правило действует внутри конструкции hex, оно не приводит к выходу из этой конструкии (поскольку оно применяется к самому внутреннем уровню скобок внутри конструкции). поэтому не нужно очищать флаг, оставшаяся часть конструкции hex должна быть разобрана пока флаг всё ещё действует.

что если существует правило восстановления после ошибок, которое может прервать или не прерывать разбор конструкции hex, в зависимости от обстоятельств? способа написать правило, определяющее, был ли прерван разбор конструкции hex, нет. поэтому, если вы используете лексиечскую увязку, лучше быть уверенным в том, что ваши правила восстановления после ошибок не таковы. каждое правило должно быть таким, что вы можете быть уверены в том, что оно всегда будет или никогда не будет сбрасывать флаг.