Changeset 59 for branches/ByteArray/Assembler.pas

Timestamp:

Nov 25, 2023, 11:47:52 PM (12 months ago)

Author:

chronos

Message:

• Fixed: Assembler and disassembler to work correctly with supported instructions.

File:

• branches/ByteArray/Assembler.pas (modified) (15 diffs)

branches/ByteArray/Assembler.pas

@@ -14 +14 @@
     RefPos: Integer;
     TextPos: TPoint;
-    class function Create(LabelName: string; RefPos: Integer): TLabelRef; static;
+    class function Create(LabelName: string; RefPos: Integer; TextPos: TPoint): TLabelRef; static;
   end;
 
@@ -23 +23 @@
     FOnError: TErrorEvent;
     Parser: TParser;
+    InstDataWidth: TBigIntSize;
+    InstAddressWidth: TBigIntSize;
     function ParseVar: Boolean;
     function ParseDb: Boolean;
     function ParseOrg: Boolean;
     function ParseInstruction: Boolean;
+    function ParseInstructionParameter(ParamType: TParamType; Memory: TMemory): Boolean;
     function ParseLabel: Boolean;
     procedure UpdateLabelRefs;
     function ParseNumParam(out Number: TBigInt): Boolean;
     function ParseReg(out RegIndex: TRegIndex): Boolean;
+    function ParseDataWidth(out Size: TBigIntSize): Boolean;
+    function ParseAddressWidth(out Size: TBigIntSize): Boolean;
   public
-    InstructionSet: TInstructionSet;
+    InstructionSet: TInstructionInfos;
     Memory: TMemory;
     Labels: TDictionary<string, TBigInt>;
@@ -38 +43 @@
     Variables: TDictionary<string, TBigInt>;
     Messages: TMessages;
+    DataWidth: TBigIntSize;
+    AddressWidth: TBigIntSize;
     procedure Error(Text: string; Pos: TPoint);
     procedure Compile(Source: string);
@@ -58 +65 @@
   SExpectedVariableValue = 'Expected variable value.';
   SUnsupportedParameterType = 'Unsupported parameter type';
+  SDuplicateLabel = 'Duplicate label %s.';
+  SLabelReferencedButNotDefined = 'Label %s referenced but not defined.';
+  SDuplicateVariableName = 'Duplicate variable name %s';
+  SExpectedParameter = 'Expected parameter';
+  SExpectedParameterType = 'Expected parameter type [%s]';
+  SExpectedNumberButFound = 'Expected number but %s found.';
 
 { TLabelRef }
 
-class function TLabelRef.Create(LabelName: string; RefPos: Integer): TLabelRef;
+class function TLabelRef.Create(LabelName: string; RefPos: Integer; TextPos: TPoint): TLabelRef;
 begin
   Result.LabelName := LabelName;
   Result.RefPos := RefPos;
+  Result.TextPos := TextPos;
 end;
 
@@ -77 +91 @@
     if Labels.TryGetValue(LabelRefs[I].LabelName, Addr) then
       Memory.Write(LabelRefs[I].RefPos, 1, Addr)
-      else Error('Label ' + LabelRefs[I].LabelName + ' referenced but not defined.', LabelRefs[I].TextPos);
+      else Error(Format(SLabelReferencedButNotDefined, [LabelRefs[I].LabelName]),
+        LabelRefs[I].TextPos);
   end;
 end;
@@ -84 +99 @@
 var
   Token: TToken;
-begin
+  LastPos: TParserPos;
+begin
+  LastPos := Parser.Pos;
   Result := False;
   Token := Parser.ReadNext;
@@ -99 +116 @@
       Result := True;
     end else begin
-      LabelRefs.Add(TLabelRef.Create(Token.Value, Memory.Position));
+      LabelRefs.Add(TLabelRef.Create(Token.Value, Memory.Position + 1, Parser.Pos.Pos));
       Number := 0;
       Result := True;
     end;
-  end else Error('Unexpected token ' + Token.Value + '.', Token.Pos);
+  end;
+  if not Result then Parser.Pos := LastPos;
 end;
 
