#-----| [CopyAssignmentOperator] __va_list_tag& __va_list_tag::operator=(__va_list_tag const&)

#-----| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const __va_list_tag &

#-----| [MoveAssignmentOperator] __va_list_tag& __va_list_tag::operator=(__va_list_tag&&)

#-----| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] __va_list_tag &&

#-----| [Operator,TopLevelFunction] void operator delete(void*)

#-----| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [VoidPointerType] void *

#-----| [Operator,TopLevelFunction] void* operator new(unsigned long)

#-----| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LongType] unsigned long

AddressOf.c:

# 1| [TopLevelFunction] void AddressOf(int)

# 1| <params>:

# 1| getParameter(0): [Parameter] i

# 1| Type = [IntType] int

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [DeclStmt] declaration

# 2| getDeclarationEntry(0): [VariableDeclarationEntry] definition of j

# 2| Type = [IntPointerType] int *

# 2| getVariable().getInitializer(): [Initializer] initializer for j

# 2| getExpr(): [AddressOfExpr] & ...

# 2| Type = [IntPointerType] int *

# 2| ValueCategory = prvalue

# 2| getOperand(): [VariableAccess] i

# 2| Type = [IntType] int

# 2| ValueCategory = lvalue

# 3| getStmt(1): [ReturnStmt] return ...

ArrayToPointer.c:

# 5| [TopLevelFunction] void ArrayToPointer()

# 5| <params>:

# 6| getEntryPoint(): [BlockStmt] { ... }

# 7| getStmt(0): [DeclStmt] declaration

# 7| getDeclarationEntry(0): [VariableDeclarationEntry] definition of c

# 7| Type = [ArrayType] char[]

# 7| getVariable().getInitializer(): [Initializer] initializer for c

# 7| getExpr(): hello

# 7| Type = [ArrayType] char[6]

# 7| Value = [StringLiteral] "hello"

# 7| ValueCategory = lvalue

# 8| getStmt(1): [DeclStmt] declaration

# 8| getDeclarationEntry(0): [VariableDeclarationEntry] definition of s

# 8| Type = [Struct] S

# 9| getStmt(2): [ExprStmt] ExprStmt

# 9| getExpr(): [AssignExpr] ... = ...

# 9| Type = [CharPointerType] char *

# 9| ValueCategory = prvalue

# 9| getLValue(): [ValueFieldAccess] name

# 9| Type = [CharPointerType] char *

# 9| ValueCategory = lvalue

# 9| getQualifier(): [VariableAccess] s

# 9| Type = [Struct] S

# 9| ValueCategory = lvalue

# 9| getRValue(): [VariableAccess] c

# 9| Type = [ArrayType] char[6]

# 9| ValueCategory = lvalue

# 9| getRValue().getFullyConverted(): [ArrayToPointerConversion] array to pointer conversion

# 9| Type = [CharPointerType] char *

# 9| ValueCategory = prvalue

# 10| getStmt(3): [ReturnStmt] return ...

Cast.c:

# 1| [TopLevelFunction] void Cast(char*, void*)

# 1| <params>:

# 1| getParameter(0): [Parameter] c

# 1| Type = [CharPointerType] char *

# 1| getParameter(1): [Parameter] v

# 1| Type = [VoidPointerType] void *

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [ExprStmt] ExprStmt

# 2| getExpr(): [AssignExpr] ... = ...

# 2| Type = [CharPointerType] char *

# 2| ValueCategory = prvalue

# 2| getLValue(): [VariableAccess] c

# 2| Type = [CharPointerType] char *

# 2| ValueCategory = lvalue

# 2| getRValue(): [VariableAccess] v

# 2| Type = [VoidPointerType] void *

# 2| ValueCategory = prvalue(load)

# 2| getRValue().getFullyConverted(): [CStyleCast] (char *)...

# 2| Conversion = [PointerConversion] pointer conversion

# 2| Type = [CharPointerType] char *

# 2| ValueCategory = prvalue

# 3| getStmt(1): [ReturnStmt] return ...

ConditionDecl.cpp:

# 1| [TopLevelFunction] void ConditionDecl()

# 1| <params>:

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [DeclStmt] declaration

# 2| getDeclarationEntry(0): [VariableDeclarationEntry] definition of j

# 2| Type = [IntType] int

# 2| getVariable().getInitializer(): [Initializer] initializer for j

# 2| getExpr(): [Literal] 0

# 2| Type = [IntType] int

# 2| Value = [Literal] 0

# 2| ValueCategory = prvalue

# 3| getStmt(1): [WhileStmt] while (...) ...

# 3| getCondition(): [ConditionDeclExpr] (condition decl)

# 3| Type = [BoolType] bool

# 3| ValueCategory = prvalue

# 3| getVariableAccess(): [VariableAccess] k

# 3| Type = [IntType] int

# 3| ValueCategory = prvalue(load)

# 3| getInitializingExpr(): [LTExpr] ... < ...

# 3| Type = [BoolType] bool

# 3| ValueCategory = prvalue

# 3| getLesserOperand(): [VariableAccess] j

# 3| Type = [IntType] int

# 3| ValueCategory = prvalue(load)

# 3| getGreaterOperand(): [Literal] 5

# 3| Type = [IntType] int

# 3| Value = [Literal] 5

# 3| ValueCategory = prvalue

# 3| getVariableAccess().getFullyConverted(): [CStyleCast] (bool)...

# 3| Conversion = [BoolConversion] conversion to bool

# 3| Type = [BoolType] bool

# 3| ValueCategory = prvalue

# 3| getInitializingExpr().getFullyConverted(): [CStyleCast] (int)...

