midl

type Args struct {
	// contains filtered or unexported fields
}

type Array struct {
	// The array bounds.
	Bound ArrayBound
}

type ArrayBound struct {
	// The upper and lower bounds for the array declaration.
	Upper, Lower int64
}

type Charset int

type ComClass struct {
	Name       string          `json:"name,omitempty"`
	Attrs      *ComClassAttr   `json:"attrs,omitempty"`
	Interfaces []*ComInterface `json:"interfaces,omitempty"`
}

type ComClassAttr struct {
	*InterfaceAttr
	AppObject bool
}

type ComInterface struct {
	Name  string            `json:"name,omitempty"`
	Type  *Type             `json:"type,omitempty"`
	Attrs *ComInterfaceAttr `json:"attrs,omitempty"`
}

type ComInterfaceAttr struct {
	Default bool
	Source  bool
}

type Const struct {
	// The constant name.
	Name string `json:"name"`
	// The constant type.
	Type Kind `json:"kind"`
	// The constant value.
	Value Expr `json:"value"`
}

type Dim struct {
	MinIs            Expr
	MaxIs            Expr
	SizeIs           Expr
	FirstIs          Expr
	LastIs           Expr
	LengthIs         Expr
	IsString         bool
	IsNullTerminated bool
	IsMultiSize      bool
	IsUTF8           bool
	Dimension        int
	NoSizeLimit      bool
}

type Direction struct {
	// Determines the operation/function parameter direction.
	In, Out bool
}

type DispatchInterface struct {
	// The dispatch interface name.
	Name string `json:"name"`
	// The dispatch interface attributes.
	Attrs *DispatchInterfaceAttr `json:"attr,omitempty"`
	// The dispatch interface body.
	Body DispatchInterfaceBody `json:"body,omitempty"`
}

type DispatchInterfaceAttr struct {
	*InterfaceAttr
}

type DispatchInterfaceBody struct {
	// The dispatch interface properties.
	Properties []*Field `json:"properties,omitempty"`
	// The dispatch interfaces methods.
	Methods []*Operation `json:"methods,omitempty"`
}

type Element struct {
	// The enumeration element label.
	Value string `json:"value"`
	// The enumeration element identifier.
	ID int `json:"id"`
}

type Enum struct {
	// Requires 32-bit uint type.
	Is32 bool
	// The enumeration elements.
	Elems []*Element `json:"elements"`
}

type Export struct {
	// The positional number.
	Position int
	// The export symbol name.
	Name string
	// The constant value, or nil.
	Const *Const `json:"const,omitempty"`
	// The type value, or nil.
	Type *Type `json:"type,omitempty"`
	// The list of aliases of the tagged declarator.
	Aliases []string `json:"aliases,omitempty"`
}

type Expr struct {
	// Value is an expression value.
	Value interface{}

	// Expr is a parsed expression tree.
	Expr *ExprTree
	// contains filtered or unexported fields
}

type ExprStore interface {
	LookupExpr(string) (Expr, bool)
}

type ExprTree struct {
	// Op is an expression tree operation.
	Op int
	// Value is a terminal value of the expression tree.
	Value interface{}
	// Cond, Lval, Rval are the expression tree children.
	// (Cond used for ternary only, Lval is a value for unary operation).
	Cond, Lval, Rval *ExprTree
}

type Exprs []Expr

type Field struct {
	// The field position.
	Position int `json:"-"`
	// The field name.
	Name string `json:"name,omitempty"`
	// The field attributes.
	Attrs *FieldAttr `json:"attrs,omitempty"`
	// The field type.
	Type *Type `json:"type,omitempty"`
	// Default Value.
	DefaultValue Expr `json:"default_value,omitempty"`
}

type FieldAttr struct {
	FirstIs     []Expr
	LastIs      []Expr
	LengthIs    []Expr
	MinIs       []Expr
	MaxIs       []Expr
	SizeIs      []Expr
	Usage       Usage
	Format      Format
	SwitchIs    Expr
	Ignore      bool
	Pointer     PointerType
	Range       *Range
	SwitchType  *Type
	Safearray   *Type
	Layout      []*Field
	NoSizeLimit bool
	IsLayout    bool
	DefaultNull []Expr
}

