12. AST manipulation library

The AST module implements compilation time reflection for the daScript syntax tree.

All functions and symbols are in “ast” module, use require to get access to it.

require ast

12.1. Type aliases

TypeDeclFlags is a bitfield

field

bit

value

ref

0

1

constant

1

2

temporary

2

4

_implicit

3

8

removeRef

4

16

removeConstant

5

32

removeDim

6

64

removeTemporary

7

128

explicitConst

8

256

aotAlias

9

512

smartPtr

10

1024

smartPtrNative

11

2048

isExplicit

12

4096

isNativeDim

13

8192

properties of the TypeDecl object.

FieldDeclarationFlags is a bitfield

field

bit

value

moveSemantics

0

1

parentType

1

2

capturedConstant

2

4

generated

3

8

capturedRef

4

16

doNotDelete

5

32

privateField

6

64

sealed

7

128

implemented

8

256

properties of the FieldDeclaration object.

StructureFlags is a bitfield

field

bit

value

isClass

0

1

genCtor

1

2

cppLayout

2

4

cppLayoutNotPod

3

8

generated

4

16

persistent

5

32

isLambda

6

64

privateStructure

7

128

macroInterface

8

256

sealed

9

512

properties of the Structure object.

ExprGenFlags is a bitfield

field

bit

value

alwaysSafe

0

1

generated

1

2

userSaidItsSafe

2

4

generation (genFlags) properties of the Expression object.

ExprFlags is a bitfield

field

bit

value

constexpression

0

1

noSideEffects

1

2

noNativeSideEffects

2

4

properties of the Expression object.

ExprPrintFlags is a bitfield

field

bit

value

topLevel

0

1

argLevel

1

2

bottomLevel

2

4

printing properties of the Expression object.

FunctionFlags is a bitfield

field

bit

value

builtIn

0

1

policyBased

1

2

callBased

2

4

interopFn

3

8

hasReturn

4

16

copyOnReturn

5

32

moveOnReturn

6

64

exports

7

128

init

8

256

addr

9

512

used

10

1024

fastCall

11

2048

knownSideEffects

12

4096

hasToRunAtCompileTime

13

8192

unsafeOperation

14

16384

unsafeDeref

15

32768

hasMakeBlock

16

65536

aotNeedPrologue

17

131072

noAot

18

262144

aotHybrid

19

524288

aotTemplate

20

1048576

generated

21

2097152

privateFunction

22

4194304

_generator

23

8388608

_lambda

24

16777216

firstArgReturnType

25

33554432

noPointerCast

26

67108864

isClassMethod

27

134217728

isTypeConstructor

28

268435456

shutdown

29

536870912

anyTemplate

30

1073741824

macroInit

31

-2147483648

properties of the Function object.

MoreFunctionFlags is a bitfield

field

bit

value

macroFunction

0

1

needStringCast

1

2

aotHashDeppendsOnArguments

2

4

additional properties of the Function object.

FunctionSideEffectFlags is a bitfield

field

bit

value

_unsafe

0

1

userScenario

1

2

modifyExternal

2

4

modifyArgument

3

8

accessGlobal

4

16

invoke

5

32

side-effect properties of the Function object.

VariableFlags is a bitfield

field

bit

value

init_via_move

0

1

init_via_clone

1

2

used

2

4

aliasCMRES

3

8

marked_used

4

16

global_shared

5

32

do_not_delete

6

64

generated

7

128

capture_as_ref

8

256

can_shadow

9

512

private_variable

10

1024

properties of the Variable object.

VariableAccessFlags is a bitfield

field

bit

value

access_extern

0

1

access_get

1

2

access_ref

2

4

access_init

3

8

access_pass

4

16

access properties of the Variable object.

ExprBlockFlags is a bitfield

field

bit

value

isClosure

0

1

hasReturn

1

2

copyOnReturn

2

4

moveOnReturn

3

8

inTheLoop

4

16

finallyBeforeBody

5

32

finallyDisabled

6

64

aotSkipMakeBlock

7

128

aotDoNotSkipAnnotationData

8

256

isCollapseable

9

512

needCollapse

10

1024

properties of the ExrpBlock object.

ExprAtFlags is a bitfield

field

bit

value

r2v

0

1

r2cr

1

2

write

2

4

no_promotion

3

8

properties of the ExprAt object.

ExprMakeLocalFlags is a bitfield

field

bit

value

useStackRef

0

1

useCMRES

1

2

doesNotNeedSp

2

4

doesNotNeedInit

3

8

initAllFields

4

16

properties of the ExprMakeLocal object (ExprMakeArray, ExprMakeStruct, ‘ExprMakeTuple’, ‘ExprMakeVariant’).

ExprAscendFlags is a bitfield

field

bit

value

useStackRef

0

1

needTypeInfo

1

2

properties of the ExprAscend object.

ExprCastFlags is a bitfield

field

bit

value

upcastCast

0

1

reinterpretCast

1

2

properties of the ExprCast object.

ExprVarFlags is a bitfield

field

bit

value

local

0

1

argument

1

2

_block

2

4

thisBlock

3

8

r2v

4

16

r2cr

5

32

write

6

64

properties of the ExprVar object.

ExprMakeStructFlags is a bitfield

field

bit

value

useInitializer

0

1

isNewHandle

1

2

properties of the ExprMakeStruct object.

MakeFieldDeclFlags is a bitfield

field

bit

value

moveSemantics

0

1

cloneSemantics

1

2

properties of the MakeFieldDecl object.

ExprFieldDerefFlags is a bitfield

field

bit

value

unsafeDeref

0

1

ignoreCaptureConst

1

2

dereferencing properties of the ExprField object.

ExprFieldFieldFlags is a bitfield

field

bit

value

r2v

0

1

r2cr

1

2

write

2

4

no_promotion

3

8

field properties of the ExprField object.

ExprSwizzleFieldFlags is a bitfield

field

bit

value

r2v

0

1

r2cr

1

2

write

2

4

properties of the ExprSwizzle object.

ExprYieldFlags is a bitfield

field

bit

value

moveSemantics

0

1

properties of the ExprYield object.

ExprReturnFlags is a bitfield

field

bit

value

moveSemantics

0

1

returnReference

1

2

returnInBlock

2

4

takeOverRightStack

3

8

returnCallCMRES

4

16

returnCMRES

5

32

fromYield

6

64

properties of the ExprReturn object.

ExprMakeBlockFlags is a bitfield

field

bit

value

isLambda

0

1

isLocalFunction

1

2

properties of the ExprMakeBlock object.

ExpressionPtr = smart_ptr<ast::Expression>

Smart pointer to Expression object.

ProgramPtr = smart_ptr<rtti::Program>

Smart pointer to Program object.

TypeDeclPtr = smart_ptr<ast::TypeDecl>

Smart pointer to TypeDecl object.

VectorTypeDeclPtr = dasvector`smart_ptr`TypeDecl

Smart pointer to das::vector<ExpressionPtr>.

EnumerationPtr = smart_ptr<ast::Enumeration>

Smart pointer to Enumeration object.

StructurePtr = smart_ptr<ast::Structure>

Smart pointer to Structure object.

FunctionPtr = smart_ptr<ast::Function>

Smart pointer to Function object.

VariablePtr = smart_ptr<ast::Variable>

Smart pointer to Variable object.

MakeFieldDeclPtr = smart_ptr<ast::MakeFieldDecl>

Smart pointer to MakeFieldDecl object.

FunctionAnnotationPtr = smart_ptr<ast::FunctionAnnotation>

Smart pointer to FunctionAnnotation object.

StructureAnnotationPtr = smart_ptr<ast::StructureAnnotation>

Smart pointer to StructureAnnotation object.

EnumerationAnnotationPtr = smart_ptr<ast::EnumerationAnnotation>

Smart pointer to EnumerationAnnotation object.

PassMacroPtr = smart_ptr<ast::PassMacro>

Smart pointer to PassMacro object.

VariantMacroPtr = smart_ptr<ast::VariantMacro>

Smart pointer to VariantMacro object.

ReaderMacroPtr = smart_ptr<ast::ReaderMacro>

Smart pointer to ReaderMacro object.

CommentReaderPtr = smart_ptr<ast::CommentReader>

Smart pointer to CommentReader object.

CallMacroPtr = smart_ptr<ast::CallMacro>

Smart pointer to CallMacro object.

TypeInfoMacroPtr = smart_ptr<ast::TypeInfoMacro>

Smart pointer to TypeInfoMacro object.

12.2. Enumerations

SideEffects

none

0

unsafe

1

userScenario

2

modifyExternal

4

accessExternal

4

modifyArgument

8

modifyArgumentAndExternal

12

worstDefault

12

accessGlobal

16

invoke

32

inferredSideEffects

56

Enumeration with all possible side effects of expression or function.

CaptureMode

capture_any

0

capture_by_copy

1

capture_by_reference

2

capture_by_clone

3

capture_by_move

4

Enumeration with lambda variables capture modes.

12.3. Handled structures

ModuleLibrary

Object which holds list of Module and provides access to them.

Expression

Expression fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Any expression (base class).

TypeDecl

TypeDecl fields are

alias

builtin::das_string

dimExpr

builtin::dasvector`smart_ptr`Expression

annotation

rtti::TypeAnnotation ?

argTypes

builtin::dasvector`smart_ptr`TypeDecl

dim

builtin::dasvector`int

_module

rtti::Module ?

at

rtti::LineInfo

secondType

smart_ptr< ast::TypeDecl >

enumType

ast::Enumeration ?

argNames

builtin::dasvector`das_string

baseType

rtti::Type

firstType

smart_ptr< ast::TypeDecl >

structType

ast::Structure ?

flags

TypeDeclFlags

TypeDecl properties are

isPointer

bool

isCtorType

bool

isVoidPointer

bool

isStructure

bool

isConst

bool

alignOf

int

isGoodArrayType

bool

rangeBaseType

rtti::Type

isVariant

bool

isNoHeapType

bool

isRawPod

bool

canAot

bool

canWrite

bool

isFoldable

bool

isNumericComparable

bool

isEnum

bool

canNew

bool

hasNonTrivialCopy

bool

isPolicyType

bool

vectorBaseType

rtti::Type

isFunction

bool

isAutoOrAlias

bool

vectorDim

int

tupleAlign

int

canBePlacedInContainer

bool

isRef

bool

variantSize

int

hasNonTrivialDtor

bool

isLocal

bool

isBitfield

bool

hasNonTrivialCtor

bool

hasClasses

bool

isGoodLambdaType

bool

isTuple

bool

isAutoArrayResolved

bool

isGoodTupleType

bool

isVectorType

bool

isClass

bool

isVoid

bool

canDelete

bool

isSimpleType

bool

isRefType

bool

isAuto

bool

isGoodTableType

bool

needDelete

bool

isArray

bool

isPod

bool

isHandle

bool

isEnumT

bool

canInitWithZero

bool

canMove

bool

tupleSize

int

isExprType

bool

canDeletePtr

bool

isAotAlias

bool

isShareable

bool

isIndex

bool

isRange

bool

isGoodBlockType

bool

sizeOf

int

isInteger

bool

isVecPolicyType

bool

isAlias

bool

isReturnType

bool

baseSizeOf

int

stride

int

isString

bool

isGoodFunctionType

bool

isGoodVariantType

bool

canCopy

bool

isNumeric

bool

countOf

int

variantAlign

int

isWorkhorseType

bool

isIterator

bool

canClone

bool

Any type declaration.

Structure

Structure fields are

_module

rtti::Module ?

at

rtti::LineInfo

parent

ast::Structure ?

annotations

rtti::AnnotationList

name

builtin::das_string

fields

builtin::dasvector`FieldDeclaration

flags

StructureFlags

Structure declaration.

FieldDeclaration

FieldDeclaration fields are

annotation

rtti::AnnotationArgumentList

at

rtti::LineInfo

name

builtin::das_string

init

smart_ptr< ast::Expression >

offset

int

_type

smart_ptr< ast::TypeDecl >

flags

FieldDeclarationFlags

Structure field declaration.

EnumEntry

EnumEntry fields are

value

smart_ptr< ast::Expression >

at

rtti::LineInfo

name

builtin::das_string

Entry in the enumeration.

Enumeration

Enumeration fields are

_module

rtti::Module ?

at

rtti::LineInfo

isPrivate

bool

cppName

builtin::das_string

list

builtin::dasvector`EnumEntry

annotations

rtti::AnnotationList

name

builtin::das_string

external

bool

baseType

rtti::Type

Enumeration declaration.

Function

Function fields are

arguments

builtin::dasvector`smart_ptr`Variable

fromGeneric

ast::Function ?

result

smart_ptr< ast::TypeDecl >

aotHash

uint64

totalGenLabel

int

_module

rtti::Module ?

index

int

at

rtti::LineInfo

inferStack

builtin::dasvector`InferHistory

body

smart_ptr< ast::Expression >

atDecl

rtti::LineInfo

sideEffectFlags

FunctionSideEffectFlags

annotations

rtti::AnnotationList

totalStackSize

uint

name

builtin::das_string

moreFlags

MoreFunctionFlags

hash

uint64

classParent

rtti::Module ?

flags

FunctionFlags

Function properties are

origin

ast::Function ?

Function declaration.

InferHistory

InferHistory fields are

func

ast::Function ?

at

rtti::LineInfo

Generic function infer history. Contains stack on where the function was first instantiated from (Function and LineInfo pairs).

Variable

Variable fields are

annotation

rtti::AnnotationArgumentList

initStackSize

uint

_module

rtti::Module ?

index

int

at

rtti::LineInfo

stackTop

uint

name

builtin::das_string

init

smart_ptr< ast::Expression >

_aka

builtin::das_string

access_flags

VariableAccessFlags

source

smart_ptr< ast::Expression >

_type

smart_ptr< ast::TypeDecl >

flags

VariableFlags

Variable properties are

isAccessUnused

bool

Variable declaration.

AstContext

AstContext fields are

func

smart_ptr< ast::Function >

scopes

builtin::dasvector`smart_ptr`Expression

blocks

builtin::dasvector`smart_ptr`Expression

_loop

builtin::dasvector`smart_ptr`Expression

_with

builtin::dasvector`smart_ptr`Expression

Lexical context for the particular expression. Contains current function, loops, blocks, scopes, and with sections.

ExprBlock

ExprBlock fields are

stackVarBottom

uint

annotationDataSid

uint64

arguments

builtin::dasvector`smart_ptr`Variable

at

rtti::LineInfo

stackCleanVars

builtin::dasvector`pair`uint`uint

list

builtin::dasvector`smart_ptr`Expression

returnType

smart_ptr< ast::TypeDecl >

printFlags

ExprPrintFlags

annotations

rtti::AnnotationList

stackTop

uint

maxLabelIndex

int

blockFlags

ExprBlockFlags

finalList

builtin::dasvector`smart_ptr`Expression

genFlags

ExprGenFlags

annotationData

uint64

stackVarTop

uint

flags

ExprFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

Any block expression, including regular blocks and all types of closures. For the closures block arguments are defined. Finally section is defined, if exists.

ExprLet

ExprLet fields are

atInit

rtti::LineInfo

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

variables

builtin::dasvector`smart_ptr`Variable

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Local variable declaration (let v = expr;).

ExprStringBuilder

ExprStringBuilder fields are

at

rtti::LineInfo

elements

builtin::dasvector`smart_ptr`Expression

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

String builder expression (“blah{blah1}blah2”).

MakeFieldDecl

MakeFieldDecl fields are

value

smart_ptr< ast::Expression >

at

rtti::LineInfo

name

builtin::das_string

flags

MakeFieldDeclFlags

Part of ExprMakeStruct, declares single field (a = expr or a <- expr etc)

ExprNamedCall

ExprNamedCall fields are

arguments

ast::MakeStruct

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Named call (call([argname1=expr1, argname2=expr2])).

