muesli/token.go

package muesli


import (
    "fmt"
)


/* Position of a token in an input stream */
type Position struct {
    FileName    string
    Line        int
    Column      int
}


/* Token Kind. Uses a rune to easily handle single character tokens. */
type TokenKind rune

const (    
    TokenKindInteger    = TokenKind('i') 
    TokenKindFloat      = TokenKind('f')
    TokenKindString     = TokenKind('s')
    TokenKindBoolean    = TokenKind('b')
    TokenKindWord       = TokenKind('w')
    TokenKindType       = TokenKind('t')
    TokenKindGet        = TokenKind('$')
    TokenKindSet        = TokenKind('=')
    TokenKindOpenBlock  = TokenKind('{')
    TokenKindCloseBlock = TokenKind('}')
    TokenKindOpenList   = TokenKind('[')
    TokenKindCloseList  = TokenKind(']')
    TokenKindOpenParen  = TokenKind('(')
    TokenKindCloseParen = TokenKind(')')
    TokenKindError      = TokenKind('!')
    TokenKindEOX        = TokenKind('\n')
    TokenKindEOF        = TokenKind(0x255)
)

/* Names of the different token types. */
var TokenKindNames map[TokenKind] string = map[TokenKind]string{
    TokenKindInteger   :  "Integer"   ,
    TokenKindFloat     :  "Float"     ,
    TokenKindString    :  "String"    ,
    TokenKindBoolean   :  "Boolean"   ,
    TokenKindWord      :  "Word"      ,
    TokenKindType      :  "Type"      ,
    TokenKindGet       :  "Get"       ,
    TokenKindSet       :  "Set"       ,
    TokenKindOpenBlock :  "OpenBlock" ,
    TokenKindCloseBlock:  "CloseBlock",
    TokenKindOpenList  :  "OpenList"  ,
    TokenKindCloseList :  "CloseList" ,
    TokenKindOpenParen :  "OpenParen" ,
    TokenKindCloseParen:  "CloseParen",
    TokenKindError     :  "Error"     ,
    TokenKindEOX       :  "EOX"       ,
    TokenKindEOF       :  "EOF"       , 
}

/* Transforms a token kid to a String */
func (kind TokenKind) String() string {
  name, ok := TokenKindNames[kind]
  if !ok {
    return "Unknown TokenKind!"
  }
  return name
}


type Token struct {
    TokenKind
    Value
    Position
}

func (token Token) String() string {
  return fmt.Sprintf("<%s:%q:%v>", token.TokenKind.String(), 
                      token.Value, token.Position)
}

func (token Token) Error() string {
    if token.TokenKind == TokenKindError {
        return token.Value.(string)
    }
    return "No error"
}

/* Returns whether or not the token is the last to be expected, 
 * that is either an error or EOF. */
func (token Token) IsLast() bool {
    switch token.TokenKind {  
        case TokenKindError:    return true
        case TokenKindEOF:      return true
        default:                return false;
    }
}


/* Creates a new token. */
func NewToken(kind TokenKind, val Value, pos Position) Token {
    return Token{kind, val, pos}
}