# 3| Conversion = [IntegralConversion] integral conversion

# 3| Type = [IntType] int

# 3| ValueCategory = prvalue

# 3| getStmt(): [BlockStmt] { ... }

# 5| getStmt(2): [ReturnStmt] return ...

ConstructorCall.cpp:

# 1| [CopyAssignmentOperator] C& C::operator=(C const&)

# 1| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const C &

# 1| [MoveAssignmentOperator] C& C::operator=(C&&)

# 1| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] C &&

# 1| [CopyConstructor] void C::C(C const&)

# 1| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const C &

# 1| [MoveConstructor] void C::C(C&&)

# 1| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] C &&

# 3| [Constructor] void C::C(int)

# 3| <params>:

# 3| getParameter(0): [Parameter] i

# 3| Type = [IntType] int

# 3| <initializations>:

# 3| getEntryPoint(): [BlockStmt] { ... }

# 4| getStmt(0): [ReturnStmt] return ...

# 7| [CopyAssignmentOperator] D& D::operator=(D const&)

# 7| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const D &

# 7| [MoveAssignmentOperator] D& D::operator=(D&&)

# 7| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] D &&

# 7| [CopyConstructor] void D::D(D const&)

# 7| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const D &

# 7| [MoveConstructor] void D::D(D&&)

# 7| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] D &&

# 9| [Constructor] void D::D()

# 9| <params>:

# 9| <initializations>:

# 9| getEntryPoint(): [BlockStmt] { ... }

# 10| getStmt(0): [ReturnStmt] return ...

# 13| [CopyAssignmentOperator] E& E::operator=(E const&)

# 13| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const E &

# 13| [MoveAssignmentOperator] E& E::operator=(E&&)

# 13| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] E &&

# 17| [TopLevelFunction] void ConstructorCall(C*, D*, E*)

# 17| <params>:

# 17| getParameter(0): [Parameter] c

# 17| Type = [PointerType] C *

# 17| getParameter(1): [Parameter] d

# 17| Type = [PointerType] D *

# 17| getParameter(2): [Parameter] e

# 17| Type = [PointerType] E *

# 17| getEntryPoint(): [BlockStmt] { ... }

# 18| getStmt(0): [ExprStmt] ExprStmt

# 18| getExpr(): [AssignExpr] ... = ...

# 18| Type = [PointerType] C *

# 18| ValueCategory = lvalue

# 18| getLValue(): [VariableAccess] c

# 18| Type = [PointerType] C *

# 18| ValueCategory = lvalue

# 18| getRValue(): [NewExpr] new

# 18| Type = [PointerType] C *

# 18| ValueCategory = prvalue

# 18| getInitializer(): [ConstructorCall] call to C

# 18| Type = [VoidType] void

# 18| ValueCategory = prvalue

# 18| getArgument(0): [Literal] 5

# 18| Type = [IntType] int

# 18| Value = [Literal] 5

# 18| ValueCategory = prvalue

# 19| getStmt(1): [ExprStmt] ExprStmt

# 19| getExpr(): [AssignExpr] ... = ...

# 19| Type = [PointerType] D *

# 19| ValueCategory = lvalue

# 19| getLValue(): [VariableAccess] d

# 19| Type = [PointerType] D *

# 19| ValueCategory = lvalue

# 19| getRValue(): [NewExpr] new

# 19| Type = [PointerType] D *

# 19| ValueCategory = prvalue

# 19| getInitializer(): [ConstructorCall] call to D

# 19| Type = [VoidType] void

# 19| ValueCategory = prvalue

# 20| getStmt(2): [ExprStmt] ExprStmt

# 20| getExpr(): [AssignExpr] ... = ...

# 20| Type = [PointerType] E *

# 20| ValueCategory = lvalue

# 20| getLValue(): [VariableAccess] e

# 20| Type = [PointerType] E *

# 20| ValueCategory = lvalue

# 20| getRValue(): [NewExpr] new

# 20| Type = [PointerType] E *

# 20| ValueCategory = prvalue

# 20| getInitializer(): [Literal] 0

# 20| Type = [Class] E

# 20| Value = [Literal] 0

# 20| ValueCategory = prvalue

# 21| getStmt(3): [ReturnStmt] return ...

Conversion1.c:

# 1| [TopLevelFunction] void Conversion1()

# 1| <params>:

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [DeclStmt] declaration

# 2| getDeclarationEntry(0): [VariableDeclarationEntry] definition of i

# 2| Type = [IntType] int

# 2| getVariable().getInitializer(): [Initializer] initializer for i

# 2| getExpr(): [Literal] 1

# 2| Type = [IntType] int

# 2| Value = [Literal] 1

# 2| ValueCategory = prvalue

# 2| getExpr().getFullyConverted(): [CStyleCast] (int)...

# 2| Conversion = [IntegralConversion] integral conversion

# 2| Type = [IntType] int

# 2| Value = [CStyleCast] 1

# 2| ValueCategory = prvalue

# 3| getStmt(1): [ReturnStmt] return ...

Conversion2.c:

# 1| [TopLevelFunction] void Conversion2(int)

# 1| <params>:

# 1| getParameter(0): [Parameter] x

# 1| Type = [IntType] int

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [ExprStmt] ExprStmt

# 2| getExpr(): [AssignExpr] ... = ...

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue

# 2| getLValue(): [VariableAccess] x

# 2| Type = [IntType] int

# 2| ValueCategory = lvalue

# 2| getRValue(): [AddExpr] ... + ...

# 2| Type = [IntType] int

# 2| Value = [AddExpr] 12

# 2| ValueCategory = prvalue

