map int to Op—no OXXX so that line numbers map properly

goop.txt

ONAME    // var or func name
ONONAME  // unnamed arg or return value: f(int, string) (int, error) { etc }
OTYPE    // type name
OPACK    // import
OLITERAL // literal
OADD          // Left + Right
OSUB          // Left - Right
OOR           // Left | Right
OXOR          // Left ^ Right
OADDSTR       // +{List} (string addition, list elements are strings)
OADDR         // &Left
OANDAND       // Left && Right
OAPPEND       // append(List); after walk, Left may contain elem type descriptor
OBYTES2STR    // Type(Left) (Type is string, Left is a []byte)
OBYTES2STRTMP // Type(Left) (Type is string, Left is a []byte, ephemeral)
ORUNES2STR    // Type(Left) (Type is string, Left is a []rune)
OSTR2BYTES    // Type(Left) (Type is []byte, Left is a string)
OSTR2BYTESTMP // Type(Left) (Type is []byte, Left is a string, ephemeral)
OSTR2RUNES    // Type(Left) (Type is []rune, Left is a string)
OAS           // Left = Right or (if Colas=true) Left := Right
OAS2          // List = Rlist (x, y, z = a, b, c)
OAS2FUNC      // List = Rlist (x, y = f())
OAS2RECV      // List = Rlist (x, ok = <-c)
OAS2MAPR      // List = Rlist (x, ok = m["foo"])
OAS2DOTTYPE   // List = Rlist (x, ok = I.(int))
OASOP         // Left Etype= Right (x += y)
OCALL         // Left(List) (function call, method call or type conversion)
OCALLFUNC  // Left(List/Rlist) (function call f(args))
OCALLMETH  // Left(List/Rlist) (direct method call x.Method(args))
OCALLINTER // Left(List/Rlist) (interface method call x.Method(args))
OCALLPART  // Left.Right (method expression x.Method, not called)
OCAP       // cap(Left)
OCLOSE     // close(Left)
OCLOSURE   // func Type { Body } (func literal)
OCOMPLIT   // Right{List} (composite literal, not yet lowered to specific form)
OMAPLIT    // Type{List} (composite literal, Type is map)
OSTRUCTLIT // Type{List} (composite literal, Type is struct)
OARRAYLIT  // Type{List} (composite literal, Type is array)
OSLICELIT  // Type{List} (composite literal, Type is slice)
OPTRLIT    // &Left (left is composite literal)
OCONV      // Type(Left) (type conversion)
OCONVIFACE // Type(Left) (type conversion, to interface)
OCONVNOP   // Type(Left) (type conversion, no effect)
OCOPY      // copy(Left, Right)
ODCL       // var Left (declares Left of type Left.Type)
ODCLFUNC  // func f() or func (r) f()
ODCLFIELD // struct field, interface field, or func/method argument/return value.
ODCLCONST // const pi = 3.14
ODCLTYPE  // type Int int or type Int = int
ODELETE      // delete(Left, Right)
ODOT         // Left.Sym (Left is of struct type)
ODOTPTR      // Left.Sym (Left is of pointer to struct type)
ODOTMETH     // Left.Sym (Left is non-interface, Right is method name)
ODOTINTER    // Left.Sym (Left is interface, Right is method name)
OXDOT        // Left.Sym (before rewrite to one of the preceding)
ODOTTYPE     // Left.Right or Left.Type (.Right during parsing, .Type once resolved); after walk, .Right contains address of interface type descriptor and .Right.Right contains address of concrete type descriptor
ODOTTYPE2    // Left.Right or Left.Type (.Right during parsing, .Type once resolved; on rhs of OAS2DOTTYPE); after walk, .Right contains address of interface type descriptor
OEQ          // Left == Right
ONE          // Left != Right
OLT          // Left < Right
OLE          // Left <= Right
OGE          // Left >= Right
OGT          // Left > Right
ODEREF       // *Left
OINDEX       // Left[Right] (index of array or slice)
OINDEXMAP    // Left[Right] (index of map)
OKEY         // Left:Right (key:value in struct/array/map literal)
OSTRUCTKEY   // Sym:Left (key:value in struct literal, after type checking)
OLEN         // len(Left)
OMAKE        // make(List) (before type checking converts to one of the following)
OMAKECHAN    // make(Type, Left) (type is chan)
OMAKEMAP     // make(Type, Left) (type is map)
OMAKESLICE   // make(Type, Left, Right) (type is slice)
OMUL         // Left * Right
ODIV         // Left / Right
OMOD         // Left % Right
OLSH         // Left << Right
ORSH         // Left >> Right
OAND         // Left & Right
OANDNOT      // Left &^ Right
ONEW         // new(Left)
ONOT         // !Left
OBITNOT      // ^Left
OPLUS        // +Left
ONEG         // -Left
OOROR        // Left || Right
OPANIC       // panic(Left)
OPRINT       // print(List)
OPRINTN      // println(List)
OPAREN       // (Left)
OSEND        // Left <- Right
OSLICE       // Left[List[0] : List[1]] (Left is untypechecked or slice)
OSLICEARR    // Left[List[0] : List[1]] (Left is array)
OSLICESTR    // Left[List[0] : List[1]] (Left is string)
OSLICE3      // Left[List[0] : List[1] : List[2]] (Left is untypedchecked or slice)
OSLICE3ARR   // Left[List[0] : List[1] : List[2]] (Left is array)
OSLICEHEADER // sliceheader{Left, List[0], List[1]} (Left is unsafe.Pointer, List[0] is length, List[1] is capacity)
ORECOVER     // recover()
ORECV        // <-Left
ORUNESTR     // Type(Left) (Type is string, Left is rune)
OSELRECV     // Left = <-Right.Left: (appears as .Left of OCASE; Right.Op == ORECV)
OSELRECV2    // List = <-Right.Left: (apperas as .Left of OCASE; count(List) == 2, Right.Op == ORECV)
OIOTA        // iota
OREAL        // real(Left)
OIMAG        // imag(Left)
OCOMPLEX     // complex(Left, Right)
OALIGNOF     // unsafe.Alignof(Left)
OOFFSETOF    // unsafe.Offsetof(Left)
OSIZEOF      // unsafe.Sizeof(Left)
OBLOCK    // { List } (block of code)
OBREAK    // break [Sym]
OCASE     // case Left or List[0]..List[1]: Nbody (select case after processing; Left==nil and List==nil means default)
OXCASE    // case List: Nbody (select case before processing; List==nil means default)
OCONTINUE // continue [Sym]
ODEFER    // defer Left (Left must be call)
OEMPTY    // no-op (empty statement)
OFALL     // fallthrough
OFOR      // for Ninit; Left; Right { Nbody }
OFORUNTIL
OGOTO   // goto Sym
OIF     // if Ninit; Left { Nbody } else { Rlist }
OLABEL  // Sym:
OGO     // go Left (Left must be call)
ORANGE  // for List = range Right { Nbody }
ORETURN // return List
OSELECT // select { List } (List is list of OXCASE or OCASE)
OSWITCH // switch Ninit; Left { List } (List is a list of OXCASE or OCASE)
OTYPESW // Left = Right.(type) (appears as .Left of OSWITCH)
OTCHAN   // chan int
OTMAP    // map[string]int
OTSTRUCT // struct{}
OTINTER  // interface{}
OTFUNC   // func()
OTARRAY  // []int, [8]int, [N]int or [...]int
ODDD        // func f(args ...int) or f(l...) or var a = [...]int{0, 1, 2}.
ODDDARG     // func f(args ...int), introduced by escape analysis.
OINLCALL    // intermediary representation of an inlined call.
OEFACE      // itable and data words of an empty-interface value.
OITAB       // itable word of an interface value.
OIDATA      // data word of an interface value in Left
OSPTR       // base pointer of a slice or string.
OCLOSUREVAR // variable reference at beginning of closure function
OCFUNC      // reference to c function pointer (not go func value)
OCHECKNIL   // emit code to ensure pointer/interface not nil
OVARDEF     // variable is about to be fully initialized
OVARKILL    // variable is dead
OVARLIVE    // variable is alive
OINDREGSP   // offset plus indirect of REGSP, such as 8(SP).
ORETJMP // return to other function
OGETG   // runtime.getg() (read g pointer)
OEND