ExprLooksLikeCall

ExprLooksLikeCall fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Anything which looks like call (call(expr1,expr2)).

ExprCallFunc

ExprCallFunc fields are

atEnclosure

rtti::LineInfo

func

ast::Function ?

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

stackTop

uint

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Actual function call (func(expr1,…)).

ExprNew

ExprNew fields are

atEnclosure

rtti::LineInfo

func

ast::Function ?

typeexpr

smart_ptr< ast::TypeDecl >

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

initializer

bool

printFlags

ExprPrintFlags

stackTop

uint

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

New expression (new Foo, new Bar(expr1..), but NOT new [[Foo …]])

ExprCall

ExprCall fields are

atEnclosure

rtti::LineInfo

func

ast::Function ?

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

stackTop

uint

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

doesNotNeedSp

bool

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Anything which looks like call (call(expr1,expr2)).

ExprPtr2Ref

ExprPtr2Ref fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Pointer dereference (*expr or deref(expr)).

ExprNullCoalescing

ExprNullCoalescing fields are

defaultValue

smart_ptr< ast::Expression >

at

rtti::LineInfo

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Null coalescing (expr1 ?? expr2).

ExprAt

ExprAt fields are

index

smart_ptr< ast::Expression >

at

rtti::LineInfo

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

atFlags

ExprAtFlags

Index lookup (expr[expr1]).

ExprSafeAt

ExprSafeAt fields are

index

smart_ptr< ast::Expression >

at

rtti::LineInfo

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

atFlags

ExprAtFlags

Safe index lookup (expr?[expr1]).

ExprIs

ExprIs fields are

typeexpr

smart_ptr< ast::TypeDecl >

at

rtti::LineInfo

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Is expression for variants and such (expr is Foo).

ExprOp

Compilation time only base class for any operator.

ExprOp2

ExprOp2 fields are

right

smart_ptr< ast::Expression >

at

rtti::LineInfo

op

builtin::das_string

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

left

smart_ptr< ast::Expression >

Two operand operator (expr1 + expr2)

ExprOp3

ExprOp3 fields are

right

smart_ptr< ast::Expression >

at

rtti::LineInfo

op

builtin::das_string

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

left

smart_ptr< ast::Expression >

Three operand operator (cond ? expr1 : expr2)

ExprCopy

ExprCopy fields are

takeOverRightStack

bool

right

smart_ptr< ast::Expression >

at

rtti::LineInfo

op

builtin::das_string

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

left

smart_ptr< ast::Expression >

Copy operator (expr1 = expr2)

ExprMove

ExprMove fields are

right

smart_ptr< ast::Expression >

at

rtti::LineInfo

op

builtin::das_string

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

left

smart_ptr< ast::Expression >

Move operator (expr1 <- expr2)

ExprClone

ExprClone fields are

right

smart_ptr< ast::Expression >

at

rtti::LineInfo

op

builtin::das_string

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

left

smart_ptr< ast::Expression >

Clone operator (expr1 := expr2)

ExprWith

ExprWith fields are

at

rtti::LineInfo

body

smart_ptr< ast::Expression >

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_with

smart_ptr< ast::Expression >

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

With section (with expr {your; block; here}).

ExprAssume

ExprAssume fields are

alias

builtin::das_string

at

rtti::LineInfo

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Assume expression (assume name = expr).

ExprWhile

ExprWhile fields are

at

rtti::LineInfo

body

smart_ptr< ast::Expression >

cond

smart_ptr< ast::Expression >

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

While loop (while expr {your; block; here;})

ExprTryCatch

ExprTryCatch fields are

try_block

smart_ptr< ast::Expression >

at

rtti::LineInfo

catch_block

smart_ptr< ast::Expression >

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Try-recover expression (try {your; block; here;} recover {your; recover; here;})

ExprIfThenElse

ExprIfThenElse fields are

at

rtti::LineInfo

if_false

smart_ptr< ast::Expression >

isStatic

bool

cond

smart_ptr< ast::Expression >

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

if_true

smart_ptr< ast::Expression >

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

If-then-else expression (if expr1 {your; block; here;} else {your; block; here;}) including static_if’s.

ExprFor

ExprFor fields are

visibility

rtti::LineInfo

allowIteratorOptimization

bool

canShadow

bool

at

rtti::LineInfo

body

smart_ptr< ast::Expression >

iteratorsAt

builtin::dasvector`LineInfo

printFlags

ExprPrintFlags

iterators

builtin::dasvector`das_string

iteratorVariables

builtin::dasvector`smart_ptr`Variable

genFlags

ExprGenFlags

iteratorsAka

builtin::dasvector`das_string

sources

builtin::dasvector`smart_ptr`Expression

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

For loop (for expr1 in expr2 {your; block; here;})

ExprMakeLocal

ExprMakeLocal fields are

makeType

smart_ptr< ast::TypeDecl >

at

rtti::LineInfo

printFlags

ExprPrintFlags

makeFlags

ExprMakeLocalFlags

stackTop

uint

extraOffset

uint

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Any make expression (ExprMakeBlock, ExprMakeTuple, ExprMakeVariant, ExprMakeStruct)

ExprMakeStruct

ExprMakeStruct fields are

makeType

smart_ptr< ast::TypeDecl >

at

rtti::LineInfo

structs

builtin::dasvector`smart_ptr`MakeStruct

printFlags

ExprPrintFlags

makeFlags

ExprMakeLocalFlags

stackTop

uint

extraOffset

uint

genFlags

ExprGenFlags

_block

smart_ptr< ast::Expression >

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

makeStructFlags

ExprMakeStructFlags

Make structure expression ([[YourStruct v1=expr1elem1, v2=expr2elem1, …; v1=expr1elem2, … ]])

ExprMakeVariant

ExprMakeVariant fields are

variants

builtin::dasvector`smart_ptr`MakeFieldDecl

makeType

smart_ptr< ast::TypeDecl >

at

rtti::LineInfo

printFlags

ExprPrintFlags

makeFlags

ExprMakeLocalFlags

stackTop

uint

extraOffset

uint

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Make variant expression ([YourVariant variantName=expr1])

ExprMakeArray

ExprMakeArray fields are

makeType

smart_ptr< ast::TypeDecl >

values

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

recordType

smart_ptr< ast::TypeDecl >

printFlags

ExprPrintFlags

makeFlags

ExprMakeLocalFlags

stackTop

uint

extraOffset

uint

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Make array expression ([[auto 1;2;3]] or [{auto “foo”;”bar”}] for static and dynamic arrays accordingly).

ExprMakeTuple

ExprMakeTuple fields are

makeType

smart_ptr< ast::TypeDecl >

values

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

recordType

smart_ptr< ast::TypeDecl >

printFlags

ExprPrintFlags

makeFlags

ExprMakeLocalFlags

stackTop

uint

extraOffset

uint

genFlags

ExprGenFlags

isKeyValue

bool

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Make tuple expression ([[auto f1,f2,f3]])

ExprArrayComprehension

ExprArrayComprehension fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

generatorSyntax

bool

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

exprFor

smart_ptr< ast::Expression >

exprWhere

smart_ptr< ast::Expression >

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Array comprehension ([{for x in 0..3; x}], [[for y in range(100); x*2; where x!=13]] for arrays or generators accordingly).

TypeInfoMacro

TypeInfoMacro fields are

_module

rtti::Module ?

name

builtin::das_string

Compilation time only structure which holds live information about typeinfo expression for the specific macro.

ExprTypeInfo

ExprTypeInfo fields are

typeexpr

smart_ptr< ast::TypeDecl >

extratrait

builtin::das_string

macro

ast::TypeInfoMacro ?

subtrait

builtin::das_string

at

rtti::LineInfo

trait

builtin::das_string

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

typeinfo() expression (typeinfo(dim a), typeinfo(is_ref_type type<int&>))

ExprTypeDecl

ExprTypeDecl fields are

typeexpr

smart_ptr< ast::TypeDecl >

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

typedecl() expression (typedecl(1+2))

ExprLabel

ExprLabel fields are

comment

builtin::das_string

at

rtti::LineInfo

labelName

int

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Label (label 13:)

ExprGoto

ExprGoto fields are

at

rtti::LineInfo

labelName

int

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Goto expression (goto label 13, goto x)

ExprRef2Value

ExprRef2Value fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Compilation time only structure which holds reference to value conversion for the value types, i.e. goes from int& to int and such.

ExprRef2Ptr

ExprRef2Ptr fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Addr expresion (addr(expr))

ExprAddr

ExprAddr fields are

func

ast::Function ?

target

builtin::das_string

at

rtti::LineInfo

funcType

smart_ptr< ast::TypeDecl >

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Function address (@@foobarfunc or @@foobarfunc<(int;int):bool>)

ExprAssert

ExprAssert fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

isVerify

bool

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Assert expression (assert(x<13) or assert(x<13, “x is too big”))

ExprQuote

ExprQuote fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Compilation time expression which holds its subexpressions but does not infer them (quote() <| x+5)

ExprStaticAssert

ExprStaticAssert fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Static assert expression (static_assert(x<13) or static_assert(x<13, “x is too big”))

ExprDebug

ExprDebug fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Debug expression (debug(x) or debug(x,”x=”))

ExprInvoke

ExprInvoke fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

stackTop

uint

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

isInvokeMethod

bool

doesNotNeedSp

bool

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Invoke expression (invoke(fn) or invoke(lamb, arg1, arg2, …))

ExprErase

ExprErase fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Erase expression (erase(tab,key))

ExprFind

ExprFind fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Find expression (find(tab,key) <| { your; block; here; })

ExprKeyExists

ExprKeyExists fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Key exists expression (key_exists(tab,key))

ExprAscend

ExprAscend fields are

ascType

smart_ptr< ast::TypeDecl >

at

rtti::LineInfo

printFlags

ExprPrintFlags

stackTop

uint

ascendFlags

ExprAscendFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

New expression for ExprMakeLocal (new [[Foo fld=val,…]] or new [[Foo() fld=…]], but NOT new Foo())

ExprCast

ExprCast fields are

castFlags

ExprCastFlags

at

rtti::LineInfo

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

castType

smart_ptr< ast::TypeDecl >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Any cast expression (cast<int> a, upcast<Foo> b or reinterpret<Bar?> c)

ExprDelete

ExprDelete fields are

at

rtti::LineInfo

native

bool

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Delete expression (delete blah)

ExprVar

ExprVar fields are

at

rtti::LineInfo

variable

smart_ptr< ast::Variable >

varFlags

ExprVarFlags

printFlags

ExprPrintFlags

argumentIndex

int

name

builtin::das_string

genFlags

ExprGenFlags

pBlock

ast::ExprBlock ?

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Variable access (foo)

ExprSwizzle

ExprSwizzle fields are

value

smart_ptr< ast::Expression >

at

rtti::LineInfo

fieldFlags

ExprSwizzleFieldFlags

mask

builtin::das_string

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

fields

builtin::dasvector`uint8

Vector swizzle operatrion (vec.xxy or vec.y)

ExprField

ExprField fields are

annotation

smart_ptr< rtti::TypeAnnotation >

value

smart_ptr< ast::Expression >

at

rtti::LineInfo

fieldIndex

int

fieldFlags

ExprFieldFieldFlags

field

ast::FieldDeclaration const? const

derefFlags

ExprFieldDerefFlags

printFlags

ExprPrintFlags

name

builtin::das_string

atField

rtti::LineInfo

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Field lookup (foo.bar)

ExprSafeField

ExprSafeField fields are

annotation

smart_ptr< rtti::TypeAnnotation >

value

smart_ptr< ast::Expression >

at

rtti::LineInfo

fieldIndex

int

fieldFlags

ExprFieldFieldFlags

field

ast::FieldDeclaration const? const

skipQQ

bool

derefFlags

ExprFieldDerefFlags

printFlags

ExprPrintFlags

name

builtin::das_string

atField

rtti::LineInfo

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Safe field lookup (foo?.bar)

ExprIsVariant

ExprIsVariant fields are

annotation

smart_ptr< rtti::TypeAnnotation >

value

smart_ptr< ast::Expression >

at

rtti::LineInfo

fieldIndex

int

fieldFlags

ExprFieldFieldFlags

field

ast::FieldDeclaration const? const

derefFlags

ExprFieldDerefFlags

printFlags

ExprPrintFlags

name

builtin::das_string

atField

rtti::LineInfo

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Is expression (foo is bar)

ExprAsVariant

ExprAsVariant fields are

annotation

smart_ptr< rtti::TypeAnnotation >

value

smart_ptr< ast::Expression >

at

rtti::LineInfo

fieldIndex

int

fieldFlags

ExprFieldFieldFlags

field

ast::FieldDeclaration const? const

derefFlags

ExprFieldDerefFlags

printFlags

ExprPrintFlags

name

builtin::das_string

atField

rtti::LineInfo

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

As expression (foo as bar)

ExprSafeAsVariant

ExprSafeAsVariant fields are

annotation

smart_ptr< rtti::TypeAnnotation >

value

smart_ptr< ast::Expression >

at

rtti::LineInfo

fieldIndex

int

fieldFlags

ExprFieldFieldFlags

field

ast::FieldDeclaration const? const

skipQQ

bool

derefFlags

ExprFieldDerefFlags

printFlags

ExprPrintFlags

name

builtin::das_string

atField

rtti::LineInfo

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Safe as expression (foo? as bar)

ExprOp1

ExprOp1 fields are

at

rtti::LineInfo

op

builtin::das_string

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Single operator expression (+a or -a or !a or ~a)

ExprReturn

ExprReturn fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

stackTop

uint

subexpr

smart_ptr< ast::Expression >

block

ast::ExprBlock ?

genFlags

ExprGenFlags

refStackTop

uint

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

returnFlags

ExprReturnFlags

__rtti

string const

Return expression (return or return foo, or return <- foo)

ExprYield

ExprYield fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

returnFlags

ExprYieldFlags

Yield expression (yield foo or yeild <- bar)

ExprBreak

ExprBreak fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Break expression (break)

ExprContinue

ExprContinue fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Continue expression (continue)

ExprConst

ExprConst fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Compilation time constant expression base class

ExprFakeContext

ExprFakeContext fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Compilation time only fake context expression. Will simulate as current evaluation Context.

ExprFakeLineInfo

ExprFakeLineInfo fields are

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Compilation time only fake lineinfo expression. Will simulate as current file and line LineInfo.

ExprConstPtr

ExprConstPtr fields are

value

void?

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Null (null). Technically can be any other pointer, but it is used for nullptr.

ExprConstInt8

ExprConstInt8 fields are

value

int8

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds int8 constant.

ExprConstInt16

ExprConstInt16 fields are

value

int16

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds int16 constant.

ExprConstInt64

ExprConstInt64 fields are

value

int64

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds int64 constant.

ExprConstInt

ExprConstInt fields are

value

int

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds int constant.

ExprConstInt2

ExprConstInt2 fields are

value

int2

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds int2 constant.

ExprConstInt3

ExprConstInt3 fields are

value

int3

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds int3 constant.

ExprConstInt4

ExprConstInt4 fields are

value

int4

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds int4 constant.

ExprConstUInt8

ExprConstUInt8 fields are

value

uint8

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds uint8 constant.

ExprConstUInt16

ExprConstUInt16 fields are

value

uint16

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds uint16 constant.

ExprConstUInt64

ExprConstUInt64 fields are

value

uint64

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds uint64 constant.

ExprConstUInt

ExprConstUInt fields are

value

uint

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds uint constant.

ExprConstUInt2

ExprConstUInt2 fields are

value

uint2

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds uint2 constant.

ExprConstUInt3

ExprConstUInt3 fields are

value

uint3

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds uint3 constant.

ExprConstUInt4

ExprConstUInt4 fields are

value

uint4

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds uint4 constant.

ExprConstRange

ExprConstRange fields are

