ast

type ArrayType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	EndLoc               Loc
	ElementType          Type
	Length               Expr
	LengthValue          *uint64
	IsBytes              bool
}

type Assert struct {
	Loc         Loc
	Cond        *Binary
	IsIoRelated bool
}

type AstFile struct {
	Success bool      `json:"success"`
	Files   []string  `json:"files"`
	Ast     *JsonAst  `json:"ast"`
	Error   *SrcError `json:"error"`
}

type Available struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Base          *Call
	Target        Expr
}

type BadExpr struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Content       string
	BadExpr       Expr
}

type Binary struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Op            BinaryOp
	Left          Expr
	Right         Expr
}

type BinaryOp int

type BitAlignment int

type BlockTrait int

type BoolLiteral struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Value         bool
}

type BoolType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
}

type Break struct {
	Loc         Loc
	RelatedLoop *Loop
}

type Call struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Callee        Expr
	RawArguments  Expr
	Arguments     []Expr
	EndLoc        Loc
}

type Cast struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Base          *Call
	Arguments     []Expr
}

type CharLiteral struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Value         string
	Code          uint64
}

type Comment struct {
	Loc     Loc
	Comment string
}

type CommentGroup struct {
	Loc      Loc
	Comments []*Comment
}

type Cond struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Cond          Expr
	Then          Expr
	ElsLoc        Loc
	Els           Expr
}

type ConstantLevel int

type Continue struct {
	Loc         Loc
	RelatedLoop *Loop
}

type Endian int

type Enum struct {
	Loc          Loc
	Belong       Member
	BelongStruct *StructType
	Ident        *Ident
	Scope        *Scope
	ColonLoc     Loc
	BaseType     Type
	Members      []*EnumMember
	EnumType     *EnumType
}

type EnumMember struct {
	Loc          Loc
	Belong       Member
	BelongStruct *StructType
	Ident        *Ident
	RawExpr      Expr
	Value        Expr
	StrLiteral   *StrLiteral
}

type EnumType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	Base                 *Enum
}

type ExplicitError struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Base          *Call
	Message       *StrLiteral
}

type Expr interface {
	Node
	GetExprType() Type
	GetConstantLevel() ConstantLevel
	// contains filtered or unexported methods
}

type Field struct {
	Loc                  Loc
	Belong               Member
	BelongStruct         *StructType
	Ident                *Ident
	ColonLoc             Loc
	IsStateVariable      bool
	FieldType            Type
	Arguments            *FieldArgument
	OffsetBit            *uint64
	OffsetRecent         uint64
	TailOffsetBit        *uint64
	TailOffsetRecent     uint64
	BitAlignment         BitAlignment
	EventualBitAlignment BitAlignment
	Follow               Follow
	EventualFollow       Follow
	Next                 *Field
}

type FieldArgument struct {
	Loc                Loc
	RawArguments       Expr
	EndLoc             Loc
	CollectedArguments []Expr
	Arguments          []Expr
	Assigns            []*Binary
	Alignment          Expr
	AlignmentValue     *uint64
	SubByteLength      Expr
	SubByteBegin       Expr
	Peek               Expr
	PeekValue          *uint64
	TypeMap            *TypeLiteral
	Metadata           []*Metadata
	ArgumentMapping    FieldArgumentMapping
}

type FieldArgumentMapping int

type FloatType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	Endian               Endian
	IsCommonSupported    bool
}

type Follow int

type Format struct {
	Loc            Loc
	Belong         Member
	BelongStruct   *StructType
	Ident          *Ident
	Body           *IndentBlock
	EncodeFn       *Function
	DecodeFn       *Function
	CastFns        []*Function
	Depends        []*IdentType
	StateVariables []*Field
}

type Function struct {
	Loc          Loc
	Belong       Member
	BelongStruct *StructType
	Ident        *Ident
	Parameters   []*Field
	ReturnType   Type
	Body         *IndentBlock
	FuncType     *FunctionType
	IsCast       bool
}

type FunctionType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	ReturnType           Type
	Parameters           []Type
}

type GenerateMapFile struct {
	Structs []string  `json:"structs"`
	LineMap []LineMap `json:"line_map"`
}

type GenericType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	Belong               Member
}

type Ident struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Ident         string
	Usage         IdentUsage
	Base          Node
	Scope         *Scope
}

type IdentType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	ImportRef            *MemberAccess
	Ident                *Ident
	Base                 Type
}

type IdentUsage int

type Identity struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Expr          Expr
}

type If struct {
	Loc             Loc
	ExprType        Type
	ConstantLevel   ConstantLevel
	StructUnionType *StructUnionType
	CondScope       *Scope
	Cond            *Identity
	Then            *IndentBlock
	Els             Node
}

type ImplicitYield struct {
	Loc  Loc
	Expr Expr
}

type Import struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Path          string
	Base          *Call
	ImportDesc    *Program
}

type IndentBlock struct {
	Loc         Loc
	StructType  *StructType
	Elements    []Node
	Scope       *Scope
	Metadata    []*Metadata
	BlockTraits BlockTrait
}

type Index struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Expr          Expr
	Index         Expr
	EndLoc        Loc
}

type IntLiteral struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Value         string
}

type IntLiteralType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	Base                 *IntLiteral
}

type IntType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	Endian               Endian
	IsSigned             bool
	IsCommonSupported    bool
}

type IoMethod int

type IoOperation struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Base          Expr
	Method        IoMethod
	Arguments     []Expr
}

type JsonAst struct {
	Node  []RawNode  `json:"node"`
	Scope []RawScope `json:"scope"`
}

type LineMap struct {
	Line uint64 `json:"line"`
	Loc  Loc    `json:"loc"`
}

type Literal interface {
	Expr
	// contains filtered or unexported methods
}

