top | up | prev | next

binder Namespace

Classes

struct ArgumentMatch
class ArityOperation
class ArrayCopyAssignmentOperation
class ArrayCopyConstructorOperation
class ArrayDefaultConstructorOperation
class ArrayElementAccessOperation
class ArrayMoveAssignmentOperation
class ArrayMoveConstructorOperation
class ArrayReferenceValue
class AttributeBinder
class AttributeProcessor
struct BetterFunctionMatch
struct BitNot
class BoundAddressOfExpression
class BoundAsExpression
class BoundAssignmentStatement
class BoundAtomicConstraint
class BoundBinaryConstraint
class BoundBitCast
class BoundBreakStatement
class BoundCaseStatement
class BoundCatchStatement
class BoundClass
class BoundClassDelegateCall
class BoundClassOrClassDelegateConversionResult
class BoundCompileUnit
class BoundCompoundStatement
class BoundConcept
struct BoundConceptKey
struct BoundConceptKeyHash
class BoundConjunction
class BoundConjunctiveConstraint
class BoundConstant
class BoundConstraint
class BoundConstructAndReturnTemporaryExpression
class BoundConstructExpression
class BoundConstructionStatement
class BoundContinueStatement
class BoundConversion
class BoundDefaultStatement
class BoundDelegateCall
class BoundDereferenceExpression
class BoundDisjunction
class BoundDisjunctiveConstraint
class BoundDoStatement
class BoundEmptyStatement
class BoundEnumConstant
class BoundEnumTypeDefinition
class BoundExpression
class BoundExpressionStatement
class BoundForStatement
class BoundFunction
class BoundFunctionCall
class BoundFunctionGroupExpression
class BoundFunctionPtr
class BoundGlobalVariable
class BoundGotoCaseStatement
class BoundGotoDefaultStatement
class BoundGotoStatement
class BoundIfStatement
class BoundInitializationStatement
class BoundIsExpression
class BoundLiteral
class BoundLocalVariable
class BoundMemberExpression
class BoundMemberVariable
class BoundNamespace
class BoundNamespaceExpression
class BoundNode
class BoundNodeVisitor
class BoundParameter
class BoundReferenceToPointerExpression
class BoundRethrowStatement
class BoundReturnStatement
class BoundSequenceStatement
class BoundSetVmtPtrStatement
class BoundSizeOfExpression
class BoundStatement
class BoundSwitchStatement
class BoundTemporary
class BoundThrowStatement
class BoundTryStatement
class BoundTypeExpression
class BoundTypeIdExpression
class BoundTypeNameExpression
class BoundWhileStatement
class CharacterPointerLiteralToStringFunctionContainerConversion
class ClassCopyAssignment
class ClassCopyAssignmentOperation
class ClassCopyConstructor
class ClassCopyConstructorOperation
class ClassDefaultConstructor
class ClassDefaultConstructorOperation
struct ClassIdMemberFunctionIndexHash
class ClassMoveAssignment
class ClassMoveAssignmentOperation
class ClassMoveConstructor
class ClassMoveConstructorOperation
class ClassTemplateRepository
class ClassTypeConversion
class ConceptIdResolver
class ConceptRepository
class ConstExprFunctionRepository
class ConstantArrayRepository
class ConstantStructureRepository
class ConstraintChecker
class ConstraintSymbolBinder
class ControlFlowAnalyzer
class Evaluator
class ExpressionBinder
class FunctionGroupValue
struct FunctionMatch
struct FunctionScopeLookup
struct FunctionTemplateKey
struct FunctionTemplateKeyHash
class FunctionTemplateRepository
struct Identity
class InlineFunctionRepository
class InterfaceCopyAssignmentOperation
class InterfaceCopyConstructorOperation
class InterfaceDefaultConstructorOperation
class InterfaceMoveAssignmentOperation
class InterfaceMoveConstructorOperation
class JsonAttributeProcessor
class JsonFieldNameAttributeProcessor
class LvalueRefefenceCopyCtor
class LvalueReferenceCopyAssignment
class LvalueReferenceCopyAssignmentOperation
class LvalueReferenceCopyConstructorOperation
class LvalueReferenceMoveAssignment
class LvalueReferenceMoveAssignmentOperation
class LvalueReferenceReturn
class LvalueReferenceReturnOperation
class NamespaceTypeSymbol
struct NamespaceVisitor
class NullPtrToPtrConversion
class OffsetPlusPointer
class OffsetPlusPointerOperation
class Operation
class OperationGroup
class OperationRepository
class PointerArrow
class PointerArrowOperation
class PointerCopyAssignment
class PointerCopyAssignmentOperation
class PointerCopyConstructorOperation
class PointerCopyCtor
class PointerDefaultConstructorOperation
class PointerDefaultCtor
class PointerEqual
class PointerEqualOperation
class PointerLess
class PointerLessOperation
class PointerMinusOffset
class PointerMinusOffsetOperation
class PointerMinusPointer
class PointerMinusPointerOperation
class PointerMoveAssignment
class PointerMoveAssignmentOperation
class PointerMoveConstructorOperation
class PointerMoveCtor
class PointerPlusOffset
class PointerPlusOffsetOperation
class PointerReturn
class PointerReturnOperation
class PtrToULongConversion
class PtrToVoidPtrConversion
class RvalueRefefenceCopyCtor
class RvalueReferenceCopyAssignment
class RvalueReferenceCopyAssignmentOperation
class RvalueReferenceCopyConstructorOperation
class RvalueReferenceReturn
class RvalueReferenceReturnOperation
class ScopedValue
class StatementBinder
class StringReferenceValue
class StringRepository
class StructuredReferenceValue
class SystemDefaultAttributeProcessor
class TypeBinder
class TypeResolver
class ULongToVoidPtrConversion
class UsingNodeAdder
class UuidRepository
class VariableValueSymbol
class VoidPtrToPtrConversion
class XmlAttributeProcessor
struct shiftLeftFun
struct shiftRightFun

Functions