# 2| getLeftOperand(): [Literal] 5

# 2| Type = [IntType] int

# 2| Value = [Literal] 5

# 2| ValueCategory = prvalue

# 2| getRightOperand(): [Literal] 7

# 2| Type = [IntType] int

# 2| Value = [Literal] 7

# 2| ValueCategory = prvalue

# 2| getLeftOperand().getFullyConverted(): [CStyleCast] (int)...

# 2| Conversion = [IntegralConversion] integral conversion

# 2| Type = [IntType] int

# 2| Value = [CStyleCast] 5

# 2| ValueCategory = prvalue

# 2| getRightOperand().getFullyConverted(): [CStyleCast] (int)...

# 2| Conversion = [IntegralConversion] integral conversion

# 2| Type = [IntType] int

# 2| Value = [CStyleCast] 7

# 2| ValueCategory = prvalue

# 3| getStmt(1): [ReturnStmt] return ...

Conversion3.cpp:

# 1| [TopLevelFunction] void Conversion3(int)

# 1| <params>:

# 1| getParameter(0): [Parameter] x

# 1| Type = [IntType] int

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [ExprStmt] ExprStmt

# 2| getExpr(): [AssignExpr] ... = ...

# 2| Type = [IntType] int

# 2| ValueCategory = lvalue

# 2| getLValue(): [VariableAccess] x

# 2| Type = [IntType] int

# 2| ValueCategory = lvalue

# 2| getRValue(): [AddExpr] ... + ...

# 2| Type = [IntType] int

# 2| Value = [AddExpr] 8

# 2| ValueCategory = prvalue

# 2| getLeftOperand(): [Literal] 5

# 2| Type = [IntType] int

# 2| Value = [Literal] 5

# 2| ValueCategory = prvalue

# 2| getRightOperand(): [Literal] 7

# 2| Type = [IntType] int

# 2| Value = [Literal] 7

# 2| ValueCategory = prvalue

# 2| getLeftOperand().getFullyConverted(): [CStyleCast] (int)...

# 2| Conversion = [IntegralConversion] integral conversion

# 2| Type = [IntType] int

# 2| Value = [CStyleCast] 1

# 2| ValueCategory = prvalue

# 2| getExpr(): [CStyleCast] (bool)...

# 2| Conversion = [BoolConversion] conversion to bool

# 2| Type = [BoolType] bool

# 2| Value = [CStyleCast] 1

# 2| ValueCategory = prvalue

# 2| getExpr(): [CStyleCast] (int)...

# 2| Conversion = [IntegralConversion] integral conversion

# 2| Type = [IntType] int

# 2| Value = [CStyleCast] 5

# 2| ValueCategory = prvalue

# 2| getRightOperand().getFullyConverted(): [ParenthesisExpr] (...)

# 2| Type = [IntType] int

# 2| Value = [ParenthesisExpr] 7

# 2| ValueCategory = prvalue

# 2| getExpr(): [CStyleCast] (int)...

# 2| Conversion = [IntegralConversion] integral conversion

# 2| Type = [IntType] int

# 2| Value = [CStyleCast] 7

# 2| ValueCategory = prvalue

# 3| getStmt(1): [ReturnStmt] return ...

Conversion4.c:

# 1| [TopLevelFunction] void Conversion4(int)

# 1| <params>:

# 1| getParameter(0): [Parameter] x

# 1| Type = [IntType] int

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [ExprStmt] ExprStmt

# 2| getExpr(): [AssignExpr] ... = ...

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue

# 2| getLValue(): [VariableAccess] x

# 2| Type = [IntType] int

# 2| ValueCategory = lvalue

# 2| getRValue(): [Literal] 7

# 2| Type = [IntType] int

# 2| Value = [Literal] 7

# 2| ValueCategory = prvalue

# 2| getRValue().getFullyConverted(): [ParenthesisExpr] (...)

# 2| Type = [IntType] int

# 2| Value = [ParenthesisExpr] 7

# 2| ValueCategory = prvalue

# 2| getExpr(): [CStyleCast] (int)...

# 2| Conversion = [IntegralConversion] integral conversion

# 2| Type = [IntType] int

# 2| Value = [CStyleCast] 7

# 2| ValueCategory = prvalue

# 3| getStmt(1): [ReturnStmt] return ...

# 5| [TopLevelFunction] char* retfn(void*)

# 5| <params>:

# 5| getParameter(0): [Parameter] v

# 5| Type = [VoidPointerType] void *

# 5| getEntryPoint(): [BlockStmt] { ... }

# 6| getStmt(0): [ReturnStmt] return ...

# 6| getExpr(): [VariableAccess] v

# 6| Type = [VoidPointerType] void *

# 6| ValueCategory = prvalue(load)

# 6| getExpr().getFullyConverted(): [CStyleCast] (char *)...

# 6| Conversion = [PointerConversion] pointer conversion

# 6| Type = [CharPointerType] char *

# 6| ValueCategory = prvalue

# 6| getExpr(): [CStyleCast] (void *)...

# 6| Conversion = [PointerConversion] pointer conversion

# 6| Type = [VoidPointerType] void *

# 6| ValueCategory = prvalue

# 6| getExpr(): [CStyleCast] (int *)...

# 6| Conversion = [PointerConversion] pointer conversion

# 6| Type = [IntPointerType] int *

# 6| ValueCategory = prvalue

# 9| [TopLevelFunction] void Conversion4_vardecl(int)

# 9| <params>:

# 9| getParameter(0): [Parameter] x

# 9| Type = [IntType] int

# 9| getEntryPoint(): [BlockStmt] { ... }