@@ -110 +128 @@
   LastPos: TParserPos;
   Token: TToken;
+  Index: Integer;
 begin
   Result := False;
   LastPos := Parser.Pos;
   Token := Parser.ReadNext;
-  if (Length(Token.Value) = 1) and (Token.Value[1] in ['A'..'H']) then begin
-    RegIndex := TRegIndex(Ord(Token.Value[1]) - Ord('A'));
-    Result := True;
-  end else Parser.Pos := LastPos;
+  if (Length(Token.Value) >= 2) and (Token.Value[1] = 'R') then begin
+    if TryStrToInt(Copy(Token.Value, 2, MaxInt), Index) then begin
+      RegIndex := Index;
+      Result := True;
+    end;
+  end;
+  if not Result then Parser.Pos := LastPos;
+end;
+
+function TAssembler.ParseDataWidth(out Size: TBigIntSize): Boolean;
+var
+  LastPos: TParserPos;
+  Token: TToken;
+  Index: Integer;
+begin
+  Result := False;
+  LastPos := Parser.Pos;
+  Token := Parser.ReadNext;
+  if (Length(Token.Value) >= 2) and (Token.Value[1] = 'D') then begin
+    if TryStrToInt(Copy(Token.Value, 2, MaxInt), Index) then begin
+      Size := Index;
+      Result := True;
+    end;
+  end;
+  if not Result then Parser.Pos := LastPos;
+end;
+
+function TAssembler.ParseAddressWidth(out Size: TBigIntSize): Boolean;
+var
+  LastPos: TParserPos;
+  Token: TToken;
+  Index: Integer;
+begin
+  Result := False;
+  LastPos := Parser.Pos;
+  Token := Parser.ReadNext;
+  if (Length(Token.Value) >= 2) and (Token.Value[1] = 'A') then begin
+    if TryStrToInt(Copy(Token.Value, 2, MaxInt), Index) then begin
+      Size := Index;
+      Result := True;
+    end;
+  end;
+  if not Result then Parser.Pos := LastPos;
 end;
 
@@ -134 +192 @@
   Labels.Clear;
   LabelRefs.Clear;
+  Variables.Clear;
   Parser.Reset;
   Parser.Source := Source;
@@ -172 +231 @@
             if TryStrToBigInt(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);
+            else Error(SExpectedNumber, TokenValue.Pos);
+          end else Error(Format(SDuplicateVariableName, [TokenName.Value]), TokenName.Pos);
         end else Error(SExpectedVariableValue, TokenValue.Pos);
       end else Error(SExpectedVariableName, TokenName.Pos);
@@ -199 +258 @@
         if Token.Kind = tkString then begin
           Memory.WriteStringPos(Token.Value);
-        end else raise Exception.Create('Expected parameter');
+        end else
+        if Token.Kind = tkEof then
+        else if Token.Kind = tkEol then
+        else raise Exception.Create(SExpectedParameter);
       end;
       if Parser.CheckNextAndRead(tkSpecialSymbol, ',') then begin
@@ -219 +281 @@
     if Token.Kind = tkNumber then begin
       Memory.Position := StrToInt(Token.Value);
-    end else Error('Expected number but ' + Token.Value + ' found.', Token.Pos);
+    end else Error(Format(SExpectedNumberButFound, [Token.Value]), Token.Pos);
   end;
 end;
@@ -225 +287 @@
 function TAssembler.ParseInstruction: Boolean;
 var
-  InstructionInfo: TInstructionInfo;
+  InstructionInfos: TInstructionInfos;
   I: Integer;
   Token: TToken;
   LastPos: TParserPos;
