midl

Documentation

Index

• Constants
• Variables
• func CanEval(es ...Expr) bool
• func FileStore(p string, f *File)
• func FindFile(f string) (string, string, error)
• func FindPath() []string
• func Hash(s string) int
• func IsBoolOp(op int) bool
• func MD5(text string) string
• func PrimitiveTypeSize(kind Kind) int
• func RPCErrorMessage(state, lookAhead int) string
• func RPCParse(RPClex RPCLexer) int
• func RPCStatname(s int) string
• func RPCTokname(c int) string
• func RPClex1(lex RPCLexer, lval *RPCSymType) (char, token int)
• func SetSwitchType(fields []*Field)
• func TagName(kind Kind, tag string) string
• func TypeSize(s TypeStore, t *Type) int
• type Args
  • func (a *Args) LookupExpr(string) (Expr, bool)
• type Array
  • func (a Array) IsFixed() bool
  • func (a *Array) MarshalJSON() ([]byte, error)
  • func (a Array) Size() int64
• type ArrayBound
• type Charset
  • func (c Charset) String() (ret string)
• type ComClass
• type ComClassAttr
  • func (a *ComClassAttr) MarshalJSON() ([]byte, error)
  • func (a *ComClassAttr) String() string
• type ComInterface
• type ComInterfaceAttr
  • func (a *ComInterfaceAttr) MarshalJSON() ([]byte, error)
  • func (a *ComInterfaceAttr) String() string
• type Const
• type Dim
  • func (d Dim) Empty() bool
  • func (d Dim) Size() Size
  • func (d Dim) String() string
• type Direction
  • func (d Direction) String() string
• type DispatchInterface
• type DispatchInterfaceAttr
  • func (a *DispatchInterfaceAttr) MarshalJSON() ([]byte, error)
  • func (a *DispatchInterfaceAttr) String() string
• type DispatchInterfaceBody
• type Element
• type Enum
• type Export
• type Expr
  • func NewExpr(op int, valuer func() (interface{}, bool), es ...Expr) (Expr, bool)
  • func NewIdent(v string) Expr
  • func NewValue(v interface{}) Expr
  • func (lval Expr) Add(rval Expr) (Expr, bool)
  • func (lval Expr) And(rval Expr) (Expr, bool)
  • func (e Expr) BigInt() (*big.Int, bool)
  • func (e Expr) Bool() bool
  • func (e Expr) CanEval() bool
  • func (e Expr) Char() (rune, bool)
  • func (e Expr) Coerce(kind Kind) (Expr, error)
  • func (lval Expr) Div(rval Expr) (Expr, bool)
  • func (val Expr) Empty() bool
  • func (lval Expr) Eq(rval Expr) (Expr, bool)
  • func (e Expr) Eval(l ExprStore) (Expr, bool)
  • func (e Expr) Expression(namer ...func(string) string) string
  • func (lval Expr) Ge(rval Expr) (Expr, bool)
  • func (lval Expr) Gt(rval Expr) (Expr, bool)
  • func (val Expr) Ident() Expr
  • func (e Expr) Int64() (int64, bool)
  • func (e Expr) IsIdent() bool
  • func (e Expr) IsZero() bool
  • func (lval Expr) Le(rval Expr) (Expr, bool)
  • func (lval Expr) LogicalAnd(rval Expr) (Expr, bool)
  • func (lval Expr) LogicalOr(rval Expr) (Expr, bool)
  • func (lval Expr) Lsh(rval Expr) (Expr, bool)
  • func (lval Expr) Lt(rval Expr) (Expr, bool)
  • func (e Expr) MarshalJSON() ([]byte, error)
  • func (lval Expr) Mul(rval Expr) (Expr, bool)
  • func (lval Expr) Ne(rval Expr) (Expr, bool)
  • func (val Expr) Neg() (Expr, bool)
  • func (val Expr) Negative() (Expr, bool)
  • func (val Expr) Not() (Expr, bool)
  • func (e Expr) Null() bool
  • func (lval Expr) Or(rval Expr) (Expr, bool)
  • func (val Expr) Positive() (Expr, bool)
  • func (val Expr) Ptr() (Expr, bool)
  • func (lval Expr) Rem(rval Expr) (Expr, bool)
  • func (e Expr) Resolve(in Expr) (Expr, bool)
  • func (val Expr) ResolveTo(to Expr) (Expr, bool)
  • func (lval Expr) Rsh(rval Expr) (Expr, bool)
  • func (e Expr) Str() (string, bool)
  • func (e Expr) String() string
  • func (lval Expr) Sub(rval Expr) (Expr, bool)
  • func (cond Expr) Ter(lval, rval Expr) (Expr, bool)
  • func (e Expr) Uint64() (uint64, bool)
  • func (lval Expr) Xor(rval Expr) (Expr, bool)
• type ExprStore
  • func NewArgs(args ...interface{}) ExprStore
