end;
   Token := KWcode[Lookup(Addr(KWlist), Value, 4) + 1];
   end;
   {–}
   { Get a Number }
   procedure GetNum;
   begin
   Value := '';
   if not IsDigit(Look) then Expected('Integer');
   while IsDigit(Look) do begin
   Value := Value + Look;
   GetChar;
   end;
   Token := '#';
   end;
   {–}
   { Get an Operator }
   procedure GetOp;
   begin
   Value := '';
   if not IsOp(Look) then Expected('Operator');
   while IsOp(Look) do begin
   Value := Value + Look;
   GetChar;
   end;
   if Length(Value) = 1 then
   Token := Value[1]
   else
   Token := '?';
   end;
   {–}
   { Lexical Scanner }
   procedure Scan;
   var k: integer;
   begin
   while Look = CR do
   Fin;
   if IsAlpha(Look) then
   GetName
   else if IsDigit(Look) then
   GetNum
   else if IsOp(Look) then begin
   GetOp
   else begin
   Value := Look;
   Token := '?';
   GetChar;
   end;
   SkipWhite;
   end;
   {–}
   { Main Program }
   begin
   Init;
   repeat
   Scan;
   case Token of
   'x': write('Ident ');
   '#': Write('Number ');
   'i', 'l', 'e': Write('Keyword ');
   else Write('Operator ');
   end;
   Writeln(Value);
   until Value = 'END';
   end.
   {–}
   Эта программа должна работать также как и предыдущая версия. Небольшое различие в структуре, может быть, но она кажется мне более простой.

Распределенные сканеры против централизованных

   Структура лексического анализатора, которую я только что вам показал, весьма стандартна и примерно 99% всех компиляторов используют что-то очень близкое к ней. Это, однако, не единственно возможная структура, или даже не всегда самая лучшая.
   Проблема со стандартным подходом состоит в том, что сканер не имеет никаких сведений о контексте. Например, он не может различить оператор присваивания "=" и оператор отношения "=" (возможно именно поэтому и C и Паскаль используют для них различные строки). Все, что сканер может сделать, это передать оператор синтаксическому анализатору, который может точно сказать исходя из контекста, какой это оператор. Точно так же, ключевое слово «IF» не может быть посредине арифметического выражения, но если ему случится оказаться там, сканер не увидит в этом никакой проблемы и возвратит его синтаксическому анализатору, правильно закодировав как «IF».
   С таким подходом, мы в действительности не используем всю информацию, имеющуюся в нашем распоряжении. В середине выражения, например, синтаксический анализатор «знает», что нет нужды искать ключевое слово, но он не имеет никакой возможности сказать это сканеру. Так что сканер продолжает делать это. Это, конечно, замедляет компиляцию.
   В настоящих компиляторах проектировщики часто принимают меры для передачи подробной информации между сканером и парсером, только чтобы избежать такого рода проблем. Но это может быть неуклюже и, конечно, уничтожит часть модульности в структуре компилятора.
   Альтернативой является поиск какого-то способа для использования контекстной информации, которая исходит из знания того, где мы находимся в синтаксическом анализаторе. Это возвращает нас обратно к понятию распределенного сканера, в котором различные части сканера вызываются в зависимости от контекста.
   В языке KISS, как и большинстве языков, ключевые слова появляются только в начале утверждения. В таких местах, как выражения они запрещены. Также, с одним небольшим исключением (многосимвольные операторы отношений), которое легко обрабатывается, все операторы односимвольны, что означает, что нам совсем не нужен GetOp.
   Так что, оказывается, даже с многосимвольными токенами мы все еще можем всегда точно определить вид лексемы исходя из текущего предсказывающего символа, исключая самое начало утверждения.
   Даже в этой точке, единственным видом лексемы, который мы можем принять, является идентификатор. Нам необходимо только определить, является ли этот идентификатор ключевым словом или левой частью оператора присваивания.
   Тогда мы заканчиваем все еще нуждаясь только в GetName и GetNum, которые используются так же, как мы использовали их в ранних главах.
   Сначала вам может показаться, что это шаг назад и довольно примитивный способ. Фактически же, это усовершенствование классического сканера, так как мы используем подпрограммы сканирования только там, где они действительно нужны. В тех местах, где ключевые слова не разрешены, мы не замедляем компиляцию, ища их.

