Changeset 4 for branches/bigint

Timestamp:

Aug 1, 2024, 10:47:04 PM (4 months ago)

Author:

chronos

Message:

• Added: Assembler to parse instructions from text string and produce binary code.

Location:

branches/bigint

Files:

• Assembler.pas (modified) (2 diffs)
• BigIntVM.lpi (modified) (1 diff)
• BigIntVM.lpr (modified) (1 diff)
• Example.asm (added)
• FormMain.pas (modified) (2 diffs)
• Instructions.pas (added)
• Memory.pas (modified) (2 diffs)
• Message.pas (added)
• Parser.pas (added)

branches/bigint/Assembler.pas

@@ -4 +4 @@
 
 uses
-  Classes, SysUtils;
+  Classes, SysUtils, Instructions, Cpu, Generics.Collections,
+  Memory, Message, Parser, Int;
 
 type
+  { TLabelRef }
+
+  TLabelRef = record
+    LabelName: string;
+    RefPos: Integer;
+    TextPos: TPoint;
+    class function Create(LabelName: string; RefPos: Integer): TLabelRef; static;
+  end;
 
   { TAssembler }
 
   TAssembler = class
-    Lines: TStringList;
-    procedure Assemble;
+  private
+    FOnError: TErrorEvent;
+    Parser: TParser;
+    function ParseVar: Boolean;
+    function ParseDb: Boolean;
+    function ParseOrg: Boolean;
+    function ParseInstruction: Boolean;
+    function ParseLabel: Boolean;
+    procedure UpdateLabelRefs;
+    procedure ParseNumParam(Token: TToken);
+  public
+    InstructionSet: TInstructionSet;
+    Memory: TMemory;
+    Labels: TDictionary<string, TInt>;
+    LabelRefs: TList<TLabelRef>;
+    Variables: TDictionary<string, TInt>;
+    Message: TMessages;
+    procedure Error(Text: string; Pos: TPoint);
+    procedure Compile(Source: string);
+    procedure LoadFromFile(FileName: string);
+    function ParseStr(var Text: string; Separator: string): string;
     constructor Create;
     destructor Destroy; override;
+    property OnError: TErrorEvent read FOnError write FOnError;
   end;
 
@@ -20 +49 @@
 implementation
 
+{ TLabelRef }
+
+class function TLabelRef.Create(LabelName: string; RefPos: Integer): TLabelRef;
+begin
+  Result.LabelName := LabelName;
+  Result.RefPos := RefPos;
+end;
+
 { TAssembler }
 
