1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
// Copyright 2018 The CUE Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package token defines constants representing the lexical tokens of the Go
// programming language and basic operations on tokens (printing, predicates).
package token
// Token is the set of lexical tokens of the CUE configuration language.
type Token int
//go:generate go run golang.org/x/tools/cmd/stringer -type=Token -linecomment
// The list of tokens.
const (
// Special tokens
ILLEGAL Token = iota
EOF
COMMENT
// e.g. @foo(bar,baz=4)
ATTRIBUTE
// Identifiers and basic type literals
// (these tokens stand for classes of literals)
literalBeg
// e.g. main, _tmp
IDENT
// e.g. 12_345Mi, 0700, 0xdeadbeef, 1.2M
INT
// e.g. 123.45
FLOAT
// e.g. 3m4s; TODO
// DURATION
// e.g. "abc"
STRING
// a part of a template string, e.g. `"age: \(`
INTERPOLATION
BOTTOM // _|_
literalEnd
// Operators and delimiters
operatorBeg
ADD // +
SUB // -
MUL // *
POW // ^
QUO // /
IQUO // quo
IREM // rem
IDIV // div
IMOD // mod
AND // &
OR // |
LAND // &&
LOR // ||
BIND // =
EQL // ==
LSS // <
GTR // >
NOT // !
ARROW // <-
NEQ // !=
LEQ // <=
GEQ // >=
MAT // =~
NMAT // !~
LPAREN // (
LBRACK // [
LBRACE // {
COMMA // ,
PERIOD // .
ELLIPSIS // ...
RPAREN // )
RBRACK // ]
RBRACE // }
SEMICOLON // ;
COLON // :
OPTION // ?
operatorEnd
keywordBeg
IF // if
FOR // for
IN // in
LET // let
// experimental
FUNC // func
TRUE // true
FALSE // false
NULL // null
keywordEnd
)
// 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 serves as "catch-all" precedence for selector,
// indexing, and other operator and delimiter tokens.
const (
LowestPrec = lowestPrec
UnaryPrec = unaryPrec
HighestPrec = highestPrec
)
const (
lowestPrec = 0 // non-operators
unaryPrec = 8
highestPrec = 9
)
// Precedence returns the operator precedence of the binary
// operator op. If op is not a binary operator, the result
// is LowestPrecedence.
func (tok Token) Precedence() int {
switch tok {
case OR:
return 1
case AND:
return 2
case LOR:
return 3
case LAND:
return 4
case EQL, NEQ, LSS, LEQ, GTR, GEQ, MAT, NMAT:
return 5
case ADD, SUB:
return 6
case MUL, QUO, IDIV, IMOD, IQUO, IREM:
return 7
}
return lowestPrec
}
var keywords map[string]Token
func init() {
keywords = make(map[string]Token)
for tok := keywordBeg + 1; tok < keywordEnd; tok++ {
keywords[tok.String()] = tok
}
}
// Lookup maps an identifier to its keyword token or IDENT (if not a keyword).
func Lookup(ident string) Token {
if tok, isKeyword := keywords[ident]; isKeyword {
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 literalBeg < tok && tok < literalEnd }
// IsOperator returns true for tokens corresponding to operators and
// delimiters; it returns false otherwise.
func (tok Token) IsOperator() bool { return operatorBeg < tok && tok < operatorEnd }
// IsKeyword returns true for tokens corresponding to keywords;
// it returns false otherwise.
func (tok Token) IsKeyword() bool { return keywordBeg < tok && tok < keywordEnd }
|