• type ExprTree
  • func (e *ExprTree) Eval(l ExprStore) (Expr, bool)
  • func (t *ExprTree) Expression(namer ...func(string) string) string
  • func (e *ExprTree) Resolve(expr *ExprTree) (Expr, *ExprTree, bool)
  • func (e *ExprTree) ResolveTo(to Expr) (Expr, bool)
  • func (t *ExprTree) String() string
• type Exprs
• type Field
  • func (f *Field) IsHandle() bool
  • func (f *Field) IsString() bool
  • func (f *Field) Scopes() []*Scope
• type FieldAttr
  • func (f *FieldAttr) Dim() []Dim
  • func (a *FieldAttr) MarshalJSON() ([]byte, error)
  • func (f *FieldAttr) SizeAttr() *SizeAttr
  • func (a *FieldAttr) String() string
  • func (f *FieldAttr) TypeAttr() *TypeAttr
• type File
  • func FileLoad(p string) (*File, bool)
  • func Files() []*File
  • func NewFile(p, pkg string) *File
  • func Parse(s string) (*File, error)
  • func (f *File) Exports() []*Export
  • func (f *File) GoPackage(tn string) (string, bool)
  • func (f *File) IsLocal(tn string) bool
  • func (f *File) Load() (*File, error)
  • func (f *File) LookupAlias(n string) []string
  • func (f *File) LookupType(n string) (*Type, bool)
• type Format
  • func (f Format) String() string
• type Func
• type Interface
  • func (iff *Interface) Exports() []*Export
  • func (iff *Interface) IsObject() bool
• type InterfaceAttr
  • func (a *InterfaceAttr) MarshalJSON() ([]byte, error)
  • func (a *InterfaceAttr) String() string
• type InterfaceBody
  • func (b InterfaceBody) Exports() []*Export
• type Kind
  • func (t Kind) MarshalJSON() ([]byte, error)
  • func (k Kind) Signed() bool
  • func (t Kind) String() (ret string)
• type Lexer
  • func NewLexer(s string) *Lexer
  • func (l *Lexer) Error(s string)
  • func (l *Lexer) Errorf(frmt string, args ...interface{})
  • func (l *Lexer) Lex(lval *RPCSymType) int
  • func (l *Lexer) Push(s string)
  • func (l *Lexer) TokName(c int) (string, bool)
• type Library
• type LibraryAttr
  • func (a *LibraryAttr) MarshalJSON() ([]byte, error)
  • func (a *LibraryAttr) String() string
• type LibraryBody
• type Operation
  • func (o *Operation) GetName() string
• type OperationAttr
  • func (a *OperationAttr) MarshalJSON() ([]byte, error)
  • func (a *OperationAttr) String() string
• type Param
  • func (p *Param) IsHandle() bool
• type ParamAttr
  • func (a *ParamAttr) MarshalJSON() ([]byte, error)
  • func (a *ParamAttr) String() string
• type Parser
  • func NewParser(s string) *Parser
  • func (p *Parser) Defer(ref *Type)
  • func (p *Parser) LookupConst(n string) (*Const, bool)
  • func (p *Parser) LookupExpr(n string) (Expr, bool)
  • func (p *Parser) LookupType(n string) (*Type, bool)
  • func (p *Parser) Store(n string, val Expr, typ ...Kind)
• type PointerType
  • func (p PointerType) String() string
• type RPCLexer
• type RPCParser
  • func RPCNewParser() RPCParser
• type RPCParserImpl
  • func (p *RPCParserImpl) Lookahead() int
  • func (RPCrcvr *RPCParserImpl) Parse(RPClex RPCLexer) int
• type RPCSymType
• type Range
• type Scope
• type ScopedType
• type Size
  • func (d Size) Empty() bool
  • func (d Size) Is() (expr Expr)
• type SizeAttr
• type Struct
  • func (s *Struct) LastField() *Field
• type Type
  • func InterfaceToExport(iff *Interface) *Type
  • func LookupType(n string) *Type
  • func (t *Type) Append(tt *Type) *Type
  • func (t *Type) AppendAfterPointer(tt *Type) *Type
  • func (t *Type) Base() *Type
  • func (t *Type) Is(kind Kind) bool
  • func (t *Type) IsPrimitiveType() bool
  • func (a *Type) MarshalJSON() ([]byte, error)
  • func (t *Type) Scopes() []*Scope
  • func (t *Type) TypeName() string
• type TypeAttr
  • func (t *TypeAttr) EnumType() Kind
  • func (a *TypeAttr) MarshalJSON() ([]byte, error)
  • func (t *TypeAttr) Merge(tt *TypeAttr) *TypeAttr
  • func (a *TypeAttr) String() string
• type TypeStore
• type Union
  • func (u *Union) IsEncapsulated() bool
• type UnionCase
  • func (u *UnionCase) String() string
• type UnionSwitch
• type Usage
  • func (u Usage) String() string
• type Version
  • func (v *Version) String() string

Constants

const ACS_BYTE_COUNT = 57459

const AND = 57477

const ANNOTATION = 57450

const APPOBJECT = 57444

const BOOLEAN = 57356

