ast_test.go

// CAUTION: Generated by yy - DO NOT EDIT.

// Copyright 2015 The PL0 Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package pl0

import (
	"fmt"
)

func ExampleBlock() {
	fmt.Println(exampleAST(3, "CALL x."))
	// Output:
	// &pl0.Block{
	// · Statement: &pl0.Statement{
	// · · Case: 2,
	// · · Token: example3.pl0:1:1: CALL,
	// · · Token2: example3.pl0:1:6: IDENT "x",
	// · },
	// }
}

func ExampleCondition() {
	fmt.Println(exampleAST(36, "IF ODD a DO"))
	// Output:
	// &pl0.Condition{
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example36.pl0:1:8: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Token: example36.pl0:1:4: ODD,
	// }
}

func ExampleCondition_case1() {
	fmt.Println(exampleAST(37, "IF a = b DO"))
	// Output:
	// &pl0.Condition{
	// · Case: 1,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example37.pl0:1:4: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Expression2: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example37.pl0:1:8: IDENT "b",
	// · · · },
	// · · },
	// · },
	// · Token: example37.pl0:1:6: '=',
	// }
}

func ExampleCondition_case2() {
	fmt.Println(exampleAST(38, "IF a # b DO"))
	// Output:
	// &pl0.Condition{
	// · Case: 2,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example38.pl0:1:4: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Expression2: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example38.pl0:1:8: IDENT "b",
	// · · · },
	// · · },
	// · },
	// · Token: example38.pl0:1:6: '#',
	// }
}

func ExampleCondition_case3() {
	fmt.Println(exampleAST(39, "IF a < b DO"))
	// Output:
	// &pl0.Condition{
	// · Case: 3,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example39.pl0:1:4: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Expression2: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example39.pl0:1:8: IDENT "b",
	// · · · },
	// · · },
	// · },
	// · Token: example39.pl0:1:6: '<',
	// }
}

func ExampleCondition_case4() {
	fmt.Println(exampleAST(40, "IF a <= b DO"))
	// Output:
	// &pl0.Condition{
	// · Case: 4,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example40.pl0:1:4: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Expression2: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example40.pl0:1:9: IDENT "b",
	// · · · },
	// · · },
	// · },
	// · Token: example40.pl0:1:6: LEQ,
	// }
}

func ExampleCondition_case5() {
	fmt.Println(exampleAST(41, "IF a > b DO"))
	// Output:
	// &pl0.Condition{
	// · Case: 5,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example41.pl0:1:4: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Expression2: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example41.pl0:1:8: IDENT "b",
	// · · · },
	// · · },
	// · },
	// · Token: example41.pl0:1:6: '>',
	// }
}

func ExampleCondition_case6() {
	fmt.Println(exampleAST(42, "IF a >= b DO"))
	// Output:
	// &pl0.Condition{
	// · Case: 6,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example42.pl0:1:4: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Expression2: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example42.pl0:1:9: IDENT "b",
	// · · · },
	// · · },
	// · },
	// · Token: example42.pl0:1:6: GEQ,
	// }
}

func ExampleConstSpec() {
	fmt.Println(exampleAST(9, "CONST a = 98 ,"))
	// Output:
	// &pl0.ConstSpec{
	// · Number: &pl0.Number{
	// · · Value: 98,
	// · · Token: example9.pl0:1:11: NUMBER "98",
	// · },
	// · Token: example9.pl0:1:7: IDENT "a",
	// · Token2: example9.pl0:1:9: '=',
	// }
}

func ExampleConstSpecList() {
	fmt.Println(exampleAST(7, "CONST a = 98 ,"))
	// Output:
	// &pl0.ConstSpecList{
	// · ConstSpec: &pl0.ConstSpec{
	// · · Number: &pl0.Number{
	// · · · Value: 98,
	// · · · Token: example7.pl0:1:11: NUMBER "98",
	// · · },
	// · · Token: example7.pl0:1:7: IDENT "a",
	// · · Token2: example7.pl0:1:9: '=',
	// · },
	// }
}