# 10| getStmt(0): [DeclStmt] declaration

# 10| getDeclarationEntry(0): [VariableDeclarationEntry] definition of y

# 10| Type = [LongType] long

# 10| getVariable().getInitializer(): [Initializer] initializer for y

# 10| getExpr(): [VariableAccess] x

# 10| Type = [IntType] int

# 10| ValueCategory = prvalue(load)

# 10| getExpr().getFullyConverted(): [CStyleCast] (long)...

# 10| Conversion = [IntegralConversion] integral conversion

# 10| Type = [LongType] long

# 10| ValueCategory = prvalue

# 11| getStmt(1): [ReturnStmt] return ...

DestructorCall.cpp:

# 1| [Constructor] void C::C()

# 1| <params>:

# 3| [Destructor] void C::~C()

# 3| <params>:

# 3| getEntryPoint(): [BlockStmt] { ... }

# 4| getStmt(0): [ReturnStmt] return ...

# 3| <destructions>:

# 11| [TopLevelFunction] void DestructorCall(C*, D*)

# 11| <params>:

# 11| getParameter(0): [Parameter] c

# 11| Type = [PointerType] C *

# 11| getParameter(1): [Parameter] d

# 11| Type = [PointerType] D *

# 11| getEntryPoint(): [BlockStmt] { ... }

# 12| getStmt(0): [ExprStmt] ExprStmt

# 12| getExpr(): [DeleteExpr] delete

# 12| Type = [VoidType] void

# 12| ValueCategory = prvalue

# 12| getDestructorCall(): [DestructorCall] call to ~C

# 12| Type = [VoidType] void

# 12| ValueCategory = prvalue

# 12| getQualifier(): [VariableAccess] c

# 12| Type = [PointerType] C *

# 12| ValueCategory = prvalue(load)

# 12| getExprWithReuse(): [ReuseExpr] reuse of c

# 12| Type = [PointerType] C *

# 12| ValueCategory = prvalue

# 13| getStmt(1): [ExprStmt] ExprStmt

# 13| getExpr(): [DeleteExpr] delete

# 13| Type = [VoidType] void

# 13| ValueCategory = prvalue

# 13| getExprWithReuse(): [VariableAccess] d

# 13| Type = [PointerType] D *

# 13| ValueCategory = prvalue(load)

# 14| getStmt(2): [ReturnStmt] return ...

DynamicCast.cpp:

# 1| [CopyAssignmentOperator] Base& Base::operator=(Base const&)

# 1| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const Base &

#-----| getEntryPoint(): [BlockStmt] { ... }

#-----| getStmt(0): [ReturnStmt] return ...

#-----| getExpr(): [PointerDereferenceExpr] * ...

#-----| Type = [Class] Base

#-----| ValueCategory = lvalue

#-----| getOperand(): [ThisExpr] this

#-----| Type = [PointerType] Base *

#-----| ValueCategory = prvalue(load)

#-----| getExpr().getFullyConverted(): [ReferenceToExpr] (reference to)

#-----| Type = [LValueReferenceType] Base &

#-----| ValueCategory = prvalue

# 1| [MoveAssignmentOperator] Base& Base::operator=(Base&&)

# 1| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] Base &&

# 1| [Constructor] void Base::Base()

# 1| <params>:

# 1| [CopyConstructor] void Base::Base(Base const&)

# 1| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const Base &

# 1| [MoveConstructor] void Base::Base(Base&&)

# 1| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] Base &&

# 2| [VirtualFunction] void Base::f()

# 2| <params>:

# 2| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [ReturnStmt] return ...

# 4| [CopyAssignmentOperator] Derived& Derived::operator=(Derived const&)

# 4| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const Derived &

#-----| getEntryPoint(): [BlockStmt] { ... }

#-----| getStmt(0): [ExprStmt] ExprStmt

# 4| getExpr(): [FunctionCall] call to operator=

# 4| Type = [LValueReferenceType] Base &

# 4| ValueCategory = prvalue

# 4| getQualifier(): [ThisExpr] this

# 4| Type = [PointerType] Derived *

# 4| ValueCategory = prvalue(load)

# 4| getArgument(0): [PointerDereferenceExpr] * ...

# 4| Type = [SpecifiedType] const Base

# 4| ValueCategory = lvalue

# 4| getOperand(): [AddressOfExpr] & ...

# 4| Type = [PointerType] const Derived *

# 4| ValueCategory = prvalue

# 4| getOperand(): [VariableAccess] (unnamed parameter 0)

# 4| Type = [LValueReferenceType] const Derived &

# 4| ValueCategory = prvalue(load)

#-----| getOperand().getFullyConverted(): [ReferenceDereferenceExpr] (reference dereference)

#-----| Type = [SpecifiedType] const Derived

#-----| ValueCategory = lvalue

#-----| getOperand().getFullyConverted(): [CStyleCast] (const Base *)...

#-----| Conversion = [BaseClassConversion] base class conversion

#-----| Type = [PointerType] const Base *

#-----| ValueCategory = prvalue

#-----| getQualifier().getFullyConverted(): [CStyleCast] (Base *)...

#-----| Conversion = [BaseClassConversion] base class conversion

#-----| Type = [PointerType] Base *

#-----| ValueCategory = prvalue

#-----| getArgument(0).getFullyConverted(): [ReferenceToExpr] (reference to)

#-----| Type = [LValueReferenceType] const Base &

#-----| ValueCategory = prvalue

#-----| getExpr().getFullyConverted(): [ReferenceDereferenceExpr] (reference dereference)

#-----| Type = [Class] Base

#-----| ValueCategory = lvalue

