Add support for register dereferencing in the first operand of the mo…

…ve instruction.

ast/ast.go

@@ -62,7 +62,8 @@ func (os InstructionStatement) statementNode()       {}
 func (os InstructionStatement) TokenLiteral() string { return os.Token.Literal }
 
 type RegisterLiteral struct {
-	Token token.Token // the token.REGISTER token
+	Token        token.Token // the token.REGISTER token
+	Dereferenced bool
 }
 
 func (rl RegisterLiteral) expressionNode()      {}

gmachine.go

@@ -30,6 +30,7 @@ const (
 	OpADDA
 	OpMULA
 	OpMVAX
+	OpMVIAX
 	OpMVAY
 	OpMVAV
 	OpMVVA
@@ -68,28 +69,29 @@ var registers = map[string]Word{
 }
 
 var opcodes = map[string]Word{
-	"HALT": OpHALT,
-	"NOOP": OpNOOP,
-	"OUTA": OpOUTA,
-	"INCA": OpINCA,
-	"INCX": OpINCX,
-	"INCY": OpINCY,
-	"DECA": OpDECA,
-	"DECX": OpDECX,
-	"DECY": OpDECY,
-	"ADDA": OpADDA,
-	"MULA": OpMULA,
-	"MVAX": OpMVAX,
-	"MVAY": OpMVAY,
-	"MVAV": OpMVAV,
-	"MVVA": OpMVVA,
-	"SETA": OpSETA,
-	"SETX": OpSETX,
-	"SETY": OpSETY,
-	"PSHA": OpPSHA,
-	"POPA": OpPOPA,
-	"JUMP": OpJUMP,
-	"JXNZ": OpJXNZ,
+	"HALT":  OpHALT,
+	"NOOP":  OpNOOP,
+	"OUTA":  OpOUTA,
+	"INCA":  OpINCA,
+	"INCX":  OpINCX,
+	"INCY":  OpINCY,
+	"DECA":  OpDECA,
+	"DECX":  OpDECX,
+	"DECY":  OpDECY,
+	"ADDA":  OpADDA,
+	"MULA":  OpMULA,
+	"MVAX":  OpMVAX,
+	"MVIAX": OpMVIAX,
+	"MVAY":  OpMVAY,
+	"MVAV":  OpMVAV,
+	"MVVA":  OpMVVA,
+	"SETA":  OpSETA,
+	"SETX":  OpSETX,
+	"SETY":  OpSETY,
+	"PSHA":  OpPSHA,
+	"POPA":  OpPOPA,
+	"JUMP":  OpJUMP,
+	"JXNZ":  OpJXNZ,
 }
 
 type Word uint64
@@ -169,6 +171,8 @@ func (g *Machine) Run() {
 			}
 		case OpMVAX:
 			g.X = g.A
+		case OpMVIAX:
+			g.X = g.Memory[g.MemOffset+g.A]
 		case OpMVAY:
 			g.Y = g.A
 		case OpMVAV:
@@ -333,11 +337,16 @@ func assembleInstructionStatement(stmt ast.InstructionStatement, program []Word,
 
 	switch instruction {
 	case "MOVE":
+		opcodeStr := "MV"
 		switch operand1 := stmt.Operand1.(type) {
 		case ast.RegisterLiteral:
+			if operand1.Dereferenced {
+				opcodeStr += "I"
+			}
+			opcodeStr += operand1.TokenLiteral()
 			switch operand2 := stmt.Operand2.(type) {
 			case ast.RegisterLiteral:
-				opcodeStr := fmt.Sprintf("%s%s%s", "MV", operand1.TokenLiteral(), operand2.TokenLiteral())
+				opcodeStr += operand2.TokenLiteral()
 				opcode, ok := opcodes[opcodeStr]
 				if !ok {
 					return nil, nil, fmt.Errorf("%w: %s at line %d", ErrUnknownOpcode, opcodeStr, stmt.Token.Line)
@@ -359,9 +368,10 @@ func assembleInstructionStatement(stmt ast.InstructionStatement, program []Word,
 				program = append(program, Word(0))
 			}
 		case ast.Identifier:
+			opcodeStr += "V"
 			switch operand2 := stmt.Operand2.(type) {
 			case ast.RegisterLiteral:
-				opcodeStr := fmt.Sprintf("%s%s%s", "MV", "V", operand2.TokenLiteral())
+				opcodeStr += operand2.TokenLiteral()
 				opcode, ok := opcodes[opcodeStr]
 				if !ok {
 					return nil, nil, fmt.Errorf("%w: %s at line %d", ErrUnknownOpcode, opcodeStr, stmt.Token.Line)

gmachine_test.go

@@ -607,6 +607,25 @@ func TestMOVE_FailsForUnknownIdentifier(t *testing.T) {
 	}
 }
 
+func TestMOVE_CopiesDereferencedRegisterAToRegisterX(t *testing.T) {
+	t.Parallel()
+	g := gmachine.New(nil)
+	err := assembleAndRunFromString(g, `
+JUMP start
+VARB num 42
+.start
+SETA num
+MOVE *A -> X
+`)
+	if err != nil {
+		t.Fatal("didn't expect an error:", err)
+	}
+	var wantX gmachine.Word = 42
+	if wantX != g.X {
+		t.Errorf("want %d, got %d", wantX, g.X)
+	}
+}
+
 func TestADDAX(t *testing.T) {
 	t.Parallel()
 	g := gmachine.New(nil)

parser/parser.go

@@ -106,6 +106,15 @@ func (p *Parser) expectOneOf(tokTypes ...token.TokenType) ast.Expression {
 	}
 
 	switch p.curToken.Type {
+	case token.ASTERISK:
+		expr := p.expectOneOf(token.REGISTER)
+		if expr == nil {
+			p.errors = append(p.errors, fmt.Errorf("%w: expected one of %+v, got %s at line %d", ErrInvalidSyntax, tokTypes, p.curToken.Type, p.curToken.Line))
+			return nil
+		}
+		regLiteral := expr.(ast.RegisterLiteral)
+		regLiteral.Dereferenced = true
+		return regLiteral
 	case token.REGISTER:
 		return p.parseRegisterLiteral()
 	case token.IDENT:
@@ -123,7 +132,7 @@ func (p *Parser) parseInstructionStatement() ast.Statement {
 	stmt := ast.InstructionStatement{Token: p.curToken}
 
 	if stmt.TokenLiteral() == "MOVE" {
-		stmt.Operand1 = p.expectOneOf(token.REGISTER, token.IDENT)
+		stmt.Operand1 = p.expectOneOf(token.ASTERISK, token.REGISTER, token.IDENT)
 		p.expectOneOf(token.ARROW)
 		stmt.Operand2 = p.expectOneOf(token.REGISTER, token.IDENT)
 	}

parser/parser_test.go

@@ -420,6 +420,7 @@ func TestParseProgram_ParsesInstructionsWithARegisterLiteralOperands(t *testing.
 
 	input := `
 MOVE A -> X
+MOVE *A -> X
 MOVE A -> Y
 ADDA X
 ADDA Y
@@ -465,25 +466,33 @@ ADDA Y
 					Literal: "A",
 					Line:    3,
 				},
+				Dereferenced: true,
 			},
 			Operand2: ast.RegisterLiteral{
 				Token: token.Token{
 					Type:    token.REGISTER,
-					Literal: "Y",
+					Literal: "X",
 					Line:    3,
 				},
 			},
 		},
 		ast.InstructionStatement{
 			Token: token.Token{
 				Type:    token.INSTRUCTION,
-				Literal: "ADDA",
+				Literal: "MOVE",
 				Line:    4,
 			},
 			Operand1: ast.RegisterLiteral{
 				Token: token.Token{
 					Type:    token.REGISTER,
-					Literal: "X",
+					Literal: "A",
+					Line:    4,
+				},
+			},
+			Operand2: ast.RegisterLiteral{
+				Token: token.Token{
+					Type:    token.REGISTER,
+					Literal: "Y",
 					Line:    4,
 				},
 			},
@@ -497,11 +506,25 @@ ADDA Y
 			Operand1: ast.RegisterLiteral{
 				Token: token.Token{
 					Type:    token.REGISTER,
-					Literal: "Y",
+					Literal: "X",
 					Line:    5,
 				},
 			},
 		},
+		ast.InstructionStatement{
+			Token: token.Token{
+				Type:    token.INSTRUCTION,
+				Literal: "ADDA",
+				Line:    6,
+			},
+			Operand1: ast.RegisterLiteral{
+				Token: token.Token{
+					Type:    token.REGISTER,
+					Literal: "Y",
+					Line:    6,
+				},
+			},
+		},
 	}
 
 	got := program.Statements

testdata/gc.txtar

@@ -9,6 +9,6 @@ SETA 42
 OUTA
 
 -- want --
-0000000 0000 0000 0000 1000 0000 0000 0000 2a00
+0000000 0000 0000 0000 1100 0000 0000 0000 2a00
 0000010 0000 0000 0000 0300                    
 0000018