Changeset 212 for branches/interpreter2/UParser.pas

Timestamp:

Apr 22, 2020, 12:04:22 PM (5 years ago)

Author:

chronos

Message:

• Added: Support for custom functions.

File:

• branches/interpreter2/UParser.pas (modified) (7 diffs)

branches/interpreter2/UParser.pas

@@ -20 +20 @@
     function ParseCommand(Block: TBlock; out Command: TCommand): Boolean;
     function ParseProgram(SystemBlock: TBlock; out Prog: TProgram): Boolean;
-    function ParseBlock(ParentBlock: TBlock; out Block: TBlock): Boolean;
+    function ParseBlock(ParentBlock: TBlock; out Block: TBlock; ExistingBlock: TBlock = nil): Boolean;
     function ParseBlockVar(Block: TBlock): Boolean;
     function ParseBlockConst(Block: TBlock): Boolean;
+    function ParseFunction(Block: TBlock; out Func: TFunction): Boolean;
+    function ParseFunctionParameter(Block: TBlock; out Parameter: TFunctionParameter): Boolean;
     function ParseAssignment(Block: TBlock; out Assignment: TAssignment): Boolean;
     function ParseExpression(Block: TBlock; out Expression: TExpression): Boolean;
@@ -194 +196 @@
 end;
 
-function TParser.ParseBlock(ParentBlock: TBlock; out Block: TBlock): Boolean;
+function TParser.ParseBlock(ParentBlock: TBlock; out Block: TBlock; ExistingBlock: TBlock = nil): Boolean;
 var
   BeginEnd: TBeginEnd;
-begin
-  Result := False;
-  Block := TBlock.Create;
+  Func: TFunction;
+begin
+  Result := False;
+  if Assigned(ExistingBlock) then Block := ExistingBlock
+    else Block := TBlock.Create;
   Block.ParentBlock := ParentBlock;
-  ParseBlockVar(Block);
-  ParseBlockConst(Block);
+  while True do begin
+    if ParseBlockVar(Block) then begin
+    end else
+    if ParseBlockConst(Block) then begin
+    end else
+    if ParseFunction(Block, Func) then begin
+      Block.Functions.Add(Func);
+    end else begin
+      Break;
+    end;
+  end;
   if ParseBeginEnd(Block, BeginEnd) then begin
     Result := True;
@@ -208 +221 @@
     Block.BeginEnd := BeginEnd;
     BeginEnd.Parent := Block;
-  end else Block.Free;
+  end else begin
+    if not Assigned(ExistingBlock) then Block.Free;
+    Block := nil;
+  end;
 end;
 
@@ -291 +307 @@
 end;
 