Объединение сканера и парсера

   Теперь, когда мы охватили всю теорию и общие аспекты лексического анализа, я наконец готов подкрепит свое заявление о том, что мы можем приспособить многосимвольные токены с минимальными изменениями в нашей предыдущей работе. Для краткости и простоты я ограничу сам себя подмножеством того, что мы сделали ранее: я разрешу только одну управляющую конструкцию (IF) и никаких булевых выражений. Этого достаточно для демонстрации синтаксического анализа и ключевых слов и выражений. Расширение до полного набора конструкций должно быть довольно очевидно из того, что мы уже сделали.
   Все элементы программы для синтаксического анализа этого подмножества с использованием односимвольных токенов уже существуют в наших предыдущих программах. Я построил ее осторожно скопировав эти файлы, но я не посмею попробовать провести вас через этот процесс. Вместо этого, во избежание беспорядка, вся программа показана ниже:
   {–}
   program KISS;
   {–}
   { Constant Declarations }
   const TAB = ^I;
   CR = ^M;
   LF = ^J;
   {–}
   { Type Declarations }
   type Symbol = string[8];
   SymTab = array[1..1000] of Symbol;
   TabPtr = ^SymTab;
   {–}
   { Variable Declarations }
   var Look : char; { Lookahead Character }
   Lcount: integer; { Label Counter }
   {–}
   { Read New Character From Input Stream }
   procedure GetChar;
   begin
   Read(Look);
   end;
   {–}
   { Report an Error }
   procedure Error(s: string);
   begin
   WriteLn;
   WriteLn(^G, 'Error: ', s, '.');
   end;
   {–}
   { Report Error and Halt }
   procedure Abort(s: string);
   begin
   Error(s);
   Halt;
   end;
   {–}
   { Report What Was Expected }
   procedure Expected(s: string);
   begin
   Abort(s + ' Expected');
   end;
   {–}
   { Recognize an Alpha Character }
   function IsAlpha(c: char): boolean;
   begin
   IsAlpha := UpCase(c) in ['A'..'Z'];
   end;
   {–}
   { Recognize a Decimal Digit }
   function IsDigit(c: char): boolean;
   begin
   IsDigit := c in ['0'..'9'];
   end;
   {–}
   { Recognize an AlphaNumeric Character }
   function IsAlNum(c: char): boolean;
   begin
   IsAlNum := IsAlpha(c) or IsDigit(c);
   end;
   {–}
   { Recognize an Addop }
   function IsAddop(c: char): boolean;
   begin
   IsAddop := c in ['+', '-'];
   end;
   {–}
   { Recognize a Mulop }
   function IsMulop(c: char): boolean;
   begin
   IsMulop := c in ['*', '/'];
   end;
   {–}
   { Recognize White Space }
   function IsWhite(c: char): boolean;
   begin
   IsWhite := c in [' ', TAB];
   end;
   {–}
   { Skip Over Leading White Space }
   procedure SkipWhite;
   begin
   while IsWhite(Look) do
   GetChar;
   end;
   {–}
   { Match a Specific Input Character }
   procedure Match(x: char);
   begin
   if Look <> x then Expected('''' + x + '''');
   GetChar;
   SkipWhite;
   end;
   {–}
   { Skip a CRLF }
   procedure Fin;
   begin
   if Look = CR then GetChar;
   if Look = LF then GetChar;
   SkipWhite;
   end;
   {–}
   { Get an Identifier }
   function GetName: char;
   begin
   while Look = CR do
   Fin;
   if not IsAlpha(Look) then Expected('Name');
   Getname := UpCase(Look);
   GetChar;
   SkipWhite;
   end;
   {–}
   { Get a Number }
   function GetNum: char;
   begin
   if not IsDigit(Look) then Expected('Integer');
   GetNum := Look;
   GetChar;
   SkipWhite;
   end;
   {–}
   { Generate a Unique Label }
   function NewLabel: string;
   var S: string;
   begin
   Str(LCount, S);
   NewLabel := 'L' + S;
   Inc(LCount);
   end;
   {–}
   { Post a Label To Output }
   procedure PostLabel(L: string);
   begin
   WriteLn(L, ':');
   end;
   {–}
   { Output a String with Tab }
   procedure Emit(s: string);
   begin
   Write(TAB, s);
   end;
   {–}
   { Output a String with Tab and CRLF }
   procedure EmitLn(s: string);
   begin
   Emit(s);
   WriteLn;
   end;
   {–}
   { Parse and Translate an Identifier }
   procedure Ident;
   var Name: char;
   begin
   Name := GetName;
   if Look = '(' then begin
   Match('(');
   Match(')');
   EmitLn('BSR ' + Name);
   end
   else
   EmitLn('MOVE ' + Name + '(PC),D0');
   end;
   {–}
   { Parse and Translate a Math Factor }
   procedure Expression; Forward;
   procedure Factor;
   begin
   if Look = '(' then begin
   Match('(');
   Expression;
   Match(')');
   end
   else if IsAlpha(Look) then
   Ident
   else
   EmitLn('MOVE #' + GetNum + ',D0');
   end;
   {–}
   { Parse and Translate the First Math Factor }
   procedure SignedFactor;
   var s: boolean;
   begin
   s := Look = '-';
   if IsAddop(Look) then begin
   GetChar;
   SkipWhite;
   end;
   Factor;
   if s then
   EmitLn('NEG D0');
   end;
   {–}
   { Recognize and Translate a Multiply }
   procedure Multiply;
   begin
   Match('*');
   Factor;
   EmitLn('MULS (SP)+,D0');
   end;
   {–}
   { Recognize and Translate a Divide }
   procedure Divide;
   begin
   Match('/');
   Factor;
   EmitLn('MOVE (SP)+,D1');
   EmitLn('EXS.L D0');
   EmitLn('DIVS D1,D0');
   end;
   {–}
   { Completion of Term Processing (called by Term and FirstTerm }
   procedure Term1;
   begin
   while IsMulop(Look) do begin
   EmitLn('MOVE D0,-(SP)');
   case Look of
   '*': Multiply;
   '/': Divide;
   end;
   end;
   end;
   {–}
   { Parse and Translate a Math Term }
   procedure Term;
   begin
   Factor;
   Term1;
   end;
   {–}
   { Parse and Translate a Math Term with Possible Leading Sign }
   procedure FirstTerm;
   begin
   SignedFactor;
   Term1;
   end;
   {–}
   { Recognize and Translate an Add }
   procedure Add;
   begin
   Match('+');
   Term;
   EmitLn('ADD (SP)+,D0');
   end;
   {–}
   { Recognize and Translate a Subtract }
   procedure Subtract;
   begin
   Match('-');
   Term;
   EmitLn('SUB (SP)+,D0');
   EmitLn('NEG D0');
   end;
   {–}
   { Parse and Translate an Expression }
   procedure Expression;
   begin
   FirstTerm;
   while IsAddop(Look) do begin
   EmitLn('MOVE D0,-(SP)');
   case Look of
   '+': Add;
   '-': Subtract;
   end;
   end;
   end;
   {–}
   { Parse and Translate a Boolean Condition }
   { This version is a dummy }
   Procedure Condition;
   begin
   EmitLn('Condition');
   end;
   {–}
   { Recognize and Translate an IF Construct }
   procedure Block;
   Forward;
   procedure DoIf;
   var L1, L2: string;
   begin
   Match('i');
   Condition;
   L1 := NewLabel;
   L2 := L1;
   EmitLn('BEQ ' + L1);
   Block;
   if Look = 'l' then begin
   Match('l');
   L2 := NewLabel;
   EmitLn('BRA ' + L2);
   PostLabel(L1);
   Block;
   end;
   PostLabel(L2);
   Match('e');
   end;
   {–}
   { Parse and Translate an Assignment Statement }
   procedure Assignment;
   var Name: char;
   begin
   Name := GetName;
   Match('=');
   Expression;
   EmitLn('LEA ' + Name + '(PC),A0');
   EmitLn('MOVE D0,(A0)');
   end;
   {–}
   { Recognize and Translate a Statement Block }
   procedure Block;
   begin
   while not(Look in ['e', 'l']) do begin
   case Look of
   'i': DoIf;
   CR: while Look = CR do
   Fin;
   else Assignment;
   end;
   end;
   end;
   {–}
   { Parse and Translate a Program }
   procedure DoProgram;
   begin
   Block;
   if Look <> 'e' then Expected('END');
   EmitLn('END')
   end;
   {–}
   { Initialize }
   procedure Init;
   begin
   LCount := 0;
   GetChar;
   end;
   {–}
   { Main Program }
   begin
   Init;
   DoProgram;
   end.
   {–}
    Пара комментариев:
   Форма синтаксического анализатора выражений, использующего FirstTerm и т.п., немного отличается от того, что вы видели ранее. Это еще одна вариация на ту же самую тему. Не позволяйте им вертеть вами... изменения необязательны для того, что будет дальше.
   Заметьте, что как обычно я добавил вызовы Fin в стратегических местах для поддержки множественных строк.
   Прежде чем приступить к добавлению сканера, сначала скопируйте этот файл и проверьте, что он действительно корректно выполняет анализ. Не забудьте «кода»: "i" для IF, "l" для ELSE и "e" для ELSE или ENDIF.
   Если программа работает, тогда давайте поспешим. При добавлении модулей сканера в программу поможет систематический план. Во всех синтаксических анализаторах, которые мы написали до этого времени, мы придерживались соглашения, что текущий предсказывающий символ должен всегда быть непустым символом. Мы предварительно загружали предсказывающий символ в Init и после этого оставляли «помпу запущенной». Чтобы позволить программе работать правильно с новыми строками мы должны ее немного модифицировать и обрабатывать символ новой строки как допустимый токен.
   В многосимвольной версии правило аналогично: текущий предсказыващий символ должен всегда оставаться на начале следующей лексемы или на новой строке.
   Многосимвольная версия показана ниже. Чтобы получить ее я сделал следующие изменения:
   • Добавлены переменные Token и Value и определения типов, необходимые для Lookup.
   • Добавлено определение KWList и KWcode.
   • Добавлен Lookup.
   • GetName и GetNum заменены их многосимвольными версиями. (Обратите внимание, что вызов Lookup был перемещен из GetName, так что он не будет выполняться внутри выражений).
   • Создана новая, рудиментарная Scan, которая вызывает GetName затем сканирует ключевые слова.
   • Создана новая процедура MatchString, которая ищет конкретное ключевое слово. Заметьте, что в отличие от Match, MatchString не считывает следующее ключевое слово.
   • Изменен Block для вызова Scan.
   • Немного изменены вызовы Fin. Fin теперь вызывается из GetName.
   Программа полностью:
   {–}
   program KISS;
   {–}
   { Constant Declarations }
   const TAB = ^I;
   CR = ^M;
   LF = ^J;
   {–}
   { Type Declarations }
   type Symbol = string[8];
   SymTab = array[1..1000] of Symbol;
   TabPtr = ^SymTab;
   {–}
   { Variable Declarations }
   var Look : char; { Lookahead Character }
   Token : char; { Encoded Token }
   Value : string[16]; { Unencoded Token }
   Lcount: integer; { Label Counter }
   {–}
   { Definition of Keywords and Token Types }
   const KWlist: array [1..4] of Symbol =
   ('IF', 'ELSE', 'ENDIF', 'END');
   const KWcode: string[5] = 'xilee';
   {–}
   { Read New Character From Input Stream }
   procedure GetChar;
   begin
   Read(Look);
   end;
   {–}
   { Report an Error }
   procedure Error(s: string);
   begin
   WriteLn;
   WriteLn(^G, 'Error: ', s, '.');
   end;
   {–}
   { Report Error and Halt }
   procedure Abort(s: string);
   begin
   Error(s);
   Halt;
   end;
   {–}
   { Report What Was Expected }
   procedure Expected(s: string);
   begin
   Abort(s + ' Expected');
   end;
   {–}
   { Recognize an Alpha Character }
   function IsAlpha(c: char): boolean;
   begin
   IsAlpha := UpCase(c) in ['A'..'Z'];
   end;
   {–}
   { Recognize a Decimal Digit }
   function IsDigit(c: char): boolean;
   begin
   IsDigit := c in ['0'..'9'];
   end;
   {–}
   { Recognize an AlphaNumeric Character }
   function IsAlNum(c: char): boolean;
   begin
   IsAlNum := IsAlpha(c) or IsDigit(c);
   end;
   {–}
   { Recognize an Addop }
   function IsAddop(c: char): boolean;
   begin
   IsAddop := c in ['+', '-'];
   end;
   {–}
   { Recognize a Mulop }
   function IsMulop(c: char): boolean;
   begin
   IsMulop := c in ['*', '/'];
   end;
   {–}
   { Recognize White Space }
   function IsWhite(c: char): boolean;
   begin
   IsWhite := c in [' ', TAB];
   end;
   {–}
   { Skip Over Leading White Space }
   procedure SkipWhite;
   begin
   while IsWhite(Look) do
   GetChar;
   end;
   {–}
   { Match a Specific Input Character }
   procedure Match(x: char);
   begin
   if Look <> x then Expected('''' + x + '''');
   GetChar;
   SkipWhite;
   end;
   {–}
   { Skip a CRLF }
   procedure Fin;
   begin
   if Look = CR then GetChar;
   if Look = LF then GetChar;
   SkipWhite;
   end;
   {–}
   { Table Lookup }
   function Lookup(T: TabPtr; s: string; n: integer): integer;
   var i: integer;
   found: boolean;
   begin
   found := false;
   i := n;
   while (i > 0) and not found do
   if s = T^[i] then
   found := true
   else
   dec(i);
   Lookup := i;
   end;
   {–}
   { Get an Identifier }
   procedure GetName;
   begin
   while Look = CR do
   Fin;
   if not IsAlpha(Look) then Expected('Name');
   Value := '';
   while IsAlNum(Look) do begin
   Value := Value + UpCase(Look);
   GetChar;
   end;
   SkipWhite;
   end;
   {–}
   { Get a Number }
   procedure GetNum;
   begin
   if not IsDigit(Look) then Expected('Integer');
   Value := '';
   while IsDigit(Look) do begin
   Value := Value + Look;
   GetChar;
   end;
   Token := '#';
   SkipWhite;
   end;
   {–}
   { Get an Identifier and Scan it for Keywords }
   procedure Scan;
   begin
   GetName;
   Token := KWcode[Lookup(Addr(KWlist), Value, 4) + 1];
   end;
   {–}
   { Match a Specific Input String }
   procedure MatchString(x: string);
   begin
   if Value <> x then Expected('''' + x + '''');
   end;
   {–}
   { Generate a Unique Label }
   function NewLabel: string;
   var S: string;
   begin
   Str(LCount, S);
   NewLabel := 'L' + S;
   Inc(LCount);
   end;
   {–}
   { Post a Label To Output }
   procedure PostLabel(L: string);
   begin
   WriteLn(L, ':');
   end;
   {–}
   { Output a String with Tab }
   procedure Emit(s: string);
   begin
   Write(TAB, s);
   end;
   {–}
   { Output a String with Tab and CRLF }
   procedure EmitLn(s: string);
   begin
   Emit(s);
   WriteLn;
   end;
   {–}
   { Parse and Translate an Identifier }
   procedure Ident;
   begin
   GetName;
   if Look = '(' then begin
   Match('(');
   Match(')');
   EmitLn('BSR ' + Value);
   end
   else
   EmitLn('MOVE ' + Value + '(PC),D0');
   end;
   {–}
   { Parse and Translate a Math Factor }
   procedure Expression; Forward;
   procedure Factor;
   begin
   if Look = '(' then begin
   Match('(');
   Expression;
   Match(')');
   end
   else if IsAlpha(Look) then
   Ident
   else begin
   GetNum;
   EmitLn('MOVE #' + Value + ',D0');
   end;
   end;
   {–}
   { Parse and Translate the First Math Factor }
   procedure SignedFactor;
   var s: boolean;
   begin
   s := Look = '-';
   if IsAddop(Look) then begin
   GetChar;
   SkipWhite;
   end;
   Factor;
   if s then
   EmitLn('NEG D0');
   end;
   {–}
   { Recognize and Translate a Multiply }
   procedure Multiply;
   begin
   Match('*');
   Factor;
   EmitLn('MULS (SP)+,D0');
   end;
   {–}
   { Recognize and Translate a Divide }
   procedure Divide;
   begin
   Match('/');
   Factor;
   EmitLn('MOVE (SP)+,D1');
   EmitLn('EXS.L D0');
   EmitLn('DIVS D1,D0');
   end;
   {–}
   { Completion of Term Processing (called by Term and FirstTerm }
   procedure Term1;
   begin
   while IsMulop(Look) do begin
   EmitLn('MOVE D0,-(SP)');
   case Look of
   '*': Multiply;
   '/': Divide;
   end;
   end;
   end;
   {–}
   { Parse and Translate a Math Term }
   procedure Term;
   begin
   Factor;
   Term1;
   end;
   {–}
   { Parse and Translate a Math Term with Possible Leading Sign }
   procedure FirstTerm;
   begin
   SignedFactor;
   Term1;
   end;
   {–}
   { Recognize and Translate an Add }
   procedure Add;
   begin
   Match('+');
   Term;
   EmitLn('ADD (SP)+,D0');
   end;
   {–}
   { Recognize and Translate a Subtract }
   procedure Subtract;
   begin
   Match('-');
   Term;
   EmitLn('SUB (SP)+,D0');
   EmitLn('NEG D0');
   end;
   {–}
   { Parse and Translate an Expression }
   procedure Expression;
   begin
   FirstTerm;
   while IsAddop(Look) do begin
   EmitLn('MOVE D0,-(SP)');
   case Look of
   '+': Add;
   '-': Subtract;
   end;
   end;
   end;
   {–}
   { Parse and Translate a Boolean Condition }
   { This version is a dummy }
   Procedure Condition;
   begin
   EmitLn('Condition');
   end;
   {–}
   { Recognize and Translate an IF Construct }
   procedure Block; Forward;
   procedure DoIf;
   var L1, L2: string;
   begin
   Condition;
   L1 := NewLabel;
   L2 := L1;
   EmitLn('BEQ ' + L1);
   Block;
   if Token = 'l' then begin
   L2 := NewLabel;
   EmitLn('BRA ' + L2);
   PostLabel(L1);
   Block;
   end;
   PostLabel(L2);
   MatchString('ENDIF');
   end;
   {–}
   { Parse and Translate an Assignment Statement }
   procedure Assignment;
   var Name: string;
   begin
   Name := Value;
   Match('=');
   Expression;
   EmitLn('LEA ' + Name + '(PC),A0');
   EmitLn('MOVE D0,(A0)');
   end;
   {–}
   { Recognize and Translate a Statement Block }
   procedure Block;
   begin
   Scan;
   while not (Token in ['e', 'l']) do begin
   case Token of
   'i': DoIf;
   else Assignment;
   end;
   Scan;
   end;
   end;
   {–}
   { Parse and Translate a Program }
   procedure DoProgram;
   begin
   Block;
   MatchString('END');
   EmitLn('END')
   end;
   {–}
   { Initialize }
   procedure Init;
   begin
   LCount := 0;
   GetChar;
   end;
   {–}
   { Main Program }
   begin
   Init;
   DoProgram;
   end.
   {–}
   Сравните эту программу с ее односимвольным вариантом. Я думаю вы согласитесь, что различия минимальны.

Заключение

   К этому времени вы узнали как анализировать и генерировать код для выражений, булевых выражений и управляющих структур. Теперь вы изучили, как разрабатывать лексические анализаторы и как встроить их элементы в транслятор. Вы все еще не видели всех элементов, объединеных в одну программу, но на основе того, что мы сделали ранее вы должны прийти к заключению, что легко расширить наши ранние программы для включения лексических анализаторов.
   Мы очень близки к получению всех элементов, необходимых для построения настоящего, функционального компилятора. Есть еще несколько отсутствующих вещей, особенно вызовы процедур и определения типов. Мы будем работать с ними на следующих нескольких уроках. Прежде чем сделать это, однако, я подумал что было бы забавно превратить транслятор в настоящий компилятор. Это то, чем мы займемся в следующей главе.
   До настоящего времени мы применяли предпочтительно восходящий метод синтаксического анализа, начиная с низкоуровневых конструкций и продвигаясь вверх. В следующей главе я также взгляну сверху вниз, и мы обсудим, как изменяется структура транслятора при изменении определения языка.
   Увидимся.

Немного философии

Введение

   Этот урок будет отличаться от других уроков в нашей серии по синтаксическому анализу и конструированию компиляторов. На этом уроке не будет никаких экспериментов или кода. На этот раз я хотел бы просто поговорить с вами некоторое время. К счастью, это будет короткий урок и затем мы сможем продолжить с того места где остановились, надо надеяться с обновленной энергией.
   Когда я учился в университете, я обнаружил, что могу всегда следить за профессорской лекцией намного лучше, если знал куда он идет. Готов поспорить, с вами было то же самое.
   Так что я подумал, может быть пришло время расказать вам куда мы идем с этой серией: что нас ждет в будущих главах и вообще что к чему. Я также поделюсь своими общими мыслями о полезности того, что мы делали.

Дорога домой

   Пока что мы охватили синтаксический анализ и трансляцию арифметических выражений, булевых выражений и их комбинаций, связанных операторами отношений. Мы также сделали то же самое для управляющих конструкций. Во всем этом мы склонялись в основном к использованию нисходящего синтаксического анализа методом рекурсивного спуска, определение синтаксиса в БНФ и непосредственной генерации ассемблерного кода. Мы также изучили значение такого приема как односимвольные токены. В последней главе мы работали с лексическим анализом и я показал вам простой но мощный способ преодоления односимвольного барьера.
   В течение всех этих исследований, я особенно выделял философию KISS... Keep It Simple, Sidney... и я надеюсь, что к настоящему времени вы поняли, насколько простыми могут в действительности быть эти вещи. Хотя наверняка имеются области в теории компиляции которые являются по настоящему пугающими, основной мыслью этой серии является то, что на практике вы можете просто вежливо обойти многие из этих областей. Если определение языка способствует этому или, как в этой серии, если вы можете определить язык по ходу дела, то возможно записать определение языка в БНФ с достаточным удобством. И, как мы видели, вы можете вывести процедуры синтаксического анализа из БНФ почти также быстро, как вы можете набирать на клавиатуре.
   По мере того, как наш компилятор принимал некоторую форму, он приобретал больше частей, но каждая часть довольно мала и проста и очень похожа на все другие.
   К этому моменту у нас есть многое из того, что составляет настоящий практический компилятор. Фактически, мы уже имеем все что нам нужно для создания игрушечного языка столь же мощного, как, скажем, Tiny Basic. В следующих двух главах мы пойдем вперед и определим этот язык.
   Для завершения этой серии, у нас все еще есть несколько тем для раскрытия. Они включают:
   • Вызовы процедур, с параметрами и без.
   • Локальные и глобальные переменные.
   • Базовые типы, такие как символьные и целочисленные типы.
   • Массивы.
   • Строки.
   • Типы и структуры, определяемые пользователем.
   • Синтаксические анализаторы с деревьями и промежуточные языки.
   • Оптимизация.
   Все это будет рассмотрено в будущих главах. Когда мы закончим, вы будете иметь все инструменты, необходимые для разработки и создания своего собственного языка и компиляторов для его трансляции.
   Я не могу спроектировать эти языки для вас, но я могу дать некоторые комментарии и рекомендации. Я уже высказал некоторые из них в прошлых главах. Вы видели, например, какие управляющие структуры я предпочитаю.
   Эти конструкции будут частью создаваемых мной языков. К этому моменту я представляю три языка, два из которых вы увидите в очередных главах:
   TINY – минимальный, но пригодный для использования язык уровня Tiny Basic или Tiny C. Он не будет очень практичным, но будет достаточно мощным, чтобы позволить вам писать и запускать настоящие программы которые делают что-нибудь заслуживающее внимание.
   KISS – язык, который я создаю для своего собственного использования. KISS предназначен быть языком системного программирования. Он не будет иметь строгого контроля типов или причудливых структур данных, но он будет поддерживать большинство вещей, которые я хочу делать с языком более высокого уровня (HOL), за исключением возможно написания компиляторов.
   Я также играл в течение нескольких лет с идеей HOL-подобного ассемблера со структурными управляющими конструкциями и HOL-подобными операциями присваивания. Это фактически было стимулом для моего первоначального углубления в джунгли теории компиляции. Этот язык возможно никогда не будет создан просто потому, что я узнал, что проще реализовать язык типа KISS, который использует только подмножество инструкций ЦПУ. Как вы знаете, ассемблер может быть предельно причудливым и нерегулярным, и язык, который отображается в него один к одному, может быть настоящим вызовом. Однако я всегда чувствовал, что синтаксис, используемый в стандартных ассемблерах тупой... почему
   MOVE.L A,B
   лучше или проще для трансляции, чем
   B=A?
   Я думаю, было бы интересным упражнением разработка «компилятора» который дал бы программисту полный доступ и к контролю над полным набором инструкций ЦПУ, и позволил бы вам генерировать программы настолько же эффективные как язык ассемблер без болезненного изучения набора мнемоник. Это может быть сделано? Я не знаю. Настоящим вопросом может быть вопрос «будет ли полученный язык проще, чем ассемблер?» Если нет, то в нем нет никакого смысла. Я думаю, что это может быть сделано, но я полностью еще не уверен в том, как должен выглядеть синтаксис.
   Возможно у вас есть некоторые комментарии или предложения об этом. Буду рад услышать их.
   Вы возможно не будете удивлены узнав, что уже работал в большинстве тех областей, которые мы рассмотрим. Я имею несколько хороших новостей: дела никогда не будут намного более сложными, чем они были до этого. Возможно построить завершенный, работающий компилятор для реального языка используя только те самые методы которые вы изучили до этого. И это поднимет некоторые интересные вопросы.

Почему это так просто? 

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