func ExampleConstSpecList_case1() {
	fmt.Println(exampleAST(8, "CONST a = 98 , c = 100 ,"))
	// Output:
	// &pl0.ConstSpecList{
	// · ConstSpec: &pl0.ConstSpec{
	// · · Number: &pl0.Number{
	// · · · Value: 98,
	// · · · Token: example8.pl0:1:11: NUMBER "98",
	// · · },
	// · · Token: example8.pl0:1:7: IDENT "a",
	// · · Token2: example8.pl0:1:9: '=',
	// · },
	// · ConstSpecList: &pl0.ConstSpecList{
	// · · Case: 1,
	// · · ConstSpec: &pl0.ConstSpec{
	// · · · Number: &pl0.Number{
	// · · · · Value: 100,
	// · · · · Token: example8.pl0:1:20: NUMBER "100",
	// · · · },
	// · · · Token: example8.pl0:1:16: IDENT "c",
	// · · · Token2: example8.pl0:1:18: '=',
	// · · },
	// · · Token: example8.pl0:1:14: ',',
	// · },
	// }
}

func ExampleConsts() {
	fmt.Println(exampleAST(6, "CONST a = 98 ; !"))
	// Output:
	// &pl0.Consts{
	// · ConstSpecList: &pl0.ConstSpecList{
	// · · ConstSpec: &pl0.ConstSpec{
	// · · · Number: &pl0.Number{
	// · · · · Value: 98,
	// · · · · Token: example6.pl0:1:11: NUMBER "98",
	// · · · },
	// · · · Token: example6.pl0:1:7: IDENT "a",
	// · · · Token2: example6.pl0:1:9: '=',
	// · · },
	// · },
	// · Token: example6.pl0:1:1: CONST,
	// · Token2: example6.pl0:1:14: ';',
	// }
}

func ExampleConstsOpt() {
	fmt.Println(exampleAST(4, "!") == (*ConstsOpt)(nil))
	// Output:
	// true
}

func ExampleConstsOpt_case1() {
	fmt.Println(exampleAST(5, "CONST a = 98 ; !"))
	// Output:
	// &pl0.ConstsOpt{
	// · Consts: &pl0.Consts{
	// · · ConstSpecList: &pl0.ConstSpecList{
	// · · · ConstSpec: &pl0.ConstSpec{
	// · · · · Number: &pl0.Number{
	// · · · · · Value: 98,
	// · · · · · Token: example5.pl0:1:11: NUMBER "98",
	// · · · · },
	// · · · · Token: example5.pl0:1:7: IDENT "a",
	// · · · · Token2: example5.pl0:1:9: '=',
	// · · · },
	// · · },
	// · · Token: example5.pl0:1:1: CONST,
	// · · Token2: example5.pl0:1:14: ';',
	// · },
	// }
}

func ExampleExpression() {
	fmt.Println(exampleAST(43, "IF + a #"))
	// Output:
	// &pl0.Expression{
	// · Term: &pl0.Term{
	// · · Factor: &pl0.Factor{
	// · · · Token: example43.pl0:1:6: IDENT "a",
	// · · },
	// · },
	// · Token: example43.pl0:1:4: '+',
	// }
}

func ExampleExpression_case1() {
	fmt.Println(exampleAST(44, "IF - a #"))
	// Output:
	// &pl0.Expression{
	// · Case: 1,
	// · Term: &pl0.Term{
	// · · Factor: &pl0.Factor{
	// · · · Token: example44.pl0:1:6: IDENT "a",
	// · · },
	// · },
	// · Token: example44.pl0:1:4: '-',
	// }
}

func ExampleExpression_case2() {
	fmt.Println(exampleAST(45, "IF a #"))
	// Output:
	// &pl0.Expression{
	// · Case: 2,
	// · Term: &pl0.Term{
	// · · Factor: &pl0.Factor{
	// · · · Token: example45.pl0:1:4: IDENT "a",
	// · · },
	// · },
	// }
}

func ExampleExpression_case3() {
	fmt.Println(exampleAST(46, "IF a + b #"))
	// Output:
	// &pl0.Expression{
	// · Case: 3,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example46.pl0:1:4: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Term: &pl0.Term{
	// · · Factor: &pl0.Factor{
	// · · · Token: example46.pl0:1:8: IDENT "b",
	// · · },
	// · },
	// · Token: example46.pl0:1:6: '+',
	// }
}

func ExampleExpression_case4() {
	fmt.Println(exampleAST(47, "IF a - b #"))
	// Output:
	// &pl0.Expression{
	// · Case: 4,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example47.pl0:1:4: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Term: &pl0.Term{
	// · · Factor: &pl0.Factor{
	// · · · Token: example47.pl0:1:8: IDENT "b",
	// · · },
	// · },
	// · Token: example47.pl0:1:6: '-',
	// }
}