#-----| getStmt(1): [ReturnStmt] return ...

#-----| getExpr(): [PointerDereferenceExpr] * ...

#-----| Type = [Class] Derived

#-----| ValueCategory = lvalue

#-----| getOperand(): [ThisExpr] this

#-----| Type = [PointerType] Derived *

#-----| ValueCategory = prvalue(load)

#-----| getExpr().getFullyConverted(): [ReferenceToExpr] (reference to)

#-----| Type = [LValueReferenceType] Derived &

#-----| ValueCategory = prvalue

# 4| [MoveAssignmentOperator] Derived& Derived::operator=(Derived&&)

# 4| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] Derived &&

# 4| [Constructor] void Derived::Derived()

# 4| <params>:

# 4| [CopyConstructor] void Derived::Derived(Derived const&)

# 4| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const Derived &

# 4| [MoveConstructor] void Derived::Derived(Derived&&)

# 4| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] Derived &&

# 5| [VirtualFunction] void Derived::f()

# 5| <params>:

# 5| getEntryPoint(): [BlockStmt] { ... }

# 5| getStmt(0): [ReturnStmt] return ...

# 8| [TopLevelFunction] void DynamicCast(Base*, Derived*)

# 8| <params>:

# 8| getParameter(0): [Parameter] bp

# 8| Type = [PointerType] Base *

# 8| getParameter(1): [Parameter] d

# 8| Type = [PointerType] Derived *

# 8| getEntryPoint(): [BlockStmt] { ... }

# 9| getStmt(0): [ExprStmt] ExprStmt

# 9| getExpr(): [AssignExpr] ... = ...

# 9| Type = [PointerType] Derived *

# 9| ValueCategory = lvalue

# 9| getLValue(): [VariableAccess] d

# 9| Type = [PointerType] Derived *

# 9| ValueCategory = lvalue

# 9| getRValue(): [VariableAccess] bp

# 9| Type = [PointerType] Base *

# 9| ValueCategory = prvalue(load)

# 9| getRValue().getFullyConverted(): [DynamicCast] dynamic_cast<Derived *>...

# 9| Conversion = [DynamicCast] dynamic_cast

# 9| Type = [PointerType] Derived *

# 9| ValueCategory = prvalue

# 10| getStmt(1): [ReturnStmt] return ...

# 12| [TopLevelFunction] void DynamicCastRef(Base&, Derived&)

# 12| <params>:

# 12| getParameter(0): [Parameter] bp

# 12| Type = [LValueReferenceType] Base &

# 12| getParameter(1): [Parameter] d

# 12| Type = [LValueReferenceType] Derived &

# 12| getEntryPoint(): [BlockStmt] { ... }

# 13| getStmt(0): [ExprStmt] ExprStmt

# 13| getExpr(): [FunctionCall] call to operator=

# 13| Type = [LValueReferenceType] Derived &

# 13| ValueCategory = prvalue

# 13| getQualifier(): [VariableAccess] d

# 13| Type = [LValueReferenceType] Derived &

# 13| ValueCategory = prvalue(load)

# 13| getArgument(0): [VariableAccess] bp

# 13| Type = [LValueReferenceType] Base &

# 13| ValueCategory = prvalue(load)

# 13| getQualifier().getFullyConverted(): [ReferenceDereferenceExpr] (reference dereference)

# 13| Type = [Class] Derived

# 13| ValueCategory = lvalue

# 13| getArgument(0).getFullyConverted(): [ReferenceToExpr] (reference to)

# 13| Type = [LValueReferenceType] const Derived &

# 13| ValueCategory = prvalue

# 13| getExpr(): [CStyleCast] (const Derived)...

# 13| Conversion = [GlvalueConversion] glvalue conversion

# 13| Type = [SpecifiedType] const Derived

# 13| ValueCategory = lvalue

# 13| getExpr(): [DynamicCast] dynamic_cast<Derived>...

# 13| Conversion = [DynamicCast] dynamic_cast

# 13| Type = [Class] Derived

# 13| ValueCategory = lvalue

# 13| getExpr(): [ReferenceDereferenceExpr] (reference dereference)

# 13| Type = [Class] Base

# 13| ValueCategory = lvalue

# 13| getExpr().getFullyConverted(): [ReferenceDereferenceExpr] (reference dereference)

# 13| Type = [Class] Derived

# 13| ValueCategory = lvalue

# 14| getStmt(1): [ReturnStmt] return ...

Parenthesis.c:

# 1| [TopLevelFunction] void Parenthesis(int)

# 1| <params>:

# 1| getParameter(0): [Parameter] i

# 1| Type = [IntType] int

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [ExprStmt] ExprStmt

# 2| getExpr(): [AssignExpr] ... = ...

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue

# 2| getLValue(): [VariableAccess] i

# 2| Type = [IntType] int

# 2| ValueCategory = lvalue

# 2| getRValue(): [MulExpr] ... * ...

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue

# 2| getLeftOperand(): [AddExpr] ... + ...

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue

# 2| getLeftOperand(): [VariableAccess] i

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue(load)

# 2| getRightOperand(): [Literal] 1

# 2| Type = [IntType] int

# 2| Value = [Literal] 1

# 2| ValueCategory = prvalue

# 2| getRightOperand(): [Literal] 2

# 2| Type = [IntType] int

# 2| Value = [Literal] 2

# 2| ValueCategory = prvalue

# 2| getLeftOperand().getFullyConverted(): [ParenthesisExpr] (...)

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue

# 3| getStmt(1): [ReturnStmt] return ...

PointerDereference.c:

