yys int

empty struct{}

statement Statement

selStmt SelectStatement

byt byte

bytes []byte

bytes2 [][]byte

str string

selectExprs SelectExprs

selectExpr SelectExpr

columns Columns

colName *ColName

tableExprs TableExprs

tableExpr TableExpr

smTableExpr SimpleTableExpr

tableName *TableName

indexHints *IndexHints

expr Expr

boolExpr BoolExpr

valExpr ValExpr

colTuple ColTuple

valExprs ValExprs

values Values

rowTuple RowTuple

subquery *Subquery

caseExpr *CaseExpr

whens []*When

when *When

orderBy OrderBy

order *Order

limit *Limit

insRows InsertRows

updateExprs UpdateExprs

updateExpr *UpdateExpr

/*

for CreateTable

*/

createTableStmt CreateTable

columnDefinition *ColumnDefinition

columnDefinitions ColumnDefinitions

columnAtts ColumnAtts

p := &yyParserImpl{

lookahead: func() int { return -1 },

}

return p

if c >= 1 && c-1 < len(yyToknames) {

if yyToknames[c-1] != "" {

return yyToknames[c-1]

}

}

return __yyfmt__.Sprintf("tok-%v", c)

if s >= 0 && s < len(yyStatenames) {

if yyStatenames[s] != "" {

return yyStatenames[s]

}

}

return __yyfmt__.Sprintf("state-%v", s)

const TOKSTART = 4

if !yyErrorVerbose {

return "syntax error"

}

for _, e := range yyErrorMessages {

if e.state == state && e.token == lookAhead {

return "syntax error: " e.msg

}

}

res := "syntax error: unexpected " yyTokname(lookAhead)

// To match Bison, suggest at most four expected tokens.

expected := make([]int, 0, 4)

// Look for shiftable tokens.

base := yyPact[state]

for tok := TOKSTART; tok-1 < len(yyToknames); tok {

if n := base tok; n >= 0 && n < yyLast && yyChk[yyAct[n]] == tok {

if len(expected) == cap(expected) {

return res

}

expected = append(expected, tok)

}

}

if yyDef[state] == -2 {

i := 0

for yyExca[i] != -1 || yyExca[i 1] != state {

i = 2

}

// Look for tokens that we accept or reduce.

for i = 2; yyExca[i] >= 0; i = 2 {

tok := yyExca[i]

if tok < TOKSTART || yyExca[i 1] == 0 {

continue

}

if len(expected) == cap(expected) {

return res

}

expected = append(expected, tok)

}

// If the default action is to accept or reduce, give up.

if yyExca[i 1] != 0 {

return res

}

}

for i, tok := range expected {

if i == 0 {

res = ", expecting "

} else {

res = " or "

}

res = yyTokname(tok)

}

return res

token = 0

char = lex.Lex(lval)

if char <= 0 {

token = yyTok1[0]

goto out

}

if char < len(yyTok1) {

token = yyTok1[char]

goto out

}

if char >= yyPrivate {

if char < yyPrivate len(yyTok2) {

token = yyTok2[char-yyPrivate]

goto out

}

}

for i := 0; i < len(yyTok3); i = 2 {

token = yyTok3[i 0]

if token == char {

token = yyTok3[i 1]

goto out

}

}

out:

if token == 0 {

token = yyTok2[1] /* unknown char */

}

if yyDebug >= 3 {

__yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char))

}

return char, token

var yyn int

var yylval yySymType

var yyVAL yySymType

var yyDollar []yySymType

_ = yyDollar // silence set and not used

yyS := make([]yySymType, yyMaxDepth)

Nerrs := 0 /* number of errors */

Errflag := 0 /* error recovery flag */

yystate := 0

yychar := -1

yytoken := -1 // yychar translated into internal numbering

yyrcvr.lookahead = func() int { return yychar }

defer func() {

// Make sure we report no lookahead when not parsing.

yystate = -1

yychar = -1

yytoken = -1

}()

yyp := -1

goto yystack

ret0:

return 0

ret1:

return 1

yystack:

/* put a state and value onto the stack */

if yyDebug >= 4 {

__yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))

}

yyp

if yyp >= len(yyS) {

nyys := make([]yySymType, len(yyS)*2)

copy(nyys, yyS)

yyS = nyys

}

yyS[yyp] = yyVAL

yyS[yyp].yys = yystate

yynewstate:

yyn = yyPact[yystate]

if yyn <= yyFlag {

goto yydefault /* simple state */

}

if yychar < 0 {

yychar, yytoken = yylex1(yylex, &yylval)

}

yyn = yytoken

if yyn < 0 || yyn >= yyLast {

goto yydefault

}

yyn = yyAct[yyn]

if yyChk[yyn] == yytoken { /* valid shift */

yychar = -1

yytoken = -1

yyVAL = yylval

yystate = yyn

if Errflag > 0 {

Errflag--

}

goto yystack

}

yydefault:

/* default state action */

yyn = yyDef[yystate]

if yyn == -2 {

if yychar < 0 {

yychar, yytoken = yylex1(yylex, &yylval)

}

/* look through exception table */

xi := 0

for {

if yyExca[xi 0] == -1 && yyExca[xi 1] == yystate {

break

}

xi = 2

}

for xi = 2; ; xi = 2 {

yyn = yyExca[xi 0]

if yyn < 0 || yyn == yytoken {

break

}

}

yyn = yyExca[xi 1]

if yyn < 0 {

goto ret0

}

}

if yyn == 0 {

/* error ... attempt to resume parsing */

switch Errflag {

case 0: /* brand new error */

yylex.Error(yyErrorMessage(yystate, yytoken))

Nerrs

if yyDebug >= 1 {

__yyfmt__.Printf("%s", yyStatname(yystate))

__yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))

}

fallthrough

case 1, 2: /* incompletely recovered error ... try again */

Errflag = 3

/* find a state where "error" is a legal shift action */

for yyp >= 0 {

yyn = yyPact[yyS[yyp].yys] yyErrCode

if yyn >= 0 && yyn < yyLast {

yystate = yyAct[yyn] /* simulate a shift of "error" */

if yyChk[yystate] == yyErrCode {

goto yystack

}

}

/* the current p has no shift on "error", pop stack */

if yyDebug >= 2 {

__yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)

}

yyp--

}

/* there is no state on the stack with an error shift ... abort */

goto ret1

case 3: /* no shift yet; clobber input char */

if yyDebug >= 2 {

__yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))

}

if yytoken == yyEofCode {

goto ret1

}

yychar = -1

yytoken = -1

goto yynewstate /* try again in the same state */

}

}

/* reduction by production yyn */

if yyDebug >= 2 {

__yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))

}

yynt := yyn

yypt := yyp

_ = yypt // guard against "declared and not used"

yyp -= yyR2[yyn]

// yyp is now the index of $0. Perform the default action. Iff the

// reduced production is ε, $1 is possibly out of range.

if yyp 1 >= len(yyS) {

nyys := make([]yySymType, len(yyS)*2)

copy(nyys, yyS)

yyS = nyys

}

yyVAL = yyS[yyp 1]

/* consult goto table to find next state */

yyn = yyR1[yyn]

yyg := yyPgo[yyn]

yyj := yyg yyS[yyp].yys 1

if yyj >= yyLast {

yystate = yyAct[yyg]

} else {

yystate = yyAct[yyj]

if yyChk[yystate] != -yyn {

yystate = yyAct[yyg]

}

}

// dummy call; replaced with literal code

switch yynt {

case 1:

yyDollar = yyS[yypt-1 : yypt 1]

//line sql.y:181

{

SetParseTree(yylex, yyDollar[1].statement)