func fakeInterpreter(pipes *plumbing.Pipes) {
receive := pipes.FromInterpreter()
send := pipes.ToInterpreter()
<-send
q := *ast.NewQuestionNode("A question", "Q1", new(ast.ScalarQuestion),
*new(scanner.Position))
receive <- &plumbing.Frontend{
Type: plumbing.UpdateQuestion,
Identifier: q.Identifier(),
Label: q.Label(),
FieldType: q.Type(),
Value: "No",
}
receive <- &plumbing.Frontend{
Type: plumbing.Flush,
}
}
func qlParse(qllex qlLexer) int {
var qln int
var qllval qlSymType
var qlVAL qlSymType
qlS := make([]qlSymType, qlMaxDepth)
Nerrs := 0 /* number of errors */
Errflag := 0 /* error recovery flag */
qlstate := 0
qlchar := -1
qlp := -1
goto qlstack
ret0:
return 0
ret1:
return 1
qlstack:
/* put a state and value onto the stack */
if qlDebug >= 4 {
__yyfmt__.Printf("char %v in %v\n", qlTokname(qlchar), qlStatname(qlstate))
}
qlp++
if qlp >= len(qlS) {
nyys := make([]qlSymType, len(qlS)*2)
copy(nyys, qlS)
qlS = nyys
}
qlS[qlp] = qlVAL
qlS[qlp].yys = qlstate
qlnewstate:
qln = qlPact[qlstate]
if qln <= qlFlag {
goto qldefault /* simple state */
}
if qlchar < 0 {
qlchar = qllex1(qllex, &qllval)
}
qln += qlchar
if qln < 0 || qln >= qlLast {
goto qldefault
}
qln = qlAct[qln]
if qlChk[qln] == qlchar { /* valid shift */
qlchar = -1
qlVAL = qllval
qlstate = qln
if Errflag > 0 {
Errflag--
}
goto qlstack
}
qldefault:
/* default state action */
qln = qlDef[qlstate]
if qln == -2 {
if qlchar < 0 {
qlchar = qllex1(qllex, &qllval)
}
/* look through exception table */
xi := 0
for {
if qlExca[xi+0] == -1 && qlExca[xi+1] == qlstate {
break
}
xi += 2
}
for xi += 2; ; xi += 2 {
qln = qlExca[xi+0]
if qln < 0 || qln == qlchar {
break
}
}
qln = qlExca[xi+1]
if qln < 0 {
goto ret0
}
}
if qln == 0 {
/* error ... attempt to resume parsing */
switch Errflag {
case 0: /* brand new error */
qllex.Error("syntax error")
Nerrs++
if qlDebug >= 1 {
__yyfmt__.Printf("%s", qlStatname(qlstate))
__yyfmt__.Printf(" saw %s\n", qlTokname(qlchar))
}
fallthrough
case 1, 2: /* incompletely recovered error ... try again */
Errflag = 3
/* find a state where "error" is a legal shift action */
for qlp >= 0 {
qln = qlPact[qlS[qlp].yys] + qlErrCode
if qln >= 0 && qln < qlLast {
qlstate = qlAct[qln] /* simulate a shift of "error" */
if qlChk[qlstate] == qlErrCode {
goto qlstack
}
}
/* the current p has no shift on "error", pop stack */
if qlDebug >= 2 {
__yyfmt__.Printf("error recovery pops state %d\n", qlS[qlp].yys)
}
qlp--
}
/* there is no state on the stack with an error shift ... abort */
goto ret1
case 3: /* no shift yet; clobber input char */
if qlDebug >= 2 {
__yyfmt__.Printf("error recovery discards %s\n", qlTokname(qlchar))
}
if qlchar == qlEofCode {
goto ret1
}
qlchar = -1
goto qlnewstate /* try again in the same state */
}
}
/* reduction by production qln */
if qlDebug >= 2 {
__yyfmt__.Printf("reduce %v in:\n\t%v\n", qln, qlStatname(qlstate))
}
qlnt := qln
qlpt := qlp
_ = qlpt // guard against "declared and not used"
qlp -= qlR2[qln]
qlVAL = qlS[qlp+1]
/* consult goto table to find next state */
qln = qlR1[qln]
qlg := qlPgo[qln]
qlj := qlg + qlS[qlp].yys + 1
if qlj >= qlLast {
qlstate = qlAct[qlg]
} else {
qlstate = qlAct[qlj]
if qlChk[qlstate] != -qln {
qlstate = qlAct[qlg]
}
}
// dummy call; replaced with literal code
switch qlnt {
case 1:
//line parser.y:71
{
finalQuestionaire = qlS[qlpt-0].questionaire
}
case 2:
//line parser.y:78
{
qlVAL.questionaire = ast.NewQuestionaireNode(qlS[qlpt-3].content, qlS[qlpt-1].stack, qlS[qlpt-3].position)
}
case 4:
//line parser.y:85
{
q := qlS[qlpt-0].question
qs := qlVAL.stack
action := ast.NewActionNode(q, qlS[qlpt-0].position)
qs = append(qs, action)
qlVAL.stack = qs
}
case 5:
//line parser.y:93
{
ifNode := qlS[qlpt-0].ifNode
qs := qlVAL.stack
action := ast.NewActionNode(ifNode, qlS[qlpt-0].position)
qs = append(qs, action)
qlVAL.stack = qs
}
case 6:
//line parser.y:104
{
qlVAL.question = ast.NewQuestionNode(qlS[qlpt-2].content, qlS[qlpt-1].content, qlS[qlpt-0].questionType, qlS[qlpt-2].position)
}
case 7:
//line parser.y:112
{
qlVAL.questionType = ast.NewScalarQuestion(qlS[qlpt-0].content, qlS[qlpt-0].position)
}
case 8:
//line parser.y:116
{
qlVAL.questionType = ast.NewComputedQuestion(qlS[qlpt-0].evaluatable, qlS[qlpt-0].position)
}
case 9:
//line parser.y:123
{
qlVAL.ifNode = ast.NewIfNode(qlS[qlpt-4].evaluatable, qlS[qlpt-1].stack, nil, qlS[qlpt-6].position)
qlVAL.evaluatable = new(ast.Evaluatable)
qlVAL.stack = []*ast.ActionNode{}
qlS[qlpt-4].evaluatable = new(ast.Evaluatable)
qlS[qlpt-1].stack = []*ast.ActionNode{}
}
case 10:
//line parser.y:132
{
qlVAL.ifNode = ast.NewIfNode(qlS[qlpt-6].evaluatable, qlS[qlpt-3].stack, qlS[qlpt-0].ifNode, qlS[qlpt-8].position)
qlVAL.evaluatable = new(ast.Evaluatable)
qlVAL.stack = []*ast.ActionNode{}
qlS[qlpt-6].evaluatable = new(ast.Evaluatable)
qlS[qlpt-3].stack = []*ast.ActionNode{}
qlS[qlpt-0].ifNode = nil
}
case 11:
//line parser.y:142
{
elseNode := ast.NewIfNode(
ast.NewTermNode(ast.NumericLiteralNodeType, true, 1, "", "", qlS[qlpt-3].position),
qlS[qlpt-1].stack,
nil,
qlS[qlpt-3].position,
)
qlVAL.ifNode = ast.NewIfNode(qlS[qlpt-8].evaluatable, qlS[qlpt-5].stack, elseNode, qlS[qlpt-10].position)
qlVAL.evaluatable = new(ast.Evaluatable)
qlVAL.stack = []*ast.ActionNode{}
qlS[qlpt-8].evaluatable = new(ast.Evaluatable)
qlS[qlpt-5].stack = []*ast.ActionNode{}
qlS[qlpt-1].stack = []*ast.ActionNode{}
}
case 12:
//line parser.y:161
{
qlVAL.evaluatable = ast.NewBoolAndNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 13:
//line parser.y:165
{
qlVAL.evaluatable = ast.NewBoolOrNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 15:
//line parser.y:173
{
qlVAL.evaluatable = ast.NewEqualsNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 16:
//line parser.y:177
{
qlVAL.evaluatable = ast.NewNotEqualsNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 17:
//line parser.y:181
{
qlVAL.evaluatable = ast.NewMoreThanNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 18:
//line parser.y:185
{
qlVAL.evaluatable = ast.NewLessThanNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 19:
//line parser.y:189
{
qlVAL.evaluatable = ast.NewMoreOrEqualsThanNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 20:
//line parser.y:193
{
qlVAL.evaluatable = ast.NewLessOrEqualsThanNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 21:
//line parser.y:197
{
qlVAL.evaluatable = ast.NewLikeNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 22:
//line parser.y:201
{
qlVAL.evaluatable = ast.NewBoolNegNode(qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 24:
//line parser.y:209
{
qlVAL.evaluatable = ast.NewMathAddNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 25:
//line parser.y:213
{
qlVAL.evaluatable = ast.NewMathSubNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 26:
//line parser.y:217
{
qlVAL.evaluatable = ast.NewMathMulNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 27:
//line parser.y:221
{
qlVAL.evaluatable = ast.NewMathDivNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 28:
//line parser.y:225
{
qlVAL.evaluatable = ast.NewMathModNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 29:
//line parser.y:229
{
qlVAL.evaluatable = ast.NewConcatNode(qlS[qlpt-2].evaluatable, qlS[qlpt-0].evaluatable, qlS[qlpt-1].position)
}
case 30:
//line parser.y:233
{
qlVAL = qlS[qlpt-1]
}
case 31:
//line parser.y:237
{
qlVAL.evaluatable = qlS[qlpt-0].termNode
qlVAL.position = qlS[qlpt-0].position
}
case 32:
//line parser.y:245
{
num, _ := strconv.ParseFloat(qlS[qlpt-0].content, 32)
qlVAL.num = float32(num)
termNode := ast.NewTermNode(
ast.NumericLiteralNodeType,
false,
qlVAL.num,
"",
"",
qlS[qlpt-0].position,
)
qlVAL.termNode = termNode
}
case 33:
//line parser.y:259
{
termNode := ast.NewTermNode(
ast.IdentifierReferenceNodeType,
false,
qlVAL.num,
"",
qlS[qlpt-0].content,
qlS[qlpt-0].position,
)
qlVAL.termNode = termNode
}
case 34:
//line parser.y:271
{
termNode := ast.NewTermNode(
ast.StringLiteralNodeType,
false,
qlVAL.num,
qlS[qlpt-0].content,
"",
qlS[qlpt-0].position,
)
qlVAL.termNode = termNode
}
case 35:
//line parser.y:283
{
termNode := ast.NewTermNode(
ast.BooleanLiteralNodeType,
true,
1,
"",
"",
qlS[qlpt-0].position,
)
qlVAL.termNode = termNode
}
case 36:
//line parser.y:295
{
termNode := ast.NewTermNode(
ast.BooleanLiteralNodeType,
false,
0,
"",
"",
qlS[qlpt-0].position,
)
qlVAL.termNode = termNode
}
}
goto qlstack /* stack new state and value */
}