Changeset 233 for branches/xpascal/Parsers

Timestamp:

Jun 26, 2023, 6:08:23 PM (17 months ago)

Author:

chronos

Message:

• Added: Support for procedures.
• Added: Project pascal file can be opened from main menu. Last file name is remembered.
• Modified: Improved XML output of source structure.

File:

• branches/xpascal/Parsers/ParserPascal.pas (modified) (10 diffs)

branches/xpascal/Parsers/ParserPascal.pas

@@ -14 +14 @@
     function ParseBeginEnd(Block: TBlock; out BeginEnd: TBeginEnd): Boolean;
     function ParseFunctionCall(Block: TBlock; out FunctionCall: TFunctionCall): Boolean;
+    function ParseProcedureCall(Block: TBlock; out ProcedureCall: TProcedureCall): Boolean;
     function ParseCommand(Block: TBlock; out Command: TCommand): Boolean;
     function ParseProgram(SystemBlock: TBlock; out Prog: TProgram): Boolean; override;
@@ -20 +21 @@
     function ParseBlockConst(Block: TBlock): Boolean;
     function ParseFunction(Block: TBlock; out Func: TFunction): Boolean;
+    function ParseFunctionParameters(Block: TBlock; out Params: TFunctionParameters): Boolean;
     function ParseFunctionParameter(Block: TBlock; out Parameter: TFunctionParameter): Boolean;
+    function ParseProcedure(Block: TBlock; out Proc: TProcedure): Boolean;
     function ParseAssignment(Block: TBlock; out Assignment: TAssignment): Boolean;
     function ParseExpression(Block: TBlock; out Expression: TExpression;
@@ -101 +104 @@
 end;
 
+function TParserPascal.ParseProcedureCall(Block: TBlock; out
+  ProcedureCall: TProcedureCall): Boolean;
+var
+  Token: TToken;
+  LastPos: TTokenizerPos;
+  ProcedureDef: TProcedure;
+  Expression: TExpression;
+  I: Integer;
+begin
+  LastPos := Tokenizer.Pos;
+  Token := Tokenizer.GetNext;
+  if Token.Kind = tkIdentifier then begin
+    ProcedureDef := Block.GetProcedure(Token.Text);
+    if Assigned(ProcedureDef) then begin
+      ProcedureCall := TProcedureCall.Create;
+      ProcedureCall.ProcedureDef := ProcedureDef;
+      if Tokenizer.CheckNextAndRead('(', tkSpecialSymbol) then begin
+        for I := 0 to ProcedureDef.Params.Count - 1 do begin
+          if I > 0 then Tokenizer.Expect(',', tkSpecialSymbol);
+          if ParseExpression(Block, Expression) then begin
+            if Expression.GetType = TFunctionParameter(ProcedureDef.Params[I]).TypeRef then
+              ProcedureCall.Params.Add(Expression)
+              else Error('Function parameter mismatch.');
+          end else Error('Expected procedure parameter.');
+        end;
+        Tokenizer.Expect(')', tkSpecialSymbol);
+      end;
+      Result := True;
+    end else begin
+      Result := False;
+      Tokenizer.Pos := LastPos;
+    end;
+  end else begin
+    Result := False;
+    Tokenizer.Pos := LastPos;
+  end;
+end;
+
 function TParserPascal.ParseCommand(Block: TBlock; out Command: TCommand): Boolean;
 var
   BeginEnd: TBeginEnd;
   FunctionCall: TFunctionCall;
+  ProcedureCall: TProcedureCall;
   Assignment: TAssignment;
   IfThenElse: TIfThenElse;
@@ -132 +174 @@
     Result := True;
     Command := FunctionCall;
+  end else
+  if ParseProcedureCall(Block, ProcedureCall) then begin
+    Result := True;
+    Command := ProcedureCall;
   end else
   if ParseRepeatUntil(Block, RepeatUntil) then begin
@@ -183 +229 @@
   BeginEnd: TBeginEnd;
   Func: TFunction;
+  Proc: TProcedure;
 begin
   Result := False;
@@ -195 +242 @@
     if ParseFunction(Block, Func) then begin
       Block.Functions.Add(Func);
-    end else begin
+    end else
+    if ParseProcedure(Block, Proc) then begin
+      Block.Procedures.Add(Proc);
+    end else
+    begin
       Break;
     end;
@@ -291 +342 @@
 var
   Token: TToken;
-  FunctionParameter: TFunctionParameter;
   NewBlock: TBlock;
   TypeRef: TType;
   Variable: TVariable;
-  I: Integer;
+  FunctionParameters: TFunctionParameters;
 begin
   Result := False;
@@ -304 +354 @@
     if Token.Kind = tkIdentifier then begin
       Func.Name := Token.Text;
-      if Tokenizer.CheckNextAndRead('(', tkSpecialSymbol) then begin
-        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;
+      Func.Block.ParentBlock := Block;
+      if ParseFunctionParameters(Func.Block, FunctionParameters) then begin
+        Func.Params.Free;
+        Func.Params := FunctionParameters;
+      end;
+
       if Tokenizer.CheckNextAndRead(':', tkSpecialSymbol) then begin
         Token := Tokenizer.GetNext;
@@ -339 +379 @@
       end else Error('Expected function block');
     end else Error('Expected function name');
+  end;
+end;
+
+function TParserPascal.ParseFunctionParameters(Block: TBlock;
+  out Params: TFunctionParameters): Boolean;
+var
+  FunctionParameter: TFunctionParameter;
+  I: Integer;
+  Variable: TVariable;
+begin
+  Result := False;
+  Params := TFunctionParameters.Create;
+  if Tokenizer.CheckNextAndRead('(', tkSpecialSymbol) then begin
+    while not Tokenizer.CheckNext(')', tkSpecialSymbol) do begin
+      if Params.Count > 0 then Tokenizer.Expect(',', tkSpecialSymbol);
+      if ParseFunctionParameter(Block, FunctionParameter) then begin
+        Params.Add(FunctionParameter);
+      end else Error('Expected function parameter.');
+    end;
+    Tokenizer.Expect(')', tkSpecialSymbol);
+    for I := 0 to Params.Count - 1 do begin
+      Variable := TVariable.Create;
+      Variable.Name := Params[I].Name;
+      Variable.TypeRef := Params[I].TypeRef;
+      Variable.Internal := True;
+      Block.Variables.Add(Variable);
+    end;
+    Result := True;
   end;
 end;
@@ -368 +436 @@
     end else Error('Expected parameter type');
   end else Error('Expected parameter name');
+end;
+
+function TParserPascal.ParseProcedure(Block: TBlock; out Proc: TProcedure
+  ): Boolean;
+var
+  Token: TToken;
+  NewBlock: TBlock;
+  FunctionParameters: TFunctionParameters;
+begin
+  Result := False;
+  if Tokenizer.CheckNextAndRead('procedure', tkKeyword) then begin
+    Result := True;
+    Proc := TProcedure.Create;
+    Token := Tokenizer.GetNext;
+    if Token.Kind = tkIdentifier then begin
+      Proc.Name := Token.Text;
+      Proc.Block.ParentBlock := Block;
+      if ParseFunctionParameters(Proc.Block, FunctionParameters) then begin
+        Proc.Params.Free;
+        Proc.Params := FunctionParameters;
+      end;
+
+      Tokenizer.Expect(';', tkSpecialSymbol);
+      if ParseBlock(Block, NewBlock, Proc.Block) then begin
+        Tokenizer.Expect(';', tkSpecialSymbol);
+      end else Error('Expected procedure block');
+    end else Error('Expected procedure name');
+  end;
 end;