Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package token defines constants representing the lexical tokens of the Go
// programming language and basic operations on tokens (printing, predicates).
//
package token

import "strconv"

// Token is the set of lexical tokens of the Go programming language.
type Token int

// The list of tokens.
const (
        // Special tokens
        ILLEGAL Token = iota
        EOF
        COMMENT

        literal_beg
        // Identifiers and basic type literals
        // (these tokens stand for classes of literals)
        IDENT  // main
        INT    // 12345
        FLOAT  // 123.45
        IMAG   // 123.45i
        CHAR   // 'a'
        STRING // "abc"
        literal_end

        operator_beg
        // Operators and delimiters
        ADD // +
        SUB // -
        MUL // *
        QUO // /
        REM // %

        AND     // &
        OR      // |
        XOR     // ^
        SHL     // <<
        SHR     // >>
        AND_NOT // &^

        ADD_ASSIGN // +=
        SUB_ASSIGN // -=
        MUL_ASSIGN // *=
        QUO_ASSIGN // /=
        REM_ASSIGN // %=

        AND_ASSIGN     // &=
        OR_ASSIGN      // |=
        XOR_ASSIGN     // ^=
        SHL_ASSIGN     // <<=
        SHR_ASSIGN     // >>=
        AND_NOT_ASSIGN // &^=

        LAND  // &&
        LOR   // ||
        ARROW // <-
        INC   // ++
        DEC   // --

        EQL    // ==
        LSS    // <
        GTR    // >
        ASSIGN // =
        NOT    // !

        NEQ      // !=
        LEQ      // <=
        GEQ      // >=
        DEFINE   // :=
        ELLIPSIS // ...

        LPAREN // (
        LBRACK // [
        LBRACE // {
        COMMA  // ,
        PERIOD // .

        RPAREN    // )
        RBRACK    // ]
        RBRACE    // }
        SEMICOLON // ;
        COLON     // :
        operator_end

        keyword_beg
        // Keywords
        BREAK
        CASE
        CHAN
        CONST
        CONTINUE

        DEFAULT
        DEFER
        ELSE
        FALLTHROUGH
        FOR

        FUNC
        GO
        GOTO
        IF
        IMPORT

        INTERFACE
        MAP
        PACKAGE
        RANGE
        RETURN

        SELECT
        STRUCT
        SWITCH
        TYPE
        VAR
        keyword_end
)

var tokens = [...]string{
        ILLEGAL: "ILLEGAL",

        EOF:     "EOF",
        COMMENT: "COMMENT",

        IDENT:  "IDENT",
        INT:    "INT",
        FLOAT:  "FLOAT",
        IMAG:   "IMAG",
        CHAR:   "CHAR",
        STRING: "STRING",

        ADD: "+",
        SUB: "-",
        MUL: "*",
        QUO: "/",
        REM: "%",

        AND:     "&",
        OR:      "|",
        XOR:     "^",
        SHL:     "<<",
        SHR:     ">>",
        AND_NOT: "&^",

        ADD_ASSIGN: "+=",
        SUB_ASSIGN: "-=",
        MUL_ASSIGN: "*=",
        QUO_ASSIGN: "/=",
        REM_ASSIGN: "%=",

        AND_ASSIGN:     "&=",
        OR_ASSIGN:      "|=",
        XOR_ASSIGN:     "^=",
        SHL_ASSIGN:     "<<=",
        SHR_ASSIGN:     ">>=",
        AND_NOT_ASSIGN: "&^=",

        LAND:  "&&",
        LOR:   "||",
        ARROW: "<-",
        INC:   "++",
        DEC:   "--",

        EQL:    "==",
        LSS:    "<",
        GTR:    ">",
        ASSIGN: "=",
        NOT:    "!",

        NEQ:      "!=",
        LEQ:      "<=",
        GEQ:      ">=",
        DEFINE:   ":=",
        ELLIPSIS: "...",

        LPAREN: "(",
        LBRACK: "[",
        LBRACE: "{",
        COMMA:  ",",
        PERIOD: ".",

        RPAREN:    ")",
        RBRACK:    "]",
        RBRACE:    "}",
        SEMICOLON: ";",
        COLON:     ":",

        BREAK:    "break",
        CASE:     "case",
        CHAN:     "chan",
        CONST:    "const",
        CONTINUE: "continue",

        DEFAULT:     "default",
        DEFER:       "defer",
        ELSE:        "else",
        FALLTHROUGH: "fallthrough",
        FOR:         "for",

        FUNC:   "func",
        GO:     "go",
        GOTO:   "goto",
        IF:     "if",
        IMPORT: "import",

        INTERFACE: "interface",
        MAP:       "map",
        PACKAGE:   "package",
        RANGE:     "range",
        RETURN:    "return",

        SELECT: "select",
        STRUCT: "struct",
        SWITCH: "switch",
        TYPE:   "type",
        VAR:    "var",
}

// String returns the string corresponding to the token tok.
// For operators, delimiters, and keywords the string is the actual
// token character sequence (e.g., for the token ADD, the string is
// "+"). For all other tokens the string corresponds to the token
// constant name (e.g. for the token IDENT, the string is "IDENT").
//
func (tok Token) String() string {
        s := ""
        if 0 <= tok && tok < Token(len(tokens)) {
                s = tokens[tok]
        }
        if s == "" {
                s = "token(" + strconv.Itoa(int(tok)) + ")"
        }
        return s
}

// A set of constants for precedence-based expression parsing.
// Non-operators have lowest precedence, followed by operators
// starting with precedence 1 up to unary operators. The highest
// precedence corresponds serves as "catch-all" precedence for
// selector, indexing, and other operator and delimiter tokens.
//
const (
        LowestPrec  = 0 // non-operators
        UnaryPrec   = 6
        HighestPrec = 7
)

// Precedence returns the operator precedence of the binary
// operator op. If op is not a binary operator, the result
// is LowestPrecedence.
//
func (op Token) Precedence() int {
        switch op {
        case LOR:
                return 1
        case LAND:
                return 2
        case EQL, NEQ, LSS, LEQ, GTR, GEQ:
                return 3
        case ADD, SUB, OR, XOR:
                return 4
        case MUL, QUO, REM, SHL, SHR, AND, AND_NOT:
                return 5
        }
        return LowestPrec
}

var keywords map[string]Token

func init() {
        keywords = make(map[string]Token)
        for i := keyword_beg + 1; i < keyword_end; i++ {
                keywords[tokens[i]] = i
        }
}

// Lookup maps an identifier to its keyword token or IDENT (if not a keyword).
//
func Lookup(ident string) Token {
        if tok, is_keyword := keywords[ident]; is_keyword {
                return tok
        }
        return IDENT
}

// Predicates

// IsLiteral returns true for tokens corresponding to identifiers
// and basic type literals; it returns false otherwise.
//
func (tok Token) IsLiteral() bool { return literal_beg < tok && tok < literal_end }

// IsOperator returns true for tokens corresponding to operators and
// delimiters; it returns false otherwise.
//
func (tok Token) IsOperator() bool { return operator_beg < tok && tok < operator_end }

// IsKeyword returns true for tokens corresponding to keywords;
// it returns false otherwise.
//
func (tok Token) IsKeyword() bool { return keyword_beg < tok && tok < keyword_end }