-procedure TAssembler.Assemble;
-begin
-
+procedure TAssembler.UpdateLabelRefs;
+var
+  I: Integer;
+  Addr: TInt;
+begin
+  for I := 0 to LabelRefs.Count - 1 do begin
+    if Labels.TryGetValue(LabelRefs[I].LabelName, Addr) then
+      Memory[LabelRefs[I].RefPos] := Addr
+      else Error('Label ' + LabelRefs[I].LabelName + ' referenced but not defined.', LabelRefs[I].TextPos);
+  end;
+end;
+
+procedure TAssembler.ParseNumParam(Token: TToken);
+var
+  Addr: TInt;
+begin
+  if Token.Kind = tkNumber then begin
+    if TryStrToInt64(Token.Value, Addr) then begin
+      Memory.WritePos(Addr);
+    end;
+  end else
+  if Token.Kind = tkIdentifier then begin;
+    if Variables.TryGetValue(Token.Value, Addr) then begin
+      Memory.WritePos(Addr);
+    end else
+    if Labels.TryGetValue(Token.Value, Addr) then begin
+      Memory.WritePos(Addr);
+    end else begin
+      LabelRefs.Add(TLabelRef.Create(Token.Value, Memory.Position));
+      Memory.WritePos(0);
+    end;
+  end else Error('Unexpected token ' + Token.Value + '.', Token.Pos);
+end;
+
+procedure TAssembler.Error(Text: string; Pos: TPoint);
+begin
+  Message.AddMessage(Text, Pos);
+  if Assigned(FOnError) then
+    FOnError(Text, Pos);
+end;
+
+procedure TAssembler.Compile(Source: string);
+begin
+  Message.Clear;
+  Memory.Size := 10000;
+  Labels.Clear;
+  LabelRefs.Clear;
+  Parser.Reset;
+  Parser.Source := Source;
+  while not Parser.CheckNextKind(tkEof) do begin
+    ParseLabel;
+    if ParseVar then begin
+    end else
+    if ParseDb then begin
+    end else
+    if ParseOrg then begin
+    end else
+    if ParseInstruction then begin
+    end;
+    if Parser.CheckNextKind(tkEof) then begin
+    end else Parser.Expect(tkEol);
+  end;
+  Parser.Expect(tkEof);
+  UpdateLabelRefs;
+  Memory.Size := Memory.Position;
+  Error('Compilation finished.', Point(0, 0));
+end;
+
+function TAssembler.ParseVar: Boolean;
+var
+  TokenName: TToken;
+  TokenValue: TToken;
+  Number: TInt;
+begin
+  Result := False;
+  if Parser.CheckNextAndRead(tkIdentifier, 'VAR') then begin
+    Result := True;
+    while True do begin
+      TokenName := Parser.ReadNext;
+      if TokenName.Kind = tkIdentifier then begin
+        TokenValue := Parser.ReadNext;
+        if TokenValue.Kind = tkNumber then begin
+          if not Labels.ContainsKey(TokenName.Value) and not Variables.ContainsKey(TokenName.Value) then begin
+            if TryStrToInt64(TokenValue.Value, Number) then
+              Variables.Add(TokenName.Value, Number)
+            else Error('Expected number', TokenValue.Pos);
+          end else Error('Duplicate variable name ' + TokenName.Value, TokenName.Pos);
+        end else Error('Expected variable value.', TokenValue.Pos);
+      end else Error('Expected variable name.', TokenName.Pos);
+      if Parser.CheckNextAndRead(tkSpecialSymbol, ',') then begin
+        Continue;
+      end;
+      Break;
+    end;
+  end;
+end;
+
+function TAssembler.ParseDb: Boolean;
+var
+  Token: TToken;
+begin
+  Result := False;
+  if Parser.CheckNextAndRead(tkIdentifier, 'DB') then begin
+    Result := True;
+    while True do begin
+      Token := Parser.ReadNext;
+      if Token.Kind = tkString then begin
+        Memory.WriteStringPos(Token.Value);
+      end else
+        ParseNumParam(Token);
+      if Parser.CheckNextAndRead(tkSpecialSymbol, ',') then begin
+        Continue;
+      end;
+      Break;
+    end;
+  end;
+end;
+
+function TAssembler.ParseOrg: Boolean;
+var
+  Token: TToken;
+begin
+  Result := False;
+  if Parser.CheckNextAndRead(tkIdentifier, 'ORG') then begin
+    Result := True;
+    Token := Parser.ReadNext;
+    if Token.Kind = tkNumber then begin
+      Memory.Position := StrToInt(Token.Value);
+    end else Error('Expected number but ' + Token.Value + ' found.', Token.Pos);
+  end;
+end;
+
+function TAssembler.ParseInstruction: Boolean;
+var
+  InstructionInfo: TInstructionInfo;
+  I: Integer;
+  Token: TToken;
+  LastPos: TParserPos;
+  Number: Integer;
+begin
+  Result := False;
+  LastPos := Parser.Pos;
+  Token := Parser.ReadNext;
+  InstructionInfo := InstructionSet.SearchName(Token.Value);
+  if Assigned(InstructionInfo) then begin
+    Result := True;
+    Memory.WritePos(TInt(InstructionInfo.Instruction));
+    for I := 0 to Length(InstructionInfo.Params) - 1 do begin
+      if I > 0 then
+        Parser.Expect(tkSpecialSymbol, ',');
+      if InstructionInfo.Params[I] = ptNumber then begin
+        Token := Parser.ReadNext;
+        ParseNumParam(Token);
+      end else
+      if InstructionInfo.Params[I] = ptIndirect then begin
+        Parser.Expect(tkSpecialSymbol, '(');
+        Token := Parser.ReadNext;
+        if TryStrToInt(Token.Value, Number) then
+          Memory.WritePos(Number)
+          else Error('Expected numeric index error', Token.Pos);
+        Parser.Expect(tkSpecialSymbol, ')');
+      end else raise Exception.Create('Unsupported parameter type');
+    end;
+  end;
+  if not Result then Parser.Pos := LastPos;
+end;
+
+function TAssembler.ParseLabel: Boolean;
+var
+  LastPos: TParserPos;
+  Token: TToken;
+  Addr: TInt;
+begin
+  Result := False;
+  LastPos := Parser.Pos;
+  Token := Parser.ReadNext;
+  if Parser.CheckNextAndRead(tkSpecialSymbol, ':') then begin
+    Result := True;
+    if not Labels.TryGetValue(Token.Value, Addr) then begin
+      Labels.Add(Token.Value, Memory.Position);
+    end else Error('Duplicate label ' + Token.Value + '.', Token.Pos);
+  end;
+  if not Result then Parser.Pos := LastPos;
+end;
+
+procedure TAssembler.LoadFromFile(FileName: string);
+var
+  Lines: TStringList;
+begin
+  Lines := TStringList.Create;
+  try
+    Lines.LoadFromFile(FileName);
+    Compile(Lines.Text);
+  finally
+    Lines.Free;
+  end;
+end;
+
+function TAssembler.ParseStr(var Text: string; Separator: string): string;
+var
+  P: Integer;
+begin
+  P := Pos(Separator, Text);
+  if P > 0 then begin
+    Result := Trim(Copy(Text, 1, P - 1));
+    Text := Trim(Copy(Text, P + 1, MaxInt));
+  end else begin
+    Result := Trim(Text);
+    Text := '';
+  end;
 end;
 
 constructor TAssembler.Create;
 begin