const BROADCAST = 57404

const BYTE = 57357

const CALLBACK = 57430

const CALL_AS = 57449

const CASE = 57394

const CAST = 57483

const CHAR = 57355

const CHARACTER_LITERAL = 57461

const COCLASS = 57457

const CONST = 57384

const DEFAULT = 57395

const DEFAULT_VALUE = 57440

const DISABLE_CONSISTENCY_CHECK = 57426

const DISPINTERFACE = 57454

const DOUBLE = 57347

const DUAL = 57432

const ENDPOINT = 57408

const ENUM = 57390

const EQ = 57473

const ERROR_STATUS_T = 57360

const EXCEPTIONS = 57409

const FALSE = 57387

const FIRST_IS = 57365

const FLOAT = 57346

const FORMAT = 57374

const FORMAT_MULTI_SIZE = 57376

const FORMAT_NULL_TERMINATED = 57375

const FORMAT_RUNE = 57378

const FORMAT_UTF8 = 57377

const GE = 57470

const GOEXT_LAYOUT = 57447

const GOEXT_NO_SIZE_LIMIT = 57448

const GT = 57472

const HANDLE = 57398

const HANDLE_T = 57359

const HELP_STRING = 57431

const HIDDEN = 57437

const HYPER = 57348

const ID = 57436

const IDEMPOTENT = 57403

const IDENT = 57464

const IGNORE = 57379

const IID_IS = 57413

const IMPORT = 57399

const IN = 57388

const INT = 57354

const INT16 = 57417

const INT32 = 57418

const INT3264 = 57415

const INT64 = 57419

const INT8 = 57416

const INTERFACE = 57402

const INT_LITERAL = 57463

const ISO_LATIN_1 = 57361

const ISO_MULTILINGUAL = 57362

const ISO_UCS = 57363

const LAST_IS = 57366

const LE = 57469

const LENGTH_IS = 57367

const LIBRARY = 57458

const LOCAL = 57410

const LOGICAL_AND = 57468

const LOGICAL_OR = 57467

const LONG = 57351

const LSH = 57478

const LT = 57471

const MAX_IS = 57368

const MAYBE = 57405

const METHODS = 57455

const MIN_IS = 57369

const MS_UNION = 57421

const NE = 57474

const NONEXTENSIBLE = 57438

const NULL = 57385

const OBJECT = 57422

const ODL = 57441

const OLEAUTOMATION = 57442

const OPTIONAL = 57443

const OR = 57475

const OUT = 57389

const PAD = 57446

const PIPE = 57391

const POINTER = 57380

const POINTER_DEFAULT = 57411

const POINTER_PTR = 57383

const POINTER_REF = 57381

const POINTER_UNIQUE = 57382

const PRAGMA_CPP_QUOTE = 57429

const PRAGMA_DEFINE = 57428

const PROPERTIES = 57456

const PROPGET = 57433

const PROPPUT = 57434

const PROPPUTREF = 57435

const PUBLIC = 57452

const RANGE = 57420

const REFLECT_DELETIONS = 57406

const RESTRICTED = 57439

const RETVAL = 57412

const RNG = 57466

const RPCEofCode = 1

const RPCErrCode = 2

const RPCFlag = -1000

const RPCInitialStackSize = 16

const RPCLast = 1056

const RPCPrivate = 57344

const RSH = 57479

const SAFEARRAY = 57445

const SHORT = 57352

const SIGNED = 57350

const SIZEOF = 57427

const SIZE_IS = 57370

const SMALL = 57353

const SOURCE = 57453

const STRICT_CONTEXT_HANDLE = 57424

const STRING = 57460

const STRING_LITERAL = 57462

const STRUCT = 57364

const SWITCH = 57393

const SWITCH_IS = 57371

const SWITCH_TYPE = 57396

const TERNARY = 57465

const TRANSMIT_AS = 57397

const TRUE = 57386

const TYPEDEF = 57400

const TYPE_STRICT_CONTEXT_HANDLE = 57425

const UMINUS = 57484

const UMUL = 57485

const UNEG = 57481

const UNION = 57392

const UNOT = 57482

const UNSIGNED = 57349

const UPLUS = 57480

const USAGE_CONTEXT_HANDLE = 57373

const USAGE_STRING = 57372

const UUID = 57401

const V1_ENUM = 57423

const VERSION = 57407

const VOID = 57358

const WCHAR_T = 57414

const WIRE_MARSHAL = 57451

const XOR = 57476

Variables

