@ -17,6 +17,8 @@
package asm package asm
import ( import (
"encoding/hex"
"errors"
"fmt" "fmt"
"math/big" "math/big"
"os" "os"
@ -30,7 +32,7 @@ import (
// and holds the tokens for the program.
// and holds the tokens for the program.
type Compiler struct { type Compiler struct {
tokens [ ] token tokens [ ] token
binary [ ] interface { } out [ ] byte
labels map [ string ] int labels map [ string ] int
@ -50,12 +52,10 @@ func NewCompiler(debug bool) *Compiler {
// Feed feeds tokens in to ch and are interpreted by
// Feed feeds tokens in to ch and are interpreted by
// the compiler.
// the compiler.
//
//
// feed is the first pass in the compile stage as it
// feed is the first pass in the compile stage as it collects the used labels in the
// collects the used labels in the program and keeps a
// program and keeps a program counter which is used to determine the locations of the
// program counter which is used to determine the locations
// jump dests. The labels can than be used in the second stage to push labels and
// of the jump dests. The labels can than be used in the
// determine the right position.
// second stage to push labels and determine the right
// position.
func ( c * Compiler ) Feed ( ch <- chan token ) { func ( c * Compiler ) Feed ( ch <- chan token ) {
var prev token var prev token
for i := range ch { for i := range ch {
@ -79,7 +79,6 @@ func (c *Compiler) Feed(ch <-chan token) {
c . pc ++ c . pc ++
} }
} }
c . tokens = append ( c . tokens , i ) c . tokens = append ( c . tokens , i )
prev = i prev = i
} }
@ -88,12 +87,11 @@ func (c *Compiler) Feed(ch <-chan token) {
} }
} }
// Compile compiles the current tokens and returns a
// Compile compiles the current tokens and returns a binary string that can be interpreted
// binary string that can be interpreted by the EVM
// by the EVM and an error if it failed.
// and an error if it failed.
//
//
// compile is the second stage in the compile phase
// compile is the second stage in the compile phase which compiles the tokens to EVM
// which compiles the tokens to EVM instructions.
// instructions.
func ( c * Compiler ) Compile ( ) ( string , [ ] error ) { func ( c * Compiler ) Compile ( ) ( string , [ ] error ) {
var errors [ ] error var errors [ ] error
// continue looping over the tokens until
// continue looping over the tokens until
@ -105,16 +103,8 @@ func (c *Compiler) Compile() (string, []error) {
} }
// turn the binary to hex
// turn the binary to hex
var bin strings . Builder h := hex . EncodeToString ( c . out )
for _ , v := range c . binary { return h , errors
switch v := v . ( type ) {
case vm . OpCode :
bin . WriteString ( fmt . Sprintf ( "%x" , [ ] byte { byte ( v ) } ) )
case [ ] byte :
bin . WriteString ( fmt . Sprintf ( "%x" , v ) )
}
}
return bin . String ( ) , errors
} }
// next returns the next token and increments the
// next returns the next token and increments the
@ -156,87 +146,114 @@ func (c *Compiler) compileLine() error {
return nil return nil
} }
// compileNumber compiles the number to bytes
// parseNumber compiles the number to bytes
func ( c * Compiler ) compileNumber ( element token ) { func parseNumber ( tok token ) ( [ ] byte , error ) {
num := math . MustParseBig256 ( element . text ) . Bytes ( ) if tok . typ != number {
if len ( num ) == 0 { panic ( "parseNumber of non-number token" )
num = [ ] byte { 0 } }
num , ok := math . ParseBig256 ( tok . text )
if ! ok {
return nil , errors . New ( "invalid number" )
} }
c . pushBin ( num ) bytes := num . Bytes ( )
if len ( bytes ) == 0 {
bytes = [ ] byte { 0 }
}
return bytes , nil
} }
// compileElement compiles the element (push & label or both)
// compileElement compiles the element (push & label or both)
// to a binary representation and may error if incorrect statements
// to a binary representation and may error if incorrect statements
// where fed.
// where fed.
func ( c * Compiler ) compileElement ( element token ) error { func ( c * Compiler ) compileElement ( element token ) error {
// check for a jump. jumps must be read and compiled
switch {
// from right to left.
case isJump ( element . text ) :
if isJump ( element . text ) { return c . compileJump ( element . text )
rvalue := c . next ( ) case isPush ( element . text ) :
switch rvalue . typ { return c . compilePush ( )
case number : default :
// TODO figure out how to return the error properly
c . outputOpcode ( toBinary ( element . text ) )
c . compileNumber ( rvalue )
case stringValue :
// strings are quoted, remove them.
c . pushBin ( rvalue . text [ 1 : len ( rvalue . text ) - 2 ] )
case label :
c . pushBin ( vm . PUSH4 )
pos := big . NewInt ( int64 ( c . labels [ rvalue . text ] ) ) . Bytes ( )
pos = append ( make ( [ ] byte , 4 - len ( pos ) ) , pos ... )
c . pushBin ( pos )
case lineEnd :
c . pos --
default :
return compileErr ( rvalue , rvalue . text , "number, string or label" )
}
// push the operation
c . pushBin ( toBinary ( element . text ) )
return nil return nil
} else if isPush ( element . text ) { }
// handle pushes. pushes are read from left to right.
}
var value [ ] byte
rvalue := c . next ( ) func ( c * Compiler ) compileJump ( jumpType string ) error {
switch rvalue . typ { rvalue := c . next ( )
case number : switch rvalue . typ {
value = math . MustParseBig256 ( rvalue . text ) . Bytes ( ) case number :
if len ( value ) == 0 { numBytes , err := parseNumber ( rvalue )
value = [ ] byte { 0 } if err != nil {
} return err
case stringValue :
value = [ ] byte ( rvalue . text [ 1 : len ( rvalue . text ) - 1 ] )
case label :
value = big . NewInt ( int64 ( c . labels [ rvalue . text ] ) ) . Bytes ( )
value = append ( make ( [ ] byte , 4 - len ( value ) ) , value ... )
default :
return compileErr ( rvalue , rvalue . text , "number, string or label" )
} }
c . outputBytes ( numBytes )
if len ( value ) > 32 { case stringValue :
return fmt . Errorf ( "%d type error: unsupported string or number with size > 32" , rvalue . lineno ) // strings are quoted, remove them.
} str := rvalue . text [ 1 : len ( rvalue . text ) - 2 ]
c . outputBytes ( [ ] byte ( str ) )
case label :
c . outputOpcode ( vm . PUSH4 )
pos := big . NewInt ( int64 ( c . labels [ rvalue . text ] ) ) . Bytes ( )
pos = append ( make ( [ ] byte , 4 - len ( pos ) ) , pos ... )
c . outputBytes ( pos )
case lineEnd :
// push without argument is supported, it just takes the destination from the stack.
c . pos --
c . pushBin ( vm . OpCode ( int ( vm . PUSH1 ) - 1 + len ( value ) ) ) default :
c . pushBin ( value ) return compileErr ( rvalue , rvalue . text , "number, string or label" )
} else {
c . pushBin ( toBinary ( element . text ) )
} }
// push the operation
c . outputOpcode ( toBinary ( jumpType ) )
return nil
}
func ( c * Compiler ) compilePush ( ) error {
// handle pushes. pushes are read from left to right.
var value [ ] byte
rvalue := c . next ( )
switch rvalue . typ {
case number :
value = math . MustParseBig256 ( rvalue . text ) . Bytes ( )
if len ( value ) == 0 {
value = [ ] byte { 0 }
}
case stringValue :
value = [ ] byte ( rvalue . text [ 1 : len ( rvalue . text ) - 1 ] )
case label :
value = big . NewInt ( int64 ( c . labels [ rvalue . text ] ) ) . Bytes ( )
value = append ( make ( [ ] byte , 4 - len ( value ) ) , value ... )
default :
return compileErr ( rvalue , rvalue . text , "number, string or label" )
}
if len ( value ) > 32 {
return fmt . Errorf ( "%d: string or number size > 32 bytes" , rvalue . lineno + 1 )
}
c . outputOpcode ( vm . OpCode ( int ( vm . PUSH1 ) - 1 + len ( value ) ) )
c . outputBytes ( value )
return nil return nil
} }
// compileLabel pushes a jumpdest to the binary slice.
// compileLabel pushes a jumpdest to the binary slice.
func ( c * Compiler ) compileLabel ( ) { func ( c * Compiler ) compileLabel ( ) {
c . pushBin ( vm . JUMPDEST ) c . outputOpcode ( vm . JUMPDEST )
}
func ( c * Compiler ) outputOpcode ( op vm . OpCode ) {
if c . debug {
fmt . Printf ( "%d: %v\n" , len ( c . out ) , op )
}
c . out = append ( c . out , byte ( op ) )
} }
// pushBin pushes the value v to the binary stack.
// output pushes the value v to the binary stack.
func ( c * Compiler ) pushBin ( v interface { } ) { func ( c * Compiler ) outputBytes ( b [ ] byte ) {
if c . debug { if c . debug {
fmt . Printf ( "%d: %v\n" , len ( c . binary ) , v ) fmt . Printf ( "%d: %x \n" , len ( c . out ) , b )
} }
c . binary = append ( c . binary , v ) c . out = append ( c . out , b ... )
} }
// isPush returns whether the string op is either any of
// isPush returns whether the string op is either any of
@ -263,13 +280,13 @@ type compileError struct {
} }
func ( err compileError ) Error ( ) string { func ( err compileError ) Error ( ) string {
return fmt . Sprintf ( "%d syntax error: unexpected %v, expected %v" , err . lineno , err . got , err . want ) return fmt . Sprintf ( "%d: syntax error: unexpected %v, expected %v" , err . lineno , err . got , err . want )
} }
func compileErr ( c token , got , want string ) error { func compileErr ( c token , got , want string ) error {
return compileError { return compileError {
got : got , got : got ,
want : want , want : want ,
lineno : c . lineno , lineno : c . lineno + 1 ,
} }
} }
Felix Lange
1 year ago
committed by
GitHub