cmd/easm: item -> token

cmd/easm/lexer.go

@@ -13,21 +13,21 @@ import (
 // current state.
 type stateFn func(*Lexer) stateFn
 
-// item is emitted when the lexer has discovered
+// token is emitted when the lexer has discovered
-// a new parsable item. These are delivered over
+// a new parsable token. These are delivered over
-// the items channels of the lexer
+// the tokens channels of the lexer
-type item struct {
+type token struct {
-	typ    itemType
+	typ    tokenType
 	lineno int
 	text   string
 }
 
-// itemType are the different types the lexer
+// tokenType are the different types the lexer
 // is able to parse and return.
-type itemType int
+type tokenType int
 
 const (
-	eof              itemType = iota // end of file
+	eof              tokenType = iota // end of file
 	lineStart                         // emitted when a line starts
 	lineEnd                           // emitted when a line ends
 	invalidStatement                  // any invalid statement
@@ -43,14 +43,14 @@ const (
 )
 
 // String implements stringer
-func (it itemType) String() string {
+func (it tokenType) String() string {
-	if int(it) > len(stringItemTypes) {
+	if int(it) > len(stringtokenTypes) {
 		return "invalid"
 	}
-	return stringItemTypes[it]
+	return stringtokenTypes[it]
 }
 
-var stringItemTypes = []string{
+var stringtokenTypes = []string{
 	eof:              "EOF",
 	invalidStatement: "invalid statement",
 	element:          "element",
@@ -68,7 +68,7 @@ var stringItemTypes = []string{
 type Lexer struct {
 	input string // input contains the source code of the program
 
-	items chan item // items is used to deliver tokens to the listener
+	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
@@ -78,12 +78,12 @@ type Lexer struct {
 }
 
 // lex lexes the program by name with the given source. It returns a
-// channel on which the items are delivered.
+// channel on which the tokens are delivered.
-func lex(name string, source []byte, debug bool) <-chan item {
+func lex(name string, source []byte, debug bool) <-chan token {
-	ch := make(chan item)
+	ch := make(chan token)
 	l := &Lexer{
 		input:  string(source),
-		items: ch,
+		tokens: ch,
 		state:  lexLine,
 		debug:  debug,
 	}
@@ -93,7 +93,7 @@ func lex(name string, source []byte, debug bool) <-chan item {
 			l.state = l.state(l)
 		}
 		l.emit(eof)
-		close(l.items)
+		close(l.tokens)
 	}()
 
 	return ch
@@ -164,15 +164,15 @@ func (l *Lexer) blob() string {
 	return l.input[l.start:l.pos]
 }
 
-// Emits a new item on to item channel for processing
+// Emits a new token on to token channel for processing
-func (l *Lexer) emit(t itemType) {
+func (l *Lexer) emit(t tokenType) {
-	item := item{t, l.lineno, l.blob()}
+	token := token{t, l.lineno, l.blob()}
 
 	if l.debug {
-		fmt.Fprintf(os.Stderr, "%04d: (%-20v) %s\n", item.lineno, item.typ, item.text)
+		fmt.Fprintf(os.Stderr, "%04d: (%-20v) %s\n", token.lineno, token.typ, token.text)
 	}
 
-	l.items <- item
+	l.tokens <- token
 	l.start = l.pos
 }
 

cmd/easm/main.go

@@ -82,7 +82,7 @@ func main() {
 // Compiler contains information about the parsed source
 // and holds the tokens for the program.
 type Compiler struct {
-	tokens []item
+	tokens []token
 	binary []interface{}
 
 	labels map[string]int
@@ -109,7 +109,7 @@ func newCompiler(debug bool) *Compiler {
 // 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 item) {
+func (c *Compiler) feed(ch <-chan token) {
 	for i := range ch {
 		switch i.typ {
 		case number:
@@ -167,7 +167,7 @@ func (c *Compiler) compile() (string, []error) {
 
 // next returns the next token and increments the
 // posititon.
-func (c *Compiler) next() item {
+func (c *Compiler) next() token {
 	token := c.tokens[c.pos]
 	c.pos++
 	return token
@@ -205,7 +205,7 @@ func (c *Compiler) compileLine() error {
 }
 
 // compileNumber compiles the number to bytes
-func (c *Compiler) compileNumber(element item) (int, error) {
+func (c *Compiler) compileNumber(element token) (int, error) {
 	num := common.String2Big(element.text).Bytes()
 	if len(num) == 0 {
 		num = []byte{0}
@@ -217,7 +217,7 @@ func (c *Compiler) compileNumber(element item) (int, error) {
 // 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 item) error {
+func (c *Compiler) compileElement(element token) error {
 	// check for a jump. jumps must be read and compiled
 	// from right to left.
 	if isJump(element.text) {
@@ -324,7 +324,7 @@ var (
 	errExpElementOrLabel = errors.New("expected beginning of line")
 )
 
-func compileErr(c item, got, want string) error {
+func compileErr(c token, got, want string) error {
 	return compileError{
 		got:    got,
 		want:   want,