Value* Add<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
void AnalyzeControlFlow(BoundCompileUnit& boundCompileUUnit)
std::vector<std::unique_ptr<Value>> ArgumentsToValues(const std::vector<std::unique_ptr<BoundExpression>>& arguments, bool& error, BoundCompileUnit& boundCompileUnit)
std::vector<std::unique_ptr<Value>> ArgumentsToValues(const std::vector<std::unique_ptr<BoundExpression>>& arguments, bool& error, bool skipFirst, BoundCompileUnit& boundCompileUnit)
bool BetterArgumentMatch(const ArgumentMatch& left, const ArgumentMatch& right) inline
Value* BinaryEvaluate<ValueT, Op>(Value* left, Value* right, Op op, const Span& span, const boost::uuids::uuid& moduleId)
Value* BinaryPredEvaluate<ValueT, Op>(Value* left, Value* right, Op op, const Span& span, const boost::uuids::uuid& moduleId)
void BindClass(ClassTypeSymbol* classType, void* boundCompileUnit)
std::unique_ptr<BoundExpression> BindExpression(Node* node, BoundCompileUnit& boundCompileUnit, BoundFunction* boundFunction, ContainerScope* containerScope, StatementBinder* statementBinder)
std::unique_ptr<BoundExpression> BindExpression(Node* node, BoundCompileUnit& boundCompileUnit, BoundFunction* boundFunction, ContainerScope* containerScope, StatementBinder* statementBinder, bool lvalue)
std::unique_ptr<BoundExpression> BindExpression(Node* node, BoundCompileUnit& boundCompileUnit, BoundFunction* boundFunction, ContainerScope* containerScope, StatementBinder* statementBinder, bool lvalue, bool acceptFunctionGroupOrMemberExpression)
std::unique_ptr<BoundExpression> BindExpression(Node* node, BoundCompileUnit& boundCompileUnit, BoundFunction* boundFunction, ContainerScope* containerScope, StatementBinder* statementBinder, bool lvalue, bool acceptFunctionGroupOrMemberExpression, bool acceptIncomplete)
std::unique_ptr<BoundExpression> BindExpression(Node* node, BoundCompileUnit& boundCompileUnit, BoundFunction* boundFunction, ContainerScope* containerScope, StatementBinder* statementBinder, bool lvalue, bool acceptFunctionGroupOrMemberExpression, bool acceptIncomplete, bool moveTemporaryDestructorCalls)
std::vector<std::string> BindTypes(Module* module, CompileUnitNode* compileUnit)
std::unique_ptr<BoundExpression> BindUnaryOp(BoundExpression* operand, Node& node, const std::u32string& groupName, BoundCompileUnit& boundCompileUnit, BoundFunction* boundFunction, ContainerScope* containerScope, StatementBinder* statementBinder)
Value* BitAnd<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* BitOr<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* BitXor<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
void CheckAccess(FunctionSymbol* fromFunction, Symbol* toSymbol)
bool CheckConstraint(ConstraintNode* constraint, const NodeList<Node>& usingNodes, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope, BoundFunction* currentFunction, const std::vector<TemplateParameterSymbol*>& templateParameters, const std::unordered_map<TemplateParameterSymbol*, TypeSymbol*>& templateParameterMap, std::unique_ptr<BoundConstraint>& boundConstraint, const Span& span, const boost::uuids::uuid& moduleId, FunctionSymbol* viableFunction, std::unique_ptr<Exception>& conceptCheckException)
void CheckFunctionReturnPaths(FunctionSymbol* functionSymbol, CompoundStatementNode* bodyNode, const Span& span, const boost::uuids::uuid& moduleId, ContainerScope* containerScope, BoundCompileUnit& boundCompileUnit)
void CheckFunctionReturnPaths(FunctionSymbol* functionSymbol, FunctionNode& functionNode, ContainerScope* containerScope, BoundCompileUnit& boundCompileUnit)
void CollectViableFunctionsFromSymbolTable(int arity, const std::u32string& groupName, const std::vector<FunctionScopeLookup>& functionScopeLookups, BoundCompileUnit& boundCompileUnit, ViableFunctionSet& viableFunctions)
Value* Complement<ValueT>(Value* subject, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* Conjunction<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
std::unique_ptr<BoundFunctionCall> CreateBoundFunctionCall(FunctionSymbol* bestFun, std::vector<std::unique_ptr<BoundExpression>>& arguments, BoundCompileUnit& boundCompileUnit, BoundFunction* boundFunction, const FunctionMatch& bestMatch, ContainerScope* containerScope, const Span& span, const boost::uuids::uuid& moduleId)
TypeSymbol* CreateFunctionGroupTypeSymbol(FunctionGroupSymbol* functionGroupSymbol, void* boundFunctionGroupExpression)
TypeSymbol* CreateMemberExpressionTypeSymbol(const Span& span, const boost::uuids::uuid& moduleId_, const std::u32string& name, void* boundMemberExpression)
TypeSymbol* CreateNamespaceTypeSymbol(NamespaceSymbol* ns)
Value* Disjunction<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* Div<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* Equal<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
std::unique_ptr<Value> Evaluate(Node* node, TypeSymbol* targetType, ContainerScope* containerScope, BoundCompileUnit& boundCompileUnit, bool dontThrow, BoundFunction* currentFunction, const Span& span, const boost::uuids::uuid& moduleId)
std::unique_ptr<BoundFunctionCall> FailWithAmbiguousOverload(const std::u32string& groupName, std::vector<std::unique_ptr<BoundExpression>>& arguments, std::vector<FunctionMatch>& functionMatches, const Span& span, const boost::uuids::uuid& moduleId, OverloadResolutionFlags flags, std::unique_ptr<Exception>& exception)
std::unique_ptr<BoundFunctionCall> FailWithNoViableFunction(const std::u32string& groupName, const std::vector<std::unique_ptr<BoundExpression>>& arguments, const Span& span, const boost::uuids::uuid& moduleId, OverloadResolutionFlags flags, std::unique_ptr<Exception>& exception)
std::unique_ptr<BoundFunctionCall> FailWithOverloadNotFound(Module* module, const ViableFunctionSet& viableFunctions, const std::u32string& groupName, const std::vector<std::unique_ptr<BoundExpression>>& arguments, const std::vector<FunctionMatch>& failedFunctionMatches, const Span& span, const boost::uuids::uuid& moduleId, OverloadResolutionFlags flags, std::unique_ptr<Exception>& exception)
bool FindClassTemplateSpecializationMatch(TypeSymbol* sourceType, TypeSymbol* targetType, ConversionType conversionType, BoundExpression* argument, BoundCompileUnit& boundCompileUnit, FunctionMatch& functionMatch, ContainerScope* containerScope, BoundFunction* currentFunction, const Span& span, const boost::uuids::uuid& moduleId)
bool FindConversions(BoundCompileUnit& boundCompileUnit, FunctionSymbol* function, std::vector<std::unique_ptr<BoundExpression>>& arguments, FunctionMatch& functionMatch, ConversionType conversionType, ContainerScope* containerScope, BoundFunction* currentFunction, const Span& span, const boost::uuids::uuid& moduleId)
bool FindQualificationConversion(TypeSymbol* sourceType, TypeSymbol* targetType, BoundExpression* argument, ConversionType conversionType, const Span& span, const boost::uuids::uuid& moduleId, FunctionMatch& functionMatch, ArgumentMatch& argumentMatch)
bool FindTemplateParameterMatch(TypeSymbol* sourceType, TypeSymbol* targetType, ConversionType conversionType, BoundExpression* argument, BoundCompileUnit& boundCompileUnit, FunctionMatch& functionMatch, ContainerScope* containerScope, BoundFunction* currentFunction, const Span& span, const boost::uuids::uuid& moduleId)
void GenerateClassAssignment(MemberFunctionSymbol* assignmentFunctionSymbol, MemberFunctionNode* assignmentNode, BoundCompoundStatement* boundCompoundStatement, BoundFunction* boundFunction, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope, StatementBinder* statementBinder, bool generateDefault, const Span& span, const boost::uuids::uuid& moduleId)
void GenerateClassInitialization(ConstructorSymbol* constructorSymbol, ConstructorNode* constructorNode, BoundCompoundStatement* boundCompoundStatement, BoundFunction* boundFunction, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope, StatementBinder* statementBinder, bool generateDefault, const Span& span, const boost::uuids::uuid& moduleId)
void GenerateClassTermination(DestructorSymbol* destructorSymbol, DestructorNode* destructorNode, BoundCompoundStatement* boundCompoundStatement, BoundFunction* boundFunction, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope, StatementBinder* statementBinder, const Span& span, const boost::uuids::uuid& moduleId)
void GenerateDestructorImplementation(BoundClass* boundClass, DestructorSymbol* destructorSymbol, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope, BoundFunction* currentFunction, const Span& span, const boost::uuids::uuid& moduleId)
void GenerateStaticClassInitialization(StaticConstructorSymbol* staticConstructorSymbol, StaticConstructorNode* staticConstructorNode, BoundCompileUnit& boundCompileUnit, BoundCompoundStatement* boundCompoundStatement, BoundFunction* boundFunction, ContainerScope* containerScope, StatementBinder* statementBinder, const Span& span, const boost::uuids::uuid& moduleId)
Value* Greater<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* GreaterEqual<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
bool HasAccess(FunctionSymbol* fromFunction, Symbol* toSymbol)
std::unique_ptr<BoundConcept> Instantiate(ConceptSymbol* conceptSymbol, const std::vector<TypeSymbol*>& typeArguments, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope, BoundFunction* currentFunction, std::unique_ptr<BoundConstraint>& boundConstraint, const Span& span, const boost::uuids::uuid& moduleId, std::unique_ptr<Exception>& exception)
bool IsAlwaysTrue(Node* node, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope)
Value* Less<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* LessEqual<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
std::u32string MakeBoundConceptName(ConceptSymbol* conceptSymbol, const std::vector<TypeSymbol*>& typeArguments)
BoundExpression* MakeExitEntryPtr(BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope, const Span& span, const boost::uuids::uuid& moduleId)
std::string MakeOverloadName(const std::u32string& groupName, const std::vector<std::unique_ptr<BoundExpression>>& arguments, const Span& span, const boost::uuids::uuid& moduleId)
Value* Mul<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* Not<ValueT>(Value* subject, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* NotEqual<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* NotSupported(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* NotSupported(Value* subject, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* Rem<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
ConceptSymbol* ResolveConceptId(ConceptIdNode* conceptIdNode, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope)
std::unique_ptr<BoundFunctionCall> ResolveOverload(const std::u32string& groupName, ContainerScope* containerScope, const std::vector<FunctionScopeLookup>& functionScopeLookups, std::vector<std::unique_ptr<BoundExpression>>& arguments, BoundCompileUnit& boundCompileUnit, BoundFunction* currentFunction, const Span& span, const boost::uuids::uuid& moduleId)
std::unique_ptr<BoundFunctionCall> ResolveOverload(const std::u32string& groupName, ContainerScope* containerScope, const std::vector<FunctionScopeLookup>& functionScopeLookups, std::vector<std::unique_ptr<BoundExpression>>& arguments, BoundCompileUnit& boundCompileUnit, BoundFunction* currentFunction, const Span& span, const boost::uuids::uuid& moduleId, OverloadResolutionFlags flags, std::vector<TypeSymbol*>& templateArgumentTypes, std::unique_ptr<Exception>& exception)
TypeSymbol* ResolveType(Node* typeExprNode, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope)
TypeSymbol* ResolveType(Node* typeExprNode, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope, ClassTypeSymbol* currentClass)
TypeSymbol* ResolveType(Node* typeExprNode, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope, TypeResolverFlags flags)
TypeSymbol* ResolveType(Node* typeExprNode, BoundCompileUnit& boundCompileUnit, ContainerScope* containerScope, TypeResolverFlags flags, ClassTypeSymbol* currentClass)
std::unique_ptr<BoundFunctionCall> SelectViableFunction(const ViableFunctionSet& viableFunctions, const std::u32string& groupName, std::vector<std::unique_ptr<BoundExpression>>& arguments, ContainerScope* containerScope, BoundCompileUnit& boundCompileUnit, BoundFunction* boundFunction, const Span& span, const boost::uuids::uuid& moduleId, OverloadResolutionFlags flags, std::vector<TypeSymbol*>& templateArgumentTypes, std::unique_ptr<Exception>& exception)
void SetConstraintSymbolBinder(ConstraintSymbolBinder* constraintSymbolBinder_)
Value* ShiftLeft<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* ShiftRight<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* Sub<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
bool TerminatesCase(StatementNode* statementNode)
bool TerminatesDefault(StatementNode* statementNode)
bool TerminatesFunction(StatementNode* statement, bool inForEverLoop, ContainerScope* containerScope, BoundCompileUnit& boundCompileUnit)
void ThrowCannotEvaluateStatically(const Span& defined, const boost::uuids::uuid& moduleId)
void ThrowCannotEvaluateStatically(const Span& defined, const boost::uuids::uuid& moduleId, const Span& referenced, const boost::uuids::uuid& referencedModuleId)
Value* UnaryEvaluate<ValueT, Op>(Value* subject, Op op, const Span& span, const boost::uuids::uuid& moduleId)
Value* UnaryMinus<ValueT>(Value* subject, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
Value* UnaryPlus<ValueT>(Value* subject, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)
std::vector<std::unique_ptr<BoundExpression>> ValuesToLiterals(std::vector<std::unique_ptr<Value>>& values, SymbolTable* symbolTable, bool& error)
bool operator!=(const BoundConceptKey& left, const BoundConceptKey& right) inline
bool operator!=(const FunctionTemplateKey& left, const FunctionTemplateKey& right)
BoundExpressionFlags operator&(BoundExpressionFlags left, BoundExpressionFlags right) inline
BoundStatementFlags operator&(BoundStatementFlags left, BoundStatementFlags right) inline
CollectFlags operator&(CollectFlags left, CollectFlags right) inline
OverloadResolutionFlags operator&(OverloadResolutionFlags left, OverloadResolutionFlags right) inline
TypeResolverFlags operator&(TypeResolverFlags left, TypeResolverFlags right) inline
bool operator==(const BoundConceptKey& left, const BoundConceptKey& right)
bool operator==(const FunctionTemplateKey& left, const FunctionTemplateKey& right)
BoundExpressionFlags operator|(BoundExpressionFlags left, BoundExpressionFlags right) inline
BoundStatementFlags operator|(BoundStatementFlags left, BoundStatementFlags right) inline
CollectFlags operator|(CollectFlags left, CollectFlags right) inline
OverloadResolutionFlags operator|(OverloadResolutionFlags left, OverloadResolutionFlags right) inline
TypeResolverFlags operator|(TypeResolverFlags left, TypeResolverFlags right) inline

Enumerations

enum class BoundExpressionFlags
enum class BoundNodeType
enum class BoundStatementFlags
enum class CollectFlags
enum class Operator
enum class OverloadResolutionFlags
enum class TypeResolverFlags

Variables

ConstraintSymbolBinder* constraintSymbolBinder

Function Details

Add Function

Value* cmajor::binder::Add<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 447 of Evaluator.cpp :
 448 {
 449     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, std::plus<typename ValueT::OperandType>(), span, moduleId);
 450 }

AnalyzeControlFlow Function

void cmajor::binder::AnalyzeControlFlow(BoundCompileUnit & boundCompileUUnit)

Definition at line 397 of ControlFlowAnalyzer.cpp :
398 {
399     ControlFlowAnalyzer controlFlowAnalyzer;
400     boundCompileUUnit.Accept(controlFlowAnalyzer);
401 }

Declaration at line 14 of ControlFlowAnalyzer.hpp

Calls: cmajor::binder::BoundCompileUnit::Accept

ArgumentsToValues Function

std::vector<std::unique_ptr<Value>> cmajor::binder::ArgumentsToValues(const std::vector<std::unique_ptr<BoundExpression >>& arguments, bool & error, BoundCompileUnit & boundCompileUnit)

Definition at line 185 of Evaluator.cpp :
 186 {
 187     return ArgumentsToValues(arguments, error, false, boundCompileUnit);
 188 }

Called by: cmajor::binder::Evaluator::Visit

ArgumentsToValues Function

std::vector<std::unique_ptr<Value>> cmajor::binder::ArgumentsToValues(const std::vector<std::unique_ptr<BoundExpression >>& arguments, bool & error, bool skipFirst, BoundCompileUnit & boundCompileUnit)

Definition at line 190 of Evaluator.cpp
Declaration at line 183 of Evaluator.cpp

Called by: cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit

BetterArgumentMatch Function

bool cmajor::binder::BetterArgumentMatch(const ArgumentMatch & left, const ArgumentMatch & right) inline

Definition at line 62 of OverloadResolution.hpp

Called by: cmajor::binder::BetterFunctionMatch::operator()

BinaryEvaluate Function

Value* cmajor::binder::BinaryEvaluate<ValueT, Op>(Value* left, Value* right, Op op, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 219 of Evaluator.cpp :
 220 {
 221     ValueT* leftCasted = static_cast<ValueT*>(left);
 222     ValueT* rightCasted = static_cast<ValueT*>(right);
 223     return new ValueT(span, moduleId, op(leftCasted->GetValue(), rightCasted->GetValue()));
 224 }

BinaryPredEvaluate Function

Value* cmajor::binder::BinaryPredEvaluate<ValueT, Op>(Value* left, Value* right, Op op, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 227 of Evaluator.cpp :
 228 {
 229     ValueT* leftCasted = static_cast<ValueT*>(left);
 230     ValueT* rightCasted = static_cast<ValueT*>(right);
 231     return new BoolValue(span, moduleId, op(leftCasted->GetValue(), rightCasted->GetValue()));
 232 }

BindClass Function

void cmajor::binder::BindClass(ClassTypeSymbol* classType, void * boundCompileUnit)

Definition at line 2539 of TypeBinder.cpp :
2540 {
2541     BoundCompileUnit* compileUnit = static_cast<BoundCompileUnit*>(boundCompileUnit);
2542     TypeBinder binder(*compileUnit);
2543     SymbolTable& symbolTable = compileUnit->GetSymbolTable();
2544     sngcm::ast::ClassNode* classNode = static_cast<ClassNode*>(symbolTable.GetNode(classType));
2545     binder.BindClass(classType, classNode, true);
2546 }

Calls: cmajor::binder::BoundCompileUnit::GetSymbolTable , cmajor::binder::TypeBinder::BindClass

BindExpression Function

std::unique_ptr<BoundExpression > cmajor::binder::BindExpression(Node* node, BoundCompileUnit & boundCompileUnit, BoundFunction * boundFunction, ContainerScope* containerScope, StatementBinder * statementBinder)

Definition at line 2705 of ExpressionBinder.cpp :
2706 {
2707     return BindExpression(node, boundCompileUnit, boundFunction, containerScope, statementBinder, false);
2708 }

Called by: cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit

BindExpression Function

std::unique_ptr<BoundExpression > cmajor::binder::BindExpression(Node* node, BoundCompileUnit & boundCompileUnit, BoundFunction * boundFunction, ContainerScope* containerScope, StatementBinder * statementBinder, bool lvalue)

Definition at line 2710 of ExpressionBinder.cpp :
2711 {
2712     return BindExpression(node, boundCompileUnit, boundFunction, containerScope, statementBinder, lvalue, false);
2713 }

Called by: cmajor::binder::StatementBinder::Visit

BindExpression Function

std::unique_ptr<BoundExpression > cmajor::binder::BindExpression(Node* node, BoundCompileUnit & boundCompileUnit, BoundFunction * boundFunction, ContainerScope* containerScope, StatementBinder * statementBinder, bool lvalue, bool acceptFunctionGroupOrMemberExpression)

Definition at line 2715 of ExpressionBinder.cpp :
2717 {
2718     return BindExpression(node, boundCompileUnit, boundFunction, containerScope, statementBinder, lvalue, acceptFunctionGroupOrMemberExpression, false);
2719 }

Called by: cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit

BindExpression Function

std::unique_ptr<BoundExpression > cmajor::binder::BindExpression(Node* node, BoundCompileUnit & boundCompileUnit, BoundFunction * boundFunction, ContainerScope* containerScope, StatementBinder * statementBinder, bool lvalue, bool acceptFunctionGroupOrMemberExpression, bool acceptIncomplete)

Definition at line 2721 of ExpressionBinder.cpp :
2723 {
2724     return BindExpression(node, boundCompileUnit, boundFunction, containerScope, statementBinder, lvalue, acceptFunctionGroupOrMemberExpression, acceptIncomplete, true);
2725 }

Called by: cmajor::binder::StatementBinder::Visit

BindExpression Function

std::unique_ptr<BoundExpression > cmajor::binder::BindExpression(Node* node, BoundCompileUnit & boundCompileUnit, BoundFunction * boundFunction, ContainerScope* containerScope, StatementBinder * statementBinder, bool lvalue, bool acceptFunctionGroupOrMemberExpression, bool acceptIncomplete, bool moveTemporaryDestructorCalls)

Definition at line 2727 of ExpressionBinder.cpp

Calls: cmajor::binder::BoundFunction::MoveTemporaryDestructorCallsTo , cmajor::binder::ExpressionBinder::GetExpression

Called by: cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit

BindTypes Function

std::vector<std::string> cmajor::binder::BindTypes(Module* module, CompileUnitNode* compileUnit)

Definition at line 13 of TypeBinding.cpp

Calls: cmajor::binder::TypeBinder::Errors , cmajor::binder::TypeBinder::SetEditMode , cmajor::symbols::Exception::Message

BindUnaryOp Function

std::unique_ptr<BoundExpression > cmajor::binder::BindUnaryOp(BoundExpression * operand, Node& node, const std::u32string& groupName, BoundCompileUnit & boundCompileUnit, BoundFunction * boundFunction, ContainerScope* containerScope, StatementBinder * statementBinder)

Definition at line 2759 of ExpressionBinder.cpp :
2761 {
2762     ExpressionBinder expressionBinder(node.GetSpan(), node.ModuleId(), boundCompileUnit, boundFunction, containerScope, statementBinder, false);
2763     expressionBinder.BindUnaryOp(operand, node, groupName);
2764     std::unique_ptr<BoundExpression> expression = expressionBinder.GetExpression();
2765     if (!expression)
2766     {
2767         throw Exception("cound not bind expression", node.GetSpan(), node.ModuleId());
2768     }
2769     return expression;
2770 }

Calls: cmajor::binder::ExpressionBinder::BindUnaryOp , cmajor::binder::ExpressionBinder::GetExpression

BitAnd Function

Value* cmajor::binder::BitAnd<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 312 of Evaluator.cpp :
 313 {
 314     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, std::bit_and<typename ValueT::OperandType>(), span, moduleId);
 315 }

BitOr Function

Value* cmajor::binder::BitOr<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 286 of Evaluator.cpp :
 287 {
 288     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, std::bit_or<typename ValueT::OperandType>(), span, moduleId);
 289 }

BitXor Function

Value* cmajor::binder::BitXor<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 299 of Evaluator.cpp :
 300 {
 301     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, std::bit_xor<typename ValueT::OperandType>(), span, moduleId);
 302 }

CheckAccess Function

void cmajor::binder::CheckAccess(FunctionSymbol* fromFunction, Symbol* toSymbol)

Definition at line 78 of Access.cpp :
79 {
80     if (!HasAccess(fromFunction, toSymbol))
81     {
82         throw Exception(toSymbol->TypeString() + " '" + ToUtf8(toSymbol->FullName()) + "' is inaccessible due to its protection level", 
83             fromFunction->GetSpan(), fromFunction->SourceModuleId(), toSymbol->GetSpan(), toSymbol->SourceModuleId());
84     }
85 }

Called by: cmajor::binder::ExpressionBinder::BindBinaryOp , cmajor::binder::ExpressionBinder::BindSymbol , cmajor::binder::ExpressionBinder::BindUnaryOp , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit

CheckConstraint Function

bool cmajor::binder::CheckConstraint(ConstraintNode* constraint, const NodeList<Node>& usingNodes, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope, BoundFunction * currentFunction, const std::vector<TemplateParameterSymbol*>& templateParameters, const std::unordered_map<TemplateParameterSymbol*, TypeSymbol*>& templateParameterMap, std::unique_ptr<BoundConstraint >& boundConstraint, const Span& span, const boost::uuids::uuid& moduleId, FunctionSymbol* viableFunction, std::unique_ptr<Exception>& conceptCheckException)

Definition at line 1387 of Concept.cpp

Calls: cmajor::binder::BoundCompileUnit::AddFileScope , cmajor::binder::BoundCompileUnit::RemoveLastFileScope , cmajor::binder::ConstraintChecker::GetBoundConstraint , cmajor::binder::ConstraintChecker::Result

Called by: cmajor::binder::ClassTemplateRepository::Instantiate

CheckFunctionReturnPaths Function

void cmajor::binder::CheckFunctionReturnPaths(FunctionSymbol* functionSymbol, CompoundStatementNode* bodyNode, const Span& span, const boost::uuids::uuid& moduleId, ContainerScope* containerScope, BoundCompileUnit & boundCompileUnit)

Definition at line 193 of StatementBinder.cpp
Declaration at line 185 of StatementBinder.cpp

CheckFunctionReturnPaths Function

void cmajor::binder::CheckFunctionReturnPaths(FunctionSymbol* functionSymbol, FunctionNode& functionNode, ContainerScope* containerScope, BoundCompileUnit & boundCompileUnit)

Definition at line 188 of StatementBinder.cpp :
 189 {
 190     CheckFunctionReturnPaths(functionSymbol, functionNode.Body(), functionNode.GetSpan(), functionNode.ModuleId(), containerScope, boundCompileUnit);
 191 }

Called by: cmajor::binder::Evaluator::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit

CollectViableFunctionsFromSymbolTable Function

void cmajor::binder::CollectViableFunctionsFromSymbolTable(int arity, const std::u32string& groupName, const std::vector<FunctionScopeLookup >& functionScopeLookups, BoundCompileUnit & boundCompileUnit, ViableFunctionSet& viableFunctions)

Definition at line 1547 of OverloadResolution.cpp

Calls: cmajor::binder::BoundCompileUnit::FileScopes , cmajor::binder::BoundCompileUnit::GetModule

Complement Function

Value* cmajor::binder::Complement<ValueT>(Value* subject, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 569 of Evaluator.cpp :
 570 {
 571     return UnaryEvaluate::UnaryEvaluate<ValueT>(subject, BitNot<typename ValueT::OperandType>(), span, moduleId);
 572 }

Conjunction Function

Value* cmajor::binder::Conjunction<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 273 of Evaluator.cpp :
 274 {
 275     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, std::logical_and<typename ValueT::OperandType>(), span, moduleId);
 276 }

CreateBoundFunctionCall Function

std::unique_ptr<BoundFunctionCall > cmajor::binder::CreateBoundFunctionCall(FunctionSymbol* bestFun, std::vector<std::unique_ptr<BoundExpression >>& arguments, BoundCompileUnit & boundCompileUnit, BoundFunction * boundFunction, const FunctionMatch & bestMatch, ContainerScope* containerScope, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 932 of OverloadResolution.cpp

Calls: cmajor::binder::BoundAddressOfExpression::Subject , cmajor::binder::BoundCompileUnit::AddBoundNode , cmajor::binder::BoundCompileUnit::GenerateCopyConstructorFor , cmajor::binder::BoundCompileUnit::GenerateCopyConstructorFor , cmajor::binder::BoundCompileUnit::IsGeneratedDestructorInstantiated , cmajor::binder::BoundCompileUnit::SetGeneratedDestructorInstantiated , cmajor::binder::BoundConversion::AddTemporary , cmajor::binder::BoundExpression::GetType , cmajor::binder::BoundExpression::MoveTemporaryDestructorCallsTo , cmajor::binder::BoundFunction::AddTemporaryDestructorCall , cmajor::binder::BoundFunction::GetFunctionSymbol , cmajor::binder::BoundFunctionCall::AddArgument , cmajor::binder::BoundFunctionCall::AddTemporary , cmajor::binder::BoundFunctionCall::Arguments , cmajor::binder::BoundLocalVariable::Clone , cmajor::symbols::FunctionSymbol::CreateTemporary , cmajor::symbols::TypeSymbol::AddPointer

CreateFunctionGroupTypeSymbol Function

TypeSymbol* cmajor::binder::CreateFunctionGroupTypeSymbol(FunctionGroupSymbol* functionGroupSymbol, void * boundFunctionGroupExpression)

Definition at line 2068 of BoundExpression.cpp :
2069 {
2070     TypeSymbol* functionGroupTypeSymbol = new FunctionGroupTypeSymbol(functionGroupSymbol, boundFunctionGroupExpression);
2071     functionGroupTypeSymbol->SetModule(functionGroupSymbol->GetModule());
2072     functionGroupSymbol->GetModule()->GetSymbolTable().SetTypeIdFor(functionGroupTypeSymbol);
2073     return functionGroupTypeSymbol;
2074 }

CreateMemberExpressionTypeSymbol Function

TypeSymbol* cmajor::binder::CreateMemberExpressionTypeSymbol(const Span& span, const boost::uuids::uuid& moduleId_, const std::u32string& name, void * boundMemberExpression)

Definition at line 2127 of BoundExpression.cpp :
2128 {
2129     TypeSymbol* memberExpressionTypeSymbol = new MemberExpressionTypeSymbol(span, moduleId_, name, boundMemberExpression);
2130     Module* module = GetRootModuleForCurrentThread();
2131     memberExpressionTypeSymbol->SetModule(module);
2132     module->GetSymbolTable().SetTypeIdFor(memberExpressionTypeSymbol);
2133     return memberExpressionTypeSymbol;
2134 }

CreateNamespaceTypeSymbol Function

TypeSymbol* cmajor::binder::CreateNamespaceTypeSymbol(NamespaceSymbol* ns)

Definition at line 2035 of BoundExpression.cpp :
2036 {
2037     TypeSymbol* nsTypeSymbol = new NamespaceTypeSymbol(ns);
2038     ns->GetModule()->GetSymbolTable().SetTypeIdFor(nsTypeSymbol);
2039     return nsTypeSymbol;
2040 }

Disjunction Function

Value* cmajor::binder::Disjunction<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 260 of Evaluator.cpp :
 261 {
 262     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, std::logical_or<typename ValueT::OperandType>(), span, moduleId);
 263 }

Div Function

Value* cmajor::binder::Div<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 486 of Evaluator.cpp :
 487 {
 488     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, std::divides<typename ValueT::OperandType>(), span, moduleId);
 489 }

Equal Function

Value* cmajor::binder::Equal<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 325 of Evaluator.cpp :
 326 {
 327     return BinaryPredEvaluate::BinaryPredEvaluate<ValueT>(left, right, std::equal_to<typename ValueT::OperandType>(), span, moduleId);
 328 }

Evaluate Function

std::unique_ptr<Value> cmajor::binder::Evaluate(Node* node, TypeSymbol* targetType, ContainerScope* containerScope, BoundCompileUnit & boundCompileUnit, bool dontThrow, BoundFunction * currentFunction, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 4066 of Evaluator.cpp

Calls: cmajor::binder::BoundCompileUnit::GetSymbolTable , cmajor::binder::Evaluator::Error , cmajor::binder::Evaluator::GetValue

Called by: cmajor::binder::ConstraintChecker::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeResolver::Visit

FailWithAmbiguousOverload Function

std::unique_ptr<BoundFunctionCall > cmajor::binder::FailWithAmbiguousOverload(const std::u32string& groupName, std::vector<std::unique_ptr<BoundExpression >>& arguments, std::vector<FunctionMatch >& functionMatches, const Span& span, const boost::uuids::uuid& moduleId, OverloadResolutionFlags flags, std::unique_ptr<Exception>& exception)

Definition at line 889 of OverloadResolution.cpp

Calls: cmajor::symbols::FunctionSymbol::FullName , cmajor::symbols::Symbol::GetSpan , cmajor::symbols::Symbol::SourceModuleId

FailWithNoViableFunction Function

std::unique_ptr<BoundFunctionCall > cmajor::binder::FailWithNoViableFunction(const std::u32string& groupName, const std::vector<std::unique_ptr<BoundExpression >>& arguments, const Span& span, const boost::uuids::uuid& moduleId, OverloadResolutionFlags flags, std::unique_ptr<Exception>& exception)

Definition at line 682 of OverloadResolution.cpp

FailWithOverloadNotFound Function

std::unique_ptr<BoundFunctionCall > cmajor::binder::FailWithOverloadNotFound(Module* module, const ViableFunctionSet& viableFunctions, const std::u32string& groupName, const std::vector<std::unique_ptr<BoundExpression >>& arguments, const std::vector<FunctionMatch >& failedFunctionMatches, const Span& span, const boost::uuids::uuid& moduleId, OverloadResolutionFlags flags, std::unique_ptr<Exception>& exception)

Definition at line 722 of OverloadResolution.cpp

FindClassTemplateSpecializationMatch Function

bool cmajor::binder::FindClassTemplateSpecializationMatch(TypeSymbol* sourceType, TypeSymbol* targetType, ConversionType conversionType, BoundExpression * argument, BoundCompileUnit & boundCompileUnit, FunctionMatch & functionMatch, ContainerScope* containerScope, BoundFunction * currentFunction, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 347 of OverloadResolution.cpp

Calls: cmajor::binder::BoundCompileUnit::GetConversion , cmajor::binder::BoundCompileUnit::GetSymbolTable , cmajor::symbols::SymbolTable::MakeClassTemplateSpecialization , cmajor::symbols::SymbolTable::MakeDerivedType

FindConversions Function

bool cmajor::binder::FindConversions(BoundCompileUnit & boundCompileUnit, FunctionSymbol* function, std::vector<std::unique_ptr<BoundExpression >>& arguments, FunctionMatch & functionMatch, ConversionType conversionType, ContainerScope* containerScope, BoundFunction * currentFunction, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 464 of OverloadResolution.cpp

Calls: cmajor::binder::BoundCompileUnit::GetConversion , cmajor::binder::BoundCompileUnit::GetSymbolTable , cmajor::binder::BoundExpression::GetFlag , cmajor::binder::BoundExpression::GetType , cmajor::binder::BoundExpression::IsLvalueExpression , cmajor::binder::TypeBinder::SetContainerScope , cmajor::binder::TypeBinder::SetCurrentFunctionSymbol , cmajor::symbols::SymbolTable::GetNodeNoThrow

Called by: cmajor::binder::ExpressionBinder::Visit , cmajor::binder::StatementBinder::Visit

FindQualificationConversion Function

bool cmajor::binder::FindQualificationConversion(TypeSymbol* sourceType, TypeSymbol* targetType, BoundExpression * argument, ConversionType conversionType, const Span& span, const boost::uuids::uuid& moduleId, FunctionMatch & functionMatch, ArgumentMatch & argumentMatch)

Definition at line 117 of OverloadResolution.cpp

Calls: cmajor::binder::BoundExpression::GetFlag , cmajor::binder::BoundExpression::IsLvalueExpression , cmajor::symbols::FunctionSymbol::ConversionDistance

FindTemplateParameterMatch Function

bool cmajor::binder::FindTemplateParameterMatch(TypeSymbol* sourceType, TypeSymbol* targetType, ConversionType conversionType, BoundExpression * argument, BoundCompileUnit & boundCompileUnit, FunctionMatch & functionMatch, ContainerScope* containerScope, BoundFunction * currentFunction, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 252 of OverloadResolution.cpp

Calls: cmajor::binder::BoundCompileUnit::GetConversion

GenerateClassAssignment Function

void cmajor::binder::GenerateClassAssignment(MemberFunctionSymbol* assignmentFunctionSymbol, MemberFunctionNode* assignmentNode, BoundCompoundStatement * boundCompoundStatement, BoundFunction * boundFunction, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope, StatementBinder * statementBinder, bool generateDefault, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 3730 of OperationRepository.cpp

Calls: cmajor::binder::BoundCompileUnit::GetConversion , cmajor::binder::BoundCompoundStatement::AddStatement , cmajor::binder::BoundExpression::GetType , cmajor::binder::BoundFunction::MoveTemporaryDestructorCallsTo , cmajor::binder::BoundMemberVariable::SetClassPtr , cmajor::symbols::TypeSymbol::AddPointer

Called by: cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit

GenerateClassInitialization Function

void cmajor::binder::GenerateClassInitialization(ConstructorSymbol* constructorSymbol, ConstructorNode* constructorNode, BoundCompoundStatement * boundCompoundStatement, BoundFunction * boundFunction, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope, StatementBinder * statementBinder, bool generateDefault, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 3408 of OperationRepository.cpp

Calls: cmajor::binder::BoundCompileUnit::GetConversion , cmajor::binder::BoundCompoundStatement::AddStatement , cmajor::binder::BoundExpression::GetType , cmajor::binder::BoundFunction::MoveTemporaryDestructorCallsTo , cmajor::binder::BoundMemberVariable::SetClassPtr , cmajor::symbols::TypeSymbol::AddPointer

Called by: cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit

GenerateClassTermination Function

void cmajor::binder::GenerateClassTermination(DestructorSymbol* destructorSymbol, DestructorNode* destructorNode, BoundCompoundStatement * boundCompoundStatement, BoundFunction * boundFunction, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope, StatementBinder * statementBinder, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 3873 of OperationRepository.cpp

Calls: cmajor::binder::BoundCompileUnit::GetConversion , cmajor::binder::BoundCompoundStatement::AddStatement , cmajor::binder::BoundCompoundStatement::InsertStatementToFront , cmajor::binder::BoundExpression::GetType , cmajor::binder::BoundMemberVariable::SetClassPtr , cmajor::symbols::TypeSymbol::AddPointer

Called by: cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit

GenerateDestructorImplementation Function

void cmajor::binder::GenerateDestructorImplementation(BoundClass * boundClass, DestructorSymbol* destructorSymbol, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope, BoundFunction * currentFunction, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 3071 of OperationRepository.cpp

Calls: cmajor::binder::BoundClass::AddMember , cmajor::binder::BoundClass::GetClassTypeSymbol , cmajor::binder::BoundCompileUnit::GetConversion , cmajor::binder::BoundExpression::GetType , cmajor::binder::BoundMemberVariable::SetClassPtr , cmajor::symbols::TypeSymbol::AddPointer

Called by: cmajor::binder::BoundFunction::AddTemporaryDestructorCall , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit

GenerateStaticClassInitialization Function

void cmajor::binder::GenerateStaticClassInitialization(StaticConstructorSymbol* staticConstructorSymbol, StaticConstructorNode* staticConstructorNode, BoundCompileUnit & boundCompileUnit, BoundCompoundStatement * boundCompoundStatement, BoundFunction * boundFunction, ContainerScope* containerScope, StatementBinder * statementBinder, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 3186 of OperationRepository.cpp

Calls: cmajor::binder::BoundCompileUnit::GetSymbolTable , cmajor::binder::BoundCompoundStatement::AddStatement , cmajor::binder::BoundExpression::GetType , cmajor::binder::BoundFunction::MoveTemporaryDestructorCallsTo , cmajor::symbols::SymbolTable::GetTypeByName , cmajor::symbols::TypeSymbol::AddPointer

Called by: cmajor::binder::StatementBinder::Visit

Greater Function

Value* cmajor::binder::Greater<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 364 of Evaluator.cpp :
 365 {
 366     return BinaryPredEvaluate::BinaryPredEvaluate<ValueT>(left, right, std::greater<typename ValueT::OperandType>(), span, moduleId);
 367 }

GreaterEqual Function

Value* cmajor::binder::GreaterEqual<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 390 of Evaluator.cpp :
 391 {
 392     return BinaryPredEvaluate::BinaryPredEvaluate<ValueT>(left, right, std::greater_equal<typename ValueT::OperandType>(), span, moduleId);
 393 }

HasAccess Function

bool cmajor::binder::HasAccess(FunctionSymbol* fromFunction, Symbol* toSymbol)

Definition at line 16 of Access.cpp

Instantiate Function

std::unique_ptr<BoundConcept > cmajor::binder::Instantiate(ConceptSymbol* conceptSymbol, const std::vector<TypeSymbol*>& typeArguments, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope, BoundFunction * currentFunction, std::unique_ptr<BoundConstraint >& boundConstraint, const Span& span, const boost::uuids::uuid& moduleId, std::unique_ptr<Exception>& exception)

Definition at line 1280 of Concept.cpp
Declaration at line 142 of Concept.cpp

Calls: cmajor::binder::BoundCompileUnit::GetSymbolTable , cmajor::binder::BoundConcept::AddBoundTemplateParameter , cmajor::binder::BoundConcept::SetBoundConstraint , cmajor::binder::BoundConcept::SetCommonType , cmajor::binder::ConstraintChecker::GetBoundConstraint , cmajor::binder::ConstraintChecker::Result , cmajor::symbols::SymbolTable::GetNode

Called by: cmajor::binder::ConstraintChecker::Visit , cmajor::binder::ConstraintChecker::Visit , cmajor::binder::ConstraintChecker::Visit

IsAlwaysTrue Function

bool cmajor::binder::IsAlwaysTrue(Node* node, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope)

Definition at line 38 of StatementBinder.cpp

Calls: cmajor::binder::BoundCompileUnit::GetSymbolTable , cmajor::symbols::SymbolTable::GetTypeByName

Less Function

Value* cmajor::binder::Less<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 351 of Evaluator.cpp :
 352 {
 353     return BinaryPredEvaluate::BinaryPredEvaluate<ValueT>(left, right, std::less<typename ValueT::OperandType>(), span, moduleId);
 354 }

LessEqual Function

Value* cmajor::binder::LessEqual<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 377 of Evaluator.cpp :
 378 {
 379     return BinaryPredEvaluate::BinaryPredEvaluate<ValueT>(left, right, std::less_equal<typename ValueT::OperandType>(), span, moduleId);
 380 }

MakeBoundConceptName Function

std::u32string cmajor::binder::MakeBoundConceptName(ConceptSymbol* conceptSymbol, const std::vector<TypeSymbol*>& typeArguments)

Definition at line 238 of BoundConstraint.cpp

MakeExitEntryPtr Function

BoundExpression * cmajor::binder::MakeExitEntryPtr(BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 3151 of OperationRepository.cpp

Calls: cmajor::binder::BoundCompileUnit::GetCompileUnitNode , cmajor::binder::BoundCompileUnit::GetNextExitEntryIndex , cmajor::binder::BoundCompileUnit::GetSymbolTable , cmajor::binder::BoundGlobalVariable::Clone , cmajor::binder::TypeBinder::GetBoundGlobalVariable , cmajor::binder::TypeBinder::SetContainerScope

MakeOverloadName Function

std::string cmajor::binder::MakeOverloadName(const std::u32string& groupName, const std::vector<std::unique_ptr<BoundExpression >>& arguments, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 653 of OverloadResolution.cpp

Mul Function

Value* cmajor::binder::Mul<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 473 of Evaluator.cpp :
 474 {
 475     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, std::multiplies<typename ValueT::OperandType>(), span, moduleId);
 476 }

Not Function

Value* cmajor::binder::Not<ValueT>(Value* subject, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 512 of Evaluator.cpp :
 513 {
 514     return UnaryEvaluate::UnaryEvaluate<ValueT>(subject, std::logical_not<typename ValueT::OperandType>(), span, moduleId);
 515 }

NotEqual Function

Value* cmajor::binder::NotEqual<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 338 of Evaluator.cpp :
 339 {
 340     return BinaryPredEvaluate::BinaryPredEvaluate<ValueT>(left, right, std::not_equal_to<typename ValueT::OperandType>(), span, moduleId);
 341 }

NotSupported Function

Value* cmajor::binder::NotSupported(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 250 of Evaluator.cpp :
 251 {
 252     if (dontThrow)
 253     {
 254         return nullptr;
 255     }
 256     throw Exception("operation not supported for types " + ValueTypeStr(left->GetValueType()) + " and " + ValueTypeStr(right->GetValueType()), span, moduleId);
 257 }

NotSupported Function

Value* cmajor::binder::NotSupported(Value* subject, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 241 of Evaluator.cpp :
 242 {
 243     if (dontThrow)
 244     {
 245         return nullptr;
 246     }
 247     throw Exception("operation not supported for type " + ValueTypeStr(subject->GetValueType()), span, moduleId);
 248 }

Rem Function

Value* cmajor::binder::Rem<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 499 of Evaluator.cpp :
 500 {
 501     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, std::modulus<typename ValueT::OperandType>(), span, moduleId);
 502 }

ResolveConceptId Function

ConceptSymbol* cmajor::binder::ResolveConceptId(ConceptIdNode* conceptIdNode, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope)

Definition at line 127 of Concept.cpp

Calls: cmajor::binder::ConceptIdResolver::GetConcept

Called by: cmajor::binder::TypeBinder::BindConcept

ResolveOverload Function

std::unique_ptr<BoundFunctionCall > cmajor::binder::ResolveOverload(const std::u32string& groupName, ContainerScope* containerScope, const std::vector<FunctionScopeLookup >& functionScopeLookups, std::vector<std::unique_ptr<BoundExpression >>& arguments, BoundCompileUnit & boundCompileUnit, BoundFunction * currentFunction, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 1570 of OverloadResolution.cpp :
1572 {
1573     std::unique_ptr<Exception> exception;
1574     std::vector<TypeSymbol*> templateArgumentTypes;
1575     return ResolveOverload(groupName, containerScope, functionScopeLookups, arguments, boundCompileUnit, currentFunction, span, moduleId, 
1576         OverloadResolutionFlags::none, templateArgumentTypes, exception);
1577 }

Called by: cmajor::binder::ArrayCopyAssignmentOperation::CollectViableFunctions , cmajor::binder::ArrayCopyConstructorOperation::CollectViableFunctions , cmajor::binder::ArrayDefaultConstructorOperation::CollectViableFunctions , cmajor::binder::ArrayMoveAssignmentOperation::CollectViableFunctions , cmajor::binder::ArrayMoveConstructorOperation::CollectViableFunctions , cmajor::binder::ClassCopyAssignmentOperation::GenerateImplementation , cmajor::binder::ClassCopyConstructorOperation::GenerateImplementation , cmajor::binder::ClassDefaultConstructorOperation::GenerateImplementation , cmajor::binder::ClassMoveAssignmentOperation::GenerateImplementation , cmajor::binder::ClassMoveConstructorOperation::GenerateImplementation , cmajor::binder::ExpressionBinder::BindBinaryOp , cmajor::binder::ExpressionBinder::BindUnaryOp , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit

ResolveOverload Function

std::unique_ptr<BoundFunctionCall > cmajor::binder::ResolveOverload(const std::u32string& groupName, ContainerScope* containerScope, const std::vector<FunctionScopeLookup >& functionScopeLookups, std::vector<std::unique_ptr<BoundExpression >>& arguments, BoundCompileUnit & boundCompileUnit, BoundFunction * currentFunction, const Span& span, const boost::uuids::uuid& moduleId, OverloadResolutionFlags flags, std::vector<TypeSymbol*>& templateArgumentTypes, std::unique_ptr<Exception>& exception)

Definition at line 1579 of OverloadResolution.cpp

Calls: cmajor::binder::BoundCompileUnit::CollectViableFunctions , cmajor::binder::BoundCompileUnit::GetModule

Called by: cmajor::binder::ConstraintChecker::Visit , cmajor::binder::ConstraintChecker::Visit , cmajor::binder::ConstraintChecker::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::ExpressionBinder::BindBinaryOp , cmajor::binder::ExpressionBinder::BindUnaryOp , cmajor::binder::ExpressionBinder::Visit

ResolveType Function

TypeSymbol* cmajor::binder::ResolveType(Node* typeExprNode, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope)

Definition at line 462 of TypeResolver.cpp :
463 {
464     return ResolveType(typeExprNode, boundCompileUnit, containerScope, TypeResolverFlags::none, nullptr);
465 }

Called by: cmajor::binder::ClassTemplateRepository::BindClassTemplateSpecialization , cmajor::binder::ClassTemplateRepository::ResolveDefaultTemplateArguments , cmajor::binder::ConstraintChecker::Visit , cmajor::binder::ConstraintChecker::Visit , cmajor::binder::ConstraintChecker::Visit , cmajor::binder::ConstraintChecker::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::ExpressionBinder::Visit , cmajor::binder::JsonAttributeProcessor::GenerateToJsonSymbol , cmajor::binder::StatementBinder::GenerateEnterAndExitFunctionCode , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::StatementBinder::Visit , cmajor::binder::XmlAttributeProcessor::GenerateSystemDomElementConstructorSymbol , cmajor::binder::XmlAttributeProcessor::GenerateToXmlSymbol

ResolveType Function

TypeSymbol* cmajor::binder::ResolveType(Node* typeExprNode, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope, ClassTypeSymbol* currentClass)

Definition at line 467 of TypeResolver.cpp :
468 {
469     return ResolveType(typeExprNode, boundCompileUnit, containerScope, TypeResolverFlags::none, currentClass);
470 }

Called by: cmajor::binder::TypeResolver::Visit , cmajor::binder::TypeResolver::Visit

ResolveType Function

TypeSymbol* cmajor::binder::ResolveType(Node* typeExprNode, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope, TypeResolverFlags flags)

Definition at line 472 of TypeResolver.cpp :
473 {
474     return ResolveType(typeExprNode, boundCompileUnit, containerScope, flags, nullptr);
475 }

Called by: cmajor::binder::TypeBinder::BindClass , cmajor::binder::TypeBinder::Visit

ResolveType Function

TypeSymbol* cmajor::binder::ResolveType(Node* typeExprNode, BoundCompileUnit & boundCompileUnit, ContainerScope* containerScope, TypeResolverFlags flags, ClassTypeSymbol* currentClass)

Definition at line 477 of TypeResolver.cpp

Calls: cmajor::binder::BoundCompileUnit::GetModule , cmajor::binder::BoundCompileUnit::GetSymbolTable , cmajor::binder::TypeResolver::DerivationRec , cmajor::binder::TypeResolver::GetType , cmajor::symbols::SymbolTable::MakeDerivedType

Called by: cmajor::binder::TypeBinder::BindTypedef , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeBinder::Visit , cmajor::binder::TypeResolver::Visit

SelectViableFunction Function

std::unique_ptr<BoundFunctionCall > cmajor::binder::SelectViableFunction(const ViableFunctionSet& viableFunctions, const std::u32string& groupName, std::vector<std::unique_ptr<BoundExpression >>& arguments, ContainerScope* containerScope, BoundCompileUnit & boundCompileUnit, BoundFunction * boundFunction, const Span& span, const boost::uuids::uuid& moduleId, OverloadResolutionFlags flags, std::vector<TypeSymbol*>& templateArgumentTypes, std::unique_ptr<Exception>& exception)

Definition at line 1170 of OverloadResolution.cpp

Calls: cmajor::binder::BoundCompileUnit::CanReuse , cmajor::binder::BoundCompileUnit::GetClassTemplateRepository , cmajor::binder::BoundCompileUnit::GetModule , cmajor::binder::BoundCompileUnit::GetSymbolTable , cmajor::binder::BoundCompileUnit::InstantiateClassTemplateMemberFunction , cmajor::binder::BoundCompileUnit::InstantiateFunctionTemplate , cmajor::binder::BoundCompileUnit::InstantiateInlineFunction , cmajor::binder::BoundFunction::GetFunctionSymbol , cmajor::binder::ClassTemplateRepository::BindClassTemplateSpecialization , cmajor::symbols::ContainerSymbol::GetContainerScope , cmajor::symbols::FunctionSymbol::DontThrow , cmajor::symbols::FunctionSymbol::HasTry , cmajor::symbols::Module::GetLock , cmajor::symbols::Module::Lock , cmajor::symbols::Symbol::GetSpan , cmajor::symbols::Symbol::SourceModuleId , cmajor::symbols::SymbolTable::CopyClassTemplateSpecialization , cmajor::symbols::SymbolTable::GetCurrentClassTemplateSpecialization , cmajor::symbols::SymbolTable::GetNodeNoThrow , cmajor::symbols::SymbolTable::GlobalNs

SetConstraintSymbolBinder Function

void cmajor::binder::SetConstraintSymbolBinder(ConstraintSymbolBinder * constraintSymbolBinder_)

Definition at line 39 of TypeBinder.cpp :
  40 {
  41     constraintSymbolBinder = constraintSymbolBinder_;
  42 }

Declaration at line 35 of TypeBinder.hpp

ShiftLeft Function

Value* cmajor::binder::ShiftLeft<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 412 of Evaluator.cpp :
 413 {
 414     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, shiftLeftFun<typename ValueT::OperandType>(), span, moduleId);
 415 }

ShiftRight Function

Value* cmajor::binder::ShiftRight<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 434 of Evaluator.cpp :
 435 {
 436     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, shiftRightFun<typename ValueT::OperandType>(), span, moduleId);
 437 }

Sub Function

Value* cmajor::binder::Sub<ValueT>(Value* left, Value* right, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 460 of Evaluator.cpp :
 461 {
 462     return BinaryEvaluate::BinaryEvaluate<ValueT>(left, right, std::minus<typename ValueT::OperandType>(), span, moduleId);
 463 }

TerminatesCase Function

bool cmajor::binder::TerminatesCase(StatementNode* statementNode)

Definition at line 119 of StatementBinder.cpp

Called by: cmajor::binder::StatementBinder::Visit

TerminatesDefault Function

bool cmajor::binder::TerminatesDefault(StatementNode* statementNode)

Definition at line 152 of StatementBinder.cpp

Called by: cmajor::binder::StatementBinder::Visit

TerminatesFunction Function

bool cmajor::binder::TerminatesFunction(StatementNode* statement, bool inForEverLoop, ContainerScope* containerScope, BoundCompileUnit & boundCompileUnit)

Definition at line 52 of StatementBinder.cpp

ThrowCannotEvaluateStatically Function

void cmajor::binder::ThrowCannotEvaluateStatically(const Span& defined, const boost::uuids::uuid& moduleId)

Definition at line 24 of Evaluator.cpp :
  25 {
  26     throw Exception("cannot evaluate statically", defined, moduleId);
  27 }

Called by: cmajor::binder::Evaluator::EvaluateSymbol

ThrowCannotEvaluateStatically Function

void cmajor::binder::ThrowCannotEvaluateStatically(const Span& defined, const boost::uuids::uuid& moduleId, const Span& referenced, const boost::uuids::uuid& referencedModuleId)

Definition at line 29 of Evaluator.cpp :
  30 {
  31     throw Exception("cannot evaluate statically", defined, moduleId, referenced, referencedModuleId);
  32 }

Called by: cmajor::binder::Evaluator::EvaluateBinOp , cmajor::binder::Evaluator::EvaluateUnaryOp , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit

UnaryEvaluate Function

Value* cmajor::binder::UnaryEvaluate<ValueT, Op>(Value* subject, Op op, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 235 of Evaluator.cpp :
 236 {
 237     ValueT* subjectCasted = static_cast<ValueT*>(subject);
 238     return new ValueT(span, moduleId, op(subjectCasted->GetValue()));
 239 }

UnaryMinus Function

Value* cmajor::binder::UnaryMinus<ValueT>(Value* subject, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 547 of Evaluator.cpp :
 548 {
 549     return UnaryEvaluate::UnaryEvaluate<ValueT>(subject, std::negate<typename ValueT::OperandType>(), span, moduleId);
 550 }

UnaryPlus Function

Value* cmajor::binder::UnaryPlus<ValueT>(Value* subject, const Span& span, const boost::uuids::uuid& moduleId, bool dontThrow)

Definition at line 534 of Evaluator.cpp :
 535 {
 536     return UnaryEvaluate::UnaryEvaluate<ValueT>(subject, Identity<typename ValueT::OperandType>(), span, moduleId);
 537 }

ValuesToLiterals Function

std::vector<std::unique_ptr<BoundExpression >> cmajor::binder::ValuesToLiterals(std::vector<std::unique_ptr<Value>>& values, SymbolTable* symbolTable, bool & error)

Definition at line 170 of Evaluator.cpp

Called by: cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit , cmajor::binder::Evaluator::Visit

operator!= Function

bool cmajor::binder::operator!=(const BoundConceptKey & left, const BoundConceptKey & right) inline

Definition at line 106 of BoundConstraint.hpp :
107 {
108     return !(left == right);
109 }

operator!= Function

bool cmajor::binder::operator!=(const FunctionTemplateKey & left, const FunctionTemplateKey & right)

Definition at line 34 of FunctionTemplateRepository.cpp :
 35 {
 36     return !(left == right);
 37 }

Declaration at line 26 of FunctionTemplateRepository.hpp

operator& Function

BoundExpressionFlags cmajor::binder::operator&(BoundExpressionFlags left, BoundExpressionFlags right) inline

Definition at line 35 of BoundExpression.hpp :
 36 {
 37     return BoundExpressionFlags(uint8_t(left) & uint8_t(right));
 38 }

operator& Function

BoundStatementFlags cmajor::binder::operator&(BoundStatementFlags left, BoundStatementFlags right) inline

Definition at line 37 of BoundStatement.hpp :
 38 {
 39     return BoundStatementFlags(uint8_t(left) & uint8_t(right));
 40 }

operator& Function

CollectFlags cmajor::binder::operator&(CollectFlags left, CollectFlags right) inline

Definition at line 34 of OperationRepository.hpp :
 35 {
 36     return static_cast<CollectFlags>(static_cast<int>(left) & static_cast<int>(right));
 37 }

operator& Function

OverloadResolutionFlags cmajor::binder::operator&(OverloadResolutionFlags left, OverloadResolutionFlags right) inline

Definition at line 33 of OverloadResolution.hpp :
 34 {
 35     return OverloadResolutionFlags(uint8_t(left) & uint8_t(right));
 36 }

operator& Function

TypeResolverFlags cmajor::binder::operator&(TypeResolverFlags left, TypeResolverFlags right) inline

Definition at line 40 of TypeResolver.hpp :
41 {
42     return TypeResolverFlags(uint8_t(left) & uint8_t(right));
43 }

operator== Function

bool cmajor::binder::operator==(const BoundConceptKey & left, const BoundConceptKey & right)

Definition at line 287 of BoundConstraint.cpp :
288 {
289     if (left.conceptSymbol != right.conceptSymbol) return false;
290     if (left.Arity() != right.Arity()) return false;
291     int n = left.Arity();
292     for (int i = 0; i < n; ++i)
293     {
294         if (!TypesEqual(left.typeArguments[i], right.typeArguments[i])) return false;
295     }
296     return true;
297 }

Declaration at line 105 of BoundConstraint.hpp

Calls: cmajor::binder::BoundConceptKey::Arity

operator== Function

bool cmajor::binder::operator==(const FunctionTemplateKey & left, const FunctionTemplateKey & right)

Definition at line 22 of FunctionTemplateRepository.cpp :
 23 {
 24     if (left.functionTemplate != right.functionTemplate) return false;
 25     if (left.templateArgumentTypes.size() != right.templateArgumentTypes.size()) return false;
 26     int n = left.templateArgumentTypes.size();
 27     for (int i = 0; i < n; ++i)
 28     {
 29         if (!TypesEqual(left.templateArgumentTypes[i], right.templateArgumentTypes[i])) return false;
 30     }
 31     return true;
 32 }

Declaration at line 25 of FunctionTemplateRepository.hpp

operator| Function

BoundExpressionFlags cmajor::binder::operator|(BoundExpressionFlags left, BoundExpressionFlags right) inline

Definition at line 30 of BoundExpression.hpp :
 31 {
 32     return BoundExpressionFlags(uint8_t(left) | uint8_t(right));
 33 }

operator| Function

BoundStatementFlags cmajor::binder::operator|(BoundStatementFlags left, BoundStatementFlags right) inline

Definition at line 32 of BoundStatement.hpp :
 33 {
 34     return BoundStatementFlags(uint8_t(left) | uint8_t(right));
 35 }

operator| Function

CollectFlags cmajor::binder::operator|(CollectFlags left, CollectFlags right) inline

Definition at line 29 of OperationRepository.hpp :
 30 {
 31     return static_cast<CollectFlags>(static_cast<int>(left) | static_cast<int>(right));
 32 }

operator| Function

OverloadResolutionFlags cmajor::binder::operator|(OverloadResolutionFlags left, OverloadResolutionFlags right) inline

Definition at line 38 of OverloadResolution.hpp :
 39 {
 40     return OverloadResolutionFlags(uint8_t(left) | uint8_t(right));
 41 }

operator| Function

TypeResolverFlags cmajor::binder::operator|(TypeResolverFlags left, TypeResolverFlags right) inline

Definition at line 45 of TypeResolver.hpp :
46 {
47     return TypeResolverFlags(uint8_t(left) | uint8_t(right));
48 }

top | up | prev | next