Лекции по конструированию компиляторов - Глава 2. Лексический анализ

Основная задача  лексического анализа - разбить входной текст,
состоящий  из   последовательности  одиночных   символов,   на
последовательность слов,  или лексем,  т.е. выделить эти слова
из  непрерывной   последовательности  символов.   Все  символы
входной последовательности  с этой точки зрения разделяются на
символы,  принадлежащие   каким-либо  лексемам,   и   символы,
разделяющие лексемы  (разделители). В  некоторых случаях между
лексемами может  и не  быть разделителей.  С другой стороны, в
некоторых языках  лексемы могут  содержать незначащие  символы
(пробел в  Фортране). В  Си разделительное  значение символов-
разделителей может  блокироваться ('\'  в конце  строки внутри
"...").
Обычно  все  лексемы  делятся  на  классы.  Примерами  таких
классов     являются      числа     (целые,      восьмеричные,
шестнадцатиричные,  действительные  и  т.д.),  идентификаторы,
строки.  Отдельно   выделяются  ключевые   слова   и   символы
пунктуации  (иногда  их  называют  символы-ограничители).  Как
правило, ключевые  слова - это некоторое конечное подмножество
идентификаторов. В  некоторых языках  (например,  ПЛ/1)  смысл
лексемы может  зависеть от  ее контекста и невозможно провести
лексический анализ в отрыве от синтаксического.
С точки зрения дальнейших фаз анализа лексический анализатор
выдает   информацию    двух   сортов:    для   синтаксического
анализатора, работающего  вслед  за  лексическим,  существенна
информация о  последовательности классов лексем, ограничителей
и ключевых  слов, а для контексного анализа, работающего вслед
за синтаксическим,  важна информация  о  конкретных  значениях
отдельных лексем  (идентификаторов,  чисел  и  т.д.).  Поэтому
общая схема  работы лексического  анализатора такова.  Сначала
выделяем  отдельную   лексему  (возможно,  используя  символы-
разделители). Если  выделенная лексема  - ограничитель,  то он
(точнее,  некоторый   его  признак)   выдается  как  результат
лексического анализа.  Ключевые слова  распознаются либо явным
выделением непосредственно  из текста, либо сначала выделяется
идентификатор, а затем делается проверка на принадлежность его
множеству  ключевых   слов.  Если   да,  то  выдается  признак
соответствующего ключевого  слова, если нет - выдается признак
идентификатора, а сам идентификатор сохраняется отдельно. Если
выделенная лексема  принадлежит какому-либо  из других классов
лексем (число,  строка и  т.д.), то  выдается  признак  класса
лексемы, а значение лексемы сохраняется.
Лексический    анализатор    может    работать    или    как
самостоятельная  фаза   трансляции,  или   как   подпрограмма,
работающая по  принципу "дай  лексему". В  первом случае (рис.
2.1) выходом лексического анализатора является файл лексем, во
втором (рис.  2.2) лексема  выдается при  каждом  обращении  к
лексическому анализатору  (при этом,  как правило, тип лексемы
возвращается как  значение функции "лексический анализатор", а
значение передается  через  глобальную  переменную).  С  точки
зрения формирования  значений  лексем,  принадлежащих  классам
лексем, лексический  анализатор  может  либо  просто  выдавать
значение каждой  лексемы и  в этом  случае  построение  таблиц
переносится   на   более   поздние   фазы,   либо   он   может
самостоятельно  строить   таблицы  объектов  (идентификаторов,
строк, чисел  и т.д.).  В  этом  случае  в  качестве  значения
лексемы выдается указатель на вход в соответствующую таблицу.

                             +------------------+
                             | Синт. анализатор || Таблица |  | Лекс. анализатор |------+
                +---------+  +------------------+
    Файл лексем                  "Дай лексему"

      Рис. 2.1                     Рис. 2.2

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

2.1. Регулярные множества и регулярные выражения