# 1| [TopLevelFunction] void PointerDereference(int*, int)

# 1| <params>:

# 1| getParameter(0): [Parameter] i

# 1| Type = [IntPointerType] int *

# 1| getParameter(1): [Parameter] j

# 1| Type = [IntType] int

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [ExprStmt] ExprStmt

# 2| getExpr(): [AssignExpr] ... = ...

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue

# 2| getLValue(): [VariableAccess] j

# 2| Type = [IntType] int

# 2| ValueCategory = lvalue

# 2| getRValue(): [PointerDereferenceExpr] * ...

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue(load)

# 2| getOperand(): [VariableAccess] i

# 2| Type = [IntPointerType] int *

# 2| ValueCategory = prvalue(load)

# 3| getStmt(1): [ReturnStmt] return ...

ReferenceDereference.cpp:

# 4| [TopLevelFunction] void ReferenceDereference(int&, int)

# 4| <params>:

# 4| getParameter(0): [Parameter] i

# 4| Type = [LValueReferenceType] int &

# 4| getParameter(1): [Parameter] j

# 4| Type = [IntType] int

# 4| getEntryPoint(): [BlockStmt] { ... }

# 5| getStmt(0): [ExprStmt] ExprStmt

# 5| getExpr(): [AssignExpr] ... = ...

# 5| Type = [IntType] int

# 5| ValueCategory = lvalue

# 5| getLValue(): [VariableAccess] j

# 5| Type = [IntType] int

# 5| ValueCategory = lvalue

# 5| getRValue(): [VariableAccess] i

# 5| Type = [LValueReferenceType] int &

# 5| ValueCategory = prvalue(load)

# 5| getRValue().getFullyConverted(): [ReferenceDereferenceExpr] (reference dereference)

# 5| Type = [IntType] int

# 5| ValueCategory = prvalue(load)

# 6| getStmt(1): [ReturnStmt] return ...

ReferenceTo.cpp:

# 1| [TopLevelFunction] int& ReferenceTo(int*)

# 1| <params>:

# 1| getParameter(0): [Parameter] i

# 1| Type = [IntPointerType] int *

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [ReturnStmt] return ...

# 2| getExpr(): [PointerDereferenceExpr] * ...

# 2| Type = [IntType] int

# 2| ValueCategory = lvalue

# 2| getOperand(): [VariableAccess] i

# 2| Type = [IntPointerType] int *

# 2| ValueCategory = prvalue(load)

# 2| getExpr().getFullyConverted(): [ReferenceToExpr] (reference to)

# 2| Type = [LValueReferenceType] int &

# 2| ValueCategory = prvalue

Sizeof.c:

# 1| [TopLevelFunction] void Sizeof(int[])

# 1| <params>:

# 1| getParameter(0): [Parameter] array

# 1| Type = [ArrayType] int[]

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [DeclStmt] declaration

# 2| getDeclarationEntry(0): [VariableDeclarationEntry] definition of i

# 2| Type = [IntType] int

# 2| getVariable().getInitializer(): [Initializer] initializer for i

# 2| getExpr(): [SizeofTypeOperator] sizeof(int)

# 2| Type = [LongType] unsigned long

# 2| Value = [SizeofTypeOperator] 4

# 2| ValueCategory = prvalue

# 2| getExpr().getFullyConverted(): [CStyleCast] (int)...

# 2| Conversion = [IntegralConversion] integral conversion

# 2| Type = [IntType] int

# 2| Value = [CStyleCast] 4

# 2| ValueCategory = prvalue

# 3| getStmt(1): [DeclStmt] declaration

# 3| getDeclarationEntry(0): [VariableDeclarationEntry] definition of j

# 3| Type = [IntType] int

# 3| getVariable().getInitializer(): [Initializer] initializer for j

# 3| getExpr(): [SizeofExprOperator] sizeof(<expr>)

# 3| Type = [LongType] unsigned long

# 3| Value = [SizeofExprOperator] 8

# 3| ValueCategory = prvalue

# 3| getExprOperand(): [VariableAccess] array

# 3| Type = [IntPointerType] int *

# 3| ValueCategory = lvalue

# 3| getExprOperand().getFullyConverted(): [ParenthesisExpr] (...)

# 3| Type = [IntPointerType] int *

# 3| ValueCategory = lvalue

# 3| getExpr().getFullyConverted(): [CStyleCast] (int)...

# 3| Conversion = [IntegralConversion] integral conversion

# 3| Type = [IntType] int

# 3| Value = [CStyleCast] 8

# 3| ValueCategory = prvalue

# 4| getStmt(2): [ReturnStmt] return ...

StatementExpr.c:

# 1| [TopLevelFunction] void StatementExpr()

# 1| <params>:

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [DeclStmt] declaration

# 2| getDeclarationEntry(0): [VariableDeclarationEntry] definition of j

# 2| Type = [IntType] int

# 2| getVariable().getInitializer(): [Initializer] initializer for j

# 2| getExpr(): [StmtExpr] (statement expression)

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue

# 2| getStmt(): [BlockStmt] { ... }

# 2| getStmt(0): [DeclStmt] declaration

# 2| getDeclarationEntry(0): [VariableDeclarationEntry] definition of i

# 2| Type = [IntType] int

# 2| getVariable().getInitializer(): [Initializer] initializer for i

# 2| getExpr(): [Literal] 5

# 2| Type = [IntType] int

# 2| Value = [Literal] 5

# 2| ValueCategory = prvalue

# 2| getStmt(1): [ExprStmt] ExprStmt

# 2| getExpr(): [VariableAccess] i

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue(load)

# 3| getStmt(1): [ReturnStmt] return ...

