Changeset 146 for branches/easy compiler/UCompiler.pas

Timestamp:

Jan 17, 2018, 2:25:45 PM (7 years ago)

Author:

chronos

Message:

• Modified: ParseBeginEnd method split to several other items for parsing each specific command.

File:

• branches/easy compiler/UCompiler.pas (modified) (10 diffs)

branches/easy compiler/UCompiler.pas

@@ -33 +33 @@
     function IsKeyword(Text: string): Boolean;
     function GetNext(Kind: TSourceTokenKind = stNone): TSourceToken;
+    function CheckNext(Text: string; Kind: TSourceTokenKind): Boolean;
     procedure Tokenize(Text: string; Tokens: TSourceTokens);
   end;
@@ -42 +43 @@
     Tokenizer: TTokenizer;
     procedure Parse(Code: TSourceCode);
-    procedure ParseBeginEnd(BeginEnd: TSourceBeginEnd);
+    function ParseBeginEnd(SourceCode: TSourceCode; out BeginEnd: TCommandBeginEnd): Boolean;
+    function ParseFunctionCall(SourceCode: TSourceCode; out FunctionCall: TCommandFunctionCall): Boolean;
+    function ParseIfZero(SourceCode: TSourceCode; out IfZero: TCommandIfZero): Boolean;
+    function ParseReference(SourceCode: TSourceCode): TSourceReference;
+    function ParseReferenceVariable(SourceCode: TSourceCode): TSourceReference;
+    function ParseVar(SourceCode: TSourceCode): Boolean;
   public
     procedure Compile(Source: string; SourceCode: TSourceCode);
@@ -99 +105 @@
   if (Kind <> stNone) and (Result.Kind <> Kind) then
     raise Exception.Create('Unexpected token type');
+end;
+
+function TTokenizer.CheckNext(Text: string; Kind: TSourceTokenKind): Boolean;
+var
+  Index: Integer;
+  Token: TSourceToken;
+begin
+  Index := TokenIndex;
+  Token := GetNext;
+  Result := (LowerCase(Token.Text) = Text) and (Token.Kind = Kind);
+  TokenIndex := Index;
 end;
 
@@ -172 +189 @@
 begin
   Tokenizer.TokenIndex := 0;
-  ParseBeginEnd(Code.Main);
-end;
-
-procedure TCompiler.ParseBeginEnd(BeginEnd: TSourceBeginEnd);
+  ParseBeginEnd(Code, Code.Main);
+end;
+
+function TCompiler.ParseVar(SourceCode: TSourceCode): Boolean;
 var
   Token: TSourceToken;
   Token2: TSourceToken;
-  Keyword: string;
-  Instruction: TSourceInstruction;
-  NewReference: TSourceReference;
-  Funct: TSourceFunction;
-  Param: TSourceFunctionParameter;
   Variable: TSourceVariable;
   ValueType: TSourceType;
-
-function ParseReference: TSourceReference;
+  TokenIndex: Integer;
+begin
+  Result := False;
+  TokenIndex := Tokenizer.TokenIndex;
+  Token := Tokenizer.GetNext;
+  if LowerCase(Token.Text) = 'var' then begin
+    Token := Tokenizer.GetNext;
+    Token2 := Tokenizer.GetNext;
+    if Token2.Kind <> stIdentifier then
+      raise Exception.Create('Expected type parameter');
+    Variable := SourceCode.Variables.Search(Token.Text);
+    if not Assigned(Variable) then begin
+      ValueType := SourceCode.Types.Search(Token2.Text);
+      if not Assigned(ValueType) then
+        raise Exception.Create('Unsupported type: ' + Token2.Text);
+      Variable := SourceCode.Variables.AddNew(Token.Text,
+        ValueType);
+    end else raise Exception.Create('Variable redefined: ' + Token.Text);
+    Result := True;
+  end;
+  if not Result then Tokenizer.TokenIndex := TokenIndex;
+end;
+
+function TCompiler.ParseReference(SourceCode: TSourceCode): TSourceReference;
+var
+  Token: TSourceToken;
+  NewReference: TSourceReference;
 begin
   Token := Tokenizer.GetNext;
@@ -193 +230 @@
     NewReference := TSourceReferenceConstant.Create;
     TSourceReferenceConstant(NewReference).Constant :=