var (
	NameTok = map[string]int{}

	TokName = map[int]string{}/* 111 elements not displayed */

	SQBReservedTok = map[int]struct{}{
		ANNOTATION:                 {},
		APPOBJECT:                  {},
		BROADCAST:                  {},
		CALL_AS:                    {},
		CALLBACK:                   {},
		DEFAULT_VALUE:              {},
		DISABLE_CONSISTENCY_CHECK:  {},
		ENDPOINT:                   {},
		FIRST_IS:                   {},
		HANDLE:                     {},
		HELP_STRING:                {},
		HIDDEN:                     {},
		ID:                         {},
		IGNORE:                     {},
		IDEMPOTENT:                 {},
		IID_IS:                     {},
		IN:                         {},
		LAST_IS:                    {},
		LENGTH_IS:                  {},
		LOCAL:                      {},
		MAX_IS:                     {},
		MAYBE:                      {},
		MIN_IS:                     {},
		MS_UNION:                   {},
		OBJECT:                     {},
		ODL:                        {},
		OLEAUTOMATION:              {},
		OPTIONAL:                   {},
		OUT:                        {},
		POINTER_DEFAULT:            {},
		PROPGET:                    {},
		PROPPUT:                    {},
		PROPPUTREF:                 {},
		POINTER_PTR:                {},
		PUBLIC:                     {},
		RANGE:                      {},
		POINTER_REF:                {},
		RETVAL:                     {},
		SIZE_IS:                    {},
		SOURCE:                     {},
		STRICT_CONTEXT_HANDLE:      {},
		USAGE_STRING:               {},
		USAGE_CONTEXT_HANDLE:       {},
		FORMAT:                     {},
		FORMAT_UTF8:                {},
		FORMAT_NULL_TERMINATED:     {},
		FORMAT_MULTI_SIZE:          {},
		FORMAT_RUNE:                {},
		SWITCH_IS:                  {},
		SWITCH_TYPE:                {},
		TRANSMIT_AS:                {},
		TYPE_STRICT_CONTEXT_HANDLE: {},
		POINTER_UNIQUE:             {},
		UUID:                       {},
		VERSION:                    {},
		WIRE_MARSHAL:               {},
		PAD:                        {},
		GOEXT_LAYOUT:               {},
		SAFEARRAY:                  {},
	}

	ReservedTok = map[int]struct{}{
		SIZEOF:           {},
		PRAGMA_CPP_QUOTE: {},
		FLOAT:            {},
		DOUBLE:           {},
		HYPER:            {},
		UNSIGNED:         {},
		SIGNED:           {},
		LONG:             {},
		SHORT:            {},
		SMALL:            {},
		INT:              {},
		INT8:             {},
		INT16:            {},
		INT32:            {},
		INT64:            {},
		INT3264:          {},
		CHAR:             {},
		WCHAR_T:          {},
		BOOLEAN:          {},
		BYTE:             {},
		VOID:             {},
		HANDLE_T:         {},
		ERROR_STATUS_T:   {},
		ISO_LATIN_1:      {},
		ISO_MULTILINGUAL: {},
		ISO_UCS:          {},
		STRUCT:           {},
		CONST:            {},
		NULL:             {},
		TRUE:             {},
		FALSE:            {},
		ENUM:             {},
		PIPE:             {},
		UNION:            {},
		SWITCH:           {},
		CASE:             {},
		DEFAULT:          {},
		IMPORT:           {},
		TYPEDEF:          {},
		INTERFACE:        {},
		COCLASS:          {},
		DISPINTERFACE:    {},
	}
)

var (
	RPCDebug        = 0
	RPCErrorVerbose = false
)

var (
	// ErrEOF ...
	ErrEOF = errors.New("unexpected EOF")
)

var RPCAct = [...]int16{}/* 1056 elements not displayed */

var RPCChk = [...]int16{}/* 613 elements not displayed */

var RPCDef = [...]int16{}/* 613 elements not displayed */

var RPCErrorMessages = [...]struct {
	state int
	token int
	msg   string
}{}

var RPCExca = [...]int16{
	-1, 0,
	1, 1,
	-2, 46,
	-1, 1,
	1, -1,
	-2, 0,
	-1, 2,
	1, 2,
	-2, 46,
	-1, 247,
	151, 115,
	-2, 46,
	-1, 263,
	113, 36,
	114, 36,
	151, 36,
	-2, 46,
	-1, 270,
	149, 198,
	154, 198,
	-2, 338,
	-1, 415,
	113, 37,
	114, 37,
	151, 37,
	-2, 46,
	-1, 416,
	113, 35,
	114, 35,
	151, 35,
	-2, 46,
	-1, 463,
	2, 338,
	122, 338,
	156, 338,
	-2, 198,
	-1, 552,
	157, 249,
	-2, 246,
	-1, 556,
	157, 249,
	-2, 246,
	-1, 580,
	157, 250,
	-2, 242,
}

var RPCPact = [...]int16{}/* 613 elements not displayed */

var RPCPgo = [...]int16{}/* 144 elements not displayed */

var RPCR1 = [...]uint8{}/* 360 elements not displayed */

var RPCR2 = [...]int8{}/* 360 elements not displayed */

var RPCStatenames = [...]string{}

var RPCTok1 = [...]uint8{}/* 127 elements not displayed */

var RPCTok2 = [...]uint8{}/* 142 elements not displayed */

var RPCTok3 = [...]int8{
	0,
}

var RPCToknames = [...]string{}/* 162 elements not displayed */

Functions

func CanEval