StaticMemberAccess.cpp:

# 1| [CopyAssignmentOperator] X& X::operator=(X const&)

# 1| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const X &

# 1| [MoveAssignmentOperator] X& X::operator=(X&&)

# 1| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] X &&

# 5| [TopLevelFunction] void StaticMemberAccess(int, X&)

# 5| <params>:

# 5| getParameter(0): [Parameter] i

# 5| Type = [IntType] int

# 5| getParameter(1): [Parameter] xref

# 5| Type = [LValueReferenceType] X &

# 5| getEntryPoint(): [BlockStmt] { ... }

# 7| getStmt(0): [ExprStmt] ExprStmt

# 7| getExpr(): [AssignExpr] ... = ...

# 7| Type = [IntType] int

# 7| ValueCategory = lvalue

# 7| getLValue(): [VariableAccess] i

# 7| Type = [IntType] int

# 7| ValueCategory = lvalue

# 7| getRValue(): [VariableAccess] i

# 7| Type = [IntType] int

# 7| ValueCategory = prvalue(load)

# 7| getQualifier(): [VariableAccess] xref

# 7| Type = [LValueReferenceType] X &

# 7| ValueCategory = prvalue(load)

# 7| getQualifier().getFullyConverted(): [ReferenceDereferenceExpr] (reference dereference)

# 7| Type = [Struct] X

# 7| ValueCategory = lvalue

# 9| getStmt(1): [ReturnStmt] return ...

Subscript.c:

# 1| [TopLevelFunction] void Subscript(int[], int)

# 1| <params>:

# 1| getParameter(0): [Parameter] i

# 1| Type = [ArrayType] int[]

# 1| getParameter(1): [Parameter] j

# 1| Type = [IntType] int

# 1| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [ExprStmt] ExprStmt

# 2| getExpr(): [AssignExpr] ... = ...

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue

# 2| getLValue(): [VariableAccess] j

# 2| Type = [IntType] int

# 2| ValueCategory = lvalue

# 2| getRValue(): [ArrayExpr] access to array

# 2| Type = [IntType] int

# 2| ValueCategory = prvalue(load)

# 2| getArrayBase(): [VariableAccess] i

# 2| Type = [IntPointerType] int *

# 2| ValueCategory = prvalue(load)

# 2| getArrayOffset(): [Literal] 5

# 2| Type = [IntType] int

# 2| Value = [Literal] 5

# 2| ValueCategory = prvalue

# 3| getStmt(1): [ReturnStmt] return ...

Throw.cpp:

# 2| [CopyAssignmentOperator] F& F::operator=(F const&)

# 2| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const F &

# 2| [MoveAssignmentOperator] F& F::operator=(F&&)

# 2| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] F &&

# 2| [CopyConstructor] void F::F(F const&)

# 2| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const F &

# 2| [MoveConstructor] void F::F(F&&)

# 2| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] F &&

# 2| <initializations>:

# 2| getEntryPoint(): [BlockStmt] { ... }

# 2| getStmt(0): [ReturnStmt] return ...

# 4| [Constructor] void F::F()

# 4| <params>:

# 4| <initializations>:

# 4| getEntryPoint(): [BlockStmt] { ... }

# 4| getStmt(0): [ReturnStmt] return ...

# 6| [TopLevelFunction] void Throw(int)

# 6| <params>:

# 6| getParameter(0): [Parameter] i

# 6| Type = [IntType] int

# 6| getEntryPoint(): [BlockStmt] { ... }

# 7| getStmt(0): [TryStmt] try { ... }

# 7| getStmt(): [BlockStmt] { ... }

# 8| getStmt(0): [IfStmt] if (...) ...

# 8| getCondition(): [VariableAccess] i

# 8| Type = [IntType] int

# 8| ValueCategory = prvalue(load)

# 9| getThen(): [ExprStmt] ExprStmt

# 9| getExpr(): [ThrowExpr] throw ...

# 9| Type = [Class] E

# 9| ValueCategory = prvalue

# 9| getExpr(): [Literal] 0

# 9| Type = [Class] E

# 9| Value = [Literal] 0

# 9| ValueCategory = prvalue

# 11| getElse(): [ExprStmt] ExprStmt

# 11| getExpr(): [ThrowExpr] throw ...

# 11| Type = [Class] F

# 11| ValueCategory = prvalue

# 11| getExpr(): [ConstructorCall] call to F

# 11| Type = [VoidType] void

# 11| ValueCategory = prvalue

# 8| getCondition().getFullyConverted(): [CStyleCast] (bool)...

# 8| Conversion = [BoolConversion] conversion to bool

# 8| Type = [BoolType] bool

# 8| ValueCategory = prvalue

# 12| getChild(1): [Handler] <handler>

# 12| getParameter(): [Parameter] e

# 12| Type = [PointerType] E *

# 12| getBlock(): [CatchBlock] { ... }

# 13| getStmt(0): [ExprStmt] ExprStmt

# 13| getExpr(): [ReThrowExpr] re-throw exception

# 13| Type = [VoidType] void

# 13| ValueCategory = prvalue

Typeid.cpp:

# 4| [CopyAssignmentOperator] std::type_info& std::type_info::operator=(std::type_info const&)

# 4| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [LValueReferenceType] const type_info &

# 4| [MoveAssignmentOperator] std::type_info& std::type_info::operator=(std::type_info&&)

# 4| <params>:

#-----| getParameter(0): [Parameter] (unnamed parameter 0)

#-----| Type = [RValueReferenceType] type_info &&

# 7| [ConstMemberFunction] char const* std::type_info::name() const