type Loc struct {
	Pos  Pos    `json:"pos"`
	File uint64 `json:"file"`
	Line uint64 `json:"line"`
	Col  uint64 `json:"col"`
}

type Loop struct {
	Loc       Loc
	CondScope *Scope
	Init      Expr
	Cond      Expr
	Step      Expr
	Body      *IndentBlock
}

type Match struct {
	Loc             Loc
	ExprType        Type
	ConstantLevel   ConstantLevel
	StructUnionType *StructUnionType
	CondScope       *Scope
	Cond            *Identity
	Branch          []*MatchBranch
	TrialMatch      bool
}

type MatchBranch struct {
	Loc    Loc
	Belong *Match
	Cond   *Identity
	SymLoc Loc
	Then   Node
}

type Member interface {
	Stmt
	GetBelong() Member
	GetBelongStruct() *StructType
	GetIdent() *Ident
	// contains filtered or unexported methods
}

type MemberAccess struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Target        Expr
	Member        *Ident
	Base          *Ident
}

type MetaType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
}

type Metadata struct {
	Loc    Loc
	Base   Expr
	Name   string
	Values []Expr
}

type Node interface {
	GetLoc() Loc
	GetNodeType() NodeType
	// contains filtered or unexported methods
}

type NodeType int

type OptionalType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	BaseType             Type
}

type OrCond struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Base          *Binary
	Conds         []Expr
}

type OrderType int

type Paren struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Expr          Expr
	EndLoc        Loc
}

type Pos struct {
	Begin uint64 `json:"begin"`
	End   uint64 `json:"end"`
}

type Program struct {
	Loc         Loc
	StructType  *StructType
	Elements    []Node
	GlobalScope *Scope
	Metadata    []*Metadata
	Endian      *SpecifyOrder
}

type Range struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Op            BinaryOp
	Start         Expr
	End           Expr
}

type RangeType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	BaseType             Type
	Range                *Range
}

type RawNode struct {
	NodeType NodeType        `json:"node_type"`
	Loc      Loc             `json:"loc"`
	Body     json.RawMessage `json:"body"`
}

type RawScope struct {
	Prev       *uintptr  `json:"prev"`
	Next       *uintptr  `json:"next"`
	Branch     *uintptr  `json:"branch"`
	Ident      []uintptr `json:"ident"`
	Owner      *uintptr  `json:"owner"`
	BranchRoot bool      `json:"branch_root"`
}

type RegexLiteral struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Value         string
}

type RegexLiteralType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	Base                 *RegexLiteral
	StrongRef            *RegexLiteral
}

type Return struct {
	Loc             Loc
	Expr            Expr
	RelatedFunction *Function
}

type Scope struct {
	Prev       *Scope
	Next       *Scope
	Branch     *Scope
	Ident      []*Ident
	Owner      Node
	BranchRoot bool
}

type ScopedStatement struct {
	Loc        Loc
	StructType *StructType
	Statement  Node
	Scope      *Scope
}

type SpecialLiteral struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Kind          SpecialLiteralKind
}

type SpecialLiteralKind int

type SpecifyOrder struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Base          *Binary
	OrderType     OrderType
	Order         Expr
	OrderValue    *uint64
}

type SrcError struct {
	Errs []SrcErrorEntry `json:"errs"`
}

type SrcErrorEntry struct {
	Msg  string `json:"msg"`
	File string `json:"file"`
	Loc  Loc    `json:"loc"`
	Src  string `json:"src"`
	Warn bool   `json:"warn"`
}

type State struct {
	Loc          Loc
	Belong       Member
	BelongStruct *StructType
	Ident        *Ident
	Body         *IndentBlock
}

type Stmt interface {
	Node
	// contains filtered or unexported methods
}

type StrLiteral struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Value         string
	BinaryValue   string
	Length        uint64
}

type StrLiteralType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	Base                 *StrLiteral
	StrongRef            *StrLiteral
}

type StructType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	Fields               []Member
	Base                 Node
	Recursive            bool
	FixedHeaderSize      uint64
	FixedTailSize        uint64
	TypeMap              *TypeLiteral
}

type StructUnionType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	Cond                 *Identity
	Conds                []Expr
	Structs              []*StructType
	Base                 Expr
	UnionFields          []*Field
	Exhaustive           bool
}

type TmpVar struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	TmpVar        uint64
}

type Token struct {
	Tag   TokenTag `json:"tag"`
	Token string   `json:"token"`
	Loc   Loc      `json:"loc"`
}

type TokenFile struct {
	Success bool      `json:"success"`
	Files   []string  `json:"files"`
	Tokens  []Token   `json:"tokens"`
	Error   *SrcError `json:"error"`
}

type TokenTag int

type Type interface {
	Node
	GetIsExplicit() bool
	GetNonDynamicAllocation() bool
	GetBitAlignment() BitAlignment
	GetBitSize() *uint64
	// contains filtered or unexported methods
}

type TypeLiteral struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	TypeLiteral   Type
	EndLoc        Loc
}

type Unary struct {
	Loc           Loc
	ExprType      Type
	ConstantLevel ConstantLevel
	Op            UnaryOp
	Expr          Expr
}

type UnaryOp int

type UnionCandidate struct {
	Loc   Loc
	Cond  Expr
	Field *Field
}

type UnionType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
	Cond                 Expr
	Candidates           []*UnionCandidate
	BaseType             *StructUnionType
	CommonType           Type
	MemberCandidates     []*Field
}

type VisitFn func(v Visitor, n Node) bool

type Visitor interface {
	Visit(v Visitor, n Node) bool
}

type VoidType struct {
	Loc                  Loc
	IsExplicit           bool
	NonDynamicAllocation bool
	BitAlignment         BitAlignment
	BitSize              *uint64
}