func CanEval(es ...Expr) bool

CanEval function returns true if expression can be evaluated immediately.

func FileStore

func FileStore(p string, f *File)

func FindFile

func FindFile(f string) (string, string, error)

func FindPath

func FindPath() []string

func Hash

func Hash(s string) int

func IsBoolOp

func IsBoolOp(op int) bool

func MD5

func MD5(text string) string

func PrimitiveTypeSize

func PrimitiveTypeSize(kind Kind) int

func RPCErrorMessage

func RPCErrorMessage(state, lookAhead int) string

func RPCParse

func RPCParse(RPClex RPCLexer) int

func RPCStatname

func RPCStatname(s int) string

func RPCTokname

func RPCTokname(c int) string

func RPClex1

func RPClex1(lex RPCLexer, lval *RPCSymType) (char, token int)

func SetSwitchType

func SetSwitchType(fields []*Field)

func TagName

func TagName(kind Kind, tag string) string

TagName function transforms the kind and tag to a tagged name.

func TypeSize

func TypeSize(s TypeStore, t *Type) int

TypeSize ...

Types

type Args

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

func (*Args) LookupExpr

func (a *Args) LookupExpr(string) (Expr, bool)

type Array

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

Array structure represents the array type.

func (Array) IsFixed

func (a Array) IsFixed() bool

IsFixed function returns true if array is of fixed size.

func (*Array) MarshalJSON

func (a *Array) MarshalJSON() ([]byte, error)

func (Array) Size

func (a Array) Size() int64

Size function returns the fixed size array.

type ArrayBound

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

ArrayBound structure represents the array bounds declaration.

type Charset

type Charset int

Charset is a predefined character set, as per DCE/RPC [C706].

const (
	CharsetNone Charset = iota
	CharsetISO_Latin_1
	CharsetISO_Multilingual
	CharsetISO_UCS
)

func (Charset) String

func (c Charset) String() (ret string)

type ComClass

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

ComClass structure ...

type ComClassAttr

type ComClassAttr struct {
	*InterfaceAttr
	AppObject bool
}

ComClassAttr ...

func (*ComClassAttr) MarshalJSON

func (a *ComClassAttr) MarshalJSON() ([]byte, error)

func (*ComClassAttr) String

func (a *ComClassAttr) String() string

type ComInterface

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

ComInterface structure ...

type ComInterfaceAttr

type ComInterfaceAttr struct {
	Default bool
	Source  bool
}

ComInterfaceAttr ...

func (*ComInterfaceAttr) MarshalJSON

func (a *ComInterfaceAttr) MarshalJSON() ([]byte, error)

func (*ComInterfaceAttr) String

func (a *ComInterfaceAttr) String() string

type Const

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

Const structure represents the constant declaration. This declaration is obtained either via `const` expression or via #define statement.

type Dim

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
}

func (Dim) Empty

func (d Dim) Empty() bool

func (Dim) Size

func (d Dim) Size() Size

func (Dim) String

func (d Dim) String() string

type Direction

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

func (Direction) String

func (d Direction) String() string

type DispatchInterface

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"`
}

DispatchInterface ...

type DispatchInterfaceAttr

type DispatchInterfaceAttr struct {
	*InterfaceAttr
}

DispatchInterfaceAttr ...

func (*DispatchInterfaceAttr) MarshalJSON

func (a *DispatchInterfaceAttr) MarshalJSON() ([]byte, error)

func (*DispatchInterfaceAttr) String

func (a *DispatchInterfaceAttr) String() string

type DispatchInterfaceBody

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

DispatchInterfaceBody ...

type Element

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

Element structure represents the enumeration element.

type Enum

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

Enum structure represents the enumeration type.

type Export

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"`
}

Export structure represents the exported symbol.

type Expr

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

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

Expr is an expression.

func NewExpr

func NewExpr(op int, valuer func() (interface{}, bool), es ...Expr) (Expr, bool)

NewExpr function builds a new expression with expression tree.

func NewIdent

func NewIdent(v string) Expr

NewIdent function creates a new expression variable.

func NewValue

func NewValue(v interface{}) Expr

NewValue function creates a new expression node value.

func (Expr) Add

func (lval Expr) Add(rval Expr) (Expr, bool)

Add function performs addition of two integers.

func (Expr) And

func (lval Expr) And(rval Expr) (Expr, bool)

Or function performs the bitwise and operation on expression.

func (Expr) BigInt

func (e Expr) BigInt() (*big.Int, bool)

BigInt function returns the *big.Int representation of the value.

func (Expr) Bool

func (e Expr) Bool() bool

Bool function returns boolean representation of the expression.

func (Expr) CanEval

func (e Expr) CanEval() bool

func (Expr) Char

func (e Expr) Char() (rune, bool)

Char function returns the char representation of the expression.

func (Expr) Coerce

func (e Expr) Coerce(kind Kind) (Expr, error)

Coerce function tries to cast the given Expr to the kind provided and returns the same expression.

func (Expr) Div

