arm/armspec: remove unfinished code
This was the start of something but never completed.
It's in the history if we need it.
Change-Id: I059e0822c33fe78df3bb988a155a8bcdca677ada
Reviewed-on: https://go-review.googlesource.com/13973
Reviewed-by: Ian Lance Taylor <iant@golang.org>
diff --git a/arm/armspec/code.go b/arm/armspec/code.go
deleted file mode 100644
index 5269d21..0000000
--- a/arm/armspec/code.go
+++ /dev/null
@@ -1,985 +0,0 @@
-// Copyright 2014 The Go 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 main
-
-import (
- "bytes"
- "fmt"
- "reflect"
- "strconv"
- "strings"
-)
-
-var errSeeOther = fmt.Errorf("see other")
-var errStop = fmt.Errorf("stop")
-var errUndefined = fmt.Errorf("undefined")
-
-type StmtOp int
-
-const (
- _ StmtOp = iota
- Assign // 1
- Return
- Undefined
- Unpredictable
- See
- ImplDefined
- SubarchDefined
- If
- Repeat
- While // 10
- For
- Case
- Enum
- Block
- StmtExpr
- Fndef
- Assert
-)
-
-type Stmt struct {
- Op StmtOp
- X, Y, Z *Expr
- List []*Expr
- Text string
- Body *Stmt
- Else *Stmt
- When []*When
- ElseIf []*ElseIf
- Block []*Stmt
- Type *Type
-}
-
-type When struct {
- Cond []*Expr
- Body *Stmt
-}
-
-type ElseIf struct {
- Cond *Expr
- Body *Stmt
-}
-
-type ExprOp int
-
-const (
- _ ExprOp = iota
- Blank // 1
- Const
- Name
- Decl
- Unknown
- Call
- ExprTuple
- Eq
- NotEq
- LtEq // 10
- Lt
- GtEq
- Gt
- BitIndex
- IfElse
- Not
- AndAnd
- OrOr
- Eor
- Colon // 20
- And
- Or
- Plus
- Minus
- Add
- Sub
- Mul
- Div
- BigDIV
- BigMOD // 30
- BigAND
- BigOR
- BigEOR
- TwoPow
- Lsh
- Rsh
- Index
- Dot
-)
-
-type Expr struct {
- Op ExprOp
- Text string
- X, Y, Z *Expr
- List []*Expr
- Type *Type
-}
-
-type TypeOp int
-
-const (
- _ TypeOp = iota
- BoolType
- BitType
- IntegerType
- NamedType
- TupleType
-)
-
-type Type struct {
- Op TypeOp
- List []*Type
- N int
- NX *Expr
- Text string
-}
-
-type Exec struct {
- Vars map[string]Value
-}
-
-type Inconsistent struct {
-}
-
-func (Inconsistent) String() string {
- return "INCONSISTENT"
-}
-
-type Bits struct {
- N int
- Val uint32
- DontCare uint32
-}
-
-func (b Bits) String() string {
- var buf bytes.Buffer
- fmt.Fprintf(&buf, "`")
- for i := b.N - 1; i >= 0; i-- {
- if (b.DontCare>>uint(i))&1 != 0 {
- fmt.Fprintf(&buf, "x")
- } else if (b.Val>>uint(i))&1 != 0 {
- fmt.Fprintf(&buf, "1")
- } else {
- fmt.Fprintf(&buf, "0")
- }
- }
- fmt.Fprintf(&buf, "'")
- return buf.String()
-}
-
-func (b Bits) Eq(v Value) bool {
- c := v.(Bits)
- if b.N != c.N {
- panic(fmt.Errorf("compare of mismatched bit lengths %v and %v", b, c))
- }
- return b.Val&^c.DontCare == c.Val
-}
-
-func (b Bits) Lt(v Value) bool {
- panic("less than on bits")
-}
-
-func (b Bits) Gt(v Value) bool {
- panic("greater than on bits")
-}
-
-func isValid(inst *Inst, w uint32) bool {
- var ctxt Exec
- ctxt.Vars = make(map[string]Value)
- off := 0
- for _, b := range strings.Split(inst.Bits, "|") {
- wid := 1
- if i := strings.Index(b, ":"); i >= 0 {
- wid, _ = strconv.Atoi(b[i+1:])
- b = b[:i]
- }
- switch b {
- case "1", "(1)":
- if (w>>uint(31-off))&1 != 1 {
- return false
- }
- case "0", "(0)":
- if (w>>uint(31-off))&1 != 0 {
- return false
- }
- default:
- bits := Bits{N: wid, Val: (w >> uint(32-off-wid)) & (1<<uint(wid) - 1)}
- // fmt.Print(b, " ", bits)
- if old, ok := ctxt.Vars[b]; ok && old != bits {
- ctxt.Define(b, Inconsistent{})
- }
- ctxt.Define(b, bits)
- }
- off += wid
- }
- // fmt.Println()
-
- for _, stmt := range inst.Prog {
- err := ctxt.stmt(stmt)
- if err != nil {
- if err == errSeeOther || err == errUndefined {
- return false
- }
- if err == errStop {
- break
- }
- panic(err)
- }
- }
- return true
-}
-
-func (ctxt *Exec) Define(name string, value Value) {
- ctxt.Vars[name] = value
-}
-
-func (ctxt *Exec) Assign(name string, value Value) error {
- ctxt.Vars[name] = value
- return nil
-}
-
-/*
-
-var global = map[string]Value{
- "ConditionPassed": _ConditionPassed,
- "UInt": _UInt,
- "SInt": _SInt,
-}
-
-type Defn struct {
- Name string
- Value Value
- Next *Defn
-}
-
-func (ctxt *Exec) Assign(name string, value Value) error {
- for d := ctxt.Scope; d != nil; d = d.Next {
- if d.Name == name {
- d.Value = value
- return nil
- }
- }
- ctxt.Define(name, value)
- return nil
-}
-
-func _ConditionPassed(ctxt *Exec, args []Value) (Value, error) {
- return Bool(true), nil
-}
-*/
-
-type Int int64
-
-func (x Int) String() string {
- return fmt.Sprint(int64(x))
-}
-
-func (x Int) Eq(y Value) bool { return x == y }
-func (x Int) Lt(y Value) bool { return x < y.(Int) }
-func (x Int) Gt(y Value) bool { return x > y.(Int) }
-
-func (x Int) Add(y Value) Value { return x + y.(Int) }
-func (x Int) Sub(y Value) Value { return x - y.(Int) }
-func (x Int) Mul(y Value) Value { return x * y.(Int) }
-
-func (x Int) Lsh(y Value) Value { return x << uint(y.(Int)) }
-func (x Int) Rsh(y Value) Value { return x >> uint(y.(Int)) }
-func (x Int) DIV(y Value) Value { return x / y.(Int) }
-
-func _UInt(_ *Exec, args []Value) (Value, error) {
- if len(args) != 1 {
- return nil, fmt.Errorf("UInt takes a single argument")
- }
- b, ok := args[0].(Bits)
- if !ok {
- return nil, fmt.Errorf("UInt takes a Bits, not %T", args[0])
- }
- if b.N > 63 {
- return nil, fmt.Errorf("UInt cannot handle %d-bit Bits", b.N)
- }
- return Int(b.Val), nil
-}
-
-func _SInt(_ *Exec, args []Value) (Value, error) {
- if len(args) != 1 {
- return nil, fmt.Errorf("SInt takes a single argument")
- }
- b, ok := args[0].(Bits)
- if !ok {
- return nil, fmt.Errorf("SInt takes a Bits, not %T", args[0])
- }
- if b.N > 64 {
- return nil, fmt.Errorf("SInt cannot handle %d-bit Bits", b.N)
- }
- return Int(int64(b.Val) << uint(64-b.N) >> uint(64-b.N)), nil
-}
-
-/*
-
-func (ctxt *Exec) Run(prog []*Stmt) error {
- for _, stmt := range prog {
- if err := ctxt.stmt(stmt); err != nil {
- return err
- }
- }
- return nil
-}
-
-*/
-
-func (ctxt *Exec) stmt(stmt *Stmt) error {
- switch stmt.Op {
- case If:
- v, err := toBool(ctxt.expr(stmt.X))
- if err != nil {
- return err
- }
- if v {
- return ctxt.stmt(stmt.Body)
- }
- for _, elseif := range stmt.ElseIf {
- v, err := toBool(ctxt.expr(elseif.Cond))
- if err != nil {
- return err
- }
- if v {
- return ctxt.stmt(elseif.Body)
- }
- }
- if stmt.Else == nil {
- return nil
- }
- return ctxt.stmt(stmt.Else)
-
- case Case:
- v, err := ctxt.expr(stmt.X)
- if err != nil {
- return err
- }
- vv, ok := v.(interface {
- Eq(Value) bool
- })
- if !ok {
- return fmt.Errorf("use of uncomparable value %T(%v) in case statement", v, v)
- }
- for _, when := range stmt.When {
- for _, cond := range when.Cond {
- w, err := ctxt.expr(cond)
- if err != nil {
- return err
- }
- if reflect.TypeOf(v) != reflect.TypeOf(w) {
- return fmt.Errorf("mistyped comparison of %T(%v) and %T(%v) in case statement", v, v, w, w)
- }
- if vv.Eq(w) {
- return ctxt.stmt(when.Body)
- }
- }
- }
- if stmt.Else == nil {
- return nil
- }
- return ctxt.stmt(stmt.Else)
-
- case Block:
- for _, x := range stmt.Block {
- if err := ctxt.stmt(x); err != nil {
- return err
- }
- }
- return nil
-
- case See:
- return errSeeOther
-
- case Undefined:
- return errUndefined
-
- case Unpredictable, ImplDefined, SubarchDefined:
- return errStop
-
- case StmtExpr:
- _, err := ctxt.expr(stmt.X)
- return err
-
- case Assign:
- v, err := ctxt.expr(stmt.Y)
- if err != nil {
- return err
- }
- if stmt.X.Op == ExprTuple {
- vv, ok := v.(Tuple)
- if !ok {
- return fmt.Errorf("assignment of non-tuple %T to tuple", v)
- }
- if len(stmt.X.List) != len(vv) {
- return fmt.Errorf("%d = %d in tuple assignment", len(stmt.X.List), len(vv))
- }
- for i, x := range stmt.X.List {
- if x.Op == Blank {
- continue
- }
- if x.Op != Name {
- return fmt.Errorf("cannot assign to expr op %d", x.Op)
- }
- if err := ctxt.Assign(x.Text, vv[i]); err != nil {
- return err
- }
- }
- return nil
- }
- x := stmt.X
- if x.Op != Name {
- return fmt.Errorf("cannot assign to expr op %d", x.Op)
- }
- return ctxt.Assign(x.Text, v)
- }
- return fmt.Errorf("unknown stmt op %d", stmt.Op)
-}
-
-func toBool(v Value, err error) (b Bool, xerr error) {
- if err != nil {
- return false, err
- }
- switch v := v.(type) {
- case Bool:
- return v, nil
- default:
- return false, fmt.Errorf("value of type %T used as bool", v)
- }
-}
-
-type Value interface {
- String() string
-}
-
-type Bool bool
-
-func (b Bool) Eq(v Value) bool { return b == v }
-
-func (b Bool) Not() Value { return !b }
-
-func (b Bool) String() string {
- if b {
- return "TRUE"
- }
- return "FALSE"
-}
-
-type Tuple []Value
-
-func (t Tuple) String() string {
- var buf bytes.Buffer
- fmt.Fprintf(&buf, "(")
- for i, v := range t {
- if i > 0 {
- fmt.Fprintf(&buf, ", ")
- }
- fmt.Fprintf(&buf, v.String())
- }
- fmt.Fprintf(&buf, ")")
- return buf.String()
-}
-
-func (ctxt *Exec) expr(x *Expr) (v Value, err error) {
- switch x.Op {
- case Call:
- fn, err := ctxt.name(x.Text)
- if err != nil {
- return nil, err
- }
- var list []Value
- for _, y := range x.List {
- v, err := ctxt.expr(y)
- if err != nil {
- return nil, err
- }
- list = append(list, v)
- }
- return ctxt.call(x.Text, fn, list)
-
- case ExprTuple:
- var list []Value
- for _, y := range x.List {
- v, err := ctxt.expr(y)
- if err != nil {
- return nil, err
- }
- list = append(list, v)
- }
- if len(list) == 1 {
- return list[0], nil
- }
- return Tuple(list), nil
-
- case AndAnd:
- v, err := toBool(ctxt.expr(x.X))
- if err != nil {
- return nil, err
- }
- if !v {
- return v, nil
- }
- return ctxt.expr(x.Y)
-
- case OrOr:
- v, err := toBool(ctxt.expr(x.X))
- if err != nil {
- return nil, err
- }
- if v {
- return v, nil
- }
- return ctxt.expr(x.Y)
-
- case Colon:
- v, err := ctxt.expr(x.X)
- if err != nil {
- return nil, err
- }
- y, err := ctxt.expr(x.Y)
- if err != nil {
- return nil, err
- }
- xb, ok := v.(Bits)
- yb, ok2 := y.(Bits)
- if !ok || !ok2 {
- return nil, fmt.Errorf("colon operator requires bit strings")
- }
- b := xb
- b.N += yb.N
- b.Val <<= uint(yb.N)
- b.DontCare <<= yb.DontCare
- return b, nil
-
- case Name:
- return ctxt.name(x.Text)
-
- case Const:
- if (strings.HasPrefix(x.Text, "‘") || strings.HasPrefix(x.Text, "’")) && strings.HasSuffix(x.Text, "’") {
- text := x.Text[len("‘") : len(x.Text)-len("’")]
- var b Bits
- b.N = len(text)
- for _, c := range text {
- b.Val <<= 1
- b.DontCare <<= 1
- if c == '1' {
- b.Val |= 1
- }
- if c == 'x' {
- b.DontCare |= 1
- }
- }
- return b, nil
- }
- n, err := strconv.Atoi(x.Text)
- if err == nil {
- return Int(n), nil
- }
- println("const", x.Text)
-
- case Not:
- l, err := ctxt.expr(x.X)
- if err != nil {
- return nil, err
- }
- switch x.Op {
- case Not:
- ll, ok := l.(interface {
- Not() Value
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support !", l)
- }
- return ll.Not(), nil
- }
-
- case Eq, NotEq, Lt, LtEq, Gt, GtEq, Add, Sub, Mul, Lsh, Rsh, BigDIV:
- l, err := ctxt.expr(x.X)
- if err != nil {
- return nil, err
- }
- r, err := ctxt.expr(x.Y)
- if err != nil {
- return nil, err
- }
- tl := reflect.TypeOf(l)
- tr := reflect.TypeOf(r)
- if tl != tr {
- return nil, fmt.Errorf("arithmetic (expr op %d) of %T(%v) with %T(%v)", x.Op, l, l, r, r)
- }
- switch x.Op {
- case Eq:
- ll, ok := l.(interface {
- Eq(Value) bool
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support ==", l)
- }
- return Bool(ll.Eq(r)), nil
- case NotEq:
- ll, ok := l.(interface {
- Eq(Value) bool
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support !=", l)
- }
- return Bool(!ll.Eq(r)), nil
- case Lt:
- ll, ok := l.(interface {
- Lt(Value) bool
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support <", l)
- }
- return Bool(ll.Lt(r)), nil
- case GtEq:
- ll, ok := l.(interface {
- Lt(Value) bool
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support >=", l)
- }
- return Bool(!ll.Lt(r)), nil
- case Gt:
- ll, ok := l.(interface {
- Gt(Value) bool
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support >", l)
- }
- return Bool(ll.Gt(r)), nil
- case LtEq:
- ll, ok := l.(interface {
- Gt(Value) bool
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support <=", l)
- }
- return Bool(!ll.Gt(r)), nil
- case Add:
- ll, ok := l.(interface {
- Add(Value) Value
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support +", l)
- }
- return ll.Add(r), nil
- case Sub:
- ll, ok := l.(interface {
- Sub(Value) Value
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support -", l)
- }
- return ll.Sub(r), nil
- case Mul:
- ll, ok := l.(interface {
- Mul(Value) Value
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support *", l)
- }
- return ll.Mul(r), nil
- case Lsh:
- ll, ok := l.(interface {
- Lsh(Value) Value
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support <<", l)
- }
- return ll.Lsh(r), nil
- case Rsh:
- ll, ok := l.(interface {
- Rsh(Value) Value
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support >>", l)
- }
- return ll.Rsh(r), nil
- case BigDIV:
- ll, ok := l.(interface {
- DIV(Value) Value
- })
- if !ok {
- return nil, fmt.Errorf("type %T does not support DIV", l)
- }
- return ll.DIV(r), nil
- }
-
- case BitIndex:
- l, err := ctxt.expr(x.X)
- if err != nil {
- return nil, err
- }
- b, ok := l.(Bits)
- if !ok {
- return nil, fmt.Errorf("bit index operator requires bitstring, not %T(%v)", l, l)
- }
- out := Bits{}
- for _, ix := range x.List {
- if ix.Op == Colon {
- r1, err := ctxt.expr(ix.X)
- if err != nil {
- return nil, err
- }
- r2, err := ctxt.expr(ix.Y)
- if err != nil {
- return nil, err
- }
- i1, ok := r1.(Int)
- i2, ok2 := r2.(Int)
- if !ok || !ok2 {
- return nil, fmt.Errorf("bit indexes must be int")
- }
- if i1 <= i2 {
- return nil, fmt.Errorf("inverted bit indexes %d:%d", i1, i2)
- }
- w := int(i1 + 1 - i2)
- out.N += w
- out.Val <<= uint(w)
- out.DontCare <<= uint(w)
- out.Val |= (b.Val >> uint(i2)) & (1<<uint(w) - 1)
- out.DontCare |= (b.DontCare >> uint(i2)) & (1<<uint(w) - 1)
- } else {
- r, err := ctxt.expr(ix)
- if err != nil {
- return nil, err
- }
- i, ok := r.(Int)
- if !ok {
- return nil, fmt.Errorf("bit index operator index must be int")
- }
- out.N++
- out.Val <<= 1
- out.DontCare <<= 1
- out.Val |= (b.Val >> uint(i)) & 1
- }
- }
- return out, nil
-
- case IfElse:
- v, err := toBool(ctxt.expr(x.X))
- if err != nil {
- return nil, err
- }
- if v {
- return ctxt.expr(x.Y)
- }
- return ctxt.expr(x.Z)
- }
- return nil, fmt.Errorf("unknown expr op %d", x.Op)
-}
-
-type Func struct {
- Name string
- F func(*Exec, []Value) (Value, error)
-}
-
-func (f Func) String() string {
- return f.Name
-}
-
-func (ctxt *Exec) call(name string, fn Value, args []Value) (Value, error) {
- switch fn := fn.(type) {
- case Func:
- return fn.F(ctxt, args)
- }
- return nil, fmt.Errorf("cannot call %s of type %T", name, fn)
-}
-
-var global = map[string]Value{
- "UInt": Func{"UInt", _UInt},
- "DecodeImmShift": Func{"DecodeImmShift", _DecodeImmShift},
- "ArchVersion": Func{"ArchVersion", _ArchVersion},
- "ZeroExtend": Func{"ZeroExtend", _ZeroExtend},
- "ARMExpandImm": Func{"ARMExpandImm", _ARMExpandImm},
- "Zeros": Func{"Zeros", _Zeros},
- "TRUE": Bool(true),
- "FALSE": Bool(false),
- "BitCount": Func{"BitCount", _BitCount},
- "Consistent": Func{"Consistent", _Consistent},
-}
-
-func _Consistent(ctxt *Exec, args []Value) (Value, error) {
- if len(args) != 1 {
- return nil, fmt.Errorf("BitCount requires one argument")
- }
- _, inconsistent := args[0].(Inconsistent)
- return Bool(!inconsistent), nil
-}
-
-func _BitCount(ctxt *Exec, args []Value) (Value, error) {
- if len(args) != 1 {
- return nil, fmt.Errorf("BitCount requires one argument")
- }
- b, ok1 := args[0].(Bits)
- if !ok1 {
- return nil, fmt.Errorf("BitCount requires bitstring argument")
- }
-
- n := 0
- for i := 0; i < b.N; i++ {
- if b.Val&(1<<uint(i)) != 0 {
- n++
- }
- }
- return Int(n), nil
-}
-
-func _ArchVersion(ctxt *Exec, args []Value) (Value, error) {
- return Int(7), nil
-}
-
-func _ZeroExtend(ctxt *Exec, args []Value) (Value, error) {
- if len(args) != 2 {
- return nil, fmt.Errorf("ZeroExtend requires two arguments")
- }
- b, ok := args[0].(Bits)
- n, ok2 := args[1].(Int)
- if !ok || !ok2 {
- return nil, fmt.Errorf("DecodeImmShift requires bitstring, int arguments")
- }
- b.N = int(n)
- return b, nil
-}
-
-func _DecodeImmShift(ctxt *Exec, args []Value) (Value, error) {
- if len(args) != 2 {
- return nil, fmt.Errorf("DecodeImmShift requires two arguments")
- }
- b1, ok1 := args[0].(Bits)
- b2, ok2 := args[1].(Bits)
- if !ok1 || !ok2 {
- return nil, fmt.Errorf("DecodeImmShift requires bitstring arguments")
- }
- _ = b1
- _ = b2
- // TODO
- return Tuple{Int(0), Int(0)}, nil
-}
-
-func _ARMExpandImm(ctxt *Exec, args []Value) (Value, error) {
- if len(args) != 1 {
- return nil, fmt.Errorf("ARMExpandImm requires one argument")
- }
- b, ok1 := args[0].(Bits)
- if !ok1 || b.N != 12 {
- return nil, fmt.Errorf("ARMExpandImm requires 12-bit bitstring argument")
- }
- v := uint32(b.Val & 0xFF)
- rot := uint(2 * ((b.Val >> 8) & 0xF))
- v = v>>rot | v<<(32-rot)
- return Bits{N: 32, Val: v}, nil
-}
-
-func _Zeros(ctxt *Exec, args []Value) (Value, error) {
- if len(args) != 1 {
- return nil, fmt.Errorf("Zeros requires one argument")
- }
- n, ok := args[0].(Int)
- if !ok {
- return nil, fmt.Errorf("Zeros requires int argument")
- }
- return Bits{N: int(n)}, nil
-}
-
-type Symbol string
-
-func (s Symbol) String() string { return string(s) }
-
-func (ctxt *Exec) name(name string) (v Value, err error) {
- v, ok := ctxt.Vars[name]
- if ok {
- return v, nil
- }
- v, ok = global[name]
- if ok {
- return v, nil
- }
- return Symbol(name), nil
- return nil, fmt.Errorf("unknown name %s", name)
-}
-
-/*
-func pseudoExec(base uint32, enc *Enc) {
- var ctxt Exec
- ctxt.Define("EncodingSpecificOperations", func(ctxt *Exec, args []Value) (Value, error) {
- return nil, ctxt.Run(enc.Prog)
- })
-
- var n uint
- for _, f := range enc.Fields {
- switch f {
- case "0", "1", "(0)", "(1)":
- n++
- default:
- wid := size[f]
- if wid == 0 {
- panic("missing width for " + f)
- }
- ctxt.Define(f, Bits{N: wid, Val: (base>>(31-n))&(1<<uint(wid)-1)})
- n += uint(wid)
- }
- }
-
- if err := ctxt.Run(enc.Inst.Prog); err != nil {
- log.Printf("%#x: %v", base, err)
- }
-}
-
-func loadLibrary(data []byte) {
- prog := parse("speclib.txt", string(data))
- for _, stmt := range prog {
- switch stmt.Op {
- default:
- log.Fatalf("unexpected statement in speclib.txt: %d", stmt.Op)
- case Fndef:
- global[stmt.Text] = funcImpl(stmt)
- case Enum:
- // TODO
- }
- }
-}
-
-func funcImpl(stmt *Stmt) func(*Exec, []Value) (Value, error) {
- return func(ctxt *Exec, args []Value) (Value, error) {
- ctxt1 := *ctxt
- if len(args) != len(stmt.List) {
- return nil, fmt.Errorf("calling %s: have %d arguments, want %d", stmt.Text, len(args), len(stmt.List))
- }
- for i, decl := range stmt.List {
- v, err := convert(args[i], decl.Type)
- if err != nil {
- return nil, fmt.Errorf("calling %s: %v", stmt.Text, err)
- }
- ctxt1.Define(decl.Text, v)
- }
- err := ctxt1.stmt(stmt.Body)
- if err != nil {
- return nil, err
- }
- if ctxt1.ret == nil && stmt.Type != nil {
- return nil, fmt.Errorf("calling %s: function body missing return", stmt.Text)
- }
- if ctxt1.ret != nil && stmt.Type == nil {
- return nil, fmt.Errorf("calling %s: unexpected return value from function with no result", stmt.Text)
- }
- return ctxt1.ret, nil
- }
-}
-
-func convert(v Value, typ *Type) (Value, error) {
- switch typ.Op {
- case BoolType:
- if v, ok := v.(Bool); ok {
- return v, nil
- }
- case BitType:
- if v, ok := v.(Bits); ok && v.N == typ.N {
- return v, nil
- }
- }
- return nil, fmt.Errorf("cannot convert %s to type %v", v, typ)
-}
-
-*/
diff --git a/arm/armspec/pseudo.go b/arm/armspec/pseudo.go
deleted file mode 100644
index 20bcec8..0000000
--- a/arm/armspec/pseudo.go
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright 2014 The Go 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 main
-
-import (
- "fmt"
- "os"
- "regexp"
- "strings"
-)
-
-type Lexer struct {
- input string
- file string
- lineno int
- sym string
- prog []*Stmt
-}
-
-type Line struct {
- File string
- Lineno int
-}
-
-func (l Line) String() string {
- return fmt.Sprintf("%s:%d", l.File, l.Lineno)
-}
-
-var nerror int
-
-func (l Line) Errorf(format string, args ...interface{}) {
- fmt.Printf("%s: %s\n", l, fmt.Sprintf(format, args...))
- if nerror++; nerror > 20 {
- fmt.Printf("too many errors\n")
- os.Exit(1)
- }
-}
-
-func re(s string) *regexp.Regexp {
- return regexp.MustCompile(`\A(?:` + s + `)`)
-}
-
-var tokens = []struct {
- re *regexp.Regexp
- val int
- fn func(*Lexer, string, *yySymType)
-}{
- {re(`//[^\n]*`), -1, nil},
- {re(`/\*(.|\n)*?\*/`), -1, nil},
- {re(`[ \t\n]+`), -1, nil},
- {re(`»`), _INDENT, nil},
- {re(`«`), _UNINDENT, str},
- {re(`return`), _RETURN, str},
- {re(`UNDEFINED`), _UNDEFINED, str},
- {re(`UNPREDICTABLE`), _UNPREDICTABLE, str},
- {re(`SEE [^;]+`), _SEE, str},
- {re(`IMPLEMENTATION_DEFINED( [^;]+)?`), _IMPLEMENTATION_DEFINED, str},
- {re(`SUBARCHITECTURE_DEFINED( [^;]+)?`), _SUBARCHITECTURE_DEFINED, str},
- {re(`if`), _IF, nil},
- {re(`then`), _THEN, nil},
- {re(`repeat`), _REPEAT, nil},
- {re(`until`), _UNTIL, nil},
- {re(`while`), _WHILE, nil},
- {re(`case`), _CASE, nil},
- {re(`for`), _FOR, nil},
- {re(`to`), _TO, nil},
- {re(`do`), _DO, nil},
- {re(`of`), _OF, nil},
- {re(`elsif`), _ELSIF, nil},
- {re(`else`), _ELSE, nil},
- {re(`otherwise`), _OTHERWISE, nil},
- {re(`enumeration`), _ENUMERATION, nil},
- {re(`when`), _WHEN, nil},
- {re(`UNKNOWN`), _UNKNOWN, nil},
- {re(`DIV`), _DIV, nil},
- {re(`MOD`), _MOD, nil},
- {re(`AND`), _AND, nil},
- {re(`OR`), _OR, nil},
- {re(`EOR`), _EOR, nil},
- {re(`&&`), _ANDAND, nil},
- {re(`\|\|`), _OROR, nil},
- {re(`==`), _EQ, nil},
- {re(`!=`), _NE, nil},
- {re(` <`), _LT, nil},
- {re(` ?<=`), _LE, nil},
- {re(` ?>=`), _GE, nil},
- {re(` >`), _GT, nil},
- {re(`{`), '{', nil},
- {re(`}`), '}', nil},
- {re(`<`), '<', nil},
- {re(`>`), '>', nil},
- {re(`2^`), _TWOPOW, nil},
- {re(` ?<<`), _LSH, nil},
- {re(` ?>>`), _RSH, nil},
- {re(`,`), ',', nil},
- {re(`:`), ':', nil},
- {re(`\+`), '+', nil},
- {re(`\.`), '.', nil},
- {re(`-`), '-', nil},
- {re(`|`), '|', nil},
- {re(`\^`), '^', nil},
- {re(`\*`), '*', nil},
- {re(`/`), '/', nil},
- {re(`%`), '%', nil},
- {re(`&`), '&', nil},
- {re(`!`), '!', nil},
- {re(`;`), ';', nil},
- {re(`=`), '=', nil},
- {re(`\(`), '(', nil},
- {re(`\)`), ')', nil},
- {re(`\[`), '[', nil},
- {re(`\]`), ']', nil},
- {re(`!`), '!', nil},
- {re(`[0-9]+`), _CONST, str},
- {re(`[0-9]+\.[0-9]+`), _CONST, str},
- {re(`0x[0-9A-Fa-f]+`), _CONST, str},
- {re("[‘’][ 0-9x]+’"), _CONST, strNoSpaces},
- {re(`bit`), _BIT, str},
- {re(`bits\(`), _BITS, str1x},
- {re(`assert`), _ASSERT, str},
- {re(`integer`), _INTEGER, nil},
- {re(`boolean`), _BOOLEAN, nil},
-
- {re(`[A-Za-z_][A-Za-z0-9_]*`), _NAME, str},
- {re(`[A-Za-z_][A-Za-z0-9_]*\(`), _NAME_PAREN, str1x},
-}
-
-func (lx *Lexer) Lex(yy *yySymType) int {
- if len(lx.input) == 0 {
- return _EOF
- }
- var (
- longest string
- longestVal int
- longestFn func(*Lexer, string, *yySymType)
- )
- for _, tok := range tokens {
- s := tok.re.FindString(lx.input)
- if len(s) > len(longest) {
- longest = s
- longestVal = tok.val
- longestFn = tok.fn
- }
- }
- if longest == "" {
- lx.Error(fmt.Sprintf("lexer stuck at %.10q", lx.input))
- return -1
- }
- //println(longest)
- yy.line = lx.line()
- if longestFn != nil {
- lx.sym = longest
- longestFn(lx, longest, yy)
- }
- lx.input = lx.input[len(longest):]
- lx.lineno += strings.Count(longest, "\n")
- if longestVal < 0 {
- // skip
- return lx.Lex(yy)
- }
- return longestVal
-}
-
-func (lx *Lexer) Error(s string) {
- lx.line().Errorf("%s near %s", s, lx.sym)
-}
-
-func (lx *Lexer) line() Line {
- return Line{lx.file, lx.lineno}
-}
-
-func nop(*Lexer, string, *yySymType) {
- // having a function in the table
- // will make the lexer save the string
- // for use in error messages.
- // nothing more to do.
-}
-
-func str(lx *Lexer, s string, yy *yySymType) {
- yy.str = s
-}
-
-func str1(lx *Lexer, s string, yy *yySymType) {
- yy.str = s[1:]
-}
-
-func str1x(lx *Lexer, s string, yy *yySymType) {
- yy.str = s[:len(s)-1]
-}
-
-func strNoSpaces(lx *Lexer, s string, yy *yySymType) {
- yy.str = strings.Replace(s, " ", "", -1)
-}
-
-func parse(name, text string) []*Stmt {
- text = markup(text)
- lx := &Lexer{
- input: text,
- file: name,
- lineno: 1,
- }
- nerror = 0
- yyParse(lx)
- return lx.prog
-}
-
-func markup(text string) string {
- prefix := ""
-
- // Fix typos.
- text = strings.Replace(text, "R[i}", "R[i]", -1)
- text = strings.Replace(text, "R[n}", "R[n]", -1)
- text = strings.Replace(text, "(1 << (3-UInt(op)-UInt(size));", "(1 << (3-UInt(op)-UInt(size)));", -1)
- text = strings.Replace(text, "(D[n+r] AND NOT(D[m+r]);", "(D[n+r] AND NOT(D[m+r]));", -1)
- text = strings.Replace(text, "(D[d+r] AND NOT(D[m+r]);", "(D[d+r] AND NOT(D[m+r]));", -1)
- text = strings.Replace(text, "(D[n+r] AND D[d+r]) OR (D[m+r] AND NOT(D[d+r]);", "(D[n+r] AND D[d+r]) OR (D[m+r] AND NOT(D[d+r]));", -1)
-
- // Add indent, unindent tags.
- lines := strings.Split(text, "\n")
- var indent []int
- for j, line := range lines {
- if i := strings.Index(line, "//"); i >= 0 {
- line = line[:i]
- }
- if strings.TrimSpace(line) == "" {
- continue
- }
- n := 0
- for n < len(line) && line[n] == '\t' {
- n++
- }
- if len(indent) == 0 {
- indent = append(indent, n)
- }
- i := indent[len(indent)-1]
- if i > n {
- for i > n {
- line = "«" + line
- indent = indent[:len(indent)-1]
- if len(indent) == 0 {
- i = -1
- } else {
- i = indent[len(indent)-1]
- }
- }
- if i == -1 {
- indent = append(indent, n)
- i = n
- }
- }
- if i < n {
- line = "»" + line
- indent = append(indent, n)
- }
- lines[j] = line
- }
- n := len(indent) - 1
- if n < 0 {
- n = 0
- }
- return prefix + strings.Join(lines, "\n") + strings.Repeat("«", n)
-}
diff --git a/arm/armspec/pseudo.y b/arm/armspec/pseudo.y
deleted file mode 100644
index 6d9532f..0000000
--- a/arm/armspec/pseudo.y
+++ /dev/null
@@ -1,553 +0,0 @@
-// Copyright 2014 The Go 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 main
-
-import (
- "strconv"
-)
-
-%}
-
-%union {
- str string
- line Line
- stmt *Stmt
- stmts []*Stmt
- expr *Expr
- exprs []*Expr
- elseifs []*ElseIf
- when *When
- whens []*When
- typ *Type
- typs []*Type
-}
-
-%token _ASSERT
-%token _BITS
-%token _BIT
-%token _IF
-%token _EOF
-%token _NAME _NAME_PAREN
-%token _RETURN
-%token _UNDEFINED
-%token _UNPREDICTABLE
-%token _IMPLEMENTATION_DEFINED
-%token _SUBARCHITECTURE_DEFINED
-%token _ENUMERATION
-%token _DO
-%token _INDENT
-%token _UNINDENT
-%token _THEN
-%token _REPEAT
-%token _UNTIL
-%token _WHILE
-%token _CASE
-%token _FOR
-%token _TO
-%token _OF
-%token _ELSIF
-%token _ELSE
-%token _OTHERWISE
-%token _WHEN
-%token _CONST
-%token _UNKNOWN
-%token _EQ
-%token _NE
-%token _LE
-%token _GE
-%token _AND
-%token _OR
-%token _EOR
-%token _ANDAND
-%token _OROR
-%token _DIV
-%token _MOD
-%token _TWOPOW
-%token _LSH
-%token _RSH
-%token _INTEGER
-%token _BOOLEAN
-
-%token <str> _NAME _NAME_PAREN _CONST
-%token <str> _SEE
-
-%left last_resort
-%left '='
-%left ','
-%left _IF
-%left _ANDAND _OROR
-%left _LT _LE '>' _GE _GT _EQ _NE
-%left ':'
-%left '+' '-' '|' '^' _OR _EOR
-%left '*' '/' '%' '&' _LSH _RSH _DIV _MOD _AND
-%left _TWOPOW
-%left '.' '<' '['
-%left unary
-
-%type <stmts> stmt_list simple_stmt_list stmt_list_opt
-%type <stmt> stmt simple_stmt block simple_block otherwise enumeration
-%type <stmt> else_opt simple_else_opt else_end simple_else_end
-%type <elseifs> elsif_list simple_elsif_list
-%type <when> when
-%type <whens> when_list
-%type <exprs> expr_list_opt expr_list expr_minus_list const_list
-%type <expr> expr call_expr const
-%type <typ> unnamed_type
-
-%%
-
-top:
- stmt_list_opt _EOF
- {
- yylex.(*Lexer).prog = $1
- return 0
- }
-
-simple_stmt:
- expr '=' expr ';'
- {
- $$ = &Stmt{Op: Assign, X: $1, Y: $3}
- }
-| expr _EQ expr ';'
- {
- $$ = &Stmt{Op: Assign, X: $1, Y: $3}
- }
-| call_expr ';'
- {
- $$ = &Stmt{Op: StmtExpr, X: $1}
- }
-| _RETURN expr_list_opt ';'
- {
- $$ = &Stmt{Op: Return, List: $2}
- }
-| _UNDEFINED ';'
- {
- $$ = &Stmt{Op: Undefined}
- }
-| _UNPREDICTABLE ';'
- {
- $$ = &Stmt{Op: Unpredictable}
- }
-| _SEE ';'
- {
- $$ = &Stmt{Op: See, Text: $1}
- }
-| _IMPLEMENTATION_DEFINED ';'
- {
- $$ = &Stmt{Op: ImplDefined}
- }
-| _SUBARCHITECTURE_DEFINED ';'
- {
- $$ = &Stmt{Op: SubarchDefined}
- }
-
-stmt:
- simple_stmt
-| unnamed_type _NAME ';'
- {
- $$ = &Stmt{Op: StmtExpr, X: &Expr{Op: Decl, Type: $1, Text: $2}}
- }
-| _IF expr _THEN block else_opt
- {
- $$ = &Stmt{Op: If, X: $2, Body: $4, ElseIf: $<elseifs>5, Else: $5}
- }
-| _IF expr _THEN simple_stmt simple_else_opt
- {
- $$ = &Stmt{Op: If, X: $2, Body: $4, ElseIf: $<elseifs>5, Else: $5}
- }
-| _REPEAT block _UNTIL expr ';'
- {
- $$ = &Stmt{Op: Repeat, Body: $2, X: $4}
- }
-| _WHILE expr do block
- {
- $$ = &Stmt{Op: While, X: $2, Body: $4}
- }
-| _FOR expr '=' expr _TO expr do block
- {
- $$ = &Stmt{Op: For, X: $2, Y: $4, Z: $6, Body: $8}
- }
-| _CASE expr _OF _INDENT when_list otherwise _UNINDENT
- {
- $$ = &Stmt{Op: Case, X: $2, When: $5, Else: $6}
- }
-| _ASSERT expr ';'
- {
- $$ = &Stmt{Op: Assert, X: $2}
- }
-| block
- {
- $$ = $1
- }
-| enumeration
-
-enumeration:
- _ENUMERATION _NAME '{' expr_list '}' ';'
- {
- $$ = &Stmt{Op: Enum, Text: $2, List: $4}
- }
-
-do:
-| _DO
-
-block:
- _INDENT stmt_list _UNINDENT
- {
- $$ = &Stmt{Op: Block, Block: $2}
- }
-
-simple_block:
- simple_stmt_list
- {
- $$ = &Stmt{Op: Block, Block: $1}
- }
-
-simple_stmt_list:
- simple_stmt
- {
- $$ = []*Stmt{$1}
- }
-| simple_stmt_list simple_stmt
- {
- $$ = append($1, $2)
- }
-
-stmt_list:
- stmt
- {
- $$ = []*Stmt{$1}
- }
-| stmt_list stmt
- {
- $$ = append($1, $2)
- }
-
-stmt_list_opt:
- {
- $$ = nil
- }
-| stmt_list
-
-else_opt:
- elsif_list else_end
- {
- $<elseifs>$ = $1
- $$ = $2
- }
-
-simple_else_opt:
- simple_elsif_list simple_else_end
- {
- $<elseifs>$ = $1
- $$ = $2
- }
-
-elsif_list:
- {
- $$ = nil
- }
-| elsif_list _ELSIF expr _THEN block
- {
- $$ = append($1, &ElseIf{Cond: $3, Body: $5})
- }
-
-simple_elsif_list:
- {
- $$ = nil
- }
-| simple_elsif_list _ELSIF expr _THEN simple_stmt
- {
- $$ = append($1, &ElseIf{Cond: $3, Body: $5})
- }
-
-else_end:
- {
- $$ = nil
- }
-| _ELSE block
- {
- $$ = $2
- }
-| _ELSE simple_stmt
- {
- $$ = $2
- }
-
-simple_else_end:
- {
- $$ = nil
- }
-| _ELSE simple_stmt
- {
- $$ = $2
- }
-
-when_list:
- {
- $$ = nil
- }
-| when_list when
- {
- $$ = append($1, $2)
- }
-
-when:
- _WHEN const_list then block
- {
- $$ = &When{Cond: $2, Body: $4}
- }
-| _WHEN const_list then simple_block
- {
- $$ = &When{Cond: $2, Body: $4}
- }
-
-then:
-| _THEN
-
-otherwise:
- {
- $$ = nil
- }
-| _OTHERWISE block
- {
- $$ = $2
- }
-| _OTHERWISE simple_block
- {
- $$ = $2
- }
-
-expr_list_opt:
- {
- $$ = nil
- }
-| expr_list
-
-expr_list:
- expr
- {
- $$ = []*Expr{$1}
- }
-| expr_list ',' expr
- {
- $$ = append($1, $3)
- }
-
-const_list:
- const
- {
- $$ = []*Expr{$1}
- }
-| const_list ',' const
- {
- $$ = append($1, $3)
- }
-
-const:
- _CONST
- {
- $$ = &Expr{Op: Const, Text: $1}
- }
-| _NAME
- {
- $$ = &Expr{Op: Name, Text: $1}
- }
-
-expr_minus_list:
- expr
- {
- $$ = []*Expr{$1}
- }
-| '-'
- {
- $$ = []*Expr{&Expr{Op: Blank}}
- }
-| expr_minus_list ',' expr
- {
- $$ = append($1, $3)
- }
-| expr_minus_list ',' '-'
- {
- $$ = append($1, &Expr{Op: Blank})
- }
-
-expr:
- _CONST
- {
- $$ = &Expr{Op: Const, Text: $1}
- }
-| _NAME
- {
- $$ = &Expr{Op: Name, Text: $1}
- }
-| unnamed_type _NAME
- {
- $$ = &Expr{Op: Decl, Type: $1, Text: $2}
- }
-| _UNKNOWN
- {
- $$ = &Expr{Op: Unknown}
- }
-| unnamed_type _UNKNOWN
- {
- $$ = &Expr{Op: Unknown, Type: $1}
- }
-| call_expr
-| '(' expr_minus_list ')'
- {
- $$ = &Expr{Op: ExprTuple, List: $2}
- }
-| expr _EQ expr
- {
- $$ = &Expr{Op: Eq, X: $1, Y: $3}
- }
-| expr _NE expr
- {
- $$ = &Expr{Op: NotEq, X: $1, Y: $3}
- }
-| expr _LE expr
- {
- $$ = &Expr{Op: LtEq, X: $1, Y: $3}
- }
-| expr '<' expr_list '>'
- {
- $$ = &Expr{Op: BitIndex, X: $1, List: $3}
- }
-| expr _LT expr
- {
- $$ = &Expr{Op: Lt, X: $1, Y: $3}
- }
-| expr _GE expr
- {
- $$ = &Expr{Op: GtEq, X: $1, Y: $3}
- }
-| expr _GT expr
- {
- $$ = &Expr{Op: Gt, X: $1, Y: $3}
- }
-| _IF expr _THEN expr _ELSE expr %prec _IF
- {
- $$ = &Expr{Op: IfElse, X: $2, Y: $4, Z: $6}
- }
-| '!' expr %prec unary
- {
- $$ = &Expr{Op: Not, X: $2}
- }
-| expr _ANDAND expr
- {
- $$ = &Expr{Op: AndAnd, X: $1, Y: $3}
- }
-| expr _OROR expr
- {
- $$ = &Expr{Op: OrOr, X: $1, Y: $3}
- }
-| expr '^' expr
- {
- $$ = &Expr{Op: Eor, X: $1, Y: $3}
- }
-| expr ':' expr
- {
- $$ = &Expr{Op: Colon, X: $1, Y: $3}
- }
-| expr _AND expr
- {
- $$ = &Expr{Op: BigAND, X: $1, Y: $3}
- }
-| expr _OR expr
- {
- $$ = &Expr{Op: BigOR, X: $1, Y: $3}
- }
-| expr _EOR expr
- {
- $$ = &Expr{Op: BigEOR, X: $1, Y: $3}
- }
-| '+' expr %prec unary
- {
- $$ = &Expr{Op: Plus, X: $2}
- }
-| '-' expr %prec unary
- {
- $$ = &Expr{Op: Minus, X: $2}
- }
-| expr '+' expr
- {
- $$ = &Expr{Op: Add, X: $1, Y: $3}
- }
-| expr '-' expr
- {
- $$ = &Expr{Op: Sub, X: $1, Y: $3}
- }
-| expr '*' expr
- {
- $$ = &Expr{Op: Mul, X: $1, Y: $3}
- }
-| expr '/' expr
- {
- $$ = &Expr{Op: Div, X: $1, Y: $3}
- }
-| expr _DIV expr
- {
- $$ = &Expr{Op: BigDIV, X: $1, Y: $3}
- }
-| expr _MOD expr
- {
- $$ = &Expr{Op: BigMOD, X: $1, Y: $3}
- }
-| _TWOPOW expr
- {
- $$ = &Expr{Op: TwoPow, X: $2}
- }
-| expr _LSH expr
- {
- $$ = &Expr{Op: Lsh, X: $1, Y: $3}
- }
-| expr _RSH expr
- {
- $$ = &Expr{Op: Rsh, X: $1, Y: $3}
- }
-| expr '[' expr_list ']'
- {
- $$ = &Expr{Op: Index, X: $1, List: $3}
- }
-| expr '.' _NAME
- {
- $$ = &Expr{Op: Dot, X: $1, Text: $3}
- }
-| expr '=' expr %prec last_resort
- {
- $$ = &Expr{Op: Eq, X: $1, Y: $3}
- }
-
-call_expr:
- _NAME_PAREN expr_list_opt ')'
- {
- $$ = &Expr{Op: Call, Text: $1, List: $2}
- }
-
-unnamed_type:
- _BITS expr ')'
- {
- $$ = &Type{Op: BitType, NX: $2}
- }
-| _BIT
- {
- $$ = &Type{Op: BitType, N: 1}
- }
-| _INTEGER
- {
- $$ = &Type{Op: IntegerType}
- }
-| _BOOLEAN
- {
- $$ = &Type{Op: BoolType}
- }
-
-%%
-
-func parseIntConst(s string) int {
- n, _ := strconv.Atoi(s)
- return n
-}
diff --git a/arm/armspec/y.go b/arm/armspec/y.go
deleted file mode 100644
index 8a289ce..0000000
--- a/arm/armspec/y.go
+++ /dev/null
@@ -1,1165 +0,0 @@
-//line pseudo.y:2
-package main
-
-import __yyfmt__ "fmt"
-
-//line pseudo.y:2
-import (
- "strconv"
-)
-
-//line pseudo.y:10
-type yySymType struct {
- yys int
- str string
- line Line
- stmt *Stmt
- stmts []*Stmt
- expr *Expr
- exprs []*Expr
- elseifs []*ElseIf
- when *When
- whens []*When
- typ *Type
- typs []*Type
-}
-
-const _ASSERT = 57346
-const _BITS = 57347
-const _BIT = 57348
-const _IF = 57349
-const _EOF = 57350
-const _NAME = 57351
-const _NAME_PAREN = 57352
-const _RETURN = 57353
-const _UNDEFINED = 57354
-const _UNPREDICTABLE = 57355
-const _IMPLEMENTATION_DEFINED = 57356
-const _SUBARCHITECTURE_DEFINED = 57357
-const _ENUMERATION = 57358
-const _DO = 57359
-const _INDENT = 57360
-const _UNINDENT = 57361
-const _THEN = 57362
-const _REPEAT = 57363
-const _UNTIL = 57364
-const _WHILE = 57365
-const _CASE = 57366
-const _FOR = 57367
-const _TO = 57368
-const _OF = 57369
-const _ELSIF = 57370
-const _ELSE = 57371
-const _OTHERWISE = 57372
-const _WHEN = 57373
-const _CONST = 57374
-const _UNKNOWN = 57375
-const _EQ = 57376
-const _NE = 57377
-const _LE = 57378
-const _GE = 57379
-const _AND = 57380
-const _OR = 57381
-const _EOR = 57382
-const _ANDAND = 57383
-const _OROR = 57384
-const _DIV = 57385
-const _MOD = 57386
-const _TWOPOW = 57387
-const _LSH = 57388
-const _RSH = 57389
-const _INTEGER = 57390
-const _BOOLEAN = 57391
-const _SEE = 57392
-const last_resort = 57393
-const _LT = 57394
-const _GT = 57395
-const unary = 57396
-
-var yyToknames = []string{
- "_ASSERT",
- "_BITS",
- "_BIT",
- "_IF",
- "_EOF",
- "_NAME",
- "_NAME_PAREN",
- "_RETURN",
- "_UNDEFINED",
- "_UNPREDICTABLE",
- "_IMPLEMENTATION_DEFINED",
- "_SUBARCHITECTURE_DEFINED",
- "_ENUMERATION",
- "_DO",
- "_INDENT",
- "_UNINDENT",
- "_THEN",
- "_REPEAT",
- "_UNTIL",
- "_WHILE",
- "_CASE",
- "_FOR",
- "_TO",
- "_OF",
- "_ELSIF",
- "_ELSE",
- "_OTHERWISE",
- "_WHEN",
- "_CONST",
- "_UNKNOWN",
- "_EQ",
- "_NE",
- "_LE",
- "_GE",
- "_AND",
- "_OR",
- "_EOR",
- "_ANDAND",
- "_OROR",
- "_DIV",
- "_MOD",
- "_TWOPOW",
- "_LSH",
- "_RSH",
- "_INTEGER",
- "_BOOLEAN",
- "_SEE",
- "last_resort",
- " =",
- " ,",
- "_LT",
- " >",
- "_GT",
- " :",
- " +",
- " -",
- " |",
- " ^",
- " *",
- " /",
- " %",
- " &",
- " .",
- " <",
- " [",
- "unary",
-}
-var yyStatenames = []string{}
-
-const yyEofCode = 1
-const yyErrCode = 2
-const yyMaxDepth = 200
-
-//line pseudo.y:544
-func parseIntConst(s string) int {
- n, _ := strconv.Atoi(s)
- return n
-}
-
-//line yacctab:1
-var yyExca = []int{
- -1, 1,
- 1, -1,
- -2, 0,
-}
-
-const yyNprod = 107
-const yyPrivate = 57344
-
-var yyTokenNames []string
-var yyStates []string
-
-const yyLast = 1272
-
-var yyAct = []int{
-
- 15, 190, 103, 44, 16, 134, 194, 16, 42, 5,
- 47, 48, 49, 50, 140, 4, 13, 137, 79, 39,
- 78, 138, 43, 6, 85, 46, 6, 181, 154, 134,
- 133, 16, 96, 89, 91, 92, 93, 94, 79, 75,
- 55, 74, 139, 134, 84, 83, 101, 82, 168, 81,
- 6, 80, 108, 109, 110, 111, 79, 113, 114, 115,
- 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
- 126, 127, 128, 129, 130, 79, 112, 76, 134, 102,
- 153, 77, 203, 3, 100, 188, 40, 27, 63, 150,
- 16, 93, 132, 70, 71, 131, 72, 73, 143, 144,
- 145, 16, 39, 147, 179, 180, 149, 142, 41, 6,
- 41, 86, 68, 69, 141, 202, 75, 55, 74, 95,
- 148, 98, 53, 54, 57, 63, 64, 65, 59, 60,
- 70, 71, 38, 72, 73, 155, 87, 196, 79, 157,
- 201, 56, 1, 58, 62, 66, 67, 164, 61, 68,
- 69, 173, 174, 75, 55, 74, 193, 88, 156, 93,
- 195, 170, 171, 167, 175, 178, 162, 176, 160, 172,
- 169, 182, 161, 159, 185, 16, 14, 177, 16, 187,
- 2, 184, 191, 16, 186, 0, 0, 0, 183, 192,
- 0, 0, 0, 0, 0, 16, 189, 0, 0, 0,
- 0, 200, 16, 207, 199, 16, 0, 0, 205, 208,
- 0, 192, 0, 0, 204, 0, 0, 0, 206, 12,
- 23, 24, 7, 0, 30, 37, 17, 18, 19, 21,
- 22, 28, 0, 27, 136, 0, 8, 0, 9, 11,
- 10, 0, 0, 0, 0, 0, 0, 29, 31, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 36, 0, 0, 25, 26, 20, 0, 0, 0, 0,
- 0, 0, 0, 34, 35, 12, 23, 24, 7, 0,
- 30, 37, 17, 18, 19, 21, 22, 28, 32, 27,
- 33, 0, 8, 0, 9, 11, 10, 0, 0, 0,
- 0, 0, 0, 29, 31, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 36, 0, 0, 25,
- 26, 20, 0, 0, 0, 0, 0, 0, 0, 34,
- 35, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 32, 0, 33, 98, 53, 54,
- 57, 63, 64, 65, 59, 60, 70, 71, 0, 72,
- 73, 0, 0, 0, 0, 99, 0, 56, 0, 58,
- 62, 66, 67, 0, 61, 68, 69, 0, 0, 75,
- 55, 74, 0, 0, 23, 24, 45, 135, 30, 37,
- 17, 18, 19, 21, 22, 0, 0, 27, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 29, 31, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 36, 0, 0, 25, 26, 20,
- 0, 0, 0, 0, 0, 0, 0, 34, 35, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 32, 0, 33, 98, 53, 54, 57, 63,
- 64, 65, 59, 60, 70, 71, 0, 72, 73, 0,
- 0, 0, 0, 99, 0, 56, 0, 58, 62, 66,
- 67, 0, 61, 68, 69, 0, 0, 75, 55, 74,
- 0, 165, 98, 53, 54, 57, 63, 64, 65, 59,
- 60, 70, 71, 0, 72, 73, 0, 0, 0, 0,
- 99, 0, 56, 0, 58, 62, 66, 67, 0, 61,
- 68, 69, 0, 0, 75, 55, 74, 0, 151, 98,
- 53, 54, 57, 63, 64, 65, 59, 60, 70, 71,
- 0, 72, 73, 0, 0, 0, 0, 99, 0, 56,
- 0, 58, 62, 66, 67, 0, 61, 68, 69, 0,
- 0, 75, 55, 74, 0, 107, 23, 24, 45, 0,
- 30, 37, 17, 18, 19, 21, 22, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 29, 31, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 36, 0, 0, 25,
- 26, 20, 0, 0, 0, 0, 0, 0, 0, 34,
- 35, 0, 0, 198, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 32, 0, 33, 98, 53, 54,
- 57, 63, 64, 65, 59, 60, 70, 71, 0, 72,
- 73, 0, 0, 0, 0, 99, 0, 56, 197, 58,
- 62, 66, 67, 0, 61, 68, 69, 0, 0, 75,
- 55, 74, 98, 53, 54, 57, 63, 64, 65, 59,
- 60, 70, 71, 0, 72, 73, 0, 0, 0, 0,
- 99, 104, 56, 0, 58, 62, 66, 67, 0, 61,
- 68, 69, 0, 0, 75, 55, 74, 0, 98, 53,
- 54, 57, 63, 64, 65, 59, 60, 70, 71, 0,
- 72, 73, 0, 0, 0, 0, 99, 0, 56, 0,
- 58, 62, 66, 67, 0, 61, 68, 69, 163, 0,
- 75, 55, 74, 98, 53, 54, 57, 63, 64, 65,
- 59, 60, 70, 71, 0, 72, 73, 0, 0, 0,
- 0, 99, 0, 56, 0, 58, 62, 66, 67, 0,
- 61, 68, 69, 166, 0, 75, 55, 74, 0, 0,
- 0, 98, 53, 54, 57, 63, 64, 65, 59, 60,
- 70, 71, 0, 72, 73, 0, 0, 0, 0, 99,
- 0, 56, 0, 58, 62, 66, 67, 0, 61, 68,
- 69, 163, 0, 75, 55, 74, 52, 53, 54, 57,
- 63, 64, 65, 59, 60, 70, 71, 0, 72, 73,
- 0, 0, 0, 0, 51, 0, 56, 146, 58, 62,
- 66, 67, 0, 61, 68, 69, 0, 0, 75, 55,
- 74, 98, 53, 54, 57, 63, 64, 65, 59, 60,
- 70, 71, 0, 72, 73, 0, 0, 0, 0, 99,
- 0, 56, 0, 58, 62, 66, 67, 0, 61, 68,
- 69, 106, 0, 75, 55, 74, 0, 0, 98, 53,
- 54, 57, 63, 64, 65, 59, 60, 70, 71, 0,
- 72, 73, 0, 0, 0, 0, 99, 0, 56, 97,
- 58, 62, 66, 67, 0, 61, 68, 69, 0, 0,
- 75, 55, 74, 98, 53, 54, 57, 63, 64, 65,
- 59, 60, 70, 71, 0, 72, 73, 0, 0, 0,
- 0, 99, 0, 56, 0, 58, 62, 66, 67, 0,
- 61, 68, 69, 0, 0, 75, 55, 74, 98, 53,
- 54, 57, 63, 64, 65, 59, 60, 70, 71, 0,
- 72, 73, 0, 0, 0, 0, 99, 0, 56, 0,
- 58, 62, 66, 67, 0, 61, 68, 69, 0, 0,
- 75, 55, 74, 98, 53, 54, 57, 63, 64, 65,
- 59, 60, 70, 71, 0, 72, 73, 0, 0, 0,
- 0, 105, 0, 56, 0, 58, 62, 66, 67, 0,
- 61, 68, 69, 0, 0, 75, 55, 74, 52, 53,
- 54, 57, 63, 64, 65, 59, 60, 70, 71, 0,
- 72, 73, 0, 0, 0, 0, 51, 0, 56, 0,
- 58, 62, 66, 67, 0, 61, 68, 69, 0, 0,
- 75, 55, 74, 98, 53, 54, 57, 63, 64, 65,
- 0, 0, 70, 71, 0, 72, 73, 23, 24, 45,
- 0, 30, 37, 56, 0, 58, 62, 66, 67, 0,
- 61, 68, 69, 0, 0, 75, 55, 74, 23, 24,
- 45, 0, 30, 37, 29, 31, 23, 24, 45, 0,
- 30, 37, 0, 0, 0, 0, 0, 36, 0, 0,
- 25, 26, 0, 0, 0, 29, 31, 0, 0, 0,
- 34, 35, 0, 29, 31, 0, 0, 0, 36, 0,
- 0, 25, 26, 0, 0, 32, 36, 33, 0, 25,
- 26, 34, 158, 0, 0, 0, 0, 0, 0, 34,
- 90, 0, 0, 0, 0, 0, 32, 0, 33, 0,
- 0, 0, 0, 0, 32, 0, 33, 63, 64, 65,
- 0, 0, 70, 71, 0, 72, 73, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 62, 66, 67, 0,
- 61, 68, 69, 0, 0, 75, 55, 74, 0, 152,
- 63, 64, 65, 0, 0, 70, 71, 0, 72, 73,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 62,
- 66, 67, 0, 61, 68, 69, 0, 0, 75, 55,
- 74, 63, 64, 65, 0, 0, 70, 71, 0, 72,
- 73, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 66, 67, 0, 61, 68, 69, 0, 0, 75,
- 55, 74,
-}
-var yyPact = []int{
-
- 271, -1000, 124, 271, -1000, -1000, 77, 1072, 69, 1072,
- 1072, 1072, 1072, -1000, -1000, 994, 7, 1072, -19, -21,
- -23, -25, -26, 1072, -1000, -1000, -1000, 271, 127, -1000,
- -1000, -1000, 1101, 1072, 1072, 1072, 1072, 1072, -1000, -1000,
- -38, -1000, 889, 75, -1000, 1072, 57, 674, 959, 854,
- 495, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072,
- 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072,
- 1072, 1072, 1072, 1072, 1072, 83, -1000, -40, -10, 924,
- -1000, -1000, -1000, -1000, -1000, 313, 215, -54, -32, 924,
- 1072, -1000, -1000, -1000, -27, -60, -1000, 379, 1072, 1072,
- -1000, 817, 1072, 69, -1000, 1072, 71, -1000, 458, 1139,
- 1172, 1172, 25, 1172, 1172, 1172, 1029, 1029, 50, 1203,
- -27, 50, 50, 50, 50, -27, -27, -27, -27, -27,
- -27, -48, -1000, -1000, 1072, -1000, -1000, 1072, 1093, -1000,
- -1000, -1000, -1000, 782, 1172, 924, 1072, 421, -1000, 747,
- -1000, -1000, -1000, -1000, -1000, 924, -24, 924, 1072, -1000,
- 133, -1000, 123, 1072, 709, -1000, 1072, 74, -43, -1000,
- 1072, 379, -1000, 1072, 561, 87, 674, 66, -1000, 379,
- 128, -1000, 638, -1000, -1000, 603, -1000, 69, -1000, -1000,
- -1000, 561, -1000, 62, -1000, -1000, -1000, 69, 561, -1000,
- -1000, 379, 128, -1000, -1000, -1000, -1000, -1000, -1000,
-}
-var yyPgo = []int{
-
- 0, 83, 182, 180, 15, 9, 16, 1, 177, 176,
- 173, 172, 170, 169, 168, 166, 165, 163, 81, 20,
- 157, 156, 0, 3, 6, 22, 142, 2, 140,
-}
-var yyR1 = []int{
-
- 0, 26, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 9, 27, 27, 6, 7, 2, 2, 1,
- 1, 3, 3, 10, 11, 14, 14, 15, 15, 12,
- 12, 12, 13, 13, 17, 17, 16, 16, 28, 28,
- 8, 8, 8, 18, 18, 19, 19, 21, 21, 24,
- 24, 20, 20, 20, 20, 22, 22, 22, 22, 22,
- 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
- 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
- 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
- 22, 22, 23, 25, 25, 25, 25,
-}
-var yyR2 = []int{
-
- 0, 2, 4, 4, 2, 3, 2, 2, 2, 2,
- 2, 1, 3, 5, 5, 5, 4, 8, 7, 3,
- 1, 1, 6, 0, 1, 3, 1, 1, 2, 1,
- 2, 0, 1, 2, 2, 0, 5, 0, 5, 0,
- 2, 2, 0, 2, 0, 2, 4, 4, 0, 1,
- 0, 2, 2, 0, 1, 1, 3, 1, 3, 1,
- 1, 1, 1, 3, 3, 1, 1, 2, 1, 2,
- 1, 3, 3, 3, 3, 4, 3, 3, 3, 6,
- 2, 3, 3, 3, 3, 3, 3, 3, 2, 2,
- 3, 3, 3, 3, 3, 3, 2, 3, 3, 4,
- 3, 3, 3, 3, 1, 1, 1,
-}
-var yyChk = []int{
-
- -1000, -26, -3, -1, -4, -5, -25, 7, 21, 23,
- 25, 24, 4, -6, -9, -22, -23, 11, 12, 13,
- 50, 14, 15, 5, 6, 48, 49, 18, 16, 32,
- 9, 33, 73, 75, 58, 59, 45, 10, 8, -4,
- 9, 33, -22, -25, -23, 7, -6, -22, -22, -22,
- -22, 52, 34, 35, 36, 67, 54, 37, 56, 41,
- 42, 61, 57, 38, 39, 40, 58, 59, 62, 63,
- 43, 44, 46, 47, 68, 66, 70, -18, -19, -22,
- 70, 70, 70, 70, 70, -22, -1, 9, -20, -22,
- 59, -22, -22, -22, -22, -18, 70, 20, 34, 52,
- 9, -22, 22, -27, 17, 52, 27, 70, -22, -22,
- -22, -22, -19, -22, -22, -22, -22, -22, -22, -22,
- -22, -22, -22, -22, -22, -22, -22, -22, -22, -22,
- -22, -19, 9, 70, 53, 74, 19, 71, 53, 74,
- 74, -6, -5, -22, -22, -22, 20, -22, -6, -22,
- 18, 70, 70, 55, 76, -22, -19, -22, 59, -10,
- -14, -11, -15, 29, -22, 70, 26, -17, 72, -12,
- 28, 29, -13, 28, 29, -22, -22, -8, -16, 30,
- 31, 70, -22, -6, -5, -22, -5, -27, 19, -6,
- -7, -2, -5, -21, -24, 32, 9, 20, 20, -6,
- -5, -28, 53, 20, -6, -5, -6, -7, -24,
-}
-var yyDef = []int{
-
- 31, -2, 0, 32, 29, 11, 0, 0, 0, 0,
- 0, 0, 0, 20, 21, 0, 70, 53, 0, 0,
- 0, 0, 0, 0, 104, 105, 106, 0, 0, 65,
- 66, 68, 0, 0, 0, 0, 0, 53, 1, 30,
- 67, 69, 0, 0, 70, 0, 0, 23, 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, 0, 4, 0, 54, 55,
- 6, 7, 8, 9, 10, 0, 0, 0, 0, 61,
- 62, 80, 88, 89, 96, 0, 12, 0, 0, 0,
- 67, 0, 0, 0, 24, 0, 0, 19, 101, 72,
- 73, 74, 0, 76, 77, 78, 81, 82, 83, 84,
- 85, 86, 87, 90, 91, 92, 93, 94, 95, 97,
- 98, 0, 100, 5, 0, 103, 25, 0, 0, 71,
- 102, 35, 37, 0, 72, 101, 0, 0, 16, 0,
- 44, 2, 3, 75, 99, 56, 0, 63, 64, 13,
- 39, 14, 42, 0, 0, 15, 0, 50, 0, 33,
- 0, 0, 34, 0, 0, 79, 23, 0, 45, 0,
- 0, 22, 0, 40, 41, 0, 43, 0, 18, 51,
- 52, 26, 27, 48, 57, 59, 60, 0, 0, 17,
- 28, 0, 0, 49, 36, 38, 46, 47, 58,
-}
-var yyTok1 = []int{
-
- 1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 75, 3, 3, 3, 64, 65, 3,
- 73, 74, 62, 58, 53, 59, 66, 63, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 57, 70,
- 67, 52, 55, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 68, 3, 76, 61, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 71, 60, 72,
-}
-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,
- 54, 56, 69,
-}
-var yyTok3 = []int{
- 0,
-}
-
-//line yaccpar:1
-
-/* parser for yacc output */
-
-var yyDebug = 0
-
-type yyLexer interface {
- Lex(lval *yySymType) int
- Error(s string)
-}
-
-const yyFlag = -1000
-
-func yyTokname(c int) string {
- // 4 is TOKSTART above
- if c >= 4 && c-4 < len(yyToknames) {
- if yyToknames[c-4] != "" {
- return yyToknames[c-4]
- }
- }
- 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 yylex1(lex yyLexer, lval *yySymType) int {
- c := 0
- char := lex.Lex(lval)
- if char <= 0 {
- c = yyTok1[0]
- goto out
- }
- if char < len(yyTok1) {
- c = yyTok1[char]
- goto out
- }
- if char >= yyPrivate {
- if char < yyPrivate+len(yyTok2) {
- c = yyTok2[char-yyPrivate]
- goto out
- }
- }
- for i := 0; i < len(yyTok3); i += 2 {
- c = yyTok3[i+0]
- if c == char {
- c = yyTok3[i+1]
- goto out
- }
- }
-
-out:
- if c == 0 {
- c = yyTok2[1] /* unknown char */
- }
- if yyDebug >= 3 {
- __yyfmt__.Printf("lex %s(%d)\n", yyTokname(c), uint(char))
- }
- return c
-}
-
-func yyParse(yylex yyLexer) int {
- var yyn int
- var yylval yySymType
- var yyVAL yySymType
- yyS := make([]yySymType, yyMaxDepth)
-
- Nerrs := 0 /* number of errors */
- Errflag := 0 /* error recovery flag */
- yystate := 0
- yychar := -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(yychar), 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 = yylex1(yylex, &yylval)
- }
- yyn += yychar
- if yyn < 0 || yyn >= yyLast {
- goto yydefault
- }
- yyn = yyAct[yyn]
- if yyChk[yyn] == yychar { /* valid shift */
- yychar = -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 = 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 == yychar {
- 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("syntax error")
- Nerrs++
- if yyDebug >= 1 {
- __yyfmt__.Printf("%s", yyStatname(yystate))
- __yyfmt__.Printf(" saw %s\n", yyTokname(yychar))
- }
- 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(yychar))
- }
- if yychar == yyEofCode {
- goto ret1
- }
- yychar = -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]
- 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:
- //line pseudo.y:100
- {
- yylex.(*Lexer).prog = yyS[yypt-1].stmts
- return 0
- }
- case 2:
- //line pseudo.y:107
- {
- yyVAL.stmt = &Stmt{Op: Assign, X: yyS[yypt-3].expr, Y: yyS[yypt-1].expr}
- }
- case 3:
- //line pseudo.y:111
- {
- yyVAL.stmt = &Stmt{Op: Assign, X: yyS[yypt-3].expr, Y: yyS[yypt-1].expr}
- }
- case 4:
- //line pseudo.y:115
- {
- yyVAL.stmt = &Stmt{Op: StmtExpr, X: yyS[yypt-1].expr}
- }
- case 5:
- //line pseudo.y:119
- {
- yyVAL.stmt = &Stmt{Op: Return, List: yyS[yypt-1].exprs}
- }
- case 6:
- //line pseudo.y:123
- {
- yyVAL.stmt = &Stmt{Op: Undefined}
- }
- case 7:
- //line pseudo.y:127
- {
- yyVAL.stmt = &Stmt{Op: Unpredictable}
- }
- case 8:
- //line pseudo.y:131
- {
- yyVAL.stmt = &Stmt{Op: See, Text: yyS[yypt-1].str}
- }
- case 9:
- //line pseudo.y:135
- {
- yyVAL.stmt = &Stmt{Op: ImplDefined}
- }
- case 10:
- //line pseudo.y:139
- {
- yyVAL.stmt = &Stmt{Op: SubarchDefined}
- }
- case 11:
- yyVAL.stmt = yyS[yypt-0].stmt
- case 12:
- //line pseudo.y:146
- {
- yyVAL.stmt = &Stmt{Op: StmtExpr, X: &Expr{Op: Decl, Type: yyS[yypt-2].typ, Text: yyS[yypt-1].str}}
- }
- case 13:
- //line pseudo.y:150
- {
- yyVAL.stmt = &Stmt{Op: If, X: yyS[yypt-3].expr, Body: yyS[yypt-1].stmt, ElseIf: yyS[yypt-0].elseifs, Else: yyS[yypt-0].stmt}
- }
- case 14:
- //line pseudo.y:154
- {
- yyVAL.stmt = &Stmt{Op: If, X: yyS[yypt-3].expr, Body: yyS[yypt-1].stmt, ElseIf: yyS[yypt-0].elseifs, Else: yyS[yypt-0].stmt}
- }
- case 15:
- //line pseudo.y:158
- {
- yyVAL.stmt = &Stmt{Op: Repeat, Body: yyS[yypt-3].stmt, X: yyS[yypt-1].expr}
- }
- case 16:
- //line pseudo.y:162
- {
- yyVAL.stmt = &Stmt{Op: While, X: yyS[yypt-2].expr, Body: yyS[yypt-0].stmt}
- }
- case 17:
- //line pseudo.y:166
- {
- yyVAL.stmt = &Stmt{Op: For, X: yyS[yypt-6].expr, Y: yyS[yypt-4].expr, Z: yyS[yypt-2].expr, Body: yyS[yypt-0].stmt}
- }
- case 18:
- //line pseudo.y:170
- {
- yyVAL.stmt = &Stmt{Op: Case, X: yyS[yypt-5].expr, When: yyS[yypt-2].whens, Else: yyS[yypt-1].stmt}
- }
- case 19:
- //line pseudo.y:174
- {
- yyVAL.stmt = &Stmt{Op: Assert, X: yyS[yypt-1].expr}
- }
- case 20:
- //line pseudo.y:178
- {
- yyVAL.stmt = yyS[yypt-0].stmt
- }
- case 21:
- yyVAL.stmt = yyS[yypt-0].stmt
- case 22:
- //line pseudo.y:185
- {
- yyVAL.stmt = &Stmt{Op: Enum, Text: yyS[yypt-4].str, List: yyS[yypt-2].exprs}
- }
- case 25:
- //line pseudo.y:194
- {
- yyVAL.stmt = &Stmt{Op: Block, Block: yyS[yypt-1].stmts}
- }
- case 26:
- //line pseudo.y:200
- {
- yyVAL.stmt = &Stmt{Op: Block, Block: yyS[yypt-0].stmts}
- }
- case 27:
- //line pseudo.y:206
- {
- yyVAL.stmts = []*Stmt{yyS[yypt-0].stmt}
- }
- case 28:
- //line pseudo.y:210
- {
- yyVAL.stmts = append(yyS[yypt-1].stmts, yyS[yypt-0].stmt)
- }
- case 29:
- //line pseudo.y:216
- {
- yyVAL.stmts = []*Stmt{yyS[yypt-0].stmt}
- }
- case 30:
- //line pseudo.y:220
- {
- yyVAL.stmts = append(yyS[yypt-1].stmts, yyS[yypt-0].stmt)
- }
- case 31:
- //line pseudo.y:225
- {
- yyVAL.stmts = nil
- }
- case 32:
- yyVAL.stmts = yyS[yypt-0].stmts
- case 33:
- //line pseudo.y:232
- {
- yyVAL.elseifs = yyS[yypt-1].elseifs
- yyVAL.stmt = yyS[yypt-0].stmt
- }
- case 34:
- //line pseudo.y:239
- {
- yyVAL.elseifs = yyS[yypt-1].elseifs
- yyVAL.stmt = yyS[yypt-0].stmt
- }
- case 35:
- //line pseudo.y:245
- {
- yyVAL.elseifs = nil
- }
- case 36:
- //line pseudo.y:249
- {
- yyVAL.elseifs = append(yyS[yypt-4].elseifs, &ElseIf{Cond: yyS[yypt-2].expr, Body: yyS[yypt-0].stmt})
- }
- case 37:
- //line pseudo.y:254
- {
- yyVAL.elseifs = nil
- }
- case 38:
- //line pseudo.y:258
- {
- yyVAL.elseifs = append(yyS[yypt-4].elseifs, &ElseIf{Cond: yyS[yypt-2].expr, Body: yyS[yypt-0].stmt})
- }
- case 39:
- //line pseudo.y:263
- {
- yyVAL.stmt = nil
- }
- case 40:
- //line pseudo.y:267
- {
- yyVAL.stmt = yyS[yypt-0].stmt
- }
- case 41:
- //line pseudo.y:271
- {
- yyVAL.stmt = yyS[yypt-0].stmt
- }
- case 42:
- //line pseudo.y:276
- {
- yyVAL.stmt = nil
- }
- case 43:
- //line pseudo.y:280
- {
- yyVAL.stmt = yyS[yypt-0].stmt
- }
- case 44:
- //line pseudo.y:285
- {
- yyVAL.whens = nil
- }
- case 45:
- //line pseudo.y:289
- {
- yyVAL.whens = append(yyS[yypt-1].whens, yyS[yypt-0].when)
- }
- case 46:
- //line pseudo.y:295
- {
- yyVAL.when = &When{Cond: yyS[yypt-2].exprs, Body: yyS[yypt-0].stmt}
- }
- case 47:
- //line pseudo.y:299
- {
- yyVAL.when = &When{Cond: yyS[yypt-2].exprs, Body: yyS[yypt-0].stmt}
- }
- case 50:
- //line pseudo.y:307
- {
- yyVAL.stmt = nil
- }
- case 51:
- //line pseudo.y:311
- {
- yyVAL.stmt = yyS[yypt-0].stmt
- }
- case 52:
- //line pseudo.y:315
- {
- yyVAL.stmt = yyS[yypt-0].stmt
- }
- case 53:
- //line pseudo.y:320
- {
- yyVAL.exprs = nil
- }
- case 54:
- yyVAL.exprs = yyS[yypt-0].exprs
- case 55:
- //line pseudo.y:327
- {
- yyVAL.exprs = []*Expr{yyS[yypt-0].expr}
- }
- case 56:
- //line pseudo.y:331
- {
- yyVAL.exprs = append(yyS[yypt-2].exprs, yyS[yypt-0].expr)
- }
- case 57:
- //line pseudo.y:337
- {
- yyVAL.exprs = []*Expr{yyS[yypt-0].expr}
- }
- case 58:
- //line pseudo.y:341
- {
- yyVAL.exprs = append(yyS[yypt-2].exprs, yyS[yypt-0].expr)
- }
- case 59:
- //line pseudo.y:347
- {
- yyVAL.expr = &Expr{Op: Const, Text: yyS[yypt-0].str}
- }
- case 60:
- //line pseudo.y:351
- {
- yyVAL.expr = &Expr{Op: Name, Text: yyS[yypt-0].str}
- }
- case 61:
- //line pseudo.y:357
- {
- yyVAL.exprs = []*Expr{yyS[yypt-0].expr}
- }
- case 62:
- //line pseudo.y:361
- {
- yyVAL.exprs = []*Expr{&Expr{Op: Blank}}
- }
- case 63:
- //line pseudo.y:365
- {
- yyVAL.exprs = append(yyS[yypt-2].exprs, yyS[yypt-0].expr)
- }
- case 64:
- //line pseudo.y:369
- {
- yyVAL.exprs = append(yyS[yypt-2].exprs, &Expr{Op: Blank})
- }
- case 65:
- //line pseudo.y:375
- {
- yyVAL.expr = &Expr{Op: Const, Text: yyS[yypt-0].str}
- }
- case 66:
- //line pseudo.y:379
- {
- yyVAL.expr = &Expr{Op: Name, Text: yyS[yypt-0].str}
- }
- case 67:
- //line pseudo.y:383
- {
- yyVAL.expr = &Expr{Op: Decl, Type: yyS[yypt-1].typ, Text: yyS[yypt-0].str}
- }
- case 68:
- //line pseudo.y:387
- {
- yyVAL.expr = &Expr{Op: Unknown}
- }
- case 69:
- //line pseudo.y:391
- {
- yyVAL.expr = &Expr{Op: Unknown, Type: yyS[yypt-1].typ}
- }
- case 70:
- yyVAL.expr = yyS[yypt-0].expr
- case 71:
- //line pseudo.y:396
- {
- yyVAL.expr = &Expr{Op: ExprTuple, List: yyS[yypt-1].exprs}
- }
- case 72:
- //line pseudo.y:400
- {
- yyVAL.expr = &Expr{Op: Eq, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 73:
- //line pseudo.y:404
- {
- yyVAL.expr = &Expr{Op: NotEq, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 74:
- //line pseudo.y:408
- {
- yyVAL.expr = &Expr{Op: LtEq, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 75:
- //line pseudo.y:412
- {
- yyVAL.expr = &Expr{Op: BitIndex, X: yyS[yypt-3].expr, List: yyS[yypt-1].exprs}
- }
- case 76:
- //line pseudo.y:416
- {
- yyVAL.expr = &Expr{Op: Lt, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 77:
- //line pseudo.y:420
- {
- yyVAL.expr = &Expr{Op: GtEq, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 78:
- //line pseudo.y:424
- {
- yyVAL.expr = &Expr{Op: Gt, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 79:
- //line pseudo.y:428
- {
- yyVAL.expr = &Expr{Op: IfElse, X: yyS[yypt-4].expr, Y: yyS[yypt-2].expr, Z: yyS[yypt-0].expr}
- }
- case 80:
- //line pseudo.y:432
- {
- yyVAL.expr = &Expr{Op: Not, X: yyS[yypt-0].expr}
- }
- case 81:
- //line pseudo.y:436
- {
- yyVAL.expr = &Expr{Op: AndAnd, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 82:
- //line pseudo.y:440
- {
- yyVAL.expr = &Expr{Op: OrOr, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 83:
- //line pseudo.y:444
- {
- yyVAL.expr = &Expr{Op: Eor, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 84:
- //line pseudo.y:448
- {
- yyVAL.expr = &Expr{Op: Colon, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 85:
- //line pseudo.y:452
- {
- yyVAL.expr = &Expr{Op: BigAND, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 86:
- //line pseudo.y:456
- {
- yyVAL.expr = &Expr{Op: BigOR, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 87:
- //line pseudo.y:460
- {
- yyVAL.expr = &Expr{Op: BigEOR, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 88:
- //line pseudo.y:464
- {
- yyVAL.expr = &Expr{Op: Plus, X: yyS[yypt-0].expr}
- }
- case 89:
- //line pseudo.y:468
- {
- yyVAL.expr = &Expr{Op: Minus, X: yyS[yypt-0].expr}
- }
- case 90:
- //line pseudo.y:472
- {
- yyVAL.expr = &Expr{Op: Add, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 91:
- //line pseudo.y:476
- {
- yyVAL.expr = &Expr{Op: Sub, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 92:
- //line pseudo.y:480
- {
- yyVAL.expr = &Expr{Op: Mul, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 93:
- //line pseudo.y:484
- {
- yyVAL.expr = &Expr{Op: Div, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 94:
- //line pseudo.y:488
- {
- yyVAL.expr = &Expr{Op: BigDIV, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 95:
- //line pseudo.y:492
- {
- yyVAL.expr = &Expr{Op: BigMOD, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 96:
- //line pseudo.y:496
- {
- yyVAL.expr = &Expr{Op: TwoPow, X: yyS[yypt-0].expr}
- }
- case 97:
- //line pseudo.y:500
- {
- yyVAL.expr = &Expr{Op: Lsh, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 98:
- //line pseudo.y:504
- {
- yyVAL.expr = &Expr{Op: Rsh, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 99:
- //line pseudo.y:508
- {
- yyVAL.expr = &Expr{Op: Index, X: yyS[yypt-3].expr, List: yyS[yypt-1].exprs}
- }
- case 100:
- //line pseudo.y:512
- {
- yyVAL.expr = &Expr{Op: Dot, X: yyS[yypt-2].expr, Text: yyS[yypt-0].str}
- }
- case 101:
- //line pseudo.y:516
- {
- yyVAL.expr = &Expr{Op: Eq, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
- }
- case 102:
- //line pseudo.y:522
- {
- yyVAL.expr = &Expr{Op: Call, Text: yyS[yypt-2].str, List: yyS[yypt-1].exprs}
- }
- case 103:
- //line pseudo.y:528
- {
- yyVAL.typ = &Type{Op: BitType, NX: yyS[yypt-1].expr}
- }
- case 104:
- //line pseudo.y:532
- {
- yyVAL.typ = &Type{Op: BitType, N: 1}
- }
- case 105:
- //line pseudo.y:536
- {
- yyVAL.typ = &Type{Op: IntegerType}
- }
- case 106:
- //line pseudo.y:540
- {
- yyVAL.typ = &Type{Op: BoolType}
- }
- }
- goto yystack /* stack new state and value */
-}