value

range

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds range constant.

ExprConstURange

ExprConstURange fields are

value

urange

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds urange constant.

ExprConstFloat

ExprConstFloat fields are

value

float

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds float constant.

ExprConstFloat2

ExprConstFloat2 fields are

value

float2

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds float2 constant.

ExprConstFloat3

ExprConstFloat3 fields are

value

float3

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds float3 constant.

ExprConstFloat4

ExprConstFloat4 fields are

value

float4

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds float4 constant.

ExprConstDouble

ExprConstDouble fields are

value

double

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds double constant.

ExprConstBool

ExprConstBool fields are

value

bool

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds bool constant.

CaptureEntry

CaptureEntry fields are

name

builtin::das_string

mode

ast::CaptureMode

Single entry in lambda capture.

ExprMakeBlock

ExprMakeBlock fields are

mmFlags

ExprMakeBlockFlags

at

rtti::LineInfo

capture

builtin::dasvector`CaptureEntry

printFlags

ExprPrintFlags

stackTop

uint

genFlags

ExprGenFlags

_block

smart_ptr< ast::Expression >

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Any closure. Holds block as well as capture information in CaptureEntry.

ExprMakeGenerator

ExprMakeGenerator fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

capture

builtin::dasvector`CaptureEntry

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

iterType

smart_ptr< ast::TypeDecl >

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Generator closure (generator<int> or generator<Foo&>)

ExprMemZero

ExprMemZero fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Memzero (memzero(expr))

ExprConstEnumeration

ExprConstEnumeration fields are

value

builtin::das_string

at

rtti::LineInfo

printFlags

ExprPrintFlags

enumType

smart_ptr< ast::Enumeration >

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Holds enumeration constant, both type and entry (Foo bar).

ExprConstBitfield

ExprConstBitfield fields are

value

bitfield<>

at

rtti::LineInfo

bitfieldType

smart_ptr< ast::TypeDecl >

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Holds bitfield constant (Foo bar).

ExprConstString

ExprConstString fields are

value

builtin::das_string

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

baseType

rtti::Type

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Holds string constant.

ExprUnsafe

ExprUnsafe fields are

at

rtti::LineInfo

body

smart_ptr< ast::Expression >

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Unsafe expression (unsafe(addr(x)))

VisitorAdapter

Adapter for the AstVisitor interface.

FunctionAnnotation

Adapter for the AstFunctionAnnotation.

StructureAnnotation

Adapter for the AstStructureAnnotation.

EnumerationAnnotation

Adapater for the AstEnumearationAnnotation.

PassMacro

PassMacro fields are

name

builtin::das_string

Adapter for the AstPassMacro.

ReaderMacro

ReaderMacro fields are

_module

rtti::Module ?

name

builtin::das_string

Adapter for the AstReaderMacro.

CommentReader

Adpater for the AstCommentReader.

CallMacro

CallMacro fields are

_module

rtti::Module ?

name

builtin::das_string

Adapter for the AstCallMacro.

VariantMacro

VariantMacro fields are

name

builtin::das_string

Adapater for the AstVariantMacro.

ExprReader

ExprReader fields are

macro

smart_ptr< ast::ReaderMacro >

sequence

builtin::das_string

at

rtti::LineInfo

printFlags

ExprPrintFlags

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

Compilation time only expression which holds temporary information for the AstReaderMacro.

ExprCallMacro

ExprCallMacro fields are

atEnclosure

rtti::LineInfo

arguments

builtin::dasvector`smart_ptr`Expression

macro

ast::CallMacro ?

at

rtti::LineInfo

printFlags

ExprPrintFlags

name

builtin::das_string

argumentsFailedToInfer

bool

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

flags

ExprFlags

__rtti

string const

Compilation time only expression which holds temporary infromation for the AstCallMacro.

12.4. Call macros

quote

Returns ast expression tree of the input, without evaluating or infering it. This is useful for macros which generate code as a shortcut for generating boilerplate code.

12.5. Typeinfo macros

ast_typedecl

|typeinfo_macro-ast-ast_typedecl|

ast_function

|typeinfo_macro-ast-ast_function|

12.6. Handled types

MakeStruct

Part of ExprMakeStruct, happens to be vector of MakeFieldDecl.

12.7. Classes

AstFunctionAnnotation

Annotation macro which is attached to the Function.

it defines as follows

AstFunctionAnnotation.transform(self: AstFunctionAnnotation; call: smart_ptr<ast::ExprCallFunc>; errors: das_string)

transform returns ExpressionPtr

argument

argument type

self

ast::AstFunctionAnnotation

call

smart_ptr< ast::ExprCallFunc >

errors

builtin::das_string

This callback occurs during the infer pass of the compilation. If no transformation is needed, the callback should return null. errors is filled with the transformation errors should they occur. Returned value replaces function call in the ast.

AstFunctionAnnotation.verifyCall(self: AstFunctionAnnotation; call: smart_ptr<ast::ExprCallFunc>; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string)

verifyCall returns bool

argument

argument type

self

ast::AstFunctionAnnotation

call

smart_ptr< ast::ExprCallFunc >

args

rtti::AnnotationArgumentList const

progArgs

rtti::AnnotationArgumentList const

errors

builtin::das_string

This callback occurs during the lint pass of the compilation. If call has lint errors it should return false and errors is filled with the lint errors.

