From a460b3a2290d5c5078ddc479be39694487839f1c Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Fri, 16 Feb 2018 04:47:02 +0100 Subject: checkin generated code --- main.go | 2 +- parser.go | 728 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 729 insertions(+), 1 deletion(-) create mode 100644 parser.go diff --git a/main.go b/main.go index 267c96c..d930058 100644 --- a/main.go +++ b/main.go @@ -1,6 +1,6 @@ package main -//go:generate -command yacc go tool yacc +//go:generate -command yacc goyacc //go:generate yacc -o parser.go parser.y import ( diff --git a/parser.go b/parser.go new file mode 100644 index 0000000..f25d7bb --- /dev/null +++ b/parser.go @@ -0,0 +1,728 @@ +//line parser.y:2 +package main + +import __yyfmt__ "fmt" + +//line parser.y:2 +import "fmt" + +var vars = map[string]interface{}{} + +//line parser.y:9 +type yySymType struct { + yys int + sval string + ival int64 + fval float64 + cval complex128 + any interface{} +} + +const STRING = 57346 +const QUOTED = 57347 +const INTEGER = 57348 +const FLOAT = 57349 +const COMPLEX = 57350 +const QUOTE = 57351 +const DOT = 57352 +const RAVEL = 57353 +const SLASH = 57354 +const BACKSLASH = 57355 +const LBRACE = 57356 +const RBRACE = 57357 +const LBRACKET = 57358 +const RBRACKET = 57359 +const PLUS = 57360 +const MINUS = 57361 +const DIAMOND = 57362 +const EACH = 57363 +const NEG = 57364 +const LESS = 57365 +const LESSEQ = 57366 +const EQ = 57367 +const MOREEQ = 57368 +const MORE = 57369 +const NEQ = 57370 +const OR = 57371 +const AND = 57372 +const TIMES = 57373 +const DIV = 57374 +const GRADEDOWN = 57375 +const GRADEUP = 57376 +const ROTH = 57377 +const TRANSPOSE = 57378 +const ROTV = 57379 +const LOG = 57380 +const NOR = 57381 +const NAND = 57382 +const FACTORIAL = 57383 +const INVERSE = 57384 +const ROLL = 57385 +const OMEGA = 57386 +const EPSILON = 57387 +const RHO = 57388 +const NOT = 57389 +const TAKE = 57390 +const DROP = 57391 +const IOTA = 57392 +const PI = 57393 +const EXP = 57394 +const ASSIGN = 57395 +const BRANCH = 57396 +const QUOTEQUAD = 57397 +const ZILDE = 57398 +const ALPHA = 57399 +const CEILING = 57400 +const FLOOR = 57401 +const DEL = 57402 +const DELTA = 57403 +const JOT = 57404 +const QUAD = 57405 +const EXECUTE = 57406 +const FORMAT = 57407 +const ENCLOSE = 57408 +const DISCLOSE = 57409 +const DECODE = 57410 +const ENCODE = 57411 +const MAGNITUDE = 57412 +const SCAN = 57413 +const REDUCE = 57414 + +var yyToknames = [...]string{ + "$end", + "error", + "$unk", + "STRING", + "QUOTED", + "INTEGER", + "FLOAT", + "COMPLEX", + "QUOTE", + "DOT", + "RAVEL", + "SLASH", + "BACKSLASH", + "LBRACE", + "RBRACE", + "LBRACKET", + "RBRACKET", + "PLUS", + "MINUS", + "DIAMOND", + "EACH", + "NEG", + "LESS", + "LESSEQ", + "EQ", + "MOREEQ", + "MORE", + "NEQ", + "OR", + "AND", + "TIMES", + "DIV", + "GRADEDOWN", + "GRADEUP", + "ROTH", + "TRANSPOSE", + "ROTV", + "LOG", + "NOR", + "NAND", + "FACTORIAL", + "INVERSE", + "ROLL", + "OMEGA", + "EPSILON", + "RHO", + "NOT", + "TAKE", + "DROP", + "IOTA", + "PI", + "EXP", + "ASSIGN", + "BRANCH", + "QUOTEQUAD", + "ZILDE", + "ALPHA", + "CEILING", + "FLOOR", + "DEL", + "DELTA", + "JOT", + "QUAD", + "EXECUTE", + "FORMAT", + "ENCLOSE", + "DISCLOSE", + "DECODE", + "ENCODE", + "MAGNITUDE", + "SCAN", + "REDUCE", +} +var yyStatenames = [...]string{} + +const yyEofCode = 1 +const yyErrCode = 2 +const yyInitialStackSize = 16 + +//line parser.y:139 +//line yacctab:1 +var yyExca = [...]int{ + -1, 1, + 1, -1, + -2, 0, + -1, 65, + 21, 83, + 23, 83, + 24, 83, + 25, 83, + 26, 83, + 27, 83, + 28, 83, + 29, 83, + 30, 83, + 39, 83, + 40, 83, + 45, 83, + 48, 83, + 49, 83, + 68, 83, + 69, 83, + -2, 60, + -1, 66, + 21, 81, + 23, 81, + 24, 81, + 25, 81, + 26, 81, + 27, 81, + 28, 81, + 29, 81, + 30, 81, + 39, 81, + 40, 81, + 45, 81, + 48, 81, + 49, 81, + 68, 81, + 69, 81, + -2, 61, +} + +const yyPrivate = 57344 + +const yyLast = 261 + +var yyAct = [...]int{ + + 38, 64, 66, 65, 88, 46, 90, 3, 48, 49, + 9, 75, 87, 76, 77, 78, 79, 80, 81, 82, + 83, 50, 51, 89, 7, 69, 73, 70, 71, 84, + 85, 74, 68, 54, 6, 55, 58, 5, 59, 60, + 67, 53, 52, 42, 43, 44, 45, 1, 56, 57, + 0, 0, 39, 92, 0, 72, 0, 0, 61, 62, + 63, 37, 35, 8, 42, 43, 44, 45, 0, 38, + 22, 34, 36, 0, 41, 0, 0, 19, 18, 0, + 0, 0, 4, 0, 0, 47, 0, 0, 0, 0, + 20, 21, 29, 28, 27, 32, 26, 25, 0, 96, + 33, 23, 10, 0, 0, 13, 14, 0, 0, 16, + 24, 17, 0, 0, 0, 0, 0, 11, 12, 0, + 0, 39, 40, 30, 31, 64, 94, 93, 0, 15, + 37, 35, 48, 49, 0, 75, 0, 76, 77, 78, + 79, 80, 81, 82, 83, 50, 51, 0, 0, 69, + 73, 70, 71, 84, 85, 74, 68, 54, 0, 55, + 58, 0, 59, 60, 67, 53, 52, 2, 22, 47, + 0, 86, 56, 57, 47, 19, 18, 0, 47, 72, + 47, 0, 61, 62, 63, 0, 0, 0, 20, 21, + 29, 28, 27, 32, 26, 25, 0, 0, 33, 23, + 10, 0, 0, 13, 14, 0, 0, 16, 24, 17, + 0, 0, 0, 0, 91, 11, 12, 0, 0, 0, + 0, 30, 31, 0, 0, 0, 0, 15, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 95, 0, 0, 0, 0, + 97, +} +var yyPact = [...]int{ + + -1000, 59, -10, 59, 157, -1000, -1000, -1000, -49, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 19, 2, -1000, -1000, -1000, -1000, 59, 114, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -10, 59, 38, -1000, + -1000, -10, 59, -1000, -1000, -10, -1000, -10, +} +var yyPgo = [...]int{ + + 0, 10, 47, 167, 7, 82, 5, 37, 34, 24, +} +var yyR1 = [...]int{ + + 0, 2, 2, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 7, 8, 9, 1, 1, 1, 1, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 5, 5, 5, 5, 5, 5, +} +var yyR2 = [...]int{ + + 0, 0, 2, 2, 3, 3, 4, 1, 1, 1, + 1, 1, 3, 2, 2, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, +} +var yyChk = [...]int{ + + -1000, -2, -3, -4, -5, -7, -8, -9, 4, -1, + 43, 58, 59, 46, 47, 70, 50, 52, 19, 18, + 31, 32, 11, 42, 51, 38, 37, 35, 34, 33, + 64, 65, 36, 41, 12, 72, 13, 71, 10, 62, + 63, 15, 5, 6, 7, 8, -6, -5, 18, 19, + 31, 32, 52, 51, 43, 45, 58, 59, 46, 48, + 49, 68, 69, 70, 11, 13, 12, 50, 42, 35, + 37, 38, 65, 36, 41, 21, 23, 24, 25, 26, + 27, 28, 29, 30, 39, 40, -3, -4, 53, 4, + 4, -3, -6, 13, 12, -3, -1, -3, +} +var yyDef = [...]int{ + + 1, -2, 2, 0, 0, 7, 8, 9, 10, 11, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 81, 82, 83, 84, 85, 86, + 0, 0, 15, 16, 17, 18, 0, 0, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, -2, -2, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 3, 0, 0, 13, + 14, 5, 0, 60, 61, 4, 12, 6, +} +var yyTok1 = [...]int{ + + 1, +} +var yyTok2 = [...]int{ + + 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, +} +var yyTok3 = [...]int{ + 0, +} + +var yyErrorMessages = [...]struct { + state int + token int + msg string +}{} + +//line yaccpar:1 + +/* parser for yacc output */ + +var ( + yyDebug = 0 + yyErrorVerbose = false +) + +type yyLexer interface { + Lex(lval *yySymType) int + Error(s string) +} + +type yyParser interface { + Parse(yyLexer) int + Lookahead() int +} + +type yyParserImpl struct { + lval yySymType + stack [yyInitialStackSize]yySymType + char int +} + +func (p *yyParserImpl) Lookahead() int { + return p.char +} + +func yyNewParser() yyParser { + return &yyParserImpl{} +} + +const yyFlag = -1000 + +func yyTokname(c int) string { + if c >= 1 && c-1 < len(yyToknames) { + if yyToknames[c-1] != "" { + return yyToknames[c-1] + } + } + return __yyfmt__.Sprintf("tok-%v", c) +} + +func yyStatname(s int) string { + if s >= 0 && s < len(yyStatenames) { + if yyStatenames[s] != "" { + return yyStatenames[s] + } + } + return __yyfmt__.Sprintf("state-%v", s) +} + +func yyErrorMessage(state, lookAhead int) string { + 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 +} + +func yylex1(lex yyLexer, lval *yySymType) (char, token int) { + 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 +} + +func yyParse(yylex yyLexer) int { + return yyNewParser().Parse(yylex) +} + +func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int { + var yyn int + var yyVAL yySymType + var yyDollar []yySymType + _ = yyDollar // silence set and not used + yyS := yyrcvr.stack[:] + + Nerrs := 0 /* number of errors */ + Errflag := 0 /* error recovery flag */ + yystate := 0 + yyrcvr.char = -1 + yytoken := -1 // yyrcvr.char translated into internal numbering + defer func() { + // Make sure we report no lookahead when not parsing. + yystate = -1 + yyrcvr.char = -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 yyrcvr.char < 0 { + yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval) + } + yyn += yytoken + if yyn < 0 || yyn >= yyLast { + goto yydefault + } + yyn = yyAct[yyn] + if yyChk[yyn] == yytoken { /* valid shift */ + yyrcvr.char = -1 + yytoken = -1 + yyVAL = yyrcvr.lval + yystate = yyn + if Errflag > 0 { + Errflag-- + } + goto yystack + } + +yydefault: + /* default state action */ + yyn = yyDef[yystate] + if yyn == -2 { + if yyrcvr.char < 0 { + yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval) + } + + /* 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 + } + yyrcvr.char = -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 10: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.y:47 + { + fmt.Println(vars[yyDollar[1].sval]) + } + case 11: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.y:48 + { + fmt.Println(yyDollar[1].any) + } + case 12: + yyDollar = yyS[yypt-3 : yypt+1] + //line parser.y:51 + { + vars[yyDollar[1].sval] = yyDollar[3].any + } + case 13: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.y:54 + { + fmt.Println(quad(string(yyDollar[2].sval))) + } + case 14: + yyDollar = yyS[yypt-2 : yypt+1] + //line parser.y:57 + { + cmd(string(yyDollar[2].sval)) + } + case 15: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.y:60 + { + yyVAL.any = yyDollar[1].sval + } + case 16: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.y:61 + { + yyVAL.any = yyDollar[1].ival + } + case 17: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.y:62 + { + yyVAL.any = yyDollar[1].fval + } + case 18: + yyDollar = yyS[yypt-1 : yypt+1] + //line parser.y:63 + { + yyVAL.any = yyDollar[1].cval + } + } + goto yystack /* stack new state and value */ +} -- cgit v1.2.3