diff --git a/core/asm/asm.go b/core/asm/asm.go
deleted file mode 100644
index fe78200999..0000000000
--- a/core/asm/asm.go
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of The go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with The go-ethereum library. If not, see .
-
-// Provides support for dealing with CVM assembly instructions (e.g., disassembling them).
-package asm
-
-import (
- "encoding/hex"
- "fmt"
-
- "github.com/CortexFoundation/CortexTheseus/core/vm"
-)
-
-// Iterator for disassembled CVM instructions
-type instructionIterator struct {
- code []byte
- pc uint64
- arg []byte
- op vm.OpCode
- error error
- started bool
-}
-
-// Create a new instruction iterator.
-func NewInstructionIterator(code []byte) *instructionIterator {
- it := new(instructionIterator)
- it.code = code
- return it
-}
-
-// Returns true if there is a next instruction and moves on.
-func (it *instructionIterator) Next() bool {
- if it.error != nil || uint64(len(it.code)) <= it.pc {
- // We previously reached an error or the end.
- return false
- }
-
- if it.started {
- // Since the iteration has been already started we move to the next instruction.
- if it.arg != nil {
- it.pc += uint64(len(it.arg))
- }
- it.pc++
- } else {
- // We start the iteration from the first instruction.
- it.started = true
- }
-
- if uint64(len(it.code)) <= it.pc {
- // We reached the end.
- return false
- }
-
- it.op = vm.OpCode(it.code[it.pc])
- if it.op.IsPush() {
- a := uint64(it.op) - uint64(vm.PUSH0)
- u := it.pc + 1 + a
- if uint64(len(it.code)) <= it.pc || uint64(len(it.code)) < u {
- it.error = fmt.Errorf("incomplete push instruction at %v", it.pc)
- return false
- }
- it.arg = it.code[it.pc+1 : u]
- } else {
- it.arg = nil
- }
- return true
-}
-
-// Returns any error that may have been encountered.
-func (it *instructionIterator) Error() error {
- return it.error
-}
-
-// Returns the PC of the current instruction.
-func (it *instructionIterator) PC() uint64 {
- return it.pc
-}
-
-// Returns the opcode of the current instruction.
-func (it *instructionIterator) Op() vm.OpCode {
- return it.op
-}
-
-// Returns the argument of the current instruction.
-func (it *instructionIterator) Arg() []byte {
- return it.arg
-}
-
-// Pretty-print all disassembled CVM instructions to stdout.
-func PrintDisassembled(code string) error {
- script, err := hex.DecodeString(code)
- if err != nil {
- return err
- }
-
- it := NewInstructionIterator(script)
- for it.Next() {
- if it.Arg() != nil && 0 < len(it.Arg()) {
- fmt.Printf("%05x: %v 0x%x\n", it.PC(), it.Op(), it.Arg())
- } else {
- fmt.Printf("%05x: %v\n", it.PC(), it.Op())
- }
- }
- return it.Error()
-}
-
-// Return all disassembled CVM instructions in human-readable format.
-func Disassemble(script []byte) ([]string, error) {
- instrs := make([]string, 0)
-
- it := NewInstructionIterator(script)
- for it.Next() {
- if it.Arg() != nil && 0 < len(it.Arg()) {
- instrs = append(instrs, fmt.Sprintf("%05x: %v 0x%x\n", it.PC(), it.Op(), it.Arg()))
- } else {
- instrs = append(instrs, fmt.Sprintf("%05x: %v\n", it.PC(), it.Op()))
- }
- }
- if err := it.Error(); err != nil {
- return nil, err
- }
- return instrs, nil
-}
diff --git a/core/asm/asm_test.go b/core/asm/asm_test.go
deleted file mode 100644
index c08f862ea9..0000000000
--- a/core/asm/asm_test.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of The go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with The go-ethereum library. If not, see .
-
-package asm
-
-import (
- "encoding/hex"
- "testing"
-)
-
-// Tests disassembling instructions
-func TestInstructionIterator(t *testing.T) {
- for i, tc := range []struct {
- want int
- code string
- wantErr string
- }{
- {2, "61000000", ""}, // valid code
- {0, "6100", "incomplete push instruction at 0"}, // invalid code
- {2, "5900", ""}, // push0
- {0, "", ""}, // empty
-
- } {
- var (
- have int
- code, _ = hex.DecodeString(tc.code)
- it = NewInstructionIterator(code)
- )
- for it.Next() {
- have++
- }
- var haveErr = ""
- if it.Error() != nil {
- haveErr = it.Error().Error()
- }
- if haveErr != tc.wantErr {
- t.Errorf("test %d: encountered error: %q want %q", i, haveErr, tc.wantErr)
- continue
- }
- if have != tc.want {
- t.Errorf("wrong instruction count, have %d want %d", have, tc.want)
- }
- }
-}
diff --git a/core/asm/compiler.go b/core/asm/compiler.go
deleted file mode 100644
index 11fd7ce5cf..0000000000
--- a/core/asm/compiler.go
+++ /dev/null
@@ -1,292 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of The go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with The go-ethereum library. If not, see .
-
-package asm
-
-import (
- "encoding/hex"
- "errors"
- "fmt"
- "math/big"
- "os"
- "strings"
-
- "github.com/CortexFoundation/CortexTheseus/common/math"
- "github.com/CortexFoundation/CortexTheseus/core/vm"
-)
-
-// Compiler contains information about the parsed source
-// and holds the tokens for the program.
-type Compiler struct {
- tokens []token
- out []byte
-
- labels map[string]int
-
- pc, pos int
-
- debug bool
-}
-
-// newCompiler returns a new allocated compiler.
-func NewCompiler(debug bool) *Compiler {
- return &Compiler{
- labels: make(map[string]int),
- debug: debug,
- }
-}
-
-// Feed feeds tokens in to ch and are interpreted by
-// the compiler.
-//
-// feed is the first pass in the compile stage as it collects the used labels in the
-// program and keeps a program counter which is used to determine the locations of the
-// jump dests. The labels can than be used in the second stage to push labels and
-// determine the right position.
-func (c *Compiler) Feed(ch <-chan token) {
- var prev token
- for i := range ch {
- switch i.typ {
- case number:
- num := math.MustParseBig256(i.text).Bytes()
- if len(num) == 0 {
- num = []byte{0}
- }
- c.pc += len(num)
- case stringValue:
- c.pc += len(i.text) - 2
- case element:
- c.pc++
- case labelDef:
- c.labels[i.text] = c.pc
- c.pc++
- case label:
- c.pc += 4
- if prev.typ == element && isJump(prev.text) {
- c.pc++
- }
- }
- c.tokens = append(c.tokens, i)
- prev = i
- }
- if c.debug {
- fmt.Fprintln(os.Stderr, "found", len(c.labels), "labels")
- }
-}
-
-// Compile compiles the current tokens and returns a binary string that can be interpreted
-// by the EVM and an error if it failed.
-//
-// compile is the second stage in the compile phase which compiles the tokens to EVM
-// instructions.
-func (c *Compiler) Compile() (string, []error) {
- var errors []error
- // continue looping over the tokens until
- // the stack has been exhausted.
- for c.pos < len(c.tokens) {
- if err := c.compileLine(); err != nil {
- errors = append(errors, err)
- }
- }
-
- // turn the binary to hex
- h := hex.EncodeToString(c.out)
- return h, errors
-}
-
-// next returns the next token and increments the
-// position.
-func (c *Compiler) next() token {
- token := c.tokens[c.pos]
- c.pos++
- return token
-}
-
-// compileLine compiles a single line instruction e.g.
-// "push 1", "jump @label".
-func (c *Compiler) compileLine() error {
- n := c.next()
- if n.typ != lineStart {
- return compileErr(n, n.typ.String(), lineStart.String())
- }
-
- lvalue := c.next()
- switch lvalue.typ {
- case eof:
- return nil
- case element:
- if err := c.compileElement(lvalue); err != nil {
- return err
- }
- case labelDef:
- c.compileLabel()
- case lineEnd:
- return nil
- default:
- return compileErr(lvalue, lvalue.text, fmt.Sprintf("%v or %v", labelDef, element))
- }
-
- if n := c.next(); n.typ != lineEnd {
- return compileErr(n, n.text, lineEnd.String())
- }
-
- return nil
-}
-
-// parseNumber compiles the number to bytes
-func parseNumber(tok token) ([]byte, error) {
- if tok.typ != number {
- panic("parseNumber of non-number token")
- }
- num, ok := math.ParseBig256(tok.text)
- if !ok {
- return nil, errors.New("invalid number")
- }
- bytes := num.Bytes()
- if len(bytes) == 0 {
- bytes = []byte{0}
- }
- return bytes, nil
-}
-
-// compileElement compiles the element (push & label or both)
-// to a binary representation and may error if incorrect statements
-// where fed.
-func (c *Compiler) compileElement(element token) error {
- switch {
- case isJump(element.text):
- return c.compileJump(element.text)
- case isPush(element.text):
- return c.compilePush()
- default:
- c.outputOpcode(toBinary(element.text))
- return nil
- }
-}
-
-func (c *Compiler) compileJump(jumpType string) error {
- rvalue := c.next()
- switch rvalue.typ {
- case number:
- numBytes, err := parseNumber(rvalue)
- if err != nil {
- return err
- }
- c.outputBytes(numBytes)
-
- case stringValue:
- // 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--
-
- default:
- return compileErr(rvalue, rvalue.text, "number, string or label")
- }
- // 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
-}
-
-// compileLabel pushes a jumpdest to the binary slice.
-func (c *Compiler) compileLabel() {
- 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))
-}
-
-// output pushes the value v to the binary stack.
-func (c *Compiler) outputBytes(b []byte) {
- if c.debug {
- fmt.Printf("%d: %x\n", len(c.out), b)
- }
- c.out = append(c.out, b...)
-}
-
-// isPush returns whether the string op is either any of
-// push(N).
-func isPush(op string) bool {
- return strings.ToUpper(op) == "PUSH"
-}
-
-// isJump returns whether the string op is jump(i)
-func isJump(op string) bool {
- return strings.ToUpper(op) == "JUMPI" || strings.ToUpper(op) == "JUMP"
-}
-
-// toBinary converts text to a vm.OpCode
-func toBinary(text string) vm.OpCode {
- return vm.StringToOp(strings.ToUpper(text))
-}
-
-type compileError struct {
- got string
- want string
-
- lineno int
-}
-
-func (err compileError) Error() string {
- return fmt.Sprintf("%d: syntax error: unexpected %v, expected %v", err.lineno, err.got, err.want)
-}
-
-func compileErr(c token, got, want string) error {
- return compileError{
- got: got,
- want: want,
- lineno: c.lineno + 1,
- }
-}
diff --git a/core/asm/compiler_test.go b/core/asm/compiler_test.go
deleted file mode 100644
index 0ca1e8198b..0000000000
--- a/core/asm/compiler_test.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of The go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with The go-ethereum library. If not, see .
-
-package asm
-
-import (
- "testing"
-)
-
-func TestCompiler(t *testing.T) {
- tests := []struct {
- input, output string
- }{
- {
- input: `
- GAS
- label:
- PUSH @label
-`,
- output: "5a5b6300000001",
- },
- {
- input: `
- PUSH @label
- label:
-`,
- output: "63000000055b",
- },
- {
- input: `
- PUSH @label
- JUMP
- label:
-`,
- output: "6300000006565b",
- },
- {
- input: `
- JUMP @label
- label:
-`,
- output: "6300000006565b",
- },
- {
- input: `
- JUMP @label
-label: ;; comment
- ADD ;; comment
-`,
- output: "6300000006565b01",
- },
- }
- for _, test := range tests {
- ch := Lex([]byte(test.input), false)
- c := NewCompiler(false)
- c.Feed(ch)
- output, err := c.Compile()
- if len(err) != 0 {
- t.Errorf("compile error: %v\ninput: %s", err, test.input)
- continue
- }
- if output != test.output {
- t.Errorf("incorrect output\ninput: %sgot: %s\nwant: %s\n", test.input, output, test.output)
- }
- }
-}
diff --git a/core/asm/lex_test.go b/core/asm/lex_test.go
deleted file mode 100644
index fc768134c9..0000000000
--- a/core/asm/lex_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of The go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with The go-ethereum library. If not, see .
-
-package asm
-
-import (
- "reflect"
- "testing"
-)
-
-func lexAll(src string) []token {
- ch := Lex([]byte(src), false)
-
- var tokens []token
- for i := range ch {
- tokens = append(tokens, i)
- }
- return tokens
-}
-
-func TestLexer(t *testing.T) {
- tests := []struct {
- input string
- tokens []token
- }{
- {
- input: ";; this is a comment",
- tokens: []token{{typ: lineStart}, {typ: eof}},
- },
- {
- input: "0x12345678",
- tokens: []token{{typ: lineStart}, {typ: number, text: "0x12345678"}, {typ: eof}},
- },
- {
- input: "0x123ggg",
- tokens: []token{{typ: lineStart}, {typ: number, text: "0x123"}, {typ: element, text: "ggg"}, {typ: eof}},
- },
- {
- input: "12345678",
- tokens: []token{{typ: lineStart}, {typ: number, text: "12345678"}, {typ: eof}},
- },
- {
- input: "123abc",
- tokens: []token{{typ: lineStart}, {typ: number, text: "123"}, {typ: element, text: "abc"}, {typ: eof}},
- },
- {
- input: "0123abc",
- tokens: []token{{typ: lineStart}, {typ: number, text: "0123"}, {typ: element, text: "abc"}, {typ: eof}},
- },
- {
- input: "00123abc",
- tokens: []token{{typ: lineStart}, {typ: number, text: "00123"}, {typ: element, text: "abc"}, {typ: eof}},
- },
- {
- input: "@foo",
- tokens: []token{{typ: lineStart}, {typ: label, text: "foo"}, {typ: eof}},
- },
- {
- input: "@label123",
- tokens: []token{{typ: lineStart}, {typ: label, text: "label123"}, {typ: eof}},
- },
- // comment after label
- {
- input: "@label123 ;; comment",
- tokens: []token{{typ: lineStart}, {typ: label, text: "label123"}, {typ: eof}},
- },
- // comment after instruction
- {
- input: "push 3 ;; comment\nadd",
- tokens: []token{{typ: lineStart}, {typ: element, text: "push"}, {typ: number, text: "3"}, {typ: lineEnd, text: "\n"}, {typ: lineStart, lineno: 1}, {typ: element, lineno: 1, text: "add"}, {typ: eof, lineno: 1}},
- },
- }
-
- for _, test := range tests {
- tokens := lexAll(test.input)
- if !reflect.DeepEqual(tokens, test.tokens) {
- t.Errorf("input %q\ngot: %+v\nwant: %+v", test.input, tokens, test.tokens)
- }
- }
-}
diff --git a/core/asm/lexer.go b/core/asm/lexer.go
deleted file mode 100644
index 5bb66c92f3..0000000000
--- a/core/asm/lexer.go
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of The go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with The go-ethereum library. If not, see .
-
-package asm
-
-import (
- "fmt"
- "os"
- "strings"
- "unicode"
- "unicode/utf8"
-)
-
-// stateFn is used through the lifetime of the
-// lexer to parse the different values at the
-// current state.
-type stateFn func(*lexer) stateFn
-
-// token is emitted when the lexer has discovered
-// a new parsable token. These are delivered over
-// the tokens channels of the lexer
-type token struct {
- typ tokenType
- lineno int
- text string
-}
-
-// tokenType are the different types the lexer
-// is able to parse and return.
-type tokenType int
-
-//go:generate go run golang.org/x/tools/cmd/stringer -type tokenType
-
-const (
- eof tokenType = iota // end of file
- lineStart // emitted when a line starts
- lineEnd // emitted when a line ends
- invalidStatement // any invalid statement
- element // any element during element parsing
- label // label is emitted when a label is found
- labelDef // label definition is emitted when a new label is found
- number // number is emitted when a number is found
- stringValue // stringValue is emitted when a string has been found
-)
-
-const (
- decimalNumbers = "1234567890" // characters representing any decimal number
- hexNumbers = decimalNumbers + "aAbBcCdDeEfF" // characters representing any hexadecimal
- alpha = "abcdefghijklmnopqrstuwvxyzABCDEFGHIJKLMNOPQRSTUWVXYZ" // characters representing alphanumeric
-)
-
-// lexer is the basic construct for parsing
-// source code and turning them in to tokens.
-// Tokens are interpreted by the compiler.
-type lexer struct {
- input string // input contains the source code of the program
-
- tokens chan token // tokens is used to deliver tokens to the listener
- state stateFn // the current state function
-
- lineno int // current line number in the source file
- start, pos, width int // positions for lexing and returning value
-
- debug bool // flag for triggering debug output
-}
-
-// lex lexes the program by name with the given source. It returns a
-// channel on which the tokens are delivered.
-func Lex(source []byte, debug bool) <-chan token {
- ch := make(chan token)
- l := &lexer{
- input: string(source),
- tokens: ch,
- state: lexLine,
- debug: debug,
- }
- go func() {
- l.emit(lineStart)
- for l.state != nil {
- l.state = l.state(l)
- }
- l.emit(eof)
- close(l.tokens)
- }()
-
- return ch
-}
-
-// next returns the next rune in the program's source.
-func (l *lexer) next() (rune rune) {
- if l.pos >= len(l.input) {
- l.width = 0
- return 0
- }
- rune, l.width = utf8.DecodeRuneInString(l.input[l.pos:])
- l.pos += l.width
- return rune
-}
-
-// backup backsup the last parsed element (multi-character)
-func (l *lexer) backup() {
- l.pos -= l.width
-}
-
-// peek returns the next rune but does not advance the seeker
-func (l *lexer) peek() rune {
- r := l.next()
- l.backup()
- return r
-}
-
-// ignore advances the seeker and ignores the value
-func (l *lexer) ignore() {
- l.start = l.pos
-}
-
-// Accepts checks whether the given input matches the next rune
-func (l *lexer) accept(valid string) bool {
- if strings.ContainsRune(valid, l.next()) {
- return true
- }
-
- l.backup()
-
- return false
-}
-
-// acceptRun will continue to advance the seeker until valid
-// can no longer be met.
-func (l *lexer) acceptRun(valid string) {
- for strings.ContainsRune(valid, l.next()) {
- }
- l.backup()
-}
-
-// acceptRunUntil is the inverse of acceptRun and will continue
-// to advance the seeker until the rune has been found.
-func (l *lexer) acceptRunUntil(until rune) bool {
- // Continues running until a rune is found
- for i := l.next(); !strings.ContainsRune(string(until), i); i = l.next() {
- if i == 0 {
- return false
- }
- }
-
- return true
-}
-
-// blob returns the current value
-func (l *lexer) blob() string {
- return l.input[l.start:l.pos]
-}
-
-// Emits a new token on to token channel for processing
-func (l *lexer) emit(t tokenType) {
- token := token{t, l.lineno, l.blob()}
-
- if l.debug {
- fmt.Fprintf(os.Stderr, "%04d: (%-20v) %s\n", token.lineno, token.typ, token.text)
- }
-
- l.tokens <- token
- l.start = l.pos
-}
-
-// lexLine is state function for lexing lines
-func lexLine(l *lexer) stateFn {
- for {
- switch r := l.next(); {
- case r == '\n':
- l.emit(lineEnd)
- l.ignore()
- l.lineno++
- l.emit(lineStart)
- case r == ';' && l.peek() == ';':
- return lexComment
- case isSpace(r):
- l.ignore()
- case isLetter(r) || r == '_':
- return lexElement
- case isNumber(r):
- return lexNumber
- case r == '@':
- l.ignore()
- return lexLabel
- case r == '"':
- return lexInsideString
- default:
- return nil
- }
- }
-}
-
-// lexComment parses the current position until the end
-// of the line and discards the text.
-func lexComment(l *lexer) stateFn {
- l.acceptRunUntil('\n')
- l.backup()
- l.ignore()
-
- return lexLine
-}
-
-// lexLabel parses the current label, emits and returns
-// the lex text state function to advance the parsing
-// process.
-func lexLabel(l *lexer) stateFn {
- l.acceptRun(alpha + "_" + decimalNumbers)
-
- l.emit(label)
-
- return lexLine
-}
-
-// lexInsideString lexes the inside of a string until
-// the state function finds the closing quote.
-// It returns the lex text state function.
-func lexInsideString(l *lexer) stateFn {
- if l.acceptRunUntil('"') {
- l.emit(stringValue)
- }
-
- return lexLine
-}
-
-func lexNumber(l *lexer) stateFn {
- acceptance := decimalNumbers
- if l.accept("xX") {
- acceptance = hexNumbers
- }
- l.acceptRun(acceptance)
-
- l.emit(number)
-
- return lexLine
-}
-
-func lexElement(l *lexer) stateFn {
- l.acceptRun(alpha + "_" + decimalNumbers)
-
- if l.peek() == ':' {
- l.emit(labelDef)
-
- l.accept(":")
- l.ignore()
- } else {
- l.emit(element)
- }
- return lexLine
-}
-
-func isLetter(t rune) bool {
- return unicode.IsLetter(t)
-}
-
-func isSpace(t rune) bool {
- return unicode.IsSpace(t)
-}
-
-func isNumber(t rune) bool {
- return unicode.IsNumber(t)
-}
diff --git a/core/asm/tokentype_string.go b/core/asm/tokentype_string.go
deleted file mode 100644
index ade76aa360..0000000000
--- a/core/asm/tokentype_string.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Code generated by "stringer -type tokenType"; DO NOT EDIT.
-
-package asm
-
-import "strconv"
-
-func _() {
- // An "invalid array index" compiler error signifies that the constant values have changed.
- // Re-run the stringer command to generate them again.
- var x [1]struct{}
- _ = x[eof-0]
- _ = x[lineStart-1]
- _ = x[lineEnd-2]
- _ = x[invalidStatement-3]
- _ = x[element-4]
- _ = x[label-5]
- _ = x[labelDef-6]
- _ = x[number-7]
- _ = x[stringValue-8]
-}
-
-const _tokenType_name = "eoflineStartlineEndinvalidStatementelementlabellabelDefnumberstringValue"
-
-var _tokenType_index = [...]uint8{0, 3, 12, 19, 35, 42, 47, 55, 61, 72}
-
-func (i tokenType) String() string {
- if i < 0 || i >= tokenType(len(_tokenType_index)-1) {
- return "tokenType(" + strconv.FormatInt(int64(i), 10) + ")"
- }
- return _tokenType_name[_tokenType_index[i]:_tokenType_index[i+1]]
-}