�.�� "�� !". ��

14. ��

��

    � �� (�� 13, ��) � ��, �� , �� , �� . � �� . �� , �� '89 �� . ��, �� .
    � �� , �� . �� , � �� TINY. �� , �� : �� . �� , �� . �� , �� .
    �� : ��-��, �� , �� . �� , �� . �� , �� , � �� .
    ��-��, �� . �� , �� , �� , �� KISS. � �� , �� .�., �� , �� . �� KISS - �� . � �� .
    ��, � �� : ��, �� .   �� . �� . ��-��, �� , �� . �� (�� Ada, ��) �� , � �� . �� , � ��, �� .
    � �� , �� . �� . �� , �� , �� , � �� .

�� ?

    �� , � �� ... �� , �� .
    �� . � �� . �� , � �� , � ��, �� TINY, �� . � �� , �� . �� , ��, �� , �� - �� .
    �� , ��, �� Turbo Pascal �� . �� (�� ) � �� . �� , �� , �� .
    � �� Turbo 5.5 ��, ��, �� -�� . � �� , �� , �� . �� , �� , �� , �� 5.5 � � �� -�� , �� . ��-��, � �� , �� . �� -�� CLM �� CompuServe, � �� . �� , �� . ��-�� Turbo 5.5 � ��?
    � �� . �� : �� TINY (�� ), �� TINY � �� KISS. � �� TINY � KISS:

TINY �� : �� 16-�� . � �� -�� , �� . KISS �� , �� .
TINY �� IF � WHILE. KISS �� , �� ... CASE.
KISS �� .

�� : �� 80x86, �� 68000. �� , �� , �� , �� . �� "�� ". � �� : � ��, �� 80x86, � �� .
�� . �� . �� , �� : �� .

��

    �� , �� , �� -�� . �� .
    �� . �� , �� , �� .
    ��, �� :

{--------------------------------------------------------------}
{ Variable Declarations }

var Look: char; { Lookahead Character }

ST: Array['A'..'Z'] of char; { *** �� ***}
{--------------------------------------------------------------}

�� , �� Init:

{--------------------------------------------------------------}
{ Initialize }

procedure Init;
var i: char;
begin
   for i := 'A' to 'Z' do
      ST[i] := '?';
   GetChar;
end;
{--------------------------------------------------------------}

�� , �� . ��, �� , �� :

{--------------------------------------------------------------}
{ Dump the Symbol Table }

procedure DumpTable;
var i: char;
begin
for i := 'A' to 'Z' do
WriteLn(i, ' ', ST[i]);
end;
{--------------------------------------------------------------}

� �� , �� ... � �� , �� .
�� (�� ), �� , �� . �� , �� , �� , �� , �� . ��, �� :

{--------------------------------------------------------------}
program Types;

{--------------------------------------------------------------}
{ Constant Declarations }

const TAB = ^I;
CR = ^M;
LF = ^J;

{--------------------------------------------------------------}
{ Variable Declarations }

var Look: char; { Lookahead Character }

ST: Array['A'..'Z'] of char;

{--------------------------------------------------------------}
{ 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;

{--------------------------------------------------------------}
{ Dump the Symbol Table }

procedure DumpTable;
var i: char;
begin
for i := 'A' to 'Z' do
WriteLn(i, ' ', ST[i]);
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 a Boolean Orop }

function IsOrop(c: char): boolean;
begin
IsOrop := c in ['|', '~'];
end;

{--------------------------------------------------------------}
{ Recognize a Relop }

function IsRelop(c: char): boolean;
begin
IsRelop := 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;

{--------------------------------------------------------------}
{ Skip Over an End-of-Line }

procedure Fin;
begin
   if Look = CR then begin
      GetChar;
      if Look = LF then
         GetChar;
   end;
end;

{--------------------------------------------------------------}
{ Match a Specific Input Character }