Пусть T  - конечный алфавит. Регулярное множество в алфавите T
определяется рекурсивно  следующим образом  (знаком '|| 3 ||
       |       /---\                +-----+
       +------   |. \ E
                 v   --------------------+
               +---+                     |
               | 4 |                     |
               +---+                     |
                 | Цифра                 |
       +-------  v                       |
       |       \--- Не цифра,Е   +-----+ |
       | Цифра | 5 |------------>|| 6 || |
       |       /---              +-----+ |
       +-------  |E                      |
                 v                       |
               +---+                     |
               | 7 ||| 10 ||
       |       /---           +------+
       +-------

                   Рис. 2.4

Такт  автомата   M  представляется   бинарным  отношением  |-,
определенным на  конфигурациях: отношение  имеет  место,  если
есть переход  из конфигурации  (q1,w1) в конфигурацию (q2,w2).
Отношения |-+  и |-*  - это,  соответственно,  транзитивное  и
рефлексивно-транзитивное замыкание  отношения |-. Говорят, что
автомат  M   допускает  цепочку  w,  если  (q0,w)|-*(q,e)  для
некоторого   qp.  На диаграмме выделяются
конечные состояния (в примерах выше двойным контуром).

Пример 2.2.  Диаграмма для  чисел языка  Паскаль приведена  на
рис. 2.4.

2.3. Построение детерминированного конечного автомата по
       регулярному выражению.

  Приведем  теперь   алгоритм  построения   детерминированного
конечного автомата по регулярному выражению [1]. К регулярному
выражению (сокращенно  РВ) r добавим маркер конца: (r)#. После
построения ДКА  для расширенного  РВ легко  построить ДКА  для
исходного РВ:  все состояния  ДКА из  которых есть  переход  в
конечное с  чтением символа  "#", можно  считать конечными,  а
символ "#" и соответствующие переходы удалить.
Представим РВ  в виде дерева, листья которого - терминальные
символы, а  внутренние вершины  - операции "." (конкатенации),
"U" (объединение), "*" (итерация).
Каждому листу  дерева (кроме  e-листьев) припишем уникальный
номер и  ссылаться на  него будем,  с одной  стороны,  как  на
позицию в  дереве и, с другой стороны, как на позицию символа,
соответствующего листу.
  Теперь, обходя  дерево T сверху-вниз слева-направо, вычислим
четыре  функции:  nullable,  firstpos,  lastpos  и  followpos.
Функции nullable,  firstpos  и  lastpos  определены  на  узлах
дерева, а  followpos -  на множестве  позиций. Значением  всех
функций, кроме  nullable, является  множество позиций. Функция
followpos вычисляется через три остальные функции.
Функция  firstpos(n)  для  каждого  узла  n  синтаксического
дерева регулярного  выражения дает  множество позиций, которые
соответствуют  первым  символам  в  подцепочках,  генерируемых
подвыражением с  вершиной в  n.  Аналогично,  lastpos(n)  дает
множество позиций,  которым соответствуют  последние символы в
подцепочках, генерируемых  подвыражениями с  вершиной  n.  Для
узлов n,  поддеревья которых  (т.е. дерево,  у которого узел n
является  корнем)   могут  породить  пустое  слово,  определим
nullable(n)=true, а для остальных узлов false.

 узел n      nullable(n)     firstpos(n)    lastpos(n)
---------------------------------------------------------
лист е  |   true      |       0          |     0
--------+-------------+------------------+--------------
лист i  |   false     |      {i}         |    {i}
--------+-------------+------------------+--------------
   U    | nullable(a) |   firstpos(a)    | lastpos(a)
 /   \  |    or       |    U             |    U
a     b | nullable(b) |   firstpos(b)    | lastpos(b)
--------+-------------+------------------+--------------
   .    | nullable(a) | if nullable(a)   |if nullable(b)
 /   \  |   and       | then firstpos(a) |then lastpos(a)
        |             |    U firstpos(b) |  U lastpos(b)
 a   b  | nullable(b) | else firstpos(a) |else lastpos(b)
--------+-------------+------------------+--------------
   *    |             |                  |
   |    |    true     |   firstpos(a)    |  lastpos(a)
   a    |             |                  |
--------------------------------------------------------

                           Рис. 2.5

Таблица для вычисления функций nullable и firstpos приведена
на рис. 2.5. Вычисление функции lastpos строится аналогично.

                    {1,2,3}.{6}
                         /   \
                {1,2,3}.{5} {6}#{6}
                     /   \            позиция |   followpos
            {1,2,3}.{4} {5}b{5}       --------+-------------
                 /   \                   1    |    {1,2,3}
        {1,2,3}.{3} {4}b{4}              2    |    {1,2,3}
            /    \                       3    |      {4}
    {1,2}*{1,2}  {3}a{3}                 4    |      {5}
         |                               5    |      {6}
    {1,2}U{1,2}                          6    |       -
       /   \                          ----------------------
  {1}a{1} {2}b{2}
                    Рис. 2.6              Рис. 2.7

Пример 2.3. Функции firstpos и lastpos для выражения (a+b)abb#
приведены на  рис.  2.6.  Слева  от  каждой  вершины  значение
firstpos, справа  - lastpos.  Заметим, что  эти функции  могут
быть вычислены за один обход дерева.
Если i  - позиция,  то followpos(i)  есть множество  позиций j
таких, что  существует некоторая  строка ...cd...,  входящая в
язык, описываемый  РВ, такая,  что  i  -  соответствует  этому
вхождению c, а j - вхождению d.
Функция followpos  может быть  вычислена также за один обход
дерева по следующим двум правилам

  1. Пусть n - внутренний узел с операцией "." (конкатенация),
a,b -  его потомки.  Тогда для  каждой позиции  i, входящей  в
lastpos(a),  добавляем   к  множеству   значений  followpos(i)
множество firstpos(b).

  2. Пусть n - внутренний узел с операцией "*" (итерация), a -
его  потомок.   Тогда  для   каждой  позиции   i,  входящей  в
lastpos(a),  добавляем   к  множеству   значений  followpos(i)
множество firstpos(а).

  Для примера 2.3 значения функции followpos приведены на рис.
2.7.
  Функция   followpos    позволит   теперь   сразу   построить
детерминированный  конечный   автомат  с   помощью  следующего
алгоритма.

Алгоритм 2.1. Прямое построение ДКА по регулярному выражению.

Будем строить  множество состояний автомата Dstates и помечать
их. Состояния  ДКА соответствуют множествам позиций. Начальным
состоянием будет  состояние firstpos(root), где root - вершина
синтаксического дерева  регулярного выражения, конечными - все
состояния, содержащие позиции, связанные с символом "#".
Сначала в Dstates имеется только одно непомеченное состояние
firstpos(root).

   while есть непомеченное состояние T в Dstates do
      пометить T;
      for каждого входного символа aSb |                   {1,2,3}    {4}  {5}
||{pb}|+----+| |----|
|+----+|a   || |    |    a: {1,2,3,4}  T={1(a),2(b),3(a),5(b)}
|      |----++-+>Sa |    b: {1,2,3,6}     /    /    |    |
|      |{pa}|| |    |                    v    v     v    v
|      +----+| |    |                   {1,2,3}    {4}  {6}
+------------+ +----+
                         a: {1,2,3,4}  T={1(a),2(b),3(a),6(#)}
                         b: {1,2,3}       /    /    |
                                         v    v     v
                                        {1,2,3}    {4}

      Рис. 2.8                        Рис. 2.9

         +--------------------b--------------------+
         |           +-----------a--------------+  |
     +-+ |       +-+ | +----a-----+             |  |
     |b| |       |a| | |          |             |  |
     V | V   a   V | V V   b      |       b     |  |
---->{1,2,3}--->{1,2,3,4}----->{1,2,3,5}----->[1,2,3,6]

                        Рис. 2.10

2.4. Построение детерминированного конечного автомата с
       минимальным числом состояний

Рассмотрим теперь алгоритм построения ДКА с минимальным числом
состояний, эквивалентного данному ДКА [2].

Алгоритм 2.2. Построение ДКА с минимальным числом состояний.

Шаг 1.  Строим начальное  разбиение П  множества состояний  из
двух групп: заключительное состояние и остальные S-F.

Шаг 2.  Применяем к  П следующую  процедуру и  получаем  новое
разбиение Пnew (рис. 2.11):

  for каждой группы G в П do
           разбиваем G на подгруппы так, чтобы
           состояния s  и t из G оказались в одной
           группе тогда и только тогда, когда для каждого
           входного символа a состояния s и t имеют
           переходы по a  в состояния из одной и той же
           группы в П;
           заменяем G в Пnew на множество всех
           полученных подгрупп
        end;

             +---+              +-+  +-+
       +-----|s,t|-----+        |s|  |t|
       |     +---+     |        +-+  +-+
       |a             a|         |    |
       |     +---+     |         v    v
       +---->|   |='0') do
 ...
end;

Проверки  на   принадлежность  диапазону   сравнениями   можно
заменить проверками на принадлежность диапазону множества:

while (Insym in ['0'..'9']) do
 ...
end;

Однако с  точки зрения  качества кода  эти программы  примерно
эквивалентны. Программу  можно значительно  улучшить следующим
образом [2].  Пусть LETTER,  DIGIT, BLANK,  SLESS  -  элементы
перечислимого типа.  Введем массив MAP, входами которого будут
символы, значениями - типы символов. Инициализируем массив MAP
следующим образом:

      MAP['A']:=LETTER;
          ........
      MAP['z']:=LETTER;
      MAP['0']:=DIGIT;
           ........

      MAP['9']:=DIGIT
      MAP[' ']:=BLANK;
      MAP['| ключевое |
      +---+ f  +---/не буква и не цифра | слово if |
      | i |--->|   |                    +----------+
      +---\    +---\буква или цифра  +---------------+
        |  \        ---------------->| Идентификатор |
       n|   \                        +---------------+
        |    \                           ^ ^  ^
        |     \ Не f  и не t             | |  |
        v      --------------------------+ |  |
      +---+       Не t                     |  |
      |   |--------------------------------+  |
      +---+                                   |
       t|                                     |
        v                                     |
      +---+ Буква или цифра                   |
      |   |-----------------------------------+
      +---+
        | Не буква и не цифра
        v
+--------------------+
| Ключевое слово int |
+--------------------+

                         Рис. 2.12

Для этого  строится конечный  автомат,  описывающий  множество
ключевых слов. На рис. 2.12 приведен фрагмент такого автомата.
Рассмотрим пример программирования этого конечного автомата на
языке Си, приведенный в [3]:

 case 'i':
 if (cp[0]=='f' &&!(map[cp[1]] & (digit | letter)))
 {cp++; return IF;}
 if (cp[0]=='n' && cp[1]=='t'
  &&!(map[cp[2]] & (digit | letter)))
 {cp+=2; return INT;}

Здесь cp  - указатель  текущего символа.  В массиве map классы
символов кодируются битами.
Поскольку ЛА  анализирует каждый символ входного потока, его
скорость существенно  зависит от  скорости выборки  очередного
символа входного  потока. В  свою  очередь,  эта  скорость  во
многом определяется  схемой буферизации.  Рассмотрим несколько
возможных эффективных схем буферизации.
В первой схеме используется буфер, размер которого - двойная
длина блока обмена N (рис. 2.13).

   N         N
 +----------------+               +-------------------+
 |       |        |               |  # |            # |
 +----------------+               +-------------------+
          ^    ^                         ^   ^
          |    |Продвижение              |   |Продвижение
          |Начало лексемы (cp)           |Начало лексемы

       Рис. 2.13                   Рис. 2.14

Чтобы не  читать каждый  символ отдельно,  в каждую из половин
буфера одной  командой чтения  считывается N символов. Если на
входе  осталось   меньше  N   символов,  в   буфер  помещается
специальный символ  (eof). На  буфер указывают  два указателя:
продвижение и  начало. Между  указателями размещается  текущая
лексема. Вначале они оба указывают на первый символ выделяемой
лексемы. Один  из них,  продвижение, продвигается вперед, пока
не будет  выделена лексема,  и устанавливается  на  ее  конец.
После  обработки  лексемы  оба  указателя  устанавливаются  на
символ, следующий  за  лексемой.  Если  указатель  продвижение
переходит середину  буфера, правая половина заполняется новыми
N  символами.  Если  указатель  продвижение  переходит  правую
границу буфера,  левая  половина  заполняется  N  символами  и
указатель продвижение устанавливается на начало буфера.
При каждом  продвижении указателя  необходимо проверять,  не
достигли ли  мы границы  одной из  половин  буфера.  Для  всех
символов, кроме  лежащих в конце половин буфера, требуются две
проверки. Число  проверок можно  свести к  одной, если в конце
каждой половины  поместить дополнительный  'сторожевой' символ

'#' (рис. 2.14).

  В этом  случае почти для всех символов делается единственная
проверка на  совпадение с  '#' и  только в  случае  совпадения
нужно проверить, достигли ли мы середины или правого конца.
В третьей  схеме используются  три  указателя  (рис.  2.15).
Непросмотренная  часть   буфера  заключена   между  текущим  и
границей  (граница   -  это  указатель  на  последний  элемент
буфера).   Анализ    очередной   лексемы    начинается   после
сканирования незначащих  пробелов. Если  после  этого  текущий
указывает на  '#' в конце буфера, делается перезагрузка буфера
(предполагается, что  '#' не  может входить в состав лексемы).
Барьер  выбирается  таким  образом,  чтобы  между  барьером  и
границей  всегда   помещалась  любая   лексема.  Если   начало
очередной лексемы  оказывается правее барьера, то часть буфера
от текущего  до границы  переписывается левее  буфера и  буфер
перезагужается. Тем  самым начало лексемы конкатенируется с ее
концом. Так  обрабатывается  ситуация,  когда  граница  буфера
прошла через лексему.

      +----------+                   +-----+
      |     N    |                   | N   |
      v          v                   v     v
 +------------------+           +-------------+
 |    |          |\n|           |    |     | #|
 +------------------+           +-------------+
          |   |   |Граница         |      |  |Граница
          |   |Барьер              |      |Барьер
          |Текущий                 |Текущий
   а) Пока текущий "     {yylval=NE; return(RELOP);}
 ">"      {yylval=GT; return(RELOP);}
 ">="     {yylval=GE; return(RELOP);}
 %%
 install_id(){/*процедура, которая помещает лексему,
               на первый символ которой указывает yytext,
               длина которой равна yyleng, в таблицу
               символов и возвращает указатель на нее*/
            }
 install_num(){/*аналогичная процедура для размещения
                лексемы числа*/
             }
                       Рис. 2.16.

В  разделе   объявлений,  заключенном   в  скобки   %{  и  %},
перечислены константы, используемые правилами трансляции. Все,
что заключено  в  эти  скобки,  непосредственно  копируется  в
программу   лексического    анализатора    lex.yy.c    и    не
рассматривается как  часть регулярных  определений или  правил
трансляции. То  же касается и вспомогательных процедур третьей
секции. На рис. 2.16 это процедуры install_id и install_num.
В  секцию  определений  входят  также  некоторые  регулярные
определения. Каждое  такое  определение  состоит  из  имени  и
регулярного выражения,  обозначаемого этим  именем.  Например,
первое определенное  имя -  это delim.  Оно  обозначает  класс
символов  {  \t\n},  т.е.  любой  из  трех  символов:  пробел,
табуляция или  новая строка. Второе определение - разделитель,
обозначаемый   именем    ws.   Разделитель    -   это    любая
последовательность  одного  или  более  символов-разделителей.
Слово delim должно быть заключено в скобки, чтобы отличить его
от образца, состоящего из пяти символов delim.
В определении letter используется класс символов. Сокращение
[A-Za-z] означает  любую из  прописных букв  от  A  до  Z  или
строчных букв  от a  до z.  В пятом  определении  для  id  для
группировки используются скобки, являющиеся метасимволами LEX.
Аналогично, вертикальная  черта - метасимвол LEX, обозначающий
объединение.
В  последнем   регулярном  определении   number  символ  '+'
используется как метасимвол "одно или более вхождений", символ
'?' как  метасимвол "ноль  или одно вхождение". Обратная черта
используется для  того, чтобы  придать обычный  смысл символу,
использующемуся в  LEX как метасимвол. В частности, десятичная
точка в  определении number  обозначается как  '\.', поскольку
точка сама  по себе  представляет  класс,  состоящий  из  всех
символов,  за  исключением  символа  новой  строки.  В  классe
символов [+\-]  обратная черта перед минусом стоит потому, что
знак минус используется как символ диапазона, как в [A-Z].
Если символ  имеет смысл метасимвола, то придать ему обычный
свысл можно  и по-другому,  заключив его  в  кавычки.  Так,  в
секции правил  трансляции шесть операций отношения заключены в
кавычки.
Рассмотрим  правила  трансляции,  следующие  за  первым  %%.
Согласно   первому   правилу,   если   обнаружено   ws,   т.е.
максимальная последовательность  пробелов, табуляций  и  новых
строк, никаких  действий  не  производится.  В  частности,  не
осуществляется возврат в синтаксический анализатор.
Согласно второму правилу, если обнаружена последовательность
букв 'if',  нужно вернуть  значение IF, которое определено как
целая константа,  понимаемая синтаксическим  анализатором  как
лексема 'if'.  Аналогично обрабатываются ключевые слова 'then'
и 'else' в двух следущих правилах.
В действии,  связанном с  правилом для  id,  два  оператора.
Переменной   yylval   присваивается   значение,   возвращаемое
процедурой install_id.  Определение этой процедуры приведено в
разделе  3.1.   Переменная  yylval   определена  в   программе
lex.yy.c,  выходе   LEX,  и   она   доступна   синтаксическому
анализатору. yylval  хранит возвращаемое лексическое значение,
поскольку второй оператор в действии, return(ID), может только
возвратить код класса лексем.
Функция  install_id   заносит   идентификаторы   в   таблицу
символов. Текущая  лексема доступна благодаря двум указателям:
yytext и  yyleng. Переменная  yytext - это указатель на первый
символ лексемы,  yyleng -  это целое,  дающее  длину  лексемы.
Например, при  занесении идентификатора  в таблицу  могут быть
скопированы yyleng символов, начиная с yytext.
Аналогично  обрабатываются  числа  в  следующем  правиле.  В
последних шести правилах yylval используется для возврата кода
операции отношения,  возвращаемое же  функцией значение  - это
код лексемы relop.
Если, например,  в  текущий  момент  лексический  анализатор
обрабатывает лексему  'if', то  этой лексеме соответствуют два
образца: 'if'  и {id}  и более длинной строки, соответствующей
образцу, нет.  Поскольку образец 'if' предшествует образцу для
идентификатора, конфликт разрешается в пользу ключевого слова.
Такая  стратегия   разрешения   конфликтов   позволяет   легко
резервировать ключевые слова.
Если  на   входе  встречается   '

Назад |
Оглавление |
Вперед