Современная электронная библиотека ModernLib.Net

Давайте создадим компилятор!

ModernLib.Net / Программирование / Креншоу Джек / Давайте создадим компилятор! - Чтение (стр. 8)
Автор: Креншоу Джек
Жанр: Программирование

 

 


      Все элементы программы для синтаксического анализа этого подмножества с использованием односимвольных токенов уже существуют в наших предыдущих программах. Я построил ее осторожно скопировав эти файлы, но я не посмею попробовать провести вас через этот процесс. Вместо этого, во избежание беспорядка, вся программа показана ниже:
      {–}
      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?
      Я думаю, было бы интересным упражнением разработка «компилятора» который дал бы программисту полный доступ и к контролю над полным набором инструкций ЦПУ, и позволил бы вам генерировать программы настолько же эффективные как язык ассемблер без болезненного изучения набора мнемоник. Это может быть сделано? Я не знаю. Настоящим вопросом может быть вопрос «будет ли полученный язык проще, чем ассемблер?» Если нет, то в нем нет никакого смысла. Я думаю, что это может быть сделано, но я полностью еще не уверен в том, как должен выглядеть синтаксис.
      Возможно у вас есть некоторые комментарии или предложения об этом. Буду рад услышать их.
      Вы возможно не будете удивлены узнав, что уже работал в большинстве тех областей, которые мы рассмотрим. Я имею несколько хороших новостей: дела никогда не будут намного более сложными, чем они были до этого. Возможно построить завершенный, работающий компилятор для реального языка используя только те самые методы которые вы изучили до этого. И это поднимет некоторые интересные вопросы.

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

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

Здесь нет ничего сложного!

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

  • Страницы:
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23