func (lval Expr) Div(rval Expr) (Expr, bool)

Div function performs integer division (`lval` / `rval`). Note that `rval` must evaluate to the non-zero value.

func (Expr) Empty

func (val Expr) Empty() bool

Empty function returns 'true' when expression is empty.

func (Expr) Eq

func (lval Expr) Eq(rval Expr) (Expr, bool)

Eq function compares two values and returns `true` if lval is equal rval.

func (Expr) Eval

func (e Expr) Eval(l ExprStore) (Expr, bool)

Eval function evaluates the expression and returns evaluated expression.

func (Expr) Expression

func (e Expr) Expression(namer ...func(string) string) string

func (Expr) Ge

func (lval Expr) Ge(rval Expr) (Expr, bool)

Ge function compares two integers and returns `true` if lval >= rval.

func (Expr) Gt

func (lval Expr) Gt(rval Expr) (Expr, bool)

Gt function compares two integers and returns `true` if lval > rval.

func (Expr) Ident

func (val Expr) Ident() Expr

func (Expr) Int64

func (e Expr) Int64() (int64, bool)

Int function returns int64 representation of the expression.

func (Expr) IsIdent

func (e Expr) IsIdent() bool

func (Expr) IsZero

func (e Expr) IsZero() bool

func (Expr) Le

func (lval Expr) Le(rval Expr) (Expr, bool)

Le function compares two integers and returns `true` if lval <= rval.

func (Expr) LogicalAnd

func (lval Expr) LogicalAnd(rval Expr) (Expr, bool)

LogicalAnd function performs logical-and (&&) operation on expression.

func (Expr) LogicalOr

func (lval Expr) LogicalOr(rval Expr) (Expr, bool)

LogicalOr function performs logical-or (||) operation on expression.

func (Expr) Lsh

func (lval Expr) Lsh(rval Expr) (Expr, bool)

Lsh function performs the left-shift of the `lval` on `rval` amount. `rval` must be a valid unsigned integer.

func (Expr) Lt

func (lval Expr) Lt(rval Expr) (Expr, bool)

Lt function compares two integers and returns `true` if lval < rval.

func (Expr) MarshalJSON

func (e Expr) MarshalJSON() ([]byte, error)

func (Expr) Mul

func (lval Expr) Mul(rval Expr) (Expr, bool)

Mul function performs integer multiplication (`lval` * `rval`).

func (Expr) Ne

func (lval Expr) Ne(rval Expr) (Expr, bool)

Ne function compares two values and returns `true` if `lval` is not equal `rval`.

func (Expr) Neg

func (val Expr) Neg() (Expr, bool)

Neg function performs integer bitwise negation.

func (Expr) Negative

func (val Expr) Negative() (Expr, bool)

Negative function returns -integer.

func (Expr) Not

func (val Expr) Not() (Expr, bool)

Not function performs boolean negation.

func (Expr) Null

func (e Expr) Null() bool

Null function returns the null representation of the expression.

func (Expr) Or

func (lval Expr) Or(rval Expr) (Expr, bool)

Or function performs the bitwise or operation on expression.

func (Expr) Positive

func (val Expr) Positive() (Expr, bool)

Positive function returns integer.

func (Expr) Ptr

func (val Expr) Ptr() (Expr, bool)

Ptr function doesn't do anything special, needed to resemble correct tree with pointer value.

func (Expr) Rem

func (lval Expr) Rem(rval Expr) (Expr, bool)

Rem function performs C-like integer reminder operation (`lval` % `rval`). Note that `rval` must evaluate to the non-zero value.

func (Expr) Resolve

func (e Expr) Resolve(in Expr) (Expr, bool)

func (Expr) ResolveTo

func (val Expr) ResolveTo(to Expr) (Expr, bool)

func (Expr) Rsh

func (lval Expr) Rsh(rval Expr) (Expr, bool)

Rsh function performs the right-shift of the `lval` on `rval` amount. `rval` must be a valid unsigned integer.

func (Expr) Str

func (e Expr) Str() (string, bool)

String function returns string representation of the expression.

func (Expr) String

func (e Expr) String() string

func (Expr) Sub

func (lval Expr) Sub(rval Expr) (Expr, bool)

Sub function performs integer substraction (`lval` - `rval`).

func (Expr) Ter

func (cond Expr) Ter(lval, rval Expr) (Expr, bool)

Ternary function performs ternary (?:) operation on expression.

func (Expr) Uint64

func (e Expr) Uint64() (uint64, bool)

Uint function returns uint64 representation of the expression.

func (Expr) Xor

func (lval Expr) Xor(rval Expr) (Expr, bool)

Or function performs the bitwise exclusive-or (xor) operation on expression.

type ExprStore

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

func NewArgs

func NewArgs(args ...interface{}) ExprStore

type ExprTree

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
}

ExprTree is an expression tree build when expression cannot be evaluated immediately.

func (*ExprTree) Eval

func (e *ExprTree) Eval(l ExprStore) (Expr, bool)

Eval function evaluates the expression tree with Store for lookup.