func ExampleFactor() {
	fmt.Println(exampleAST(51, "IF a #"))
	// Output:
	// &pl0.Factor{
	// · Token: example51.pl0:1:4: IDENT "a",
	// }
}

func ExampleFactor_case1() {
	fmt.Println(exampleAST(52, "WHILE 97 #"))
	// Output:
	// &pl0.Factor{
	// · Case: 1,
	// · Number: &pl0.Number{
	// · · Value: 97,
	// · · Token: example52.pl0:1:7: NUMBER "97",
	// · },
	// }
}

func ExampleFactor_case2() {
	fmt.Println(exampleAST(53, "WHILE ( a ) #"))
	// Output:
	// &pl0.Factor{
	// · Case: 2,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example53.pl0:1:9: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Token: example53.pl0:1:7: '(',
	// · Token2: example53.pl0:1:11: ')',
	// }
}

func ExampleNumber() {
	fmt.Println(exampleAST(10, "WHILE 97 #"))
	// Output:
	// &pl0.Number{
	// · Value: 97,
	// · Token: example10.pl0:1:7: NUMBER "97",
	// }
}

func ExampleProcList() {
	fmt.Println(exampleAST(19, "PROCEDURE a ; ; !"))
	// Output:
	// &pl0.ProcList{
	// · ProcSpec: &pl0.ProcSpec{
	// · · Block: &pl0.Block{
	// · · },
	// · · Token: example19.pl0:1:1: PROCEDURE,
	// · · Token2: example19.pl0:1:11: IDENT "a",
	// · · Token3: example19.pl0:1:13: ';',
	// · · Token4: example19.pl0:1:15: ';',
	// · },
	// }
}

func ExampleProcList_case1() {
	fmt.Println(exampleAST(20, "PROCEDURE a ; ; PROCEDURE b ; ; !"))
	// Output:
	// &pl0.ProcList{
	// · ProcList: &pl0.ProcList{
	// · · Case: 1,
	// · · ProcSpec: &pl0.ProcSpec{
	// · · · Block: &pl0.Block{
	// · · · },
	// · · · Token: example20.pl0:1:17: PROCEDURE,
	// · · · Token2: example20.pl0:1:27: IDENT "b",
	// · · · Token3: example20.pl0:1:29: ';',
	// · · · Token4: example20.pl0:1:31: ';',
	// · · },
	// · },
	// · ProcSpec: &pl0.ProcSpec{
	// · · Block: &pl0.Block{
	// · · },
	// · · Token: example20.pl0:1:1: PROCEDURE,
	// · · Token2: example20.pl0:1:11: IDENT "a",
	// · · Token3: example20.pl0:1:13: ';',
	// · · Token4: example20.pl0:1:15: ';',
	// · },
	// }
}

func ExampleProcListOpt() {
	fmt.Println(exampleAST(17, "!") == (*ProcListOpt)(nil))
	// Output:
	// true
}

func ExampleProcListOpt_case1() {
	fmt.Println(exampleAST(18, "PROCEDURE a ; ; !"))
	// Output:
	// &pl0.ProcListOpt{
	// · ProcList: &pl0.ProcList{
	// · · ProcSpec: &pl0.ProcSpec{
	// · · · Block: &pl0.Block{
	// · · · },
	// · · · Token: example18.pl0:1:1: PROCEDURE,
	// · · · Token2: example18.pl0:1:11: IDENT "a",
	// · · · Token3: example18.pl0:1:13: ';',
	// · · · Token4: example18.pl0:1:15: ';',
	// · · },
	// · },
	// }
}

func ExampleProcSpec() {
	fmt.Println(exampleAST(22, "PROCEDURE a ; ; !"))
	// Output:
	// &pl0.ProcSpec{
	// · Block: &pl0.Block{
	// · },
	// · Token: example22.pl0:1:1: PROCEDURE,
	// · Token2: example22.pl0:1:11: IDENT "a",
	// · Token3: example22.pl0:1:13: ';',
	// · Token4: example22.pl0:1:15: ';',
	// }
}