+  J: Integer;
+  AllowedParams: set of TParamType;
+  ParamType: TParamType;
+  ParamOk: Boolean;
+  LastMessagesCount: Integer;
+  Text: string;
+  EmptyParam: Boolean;
+  InstructionMemory: TMemory;
+  ParamMemory: TMemory;
+begin
+  Result := False;
+  LastPos := Parser.Pos;
+  Token := Parser.ReadNext;
+  InstructionInfos := InstructionSet.SearchByNameMultiple(Token.Value);
+  InstDataWidth := DataWidth;
+  InstAddressWidth := AddressWidth;
+  InstructionMemory := TMemory.Create;
+  InstructionMemory.Grow := True;
+  ParamMemory := TMemory.Create;
+  ParamMemory.Grow := True;
+  J := 0;
+  if InstructionInfos.Count > 0 then
+  repeat
+    EmptyParam := False;
+
+    if J > 0 then
+      Parser.Expect(tkSpecialSymbol, ',');
+
+    // Get allowed parameters
+    AllowedParams := [];
+    for I := 0 to InstructionInfos.Count - 1 do begin
+      if Length(InstructionInfos[I].Params) > J then
+        AllowedParams := AllowedParams + [InstructionInfos[I].Params[J]]
+        else EmptyParam := True;
+    end;
+
+    if AllowedParams <> [] then begin
+      ParamOk := False;
+      for ParamType := Low(TParamType) to High(TParamType) do begin
+        if ParamType in AllowedParams then begin
+          LastMessagesCount := Messages.Count;
+          ParamMemory.Clear;
+          if ParseInstructionParameter(ParamType, ParamMemory) and
+            (LastMessagesCount = Messages.Count) then begin
+            ParamOk := True;
+            InstructionMemory.WriteMemoryPos(ParamMemory);
+            Break;
+          end else Messages.Count := LastMessagesCount;
+        end;
+      end;
+      if not ParamOk then begin
+        if EmptyParam then begin
+          ParamType := ptNone;
+        end else begin
+          Text := '';
+          for ParamType := Low(TParamType) to High(TParamType) do begin
+            if ParamType in AllowedParams then begin
+              if Text <> '' then Text := Text + ' or ';
+              Text := Text + ParamTypeString[ParamType]
+            end;
+          end;
+
+          Error(Format(SExpectedParameterType, [Text]), Parser.Pos.Pos);
+          Break;
+        end;
+      end;
+    end;
+
+    // Remove not matching instruction infos
+    for I := InstructionInfos.Count - 1 downto 0 do
+      if (Length(InstructionInfos[I].Params) > J) and
+        (InstructionInfos[I].Params[J] <> ParamType) then InstructionInfos.Delete(I);
+
+    if (InstructionInfos.Count = 1) and (J >= (Length(InstructionInfos[0].Params) - 1)) then begin
+      Memory.WritePos(1, Byte(InstructionInfos[0].Instruction));
+      Memory.WriteMemoryPos(InstructionMemory);
+      Result := True;
+      Break;
+    end;
+
+    Inc(J);
+  until False;
+
+  if not Result then Parser.Pos := LastPos;
+  FreeAndNil(ParamMemory);
+  FreeAndNil(InstructionMemory);
+end;
+
+function TAssembler.ParseInstructionParameter(ParamType: TParamType; Memory: TMemory): Boolean;
+var
+  LastPos: TParserPos;
+  I: Integer;
   RegIndex: TRegIndex;
   Number: TBigInt;