func (*ExprTree) Expression

func (t *ExprTree) Expression(namer ...func(string) string) string

func (*ExprTree) Resolve

func (e *ExprTree) Resolve(expr *ExprTree) (Expr, *ExprTree, bool)

func (*ExprTree) ResolveTo

func (e *ExprTree) ResolveTo(to Expr) (Expr, bool)

func (*ExprTree) String

func (t *ExprTree) String() string

type Exprs

type Exprs []Expr

Exprs is a list of expressions.

type Field

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"`
}

Field structure represents the union/structure field declaration.

func (*Field) IsHandle

func (f *Field) IsHandle() bool

func (*Field) IsString

func (f *Field) IsString() bool

func (*Field) Scopes

func (f *Field) Scopes() []*Scope

type FieldAttr

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
}

FieldAttr ...

func (*FieldAttr) Dim

func (f *FieldAttr) Dim() []Dim

func (*FieldAttr) MarshalJSON

func (a *FieldAttr) MarshalJSON() ([]byte, error)

func (*FieldAttr) SizeAttr

func (f *FieldAttr) SizeAttr() *SizeAttr

func (*FieldAttr) String

func (a *FieldAttr) String() string

func (*FieldAttr) TypeAttr

func (f *FieldAttr) TypeAttr() *TypeAttr

type File

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
}

File structure represents the parsed file contents.

func FileLoad

func FileLoad(p string) (*File, bool)

FileLoad ...

func Files

func Files() []*File

func NewFile

func NewFile(p, pkg string) *File

func Parse

func Parse(s string) (*File, error)

Parse ...

func (*File) Exports

func (f *File) Exports() []*Export

Exports function returns the exported symbols as a sorted array.

func (*File) GoPackage

func (f *File) GoPackage(tn string) (string, bool)

GoPackage function returns the go package name for the type.

func (*File) IsLocal

func (f *File) IsLocal(tn string) bool

func (*File) Load

func (f *File) Load() (*File, error)

Load function loads the file content.

func (*File) LookupAlias

func (f *File) LookupAlias(n string) []string

func (*File) LookupType

func (f *File) LookupType(n string) (*Type, bool)

LookupType function lookups the type inside the file.

type Format

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

func (Format) String

func (f Format) String() string

type Func

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

Func structure represents the function type.

type Interface

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"`
}

Interface structure represents the interface definition.

func (*Interface) Exports

func (iff *Interface) Exports() []*Export

Exports function ...

func (*Interface) IsObject

func (iff *Interface) IsObject() bool

type InterfaceAttr

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
}

InterfaceAttr ...

func (*InterfaceAttr) MarshalJSON

func (a *InterfaceAttr) MarshalJSON() ([]byte, error)

func (*InterfaceAttr) String

func (a *InterfaceAttr) String() string

type InterfaceBody

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"`
}

InterfaceBody structure represents the interface body definitions.

func (InterfaceBody) Exports

func (b InterfaceBody) Exports() []*Export

Exports function ...

type Kind

type Kind int

Kind is the type selector.

const (
	TypeInvalid Kind = iota
	TypeInt8
	TypeUint8
	TypeInt16
	TypeUint16
	TypeInt32
	TypeInt64
	TypeUint32
	TypeUint64
	TypeInt32_64  // 32 for NDR, 64 for NDR64 representation.
	TypeUint32_64 // 32 for NDR, 64 for NDR64 representation.
	TypeFloat32
	TypeFloat64
	TypeCharset
	TypeUChar
	TypeChar
	TypeWChar
	TypeEnum
	TypeString
	TypeStruct
	TypeUnion
	TypeCUnion
	TypeFunc
	TypeArray
	TypePointer
	TypePipe
	TypeBoolean
	TypeVoid // constant declaration only.
	TypeHandle
	TypeError
	TypeInterface
	TypeDispInterface
	TypeRef       // type reference, resolved via lookup.
	TypeAttribute //
	TypeTag
)

func (Kind) MarshalJSON

func (t Kind) MarshalJSON() ([]byte, error)

func (Kind) Signed

func (k Kind) Signed() bool

func (Kind) String

func (t Kind) String() (ret string)

type Lexer

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

Lexer ...

func NewLexer

func NewLexer(s string) *Lexer

NewLexer ...

func (*Lexer) Error

func (l *Lexer) Error(s string)

Error ...

func (*Lexer) Errorf

func (l *Lexer) Errorf(frmt string, args ...interface{})

Errorf ...

func (*Lexer) Lex

func (l *Lexer) Lex(lval *RPCSymType) int

Lex ...

func (*Lexer) Push

func (l *Lexer) Push(s string)

Push function pushes the string on current position to re-enter the line.

func (*Lexer) TokName

func (l *Lexer) TokName(c int) (string, bool)

TokName function maps the token to the token name.

type Library

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

type LibraryAttr

type LibraryAttr struct {
	*InterfaceAttr
}

LibraryAttr ...

func (*LibraryAttr) MarshalJSON