func ExampleProgram() {
	fmt.Println(exampleAST(1, "."))
	// Output:
	// &pl0.Program{
	// · Code: []*pl0.Call{ // len 5
	// · · 0: &pl0.Call{
	// · · · Target: 2,
	// · · },
	// · · 1: &pl0.Halt{
	// · · · Addr: 1,
	// · · },
	// · · 2: &pl0.Enter{
	// · · · Addr: 2,
	// · · · Token: example1.pl0:1:1: '.',
	// · · },
	// · · 3: &pl0.Jmp{
	// · · · Addr: 3,
	// · · · Target: 4,
	// · · },
	// · · 4: &pl0.Leave{
	// · · · Addr: 4,
	// · · },
	// · },
	// · Block: &pl0.Block{
	// · },
	// · Token: example1.pl0:1:1: '.',
	// }
}

func ExampleStatement() {
	fmt.Println(exampleAST(23, ".") == (*Statement)(nil))
	// Output:
	// true
}

func ExampleStatement_case1() {
	fmt.Println(exampleAST(24, "a := b ."))
	// Output:
	// &pl0.Statement{
	// · Case: 1,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example24.pl0:1:6: IDENT "b",
	// · · · },
	// · · },
	// · },
	// · Token: example24.pl0:1:1: IDENT "a",
	// · Token2: example24.pl0:1:3: ASSIGN,
	// }
}

func ExampleStatement_case2() {
	fmt.Println(exampleAST(25, "CALL a ."))
	// Output:
	// &pl0.Statement{
	// · Case: 2,
	// · Token: example25.pl0:1:1: CALL,
	// · Token2: example25.pl0:1:6: IDENT "a",
	// }
}

func ExampleStatement_case3() {
	fmt.Println(exampleAST(26, "? a ."))
	// Output:
	// &pl0.Statement{
	// · Case: 3,
	// · Token: example26.pl0:1:1: '?',
	// · Token2: example26.pl0:1:3: IDENT "a",
	// }
}

func ExampleStatement_case4() {
	fmt.Println(exampleAST(27, "! a ."))
	// Output:
	// &pl0.Statement{
	// · Case: 4,
	// · Expression: &pl0.Expression{
	// · · Case: 2,
	// · · Term: &pl0.Term{
	// · · · Factor: &pl0.Factor{
	// · · · · Token: example27.pl0:1:3: IDENT "a",
	// · · · },
	// · · },
	// · },
	// · Token: example27.pl0:1:1: '!',
	// }
}

func ExampleStatement_case5() {
	fmt.Println(exampleAST(28, "BEGIN END ."))
	// Output:
	// &pl0.Statement{
	// · Case: 5,
	// · Token: example28.pl0:1:1: BEGIN,
	// · Token2: example28.pl0:1:7: END,
	// }
}

func ExampleStatement_case6() {
	fmt.Println(exampleAST(30, "IF ODD a THEN ."))
	// Output:
	// &pl0.Statement{
	// · Case: 6,
	// · Condition: &pl0.Condition{
	// · · Expression: &pl0.Expression{
	// · · · Case: 2,
	// · · · Term: &pl0.Term{
	// · · · · Factor: &pl0.Factor{
	// · · · · · Token: example30.pl0:1:8: IDENT "a",
	// · · · · },
	// · · · },
	// · · },
	// · · Token: example30.pl0:1:4: ODD,
	// · },
	// · Token: example30.pl0:1:1: IF,
	// · Token2: example30.pl0:1:10: THEN,
	// }
}

func ExampleStatement_case7() {
	fmt.Println(exampleAST(33, "WHILE ODD a DO ."))
	// Output:
	// &pl0.Statement{
	// · Case: 7,
	// · Condition: &pl0.Condition{
	// · · Expression: &pl0.Expression{
	// · · · Case: 2,
	// · · · Term: &pl0.Term{
	// · · · · Factor: &pl0.Factor{
	// · · · · · Token: example33.pl0:1:11: IDENT "a",
	// · · · · },
	// · · · },
	// · · },
	// · · Token: example33.pl0:1:7: ODD,
	// · },
	// · Token: example33.pl0:1:1: WHILE,
	// · Token2: example33.pl0:1:13: DO,
	// }
}

