Changeset 100 for branches/interpreter/Parser3.pas

Timestamp:

Feb 11, 2017, 12:47:38 PM (8 years ago)

Author:

chronos

Message:

• Modified: Better expression parsing.
• Added: Executor function call context for storing local variables.

File:

• branches/interpreter/Parser3.pas (modified) (25 diffs)

branches/interpreter/Parser3.pas

@@ -14 +14 @@
 
 type
-  TTokenType = (ttNormal, ttSpecialSymbol, ttString, ttConstant);
+  TTokenType = (ttNormal, ttSpecialSymbol, ttString, ttConstant, ttNumber, ttChar);
 
 var
@@ -22 +22 @@
 
   MainProgram: PProgramCode;
+  FunctionContext: PFunction;
 
 function ParseIfThen(IfThenElse: PIfThenElse): Boolean; forward;
@@ -27 +28 @@
 function ParseExecution(Execution: PExecution): Boolean; forward;
 function ParseBeginEnd(BeginEnd: PBeginEnd): Boolean; forward;
-function ParseGetValue(GetValue: PGetValue): Boolean; forward;
+function ParseGetValue(GetValue: PGetValue; NoExpression: Boolean = False): Boolean; forward;
 
 
@@ -33 +34 @@
 begin
   Result := (C = ' ') or (C = #13) or (C = #10) or (C = #9);
+end;
+
+function IsDigit(C: Char): Boolean;
+begin
+  Result := (C >= '0') and (C <= '9');
 end;
 
@@ -72 +78 @@
 end;
 
+function StrToInt(S: string): Integer;
+var
+  I: Integer;
+  N: Integer;
+begin
+  Result := 0;
+  N := 1;
+  I := Length(S);
+  while I >= 1 do begin
+    Result := Result + (Ord(S[I]) - Ord('0')) * N;
+    N := N * 10;
+    I := I - 1;
+  end;
+end;
+
 function ReadNext: string;
 var
   C: Char;
-  IsString: Boolean;
 begin
   Result := '';
-  IsString := False;
   LastTokenType := ttNormal;
   repeat
     C := ReadChar;
-    if IsString then begin
+    if LastTokenType = ttString then begin
       if C = '''' then begin
+        Break;
+      end else Result := Result + C;
+    end else
+    if LastTokenType = ttNumber then begin
+      if not IsDigit(C) then begin
+        if Result[1] = '#' then begin
+          Result := Chr(StrToInt(Copy(Result, 2, Length(Result))));
+          LastTokenType := ttChar;
+        end;
+        InputTextPos := InputTextPos - 1;
         Break;
       end else Result := Result + C;
@@ -108 +137 @@
         end;
       end else
+      if C = '#' then begin
+        Result := Result + '#';
+        LastTokenType := ttNumber;
+      end else
       if C = '''' then begin
         LastTokenType := ttString;
-        IsString := True;
       end else begin
         Result := Result + C;
@@ -157 +189 @@
   OldPos := InputTextPos;
   Next := ReadNext;
-  Variable := MainProgram^.Variables.GetByName(Next);
+  if FunctionContext = nil then
+    Variable := MainProgram^.Variables.GetByName(Next)
+    else Variable := FunctionContext^.Variables.GetByName(Next);
   if Variable <> nil then begin
     Result := True;
@@ -182 +216 @@
 end;
 
+function GetOperatorType(Name: string): TOperator;
+var
+  I: Integer;
+begin
+  I := 0;
+  while (I < Length(OperatorString)) and (OperatorString[TOperator(I)] <> Name) do Inc(I);
+  if I < Length(OperatorString) then Result := TOperator(I)
+    else Result := opNone;
+end;
+
+function ParseOperator(out ExpOperator: TOperator): Boolean;
+var
+  OldPos: Integer;
+  OperatorName: string;
+begin
+  OldPos := InputTextPos;
+  OperatorName := ReadNext;
+  ExpOperator := GetOperatorType(OperatorName);
+  if ExpOperator <> opNone then begin
+    Result := True;
+
+  end else begin
+    InputTextPos := OldPos;
+    Result := False;
+  end;
+end;
+
+function ParseValue(Value: PConstant): Boolean;
+var
+  OldPos: Integer;
+  Text: string;
+begin
+  Result := True;
+  OldPos := InputTextPos;
+  Text := ReadNext;
+  if LastTokenType = ttString then begin
+    Value.DataType := MainProgram.Types.GetByName('string');
+    Value.ValueString := Text;
+  end else
+  if LastTokenType = ttChar then begin
+    Value.DataType := MainProgram.Types.GetByName('Char');
+    Value.ValueChar := Text[1];
+  end else
+  if LastTokenType = ttNumber then begin
+    Value.DataType := MainProgram.Types.GetByName('Integer');
+    //Value.ValueInteger := StrToInt(Text);
+  end else begin
+    Result := False;
+    InputTextPos := OldPos;
+  end;
+end;
+
+procedure DeleteExpressionItem(Expression: PExpression; Index: Integer);
+var
+  I: Integer;
+begin
+  I := Index;
+  while (I + 1) < Length(Expression^.Items) do begin
+    Expression^.Items[I] := Expression^.Items[I + 1];
+    I := I + 1;
+  end;
+  SetLength(Expression^.Items, Length(Expression^.Items) - 1);
+end;
+
 function ParseExpression(Expression: PExpression): Boolean;
 var
-  Next: string;
-  OldPos: Integer;
-  R: Boolean;
   GetValue: TGetValue;
-  Execution: TExecution;
-  Variable: PVariable;
+  ExpOperator: TOperator;
   SubExpression: TExpression;
+  I: Integer;
+  II: Integer;
 begin
   Result := True;
-  if CheckNext('not') then begin
-    Expect('not');
-  end;
-  if CheckNext('(') then begin
-    Expect('(');
-    if ParseGetValue(@GetValue) then begin
+  repeat
+    if CheckNext('(') then begin
+      Expect('(');
+      if ParseExpression(@SubExpression) then begin
+        SetLength(Expression^.Items, Length(Expression^.Items) + 1);
+        Expression^.Items[Length(Expression^.Items) - 1] := SubExpression;
+      end;
+      Expect(')');
+    end else
+    if ParseOperator(ExpOperator) then begin
       SetLength(Expression^.Items, Length(Expression^.Items) + 1);
-      Expression^.Items[Length(Expression^.Items) - 1] := GetValue;
+      Expression^.Items[Length(Expression^.Items) - 1].NodeType := ntOperator;
+      Expression^.Items[Length(Expression^.Items) - 1].OperatorType := ExpOperator;
+    end else
+    if ParseGetValue(@GetValue, True) then begin
+      SetLength(Expression^.Items, Length(Expression^.Items) + 1);
+      Expression^.Items[Length(Expression^.Items) - 1].NodeType := ntValue;
+      Expression^.Items[Length(Expression^.Items) - 1].Value := GetValue;
+    end else begin
+      Result:= True;
+      Break;
     end;
-    Expect(')');
-  end else
-  if ParseVariable(Variable) then begin
-    OldPos := InputTextPos;
-    Next := ReadNext;
-    if IsOperator(Next) then begin
-      Next := ReadNext;
-      //if IsVariable(Next) then begin
-
-      //end else ShowError('Expected variable');
-    end else InputTextPos := OldPos;
-  end else
-  if LastTokenType = ttString then begin
-    ReadNext
-  end else
-  if ParseExecution(@Execution) then begin
-  end else
-  ShowError('Expected variable but found ' + ReadNext);
-
-  OldPos := InputTextPos;
-  Next := ReadNext;
-  if IsLogicOperator(Next) or IsOperator(Next) then begin
-    R := ParseExpression(@SubExpression);
-  end else InputTextPos := OldPos;
-end;
-
-function ParseGetValue(GetValue: PGetValue): Boolean;
+  until False;
+
+  if Length(Expression^.Items) > 0 then begin
+    // Build expression tree using operator precedence
+    for II := 0 to Length(OperatorPrecedence) - 1 do begin
+      I := 1;
+      while (I < Length(Expression^.Items) - 1) do begin
+        if (TExpression(Expression^.Items[I]).NodeType = ntOperator) and
+          not TExpression(Expression^.Items[I]).Associated and
+          (TExpression(Expression^.Items[I]).OperatorType = OperatorPrecedence[II]) then
+        begin
+          if Expression^.Items[I].OperatorType = opNot then begin
+            Expression^.Items[I].Associated := True;
+            SetLength(Expression^.Items[I].Items, 1);
+            Expression^.Items[I].Items[0] := Expression^.Items[I + 1];
+            DeleteExpressionItem(Expression, I + 1);
+          end else begin
+            Expression^.Items[I].Associated := True;
+            SetLength(Expression^.Items[I].Items, 2);
+            Expression^.Items[I].Items[1] := Expression^.Items[I - 1];
+            Expression^.Items[I].Items[0] := Expression^.Items[I + 1];
+            DeleteExpressionItem(Expression, I + 1);
+            DeleteExpressionItem(Expression, I - 1);
+          end;
+        end else Inc(I);
+      end;
+    end;
+  end;
+end;
+
+procedure AssignExpression(ExpDst, ExpSrc: PExpression);
+var
+  I: Integer;
+begin
+  ExpDst^.OperatorType := ExpSrc^.OperatorType;
+  ExpDst^.NodeType := ExpSrc^.NodeType;
+  ExpDst^.Associated := ExpSrc^.Associated;
+  ExpDst^.Value := ExpSrc^.Value;
+  SetLength(ExpDst^.Items, 1); //Length(ExpSrc^.Items));
+  for I := 0 to Length(ExpDst^.Items) - 1 do
+    ExpDst^.Items[I] := ExpSrc^.Items[I];
+end;
+
+function ParseGetValue(GetValue: PGetValue; NoExpression: Boolean = False): Boolean;
 var
   Variable: PVariable;
@@ -234 +360 @@
   FunctionCall: TExecution;
   Expression: TExpression;
-begin
+  Value: TConstant;
+begin
+  Result := True;
+  if not NoExpression and ParseExpression(@Expression) then begin
+    GetValue^.ReadType := rtExpression;
+    GetValue^.Expression := GetMem(SizeOf(TExpression));
+    FillChar(GetValue^.Expression^, SizeOf(TExpression), 0);
+    GetValue^.Expression^ := Expression;
+    //AssignExpression(GetValue^.Expression, @Expression);
+  end else
   if ParseVariable(Variable) then begin
+    GetValue^.ReadType := rtVariable;
     GetValue^.Variable := Variable;
-    GetValue^.ReadType := rtVariable;
   end else
   if ParseConstant(Constant) then begin
+    GetValue^.ReadType := rtConstant;
     GetValue^.Constant := Constant;
-    GetValue^.ReadType := rtConstant;
+  end else
+  if ParseValue(@Value) then begin
+    GetValue^.ReadType := rtValue;
+    GetValue^.Value := Value;
   end else
   if ParseExecution(@FunctionCall) then begin
-    GetValue^.FunctionCall := GetMem(SizeOf(TExecution));
+    GetValue^.ReadType := rtFunctionCall;
+    GetValue^.FunctionCall := GetMem(SizeOf(TFunctionCall));
+    FillChar(GetValue^.FunctionCall^, SizeOf(TFunctionCall), 0);
     GetValue^.FunctionCall^ := FunctionCall;
-    GetValue^.ReadType := rtFunctionCall;
-  end else
-  if ParseExpression(@Expression) then begin
-    GetValue^.Expression := GetMem(SizeOf(TExpression));
-    GetValue^.Expression^ := Expression;
-    GetValue^.ReadType := rtExpression;
-  end else
-    ShowError('Expected value');
-end;
-
-function ParseAssignment: Boolean;
+  end else
+    Result := False;
+end;
+
+function ParseAssignment(Assignment: PAssignment): Boolean;
 var
   Variable: PVariable;
-  Assignment: TAssignment;
 begin
   if ParseVariable(Variable) then begin
     Result := True;
-    Assignment.Destination := Variable;
+    Assignment^.Destination := Variable;
     Expect(':=');
-    ParseGetValue(@Assignment.Source);
+    ParseGetValue(@Assignment^.Source);
   end else begin
     Result := False;
@@ -283 +417 @@
   Func := MainProgram.Functions.GetByName(Next);
   if Func <> nil then begin
+    Execution^.Func := Func;
     SetLength(Execution^.Parameters.Items, Length(Func^.Parameters.Items));
     if Length(Func^.Parameters.Items) > 0 then begin
@@ -311 +446 @@
   if ParseBeginEnd(@BeginEnd) then begin
     Command^.BeginEnd := GetMem(SizeOf(TBeginEnd));
+    FillChar(Command^.BeginEnd^, SizeOf(TBeginEnd), 0);
     Command^.BeginEnd^ := BeginEnd;
     Command^.CmdType := ctBeginEnd;
   end else
-  if ParseAssignment then begin
+  if ParseAssignment(@Assignment) then begin
     Command^.Assignment := GetMem(SizeOf(TAssignment));
+    FillChar(Command^.Assignment^, SizeOf(TAssignment), 0);
     Command^.Assignment^ := Assignment;
     Command^.CmdType := ctAssignment;
@@ -321 +458 @@
   if ParseExecution(@Execution) then begin
     Command^.Execution := GetMem(SizeOf(TExecution));
+    FillChar(Command^.Execution^, SizeOf(TExecution), 0);
     Command^.Execution^ := Execution;
     Command^.CmdType := ctExecution;
@@ -326 +464 @@
   if ParseIfThen(@IfThenElse) then begin
     Command^.IfThenElse := GetMem(SizeOf(TIfThenElse));
+    FillChar(Command^.IfThenElse^, SizeOf(TIfThenElse), 0);
     Command^.IfThenElse^ := IfThenElse;
     Command^.CmdType := ctIfThenElse;
@@ -331 +470 @@
   if ParseWhileDo(@WhileDo) then begin
     Command^.WhileDo := GetMem(SizeOf(TWhileDo));
+    FillChar(Command^.WhileDo^, SizeOf(TWhileDo), 0);
     Command^.WhileDo^ := WhileDo;
     Command^.CmdType := ctWhileDo;
@@ -341 +481 @@
     Result := True;
     Expect('if');
-    ParseExpression(@IfThenElse.Condition);
+    ParseGetValue(@IfThenElse.Condition);
     Expect('then');
     ParseCommand(@IfThenElse^.DoThen);
@@ -356 +496 @@
     Result := True;
     Expect('while');
-    ParseExpression(@WhileDo.Condition);
+    ParseGetValue(@WhileDo.Condition);
     Expect('do');
     ParseCommand(@WhileDo^.Command);
@@ -391 +531 @@
 begin
   if CheckNext('(') then begin
+    Result := True;
     Expect('(');
     ParamName := ReadNext;
@@ -398 +539 @@
     if ParamType <> nil then begin
       Params^.Add(FunctionParameterCreate(ParamName, ParamType));
+      FunctionContext^.Variables.Add(VariableCreate(ParamName, ParamType));
     end else ShowError('Unknown parameter type ' + ParamTypeName);
     Expect(')');
-  end;
+  end else Result := False;
 end;
 
@@ -424 +566 @@
         VarType := MainProgram^.Types.GetByName(VarTypeName);
         if VarType <> nil then begin
-          MainProgram^.Variables.Add(VariableCreate(VarName, VarType));
+          if FunctionContext = nil then
+            MainProgram^.Variables.Add(VariableCreate(VarName, VarType))
+            else FunctionContext^.Variables.Add(VariableCreate(VarName, VarType));
         end else ShowError('Unknown variable type ' + VarTypeName);
         Expect(';');
@@ -435 +579 @@
 var
   ReturnType: string;
+  DataType: PType;
 begin
   if CheckNext('function') then begin
     Result := True;
     Expect('function');
+    FunctionContext := Func;
     Func^.Name := ReadNext;
     ParseParams(@Func^.Parameters);
     Expect(':');
     ReturnType := ReadNext;
+    DataType := MainProgram.Types.GetByName(ReturnType);
+    if DataType <> nil then Func^.ReturnType := DataType
+      else ShowError('Unknown type ' + ReturnType);
     Expect(';');
+    Func^.Variables.Add(VariableCreate('Result', Func^.ReturnType));
     if ParseVariableSection then begin
     end;
     ParseBeginEnd(@Func^.BeginEnd);
+    FunctionContext := nil;
     Expect(';');
   end else Result := False;
@@ -456 +607 @@
     Result := True;
     Expect('procedure');
+    FunctionContext := Func;
     Func^.Name := ReadNext;
     ParseParams(@Func^.Parameters);
@@ -462 +614 @@
     end;
     ParseBeginEnd(@Func^.BeginEnd);
+    FunctionContext := nil;
     Expect(';');
   end else Result := False;
@@ -491 +644 @@
 
   SetLength(ProgramCode^.Variables.Items, 0);
-  ProgramCode^.Variables.Add(VariableCreate('Result', TypeString));
-  ProgramCode^.Variables.Add(VariableCreate('C', TypeChar));
-  ProgramCode^.Variables.Add(VariableCreate('Text', TypeString));
 
   SetLength(ProgramCode^.Functions.Items, 0);
@@ -527 +677 @@
   repeat
     SetLength(NewFunc.Parameters.Items, 0);
+    SetLength(NewFunc.Variables.Items, 0);
     if ParseFunction(@NewFunc) then begin
       ProgramCode.Functions.Add(NewFunc);
@@ -534 +685 @@
     end else Break;
   until False;
+  FunctionContext := nil;
   ParseBeginEnd(@ProgramCode.BeginEnd);
   Expect('.');