-begin
-  Result := False;
-  LastPos := Parser.Pos;
-  Token := Parser.ReadNext;
-  InstructionInfo := InstructionSet.SearchName(Token.Value);
-  if Assigned(InstructionInfo) then begin
-    Result := True;
-    Memory.WritePos(1, Integer(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
-        if ParseNumParam(Number) then Memory.WritePos(1, Number)
-          else Error(SExpectedNumber, Token.Pos);
-      end else
-      if InstructionInfo.Params[I] = ptReg then begin
-        if ParseReg(RegIndex) then Memory.WritePos(1, Byte(RegIndex))
-          else Error(SExpectedRegisterName, Token.Pos);
-      end else
-      if InstructionInfo.Params[I] = ptRegIndirect then begin
-        Parser.Expect(tkSpecialSymbol, '(');
-        if ParseReg(RegIndex) then Memory.WritePos(1, Byte(RegIndex))
-          else Error(SExpectedRegisterName, Token.Pos);
-        Parser.Expect(tkSpecialSymbol, ')');
-      end else
-      if InstructionInfo.Params[I] = ptRegIndirectIndex then begin
-        Parser.Expect(tkSpecialSymbol, '(');
-        if ParseReg(RegIndex) then begin
-          Memory.WritePos(1, Byte(RegIndex));
-          Parser.Expect(tkSpecialSymbol, '+');
-          Token := Parser.ReadNext;
-          if ParseNumParam(Number) then Memory.WritePos(1, Number)
-            else Error(SExpectedNumericIndex, Token.Pos);
-        end else Error(SExpectedRegisterName, Token.Pos);
-        Parser.Expect(tkSpecialSymbol, ')');
-      end else Error(SUnsupportedParameterType, Token.Pos);
+  Token: TToken;
+begin
+  LastPos := Parser.Pos;
+  Result := True;
+  case ParamType of
+    ptData: begin
+      if ParseNumParam(Number) then Memory.WritePos(InstDataWidth, Number)
+        else begin
+          Error(SExpectedNumber, Parser.Pos.Pos);
+          Result := False;
+        end;
+    end;
+    ptAddress: begin
+      if ParseNumParam(Number) then Memory.WritePos(InstAddressWidth, Number)
+        else begin
+          Error(SExpectedNumber, Parser.Pos.Pos);
+          Result := False;
+        end;
+    end;
+    ptReg: begin
+      if ParseReg(RegIndex) then Memory.WritePos(1, Byte(RegIndex))
+        else begin
+          Error(SExpectedRegisterName, Parser.Pos.Pos);
+          Result := False;
+        end;
+    end;
+    ptRegIndirect: begin
+      if not Parser.Expect(tkSpecialSymbol, '(') then Result := False;
+      if ParseReg(RegIndex) then Memory.WritePos(1, Byte(RegIndex))
+        else begin
+          Error(SExpectedRegisterName, Parser.Pos.Pos);
+          Result := False;
+        end;
+      if not Parser.Expect(tkSpecialSymbol, ')') then Result := False;;
+    end;
+    ptRegIndirectIndex: begin
+      if not Parser.Expect(tkSpecialSymbol, '(') then Result := False;
+      if ParseReg(RegIndex) then begin
+        Memory.WritePos(1, Byte(RegIndex));
+        if not Parser.Expect(tkSpecialSymbol, '+') then Result := False;
+        if ParseNumParam(Number) then Memory.WritePos(InstAddressWidth, Number)
+          else begin
+            Error(SExpectedNumericIndex, Parser.Pos.Pos);
+            Result := False;
+          end;
+      end else begin
+        Error(SExpectedRegisterName, Parser.Pos.Pos);
+        Result := False;
+      end;
+      if not Parser.Expect(tkSpecialSymbol, ')') then Result := False;
+    end;
+    ptDataWidth: begin
+      if ParseDataWidth(InstDataWidth) then begin
+        Memory.WritePos(1, InstDataWidth)
+      end else begin
+        Error(SExpectedRegisterName, Parser.Pos.Pos);
+        Result := False;
+      end;
+    end;
+    ptAddressWidth: begin
+      if ParseAddressWidth(InstAddressWidth) then begin
+        Memory.WritePos(1, InstAddressWidth)
+      end else begin
+        Error(SExpectedRegisterName, Parser.Pos.Pos);
+        Result := False;
+      end;
+    end;
+    else begin
+      Result := False;
+      Error(SUnsupportedParameterType, Parser.Pos.Pos);
     end;
   end;
@@ -285 +473 @@
     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 else Error(Format(SDuplicateLabel, [Token.Value]), Token.Pos);
   end;
   if not Result then Parser.Pos := LastPos;
@@ -323 +511 @@
   Messages := TMessages.Create;
   Memory := TMemory.Create;
-  InstructionSet := TInstructionSet.Create;
+  InstructionSet := TInstructionInfos.Create;
+  InstructionSet.Init;
   Labels := TDictionary<string, TBigInt>.Create;
   LabelRefs := TList<TLabelRef>.Create;