mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
The LICENSE has changed from a single license (Apache2) to a dual license (Apache2 or MIT, at your option). If you've previously used Wuffs under the Apache2 license, you are able to keep doing so. No further action required by you. The two files listed below (previous releases) are exceptions, as they are older snapshots, frozen in time. Their license has not changed: release/c/wuffs-v0.2.c release/c/wuffs-v0.3.c Every name in the AUTHORS file, other than Google Inc., has signed Google's CLA (Contributor License Agreement).
1299 lines
37 KiB
Go
1299 lines
37 KiB
Go
// Copyright 2017 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
package ast
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
|
|
"github.com/google/wuffs/lib/interval"
|
|
|
|
t "github.com/google/wuffs/lang/token"
|
|
)
|
|
|
|
// Kind is what kind of node it is. For example, a top-level func or a numeric
|
|
// constant. Kind is different from Type; the latter is used for type-checking
|
|
// in the programming language sense.
|
|
type Kind uint32
|
|
|
|
// XType is the explicit type, directly from the source code.
|
|
//
|
|
// MType is the implicit type, deduced for expressions during type checking.
|
|
//
|
|
// MBounds are the implicit bounds, deduced during bounds checking.
|
|
|
|
const (
|
|
KInvalid = Kind(iota)
|
|
|
|
KArg
|
|
KAssert
|
|
KAssign
|
|
KChoose
|
|
KConst
|
|
KExpr
|
|
KField
|
|
KFile
|
|
KFunc
|
|
KIOManip
|
|
KIf
|
|
KIterate
|
|
KJump
|
|
KRet
|
|
KStatus
|
|
KStruct
|
|
KTypeExpr
|
|
KUse
|
|
KVar
|
|
KWhile
|
|
)
|
|
|
|
func (k Kind) String() string {
|
|
if uint(k) < uint(len(kindStrings)) {
|
|
return kindStrings[k]
|
|
}
|
|
return "KUnknown"
|
|
}
|
|
|
|
var kindStrings = [...]string{
|
|
KInvalid: "KInvalid",
|
|
|
|
KArg: "KArg",
|
|
KAssert: "KAssert",
|
|
KAssign: "KAssign",
|
|
KChoose: "KChoose",
|
|
KConst: "KConst",
|
|
KExpr: "KExpr",
|
|
KField: "KField",
|
|
KFile: "KFile",
|
|
KFunc: "KFunc",
|
|
KIOManip: "KIOManip",
|
|
KIf: "KIf",
|
|
KIterate: "KIterate",
|
|
KJump: "KJump",
|
|
KRet: "KRet",
|
|
KStatus: "KStatus",
|
|
KStruct: "KStruct",
|
|
KTypeExpr: "KTypeExpr",
|
|
KUse: "KUse",
|
|
KVar: "KVar",
|
|
KWhile: "KWhile",
|
|
}
|
|
|
|
type Flags uint32
|
|
|
|
const (
|
|
// The low 8 bits are reserved. Effect values (Effect is a uint8) share the
|
|
// same values as Flags.
|
|
|
|
FlagsPublic = Flags(0x00000100)
|
|
FlagsHasBreak = Flags(0x00000200)
|
|
FlagsHasContinue = Flags(0x00000400)
|
|
FlagsHasDeepBreak = Flags(0x00000800)
|
|
FlagsHasDeepContinue = Flags(0x00001000)
|
|
FlagsGlobalIdent = Flags(0x00002000)
|
|
FlagsClassy = Flags(0x00004000)
|
|
FlagsSubExprHasEffect = Flags(0x00008000)
|
|
FlagsRetsError = Flags(0x00010000)
|
|
FlagsPrivateData = Flags(0x00020000)
|
|
FlagsChoosy = Flags(0x00040000)
|
|
FlagsHasChooseCPUArch = Flags(0x00080000)
|
|
)
|
|
|
|
func breakFlags(deep bool) Flags {
|
|
if deep {
|
|
return FlagsHasBreak | FlagsHasDeepBreak
|
|
}
|
|
return FlagsHasBreak
|
|
}
|
|
|
|
func continueFlags(deep bool) Flags {
|
|
if deep {
|
|
return FlagsHasContinue | FlagsHasDeepContinue
|
|
}
|
|
return FlagsHasContinue
|
|
}
|
|
|
|
func (f Flags) AsEffect() Effect { return Effect(f) }
|
|
|
|
type Effect uint8
|
|
|
|
const (
|
|
EffectPure = Effect(0)
|
|
EffectImpure = Effect(effectBitImpure)
|
|
EffectImpureCoroutine = Effect(effectBitImpure | effectBitCoroutine)
|
|
|
|
effectBitImpure = 0x01
|
|
effectBitCoroutine = 0x02
|
|
|
|
effectMask = Effect(0xFF)
|
|
)
|
|
|
|
func (e Effect) AsFlags() Flags { return Flags(e) }
|
|
|
|
func (e Effect) Pure() bool { return e == 0 }
|
|
func (e Effect) Impure() bool { return e&effectBitImpure != 0 }
|
|
func (e Effect) Coroutine() bool { return e&effectBitCoroutine != 0 }
|
|
|
|
func (e Effect) WeakerThan(o Effect) bool { return e < o }
|
|
|
|
func (e Effect) String() string {
|
|
switch e & effectMask {
|
|
case EffectPure:
|
|
return ""
|
|
case EffectImpure:
|
|
return "!"
|
|
case EffectImpureCoroutine:
|
|
return "?"
|
|
}
|
|
return "‽INVALID_EFFECT‽"
|
|
}
|
|
|
|
type Node struct {
|
|
kind Kind
|
|
flags Flags
|
|
|
|
constValue *big.Int
|
|
mBounds interval.IntRange
|
|
mType *TypeExpr
|
|
jumpTarget Loop
|
|
|
|
filename string
|
|
line uint32
|
|
|
|
// The idX fields' meaning depend on what kind of node it is.
|
|
//
|
|
// kind id0 id1 id2 kind
|
|
// ------------------------------------------------------------
|
|
// Arg . . name Arg
|
|
// Assert keyword . lit(reason) Assert
|
|
// Assign operator . . Assign
|
|
// Choose . . name Choose
|
|
// Const . pkg name Const
|
|
// Expr operator . literal/ident Expr
|
|
// Field . . name Field
|
|
// File . . . File
|
|
// Func funcName receiverPkg receiverName Func
|
|
// IOManip keyword . . IOManip
|
|
// If . likelihood . If
|
|
// Iterate advance label length Iterate
|
|
// Jump keyword label . Jump
|
|
// Ret keyword . . Ret
|
|
// Status keyword pkg lit(message) Status
|
|
// Struct . pkg name Struct
|
|
// TypeExpr decorator pkg name TypeExpr
|
|
// Use . . lit(path) Use
|
|
// Var operator . name Var
|
|
// While . label . While
|
|
id0 t.ID
|
|
id1 t.ID
|
|
id2 t.ID
|
|
|
|
lhs *Node // Left Hand Side.
|
|
mhs *Node // Middle Hand Side.
|
|
rhs *Node // Right Hand Side.
|
|
|
|
list0 []*Node
|
|
list1 []*Node
|
|
list2 []*Node
|
|
}
|
|
|
|
func (n *Node) Kind() Kind { return n.kind }
|
|
func (n *Node) MBounds() interval.IntRange { return n.mBounds }
|
|
func (n *Node) MType() *TypeExpr { return n.mType }
|
|
func (n *Node) SetMBounds(x interval.IntRange) { n.mBounds = x }
|
|
func (n *Node) SetMType(x *TypeExpr) { n.mType = x }
|
|
|
|
func (n *Node) AsArg() *Arg { return (*Arg)(n) }
|
|
func (n *Node) AsAssert() *Assert { return (*Assert)(n) }
|
|
func (n *Node) AsAssign() *Assign { return (*Assign)(n) }
|
|
func (n *Node) AsChoose() *Choose { return (*Choose)(n) }
|
|
func (n *Node) AsConst() *Const { return (*Const)(n) }
|
|
func (n *Node) AsExpr() *Expr { return (*Expr)(n) }
|
|
func (n *Node) AsField() *Field { return (*Field)(n) }
|
|
func (n *Node) AsFile() *File { return (*File)(n) }
|
|
func (n *Node) AsFunc() *Func { return (*Func)(n) }
|
|
func (n *Node) AsIOManip() *IOManip { return (*IOManip)(n) }
|
|
func (n *Node) AsIf() *If { return (*If)(n) }
|
|
func (n *Node) AsIterate() *Iterate { return (*Iterate)(n) }
|
|
func (n *Node) AsJump() *Jump { return (*Jump)(n) }
|
|
func (n *Node) AsRaw() *Raw { return (*Raw)(n) }
|
|
func (n *Node) AsRet() *Ret { return (*Ret)(n) }
|
|
func (n *Node) AsStatus() *Status { return (*Status)(n) }
|
|
func (n *Node) AsStruct() *Struct { return (*Struct)(n) }
|
|
func (n *Node) AsTypeExpr() *TypeExpr { return (*TypeExpr)(n) }
|
|
func (n *Node) AsUse() *Use { return (*Use)(n) }
|
|
func (n *Node) AsVar() *Var { return (*Var)(n) }
|
|
func (n *Node) AsWhile() *While { return (*While)(n) }
|
|
|
|
func (n *Node) Walk(f func(*Node) error) error {
|
|
if n != nil {
|
|
if err := f(n); err != nil {
|
|
return err
|
|
}
|
|
for _, o := range n.AsRaw().SubNodes() {
|
|
if err := o.Walk(f); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, l := range n.AsRaw().SubLists() {
|
|
for _, o := range l {
|
|
if err := o.Walk(f); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func dropExprCachedMBounds(n *Node) error {
|
|
if n.kind == KExpr {
|
|
n.mBounds = interval.IntRange{nil, nil}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Loop interface {
|
|
AsNode() *Node
|
|
HasBreak() bool
|
|
HasContinue() bool
|
|
HasDeepBreak() bool
|
|
HasDeepContinue() bool
|
|
Keyword() t.ID
|
|
Label() t.ID
|
|
Asserts() []*Node
|
|
Body() []*Node
|
|
SetHasBreak(deep bool)
|
|
SetHasContinue(deep bool)
|
|
}
|
|
|
|
type LoopStack []Loop
|
|
|
|
// Push returns false if an existing Loop has the same non-zero label.
|
|
func (s *LoopStack) Push(l Loop) (ok bool) {
|
|
if label := l.Label(); label != 0 {
|
|
for _, o := range *s {
|
|
if label == o.Label() {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
*s = append(*s, l)
|
|
return true
|
|
}
|
|
|
|
func (s *LoopStack) Pop() Loop {
|
|
l := (*s)[len(*s)-1]
|
|
*s = (*s)[:len(*s)-1]
|
|
return l
|
|
}
|
|
|
|
func (s *LoopStack) Top() Loop {
|
|
return (*s)[len(*s)-1]
|
|
}
|
|
|
|
type Raw Node
|
|
|
|
func (n *Raw) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Raw) Flags() Flags { return n.flags }
|
|
func (n *Raw) FilenameLine() (string, uint32) { return n.filename, n.line }
|
|
func (n *Raw) SubNodes() [3]*Node { return [3]*Node{n.lhs, n.mhs, n.rhs} }
|
|
func (n *Raw) SubLists() [3][]*Node { return [3][]*Node{n.list0, n.list1, n.list2} }
|
|
|
|
func (n *Raw) SetFilenameLine(f string, l uint32) { n.filename, n.line = f, l }
|
|
|
|
func (n *Raw) SetPackage(tm *t.Map, pkg t.ID) error {
|
|
return n.AsNode().Walk(func(o *Node) error {
|
|
switch o.Kind() {
|
|
default:
|
|
return nil
|
|
|
|
case KConst, KFunc, KStatus, KStruct:
|
|
// No-op.
|
|
|
|
case KExpr:
|
|
if o.id0 != t.IDStatus {
|
|
return nil
|
|
}
|
|
|
|
case KTypeExpr:
|
|
if o.id0 != 0 {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
if o.id1 == t.IDBase {
|
|
return nil
|
|
}
|
|
if o.id1 != 0 {
|
|
return fmt.Errorf(`invalid SetPackage(%q) call: old package: got %q, want ""`,
|
|
pkg.Str(tm), o.id1.Str(tm))
|
|
}
|
|
o.id1 = pkg
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// MaxExprDepth is an advisory limit for an Expr's recursion depth.
|
|
const MaxExprDepth = 255
|
|
|
|
// Expr is an expression, such as "i", "+j" or "k + l[m(n, o)].p":
|
|
// - ID0: <0|operator|IDOpenParen|IDOpenBracket|IDDotDot|IDDot>
|
|
// - ID2: <0|literal|ident>
|
|
// - LHS: <nil|Expr>
|
|
// - MHS: <nil|Expr>
|
|
// - RHS: <nil|Expr|TypeExpr>
|
|
// - List0: <Arg|Expr> function call args, assoc. op args or list members.
|
|
//
|
|
// A zero ID0 means an identifier or literal in ID2, like `foo`, `42` or a
|
|
// status literal like `"#foo"`.
|
|
//
|
|
// For unary operators, ID0 is the operator and RHS is the operand.
|
|
//
|
|
// For binary operators, ID0 is the operator and LHS and RHS are the operands.
|
|
//
|
|
// For associative operators, ID0 is the operator and List0 holds the operands.
|
|
//
|
|
// The ID0 operator is in disambiguous form. For example, IDXUnaryPlus,
|
|
// IDXBinaryPlus or IDXAssociativePlus, not a bare IDPlus.
|
|
//
|
|
// For function calls, like "LHS(List0)", ID0 is IDOpenParen.
|
|
//
|
|
// For indexes, like "LHS[RHS]", ID0 is IDOpenBracket.
|
|
//
|
|
// For slices, like "LHS[MHS .. RHS]", ID0 is IDDotDot.
|
|
//
|
|
// For selectors, like "LHS.ID2", ID0 is IDDot.
|
|
//
|
|
// For lists, like "[0, 1, 2]", ID0 is IDComma.
|
|
type Expr Node
|
|
|
|
const (
|
|
ExprOperatorCall = t.IDOpenParen
|
|
ExprOperatorIndex = t.IDOpenBracket
|
|
ExprOperatorList = t.IDComma
|
|
ExprOperatorSelector = t.IDDot
|
|
ExprOperatorSlice = t.IDDotDot
|
|
)
|
|
|
|
func (n *Expr) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Expr) Effect() Effect { return Effect(n.flags) }
|
|
func (n *Expr) GlobalIdent() bool { return n.flags&FlagsGlobalIdent != 0 }
|
|
func (n *Expr) SubExprHasEffect() bool { return n.flags&FlagsSubExprHasEffect != 0 }
|
|
func (n *Expr) ConstValue() *big.Int { return n.constValue }
|
|
func (n *Expr) MBounds() interval.IntRange { return n.mBounds }
|
|
func (n *Expr) MType() *TypeExpr { return n.mType }
|
|
func (n *Expr) Operator() t.ID { return n.id0 }
|
|
func (n *Expr) Ident() t.ID { return n.id2 }
|
|
func (n *Expr) LHS() *Node { return n.lhs }
|
|
func (n *Expr) MHS() *Node { return n.mhs }
|
|
func (n *Expr) RHS() *Node { return n.rhs }
|
|
func (n *Expr) Args() []*Node { return n.list0 }
|
|
|
|
func (n *Expr) SetConstValue(x *big.Int) { n.constValue = x }
|
|
func (n *Expr) SetGlobalIdent() { n.flags |= FlagsGlobalIdent }
|
|
func (n *Expr) SetMBounds(x interval.IntRange) { n.mBounds = x }
|
|
func (n *Expr) SetMType(x *TypeExpr) { n.mType = x }
|
|
|
|
func (n *Expr) IsArgsDotFoo() (foo t.ID) {
|
|
if (n.id0 == t.IDDot) && (n.lhs.id0 == 0) && (n.lhs.id2 == t.IDArgs) {
|
|
return n.id2
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (n *Expr) IsThisDotFoo() (foo t.ID) {
|
|
if (n.id0 == t.IDDot) && (n.lhs.id0 == 0) && (n.lhs.id2 == t.IDThis) {
|
|
return n.id2
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (n *Expr) IsIndex() (arrayOrSlice *Expr, index *Expr, ok bool) {
|
|
if n.id0 == ExprOperatorIndex {
|
|
return n.lhs.AsExpr(), n.rhs.AsExpr(), true
|
|
}
|
|
return nil, nil, false
|
|
}
|
|
|
|
func (n *Expr) IsList() (args []*Node, ok bool) {
|
|
if n.id0 == ExprOperatorList {
|
|
return n.list0, true
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
func (n *Expr) IsMethodCall() (recv *Expr, meth t.ID, args []*Node, ok bool) {
|
|
if n.id0 == ExprOperatorCall {
|
|
if o := n.lhs; o.id0 == t.IDDot {
|
|
return o.lhs.AsExpr(), o.id2, n.list0, true
|
|
}
|
|
}
|
|
return nil, 0, nil, false
|
|
}
|
|
|
|
func (n *Expr) IsSelector() (lhs *Expr, field t.ID, ok bool) {
|
|
if n.id0 == ExprOperatorSelector {
|
|
return n.lhs.AsExpr(), n.id2, true
|
|
}
|
|
return nil, 0, false
|
|
}
|
|
|
|
func (n *Expr) IsSlice() (arrayOrSlice *Expr, lo *Expr, hi *Expr, ok bool) {
|
|
if n.id0 == ExprOperatorSlice {
|
|
return n.lhs.AsExpr(), n.mhs.AsExpr(), n.rhs.AsExpr(), true
|
|
}
|
|
return nil, nil, nil, false
|
|
}
|
|
|
|
func NewExpr(flags Flags, operator t.ID, ident t.ID, lhs *Node, mhs *Node, rhs *Node, args []*Node) *Expr {
|
|
subExprEffect := Flags(0)
|
|
if lhs != nil {
|
|
subExprEffect |= lhs.flags & Flags(effectMask)
|
|
}
|
|
if mhs != nil {
|
|
subExprEffect |= mhs.flags & Flags(effectMask)
|
|
}
|
|
if rhs != nil {
|
|
subExprEffect |= rhs.flags & Flags(effectMask)
|
|
}
|
|
for _, o := range args {
|
|
subExprEffect |= o.flags & Flags(effectMask)
|
|
}
|
|
if subExprEffect != 0 {
|
|
flags |= subExprEffect | FlagsSubExprHasEffect
|
|
}
|
|
|
|
return &Expr{
|
|
kind: KExpr,
|
|
flags: flags,
|
|
id0: operator,
|
|
id2: ident,
|
|
lhs: lhs,
|
|
mhs: mhs,
|
|
rhs: rhs,
|
|
list0: args,
|
|
}
|
|
}
|
|
|
|
// Assert is "assert RHS via ID2(args)", "choose etc", "pre etc", "inv etc" or
|
|
// "post etc":
|
|
// - ID0: <IDAssert|IDChoose|IDPre|IDInv|IDPost>
|
|
// - ID2: <"-string literal> reason
|
|
// - RHS: <Expr>
|
|
// - List0: <Arg> reason arguments
|
|
type Assert Node
|
|
|
|
func (n *Assert) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Assert) Keyword() t.ID { return n.id0 }
|
|
func (n *Assert) Reason() t.ID { return n.id2 }
|
|
func (n *Assert) Condition() *Expr { return n.rhs.AsExpr() }
|
|
func (n *Assert) Args() []*Node { return n.list0 }
|
|
|
|
func (n *Assert) DropExprCachedMBounds() error { return n.AsNode().Walk(dropExprCachedMBounds) }
|
|
|
|
func (n *Assert) IsChooseCPUArch() bool {
|
|
if n.id0 != t.IDChoose {
|
|
return false
|
|
}
|
|
cond := n.Condition()
|
|
if cond.Operator() != t.IDXBinaryGreaterEq {
|
|
return false
|
|
}
|
|
lhs := cond.LHS().AsExpr()
|
|
rhs := cond.RHS().AsExpr()
|
|
if (lhs.Operator() != 0) || (lhs.Ident() != t.IDCPUArch) || (rhs.Operator() != 0) {
|
|
return false
|
|
}
|
|
switch rhs.Ident() {
|
|
case t.IDARMCRC32, t.IDARMNeon, t.IDX86SSE42, t.IDX86AVX2, t.IDX86BMI2:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func NewAssert(keyword t.ID, condition *Expr, reason t.ID, args []*Node) *Assert {
|
|
return &Assert{
|
|
kind: KAssert,
|
|
id0: keyword,
|
|
id2: reason,
|
|
rhs: condition.AsNode(),
|
|
list0: args,
|
|
}
|
|
}
|
|
|
|
// Arg is "name:value".
|
|
// - ID2: <ident> name
|
|
// - RHS: <Expr> value
|
|
type Arg Node
|
|
|
|
func (n *Arg) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Arg) Name() t.ID { return n.id2 }
|
|
func (n *Arg) Value() *Expr { return n.rhs.AsExpr() }
|
|
|
|
func NewArg(name t.ID, value *Expr) *Arg {
|
|
return &Arg{
|
|
kind: KArg,
|
|
id2: name,
|
|
rhs: value.AsNode(),
|
|
}
|
|
}
|
|
|
|
// Assign is "LHS = RHS" or "LHS op= RHS" or "RHS":
|
|
// - ID0: operator
|
|
// - LHS: <nil|Expr>
|
|
// - RHS: <Expr>
|
|
type Assign Node
|
|
|
|
func (n *Assign) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Assign) Operator() t.ID { return n.id0 }
|
|
func (n *Assign) LHS() *Expr { return n.lhs.AsExpr() }
|
|
func (n *Assign) RHS() *Expr { return n.rhs.AsExpr() }
|
|
|
|
func NewAssign(operator t.ID, lhs *Expr, rhs *Expr) *Assign {
|
|
return &Assign{
|
|
kind: KAssign,
|
|
id0: operator,
|
|
lhs: lhs.AsNode(),
|
|
rhs: rhs.AsNode(),
|
|
}
|
|
}
|
|
|
|
// Var is "var ID2 LHS":
|
|
// - ID2: name
|
|
// - LHS: <TypeExpr>
|
|
type Var Node
|
|
|
|
func (n *Var) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Var) Filename() string { return n.filename }
|
|
func (n *Var) Line() uint32 { return n.line }
|
|
func (n *Var) Name() t.ID { return n.id2 }
|
|
func (n *Var) XType() *TypeExpr { return n.lhs.AsTypeExpr() }
|
|
|
|
func NewVar(name t.ID, xType *TypeExpr) *Var {
|
|
return &Var{
|
|
kind: KVar,
|
|
id2: name,
|
|
lhs: xType.AsNode(),
|
|
}
|
|
}
|
|
|
|
// Field is a "name : type" struct field:
|
|
// - FlagsPrivateData is the initializer need not explicitly memset to zero.
|
|
// - ID2: name
|
|
// - LHS: <TypeExpr>
|
|
type Field Node
|
|
|
|
func (n *Field) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Field) PrivateData() bool { return n.flags&FlagsPrivateData != 0 }
|
|
func (n *Field) Name() t.ID { return n.id2 }
|
|
func (n *Field) XType() *TypeExpr { return n.lhs.AsTypeExpr() }
|
|
|
|
func NewField(flags Flags, name t.ID, xType *TypeExpr) *Field {
|
|
return &Field{
|
|
kind: KField,
|
|
flags: flags,
|
|
id2: name,
|
|
lhs: xType.AsNode(),
|
|
}
|
|
}
|
|
|
|
// IOManip is "io_bind (io:LHS, data:MHS, history_position:RHS) { List2 }" or
|
|
// "io_limit (io:LHS, limit:MHS) { List2 }":
|
|
// - ID0: <IDIOBind|IDIOLimit>
|
|
// - LHS: <Expr>
|
|
// - MHS: <Expr>
|
|
// - RHS: <Expr>
|
|
// - List2: <Statement> body
|
|
type IOManip Node
|
|
|
|
func (n *IOManip) AsNode() *Node { return (*Node)(n) }
|
|
func (n *IOManip) Keyword() t.ID { return n.id0 }
|
|
func (n *IOManip) IO() *Expr { return n.lhs.AsExpr() }
|
|
func (n *IOManip) Arg1() *Expr { return n.mhs.AsExpr() }
|
|
func (n *IOManip) HistoryPosition() *Expr { return n.rhs.AsExpr() }
|
|
func (n *IOManip) Body() []*Node { return n.list2 }
|
|
|
|
func NewIOManip(keyword t.ID, io *Expr, arg1 *Expr, historyPosition *Expr, body []*Node) *IOManip {
|
|
return &IOManip{
|
|
kind: KIOManip,
|
|
id0: keyword,
|
|
lhs: io.AsNode(),
|
|
mhs: arg1.AsNode(),
|
|
rhs: historyPosition.AsNode(),
|
|
list2: body,
|
|
}
|
|
}
|
|
|
|
// Iterate is
|
|
// "iterate.ID1 (assigns)(length:ID2, advance:ID0, unroll:LHS), List1 { List2 } else RHS":
|
|
// - FlagsHasBreak is the iterate has an explicit break
|
|
// - FlagsHasContinue is the iterate has an explicit continue
|
|
// - ID0: advance
|
|
// - ID1: <0|label>
|
|
// - ID2: length
|
|
// - LHS: <Expr> unroll
|
|
// - RHS: <nil|Iterate>
|
|
// - List0: <Assign> assigns
|
|
// - List1: <Assert> asserts
|
|
// - List2: <Statement> body
|
|
type Iterate Node
|
|
|
|
func (n *Iterate) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Iterate) HasBreak() bool { return n.flags&FlagsHasBreak != 0 }
|
|
func (n *Iterate) HasContinue() bool { return n.flags&FlagsHasContinue != 0 }
|
|
func (n *Iterate) HasDeepBreak() bool { return n.flags&FlagsHasDeepBreak != 0 }
|
|
func (n *Iterate) HasDeepContinue() bool { return n.flags&FlagsHasDeepContinue != 0 }
|
|
func (n *Iterate) Keyword() t.ID { return t.IDIterate }
|
|
func (n *Iterate) Advance() t.ID { return n.id0 }
|
|
func (n *Iterate) Label() t.ID { return n.id1 }
|
|
func (n *Iterate) Length() t.ID { return n.id2 }
|
|
func (n *Iterate) Unroll() t.ID { return n.lhs.id2 }
|
|
func (n *Iterate) UnrollAsExpr() *Expr { return n.lhs.AsExpr() }
|
|
func (n *Iterate) ElseIterate() *Iterate { return n.rhs.AsIterate() }
|
|
func (n *Iterate) Assigns() []*Node { return n.list0 }
|
|
func (n *Iterate) Asserts() []*Node { return n.list1 }
|
|
func (n *Iterate) Body() []*Node { return n.list2 }
|
|
|
|
func (n *Iterate) SetBody(body []*Node) { n.list2 = body }
|
|
func (n *Iterate) SetElseIterate(o *Iterate) { n.rhs = o.AsNode() }
|
|
func (n *Iterate) SetHasBreak(deep bool) { n.flags |= breakFlags(deep) }
|
|
func (n *Iterate) SetHasContinue(deep bool) { n.flags |= continueFlags(deep) }
|
|
|
|
func NewIterate(label t.ID, assigns []*Node, length t.ID, advance t.ID, unroll t.ID, asserts []*Node) *Iterate {
|
|
return &Iterate{
|
|
kind: KIterate,
|
|
id0: advance,
|
|
id1: label,
|
|
id2: length,
|
|
lhs: NewExpr(0, 0, unroll, nil, nil, nil, nil).AsNode(),
|
|
list0: assigns,
|
|
list1: asserts,
|
|
}
|
|
}
|
|
|
|
// While is "while.ID1 MHS, List1 { List2 } endwhile.ID1":
|
|
// - FlagsHasBreak is the while has an explicit break
|
|
// - FlagsHasContinue is the while has an explicit continue
|
|
// - ID1: <0|label>
|
|
// - MHS: <Expr>
|
|
// - List1: <Assert> asserts
|
|
// - List2: <Statement> body
|
|
//
|
|
// TODO: should we be able to unroll while loops too?
|
|
type While Node
|
|
|
|
func (n *While) AsNode() *Node { return (*Node)(n) }
|
|
func (n *While) HasBreak() bool { return n.flags&FlagsHasBreak != 0 }
|
|
func (n *While) HasContinue() bool { return n.flags&FlagsHasContinue != 0 }
|
|
func (n *While) HasDeepBreak() bool { return n.flags&FlagsHasDeepBreak != 0 }
|
|
func (n *While) HasDeepContinue() bool { return n.flags&FlagsHasDeepContinue != 0 }
|
|
func (n *While) Keyword() t.ID { return t.IDWhile }
|
|
func (n *While) Label() t.ID { return n.id1 }
|
|
func (n *While) Condition() *Expr { return n.mhs.AsExpr() }
|
|
func (n *While) Asserts() []*Node { return n.list1 }
|
|
func (n *While) Body() []*Node { return n.list2 }
|
|
|
|
func (n *While) SetBody(body []*Node) { n.list2 = body }
|
|
func (n *While) SetHasBreak(deep bool) { n.flags |= breakFlags(deep) }
|
|
func (n *While) SetHasContinue(deep bool) { n.flags |= continueFlags(deep) }
|
|
|
|
func (n *While) IsWhileTrue() bool {
|
|
condition := n.mhs.AsExpr()
|
|
return (condition.Operator() == 0) && (condition.Ident() == t.IDTrue)
|
|
}
|
|
|
|
func NewWhile(label t.ID, condition *Expr, asserts []*Node) *While {
|
|
return &While{
|
|
kind: KWhile,
|
|
id1: label,
|
|
mhs: condition.AsNode(),
|
|
list1: asserts,
|
|
}
|
|
}
|
|
|
|
// If is "if MHS { List2 } else RHS" or "if MHS { List2 } else { List1 }":
|
|
// - MHS: <Expr>
|
|
// - RHS: <nil|If>
|
|
// - List1: <Statement> if-false body
|
|
// - List2: <Statement> if-true body
|
|
type If Node
|
|
|
|
func (n *If) AsNode() *Node { return (*Node)(n) }
|
|
func (n *If) Likelihood() t.ID { return n.id1 }
|
|
func (n *If) Condition() *Expr { return n.mhs.AsExpr() }
|
|
func (n *If) ElseIf() *If { return n.rhs.AsIf() }
|
|
func (n *If) BodyIfTrue() []*Node { return n.list2 }
|
|
func (n *If) BodyIfFalse() []*Node { return n.list1 }
|
|
|
|
func NewIf(likelihood t.ID, condition *Expr, bodyIfTrue []*Node, bodyIfFalse []*Node, elseIf *If) *If {
|
|
return &If{
|
|
kind: KIf,
|
|
id1: likelihood,
|
|
mhs: condition.AsNode(),
|
|
rhs: elseIf.AsNode(),
|
|
list1: bodyIfFalse,
|
|
list2: bodyIfTrue,
|
|
}
|
|
}
|
|
|
|
// Choose is "choose ID2: List0":
|
|
// - ID2: name
|
|
// - List0: <Expr> method names.
|
|
type Choose Node
|
|
|
|
func (n *Choose) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Choose) Name() t.ID { return n.id2 }
|
|
func (n *Choose) Args() []*Node { return n.list0 }
|
|
|
|
func NewChoose(name t.ID, args []*Node) *Choose {
|
|
return &Choose{
|
|
kind: KChoose,
|
|
id2: name,
|
|
list0: args,
|
|
}
|
|
}
|
|
|
|
// Ret is "return LHS" or "yield LHS":
|
|
// - FlagsReturnsError LHS is an error status
|
|
// - ID0: <IDReturn|IDYield>
|
|
// - LHS: <Expr>
|
|
type Ret Node
|
|
|
|
func (n *Ret) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Ret) RetsError() bool { return n.flags&FlagsRetsError != 0 }
|
|
func (n *Ret) Keyword() t.ID { return n.id0 }
|
|
func (n *Ret) Value() *Expr { return n.lhs.AsExpr() }
|
|
|
|
func (n *Ret) SetRetsError() { n.flags |= FlagsRetsError }
|
|
|
|
func NewRet(keyword t.ID, value *Expr) *Ret {
|
|
return &Ret{
|
|
kind: KRet,
|
|
id0: keyword,
|
|
lhs: value.AsNode(),
|
|
}
|
|
}
|
|
|
|
// Jump is "break" or "continue", with an optional label, "break.label":
|
|
// - ID0: <IDBreak|IDContinue>
|
|
// - ID1: <0|label>
|
|
type Jump Node
|
|
|
|
func (n *Jump) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Jump) JumpTarget() Loop { return n.jumpTarget }
|
|
func (n *Jump) Keyword() t.ID { return n.id0 }
|
|
func (n *Jump) Label() t.ID { return n.id1 }
|
|
|
|
func (n *Jump) SetJumpTarget(o Loop) { n.jumpTarget = o }
|
|
|
|
func NewJump(keyword t.ID, label t.ID) *Jump {
|
|
return &Jump{
|
|
kind: KJump,
|
|
id0: keyword,
|
|
id1: label,
|
|
}
|
|
}
|
|
|
|
// MaxTypeExprDepth is an advisory limit for a TypeExpr's recursion depth.
|
|
const MaxTypeExprDepth = 63
|
|
|
|
// TypeExpr is a type expression, such as "base.u32", "base.u32[..= 8]", "foo",
|
|
// "pkg.bar", "ptr T", "array[8] T", "slice T" or "table T":
|
|
// - ID0: <0|IDArray|IDFunc|IDNptr|IDPtr|IDRoarray|IDRoslice|IDRotable|
|
|
// .... IDSlice|IDTable>
|
|
// - ID1: <0|pkg>
|
|
// - ID2: <0|type name>
|
|
// - LHS: <nil|Expr>
|
|
// - MHS: <nil|Expr>
|
|
// - RHS: <nil|TypeExpr>
|
|
//
|
|
// An IDNptr or IDPtr ID0 means "nptr RHS" or "ptr RHS". RHS is the inner type.
|
|
//
|
|
// An IDArray ID0 means "array[LHS] RHS". RHS is the inner type.
|
|
//
|
|
// An IDSlice ID0 means "slice RHS". RHS is the inner type.
|
|
//
|
|
// An IDTable ID0 means "table RHS". RHS is the inner type.
|
|
//
|
|
// An IDFunc ID0 means "func ID2" or "func (LHS).ID2", a function or method
|
|
// type. LHS is the receiver type, which may be nil. If non-nil, it will be a
|
|
// pointee type: "T" instead of "ptr T", "ptr ptr T", etc.
|
|
//
|
|
// TODO: method effects: "foo" vs "foo!" vs "foo?".
|
|
//
|
|
// A zero ID0 means a (possibly package-qualified) type like "pkg.foo" or
|
|
// "foo". ID1 is the "pkg" or zero, ID2 is the "foo".
|
|
//
|
|
// Numeric types can be refined as "foo[LHS ..= MHS]". LHS and MHS are Expr's,
|
|
// possibly nil. For example, the LHS for "base.u32[..= 4095]" is nil.
|
|
//
|
|
// TODO: struct types, list types, nptr vs ptr.
|
|
type TypeExpr Node
|
|
|
|
func (n *TypeExpr) AsNode() *Node { return (*Node)(n) }
|
|
func (n *TypeExpr) Decorator() t.ID { return n.id0 }
|
|
func (n *TypeExpr) QID() t.QID { return t.QID{n.id1, n.id2} }
|
|
func (n *TypeExpr) FuncName() t.ID { return n.id2 }
|
|
func (n *TypeExpr) ArrayLength() *Expr { return n.lhs.AsExpr() }
|
|
func (n *TypeExpr) Receiver() *TypeExpr { return n.lhs.AsTypeExpr() }
|
|
func (n *TypeExpr) Bounds() [2]*Expr { return [2]*Expr{n.lhs.AsExpr(), n.mhs.AsExpr()} }
|
|
func (n *TypeExpr) Min() *Expr { return n.lhs.AsExpr() }
|
|
func (n *TypeExpr) Max() *Expr { return n.mhs.AsExpr() }
|
|
func (n *TypeExpr) Inner() *TypeExpr { return n.rhs.AsTypeExpr() }
|
|
|
|
func (n *TypeExpr) CloneReadOnly() *TypeExpr {
|
|
ret := *n
|
|
switch ret.id0 {
|
|
case t.IDArray:
|
|
ret.id0 = t.IDRoarray
|
|
case t.IDSlice:
|
|
ret.id0 = t.IDRoslice
|
|
case t.IDTable:
|
|
ret.id0 = t.IDRotable
|
|
}
|
|
if ret.rhs != nil {
|
|
ret.rhs = ret.rhs.AsTypeExpr().CloneReadOnly().AsNode()
|
|
}
|
|
return &ret
|
|
}
|
|
|
|
func (n *TypeExpr) Innermost() *TypeExpr {
|
|
for ; n != nil && n.Inner() != nil; n = n.Inner() {
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (n *TypeExpr) Pointee() *TypeExpr {
|
|
for ; n != nil && (n.id0 == t.IDNptr || n.id0 == t.IDPtr); n = n.Inner() {
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (n *TypeExpr) BulkSize() *big.Int {
|
|
if !n.IsBulkNumType() {
|
|
return nil
|
|
}
|
|
ret := big.NewInt(1)
|
|
for ; n.id0 == t.IDArray; n = n.rhs.AsTypeExpr() {
|
|
ret = ret.Mul(ret, n.ArrayLength().ConstValue())
|
|
}
|
|
switch n.id2 {
|
|
case t.IDU8:
|
|
return ret
|
|
case t.IDU16:
|
|
return ret.Lsh(ret, 1)
|
|
case t.IDU32:
|
|
return ret.Lsh(ret, 2)
|
|
case t.IDU64:
|
|
return ret.Lsh(ret, 3)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (n *TypeExpr) IsBulkNumType() bool {
|
|
for ; (n.id0 == t.IDArray) || (n.id0 == t.IDRoarray); n = n.rhs.AsTypeExpr() {
|
|
}
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsNumType()
|
|
}
|
|
|
|
func (n *TypeExpr) IsBool() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2 == t.IDBool
|
|
}
|
|
|
|
func (n *TypeExpr) IsCPUArchType() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsBuiltInCPUArch()
|
|
}
|
|
|
|
func (n *TypeExpr) IsEmptyStruct() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2 == t.IDEmptyStruct
|
|
}
|
|
|
|
func (n *TypeExpr) IsEtcUtilityType() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsEtcUtility()
|
|
}
|
|
|
|
func (n *TypeExpr) IsIdeal() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2 == t.IDQIdeal
|
|
}
|
|
|
|
func (n *TypeExpr) IsIOType() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase &&
|
|
(n.id2 == t.IDIOReader || n.id2 == t.IDIOWriter)
|
|
}
|
|
|
|
func (n *TypeExpr) IsTokenType() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase &&
|
|
(n.id2 == t.IDTokenReader || n.id2 == t.IDTokenWriter)
|
|
}
|
|
|
|
func (n *TypeExpr) IsIOTokenType() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase &&
|
|
(n.id2 == t.IDIOReader || n.id2 == t.IDIOWriter ||
|
|
n.id2 == t.IDTokenReader || n.id2 == t.IDTokenWriter)
|
|
}
|
|
|
|
func (n *TypeExpr) IsNullptr() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2 == t.IDQNullptr
|
|
}
|
|
|
|
func (n *TypeExpr) IsNumType() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsNumType()
|
|
}
|
|
|
|
func (n *TypeExpr) IsNumTypeOrIdeal() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsNumTypeOrIdeal()
|
|
}
|
|
|
|
func (n *TypeExpr) IsRangeType() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsRangeType()
|
|
}
|
|
|
|
func (n *TypeExpr) IsRectType() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsRectType()
|
|
}
|
|
|
|
func (n *TypeExpr) IsRefined() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsNumType() && (n.lhs != nil || n.mhs != nil)
|
|
}
|
|
|
|
func (n *TypeExpr) IsStatus() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase && n.id2 == t.IDStatus
|
|
}
|
|
|
|
func (n *TypeExpr) IsEitherArrayType() bool {
|
|
return (n.id0 == t.IDArray) || (n.id0 == t.IDRoarray)
|
|
}
|
|
|
|
func (n *TypeExpr) IsEitherSliceType() bool {
|
|
return (n.id0 == t.IDSlice) || (n.id0 == t.IDRoslice)
|
|
}
|
|
|
|
func (n *TypeExpr) IsEitherTableType() bool {
|
|
return (n.id0 == t.IDTable) || (n.id0 == t.IDRotable)
|
|
}
|
|
|
|
func (n *TypeExpr) IsFuncType() bool {
|
|
return n.id0 == t.IDFunc
|
|
}
|
|
|
|
func (n *TypeExpr) IsPointerType() bool {
|
|
return n.id0 == t.IDNptr || n.id0 == t.IDPtr
|
|
}
|
|
|
|
func (n *TypeExpr) IsReadOnly() bool {
|
|
return (n.id0 == t.IDRoarray) || (n.id0 == t.IDRoslice) || (n.id0 == t.IDRotable)
|
|
}
|
|
|
|
func (n *TypeExpr) IsRecursivelyReadOnly() bool {
|
|
for ; n != nil; n = n.Inner() {
|
|
switch n.id0 {
|
|
case t.IDRoarray, t.IDRoslice, t.IDRotable:
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (n *TypeExpr) IsContainerOfSpecificNumType(container t.ID, numType t.ID) bool {
|
|
return (n.id0 == container) && n.Inner().IsNumType() && (n.Inner().id2 == numType)
|
|
}
|
|
|
|
func (n *TypeExpr) IsUnsignedInteger() bool {
|
|
return n.id0 == 0 && n.id1 == t.IDBase &&
|
|
(n.id2 == t.IDU8 || n.id2 == t.IDU16 || n.id2 == t.IDU32 || n.id2 == t.IDU64)
|
|
}
|
|
|
|
func (n *TypeExpr) HasPointers() bool {
|
|
for ; n != nil; n = n.Inner() {
|
|
switch n.id0 {
|
|
case 0:
|
|
if n.id1 == t.IDBase {
|
|
switch n.id2 {
|
|
case t.IDIOReader, t.IDIOWriter:
|
|
return true
|
|
}
|
|
}
|
|
case t.IDNptr, t.IDPtr, t.IDRoslice, t.IDRotable, t.IDSlice, t.IDTable:
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (n *TypeExpr) Unrefined() *TypeExpr {
|
|
if !n.IsRefined() {
|
|
return n
|
|
}
|
|
return &TypeExpr{
|
|
kind: KTypeExpr,
|
|
id1: n.id1,
|
|
id2: n.id2,
|
|
}
|
|
}
|
|
|
|
func NewTypeExpr(decorator t.ID, pkg t.ID, name t.ID, alenRecvMin *Node, max *Expr, inner *TypeExpr) *TypeExpr {
|
|
return &TypeExpr{
|
|
kind: KTypeExpr,
|
|
id0: decorator,
|
|
id1: pkg,
|
|
id2: name,
|
|
lhs: alenRecvMin,
|
|
mhs: max.AsNode(),
|
|
rhs: inner.AsNode(),
|
|
}
|
|
}
|
|
|
|
// MaxBodyDepth is an advisory limit for a function body's recursion depth.
|
|
const MaxBodyDepth = 255
|
|
|
|
// Func is "func ID2.ID0(LHS)(RHS) { List2 }":
|
|
// - FlagsPublic is "pub" vs "pri"
|
|
// - ID0: funcName
|
|
// - ID1: <0|receiverPkg> (set by calling SetPackage)
|
|
// - ID2: <0|receiverName>
|
|
// - LHS: <Struct> in-parameters
|
|
// - RHS: <Struct> out-parameters
|
|
// - List1: <Assert> asserts
|
|
// - List2: <Statement> body
|
|
type Func Node
|
|
|
|
func (n *Func) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Func) Choosy() bool { return n.flags&FlagsChoosy != 0 }
|
|
func (n *Func) Effect() Effect { return Effect(n.flags) }
|
|
func (n *Func) HasChooseCPUArch() bool { return n.flags&FlagsHasChooseCPUArch != 0 }
|
|
func (n *Func) Public() bool { return n.flags&FlagsPublic != 0 }
|
|
func (n *Func) Filename() string { return n.filename }
|
|
func (n *Func) Line() uint32 { return n.line }
|
|
func (n *Func) QQID() t.QQID { return t.QQID{n.id1, n.id2, n.id0} }
|
|
func (n *Func) Receiver() t.QID { return t.QID{n.id1, n.id2} }
|
|
func (n *Func) FuncName() t.ID { return n.id0 }
|
|
func (n *Func) In() *Struct { return n.lhs.AsStruct() }
|
|
func (n *Func) Out() *TypeExpr { return n.rhs.AsTypeExpr() }
|
|
func (n *Func) Asserts() []*Node { return n.list1 }
|
|
func (n *Func) Body() []*Node { return n.list2 }
|
|
|
|
func (n *Func) BodyEndsWithReturn() bool {
|
|
if len(n.list2) == 0 {
|
|
return false
|
|
}
|
|
end := n.list2[len(n.list2)-1]
|
|
return (end.kind == KRet) && (end.AsRet().Keyword() == t.IDReturn)
|
|
}
|
|
|
|
func fieldsEq(xs []*Node, ys []*Node) bool {
|
|
if len(xs) != len(ys) {
|
|
return false
|
|
}
|
|
for i := range xs {
|
|
x, y := xs[i].AsField(), ys[i].AsField()
|
|
if (x.Name() != y.Name()) || !x.XType().Eq(y.XType()) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (n *Func) CheckChooseCompatible(o *Func) error {
|
|
if n.Effect() != o.Effect() {
|
|
return fmt.Errorf("different effects")
|
|
}
|
|
if !fieldsEq(n.In().Fields(), o.In().Fields()) {
|
|
return fmt.Errorf("different args type")
|
|
}
|
|
if !n.Out().Eq(o.Out()) {
|
|
return fmt.Errorf("different return type")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewFunc(flags Flags, filename string, line uint32, receiverName t.ID, funcName t.ID, in *Struct, out *TypeExpr, asserts []*Node, body []*Node) *Func {
|
|
return &Func{
|
|
kind: KFunc,
|
|
flags: flags,
|
|
filename: filename,
|
|
line: line,
|
|
id0: funcName,
|
|
id2: receiverName,
|
|
lhs: in.AsNode(),
|
|
rhs: out.AsNode(),
|
|
list1: asserts,
|
|
list2: body,
|
|
}
|
|
}
|
|
|
|
// Status is "error (RHS) ID2" or "suspension (RHS) ID2":
|
|
// - FlagsPublic is "pub" vs "pri"
|
|
// - ID1: <0|pkg> (set by calling SetPackage)
|
|
// - ID2: message
|
|
type Status Node
|
|
|
|
func (n *Status) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Status) Public() bool { return n.flags&FlagsPublic != 0 }
|
|
func (n *Status) Filename() string { return n.filename }
|
|
func (n *Status) Line() uint32 { return n.line }
|
|
func (n *Status) QID() t.QID { return t.QID{n.id1, n.id2} }
|
|
|
|
func NewStatus(flags Flags, filename string, line uint32, message t.ID) *Status {
|
|
return &Status{
|
|
kind: KStatus,
|
|
flags: flags,
|
|
filename: filename,
|
|
line: line,
|
|
id2: message,
|
|
}
|
|
}
|
|
|
|
// Const is "const ID2 LHS = RHS":
|
|
// - FlagsPublic is "pub" vs "pri"
|
|
// - ID1: <0|pkg> (set by calling SetPackage)
|
|
// - ID2: name
|
|
// - LHS: <TypeExpr>
|
|
// - RHS: <Expr>
|
|
type Const Node
|
|
|
|
func (n *Const) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Const) Public() bool { return n.flags&FlagsPublic != 0 }
|
|
func (n *Const) Filename() string { return n.filename }
|
|
func (n *Const) Line() uint32 { return n.line }
|
|
func (n *Const) QID() t.QID { return t.QID{n.id1, n.id2} }
|
|
func (n *Const) XType() *TypeExpr { return n.lhs.AsTypeExpr() }
|
|
func (n *Const) Value() *Expr { return n.rhs.AsExpr() }
|
|
|
|
func NewConst(flags Flags, filename string, line uint32, name t.ID, xType *TypeExpr, value *Expr) *Const {
|
|
return &Const{
|
|
kind: KConst,
|
|
flags: flags,
|
|
filename: filename,
|
|
line: line,
|
|
id2: name,
|
|
lhs: xType.AsNode(),
|
|
rhs: value.AsNode(),
|
|
}
|
|
}
|
|
|
|
// MaxImplements is an advisory limit for the number of interfaces a Struct can
|
|
// implement.
|
|
const MaxImplements = 63
|
|
|
|
// Struct is "struct ID2? implements List0 (List1)":
|
|
// - FlagsPublic is "pub" vs "pri"
|
|
// - FlagsClassy is "ID2" vs "ID2?"
|
|
// - ID1: <0|pkg> (set by calling SetPackage)
|
|
// - ID2: name
|
|
// - List0: <TypeExpr> implements
|
|
// - List1: <Field> fields
|
|
//
|
|
// The question mark indicates a classy struct - one that supports methods,
|
|
// especially coroutines.
|
|
type Struct Node
|
|
|
|
func (n *Struct) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Struct) Classy() bool { return n.flags&FlagsClassy != 0 }
|
|
func (n *Struct) Public() bool { return n.flags&FlagsPublic != 0 }
|
|
func (n *Struct) Filename() string { return n.filename }
|
|
func (n *Struct) Line() uint32 { return n.line }
|
|
func (n *Struct) QID() t.QID { return t.QID{n.id1, n.id2} }
|
|
func (n *Struct) Implements() []*Node { return n.list0 }
|
|
func (n *Struct) Fields() []*Node { return n.list1 }
|
|
|
|
func NewStruct(flags Flags, filename string, line uint32, name t.ID, implements []*Node, fields []*Node) *Struct {
|
|
return &Struct{
|
|
kind: KStruct,
|
|
flags: flags,
|
|
filename: filename,
|
|
line: line,
|
|
id2: name,
|
|
list0: implements,
|
|
list1: fields,
|
|
}
|
|
}
|
|
|
|
// Use is "use ID2":
|
|
// - ID2: <"-string literal> package path
|
|
type Use Node
|
|
|
|
func (n *Use) AsNode() *Node { return (*Node)(n) }
|
|
func (n *Use) Filename() string { return n.filename }
|
|
func (n *Use) Line() uint32 { return n.line }
|
|
func (n *Use) Path() t.ID { return n.id2 }
|
|
|
|
func NewUse(filename string, line uint32, path t.ID) *Use {
|
|
return &Use{
|
|
kind: KUse,
|
|
filename: filename,
|
|
line: line,
|
|
id2: path,
|
|
}
|
|
}
|
|
|
|
// File is a file of source code:
|
|
// - List0: <Const|Func|Status|Struct|Use> top-level declarations
|
|
type File Node
|
|
|
|
func (n *File) AsNode() *Node { return (*Node)(n) }
|
|
func (n *File) Filename() string { return n.filename }
|
|
func (n *File) TopLevelDecls() []*Node { return n.list0 }
|
|
|
|
func NewFile(filename string, topLevelDecls []*Node) *File {
|
|
return &File{
|
|
kind: KFile,
|
|
filename: filename,
|
|
list0: topLevelDecls,
|
|
}
|
|
}
|
|
|
|
// Statement means one of:
|
|
// - Assert
|
|
// - Assign
|
|
// - Choose
|
|
// - IOManip
|
|
// - If
|
|
// - Iterate
|
|
// - Jump
|
|
// - Ret
|
|
// - Var
|
|
// - While
|
|
|
|
// Terminates returns whether a block of statements terminates. In other words,
|
|
// whether the block is non-empty and its final statement is a "return",
|
|
// "break", "continue", a "while true" that doesn't break or an "if-else" chain
|
|
// where all branches terminate.
|
|
func Terminates(body []*Node) bool {
|
|
if len(body) == 0 {
|
|
return false
|
|
}
|
|
n := body[len(body)-1]
|
|
switch n.Kind() {
|
|
case KIf:
|
|
n := n.AsIf()
|
|
for {
|
|
if !Terminates(n.BodyIfTrue()) {
|
|
return false
|
|
}
|
|
bif := n.BodyIfFalse()
|
|
if len(bif) > 0 && !Terminates(bif) {
|
|
return false
|
|
}
|
|
n = n.ElseIf()
|
|
if n == nil {
|
|
return len(bif) > 0
|
|
}
|
|
}
|
|
case KJump:
|
|
return true
|
|
case KRet:
|
|
return n.AsRet().Keyword() == t.IDReturn
|
|
case KWhile:
|
|
n := n.AsWhile()
|
|
return n.IsWhileTrue() && !n.HasBreak()
|
|
}
|
|
return false
|
|
}
|