-      BeginEnd.SourceCode.Constants.AddNewString(Token.Text);
+      SourceCode.Constants.AddNewString(Token.Text);
   end else
   if Token.Kind = stIdentifier then begin
     NewReference := TSourceReferenceVariable.Create;
     TSourceReferenceVariable(NewReference).Variable :=
-      BeginEnd.SourceCode.Variables.Search(Token.Text);
+      SourceCode.Variables.Search(Token.Text);
     if TSourceReferenceVariable(NewReference).Variable = nil then
       raise Exception.Create('Variable not found: ' + Token.Text);
@@ -205 +242 @@
     NewReference := TSourceReferenceConstant.Create;
     TSourceReferenceConstant(NewReference).Constant :=
-      BeginEnd.SourceCode.Constants.AddNewInteger(StrToInt(Token.Text));
+      SourceCode.Constants.AddNewInteger(StrToInt(Token.Text));
   end else
   raise Exception.Create('Unexpected parameter');
@@ -211 +248 @@
 end;
 
-function ParseReferenceVariable(Initialize: Boolean = False): TSourceReference;
+function TCompiler.ParseReferenceVariable(SourceCode: TSourceCode): TSourceReference;
+var
+  Token: TSourceToken;
+  NewReference: TSourceReference;
 begin
   Token := Tokenizer.GetNext;
@@ -217 +257 @@
     NewReference := TSourceReferenceVariable.Create;
     TSourceReferenceVariable(NewReference).Variable :=
-      BeginEnd.SourceCode.Variables.Search(Token.Text);
+      SourceCode.Variables.Search(Token.Text);
     if TSourceReferenceVariable(NewReference).Variable = nil then
       raise Exception.Create('Variable not found: ' + Token.Text);
@@ -225 +265 @@
 end;
 
-begin
-  while True do begin
+function TCompiler.ParseFunctionCall(SourceCode: TSourceCode; out FunctionCall: TCommandFunctionCall): Boolean;
+var
+  Funct: TSourceFunction;
+  Param: TSourceFunctionParameter;
+  Token: TSourceToken;
+  TokenIndex: Integer;
+  Keyword: string;
+begin
+  Result := False;
+  TokenIndex := Tokenizer.TokenIndex;
+  Token := Tokenizer.GetNext;
+  Keyword := LowerCase(Token.Text);
+  Funct := SourceCode.Functions.Search(Keyword);
+  if Assigned(Funct) then begin
+    FunctionCall := TCommandFunctionCall.Create;
+    FunctionCall.Name := Keyword;
+    for Param in Funct.Parameters do
+    if Param.Kind = pkString then begin
+      FunctionCall.Parameters.Add(ParseReference(SourceCode))
+    end else
+    if Param.Kind = pkVariable then begin
+      FunctionCall.Parameters.Add(ParseReferenceVariable(SourceCode));
+    end else
+    raise Exception.Create('Unsupported parameter type.');
+    Result := True;
+  end;
+  if not Result then Tokenizer.TokenIndex := TokenIndex;
+end;
+
+function TCompiler.ParseIfZero(SourceCode: TSourceCode; out IfZero: TCommandIfZero): Boolean;
+var
+  Token: TSourceToken;
+  TokenIndex: Integer;
+  Keyword: string;
+begin
+  Result := False;
+  TokenIndex := Tokenizer.TokenIndex;
+  Token := Tokenizer.GetNext;
+  Keyword := LowerCase(Token.Text);
+  if Keyword = 'ifzero' then begin
+    IfZero := TCommandIfZero.Create;
+    IfZero.Variable := TSourceReferenceVariable(ParseReferenceVariable(SourceCode)).Variable;
+    Result := True;
+  end;
+  if not Result then Tokenizer.TokenIndex := TokenIndex;
+end;
+
+function TCompiler.ParseBeginEnd(SourceCode: TSourceCode; out BeginEnd: TCommandBeginEnd): Boolean;
+var
+  Token: TSourceToken;
+  Keyword: string;
+  TokenIndex: Integer;
+  CommandBeginEnd: TCommandBeginEnd;
+  CommandIfZero: TCommandIfZero;
+  CommandFunctionCall: TCommandFunctionCall;
+begin
+  Result := False;
+  TokenIndex := Tokenizer.TokenIndex;
+  Token := Tokenizer.GetNext;
+  Keyword := LowerCase(Token.Text);
+  if Keyword = 'begin' then begin
+    BeginEnd := TCommandBeginEnd.Create;
+    BeginEnd.SourceCode := SourceCode;
+    while True do begin
+      if ParseVar(SourceCode) then
+      else if ParseBeginEnd(SourceCode, CommandBeginEnd) then
+        BeginEnd.Instructions.Add(CommandBeginEnd)
+      else if ParseIfZero(SourceCode, CommandIfZero) then
+        BeginEnd.Instructions.Add(CommandIfZero)
+      else if ParseFunctionCall(SourceCode, CommandFunctionCall) then
+        BeginEnd.Instructions.Add(CommandFunctionCall)
+      else if Tokenizer.CheckNext('end', stIdentifier) then begin
+        Break;
+      end
+      else raise Exception.Create('Unknown token: ' + Keyword);
+    end;
     Token := Tokenizer.GetNext;