func (a *LibraryAttr) MarshalJSON() ([]byte, error)

func (*LibraryAttr) String

func (a *LibraryAttr) String() string

type LibraryBody

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

LibraryBody ...

type Operation

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"`
}

Operation structure represents the RPC call.

func (*Operation) GetName

func (o *Operation) GetName() string

type OperationAttr

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
}

OperationAttr ...

func (*OperationAttr) MarshalJSON

func (a *OperationAttr) MarshalJSON() ([]byte, error)

func (*OperationAttr) String

func (a *OperationAttr) String() string

type Param

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"`
}

Param structure represents the operation/function parameter declaration.

func (*Param) IsHandle

func (p *Param) IsHandle() bool

type ParamAttr

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

ParamAttr ...

func (*ParamAttr) MarshalJSON

func (a *ParamAttr) MarshalJSON() ([]byte, error)

func (*ParamAttr) String

func (a *ParamAttr) String() string

type Parser

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

func NewParser

func NewParser(s string) *Parser

NewParser function returns the parser entity.

func (*Parser) Defer

func (p *Parser) Defer(ref *Type)

Defer function defers the type resolution until the parse end.

func (*Parser) LookupConst

func (p *Parser) LookupConst(n string) (*Const, bool)

LookupConst ...

func (*Parser) LookupExpr

func (p *Parser) LookupExpr(n string) (Expr, bool)

LookupExpr ...

func (*Parser) LookupType

func (p *Parser) LookupType(n string) (*Type, bool)

LookupType ...

func (*Parser) Store

func (p *Parser) Store(n string, val Expr, typ ...Kind)

Store ...

type PointerType

type PointerType int

const (
	PointerTypeNone PointerType = iota
	PointerTypeRef
	PointerTypePtr
	PointerTypeUnique
	PointerTypeRefWeak
)

func (PointerType) String

func (p PointerType) String() string

type RPCLexer

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

type RPCParser

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

func RPCNewParser

func RPCNewParser() RPCParser

type RPCParserImpl

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

func (*RPCParserImpl) Lookahead

func (p *RPCParserImpl) Lookahead() int

func (*RPCParserImpl) Parse

func (RPCrcvr *RPCParserImpl) Parse(RPClex RPCLexer) int

type RPCSymType

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

type Range struct {
	Min, Max int64
}

Range structure repsents the range attribute.

type Scope

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

type ScopedType

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

type Size

type Size struct {
	MinIs  Expr
	MaxIs  Expr
	SizeIs Expr
}

func (Size) Empty

func (d Size) Empty() bool

func (Size) Is

func (d Size) Is() (expr Expr)

type SizeAttr

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

type Struct

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

Struct structure represents the structure type.

func (*Struct) LastField

func (s *Struct) LastField() *Field

LastField function

type Type

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 structure represents the type declaration.

func InterfaceToExport

func InterfaceToExport(iff *Interface) *Type

func LookupType

func LookupType(n string) *Type

func (*Type) Append

func (t *Type) Append(tt *Type) *Type

func (*Type) AppendAfterPointer

func (t *Type) AppendAfterPointer(tt *Type) *Type

func (*Type) Base

func (t *Type) Base() *Type

func (*Type) Is

func (t *Type) Is(kind Kind) bool

Is function returns true if type is of a given kind. Note, that synthetic type `TypeTag` is used to determine if type can be a tagged type.

func (*Type) IsPrimitiveType

func (t *Type) IsPrimitiveType() bool

func (*Type) MarshalJSON

func (a *Type) MarshalJSON() ([]byte, error)

func (*Type) Scopes

func (t *Type) Scopes() []*Scope

Scopes function returns the list types grouped by scope. Within a single scope pointer defaults are applied.

func (*Type) TypeName

func (t *Type) TypeName() string

TypeName function returns the name of the type.

type TypeAttr

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
}

TypeAttr ...

func (*TypeAttr) EnumType

func (t *TypeAttr) EnumType() Kind

func (*TypeAttr) MarshalJSON

func (a *TypeAttr) MarshalJSON() ([]byte, error)

func (*TypeAttr) Merge

func (t *TypeAttr) Merge(tt *TypeAttr) *TypeAttr

func (*TypeAttr) String

func (a *TypeAttr) String() string

type TypeStore

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

TypeStore interface represents the type storage to resolve kind of TypeRef.

type Union

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

Union structure represents the union type.

func (*Union) IsEncapsulated

func (u *Union) IsEncapsulated() bool

type UnionCase

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

UnionCase structure is a union case statement, if Label is nil, this is default case.

func (*UnionCase) String

func (u *UnionCase) String() string

type UnionSwitch

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

UnionSwitch structure represents the union switch (switch_is declaration).

type Usage

type Usage struct {
	ContextHandle bool
	IsString      bool
}

Usage structure represents the field, parameter usage attribute.

func (Usage) String

func (u Usage) String() string

type Version

type Version struct {
	Minor, Major uint16
}

Version structure represents the interface version structure.

func (*Version) String

func (v *Version) String() string