type File struct {
	FullPath string `json:"full_path"`
	// Path is a path to file.
	Path string `json:"path"`
	// GoPkg ...
	GoPkg string `json:"go_pkg"`
	// The list of imports.
	Imports []string `json:"imports,omitempty"`
	// Export is a map of exported symbols on file level.
	Export map[string]*Export `json:"exports,omitempty"`
	// Interfaces is a list of interfaces.
	Interfaces []*Interface `json:"interfaces,omitempty"`
	// ComClasses is a list of COM classes.
	ComClasses []*ComClass `json:"com_classes,omitempty"`
	// DispatchInterfaces ...
	DispatchInterfaces []*DispatchInterface `json:"dispatch_interfaces,omitempty"`
	// Libraries ...
	Libraries []*Library `json:"libraries,omitempty"`
	// contains filtered or unexported fields
}

type Format struct {
	NullTerminated bool
	UTF8           bool
	MultiSize      bool
	Rune           bool
	Hex            bool
}

type Func struct {
	// The function parameters list.
	Params []*Param
}

type Interface struct {
	// The interface name.
	Name string `json:"name,omitempty"`
	// The interface base.
	BaseName string `json:"base_name,omitempty"`
	// The interface base.
	Base *Interface `json:"-"`
	// The interface attributes.
	Attrs *InterfaceAttr `json:"attrs,omitempty"`
	// Body is an interface body (including export symbols and function calls).
	Body InterfaceBody `json:"body,omitempty"`
}

type InterfaceAttr struct {
	UUID           *uuid.UUID
	Version        *Version
	Endpoints      []string
	Exceptions     []string
	Local          bool
	PointerDefault PointerType
	MSUnion        bool
	Object         bool
	HelpString     string
	Dual           bool
	Hidden         bool
	Nonextensible  bool
	ODL            bool
	OLEAutomation  bool
}

type InterfaceBody struct {
	// Imports is a list of file paths for the imported symbols.
	Imports []string `json:"imports"`
	// Export is a map for the exported symbols.
	Export map[string]*Export `json:"exports"`
	// Operations is a list of the interface operations.
	Operations []*Operation `json:"operations"`
}

type Kind int

type Lexer struct {
	// contains filtered or unexported fields
}

type Library struct {
	Name  string       `json:"name"`
	Attrs *LibraryAttr `json:"attr,omitempty"`
	Body  LibraryBody  `json:"body,omitempty"`
}

type LibraryAttr struct {
	*InterfaceAttr
}

type LibraryBody struct {
	ComClasses []*ComClass `json:"com_classes,omitempty"`
}

type Operation struct {
	// The operation name.
	Name string `json:"name"`
	// The operation number.
	OpNum int `json:"op_num"`
	// The operation return type.
	Type *Type `json:"type"`
	// The operation parameter list.
	Params []*Param `json:"params"`
	// The operation attributes.
	Attrs *OperationAttr `json:"attrs,omitempty"`
}

type OperationAttr struct {
	Idempotent       bool
	Broadcast        bool
	Maybe            bool
	ReflectDeletions bool
	Usage            Usage
	Format           Format
	Pointer          PointerType
	Callback         bool
	PropGet          bool
	PropPut          bool
	PropPutRef       bool
	ID               Expr
	Restricted       bool
	CallAs           string
}

type Param struct {
	// The parameter name.
	Name string `json:"name,omitempty"`
	// The parameter type.
	Type *Type `json:"type,omitempty"`
	// The parameter attributes.
	Attrs *ParamAttr `json:"attrs,omitempty"`
}

type ParamAttr struct {
	*FieldAttr
	Direction               Direction
	DisableConsistencyCheck bool
	IIDIs                   Expr
	Retval                  bool
	DefaultValue            Expr
	Optional                bool
	Annotation              string
}

type Parser struct {
	// The lexer entity.
	*Lexer
	// contains filtered or unexported fields
}

type PointerType int

type RPCLexer interface {
	Lex(lval *RPCSymType) int
	Error(s string)
}