func ExampleStatementList() {
	fmt.Println(exampleAST(34, "BEGIN i := 42 END"))
	// Output:
	// &pl0.StatementList{
	// · Statement: &pl0.Statement{
	// · · Case: 1,
	// · · Expression: &pl0.Expression{
	// · · · Case: 2,
	// · · · Term: &pl0.Term{
	// · · · · Factor: &pl0.Factor{
	// · · · · · Case: 1,
	// · · · · · Number: &pl0.Number{
	// · · · · · · Value: 42,
	// · · · · · · Token: example34.pl0:1:12: NUMBER "42",
	// · · · · · },
	// · · · · },
	// · · · },
	// · · },
	// · · Token: example34.pl0:1:7: IDENT "i",
	// · · Token2: example34.pl0:1:9: ASSIGN,
	// · },
	// }
}

func ExampleStatementList_case1() {
	fmt.Println(exampleAST(35, "BEGIN ; ;"))
	// Output:
	// &pl0.StatementList{
	// · StatementList: &pl0.StatementList{
	// · · Case: 1,
	// · · Token: example35.pl0:1:7: ';',
	// · },
	// }
}

func ExampleTerm() {
	fmt.Println(exampleAST(48, "IF a #"))
	// Output:
	// &pl0.Term{
	// · Factor: &pl0.Factor{
	// · · Token: example48.pl0:1:4: IDENT "a",
	// · },
	// }
}

func ExampleTerm_case1() {
	fmt.Println(exampleAST(49, "IF a * b #"))
	// Output:
	// &pl0.Term{
	// · Case: 1,
	// · Factor: &pl0.Factor{
	// · · Token: example49.pl0:1:8: IDENT "b",
	// · },
	// · Term: &pl0.Term{
	// · · Factor: &pl0.Factor{
	// · · · Token: example49.pl0:1:4: IDENT "a",
	// · · },
	// · },
	// · Token: example49.pl0:1:6: '*',
	// }
}

func ExampleTerm_case2() {
	fmt.Println(exampleAST(50, "IF a / b #"))
	// Output:
	// &pl0.Term{
	// · Case: 2,
	// · Factor: &pl0.Factor{
	// · · Token: example50.pl0:1:8: IDENT "b",
	// · },
	// · Term: &pl0.Term{
	// · · Factor: &pl0.Factor{
	// · · · Token: example50.pl0:1:4: IDENT "a",
	// · · },
	// · },
	// · Token: example50.pl0:1:6: '/',
	// }
}

func ExampleVariable() {
	fmt.Println(exampleAST(14, "VAR a ,"))
	// Output:
	// &pl0.Variable{
	// · Token: example14.pl0:1:5: IDENT "a",
	// }
}

func ExampleVariableList() {
	fmt.Println(exampleAST(15, "VAR a ,"))
	// Output:
	// &pl0.VariableList{
	// · Variable: &pl0.Variable{
	// · · Token: example15.pl0:1:5: IDENT "a",
	// · },
	// }
}

func ExampleVariableList_case1() {
	fmt.Println(exampleAST(16, "VAR a , b ,"))
	// Output:
	// &pl0.VariableList{
	// · Variable: &pl0.Variable{
	// · · Token: example16.pl0:1:5: IDENT "a",
	// · },
	// · VariableList: &pl0.VariableList{
	// · · Case: 1,
	// · · Token: example16.pl0:1:7: ',',
	// · · Variable: &pl0.Variable{
	// · · · Token: example16.pl0:1:9: IDENT "b",
	// · · },
	// · },
	// }
}

func ExampleVars() {
	fmt.Println(exampleAST(13, "VAR a ; !"))
	// Output:
	// &pl0.Vars{
	// · Token: example13.pl0:1:1: VAR,
	// · Token2: example13.pl0:1:7: ';',
	// · VariableList: &pl0.VariableList{
	// · · Variable: &pl0.Variable{
	// · · · Token: example13.pl0:1:5: IDENT "a",
	// · · },
	// · },
	// }
}

func ExampleVarsOpt() {
	fmt.Println(exampleAST(11, "!") == (*VarsOpt)(nil))
	// Output:
	// true
}

func ExampleVarsOpt_case1() {
	fmt.Println(exampleAST(12, "VAR a ; !"))
	// Output:
	// &pl0.VarsOpt{
	// · Vars: &pl0.Vars{
	// · · Token: example12.pl0:1:1: VAR,
	// · · Token2: example12.pl0:1:7: ';',
	// · · VariableList: &pl0.VariableList{
	// · · · Variable: &pl0.Variable{
	// · · · · Token: example12.pl0:1:5: IDENT "a",
	// · · · },
	// · · },
	// · },
	// }
}