# 7| <params>:

# 13| [VirtualFunction] void Base::v()

# 13| <params>:

# 13| getEntryPoint(): [BlockStmt] { ... }

# 13| getStmt(0): [ReturnStmt] return ...

# 18| [TopLevelFunction] void TypeId(Base*)

# 18| <params>:

# 18| getParameter(0): [Parameter] bp

# 18| Type = [PointerType] Base *

# 18| getEntryPoint(): [BlockStmt] { ... }

# 19| getStmt(0): [DeclStmt] declaration

# 19| getDeclarationEntry(0): [VariableDeclarationEntry] definition of name

# 19| Type = [PointerType] const char *

# 19| getVariable().getInitializer(): [Initializer] initializer for name

# 19| getExpr(): [FunctionCall] call to name

# 19| Type = [PointerType] const char *

# 19| ValueCategory = prvalue

# 19| getQualifier(): [TypeidOperator] typeid ...

# 19| Type = [SpecifiedType] const type_info

# 19| ValueCategory = lvalue

# 19| getExpr(): [VariableAccess] bp

# 19| Type = [PointerType] Base *

# 19| ValueCategory = lvalue

# 20| getStmt(1): [ReturnStmt] return ...

VacuousDestructorCall.cpp:

# 2| [TemplateFunction,TopLevelFunction] void CallDestructor<T>(T, T*)

# 2| <params>:

# 2| getParameter(0): [Parameter] x

# 2| Type = [TypeTemplateParameter] T

# 2| getParameter(1): [Parameter] y

# 2| Type = [PointerType] T *

# 2| getEntryPoint(): [BlockStmt] { ... }

# 3| getStmt(0): [ExprStmt] ExprStmt

# 3| getExpr(): [ExprCall] call to expression

# 3| Type = [UnknownType] unknown

# 3| ValueCategory = prvalue

# 3| getExpr(): [Literal] Unknown literal

# 3| Type = [UnknownType] unknown

# 3| ValueCategory = prvalue

# 3| getChild(-1): [VariableAccess] x

# 3| Type = [TypeTemplateParameter] T

# 3| ValueCategory = lvalue

# 4| getStmt(1): [ExprStmt] ExprStmt

# 4| getExpr(): [ExprCall] call to expression

# 4| Type = [UnknownType] unknown

# 4| ValueCategory = prvalue

# 4| getExpr(): [Literal] Unknown literal

# 4| Type = [UnknownType] unknown

# 4| ValueCategory = prvalue

# 4| getChild(-1): [VariableAccess] y

# 4| Type = [PointerType] T *

# 4| ValueCategory = prvalue(load)

# 5| getStmt(2): [ReturnStmt] return ...

# 2| [FunctionTemplateInstantiation,TopLevelFunction] void CallDestructor<int>(int, int*)

# 2| <params>:

# 2| getParameter(0): [Parameter] x

# 2| Type = [IntType] int

# 2| getParameter(1): [Parameter] y

# 2| Type = [IntPointerType] int *

# 2| getEntryPoint(): [BlockStmt] { ... }

# 3| getStmt(0): [ExprStmt] ExprStmt

# 3| getExpr(): [VacuousDestructorCall] (vacuous destructor call)

# 3| Type = [VoidType] void

# 3| ValueCategory = prvalue

# 3| getChild(0): [VariableAccess] x

# 3| Type = [IntType] int

# 3| ValueCategory = lvalue

# 4| getStmt(1): [ExprStmt] ExprStmt

# 4| getExpr(): [VacuousDestructorCall] (vacuous destructor call)

# 4| Type = [VoidType] void

# 4| ValueCategory = prvalue

# 4| getChild(0): [VariableAccess] y

# 4| Type = [IntPointerType] int *

# 4| ValueCategory = prvalue(load)

# 5| getStmt(2): [ReturnStmt] return ...

# 7| [TopLevelFunction] void Vacuous(int)

# 7| <params>:

# 7| getParameter(0): [Parameter] i

# 7| Type = [IntType] int

# 7| getEntryPoint(): [BlockStmt] { ... }

# 10| getStmt(0): [ExprStmt] ExprStmt

# 10| getExpr(): [FunctionCall] call to CallDestructor

# 10| Type = [VoidType] void

# 10| ValueCategory = prvalue

# 10| getArgument(0): [VariableAccess] i

# 10| Type = [IntType] int

# 10| ValueCategory = prvalue(load)

# 10| getArgument(1): [AddressOfExpr] & ...

# 10| Type = [IntPointerType] int *

# 10| ValueCategory = prvalue

# 10| getOperand(): [VariableAccess] i

# 10| Type = [IntType] int

# 10| ValueCategory = lvalue

# 11| getStmt(1): [ReturnStmt] return ...

Varargs.c:

# 8| [TopLevelFunction] void VarArgs(char const*)

# 8| <params>:

# 8| getParameter(0): [Parameter] text

# 8| Type = [PointerType] const char *

# 8| getEntryPoint(): [BlockStmt] { ... }

# 9| getStmt(0): [DeclStmt] declaration

# 9| getDeclarationEntry(0): [VariableDeclarationEntry] definition of args

# 9| Type = [CTypedefType] va_list

# 10| getStmt(1): [ExprStmt] ExprStmt

# 10| getExpr(): [BuiltInVarArgsStart] __builtin_va_start

# 10| Type = [VoidType] void

# 10| ValueCategory = prvalue

# 10| getVAList(): [VariableAccess] args

# 10| Type = [CTypedefType] va_list

# 10| ValueCategory = lvalue

# 10| getLastNamedParameter(): [VariableAccess] text