github.com/devseccon/trivy@v0.47.1-0.20231123133102-bd902a0bd996/pkg/licensing/expression/parser_gen.go (about) 1 // Code generated by goyacc -o parser_gen.go parser.go.y. DO NOT EDIT. 2 3 //line parser.go.y:2 4 package expression 5 6 import __yyfmt__ "fmt" 7 8 //line parser.go.y:2 9 10 //line parser.go.y:5 11 type yySymType struct { 12 yys int 13 token Token 14 expr Expression 15 } 16 17 const IDENT = 57346 18 const OR = 57347 19 const AND = 57348 20 const WITH = 57349 21 22 var yyToknames = [...]string{ 23 "$end", 24 "error", 25 "$unk", 26 "IDENT", 27 "OR", 28 "AND", 29 "WITH", 30 "'+'", 31 "'('", 32 "')'", 33 } 34 35 var yyStatenames = [...]string{} 36 37 const yyEofCode = 1 38 const yyErrCode = 2 39 const yyInitialStackSize = 16 40 41 //line parser.go.y:73 42 43 //line yacctab:1 44 var yyExca = [...]int8{ 45 -1, 1, 46 1, -1, 47 -2, 0, 48 } 49 50 const yyPrivate = 57344 51 52 const yyLast = 22 53 54 var yyAct = [...]int8{ 55 8, 7, 9, 2, 10, 16, 9, 4, 11, 12, 56 6, 13, 14, 15, 3, 5, 8, 7, 9, 7, 57 9, 1, 58 } 59 60 var yyPact = [...]int16{ 61 6, -1000, 11, 0, -1000, 6, -1000, 6, 6, 6, 62 -1000, -1000, -5, -1, 13, -1, -1000, 63 } 64 65 var yyPgo = [...]int8{ 66 0, 21, 14, 7, 3, 67 } 68 69 var yyR1 = [...]int8{ 70 0, 1, 2, 2, 3, 4, 4, 4, 4, 4, 71 4, 72 } 73 74 var yyR2 = [...]int8{ 75 0, 1, 1, 2, 2, 1, 1, 3, 3, 3, 76 3, 77 } 78 79 var yyChk = [...]int16{ 80 -1000, -1, -4, -2, -3, 9, 4, 6, 5, 7, 81 4, 8, -4, -4, -4, -4, 10, 82 } 83 84 var yyDef = [...]int8{ 85 0, -2, 1, 5, 6, 0, 2, 0, 0, 0, 86 3, 4, 0, 7, 8, 9, 10, 87 } 88 89 var yyTok1 = [...]int8{ 90 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 91 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 92 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 93 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 94 9, 10, 3, 8, 95 } 96 97 var yyTok2 = [...]int8{ 98 2, 3, 4, 5, 6, 7, 99 } 100 101 var yyTok3 = [...]int8{ 102 0, 103 } 104 105 var yyErrorMessages = [...]struct { 106 state int 107 token int 108 msg string 109 }{} 110 111 //line yaccpar:1 112 113 /* parser for yacc output */ 114 115 var ( 116 yyDebug = 0 117 yyErrorVerbose = false 118 ) 119 120 type yyLexer interface { 121 Lex(lval *yySymType) int 122 Error(s string) 123 } 124 125 type yyParser interface { 126 Parse(yyLexer) int 127 Lookahead() int 128 } 129 130 type yyParserImpl struct { 131 lval yySymType 132 stack [yyInitialStackSize]yySymType 133 char int 134 } 135 136 func (p *yyParserImpl) Lookahead() int { 137 return p.char 138 } 139 140 func yyNewParser() yyParser { 141 return &yyParserImpl{} 142 } 143 144 const yyFlag = -1000 145 146 func yyTokname(c int) string { 147 if c >= 1 && c-1 < len(yyToknames) { 148 if yyToknames[c-1] != "" { 149 return yyToknames[c-1] 150 } 151 } 152 return __yyfmt__.Sprintf("tok-%v", c) 153 } 154 155 func yyStatname(s int) string { 156 if s >= 0 && s < len(yyStatenames) { 157 if yyStatenames[s] != "" { 158 return yyStatenames[s] 159 } 160 } 161 return __yyfmt__.Sprintf("state-%v", s) 162 } 163 164 func yyErrorMessage(state, lookAhead int) string { 165 const TOKSTART = 4 166 167 if !yyErrorVerbose { 168 return "syntax error" 169 } 170 171 for _, e := range yyErrorMessages { 172 if e.state == state && e.token == lookAhead { 173 return "syntax error: " + e.msg 174 } 175 } 176 177 res := "syntax error: unexpected " + yyTokname(lookAhead) 178 179 // To match Bison, suggest at most four expected tokens. 180 expected := make([]int, 0, 4) 181 182 // Look for shiftable tokens. 183 base := int(yyPact[state]) 184 for tok := TOKSTART; tok-1 < len(yyToknames); tok++ { 185 if n := base + tok; n >= 0 && n < yyLast && int(yyChk[int(yyAct[n])]) == tok { 186 if len(expected) == cap(expected) { 187 return res 188 } 189 expected = append(expected, tok) 190 } 191 } 192 193 if yyDef[state] == -2 { 194 i := 0 195 for yyExca[i] != -1 || int(yyExca[i+1]) != state { 196 i += 2 197 } 198 199 // Look for tokens that we accept or reduce. 200 for i += 2; yyExca[i] >= 0; i += 2 { 201 tok := int(yyExca[i]) 202 if tok < TOKSTART || yyExca[i+1] == 0 { 203 continue 204 } 205 if len(expected) == cap(expected) { 206 return res 207 } 208 expected = append(expected, tok) 209 } 210 211 // If the default action is to accept or reduce, give up. 212 if yyExca[i+1] != 0 { 213 return res 214 } 215 } 216 217 for i, tok := range expected { 218 if i == 0 { 219 res += ", expecting " 220 } else { 221 res += " or " 222 } 223 res += yyTokname(tok) 224 } 225 return res 226 } 227 228 func yylex1(lex yyLexer, lval *yySymType) (char, token int) { 229 token = 0 230 char = lex.Lex(lval) 231 if char <= 0 { 232 token = int(yyTok1[0]) 233 goto out 234 } 235 if char < len(yyTok1) { 236 token = int(yyTok1[char]) 237 goto out 238 } 239 if char >= yyPrivate { 240 if char < yyPrivate+len(yyTok2) { 241 token = int(yyTok2[char-yyPrivate]) 242 goto out 243 } 244 } 245 for i := 0; i < len(yyTok3); i += 2 { 246 token = int(yyTok3[i+0]) 247 if token == char { 248 token = int(yyTok3[i+1]) 249 goto out 250 } 251 } 252 253 out: 254 if token == 0 { 255 token = int(yyTok2[1]) /* unknown char */ 256 } 257 if yyDebug >= 3 { 258 __yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char)) 259 } 260 return char, token 261 } 262 263 func yyParse(yylex yyLexer) int { 264 return yyNewParser().Parse(yylex) 265 } 266 267 func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int { 268 var yyn int 269 var yyVAL yySymType 270 var yyDollar []yySymType 271 _ = yyDollar // silence set and not used 272 yyS := yyrcvr.stack[:] 273 274 Nerrs := 0 /* number of errors */ 275 Errflag := 0 /* error recovery flag */ 276 yystate := 0 277 yyrcvr.char = -1 278 yytoken := -1 // yyrcvr.char translated into internal numbering 279 defer func() { 280 // Make sure we report no lookahead when not parsing. 281 yystate = -1 282 yyrcvr.char = -1 283 yytoken = -1 284 }() 285 yyp := -1 286 goto yystack 287 288 ret0: 289 return 0 290 291 ret1: 292 return 1 293 294 yystack: 295 /* put a state and value onto the stack */ 296 if yyDebug >= 4 { 297 __yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate)) 298 } 299 300 yyp++ 301 if yyp >= len(yyS) { 302 nyys := make([]yySymType, len(yyS)*2) 303 copy(nyys, yyS) 304 yyS = nyys 305 } 306 yyS[yyp] = yyVAL 307 yyS[yyp].yys = yystate 308 309 yynewstate: 310 yyn = int(yyPact[yystate]) 311 if yyn <= yyFlag { 312 goto yydefault /* simple state */ 313 } 314 if yyrcvr.char < 0 { 315 yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval) 316 } 317 yyn += yytoken 318 if yyn < 0 || yyn >= yyLast { 319 goto yydefault 320 } 321 yyn = int(yyAct[yyn]) 322 if int(yyChk[yyn]) == yytoken { /* valid shift */ 323 yyrcvr.char = -1 324 yytoken = -1 325 yyVAL = yyrcvr.lval 326 yystate = yyn 327 if Errflag > 0 { 328 Errflag-- 329 } 330 goto yystack 331 } 332 333 yydefault: 334 /* default state action */ 335 yyn = int(yyDef[yystate]) 336 if yyn == -2 { 337 if yyrcvr.char < 0 { 338 yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval) 339 } 340 341 /* look through exception table */ 342 xi := 0 343 for { 344 if yyExca[xi+0] == -1 && int(yyExca[xi+1]) == yystate { 345 break 346 } 347 xi += 2 348 } 349 for xi += 2; ; xi += 2 { 350 yyn = int(yyExca[xi+0]) 351 if yyn < 0 || yyn == yytoken { 352 break 353 } 354 } 355 yyn = int(yyExca[xi+1]) 356 if yyn < 0 { 357 goto ret0 358 } 359 } 360 if yyn == 0 { 361 /* error ... attempt to resume parsing */ 362 switch Errflag { 363 case 0: /* brand new error */ 364 yylex.Error(yyErrorMessage(yystate, yytoken)) 365 Nerrs++ 366 if yyDebug >= 1 { 367 __yyfmt__.Printf("%s", yyStatname(yystate)) 368 __yyfmt__.Printf(" saw %s\n", yyTokname(yytoken)) 369 } 370 fallthrough 371 372 case 1, 2: /* incompletely recovered error ... try again */ 373 Errflag = 3 374 375 /* find a state where "error" is a legal shift action */ 376 for yyp >= 0 { 377 yyn = int(yyPact[yyS[yyp].yys]) + yyErrCode 378 if yyn >= 0 && yyn < yyLast { 379 yystate = int(yyAct[yyn]) /* simulate a shift of "error" */ 380 if int(yyChk[yystate]) == yyErrCode { 381 goto yystack 382 } 383 } 384 385 /* the current p has no shift on "error", pop stack */ 386 if yyDebug >= 2 { 387 __yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys) 388 } 389 yyp-- 390 } 391 /* there is no state on the stack with an error shift ... abort */ 392 goto ret1 393 394 case 3: /* no shift yet; clobber input char */ 395 if yyDebug >= 2 { 396 __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken)) 397 } 398 if yytoken == yyEofCode { 399 goto ret1 400 } 401 yyrcvr.char = -1 402 yytoken = -1 403 goto yynewstate /* try again in the same state */ 404 } 405 } 406 407 /* reduction by production yyn */ 408 if yyDebug >= 2 { 409 __yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate)) 410 } 411 412 yynt := yyn 413 yypt := yyp 414 _ = yypt // guard against "declared and not used" 415 416 yyp -= int(yyR2[yyn]) 417 // yyp is now the index of $0. Perform the default action. Iff the 418 // reduced production is ε, $1 is possibly out of range. 419 if yyp+1 >= len(yyS) { 420 nyys := make([]yySymType, len(yyS)*2) 421 copy(nyys, yyS) 422 yyS = nyys 423 } 424 yyVAL = yyS[yyp+1] 425 426 /* consult goto table to find next state */ 427 yyn = int(yyR1[yyn]) 428 yyg := int(yyPgo[yyn]) 429 yyj := yyg + yyS[yyp].yys + 1 430 431 if yyj >= yyLast { 432 yystate = int(yyAct[yyg]) 433 } else { 434 yystate = int(yyAct[yyj]) 435 if int(yyChk[yystate]) != -yyn { 436 yystate = int(yyAct[yyg]) 437 } 438 } 439 // dummy call; replaced with literal code 440 switch yynt { 441 442 case 1: 443 yyDollar = yyS[yypt-1 : yypt+1] 444 //line parser.go.y:25 445 { 446 yyVAL.expr = yyDollar[1].expr 447 if l, ok := yylex.(*Lexer); ok { 448 l.result = yyVAL.expr 449 } 450 } 451 case 2: 452 yyDollar = yyS[yypt-1 : yypt+1] 453 //line parser.go.y:34 454 { 455 yyVAL.expr = SimpleExpr{license: yyDollar[1].token.literal} 456 } 457 case 3: 458 yyDollar = yyS[yypt-2 : yypt+1] 459 //line parser.go.y:38 460 { 461 yyVAL.expr = SimpleExpr{license: yyDollar[1].expr.String() + " " + yyDollar[2].token.literal} 462 } 463 case 4: 464 yyDollar = yyS[yypt-2 : yypt+1] 465 //line parser.go.y:44 466 { 467 yyVAL.expr = SimpleExpr{license: yyDollar[1].expr.String(), hasPlus: true} 468 } 469 case 5: 470 yyDollar = yyS[yypt-1 : yypt+1] 471 //line parser.go.y:49 472 { 473 yyVAL.expr = yyDollar[1].expr 474 } 475 case 6: 476 yyDollar = yyS[yypt-1 : yypt+1] 477 //line parser.go.y:52 478 { 479 yyVAL.expr = yyDollar[1].expr 480 } 481 case 7: 482 yyDollar = yyS[yypt-3 : yypt+1] 483 //line parser.go.y:56 484 { 485 yyVAL.expr = CompoundExpr{left: yyDollar[1].expr, conjunction: yyDollar[2].token, right: yyDollar[3].expr} 486 } 487 case 8: 488 yyDollar = yyS[yypt-3 : yypt+1] 489 //line parser.go.y:60 490 { 491 yyVAL.expr = CompoundExpr{left: yyDollar[1].expr, conjunction: yyDollar[2].token, right: yyDollar[3].expr} 492 } 493 case 9: 494 yyDollar = yyS[yypt-3 : yypt+1] 495 //line parser.go.y:64 496 { 497 yyVAL.expr = CompoundExpr{left: yyDollar[1].expr, conjunction: yyDollar[2].token, right: yyDollar[3].expr} 498 } 499 case 10: 500 yyDollar = yyS[yypt-3 : yypt+1] 501 //line parser.go.y:68 502 { 503 yyVAL.expr = yyDollar[2].expr 504 } 505 } 506 goto yystack /* stack new state and value */ 507 }