+function TParser.ParseFunction(Block: TBlock; out Func: TFunction): Boolean;
+var
+  Token: TToken;
+  FunctionParameter: TFunctionParameter;
+  NewBlock: TBlock;
+  TypeRef: TType;
+  Variable: TVariable;
+  I: Integer;
+begin
+  Result := False;
+  if Tokenizer.CheckNext('function', tkKeyword) then begin
+    Tokenizer.Expect('function', tkKeyword);
+    Result := True;
+    Func := TFunction.Create;
+    Token := Tokenizer.GetNext;
+    if Token.Kind = tkIdentifier then begin
+      Func.Name := Token.Text;
+      if Tokenizer.CheckNext('(', tkSpecialSymbol) then begin
+        Tokenizer.Expect('(', tkSpecialSymbol);
+        while not Tokenizer.CheckNext(')', tkSpecialSymbol) do begin
+          if Func.Params.Count > 0 then Tokenizer.Expect(',', tkSpecialSymbol);
+          if ParseFunctionParameter(Block, FunctionParameter) then begin
+            Func.Params.Add(FunctionParameter);
+          end else Error('Expected function parameter.');
+        end;
+        Tokenizer.Expect(')', tkSpecialSymbol);
+        for I := 0 to Func.Params.Count - 1 do begin
+          Variable := TVariable.Create;
+          Variable.Name := TFunctionParameter(Func.Params[I]).Name;
+          Variable.TypeRef := TFunctionParameter(Func.Params[I]).TypeRef;
+          Variable.Internal := True;
+          Func.Block.Variables.Add(Variable);
+        end;
+      end;
+      if Tokenizer.CheckNext(':', tkSpecialSymbol) then begin
+        Tokenizer.Expect(':', tkSpecialSymbol);
+        Token := Tokenizer.GetNext;
+        if Token.Kind = tkIdentifier then begin
+          TypeRef := Block.GetType(Token.Text);
+          if Assigned(TypeRef) then begin
+            Func.ResultType := TypeRef;
+            Variable := TVariable.Create;
+            Variable.Name := 'Result';
+            Variable.TypeRef := TypeRef;
+            Variable.Internal := True;
+            Func.Block.Variables.Add(Variable);
+          end else Error('Type ' + Token.Text + ' not found');
+        end;
+      end;
+      Tokenizer.Expect(';', tkSpecialSymbol);
+      if ParseBlock(Block, NewBlock, Func.Block) then begin
+        Tokenizer.Expect(';', tkSpecialSymbol);
+      end else Error('Expected function block');
+    end else Error('Expected function name');
+  end;
+end;
+
+function TParser.ParseFunctionParameter(Block: TBlock; out Parameter: TFunctionParameter
+  ): Boolean;
+var
+  Token: TToken;
+  TypeRef: TType;
+begin
+  Result := True;
+  Token := Tokenizer.GetNext;
+  if Token.Kind = tkIdentifier then begin
+    Parameter := TFunctionParameter.Create;
+    Parameter.Name := Token.Text;
+    Tokenizer.Expect(':', tkSpecialSymbol);
+    Token := Tokenizer.GetNext;
+    if Token.Kind = tkIdentifier then begin
+      TypeRef := Block.GetType(Token.Text);
+      if Assigned(TypeRef) then begin
+        Parameter.TypeRef := TypeRef;
+      end else Error('Type ' + Token.Text + ' not found');
+    end else Error('Expected parameter type');
+  end else Error('Expected parameter name');
+end;
+
 function TParser.ParseAssignment(Block: TBlock; out Assignment: TAssignment): Boolean;
 var
@@ -315 +410 @@
         end else begin
           Result := False;
-          Error('Assignment type mismatch.');
+          Error('Assignment type mismatch. Expected ' + Variable.TypeRef.Name + ' but got ' + Expression.GetType.Name);
         end;
       end;
@@ -348 +443 @@
   Expression: TExpression;
   LastPos: TTokenizerPos;
+  I: Integer;
+  ExpectedType: TType;
 begin
   Result := False;
@@ -362 +459 @@
       else if Token.Text = '<>' then ExpressionOperation.Operation := eoNotEqual
       else Error('Unsupported operator ' + Token.Text);
+      ExpressionOperation.FunctionRef := ExpressionOperation.TypeRef.Functions.SearchByName(ExpressionOperation.GetFunctionName);
+      if not Assigned(ExpressionOperation.FunctionRef.ResultType) then
+        raise Exception.Create('Missing result type for function');
+      ExpressionOperation.TypeRef := ExpressionOperation.FunctionRef.ResultType;
       ExpressionOperation.Items.Add(Operand);
+      I := 1;
       if ParseExpression(Block, Expression) then begin
-        if Expression.GetType = Operand.GetType then
+        ExpectedType := TFunctionParameter(ExpressionOperation.FunctionRef.Params[I]).TypeRef;
+        if Expression.GetType = ExpectedType then
           ExpressionOperation.Items.Add(Expression)
-          else Error('Expression operands needs to be same type.');
+          else Error('Expression operands needs to be same type. Expected ' + ExpectedType.Name + ' but found ' + Expression.GetType.Name);
       end else Error('Missing operand.');
     end else Operand.Free;