-  Lines := TStringList.Create;
+  Parser := TParser.Create;
+  Parser.OnError := Error;
+  Message := TMessages.Create;
+  Memory := TMemory.Create;
+  InstructionSet := TInstructionSet.Create;
+  Labels := TDictionary<string, TInt>.Create;
+  LabelRefs := TList<TLabelRef>.Create;
+  Variables := TDictionary<string, TInt>.Create;
 end;
 
 destructor TAssembler.Destroy;
 begin
-  FreeAndNil(Lines);
+  FreeAndNil(Variables);
+  FreeAndNil(Labels);
+  FreeAndNil(LabelRefs);
+  FreeAndNil(InstructionSet);
+  FreeAndNil(Memory);
+  FreeAndNil(Message);
+  FreeAndNil(Parser);
   inherited;
 end;

branches/bigint/BigIntVM.lpi

@@ -118 +118 @@
         <IsPartOfProject Value="True"/>
       </Unit>
+      <Unit>
+        <Filename Value="Instructions.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Parser.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Message.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Example.asm"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
     </Units>
   </ProjectOptions>

branches/bigint/BigIntVM.lpr

@@ -10 +10 @@
   Interfaces, // this includes the LCL widgetset
   Forms, FormMain, Cpu, Memory, Int, Machine, DeviceManager, Screen, Console,
-  Device, Assembler
+  Device, Assembler, Instructions, Parser, Message
   { you can add units after this };
 

branches/bigint/FormMain.pas

@@ -5 +5 @@
 uses
   Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls, Machine, Int,
-  Cpu;
+  Cpu, Assembler;
 
 type
@@ -45 +45 @@
 procedure TFormMain.FormShow(Sender: TObject);
 var
-  Label1: TInt;
+  Assembler: TAssembler;
+  Lines: TStringList;
 begin
-  with Machine.Memory do begin
-    WritePos(TInt(inLoadConst));
-    WritePos(1000);
-    WritePos(Ord('A'));
+  Lines := TStringList.Create;
+  Lines.LoadFromFile('Example.asm');
 
-    WritePos(TInt(inLoadConst));
-    WritePos(1001);
-    WritePos(20);
+  Assembler := TAssembler.Create;
+  with Assembler do begin
+    Compile(Lines.Text);
+    Machine.Memory.CopyFrom(Memory, 0, 0, Memory.Size);
+    Free;
+  end;
 
-    Label1 := Position;
+  Lines.Free;
 
-    WritePos(TInt(inOutput));
-    WritePos(0);
-    WritePos(1000);
-
-    WritePos(TInt(inInc));
-    WritePos(1000);
-
-    WritePos(TInt(inDec));
-    WritePos(1001);
-
-    WritePos(TInt(inJumpNotZero));
-    WritePos(1001);
-    WritePos(Label1);
-
-    WritePos(TInt(inHalt));
-  end;
   Machine.Run;
 end;

branches/bigint/Memory.pas

@@ -21 +21 @@
     procedure WritePos(Data: TInt);
     function ReadPos: TInt;
+    procedure CopyFrom(Source: TMemory; Dst, Src, Count: TInt);
+    procedure WriteStringPos(Value: string);
     property Size: TInt read GetSize write SetSize;
     property Position: TInt read FPosition write FPosition;
+    property Items[Index: TInt]: TInt read Read write Write; default;
   end;
 
@@ -62 +65 @@
 end;
 
+procedure TMemory.CopyFrom(Source: TMemory; Dst, Src, Count: TInt);
+var
+  I: Integer;
+begin
+  for I := 0 to Count - 1 do begin
+    Write(Dst, Source.Read(Src));
+    Inc(Dst);
+    Inc(Src);
+  end;
+end;
+
+procedure TMemory.WriteStringPos(Value: string);
+var
+  I: Integer;
+begin
+  if Length(Value) > 0 then begin
+    if Position + Length(Value) > Size then Size := Position + Length(Value);
+    for I := 0 to Length(Value) - 1 do
+      Items[Position + I] := Ord(Value[I + 1]);
+    Inc(FPosition, Length(Value));
+  end;
+end;
+
 end.