type RPCParser interface {
	Parse(RPCLexer) int
	Lookahead() int
}

type RPCParserImpl struct {
	// contains filtered or unexported fields
}

type RPCSymType struct {
	File                  File
	Interface             Interface
	InterfaceBody         InterfaceBody
	Version               *Version
	Export                []*Export
	Type                  *Type
	Kind                  Kind
	Const                 *Const
	Operation             *Operation
	Operations            []*Operation
	Param                 *Param
	Params                []*Param
	Fields                []*Field
	Field                 *Field
	Declarators           []*pDeclarator
	Declarator            *pDeclarator
	ArrayBound            ArrayBound
	Int64                 int64
	UnionSwitch           *UnionSwitch
	UnionCases            []*UnionCase
	UnionCase             *UnionCase
	Expr                  Expr
	Exprs                 Exprs
	Ident                 string
	Char                  rune
	String                string
	Int                   *big.Int
	UUID                  *uuid.UUID
	Range                 *Range
	Strings               []string
	Token                 int
	Typedef               *pTypedef
	Attr                  pAttr
	AttrType              pAttrType
	TagID                 pTagID
	TagIDs                []pTagID
	ComClass              ComClass
	Library               Library
	ComInterfaces         []*ComInterface
	ComInterface          *ComInterface
	DispatchInterface     DispatchInterface
	DispatchInterfaceBody DispatchInterfaceBody
	// contains filtered or unexported fields
}

type Range struct {
	Min, Max int64
}

type Scope struct {
	Attr  *TypeAttr
	Types []*ScopedType
}

type ScopedType struct {
	*Type   `json:"type"`
	Dim     Dim `json:"dim"`
	Pointer int `json:"pointer"`
}

type Size struct {
	MinIs  Expr
	MaxIs  Expr
	SizeIs Expr
}

type SizeAttr struct {
	MinIs  []Expr
	MaxIs  []Expr
	SizeIs []Expr
}

type Struct struct {
	// The structure fields.
	Fields []*Field `json:"fields,omitempty"`
}

type Type struct {
	Kind      Kind       `json:"kind,omitempty"`
	Charset   Charset    `json:"charset,omitempty"`
	Name      string     `json:"name,omitempty"`
	Tag       string     `json:"tag,omitempty"`
	Func      *Func      `json:"func,omitempty"`
	Array     *Array     `json:"array,omitempty"`
	Enum      *Enum      `json:"enum,omitempty"`
	Struct    *Struct    `json:"struct,omitempty"`
	Union     *Union     `json:"union,omitempty"`
	Interface *Interface `json:"-"`
	Attrs     *TypeAttr  `json:"attrs,omitempty"`
	Alias     string     `json:"alias,omitempty"`
	Elem      *Type      `json:"elem,omitempty"`
}

type TypeAttr struct {
	TransmitAs              *Type
	Handle                  bool
	SwitchType              *Type
	Usage                   Usage
	Format                  Format
	Pointer                 PointerType
	V1Enum                  bool
	Range                   *Range
	DisableConsistencyCheck bool
	WireMarshal             string
	Public                  bool
	Alias                   string
	// names, pointers to keep track of lost data merged.
	Names    []string
	Pointers []PointerType
	Parent   string
	Pad      uint64
	IsLayout bool
}

type TypeStore interface {
	// LookupType function must resolve the type reference
	// and return type or 'false'
	LookupType(n string) (*Type, bool)
}

type Union struct {
	// The list of union switch/case statements.
	Body   []*UnionCase `json:"body,omitempty"`
	Switch *UnionSwitch `json:"switch,omitempty"`
}

type UnionCase struct {
	Position  int           `json:"position,omitempty"`
	Labels    []interface{} `json:"labels,omitempty"`
	Arms      []*Field      `json:"arms,omitempty"`
	IsDefault bool          `json:"is_default,omitempty"`
}

type UnionSwitch struct {
	Name string `json:"name"`
	Type *Type  `json:"type,omitempty"`
}

type Usage struct {
	ContextHandle bool
	IsString      bool
}

type Version struct {
	Minor, Major uint16
}