var yylast int
-var imported_unsafe int
+var imported_unsafe bool
var (
goos string
{"wb", &Debug_wb}, // print information about write barriers
}
-// Our own isdigit, isspace, isalpha, isalnum that take care
-// of EOF and other out of range arguments.
-func yy_isdigit(c int) bool {
- return c >= 0 && c <= 0xFF && isdigit(c)
-}
-
-func yy_isspace(c int) bool {
- return c == ' ' || c == '\t' || c == '\n' || c == '\r'
-}
-
-func yy_isalpha(c int) bool {
- return 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z'
-}
-
-func yy_isalnum(c int) bool {
- return c >= 0 && c <= 0xFF && isalnum(c)
-}
-
-// Disallow use of isdigit etc.
-
const (
EOF = -1
)
curio.peekc = 0
curio.peekc1 = 0
- curio.nlsemi = 0
- curio.eofnl = 0
+ curio.nlsemi = false
+ curio.eofnl = false
curio.last = 0
// Skip initial BOM if present.
block = 1
iota_ = -1000000
- imported_unsafe = 0
+ imported_unsafe = false
yyparse()
if nsyntaxerrors != 0 {
// is this path a local name? begins with ./ or ../ or /
func islocalname(name string) bool {
return strings.HasPrefix(name, "/") ||
- Ctxt.Windows != 0 && len(name) >= 3 && yy_isalpha(int(name[0])) && name[1] == ':' && name[2] == '/' ||
+ Ctxt.Windows != 0 && len(name) >= 3 && isAlpha(int(name[0])) && name[1] == ':' && name[2] == '/' ||
strings.HasPrefix(name, "./") || name == "." ||
strings.HasPrefix(name, "../") || name == ".."
}
importpkg = mkpkg(f.U.(string))
cannedimports("unsafe.o", unsafeimport)
- imported_unsafe = 1
+ imported_unsafe = true
return
}
curio.peekc = 0
curio.peekc1 = 0
curio.infile = file
- curio.nlsemi = 0
+ curio.nlsemi = false
typecheckok = true
- var c int32
for {
- c = int32(getc())
+ c := getc()
if c == EOF {
break
}
if c != '$' {
continue
}
- c = int32(getc())
+ c = getc()
if c == EOF {
break
}
curio.peekc1 = 0
curio.infile = file
curio.cp = cp
- curio.nlsemi = 0
+ curio.nlsemi = false
curio.importsafe = false
typecheckok = true
func isfrog(c int) bool {
// complain about possibly invisible control characters
if c < ' ' {
- return !yy_isspace(c) // exclude good white space
+ return !isSpace(c) // exclude good white space
}
if 0x7f <= c && c <= 0xa0 { // DEL, unicode block including unbreakable space.
}
type Loophack struct {
- v int
next *Loophack
+ v bool
}
var _yylex_lstk *Loophack
var escflag int
var v int64
var cp *bytes.Buffer
- var rune_ uint
var s *Sym
var h *Loophack
var str string
l0:
c := getc()
- if yy_isspace(c) {
- if c == '\n' && curio.nlsemi != 0 {
+ if isSpace(c) {
+ if c == '\n' && curio.nlsemi {
ungetc(c)
if Debug['x'] != 0 {
fmt.Printf("lex: implicit semi\n")
goto talph
}
- if yy_isalpha(c) {
+ if isAlpha(c) {
cp = &lexbuf
cp.Reset()
goto talph
}
- if yy_isdigit(c) {
+ if isDigit(c) {
cp = &lexbuf
cp.Reset()
if c != '0' {
for {
cp.WriteByte(byte(c))
c = getc()
- if yy_isdigit(c) {
+ if isDigit(c) {
continue
}
if c == '.' {
for {
cp.WriteByte(byte(c))
c = getc()
- if yy_isdigit(c) {
+ if isDigit(c) {
continue
}
if c >= 'a' && c <= 'f' {
c1 = 0
for {
- if !yy_isdigit(c) {
+ if !isDigit(c) {
break
}
if c < '0' || c > '7' {
case '.':
c1 = getc()
- if yy_isdigit(c1) {
+ if isDigit(c1) {
cp = &lexbuf
cp.Reset()
cp.WriteByte(byte(c))
if v < utf8.RuneSelf || escflag != 0 {
cp.WriteByte(byte(v))
} else {
- rune_ = uint(v)
- cp.WriteRune(rune(rune_))
+ cp.WriteRune(rune(v))
}
}
case '/':
c1 = getc()
if c1 == '*' {
- nl := 0
+ nl := false
for {
c = int(getr())
if c == '\n' {
- nl = 1
+ nl = true
}
for c == '*' {
c = int(getr())
if c == '/' {
- if nl != 0 {
+ if nl {
ungetc('\n')
}
goto l0
}
if c == '\n' {
- nl = 1
+ nl = true
}
}
*
* when we see the keyword, the next
* non-parenthesized '{' becomes an LBODY.
- * loophack is normally 0.
- * a keyword makes it go up to 1.
- * parens push loophack onto a stack and go back to 0.
- * a '{' with loophack == 1 becomes LBODY and disables loophack.
+ * loophack is normally false.
+ * a keyword sets it to true.
+ * parens push loophack onto a stack and go back to false.
+ * a '{' with loophack == true becomes LBODY and disables loophack.
*
* i said it was clumsy.
*/
case '(', '[':
- if loophack != 0 || _yylex_lstk != nil {
+ if loophack || _yylex_lstk != nil {
h = new(Loophack)
if h == nil {
Flusherrors()
h.v = loophack
h.next = _yylex_lstk
_yylex_lstk = h
- loophack = 0
+ loophack = false
}
goto lx
goto lx
case '{':
- if loophack == 1 {
+ if loophack {
if Debug['x'] != 0 {
fmt.Printf("%v lex: LBODY\n", Ctxt.Line(int(lexlineno)))
}
- loophack = 0
+ loophack = false
return LBODY
}
for {
if c >= utf8.RuneSelf {
ungetc(c)
- rune_ = uint(getr())
+ r := rune(getr())
// 0xb7 ยท is used for internal names
- if !unicode.IsLetter(rune(rune_)) && !unicode.IsDigit(rune(rune_)) && (importpkg == nil || rune_ != 0xb7) {
- Yyerror("invalid identifier character U+%04x", rune_)
+ if !unicode.IsLetter(r) && !unicode.IsDigit(r) && (importpkg == nil || r != 0xb7) {
+ Yyerror("invalid identifier character U+%04x", r)
}
- cp.WriteRune(rune(rune_))
- } else if !yy_isalnum(c) && c != '_' {
+ cp.WriteRune(r)
+ } else if !isAlnum(c) && c != '_' {
break
} else {
cp.WriteByte(byte(c))
goto l0
case LFOR, LIF, LSWITCH, LSELECT:
- loophack = 1 // see comment about loophack above
+ loophack = true // see comment about loophack above
}
if Debug['x'] != 0 {
for {
cp.WriteByte(byte(c))
c = getc()
- if !yy_isdigit(c) {
+ if !isDigit(c) {
break
}
}
c = getc()
}
- if !yy_isdigit(c) {
+ if !isDigit(c) {
Yyerror("malformed floating point constant exponent")
}
- for yy_isdigit(c) {
+ for isDigit(c) {
cp.WriteByte(byte(c))
c = getc()
}
func more(pp *string) bool {
p := *pp
- for p != "" && yy_isspace(int(p[0])) {
+ for p != "" && isSpace(int(p[0])) {
p = p[1:]
}
*pp = p
}
if verb == "go:linkname" {
- if imported_unsafe == 0 {
+ if !imported_unsafe {
Yyerror("//go:linkname only allowed in Go files that import \"unsafe\"")
}
f := strings.Fields(cmd)
return ""
}
i := 0
- for i < len(p) && !yy_isspace(int(p[i])) && p[i] != '"' {
+ for i < len(p) && !isSpace(int(p[i])) && p[i] != '"' {
i++
}
sym := p[:i]
verb := text[3:] // skip "go:"
if verb == "cgo_dynamic_linker" || verb == "dynlinker" {
- var ok bool
- var p string
- p, ok = getquoted(&q)
+ p, ok := getquoted(&q)
if !ok {
Yyerror("usage: //go:cgo_dynamic_linker \"path\"")
return
}
if verb == "cgo_ldflag" {
- var ok bool
- var p string
- p, ok = getquoted(&q)
+ p, ok := getquoted(&q)
if !ok {
Yyerror("usage: //go:cgo_ldflag \"arg\"")
return
func yylex(yylval *yySymType) int32 {
lx := int(_yylex(yylval))
- if curio.nlsemi != 0 && lx == EOF {
+ if curio.nlsemi && lx == EOF {
// Treat EOF as "end of line" for the purposes
// of inserting a semicolon.
lx = ';'
')',
'}',
']':
- curio.nlsemi = 1
+ curio.nlsemi = true
default:
- curio.nlsemi = 0
+ curio.nlsemi = false
}
// Track last two tokens returned by yylex.
// insert \n at EOF
case EOF:
- if curio.eofnl != 0 || curio.last == '\n' {
+ if curio.eofnl || curio.last == '\n' {
return EOF
}
- curio.eofnl = 1
+ curio.eofnl = true
c = '\n'
fallthrough
return fmt.Sprintf("LEX-%d", lex)
}
-var yytfix = []struct {
- have string
- want string
-}{
- {"$end", "EOF"},
- {"LASOP", "op="},
- {"LBREAK", "break"},
- {"LCASE", "case"},
- {"LCHAN", "chan"},
- {"LCOLAS", ":="},
- {"LCONST", "const"},
- {"LCONTINUE", "continue"},
- {"LDDD", "..."},
- {"LDEFAULT", "default"},
- {"LDEFER", "defer"},
- {"LELSE", "else"},
- {"LFALL", "fallthrough"},
- {"LFOR", "for"},
- {"LFUNC", "func"},
- {"LGO", "go"},
- {"LGOTO", "goto"},
- {"LIF", "if"},
- {"LIMPORT", "import"},
- {"LINTERFACE", "interface"},
- {"LMAP", "map"},
- {"LNAME", "name"},
- {"LPACKAGE", "package"},
- {"LRANGE", "range"},
- {"LRETURN", "return"},
- {"LSELECT", "select"},
- {"LSTRUCT", "struct"},
- {"LSWITCH", "switch"},
- {"LTYPE", "type"},
- {"LVAR", "var"},
- {"LANDAND", "&&"},
- {"LANDNOT", "&^"},
- {"LBODY", "{"},
- {"LCOMM", "<-"},
- {"LDEC", "--"},
- {"LINC", "++"},
- {"LEQ", "=="},
- {"LGE", ">="},
- {"LGT", ">"},
- {"LLE", "<="},
- {"LLT", "<"},
- {"LLSH", "<<"},
- {"LRSH", ">>"},
- {"LOROR", "||"},
- {"LNE", "!="},
+var yytfix = map[string]string{
+ "$end": "EOF",
+ "LASOP": "op=",
+ "LBREAK": "break",
+ "LCASE": "case",
+ "LCHAN": "chan",
+ "LCOLAS": ":=",
+ "LCONST": "const",
+ "LCONTINUE": "continue",
+ "LDDD": "...",
+ "LDEFAULT": "default",
+ "LDEFER": "defer",
+ "LELSE": "else",
+ "LFALL": "fallthrough",
+ "LFOR": "for",
+ "LFUNC": "func",
+ "LGO": "go",
+ "LGOTO": "goto",
+ "LIF": "if",
+ "LIMPORT": "import",
+ "LINTERFACE": "interface",
+ "LMAP": "map",
+ "LNAME": "name",
+ "LPACKAGE": "package",
+ "LRANGE": "range",
+ "LRETURN": "return",
+ "LSELECT": "select",
+ "LSTRUCT": "struct",
+ "LSWITCH": "switch",
+ "LTYPE": "type",
+ "LVAR": "var",
+ "LANDAND": "&&",
+ "LANDNOT": "&^",
+ "LBODY": "{",
+ "LCOMM": "<-",
+ "LDEC": "--",
+ "LINC": "++",
+ "LEQ": "==",
+ "LGE": ">=",
+ "LGT": ">",
+ "LLE": "<=",
+ "LLT": "<",
+ "LLSH": "<<",
+ "LRSH": ">>",
+ "LOROR": "||",
+ "LNE": "!=",
// spell out to avoid confusion with punctuation in error messages
- {"';'", "semicolon or newline"},
- {"','", "comma"},
+ "';'": "semicolon or newline",
+ "','": "comma",
}
func init() {
yyErrorVerbose = true
-Outer:
for i, s := range yyToknames {
// Apply yytfix if possible.
- for _, fix := range yytfix {
- if s == fix.have {
- yyToknames[i] = fix.want
- continue Outer
- }
- }
-
- // Turn 'x' into x.
- if len(s) == 3 && s[0] == '\'' && s[2] == '\'' {
+ if fix, ok := yytfix[s]; ok {
+ yyToknames[i] = fix
+ } else if len(s) == 3 && s[0] == '\'' && s[2] == '\'' {
+ // Turn 'x' into x.
yyToknames[i] = s[1:2]
- continue
}
}
}