-    if Token.Kind = stEof then Break
-    else
-    if Token.Kind = stIdentifier then begin
-      Keyword := LowerCase(Token.Text);
-      if Keyword = 'var' then begin
-        Token := Tokenizer.GetNext;
-        Token2 := Tokenizer.GetNext;
-        if Token2.Kind <> stIdentifier then
-          raise Exception.Create('Expected type parameter');
-        Variable := BeginEnd.SourceCode.Variables.Search(Token.Text);
-        if not Assigned(Variable) then begin
-          ValueType := BeginEnd.SourceCode.Types.Search(Token2.Text);
-          if not Assigned(ValueType) then
-            raise Exception.Create('Unsupported type: ' + Token2.Text);
-          Variable := BeginEnd.SourceCode.Variables.AddNew(Token.Text,
-            ValueType);
-        end else raise Exception.Create('Variable redefined: ' + Token.Text);
-      end else
-      if Keyword = 'begin' then begin
-        Instruction := TSourceBeginEnd.Create;
-        BeginEnd.Instructions.Add(Instruction);
-        TSourceBeginEnd(Instruction).SourceCode := BeginEnd.SourceCode;
-        ParseBeginEnd(TSourceBeginEnd(Instruction));
-      end else
-      if Keyword = 'end' then begin
-        Break;
-      end else
-      begin
-        Funct := BeginEnd.SourceCode.Functions.Search(Keyword);
-        if Assigned(Funct) then begin
-          Instruction := TSourceFunctionCall.Create;
-          TSourceFunctionCall(Instruction).Name := Keyword;
-          for Param in Funct.Parameters do
-          if Param.Kind = pkString then begin
-            TSourceFunctionCall(Instruction).Parameters.Add(ParseReference)
-          end else
-          if Param.Kind = pkVariable then begin
-            TSourceFunctionCall(Instruction).Parameters.Add(ParseReferenceVariable(True));
-          end else
-          raise Exception.Create('Unsupported parameter type.');
-          BeginEnd.Instructions.Add(Instruction);
-        end else raise Exception.Create('Unsupported keyword: ' + Token.Text);
-      end;
-    end else raise Exception.Create('Unsupported token kind.');
-  end;
+    if LowerCase(Token.Text) <> 'end' then
+      raise Exception.Create('Expected end keyword');
+    Result := True;
+  end;
+  if not Result then Tokenizer.TokenIndex := TokenIndex;
 end;
 
@@ -292 +366 @@
 var
   I: Integer;
-  Instruction: TSourceInstruction;
+  Instruction: TSourceCommand;
   TargetInstruction: TTargetInstruction;
 begin
 {  Target.Instructions.Count := 0;
   for I := 0 to SourceCode.Instructions.Count - 1 do begin
-    Instruction := TSourceInstruction(SourceCode.Instructions[I]);
-    if Instruction is TSourceFunctionCall then begin
+    Instruction := TSourceCommand(SourceCode.Instructions[I]);
+    if Instruction is TCommandFunctionCall then begin
       TargetInstruction := TTargetInstruction.Create;
       TargetInstruction.Kind := tiFunction;
-      TargetInstruction.Name := TSourceFunctionCall(Instruction).Name;
+      TargetInstruction.Name := TCommandFunctionCall(Instruction).Name;
       Target.Instructions.Add(TargetInstruction)
     end else raise Exception.Create('Unsupported source instruction');