procedure Match(x: char);
begin
   if Look = x then GetChar
   else Expected('''' + x + '''');
   SkipWhite;
end;

{--------------------------------------------------------------}
{ Get an Identifier }

function GetName: char;
begin
   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;

{--------------------------------------------------------------}
{ 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;

{--------------------------------------------------------------}
{ Initialize }

procedure Init;
var i: char;
begin
   for i := 'A' to 'Z' do
      ST[i] := '?';
   GetChar;
   SkipWhite;
end;

{--------------------------------------------------------------}
{ Main Program }

begin
Init;
DumpTable;
end.
{--------------------------------------------------------------}

��, �� . �� (�� ) �� (�� ) �� . �� , �� .
��, ��-�� , �� . �� DumpTable �� IF. �� :

for i := 'A' to 'Z' do
if ST[i] <> '?' then
WriteLn(i, ' ', ST[i]);

�� . �� ?
��, �� ! �� , �� . �� , �� . �� :

ST['A'] := 'a';
ST['P'] := 'b';
ST['X'] := 'c';

�� , �� , �� , ��, �� .

��

��, �� - �� . ��, �� , �� , �� . � �� , �� , �� , �� (�� 26 ��!). �� :

{--------------------------------------------------------------}
{ Report Type of a Variable }

function TypeOf(N: char): char;
begin
TypeOf := ST[N];
end;

{--------------------------------------------------------------}
{ Report if a Variable is in the Table }

function InTable(N: char): boolean;
begin
InTable := TypeOf(N) <> '?';
end;

{--------------------------------------------------------------}
{ Check for a Duplicate Variable Name }

procedure CheckDup(N: char);
begin
if InTable(N) then Abort('Duplicate Name ' + N);
end;

{--------------------------------------------------------------}
{ Add Entry to Table }

procedure AddEntry(N, T: char);
begin
CheckDup(N);
ST[N] := T;
end;
{--------------------------------------------------------------}

�� :

    AddEntry('A', 'a');
    AddEntry('P', 'b');
    AddEntry('X', 'c');

� �� . ��? �� , �� . � �� .

��

� �� , �� , �� TINY, �� , �� . �� "��", �� - �� . ��, �� :

��, �� . �� - �� . �� , �� . �� , �� Alloc �� AddEntry �� :

{--------------------------------------------------------------}
{ Allocate Storage for a Variable }

procedure Alloc(N: char);
begin
AddEntry(N, 'v');
WriteLn(N, ':', TAB, 'DC 0');
end;

{--------------------------------------------------------------}
{ Parse and Translate a Data Declaration }

procedure Decl;
var Name: char;
begin
Match('v');
Alloc(GetName);
end;

{--------------------------------------------------------------}
{ Parse and Translate Global Declarations }

procedure TopDecls;
begin
   while Look <> '.' do begin
      case Look of
        'v': Decl;
      else Abort('Unrecognized Keyword ' + Look);
      end;
      Fin;
   end;
end;
{--------------------------------------------------------------}

��, � �� TopDecl � �� . �� . �� , �� . �� TopDecls �� .
�� , �� .

��

�� TopDecl �� . �� , � �� , �� .�., �� :

��:

<typename> ::= BYTE | WORD | LONG

(�� , �� 68000, �� .)
�� , �� , �� . �� , �� , �� , � �� Alloc �� . �� -�� .

{--------------------------------------------------------------}
{ Generate Code for Allocation of a Variable }

procedure AllocVar(N, T: char);
begin
WriteLn(N, ':', TAB, 'DC.', T, ' 0');
end;

{--------------------------------------------------------------}
{ Allocate Storage for a Variable }

procedure Alloc(N, T: char);
begin
AddEntry(N, T);
AllocVar(N, T);
end;

{--------------------------------------------------------------}
{ Parse and Translate a Data Declaration }

procedure Decl;
var Typ: char;
begin
Typ := GetName;
Alloc(GetName, Typ);
end;

{--------------------------------------------------------------}
{ Parse and Translate Global Declarations }

procedure TopDecls;
begin
   while Look <> '.' do begin
      case Look of
        'b', 'w', 'l': Decl;
      else Abort('Unrecognized Keyword ' + Look);
      end;
      Fin;
   end;
end;
{--------------------------------------------------------------}

�� . �� "b", "w" � "l" �� (�� ). �� , �� . �� , �� , �� . �� ? ��, �� .

��

��, �� , �� -�� . �� , �� D0. �� , �� Alloc, �.�. �� , �� . �� -�� . �� :

{---------------------------------------------------------------}
{ Load a Variable to Primary Register }

procedure LoadVar(Name, Typ: char);
begin
Move(Typ, Name + '(PC)', 'D0');
end;
{---------------------------------------------------------------}

�� 68000, �� MOVE. �� :

{---------------------------------------------------------------}
{ Generate a Move Instruction }

procedure Move(Size: char; Source, Dest: String);
begin
EmitLn('MOVE.' + Size + ' ' + Source + ',' + Dest);
end;
{---------------------------------------------------------------}

�� , �� - �� ; �� . �� , �� , �� .
�� , �� , �� , � �� - �� . �� :

{--------------------------------------------------------------}
{ Recognize a Legal Variable Type }

function IsVarType(c: char): boolean;
begin
IsVarType := c in ['B', 'W', 'L'];
end;
{--------------------------------------------------------------}

��, �� , ��