AstFunctionAnnotation.apply(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

apply returns bool

argument

argument type

self

ast::AstFunctionAnnotation

func

FunctionPtr

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

errors

builtin::das_string

This callback occurs during the parse pass of the compilation on the function itself. If function has application errors it should return false and errors field.

AstFunctionAnnotation.finish(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string)

finish returns bool

argument

argument type

self

ast::AstFunctionAnnotation

func

FunctionPtr

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

progArgs

rtti::AnnotationArgumentList const

errors

builtin::das_string

This callback occurs during the finalize allocations pass of the compilation, after the stack is allocated, on the function itself. If function has finalization errors it should return false and errors field.

AstFunctionAnnotation.patch(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string; astChanged: bool&)

patch returns bool

argument

argument type

self

ast::AstFunctionAnnotation

func

FunctionPtr

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

progArgs

rtti::AnnotationArgumentList const

errors

builtin::das_string

astChanged

bool&

This callback occurs right after the infer pass of the compilation on the function itself. If function has patching errors it should return false and errors field. If the astChanged flag is set, infer pass will be repeated. This allows to fix up the function after the infer pass with all the type information fully available.

AstFunctionAnnotation.fixup(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string)

fixup returns bool

argument

argument type

self

ast::AstFunctionAnnotation

func

FunctionPtr

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

progArgs

rtti::AnnotationArgumentList const

errors

builtin::das_string

This callback occurs during the finalize allocations pass of the compilation, before the stack is allocated, on the function itself. If function has fixup errors it should return false and errors field.

AstFunctionAnnotation.lint(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string)

lint returns bool

argument

argument type

self

ast::AstFunctionAnnotation

func

FunctionPtr

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

progArgs

rtti::AnnotationArgumentList const

errors

builtin::das_string

This callback occurs during the lint pass of the compilation on the function itself. If function has lint errors it should return false and errors field.

AstFunctionAnnotation.complete(self: AstFunctionAnnotation; func: FunctionPtr; ctx: smart_ptr<rtti::Context>)

argument

argument type

self

ast::AstFunctionAnnotation

func

FunctionPtr

ctx

smart_ptr< rtti::Context >

This callback occurs as the final stage of Context simulation.

AstFunctionAnnotation.isCompatible(self: AstFunctionAnnotation; func: FunctionPtr; types: VectorTypeDeclPtr; decl: AnnotationDeclaration const; errors: das_string)

isCompatible returns bool

argument

argument type

self

ast::AstFunctionAnnotation

func

FunctionPtr

types

VectorTypeDeclPtr

decl

rtti::AnnotationDeclaration const

errors

builtin::das_string

This callback occurs during function type matching for both generic and regular functions. If function can accept given argument types it should return true, otherwise errors is filled with the matching problems.

AstFunctionAnnotation.isSpecialized(self: AstFunctionAnnotation)

isSpecialized returns bool

This callback occurs during function type matching. If function requires special type matching (i.e. isCompatible` is implemented) it should return true.

AstBlockAnnotation

Annotation macro which is attached to the ExprBlock.

it defines as follows

AstBlockAnnotation.apply(self: AstBlockAnnotation; blk: smart_ptr<ast::ExprBlock>; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

apply returns bool

argument

argument type

self

ast::AstBlockAnnotation

blk

smart_ptr< ast::ExprBlock >

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

errors

builtin::das_string

This callback occurs during the parse pass of the compilation. If block has application errors it should return false and errors field.

AstBlockAnnotation.finish(self: AstBlockAnnotation; blk: smart_ptr<ast::ExprBlock>; group: ModuleGroup; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string)

finish returns bool

argument

argument type

self

ast::AstBlockAnnotation

blk

smart_ptr< ast::ExprBlock >

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

progArgs

rtti::AnnotationArgumentList const

errors

builtin::das_string

This callback occurs during the finalize allocations pass of the compilation, after the stack is allocated. If block has finalization errors it should return false and errors field.

AstStructureAnnotation

Annotation macro which is attached to the Structure.

it defines as follows

AstStructureAnnotation.apply(self: AstStructureAnnotation; st: StructurePtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

apply returns bool

argument

argument type

self

ast::AstStructureAnnotation

st

StructurePtr

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

errors

builtin::das_string

This callback occurs during the parse pass of the compilation. If structure has application errors it should return false and errors field.

AstStructureAnnotation.finish(self: AstStructureAnnotation; st: StructurePtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

finish returns bool

argument

argument type

self

ast::AstStructureAnnotation

st

StructurePtr

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

errors

builtin::das_string

This callback occurs during the finalize allocations pass of the compilation, after the stack is allocated. If structure has finalization errors it should return false and errors field.

AstStructureAnnotation.patch(self: AstStructureAnnotation; st: StructurePtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string; astChanged: bool&)

patch returns bool

argument

argument type

self

ast::AstStructureAnnotation

st

StructurePtr

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

errors

builtin::das_string

astChanged

bool&

This callback occurs right after the infer pass of the compilation on the structure itself. If structure has patching errors it should return false and errors field. If the astChanged flag is set, infer pass will be repeated. This allows to fix up the function after the infer pass with all the type information fully available.

AstStructureAnnotation.complete(self: AstStructureAnnotation; st: StructurePtr; ctx: smart_ptr<rtti::Context>)

argument

argument type

self

ast::AstStructureAnnotation

st

StructurePtr

ctx

smart_ptr< rtti::Context >

This callback occurs as the final stage of Context simulation.

AstPassMacro

This macro is used to implement custom infer passes.

it defines as follows

AstPassMacro.apply(self: AstPassMacro; prog: ProgramPtr; mod: rtti::Module? const)

apply returns bool

argument

argument type

self

ast::AstPassMacro

prog

ProgramPtr

mod

rtti::Module ? const

This callback is called after infer pass. If macro did any work it returns true; infer pass is restarted a the memoent when first macro which did any work.

AstVariantMacro

This macro is used to implement custom is, as and ?as expressions.

it defines as follows

AstVariantMacro.visitExprIsVariant(self: AstVariantMacro; prog: ProgramPtr; mod: rtti::Module? const; expr: smart_ptr<ast::ExprIsVariant> const)

visitExprIsVariant returns ExpressionPtr

argument

argument type

self

ast::AstVariantMacro

prog

ProgramPtr

mod

rtti::Module ? const

expr

smart_ptr< ast::ExprIsVariant > const

This callback occurs during the infer pass for every ExprIsVariant (a is b). If no work is necessary it should return null, otherwise expression will be replaced by the result.

AstVariantMacro.visitExprAsVariant(self: AstVariantMacro; prog: ProgramPtr; mod: rtti::Module? const; expr: smart_ptr<ast::ExprAsVariant> const)

visitExprAsVariant returns ExpressionPtr

argument

argument type

self

ast::AstVariantMacro

prog

ProgramPtr

mod

rtti::Module ? const

expr

smart_ptr< ast::ExprAsVariant > const

This callback occurs during the infer pass for every ExprAsVariant (a as b). If no work is necessary it should return null, otherwise expression will be replaced by the result.

AstVariantMacro.visitExprSafeAsVariant(self: AstVariantMacro; prog: ProgramPtr; mod: rtti::Module? const; expr: smart_ptr<ast::ExprSafeAsVariant> const)

visitExprSafeAsVariant returns ExpressionPtr

argument

argument type

self

ast::AstVariantMacro

prog

ProgramPtr

mod

rtti::Module ? const

expr

smart_ptr< ast::ExprSafeAsVariant > const

This callback occurs during the infer pass for every ExprSafeIsVariant (a ?as b). If no work is necessary it should return null, otherwise expression will be replaced by the result.

AstReaderMacro

This macro is used to implement custom parsing functionality, i.e. anything starting with %NameOfTheMacro~ and ending when the macro says it ends.

it defines as follows

AstReaderMacro.accept(self: AstReaderMacro; prog: ProgramPtr; mod: rtti::Module? const; expr: ast::ExprReader? const; ch: int const; info: LineInfo const)

accept returns bool

argument

argument type

self

ast::AstReaderMacro

prog

ProgramPtr

mod

rtti::Module ? const

expr

ast::ExprReader ? const

ch

int const

info

rtti::LineInfo const

This callback occurs during the parse pass for every character. When the macro is done with the input (i.e. recognizeable input ends) it should return false. Typically characters are appended to the expr.sequence inside the ExprReader.

AstReaderMacro.visit(self: AstReaderMacro; prog: ProgramPtr; mod: rtti::Module? const; expr: smart_ptr<ast::ExprReader> const)

visit returns ExpressionPtr

argument

argument type

self

ast::AstReaderMacro

prog

ProgramPtr

mod

rtti::Module ? const

expr

smart_ptr< ast::ExprReader > const

This callback occurs during the infer pass for every instance of ExprReader for that specific macro. Macro needs to convert ExprReader to some meaningful expression.

AstCommentReader

This macro is used to implement custom comment parsing function (such as doxygen-style documentation etc).

it defines as follows

AstCommentReader.open(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; cpp: bool const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

cpp

bool const

info

rtti::LineInfo const

This callback occurs during the parse pass for every // or /* sequence which indicated begining of the comment section.

AstCommentReader.accept(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; ch: int const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

ch

int const

info

rtti::LineInfo const

This callback occurs during the parse pass for every character in the comment section.

AstCommentReader.close(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass for every new line or */ sequence which indicates end of the comment section.

AstCommentReader.beforeStructure(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass before the structure body block.

AstCommentReader.afterStructure(self: AstCommentReader; st: StructurePtr; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

st

StructurePtr

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass after the structure body block.

AstCommentReader.beforeStructureFields(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass before the first structure field is declared.

AstCommentReader.afterStructureField(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

name

string const

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass after the structure field is declared (after the following comment section, should it have one).

AstCommentReader.afterStructureFields(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass after the last structure field is declared.

AstCommentReader.beforeFunction(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass before the function body block.

AstCommentReader.afterFunction(self: AstCommentReader; fn: FunctionPtr; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

fn

FunctionPtr

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass after the function body block.

AstCommentReader.beforeGlobalVariables(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass before the first global variable declaration but after let or var keyword.

AstCommentReader.afterGlobalVariable(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

name

string const

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass after global variable is declaraed (after the following comment section, should it have one).

AstCommentReader.afterGlobalVariables(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass after every global variable in the declaration is declared.

AstCommentReader.beforeVariant(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse pass before the variant alias declaration.

AstCommentReader.afterVariant(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

name

string const

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse after the variant alias declaration.

AstCommentReader.beforeEnumeration(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse before the enumeration declaration.

AstCommentReader.afterEnumeration(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

name

string const

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

This callback occurs during the parse after the enumeration declaration.

AstCommentReader.beforeAlias(self: AstCommentReader; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

|method-ast-AstCommentReader.beforeAlias|

AstCommentReader.afterAlias(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: rtti::Module? const; info: LineInfo const)

argument

argument type

self

ast::AstCommentReader

name

string const

prog

ProgramPtr

mod

rtti::Module ? const

info

rtti::LineInfo const

|method-ast-AstCommentReader.afterAlias|

AstCallMacro

This macro is used to implement custom call-like expressions ( like foo(bar,bar2,…) ).

it defines as follows

AstCallMacro.preVisit(self: AstCallMacro; prog: ProgramPtr; mod: rtti::Module? const; expr: smart_ptr<ast::ExprCallMacro> const)

argument

argument type

self

ast::AstCallMacro

prog

ProgramPtr

mod

rtti::Module ? const

expr

smart_ptr< ast::ExprCallMacro > const

This callback occurs during the infer pass for every ExprCallMacro, before its arguments are inferred.

AstCallMacro.visit(self: AstCallMacro; prog: ProgramPtr; mod: rtti::Module? const; expr: smart_ptr<ast::ExprCallMacro> const)

visit returns ExpressionPtr

argument

argument type

self

ast::AstCallMacro

prog

ProgramPtr

mod

rtti::Module ? const

expr

smart_ptr< ast::ExprCallMacro > const

This callback occurs during the infer pass for every ExprCallMacro, after its arguments are inferred. When fully inferred macro is expected to replace ExprCallMacro with meaningful expression.

AstTypeInfoMacro

This macro is used to implement type info traits, i.e. typeinfo(YourTraitHere …) expressions.

it defines as follows

AstTypeInfoMacro.getAstChange(self: AstTypeInfoMacro; expr: smart_ptr<ast::ExprTypeInfo> const; errors: das_string)

getAstChange returns ExpressionPtr

argument

argument type

self

ast::AstTypeInfoMacro

expr

smart_ptr< ast::ExprTypeInfo > const

errors

builtin::das_string

This callback occurs during the infer pass. If no changes are necessary it should return null, otherwise expression will be replaced by the result. errors should be filled if trait is malformed.

AstTypeInfoMacro.getAstType(self: AstTypeInfoMacro; lib: ModuleLibrary; expr: smart_ptr<ast::ExprTypeInfo> const; errors: das_string)

getAstType returns TypeDeclPtr

argument

argument type

self

ast::AstTypeInfoMacro

lib

ast::ModuleLibrary

expr

smart_ptr< ast::ExprTypeInfo > const

errors

builtin::das_string

This callback occurs during the infer pass. It should return type of the typeinfo expression. That way trait can return Type, and not Expression.

AstEnumerationAnnotation

Annotation macro which is attached to Enumeration.

it defines as follows

AstEnumerationAnnotation.apply(self: AstEnumerationAnnotation; st: EnumerationPtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

apply returns bool

argument

argument type

self

ast::AstEnumerationAnnotation

st

EnumerationPtr

group

rtti::ModuleGroup

args

rtti::AnnotationArgumentList const

errors

builtin::das_string

This callback occurs during the parse pass. If any errors occur errors should be filled and false should be returned.

AstVisitor

This class implements Visitor interface for the ast tree. For typical expression two methods are provided: preVisitExpr and visitExpr. preVisitExpr occurs before the subexpressions are visited, and visitExpr occurs after the subexpressions are visited. visitExpr can return new expression which will replace the original one, or original expression - if no changes are necessary. There are other potential callbacks deppending of the nature of expression, which represent particular sections of the ast tree. Additionally ‘preVisitExpression’ and visitExpression are called before and after expression specific callbacks.

it defines as follows

AstVisitor.preVisitProgram(self: AstVisitor; prog: ProgramPtr)

argument

argument type

self

ast::AstVisitor

prog

ProgramPtr

before entire program, put your initialization there.

AstVisitor.visitProgram(self: AstVisitor; porg: ProgramPtr)

argument

argument type

self

ast::AstVisitor

porg

ProgramPtr

after entire program, put your finalizers there.

AstVisitor.preVisitProgramBody(self: AstVisitor; prog: ProgramPtr; mod: rtti::Module? const)

argument

argument type

self

ast::AstVisitor

prog

ProgramPtr

mod

rtti::Module ? const

after enumerations, structures, and aliases, but before global variables, generics and functions.

AstVisitor.preVisitTypeDecl(self: AstVisitor; typ: TypeDeclPtr)

argument

argument type

self

ast::AstVisitor

typ

TypeDeclPtr

before a type declaration anywhere. yor type validation code typically goes here

AstVisitor.visitTypeDecl(self: AstVisitor; typ: TypeDeclPtr)

visitTypeDecl returns TypeDeclPtr

argument

argument type

self

ast::AstVisitor

typ

TypeDeclPtr

after a type declaration

AstVisitor.preVisitAlias(self: AstVisitor; typ: TypeDeclPtr; name: das_string const)

argument

argument type

self

ast::AstVisitor

typ

TypeDeclPtr

name

builtin::das_string const

before TypeDecl

AstVisitor.visitAlias(self: AstVisitor; typ: TypeDeclPtr; name: das_string const)

visitAlias returns TypeDeclPtr

argument

argument type

self

ast::AstVisitor

typ

TypeDeclPtr

name

builtin::das_string const

after TypeDecl

AstVisitor.canVisitEnumeration(self: AstVisitor; arg: ast::Enumeration? const)

canVisitEnumeration returns bool

argument

argument type

self

ast::AstVisitor

arg

ast::Enumeration ? const

if true Enumeration will be visited

AstVisitor.preVisitEnumeration(self: AstVisitor; enu: EnumerationPtr)

argument

argument type

self

ast::AstVisitor

enu

EnumerationPtr

before Enumeration

AstVisitor.preVisitEnumerationValue(self: AstVisitor; enu: EnumerationPtr; name: das_string const; value: ExpressionPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

enu

EnumerationPtr

name

builtin::das_string const

value

ExpressionPtr

last

bool const

before every enumeration entry

AstVisitor.visitEnumerationValue(self: AstVisitor; enu: EnumerationPtr; name: das_string const; value: ExpressionPtr; last: bool const)

visitEnumerationValue returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

enu

EnumerationPtr

name

builtin::das_string const

value

ExpressionPtr

last

bool const

after every enumeration entry

AstVisitor.visitEnumeration(self: AstVisitor; enu: EnumerationPtr)

visitEnumeration returns EnumerationPtr

argument

argument type

self

ast::AstVisitor

enu

EnumerationPtr

after Enumeration

AstVisitor.canVisitStructure(self: AstVisitor; arg: ast::Structure? const)

canVisitStructure returns bool

argument

argument type

self

ast::AstVisitor

arg

ast::Structure ? const

if true Structure will be visited

AstVisitor.preVisitStructure(self: AstVisitor; str: StructurePtr)

argument

argument type

self

ast::AstVisitor

str

StructurePtr

before Structure

AstVisitor.preVisitStructureField(self: AstVisitor; str: StructurePtr; decl: FieldDeclaration const; last: bool const)

argument

argument type

self

ast::AstVisitor

str

StructurePtr

decl

ast::FieldDeclaration const

last

bool const

before every structure field

AstVisitor.visitStructureField(self: AstVisitor; str: StructurePtr; decl: FieldDeclaration const; last: bool const)

argument

argument type

self

ast::AstVisitor

str

StructurePtr

decl

ast::FieldDeclaration const

last

bool const

after every structure field

AstVisitor.visitStructure(self: AstVisitor; str: StructurePtr)

visitStructure returns StructurePtr

argument

argument type

self

ast::AstVisitor

str

StructurePtr

after Structure

AstVisitor.canVisitFunction(self: AstVisitor; fun: ast::Function? const)

canVisitFunction returns bool

argument

argument type

self

ast::AstVisitor

fun

ast::Function ? const

if true Function will be visited

AstVisitor.canVisitFunctionArgumentInit(self: AstVisitor; fun: ast::Function? const; arg: VariablePtr; value: ExpressionPtr)

canVisitFunctionArgumentInit returns bool

argument

argument type

self

ast::AstVisitor

fun

ast::Function ? const

arg

VariablePtr

value

ExpressionPtr

if true function argument initialization expressions will be visited

AstVisitor.preVisitFunction(self: AstVisitor; fun: FunctionPtr)

argument

argument type

self

ast::AstVisitor

fun

FunctionPtr

before Function

AstVisitor.visitFunction(self: AstVisitor; fun: FunctionPtr)

visitFunction returns FunctionPtr

argument

argument type

self

ast::AstVisitor

fun

FunctionPtr

after Function

AstVisitor.preVisitFunctionArgument(self: AstVisitor; fun: FunctionPtr; arg: VariablePtr; lastArg: bool const)

argument

argument type

self

ast::AstVisitor

fun

FunctionPtr

arg

VariablePtr

lastArg

bool const

before every argument

AstVisitor.visitFunctionArgument(self: AstVisitor; fun: FunctionPtr; arg: VariablePtr; lastArg: bool const)

visitFunctionArgument returns VariablePtr

argument

argument type

self

ast::AstVisitor

fun

FunctionPtr

arg

VariablePtr

lastArg

bool const

after every argument

AstVisitor.preVisitFunctionArgumentInit(self: AstVisitor; fun: FunctionPtr; arg: VariablePtr; value: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

fun

FunctionPtr

arg

VariablePtr

value

ExpressionPtr

before every argument initialization expression (should it have one), between ‘preVisitFunctionArgument’ and visitFunctionArgument

AstVisitor.visitFunctionArgumentInit(self: AstVisitor; fun: FunctionPtr; arg: VariablePtr; value: ExpressionPtr)

visitFunctionArgumentInit returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

fun

FunctionPtr

arg

VariablePtr

value

ExpressionPtr

after every argument initialization expression (should it have one), between ‘preVisitFunctionArgument’ and visitFunctionArgument

AstVisitor.preVisitFunctionBody(self: AstVisitor; fun: FunctionPtr)

argument

argument type

self

ast::AstVisitor

fun

FunctionPtr

before the Function body block, between preVisitFunction and visitFunction (not for abstract functions)

AstVisitor.visitFunctionBody(self: AstVisitor; fun: FunctionPtr)

argument

argument type

self

ast::AstVisitor

fun

FunctionPtr

after the Function body block, between preVisitFunction and visitFunction (not for abstract functions)

AstVisitor.preVisitExpression(self: AstVisitor; expr: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

ExpressionPtr

before every Expression

AstVisitor.visitExpression(self: AstVisitor; expr: ExpressionPtr)

visitExpression returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

ExpressionPtr

after every Expression

AstVisitor.preVisitExprBlock(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const)

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

before ExprBlock

AstVisitor.visitExprBlock(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const)

visitExprBlock returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

after ExprBlock

AstVisitor.preVisitExprBlockArgument(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const; arg: VariablePtr; lastArg: bool const)

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

arg

VariablePtr

lastArg

bool const

before every block argument

AstVisitor.visitExprBlockArgument(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const; arg: VariablePtr; lastArg: bool const)

visitExprBlockArgument returns VariablePtr

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

arg

VariablePtr

lastArg

bool const

after every block argument

AstVisitor.preVisitExprBlockArgumentInit(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const; arg: VariablePtr; expr: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

arg

VariablePtr

expr

ExpressionPtr

before every block argument initialization expression (should it have one), between ‘preVisitExprBlockArgument’ and visitExprBlockArgument

AstVisitor.visitExprBlockArgumentInit(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const; arg: VariablePtr; expr: ExpressionPtr)

visitExprBlockArgumentInit returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

arg

VariablePtr

expr

ExpressionPtr

after every block argument initialization expression (should it have one), between ‘preVisitExprBlockArgument’ and visitExprBlockArgument

AstVisitor.preVisitExprBlockExpression(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const; expr: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

expr

ExpressionPtr

before every block expression

AstVisitor.visitExprBlockExpression(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const; expr: ExpressionPtr)

visitExprBlockExpression returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

expr

ExpressionPtr

after every block expression

AstVisitor.preVisitExprBlockFinal(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const)

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

before finally` section of the block

AstVisitor.visitExprBlockFinal(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const)

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

after finally` section of the block

AstVisitor.preVisitExprBlockFinalExpression(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const; expr: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

expr

ExpressionPtr

before every block expression in the finally section, between preVisitExprBlockFinal and visitExprBlockFinal

AstVisitor.visitExprBlockFinalExpression(self: AstVisitor; blk: smart_ptr<ast::ExprBlock> const; expr: ExpressionPtr)

visitExprBlockFinalExpression returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

expr

ExpressionPtr

after every block expression in the finally` section, between preVisitExprBlockFinal and visitExprBlockFinal

AstVisitor.preVisitExprLet(self: AstVisitor; expr: smart_ptr<ast::ExprLet> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLet > const

before ExprLet

AstVisitor.visitExprLet(self: AstVisitor; expr: smart_ptr<ast::ExprLet> const)

visitExprLet returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLet > const

after ExprLet

AstVisitor.preVisitExprLetVariable(self: AstVisitor; expr: smart_ptr<ast::ExprLet> const; arg: VariablePtr; lastArg: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLet > const

arg

VariablePtr

lastArg

bool const

before every variable

AstVisitor.visitExprLetVariable(self: AstVisitor; expr: smart_ptr<ast::ExprLet> const; arg: VariablePtr; lastArg: bool const)

visitExprLetVariable returns VariablePtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLet > const

arg

VariablePtr

lastArg

bool const

after every variable

AstVisitor.preVisitExprLetVariableInit(self: AstVisitor; blk: smart_ptr<ast::ExprLet> const; arg: VariablePtr; expr: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprLet > const

arg

VariablePtr

expr

ExpressionPtr

before variable initialization (should it have one), between preVisitExprLetVariable and visitExprLetVariable

AstVisitor.visitExprLetVariableInit(self: AstVisitor; blk: smart_ptr<ast::ExprLet> const; arg: VariablePtr; expr: ExpressionPtr)

visitExprLetVariableInit returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprLet > const

arg

VariablePtr

expr

ExpressionPtr

after variable initialization (should it have one), between preVisitExprLetVariable and visitExprLetVariable

AstVisitor.canVisitGlobalVariable(self: AstVisitor; arg: ast::Variable? const)

canVisitGlobalVariable returns bool

argument

argument type

self

ast::AstVisitor

arg

ast::Variable ? const

If true global variable declaration will be visited

AstVisitor.preVisitGlobalLet(self: AstVisitor; prog: ProgramPtr)

argument

argument type

self

ast::AstVisitor

prog

ProgramPtr

before global variable declaration

AstVisitor.visitGlobalLet(self: AstVisitor; prog: ProgramPtr)

argument

argument type

self

ast::AstVisitor

prog

ProgramPtr

after global variable declaration

AstVisitor.preVisitGlobalLetVariable(self: AstVisitor; arg: VariablePtr; lastArg: bool const)

argument

argument type

self

ast::AstVisitor

arg

VariablePtr

lastArg

bool const

before every global variable

AstVisitor.visitGlobalLetVariable(self: AstVisitor; arg: VariablePtr; lastArg: bool const)

visitGlobalLetVariable returns VariablePtr

argument

argument type

self

ast::AstVisitor

arg

VariablePtr

lastArg

bool const

after every global variable

AstVisitor.preVisitGlobalLetVariableInit(self: AstVisitor; arg: VariablePtr; expr: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

arg

VariablePtr

expr

ExpressionPtr

before global variable initialization (should it have one), between preVisitGlobalLetVariable and visitGlobalLetVariable

AstVisitor.visitGlobalLetVariableInit(self: AstVisitor; arg: VariablePtr; expr: ExpressionPtr)

visitGlobalLetVariableInit returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

arg

VariablePtr

expr

ExpressionPtr

after global variable initialization (should it have one), between preVisitGlobalLetVariable and visitGlobalLetVariable

AstVisitor.preVisitExprStringBuilder(self: AstVisitor; expr: smart_ptr<ast::ExprStringBuilder> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprStringBuilder > const

before ExprStringBuilder

AstVisitor.visitExprStringBuilder(self: AstVisitor; expr: smart_ptr<ast::ExprStringBuilder> const)

visitExprStringBuilder returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprStringBuilder > const

after ExprStringBuilder

AstVisitor.preVisitExprStringBuilderElement(self: AstVisitor; expr: smart_ptr<ast::ExprStringBuilder> const; elem: ExpressionPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprStringBuilder > const

elem

ExpressionPtr

last

bool const

before any element of string builder (string or expression)

AstVisitor.visitExprStringBuilderElement(self: AstVisitor; expr: smart_ptr<ast::ExprStringBuilder> const; elem: ExpressionPtr; last: bool const)

visitExprStringBuilderElement returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprStringBuilder > const

elem

ExpressionPtr

last

bool const

after any element of string builder

AstVisitor.preVisitExprNew(self: AstVisitor; expr: smart_ptr<ast::ExprNew> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNew > const

before ExprNew

AstVisitor.visitExprNew(self: AstVisitor; expr: smart_ptr<ast::ExprNew> const)

visitExprNew returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNew > const

after ExprNew

AstVisitor.preVisitExprNewArgument(self: AstVisitor; expr: smart_ptr<ast::ExprNew> const; arg: ExpressionPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNew > const

arg

ExpressionPtr

last

bool const

before every argument

AstVisitor.visitExprNewArgument(self: AstVisitor; expr: smart_ptr<ast::ExprNew> const; arg: ExpressionPtr; last: bool const)

visitExprNewArgument returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNew > const

arg

ExpressionPtr

last

bool const

after every argument

AstVisitor.preVisitExprNamedCall(self: AstVisitor; expr: smart_ptr<ast::ExprNamedCall> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNamedCall > const

before ExprNamedCall

AstVisitor.visitExprNamedCall(self: AstVisitor; expr: smart_ptr<ast::ExprNamedCall> const)

visitExprNamedCall returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNamedCall > const

after ExprNamedCall`

AstVisitor.preVisitExprNamedCallArgument(self: AstVisitor; expr: smart_ptr<ast::ExprNamedCall> const; arg: MakeFieldDeclPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNamedCall > const

arg

MakeFieldDeclPtr

last

bool const

before every argument

AstVisitor.visitExprNamedCallArgument(self: AstVisitor; expr: smart_ptr<ast::ExprNamedCall> const; arg: MakeFieldDeclPtr; last: bool const)

visitExprNamedCallArgument returns MakeFieldDeclPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNamedCall > const

arg

MakeFieldDeclPtr

last

bool const

after every argument

AstVisitor.preVisitExprLooksLikeCall(self: AstVisitor; expr: smart_ptr<ast::ExprLooksLikeCall> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLooksLikeCall > const

before ExprLooksLikeCall

AstVisitor.visitExprLooksLikeCall(self: AstVisitor; expr: smart_ptr<ast::ExprLooksLikeCall> const)

visitExprLooksLikeCall returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLooksLikeCall > const

after ExprLooksLikeCall

AstVisitor.preVisitExprLooksLikeCallArgument(self: AstVisitor; expr: smart_ptr<ast::ExprLooksLikeCall> const; arg: ExpressionPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLooksLikeCall > const

arg

ExpressionPtr

last

bool const

before every argument

AstVisitor.visitExprLooksLikeCallArgument(self: AstVisitor; expr: smart_ptr<ast::ExprLooksLikeCall> const; arg: ExpressionPtr; last: bool const)

visitExprLooksLikeCallArgument returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLooksLikeCall > const

arg

ExpressionPtr

last

bool const

after every argument

AstVisitor.preVisitExprCall(self: AstVisitor; expr: smart_ptr<ast::ExprCall> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCall > const

before ExprCall

AstVisitor.visitExprCall(self: AstVisitor; expr: smart_ptr<ast::ExprCall> const)

visitExprCall returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCall > const

after ExprCall

AstVisitor.preVisitExprCallArgument(self: AstVisitor; expr: smart_ptr<ast::ExprCall> const; arg: ExpressionPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCall > const

arg

ExpressionPtr

last

bool const

before every argument

AstVisitor.visitExprCallArgument(self: AstVisitor; expr: smart_ptr<ast::ExprCall> const; arg: ExpressionPtr; last: bool const)

visitExprCallArgument returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCall > const

arg

ExpressionPtr

last

bool const

after every argument

AstVisitor.preVisitExprNullCoalescing(self: AstVisitor; expr: smart_ptr<ast::ExprNullCoalescing> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNullCoalescing > const

before ExprNullCoalescing

AstVisitor.visitExprNullCoalescing(self: AstVisitor; expr: smart_ptr<ast::ExprNullCoalescing> const)

visitExprNullCoalescing returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNullCoalescing > const

after ExprNullCoalescing

AstVisitor.preVisitExprNullCoalescingDefault(self: AstVisitor; expr: smart_ptr<ast::ExprNullCoalescing> const; defval: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNullCoalescing > const

defval

ExpressionPtr

before the default value

AstVisitor.preVisitExprAt(self: AstVisitor; expr: smart_ptr<ast::ExprAt> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAt > const

before ExprAt

AstVisitor.visitExprAt(self: AstVisitor; expr: smart_ptr<ast::ExprAt> const)

visitExprAt returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAt > const

after ExprAt

AstVisitor.preVisitExprAtIndex(self: AstVisitor; expr: smart_ptr<ast::ExprAt> const; index: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAt > const

index

ExpressionPtr

before the index

AstVisitor.preVisitExprSafeAt(self: AstVisitor; expr: smart_ptr<ast::ExprSafeAt> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSafeAt > const

before ExprSafeAt

AstVisitor.visitExprSafeAt(self: AstVisitor; expr: smart_ptr<ast::ExprSafeAt> const)

visitExprSafeAt returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSafeAt > const

after ExprSafeAt

AstVisitor.preVisitExprSafeAtIndex(self: AstVisitor; expr: smart_ptr<ast::ExprAt> const; index: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAt > const

index

ExpressionPtr

before the index

AstVisitor.preVisitExprIs(self: AstVisitor; expr: smart_ptr<ast::ExprIs> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIs > const

before ExprIs

AstVisitor.visitExprIs(self: AstVisitor; expr: smart_ptr<ast::ExprIs> const)

visitExprIs returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIs > const

after ExprIs

AstVisitor.preVisitExprIsType(self: AstVisitor; expr: smart_ptr<ast::ExprAt> const; typeDecl: TypeDeclPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAt > const

typeDecl

TypeDeclPtr

before the type

AstVisitor.preVisitExprOp2(self: AstVisitor; expr: smart_ptr<ast::ExprOp2> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp2 > const

before ExprOp2

AstVisitor.visitExprOp2(self: AstVisitor; expr: smart_ptr<ast::ExprOp2> const)

visitExprOp2 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp2 > const

after ExprOp2

AstVisitor.preVisitExprOp2Right(self: AstVisitor; expr: smart_ptr<ast::ExprOp2> const; right: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp2 > const

right

ExpressionPtr

before the right operand

AstVisitor.preVisitExprOp3(self: AstVisitor; expr: smart_ptr<ast::ExprOp3> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp3 > const

before ExprOp3

AstVisitor.visitExprOp3(self: AstVisitor; expr: smart_ptr<ast::ExprOp3> const)

visitExprOp3 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp3 > const

after ExprOp3

AstVisitor.preVisitExprOp3Left(self: AstVisitor; expr: smart_ptr<ast::ExprOp3> const; left: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp3 > const

left

ExpressionPtr

before the left option

AstVisitor.preVisitExprOp3Right(self: AstVisitor; expr: smart_ptr<ast::ExprOp3> const; right: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp3 > const

right

ExpressionPtr

before the right option

AstVisitor.preVisitExprCopy(self: AstVisitor; expr: smart_ptr<ast::ExprCopy> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCopy > const

before ExprCopy

AstVisitor.visitExprCopy(self: AstVisitor; expr: smart_ptr<ast::ExprCopy> const)

visitExprCopy returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCopy > const

after ExprCopy

AstVisitor.preVisitExprCopyRight(self: AstVisitor; expr: smart_ptr<ast::ExprCopy> const; right: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCopy > const

right

ExpressionPtr

before the right operand

AstVisitor.preVisitExprMove(self: AstVisitor; expr: smart_ptr<ast::ExprMove> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMove > const

before ExprMove

AstVisitor.visitExprMove(self: AstVisitor; expr: smart_ptr<ast::ExprMove> const)

visitExprMove returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMove > const

after ExprMove

AstVisitor.preVisitExprMoveRight(self: AstVisitor; expr: smart_ptr<ast::ExprMove> const; right: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMove > const

right

ExpressionPtr

before the right operand

AstVisitor.preVisitExprClone(self: AstVisitor; expr: smart_ptr<ast::ExprClone> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprClone > const

before ExprClone

AstVisitor.visitExprClone(self: AstVisitor; expr: smart_ptr<ast::ExprClone> const)

visitExprClone returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprClone > const

after ExprClone

AstVisitor.preVisitExprCloneRight(self: AstVisitor; expr: smart_ptr<ast::ExprClone> const; right: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprClone > const

right

ExpressionPtr

before the right operand

AstVisitor.preVisitExprAssume(self: AstVisitor; expr: smart_ptr<ast::ExprAssume> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAssume > const

before ExprAssume

AstVisitor.visitExprAssume(self: AstVisitor; expr: smart_ptr<ast::ExprAssume> const)

visitExprAssume returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAssume > const

after ExprAssume

AstVisitor.preVisitExprWith(self: AstVisitor; expr: smart_ptr<ast::ExprWith> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprWith > const

before ExprWith

AstVisitor.visitExprWith(self: AstVisitor; expr: smart_ptr<ast::ExprWith> const)

visitExprWith returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprWith > const

after ExprWith

AstVisitor.preVisitExprWithBody(self: AstVisitor; expr: smart_ptr<ast::ExprWith> const; right: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprWith > const

right

ExpressionPtr

before the body block

AstVisitor.preVisitExprWhile(self: AstVisitor; expr: smart_ptr<ast::ExprWhile> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprWhile > const

before ExprWhile

AstVisitor.visitExprWhile(self: AstVisitor; expr: smart_ptr<ast::ExprWhile> const)

visitExprWhile returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprWhile > const

after ExprWhile

AstVisitor.preVisitExprWhileBody(self: AstVisitor; expr: smart_ptr<ast::ExprWhile> const; right: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprWhile > const

right

ExpressionPtr

before the body block

AstVisitor.preVisitExprTryCatch(self: AstVisitor; expr: smart_ptr<ast::ExprTryCatch> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprTryCatch > const

before ExprTryCatch

AstVisitor.visitExprTryCatch(self: AstVisitor; expr: smart_ptr<ast::ExprTryCatch> const)

visitExprTryCatch returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprTryCatch > const

after ExprTryCatch

AstVisitor.preVisitExprTryCatchCatch(self: AstVisitor; expr: smart_ptr<ast::ExprTryCatch> const; right: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprTryCatch > const

right

ExpressionPtr

before the catch (recover) section

AstVisitor.preVisitExprIfThenElse(self: AstVisitor; expr: smart_ptr<ast::ExprIfThenElse> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIfThenElse > const

before ExprIfThenElse

AstVisitor.visitExprIfThenElse(self: AstVisitor; expr: smart_ptr<ast::ExprIfThenElse> const)

visitExprIfThenElse returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIfThenElse > const

after ExprIfThenElse

AstVisitor.preVisitExprIfThenElseIfBlock(self: AstVisitor; expr: smart_ptr<ast::ExprIfThenElse> const; ifBlock: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIfThenElse > const

ifBlock

ExpressionPtr

before the if block

AstVisitor.preVisitExprIfThenElseElseBlock(self: AstVisitor; expr: smart_ptr<ast::ExprIfThenElse> const; elseBlock: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIfThenElse > const

elseBlock

ExpressionPtr

before the else block

AstVisitor.preVisitExprFor(self: AstVisitor; expr: smart_ptr<ast::ExprFor> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFor > const

before the ExprFor

AstVisitor.visitExprFor(self: AstVisitor; expr: smart_ptr<ast::ExprFor> const)

visitExprFor returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFor > const

after the ExprFor

AstVisitor.preVisitExprForVariable(self: AstVisitor; expr: smart_ptr<ast::ExprFor> const; svar: VariablePtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFor > const

svar

VariablePtr

last

bool const

before each variable

AstVisitor.visitExprForVariable(self: AstVisitor; expr: smart_ptr<ast::ExprFor> const; svar: VariablePtr; last: bool const)

visitExprForVariable returns VariablePtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFor > const

svar

VariablePtr

last

bool const

after each variable

AstVisitor.preVisitExprForSource(self: AstVisitor; expr: smart_ptr<ast::ExprFor> const; source: ExpressionPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFor > const

source

ExpressionPtr

last

bool const

before each source

AstVisitor.visitExprForSource(self: AstVisitor; expr: smart_ptr<ast::ExprFor> const; source: ExpressionPtr; last: bool const)

visitExprForSource returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFor > const

source

ExpressionPtr

last

bool const

after each source

AstVisitor.preVisitExprForStack(self: AstVisitor; expr: smart_ptr<ast::ExprFor> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFor > const

before the stack is allocated before the body, regardless if it has one

AstVisitor.preVisitExprForBody(self: AstVisitor; expr: smart_ptr<ast::ExprFor> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFor > const

before the body (should it have one)

AstVisitor.preVisitExprMakeVariant(self: AstVisitor; expr: smart_ptr<ast::ExprMakeVariant> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeVariant > const

before ExprMakeVariant

AstVisitor.visitExprMakeVariant(self: AstVisitor; expr: smart_ptr<ast::ExprMakeVariant> const)

visitExprMakeVariant returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeVariant > const

after ExprMakeVariant

AstVisitor.preVisitExprMakeVariantField(self: AstVisitor; expr: smart_ptr<ast::ExprMakeVariant> const; index: int const; decl: MakeFieldDeclPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeVariant > const

index

int const

decl

MakeFieldDeclPtr

last

bool const

before every field

AstVisitor.visitExprMakeVariantField(self: AstVisitor; expr: smart_ptr<ast::ExprMakeVariant> const; index: int const; decl: MakeFieldDeclPtr; last: bool const)

visitExprMakeVariantField returns MakeFieldDeclPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeVariant > const

index

int const

decl

MakeFieldDeclPtr

last

bool const

after every field

AstVisitor.canVisitMakeStructBody(self: AstVisitor; expr: smart_ptr<ast::ExprMakeStruct> const)

canVisitMakeStructBody returns bool

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeStruct > const

if true the visitor can visit the body of ExprMakeStruct

AstVisitor.canVisitMakeStructBlock(self: AstVisitor; expr: smart_ptr<ast::ExprMakeStruct> const; blk: ExpressionPtr)

canVisitMakeStructBlock returns bool

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeStruct > const

blk

ExpressionPtr

if true the visitor can visit the block behind ExprMakeStruct

AstVisitor.preVisitExprMakeStruct(self: AstVisitor; expr: smart_ptr<ast::ExprMakeStruct> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeStruct > const

before ExprMakeStruct

AstVisitor.visitExprMakeStruct(self: AstVisitor; expr: smart_ptr<ast::ExprMakeStruct> const)

visitExprMakeStruct returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeStruct > const

after ExprMakeStruct

AstVisitor.preVisitExprMakeStructIndex(self: AstVisitor; expr: smart_ptr<ast::ExprMakeStruct> const; index: int const; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeStruct > const

index

int const

last

bool const

before each struct in the array of structures

AstVisitor.visitExprMakeStructIndex(self: AstVisitor; expr: smart_ptr<ast::ExprMakeStruct> const; index: int const; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeStruct > const

index

int const

last

bool const

after each struct in the array of structures

AstVisitor.preVisitExprMakeStructField(self: AstVisitor; expr: smart_ptr<ast::ExprMakeStruct> const; index: int const; decl: MakeFieldDeclPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeStruct > const

index

int const

decl

MakeFieldDeclPtr

last

bool const

before each field of the struct, between preVisitExprMakeStructIndex and visitExprMakeStructIndex

AstVisitor.visitExprMakeStructField(self: AstVisitor; expr: smart_ptr<ast::ExprMakeStruct> const; index: int const; decl: MakeFieldDeclPtr; last: bool const)

visitExprMakeStructField returns MakeFieldDeclPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeStruct > const

index

int const

decl

MakeFieldDeclPtr

last

bool const

after each field of the struct, between preVisitExprMakeStructIndex and visitExprMakeStructIndex

AstVisitor.preVisitExprMakeArray(self: AstVisitor; expr: smart_ptr<ast::ExprMakeArray> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeArray > const

before ExprMakeArray

AstVisitor.visitExprMakeArray(self: AstVisitor; expr: smart_ptr<ast::ExprMakeArray> const)

visitExprMakeArray returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeArray > const

after ExprMakeArray

AstVisitor.preVisitExprMakeArrayIndex(self: AstVisitor; expr: smart_ptr<ast::ExprMakeArray> const; index: int const; init: ExpressionPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeArray > const

index

int const

init

ExpressionPtr

last

bool const

before each element of the array

AstVisitor.visitExprMakeArrayIndex(self: AstVisitor; expr: smart_ptr<ast::ExprMakeArray> const; index: int const; init: ExpressionPtr; last: bool const)

visitExprMakeArrayIndex returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeArray > const

index

int const

init

ExpressionPtr

last

bool const

after each element of the array

AstVisitor.preVisitExprMakeTuple(self: AstVisitor; expr: smart_ptr<ast::ExprMakeTuple> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeTuple > const

before ExprMakeTuple

AstVisitor.visitExprMakeTuple(self: AstVisitor; expr: smart_ptr<ast::ExprMakeTuple> const)

visitExprMakeTuple returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeTuple > const

after ExprMakeTuple

AstVisitor.preVisitExprMakeTupleIndex(self: AstVisitor; expr: smart_ptr<ast::ExprMakeTuple> const; index: int const; init: ExpressionPtr; last: bool const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeTuple > const

index

int const

init

ExpressionPtr

last

bool const

before each field of the tuple

AstVisitor.visitExprMakeTupleIndex(self: AstVisitor; expr: smart_ptr<ast::ExprMakeTuple> const; index: int const; init: ExpressionPtr; last: bool const)

visitExprMakeTupleIndex returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeTuple > const

index

int const

init

ExpressionPtr

last

bool const

after each field of the tuple

AstVisitor.preVisitExprArrayComprehension(self: AstVisitor; expr: smart_ptr<ast::ExprArrayComprehension> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprArrayComprehension > const

before ExprArrayComprehension

AstVisitor.visitExprArrayComprehension(self: AstVisitor; expr: smart_ptr<ast::ExprArrayComprehension> const)

visitExprArrayComprehension returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprArrayComprehension > const

after ExprArrayComprehension

AstVisitor.preVisitExprArrayComprehensionSubexpr(self: AstVisitor; expr: smart_ptr<ast::ExprArrayComprehension> const; subexrp: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprArrayComprehension > const

subexrp

ExpressionPtr

before the subexpression

AstVisitor.preVisitExprArrayComprehensionWhere(self: AstVisitor; expr: smart_ptr<ast::ExprArrayComprehension> const; filter: ExpressionPtr)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprArrayComprehension > const

filter

ExpressionPtr

before the where clause

AstVisitor.preVisitExprTypeInfo(self: AstVisitor; expr: smart_ptr<ast::ExprTypeInfo> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprTypeInfo > const

before ExprTypeInfo

AstVisitor.visitExprTypeInfo(self: AstVisitor; expr: smart_ptr<ast::ExprTypeInfo> const)

visitExprTypeInfo returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprTypeInfo > const

after ExprTypeInfo

AstVisitor.preVisitExprPtr2Ref(self: AstVisitor; expr: smart_ptr<ast::ExprPtr2Ref> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprPtr2Ref > const

before ExprPtr2Ref

AstVisitor.visitExprPtr2Ref(self: AstVisitor; expr: smart_ptr<ast::ExprPtr2Ref> const)

visitExprPtr2Ref returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprPtr2Ref > const

after ExprPtr2Ref

AstVisitor.preVisitExprLabel(self: AstVisitor; expr: smart_ptr<ast::ExprLabel> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLabel > const

before ExprLabel

AstVisitor.visitExprLabel(self: AstVisitor; expr: smart_ptr<ast::ExprLabel> const)

visitExprLabel returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLabel > const

after ExprLabel

AstVisitor.preVisitExprGoto(self: AstVisitor; expr: smart_ptr<ast::ExprGoto> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprGoto > const

before ExprGoto

AstVisitor.visitExprGoto(self: AstVisitor; expr: smart_ptr<ast::ExprGoto> const)

visitExprGoto returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprGoto > const

after ExprGoto

AstVisitor.preVisitExprRef2Value(self: AstVisitor; expr: smart_ptr<ast::ExprRef2Value> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprRef2Value > const

before ExprRef2Value

AstVisitor.visitExprRef2Value(self: AstVisitor; expr: smart_ptr<ast::ExprRef2Value> const)

visitExprRef2Value returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprRef2Value > const

after ExprRef2Value

AstVisitor.preVisitExprRef2Ptr(self: AstVisitor; expr: smart_ptr<ast::ExprRef2Ptr> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprRef2Ptr > const

before ExprRef2Ptr

AstVisitor.visitExprRef2Ptr(self: AstVisitor; expr: smart_ptr<ast::ExprRef2Ptr> const)

visitExprRef2Ptr returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprRef2Ptr > const

after ExprRef2Ptr

AstVisitor.preVisitExprAddr(self: AstVisitor; expr: smart_ptr<ast::ExprAddr> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAddr > const

before ExprAddr

AstVisitor.visitExprAddr(self: AstVisitor; expr: smart_ptr<ast::ExprAddr> const)

visitExprAddr returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAddr > const

after ExprAddr

AstVisitor.preVisitExprAssert(self: AstVisitor; expr: smart_ptr<ast::ExprAssert> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAssert > const

before ExprAssert

AstVisitor.visitExprAssert(self: AstVisitor; expr: smart_ptr<ast::ExprAssert> const)

visitExprAssert returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAssert > const

after ExprAssert

AstVisitor.preVisitExprStaticAssert(self: AstVisitor; expr: smart_ptr<ast::ExprStaticAssert> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprStaticAssert > const

before ExprStaticAssert

AstVisitor.visitExprStaticAssert(self: AstVisitor; expr: smart_ptr<ast::ExprStaticAssert> const)

visitExprStaticAssert returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprStaticAssert > const

after ExprStaticAssert

AstVisitor.preVisitExprQuote(self: AstVisitor; expr: smart_ptr<ast::ExprQuote> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprQuote > const

before ExprQuote

AstVisitor.visitExprQuote(self: AstVisitor; expr: smart_ptr<ast::ExprQuote> const)

visitExprQuote returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprQuote > const

after ExprQuote

AstVisitor.preVisitExprDebug(self: AstVisitor; expr: smart_ptr<ast::ExprDebug> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprDebug > const

before ExprDebug

AstVisitor.visitExprDebug(self: AstVisitor; expr: smart_ptr<ast::ExprDebug> const)

visitExprDebug returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprDebug > const

after ExprDebug

AstVisitor.preVisitExprInvoke(self: AstVisitor; expr: smart_ptr<ast::ExprInvoke> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprInvoke > const

before ExprInvoke

AstVisitor.visitExprInvoke(self: AstVisitor; expr: smart_ptr<ast::ExprInvoke> const)

visitExprInvoke returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprInvoke > const

after ExprInvoke

AstVisitor.preVisitExprErase(self: AstVisitor; expr: smart_ptr<ast::ExprErase> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprErase > const

before ExprErase

AstVisitor.visitExprErase(self: AstVisitor; expr: smart_ptr<ast::ExprErase> const)

visitExprErase returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprErase > const

after ExprErase

AstVisitor.preVisitExprFind(self: AstVisitor; expr: smart_ptr<ast::ExprFind> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFind > const

before ExprFind

AstVisitor.visitExprFind(self: AstVisitor; expr: smart_ptr<ast::ExprFind> const)

visitExprFind returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFind > const

after ExprFind

AstVisitor.preVisitExprKeyExists(self: AstVisitor; expr: smart_ptr<ast::ExprKeyExists> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprKeyExists > const

before ExprKeyExists

AstVisitor.visitExprKeyExists(self: AstVisitor; expr: smart_ptr<ast::ExprKeyExists> const)

visitExprKeyExists returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprKeyExists > const

after ExprKeyExists

AstVisitor.preVisitExprAscend(self: AstVisitor; expr: smart_ptr<ast::ExprAscend> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAscend > const

before ExprAscend

AstVisitor.visitExprAscend(self: AstVisitor; expr: smart_ptr<ast::ExprAscend> const)

visitExprAscend returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAscend > const

after ExprAscend

AstVisitor.preVisitExprCast(self: AstVisitor; expr: smart_ptr<ast::ExprCast> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCast > const

before ExprCast

AstVisitor.visitExprCast(self: AstVisitor; expr: smart_ptr<ast::ExprCast> const)

visitExprCast returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCast > const

after ExprCast

AstVisitor.preVisitExprDelete(self: AstVisitor; expr: smart_ptr<ast::ExprDelete> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprDelete > const

before ExprDelete

AstVisitor.visitExprDelete(self: AstVisitor; expr: smart_ptr<ast::ExprDelete> const)

visitExprDelete returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprDelete > const

after ExprDelete

AstVisitor.preVisitExprVar(self: AstVisitor; expr: smart_ptr<ast::ExprVar> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprVar > const

before ExprVar

AstVisitor.visitExprVar(self: AstVisitor; expr: smart_ptr<ast::ExprVar> const)

visitExprVar returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprVar > const

after ExprVar

AstVisitor.preVisitExprField(self: AstVisitor; expr: smart_ptr<ast::ExprField> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprField > const

before ExprField

AstVisitor.visitExprField(self: AstVisitor; expr: smart_ptr<ast::ExprField> const)

visitExprField returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprField > const

after ExprField

AstVisitor.preVisitExprSafeField(self: AstVisitor; expr: smart_ptr<ast::ExprSafeField> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSafeField > const

before ExprSafeField

AstVisitor.visitExprSafeField(self: AstVisitor; expr: smart_ptr<ast::ExprSafeField> const)

visitExprSafeField returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSafeField > const

after ExprSafeField

AstVisitor.preVisitExprSwizzle(self: AstVisitor; expr: smart_ptr<ast::ExprSwizzle> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSwizzle > const

before ExprSwizzle

AstVisitor.visitExprSwizzle(self: AstVisitor; expr: smart_ptr<ast::ExprSwizzle> const)

visitExprSwizzle returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSwizzle > const

after ExprSwizzle

AstVisitor.preVisitExprIsVariant(self: AstVisitor; expr: smart_ptr<ast::ExprIsVariant> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIsVariant > const

before ExprIsVariant

AstVisitor.visitExprIsVariant(self: AstVisitor; expr: smart_ptr<ast::ExprIsVariant> const)

visitExprIsVariant returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIsVariant > const

after ExprIsVariant

AstVisitor.preVisitExprAsVariant(self: AstVisitor; expr: smart_ptr<ast::ExprAsVariant> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAsVariant > const

before ExprAsVariant

AstVisitor.visitExprAsVariant(self: AstVisitor; expr: smart_ptr<ast::ExprAsVariant> const)

visitExprAsVariant returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAsVariant > const

after ExprAsVariant

AstVisitor.preVisitExprSafeAsVariant(self: AstVisitor; expr: smart_ptr<ast::ExprSafeAsVariant> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSafeAsVariant > const

before ExprSafeAsVariant

AstVisitor.visitExprSafeAsVariant(self: AstVisitor; expr: smart_ptr<ast::ExprSafeAsVariant> const)

visitExprSafeAsVariant returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSafeAsVariant > const

after ExprSafeAsVariant

AstVisitor.preVisitExprOp1(self: AstVisitor; expr: smart_ptr<ast::ExprOp1> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp1 > const

before ExprOp1

AstVisitor.visitExprOp1(self: AstVisitor; expr: smart_ptr<ast::ExprOp1> const)

visitExprOp1 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp1 > const

after ExprOp1

AstVisitor.preVisitExprReturn(self: AstVisitor; expr: smart_ptr<ast::ExprReturn> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprReturn > const

before ExprReturn

AstVisitor.visitExprReturn(self: AstVisitor; expr: smart_ptr<ast::ExprReturn> const)

visitExprReturn returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprReturn > const

after ExprReturn

AstVisitor.preVisitExprYield(self: AstVisitor; expr: smart_ptr<ast::ExprYield> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprYield > const

before ExprYield

AstVisitor.visitExprYield(self: AstVisitor; expr: smart_ptr<ast::ExprYield> const)

visitExprYield returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprYield > const

after ‘ExprYield’

AstVisitor.preVisitExprBreak(self: AstVisitor; expr: smart_ptr<ast::ExprBreak> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprBreak > const

before ExprBreak

AstVisitor.visitExprBreak(self: AstVisitor; expr: smart_ptr<ast::ExprBreak> const)

visitExprBreak returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprBreak > const

after ExprBreak

AstVisitor.preVisitExprContinue(self: AstVisitor; expr: smart_ptr<ast::ExprContinue> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprContinue > const

before ExprContinue

AstVisitor.visitExprContinue(self: AstVisitor; expr: smart_ptr<ast::ExprContinue> const)

visitExprContinue returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprContinue > const

after ExprContinue

AstVisitor.preVisitExprMakeBlock(self: AstVisitor; expr: smart_ptr<ast::ExprMakeBlock> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeBlock > const

before ExprMakeBlock

AstVisitor.visitExprMakeBlock(self: AstVisitor; expr: smart_ptr<ast::ExprMakeBlock> const)

visitExprMakeBlock returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeBlock > const

after ExprMakeBlock

AstVisitor.preVisitExprMakeGenerator(self: AstVisitor; expr: smart_ptr<ast::ExprMakeGenerator> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeGenerator > const

before ExprMakeGenerator

AstVisitor.visitExprMakeGenerator(self: AstVisitor; expr: smart_ptr<ast::ExprMakeGenerator> const)

visitExprMakeGenerator returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeGenerator > const

after ExprMakeGenerator

AstVisitor.preVisitExprMemZero(self: AstVisitor; expr: smart_ptr<ast::ExprMemZero> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMemZero > const

before ExprMemZero

AstVisitor.visitExprMemZero(self: AstVisitor; expr: smart_ptr<ast::ExprMemZero> const)

visitExprMemZero returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMemZero > const

after ExprMemZero

AstVisitor.preVisitExprConst(self: AstVisitor; expr: smart_ptr<ast::ExprConst> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConst > const

before ExprConst

AstVisitor.visitExprConst(self: AstVisitor; expr: smart_ptr<ast::ExprConst> const)

visitExprConst returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConst > const

after ExprConst

AstVisitor.preVisitExprConstPtr(self: AstVisitor; expr: smart_ptr<ast::ExprConstPtr> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstPtr > const

before ExprConstPtr

AstVisitor.visitExprConstPtr(self: AstVisitor; expr: smart_ptr<ast::ExprConstPtr> const)

visitExprConstPtr returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstPtr > const

after ExprConstPtr

AstVisitor.preVisitExprConstEnumeration(self: AstVisitor; expr: smart_ptr<ast::ExprConstEnumeration> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstEnumeration > const

before ExprConstEnumeration

AstVisitor.visitExprConstEnumeration(self: AstVisitor; expr: smart_ptr<ast::ExprConstEnumeration> const)

visitExprConstEnumeration returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstEnumeration > const

after ExprConstEnumeration

AstVisitor.preVisitExprConstBitfield(self: AstVisitor; expr: smart_ptr<ast::ExprConstBitfield> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstBitfield > const

before ExprConstBitfield

AstVisitor.visitExprConstBitfield(self: AstVisitor; expr: smart_ptr<ast::ExprConstBitfield> const)

visitExprConstBitfield returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstBitfield > const

after ExprConstBitfield

AstVisitor.preVisitExprConstInt8(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt8> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt8 > const

before ExprConstInt8

AstVisitor.visitExprConstInt8(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt8> const)

visitExprConstInt8 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt8 > const

after ExprConstInt8

AstVisitor.preVisitExprConstInt16(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt16> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt16 > const

before ExprConstInt16

AstVisitor.visitExprConstInt16(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt16> const)

visitExprConstInt16 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt16 > const

after ExprConstInt16

AstVisitor.preVisitExprConstInt64(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt64> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt64 > const

before ExprConstInt64

AstVisitor.visitExprConstInt64(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt64> const)

visitExprConstInt64 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt64 > const

after ExprConstInt64

AstVisitor.preVisitExprConstInt(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt > const

before ExprConstInt

AstVisitor.visitExprConstInt(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt> const)

visitExprConstInt returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt > const

after ExprConstInt

AstVisitor.preVisitExprConstInt2(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt2> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt2 > const

before ExprConstInt2

AstVisitor.visitExprConstInt2(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt2> const)

visitExprConstInt2 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt2 > const

after ExprConstInt2

AstVisitor.preVisitExprConstInt3(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt3> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt3 > const

before ExprConstInt3

AstVisitor.visitExprConstInt3(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt3> const)

visitExprConstInt3 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt3 > const

after ExprConstInt3

AstVisitor.preVisitExprConstInt4(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt4> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt4 > const

before ExprConstInt4

AstVisitor.visitExprConstInt4(self: AstVisitor; expr: smart_ptr<ast::ExprConstInt4> const)

visitExprConstInt4 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt4 > const

after ExprConstInt4

AstVisitor.preVisitExprConstUInt8(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt8> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt8 > const

before ExprConstUInt8

AstVisitor.visitExprConstUInt8(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt8> const)

visitExprConstUInt8 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt8 > const

after ExprConstUInt8

AstVisitor.preVisitExprConstUInt16(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt16> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt16 > const

before ExprConstUInt16

AstVisitor.visitExprConstUInt16(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt16> const)

visitExprConstUInt16 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt16 > const

after ExprConstUInt16

AstVisitor.preVisitExprConstUInt64(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt64> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt64 > const

before ExprConstUInt64

AstVisitor.visitExprConstUInt64(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt64> const)

visitExprConstUInt64 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt64 > const

after ExprConstUInt64

AstVisitor.preVisitExprConstUInt(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt > const

before ExprConstUInt

AstVisitor.visitExprConstUInt(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt> const)

visitExprConstUInt returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt > const

after ExprConstUInt

AstVisitor.preVisitExprConstUInt2(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt2> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt2 > const

before ExprConstUInt2

AstVisitor.visitExprConstUInt2(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt2> const)

visitExprConstUInt2 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt2 > const

after ExprConstUInt2

AstVisitor.preVisitExprConstUInt3(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt3> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt3 > const

before ExprConstUInt3

AstVisitor.visitExprConstUInt3(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt3> const)

visitExprConstUInt3 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt3 > const

after ExprConstUInt3

AstVisitor.preVisitExprConstUInt4(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt4> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt4 > const

before ExprConstUInt4

AstVisitor.visitExprConstUInt4(self: AstVisitor; expr: smart_ptr<ast::ExprConstUInt4> const)

visitExprConstUInt4 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt4 > const

after ExprConstUInt4

AstVisitor.preVisitExprConstRange(self: AstVisitor; expr: smart_ptr<ast::ExprConstRange> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstRange > const

before ExprConstRange

AstVisitor.visitExprConstRange(self: AstVisitor; expr: smart_ptr<ast::ExprConstRange> const)

visitExprConstRange returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstRange > const

after ExprConstRange

AstVisitor.preVisitExprConstURange(self: AstVisitor; expr: smart_ptr<ast::ExprConstURange> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstURange > const

before ExprConstURange

AstVisitor.visitExprConstURange(self: AstVisitor; expr: smart_ptr<ast::ExprConstURange> const)

visitExprConstURange returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstURange > const

after ExprConstURange

AstVisitor.preVisitExprConstBool(self: AstVisitor; expr: smart_ptr<ast::ExprConstBool> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstBool > const

before ExprConstBool

AstVisitor.visitExprConstBool(self: AstVisitor; expr: smart_ptr<ast::ExprConstBool> const)

visitExprConstBool returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstBool > const

after ExprConstBool

AstVisitor.preVisitExprConstFloat(self: AstVisitor; expr: smart_ptr<ast::ExprConstFloat> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat > const

before ExprConstFloat

AstVisitor.visitExprConstFloat(self: AstVisitor; expr: smart_ptr<ast::ExprConstFloat> const)

visitExprConstFloat returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat > const

after ExprConstFloat

AstVisitor.preVisitExprConstFloat2(self: AstVisitor; expr: smart_ptr<ast::ExprConstFloat2> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat2 > const

before ExprConstFloat2

AstVisitor.visitExprConstFloat2(self: AstVisitor; expr: smart_ptr<ast::ExprConstFloat2> const)

visitExprConstFloat2 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat2 > const

after ExprConstFloat2

AstVisitor.preVisitExprConstFloat3(self: AstVisitor; expr: smart_ptr<ast::ExprConstFloat3> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat3 > const

before ExprConstFloat3

AstVisitor.visitExprConstFloat3(self: AstVisitor; expr: smart_ptr<ast::ExprConstFloat3> const)

visitExprConstFloat3 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat3 > const

after ExprConstFloat3

AstVisitor.preVisitExprConstFloat4(self: AstVisitor; expr: smart_ptr<ast::ExprConstFloat4> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat4 > const

before ExprConstFloat4

AstVisitor.visitExprConstFloat4(self: AstVisitor; expr: smart_ptr<ast::ExprConstFloat4> const)

visitExprConstFloat4 returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat4 > const

after ExprConstFloat4

AstVisitor.preVisitExprConstString(self: AstVisitor; expr: smart_ptr<ast::ExprConstString> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstString > const

before ExprConstString

AstVisitor.visitExprConstString(self: AstVisitor; expr: smart_ptr<ast::ExprConstString> const)

visitExprConstString returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstString > const

after ExprConstString

AstVisitor.preVisitExprConstDouble(self: AstVisitor; expr: smart_ptr<ast::ExprConstDouble> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstDouble > const

before ExprConstDouble

AstVisitor.visitExprConstDouble(self: AstVisitor; expr: smart_ptr<ast::ExprConstDouble> const)

visitExprConstDouble returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstDouble > const

after ExprConstDouble

AstVisitor.preVisitExprFakeContext(self: AstVisitor; expr: smart_ptr<ast::ExprFakeContext> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFakeContext > const

before ExprConstFakeContext

AstVisitor.visitExprFakeContext(self: AstVisitor; expr: smart_ptr<ast::ExprFakeContext> const)

visitExprFakeContext returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFakeContext > const

after ExprConstFakeContext

AstVisitor.preVisitExprFakeLineInfo(self: AstVisitor; expr: smart_ptr<ast::ExprFakeLineInfo> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFakeLineInfo > const

before ExprConstFakeLineInfo

AstVisitor.visitExprFakeLineInfo(self: AstVisitor; expr: smart_ptr<ast::ExprFakeLineInfo> const)

visitExprFakeLineInfo returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFakeLineInfo > const

after ExprConstFakeLineInfo

AstVisitor.preVisitExprReader(self: AstVisitor; expr: smart_ptr<ast::ExprReader> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprReader > const

before ExprReader

AstVisitor.visitExprReader(self: AstVisitor; expr: smart_ptr<ast::ExprReader> const)

visitExprReader returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprReader > const

after ExprReader

AstVisitor.preVisitExprUnsafe(self: AstVisitor; expr: smart_ptr<ast::ExprUnsafe> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprUnsafe > const

before ExprUnsafe

AstVisitor.visitExprUnsafe(self: AstVisitor; expr: smart_ptr<ast::ExprUnsafe> const)

visitExprUnsafe returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprUnsafe > const

after ExprUnsafe

AstVisitor.preVisitExprCallMacro(self: AstVisitor; expr: smart_ptr<ast::ExprCallMacro> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCallMacro > const

before ExprCallMacro

AstVisitor.visitExprCallMacro(self: AstVisitor; expr: smart_ptr<ast::ExprCallMacro> const)

visitExprCallMacro returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCallMacro > const

after ExprCallMacro

12.8. Call generation

make_call(at: LineInfo const implicit; name: string const implicit)

make_call returns smart_ptr< ast::Expression >

argument

argument type

at

rtti::LineInfo const implicit

name

string const implicit

Creates appropriate call expression for the given call function name in the Program. ExprCallMacro will be created if appropriate macro is found. Otherwise ExprCall will be created.

12.9. Visitor pattern

visit(program: smart_ptr<rtti::Program> const implicit; adapter: smart_ptr<ast::VisitorAdapter> const implicit)

argument

argument type

program

smart_ptr< rtti::Program > const implicit

adapter

smart_ptr< ast::VisitorAdapter > const implicit

Invokes visitor for the given object.

visit_modules(program: smart_ptr<rtti::Program> const implicit; adapter: smart_ptr<ast::VisitorAdapter> const implicit)

argument

argument type

program

smart_ptr< rtti::Program > const implicit

adapter

smart_ptr< ast::VisitorAdapter > const implicit

Invokes visitor for the given list of modules inside the Program.

visit(function: smart_ptr<ast::Function> const implicit; adapter: smart_ptr<ast::VisitorAdapter> const implicit)

argument

argument type

function

smart_ptr< ast::Function > const implicit

adapter

smart_ptr< ast::VisitorAdapter > const implicit

Invokes visitor for the given object.

visit(expression: smart_ptr<ast::Expression> const implicit; adapter: smart_ptr<ast::VisitorAdapter> const implicit)

argument

argument type

expression

smart_ptr< ast::Expression > const implicit

adapter

smart_ptr< ast::VisitorAdapter > const implicit

Invokes visitor for the given object.

12.10. Adapter generation

make_visitor(class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_visitor returns smart_ptr< ast::VisitorAdapter >

argument

argument type

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstVisitor interface.

make_function_annotation(name: string const implicit; class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_function_annotation returns smart_ptr< ast::FunctionAnnotation >

argument

argument type

name

string const implicit

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstFunctionAnnotation.

make_block_annotation(name: string const implicit; class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_block_annotation returns smart_ptr< ast::FunctionAnnotation >

argument

argument type

name

string const implicit

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstBlockAnnotation.

make_structure_annotation(name: string const implicit; class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_structure_annotation returns smart_ptr< ast::StructureAnnotation >

argument

argument type

name

string const implicit

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstStructureAnnotation.

make_enumeration_annotation(name: string const implicit; class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_enumeration_annotation returns smart_ptr< ast::EnumerationAnnotation >

argument

argument type

name

string const implicit

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstEnumearationAnnotation.

make_pass_macro(name: string const implicit; class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_pass_macro returns smart_ptr< ast::PassMacro >

argument

argument type

name

string const implicit

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstPassMacro.

make_reader_macro(name: string const implicit; class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_reader_macro returns smart_ptr< ast::ReaderMacro >

argument

argument type

name

string const implicit

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstReaderMacro.

make_comment_reader(class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_comment_reader returns smart_ptr< ast::CommentReader >

argument

argument type

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstCommentReader.

make_call_macro(name: string const implicit; class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_call_macro returns smart_ptr< ast::CallMacro >

argument

argument type

name

string const implicit

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstCallMacro.

make_typeinfo_macro(name: string const implicit; class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_typeinfo_macro returns smart_ptr< ast::TypeInfoMacro >

argument

argument type

name

string const implicit

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstTypeInfo macro.

make_variant_macro(name: string const implicit; class: void? const implicit; info: rtti::StructInfo const? const implicit)

make_variant_macro returns smart_ptr< ast::VariantMacro >

argument

argument type

name

string const implicit

class

void? const implicit

info

rtti::StructInfo const? const implicit

Creates adapter for the AstVariantMacro.

make_clone_structure(structure: ast::Structure? const implicit)

make_clone_structure returns smart_ptr< ast::Function >

argument

argument type

structure

ast::Structure ? const implicit

Generates clone function for the given structure.

make_function_annotation(name: string const; someClassPtr: auto const)

make_function_annotation returns FunctionAnnotationPtr

argument

argument type

name

string const

someClassPtr

auto const

Creates adapter for the AstFunctionAnnotation.

make_block_annotation(name: string const; someClassPtr: auto const)

make_block_annotation returns FunctionAnnotationPtr

argument

argument type

name

string const

someClassPtr

auto const

Creates adapter for the AstBlockAnnotation.

make_structure_annotation(name: string const; someClassPtr: auto const)

make_structure_annotation returns StructureAnnotationPtr

argument

argument type

name

string const

someClassPtr

auto const

Creates adapter for the AstStructureAnnotation.

make_enumeration_annotation(name: string const; someClassPtr: auto const)

make_enumeration_annotation returns EnumerationAnnotationPtr

argument

argument type

name

string const

someClassPtr

auto const

Creates adapter for the AstEnumearationAnnotation.

make_visitor(someClass: auto const)

make_visitor returns smart_ptr< ast::VisitorAdapter >

argument

argument type

someClass

auto const

Creates adapter for the AstVisitor interface.

make_reader_macro(name: string const; someClassPtr: auto const)

make_reader_macro returns ReaderMacroPtr

argument

argument type

name

string const

someClassPtr

auto const

Creates adapter for the AstReaderMacro.

make_comment_reader(name: string const; someClassPtr: auto const)

make_comment_reader returns CommentReaderPtr

argument

argument type

name

string const

someClassPtr

auto const

Creates adapter for the AstCommentReader.

make_call_macro(name: string const; someClassPtr: auto const)

make_call_macro returns CallMacroPtr

argument

argument type

name

string const

someClassPtr

auto const

Creates adapter for the AstCallMacro.

make_typeinfo_macro(name: string const; someClassPtr: auto const)

make_typeinfo_macro returns TypeInfoMacroPtr

argument

argument type

name

string const

someClassPtr

auto const

Creates adapter for the AstTypeInfo macro.

make_pass_macro(name: string const; someClassPtr: auto const)

make_pass_macro returns PassMacroPtr

argument

argument type

name

string const

someClassPtr

auto const

Creates adapter for the AstPassMacro.

make_variant_macro(name: string const; someClassPtr: auto const)

make_variant_macro returns VariantMacroPtr

argument

argument type

name

string const

someClassPtr

auto const

Creates adapter for the AstVariantMacro.

12.11. Adapter application

add_function_annotation(module: rtti::Module? const implicit; annotation: smart_ptr<ast::FunctionAnnotation>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::FunctionAnnotation >& implicit

Adds function annotation to the given object. Calls apply if applicable.

add_function_annotation(function: smart_ptr<ast::Function> const implicit; annotation: smart_ptr<ast::FunctionAnnotation>& implicit)

argument

argument type

function

smart_ptr< ast::Function > const implicit

annotation

smart_ptr< ast::FunctionAnnotation >& implicit

Adds function annotation to the given object. Calls apply if applicable.

add_function_annotation(function: smart_ptr<ast::Function> const implicit; annotation: smart_ptr<rtti::AnnotationDeclaration>& implicit)

argument

argument type

function

smart_ptr< ast::Function > const implicit

annotation

smart_ptr< rtti::AnnotationDeclaration >& implicit

Adds function annotation to the given object. Calls apply if applicable.

add_structure_annotation(module: rtti::Module? const implicit; annotation: smart_ptr<ast::StructureAnnotation>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::StructureAnnotation >& implicit

Adds structure annotation to the given object. Calls apply if applicable.

add_structure_annotation(structure: smart_ptr<ast::Structure> const implicit; annotation: smart_ptr<ast::StructureAnnotation>& implicit)

argument

argument type

structure

smart_ptr< ast::Structure > const implicit

annotation

smart_ptr< ast::StructureAnnotation >& implicit

Adds structure annotation to the given object. Calls apply if applicable.

add_enumeration_annotation(module: rtti::Module? const implicit; annotation: smart_ptr<ast::EnumerationAnnotation>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::EnumerationAnnotation >& implicit

Adds enumeration annotation to the given object. Calls apply if applicable.

add_infer_macro(module: rtti::Module? const implicit; annotation: smart_ptr<ast::PassMacro>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::PassMacro >& implicit

Adds AstPassMacro adapter to the infer` pass.

add_dirty_infer_macro(module: rtti::Module? const implicit; annotation: smart_ptr<ast::PassMacro>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::PassMacro >& implicit

Adds AstPassMacro adapter to the dirty infer pass.

add_lint_macro(module: rtti::Module? const implicit; annotation: smart_ptr<ast::PassMacro>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::PassMacro >& implicit

Adds AstPassMacro adapter to the lint pass.

add_global_lint_macro(module: rtti::Module? const implicit; annotation: smart_ptr<ast::PassMacro>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::PassMacro >& implicit

Adds AstPassMacro adapter to the global lint pass.

add_optimization_macro(module: rtti::Module? const implicit; annotation: smart_ptr<ast::PassMacro>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::PassMacro >& implicit

Adds AstPassMacro adapter to the optimization pass.

add_reader_macro(module: rtti::Module? const implicit; annotation: smart_ptr<ast::ReaderMacro>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::ReaderMacro >& implicit

Adds AstReaderMacro adapter to the specific module.

add_comment_reader(module: rtti::Module? const implicit; reader: smart_ptr<ast::CommentReader>& implicit)

argument

argument type

module

rtti::Module ? const implicit

reader

smart_ptr< ast::CommentReader >& implicit

Adds AstCommentReader adapter to the specific module.

add_call_macro(module: rtti::Module? const implicit; annotation: smart_ptr<ast::CallMacro>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::CallMacro >& implicit

Adds AstCallMacro adapter to the specific module.

add_typeinfo_macro(module: rtti::Module? const implicit; annotation: smart_ptr<ast::TypeInfoMacro>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::TypeInfoMacro >& implicit

Adds AstTypeInfo adapter to the specific module.

add_variant_macro(module: rtti::Module? const implicit; annotation: smart_ptr<ast::VariantMacro>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr< ast::VariantMacro >& implicit

Adds AstVariantMacro to the specific module.

add_new_block_annotation(name: string const; someClassPtr: auto const)

add_new_block_annotation returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstBlockAnnotation and adds it to the current module.

add_new_function_annotation(name: string const; someClassPtr: auto const)

add_new_function_annotation returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstFunctionAnnotation and adds it to the current module.

add_new_contract_annotation(name: string const; someClassPtr: auto const)

add_new_contract_annotation returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstContractAnnotation and adds it to the current module.

add_new_structure_annotation(name: string const; someClassPtr: auto const)

add_new_structure_annotation returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstStructureAnnotation and adds it to the current module.

add_new_enumeration_annotation(name: string const; someClassPtr: auto const)

add_new_enumeration_annotation returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstEnumerationAnnotation and adds it to the current module.

add_new_variant_macro(name: string const; someClassPtr: auto const)

add_new_variant_macro returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstVariantMacro and adds it to the current module.

add_new_reader_macro(name: string const; someClassPtr: auto const)

add_new_reader_macro returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstReaderMacro and adds it to the current module.

add_new_comment_reader(name: string const; someClassPtr: auto const)

add_new_comment_reader returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstCommentReader and adds it to the current module.

add_new_call_macro(name: string const; someClassPtr: auto const)

add_new_call_macro returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstCallMacro and adds it to the current module.

add_new_typeinfo_macro(name: string const; someClassPtr: auto const)

add_new_typeinfo_macro returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstTypeInfoMacro and adds it to the current module.

add_new_infer_macro(name: string const; someClassPtr: auto const)

add_new_infer_macro returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstPassMacro and adds it to the current module infer pass.

add_new_dirty_infer_macro(name: string const; someClassPtr: auto const)

add_new_dirty_infer_macro returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstPassMacro and adds it to the current module dirty infer pass.

add_new_lint_macro(name: string const; someClassPtr: auto const)

add_new_lint_macro returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstPassMacro and adds it to the current module lint pass.

add_new_global_lint_macro(name: string const; someClassPtr: auto const)

add_new_global_lint_macro returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstPassMacro and adds it to the current module global lint pass.

add_new_optimization_macro(name: string const; someClassPtr: auto const)

add_new_optimization_macro returns auto

argument

argument type

name

string const

someClassPtr

auto const

Makes adapter to the AstPassMacro and adds it to the current module optimization pass.

12.12. Adding objects to objects

add_enumeration_entry(enum: smart_ptr<ast::Enumeration> const implicit; name: string const implicit)

add_enumeration_entry returns int

argument

argument type

enum

smart_ptr< ast::Enumeration > const implicit

name

string const implicit

Adds entry to enumeration annotation.

add_function(module: rtti::Module? const implicit; function: smart_ptr<ast::Function>& implicit)

add_function returns bool

argument

argument type

module

rtti::Module ? const implicit

function

smart_ptr< ast::Function >& implicit

Adds function to a Module. Will return false on duplicates.

add_generic(module: rtti::Module? const implicit; function: smart_ptr<ast::Function>& implicit)

add_generic returns bool

argument

argument type

module

rtti::Module ? const implicit

function

smart_ptr< ast::Function >& implicit

Adds generic function to a Module. Will return false on duplicates.

add_variable(module: rtti::Module? const implicit; variable: smart_ptr<ast::Variable>& implicit)

add_variable returns bool

argument

argument type

module

rtti::Module ? const implicit

variable

smart_ptr< ast::Variable >& implicit

Adds variable to a Module. Will return false on duplicates.

add_structure(module: rtti::Module? const implicit; structure: smart_ptr<ast::Structure>& implicit)

add_structure returns bool

argument

argument type

module

rtti::Module ? const implicit

structure

smart_ptr< ast::Structure >& implicit

Adds structure to a Module. Will return false on duplicates.

12.13. Program and module access

this_program()

this_program returns smart_ptr< rtti::Program >

Program attached to the current context (or null if RTTI is disabled).

this_module()

this_module returns rtti::Module ?

Main module attached to the current context (will through if RTTI is disabled).

compiling_program()

compiling_program returns smart_ptr< rtti::Program >

Currently compiling program.

compiling_module()

compiling_module returns rtti::Module ?

Currently compiling module.

12.14. Textual descriptions of the objects

describe_typedecl(type: smart_ptr<ast::TypeDecl> const implicit; extra: bool const; contracts: bool const; module: bool const)

describe_typedecl returns string

argument

argument type

type

smart_ptr< ast::TypeDecl > const implicit

extra

bool const

contracts

bool const

module

bool const

Returns description of the TypeDecl which should match corresponding daScript type declaration.

describe_typedecl_cpp(type: smart_ptr<ast::TypeDecl> const implicit; substitueRef: bool const; skipRef: bool const; skipConst: bool const; redundantConst: bool const)

describe_typedecl_cpp returns string

argument

argument type

type

smart_ptr< ast::TypeDecl > const implicit

substitueRef

bool const

skipRef

bool const

skipConst

bool const

redundantConst

bool const

Returns description of the TypeDecl which should match corresponding C++ type declaration.

describe_expression(expression: smart_ptr<ast::Expression> const implicit)

describe_expression returns string

argument

argument type

expression

smart_ptr< ast::Expression > const implicit

Returns description of the Expression which should match corresponding daScript code.

describe_function(function: smart_ptr<ast::Function> const implicit)

describe_function returns string

argument

argument type

function

smart_ptr< ast::Function > const implicit

Returns description of the Function which should match corresponding daScript function declaration.

das_to_string(type: Type const)

das_to_string returns string

argument

argument type

type

rtti::Type const

Returns description (name) of the corresponding Type.

describe(decl: smart_ptr<ast::TypeDecl> const; extra: bool const; contracts: bool const; modules: bool const)

describe returns auto

argument

argument type

decl

smart_ptr< ast::TypeDecl > const

extra

bool const

contracts

bool const

modules

bool const

Describes object and produces corresponding daScript code as string.

describe_cpp(decl: smart_ptr<ast::TypeDecl> const; substitureRef: bool const; skipRef: bool const; skipConst: bool const; redundantConst: bool const)

describe_cpp returns auto

argument

argument type

decl

smart_ptr< ast::TypeDecl > const

substitureRef

bool const

skipRef

bool const

skipConst

bool const

redundantConst

bool const

Describes TypeDecl and produces corresponding C++ code as a string.

describe(expr: smart_ptr<ast::Expression> const)

describe returns auto

argument

argument type

expr

smart_ptr< ast::Expression > const

Describes object and produces corresponding daScript code as string.

describe(expr: smart_ptr<ast::Function> const)

describe returns auto

argument

argument type

expr

smart_ptr< ast::Function > const

Describes object and produces corresponding daScript code as string.

12.15. Searching

find_module_via_rtti(program: smart_ptr<rtti::Program> const implicit; name: string const implicit)

find_module_via_rtti returns rtti::Module ?

argument

argument type

program

smart_ptr< rtti::Program > const implicit

name

string const implicit

Find module by name in the Program.

find_module_function_via_rtti(module: rtti::Module? const implicit; function: function<> const)

find_module_function_via_rtti returns smart_ptr< ast::Function >

argument

argument type

module

rtti::Module ? const implicit

function

function<> const

Find function by name in the Module.

find_variable(module: rtti::Module? const implicit; variable: string const implicit)

find_variable returns smart_ptr< ast::Variable >

argument

argument type

module

rtti::Module ? const implicit

variable

string const implicit

Finds variable in the Module.

find_bitfield_name(bit: smart_ptr<ast::TypeDecl> const implicit; value: bitfield const)

find_bitfield_name returns string

argument

argument type

bit

smart_ptr< ast::TypeDecl > const implicit

value

bitfield<> const

Finds name of the corresponding bitfield value in the specified type.

find_enum_value(enum: smart_ptr<ast::Enumeration> const implicit; value: string const implicit)

find_enum_value returns int64

argument

argument type

enum

smart_ptr< ast::Enumeration > const implicit

value

string const implicit

Finds name of the corresponding enumeration value in the specified type.

find_module(prog: smart_ptr<rtti::Program> const; name: string const)

find_module returns rtti::Module ?

argument

argument type

prog

smart_ptr< rtti::Program > const

name

string const

Finds Module in the Program.

find_module(name: string const)

find_module returns rtti::Module ?

argument

argument type

name

string const

Finds Module in the Program.

find_compiling_module(name: string const)

find_compiling_module returns rtti::Module ?

argument

argument type

name

string const

Finds Module in the currently compiling Program.

12.16. Iterating

for_each_function(module: rtti::Module? const implicit; name: string const implicit; block: block<(smart_ptr<ast::Function>):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

name

string const implicit

block

block<(smart_ptr< ast::Function >):void> const implicit

Iterates through each function in the given Module.

for_each_generic(module: rtti::Module? const implicit; name: string const implicit; block: block<(smart_ptr<ast::Function>):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

name

string const implicit

block

block<(smart_ptr< ast::Function >):void> const implicit

Iterates through each generic function in the given Module.

any_table_foreach(table: void? const implicit; keyStride: int const; valueStride: int const; block: block<(void?;void?):void> const implicit)

argument

argument type

table

void? const implicit

keyStride

int const

valueStride

int const

block

block<(void?;void?):void> const implicit

Iterates through any table<> type in a typeless fasion (via void?)

any_array_foreach(array: void? const implicit; stride: int const; block: block<(void?):void> const implicit)

argument

argument type

array

void? const implicit

stride

int const

block

block<(void?):void> const implicit

Iterates through any array<> type in a typeless fasion (via void?)

for_each_typedef(module: rtti::Module? const implicit; block: block<(string#;smart_ptr<ast::TypeDecl>):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

block

block<(string#;smart_ptr< ast::TypeDecl >):void> const implicit

Iterates through every typedef in the Module.

for_each_enumeration(module: rtti::Module? const implicit; block: block<(smart_ptr<ast::Enumeration>):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

block

block<(smart_ptr< ast::Enumeration >):void> const implicit

Iterates through every enumeration in the Module.

for_each_structure(module: rtti::Module? const implicit; block: block<(smart_ptr<ast::Structure>):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

block

block<(smart_ptr< ast::Structure >):void> const implicit

Iterates through every structure in the Module.

for_each_generic(module: rtti::Module? const implicit; block: block<(smart_ptr<ast::Function>):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

block

block<(smart_ptr< ast::Function >):void> const implicit

Iterates through each generic function in the given Module.

for_each_global(module: rtti::Module? const implicit; block: block<(smart_ptr<ast::Variable>):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

block

block<(smart_ptr< ast::Variable >):void> const implicit

Iterates through every global variable in the Module.

for_each_call_macro(module: rtti::Module? const implicit; block: block<(string#):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

block

block<(string#):void> const implicit

Iterates through every CallMacro adapter in the Module.

for_each_reader_macro(module: rtti::Module? const implicit; block: block<(string#):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

block

block<(string#):void> const implicit

Iterates through each reader macro in the given Module.

for_each_variant_macro(module: rtti::Module? const implicit; block: block<(smart_ptr<ast::VariantMacro>):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

block

block<(smart_ptr< ast::VariantMacro >):void> const implicit

Iterates through each variant macro in the given Module.

for_each_typeinfo_macro(module: rtti::Module? const implicit; block: block<(smart_ptr<ast::TypeInfoMacro>):void> const implicit)

argument

argument type

module

rtti::Module ? const implicit

block

block<(smart_ptr< ast::TypeInfoMacro >):void> const implicit

Iterates through each typeinfo macro in the given Module.

for_each_field(annotation: BasicStructureAnnotation const implicit; block: block<(string;string;smart_ptr<ast::TypeDecl>;uint):void> const implicit)

argument

argument type

annotation

rtti::BasicStructureAnnotation const implicit

block

block<(string;string;smart_ptr< ast::TypeDecl >;uint):void> const implicit

Iterates through every field in the BuiltinStructure handled type.

12.17. Cloning

clone_structure(structure: ast::Structure const? const implicit)

clone_structure returns smart_ptr< ast::Structure >

argument

argument type

structure

ast::Structure const? const implicit

Returns clone of the Structure.

clone_expression(expression: smart_ptr<ast::Expression> const implicit)

clone_expression returns smart_ptr< ast::Expression >

argument

argument type

expression

smart_ptr< ast::Expression > const implicit

Clones Expression with subexpressions, including corresponding type.

clone_function(function: smart_ptr<ast::Function> const implicit)

clone_function returns smart_ptr< ast::Function >

argument

argument type