top | up | prev | next

symbols Namespace

Classes

class ArrayBeginFunction
class ArrayCBeginFunction
class ArrayCEndFunction
class ArrayEndFunction
struct ArrayKey
struct ArrayKeyHash
class ArrayLengthFunction
class ArrayLengthIntrinsicFunction
class ArrayTypeCopyAssignment
class ArrayTypeCopyConstructor
class ArrayTypeDefaultConstructor
class ArrayTypeElementAccess
class ArrayTypeMoveAssignment
class ArrayTypeMoveConstructor
class ArrayTypeSymbol
class ArrayValue
class AxiomSymbol
struct BasicTypeAShr
class BasicTypeAShrOperation
struct BasicTypeAdd
class BasicTypeAddOperation
struct BasicTypeAnd
class BasicTypeAndOperation
class BasicTypeBinaryOperation
struct BasicTypeBitCast
class BasicTypeBitCastOperation
class BasicTypeComparisonOperation
struct BasicTypeComplement
class BasicTypeComplementOperation
class BasicTypeConversion
class BasicTypeCopyAssignment
class BasicTypeCopyCtor
class BasicTypeDefaultCharOperation
class BasicTypeDefaultCtor
class BasicTypeDefaultDoubleOperation
class BasicTypeDefaultFloatOperation
class BasicTypeDefaultInt1Operation
class BasicTypeDefaultSInt16Operation
class BasicTypeDefaultSInt32Operation
class BasicTypeDefaultSInt64Operation
class BasicTypeDefaultSInt8Operation
class BasicTypeDefaultUCharOperation
class BasicTypeDefaultUInt16Operation
class BasicTypeDefaultUInt32Operation
class BasicTypeDefaultUInt64Operation
class BasicTypeDefaultUInt8Operation
class BasicTypeDefaultWCharOperation
class BasicTypeExplicitConversion
class BasicTypeExplicitSignExtensionOperation
class BasicTypeExplicitSignedIntToFloatingOperation
class BasicTypeExplicitUnsignedIntToFloatingOperation
class BasicTypeExplicitZeroExtensionOperation
struct BasicTypeFAdd
class BasicTypeFAddOperation
struct BasicTypeFDiv
class BasicTypeFDivOperation
struct BasicTypeFMul
class BasicTypeFMulOperation
struct BasicTypeFSub
class BasicTypeFSubOperation
struct BasicTypeFloatUnaryMinus
class BasicTypeFloatUnaryMinusOperation
struct BasicTypeFloatingEquality
class BasicTypeFloatingEqualityOperation
struct BasicTypeFloatingExtension
class BasicTypeFloatingExtensionOperation
struct BasicTypeFloatingLessThan
class BasicTypeFloatingLessThanOperation
struct BasicTypeFloatingToSignedInt
class BasicTypeFloatingToSignedIntOperation
struct BasicTypeFloatingToUnsignedInt
class BasicTypeFloatingToUnsignedIntOperation
struct BasicTypeFloatingTruncation
class BasicTypeFloatingTruncationOperation
class BasicTypeImplicitConversion
class BasicTypeImplicitSignExtensionOperation
class BasicTypeImplicitSignedIntToFloatingOperation
class BasicTypeImplicitUnsignedIntToFloatingOperation
class BasicTypeImplicitZeroExtensionOperation
struct BasicTypeIntUnaryMinus
class BasicTypeIntUnaryMinusOperation
struct BasicTypeIntegerEquality
class BasicTypeIntegerEqualityOperation
struct BasicTypeLShr
class BasicTypeLShrOperation
class BasicTypeMoveAssignment
class BasicTypeMoveCtor
struct BasicTypeMul
class BasicTypeMulOperation
struct BasicTypeNot
class BasicTypeNotOperation
struct BasicTypeOr
class BasicTypeOrOperation
class BasicTypeReturn
struct BasicTypeSDiv
class BasicTypeSDivOperation
struct BasicTypeSRem
class BasicTypeSRemOperation
struct BasicTypeShl
class BasicTypeShlOperation
struct BasicTypeSignExtension
struct BasicTypeSignedIntToFloating
struct BasicTypeSignedIntegerLessThan
class BasicTypeSignedIntegerLessThanOperation
struct BasicTypeSub
class BasicTypeSubOperation
class BasicTypeSymbol
struct BasicTypeTruncation
class BasicTypeTruncationOperation
struct BasicTypeUDiv
class BasicTypeUDivOperation
struct BasicTypeURem
class BasicTypeURemOperation
class BasicTypeUnaryOperation
struct BasicTypeUnaryPlus
class BasicTypeUnaryPlusOperation
struct BasicTypeUnsignedIntToFloating
struct BasicTypeUnsignedIntegerLessThan
class BasicTypeUnsignedIntegerLessThanOperation
struct BasicTypeXor
class BasicTypeXorOperation
struct BasicTypeZeroExtension
class BoolTypeSymbol
class BoolValue
class BoundTemplateParameterSymbol
struct ByDocName
struct ByFullName
class ByteTypeSymbol
class ByteValue
struct CCComponent
struct CCSymbolEntry
class CannotAssignToConstOverloadException
class CannotBindConstToNonconstOverloadException
class CastOverloadException
class CharTypeSymbol
class CharValue
class ClassDelegateTypeCopyAssignment
class ClassDelegateTypeCopyConstructor
class ClassDelegateTypeDefaultConstructor
class ClassDelegateTypeEquality
class ClassDelegateTypeMoveAssignment
class ClassDelegateTypeMoveConstructor
class ClassDelegateTypeSymbol
class ClassGroupTypeSymbol
struct ClassInfo
struct ClassTemplateSpecializationKey
struct ClassTemplateSpecializationKeyHash
class ClassTemplateSpecializationSymbol
class ClassToInterfaceConversion
class ClassTypeSymbol
class CompileWarningCollection
class ConceptGroupSymbol
class ConceptSymbol
class ConcreteSymbolCreator
class ConstantSymbol
class ConstructorSymbol
class ContainerClassTemplateMap
class ContainerScope
class ContainerSymbol
class ConversionFunctionSymbol
class ConversionTable
struct ConversionTableEntry
struct ConversionTableEntryHash
class DeclarationBlock
struct DefaultChar
struct DefaultDouble
struct DefaultFloat
struct DefaultInt1
struct DefaultSInt16
struct DefaultSInt32
struct DefaultSInt64
struct DefaultSInt8
struct DefaultUChar
struct DefaultUInt16
struct DefaultUInt32
struct DefaultUInt64
struct DefaultUInt8
struct DefaultWChar
class DelegateToVoidPtrConversion
class DelegateTypeCopyAssignment
class DelegateTypeCopyConstructor
class DelegateTypeDefaultConstructor
class DelegateTypeEquality
class DelegateTypeMoveAssignment
class DelegateTypeMoveConstructor
class DelegateTypeReturn
class DelegateTypeSymbol
class DerivedTypeSymbol
class DestructorSymbol
class DoubleTypeSymbol
class DoubleValue
class EditModuleCache
class EnumConstantSymbol
class EnumTypeCopyAssignment
class EnumTypeCopyConstructor
class EnumTypeDefaultConstructor
class EnumTypeEqualityOp
class EnumTypeMoveAssignment
class EnumTypeMoveConstructor
class EnumTypeReturn
class EnumTypeSymbol
class EnumTypeToUnderlyingTypeConversion
class Exception
class FileScope
class FileTable
class FloatTypeSymbol
class FloatValue
class FunctionGroupSymbol
class FunctionGroupTypeSymbol
class FunctionIndex
struct FunctionRequest
class FunctionSymbol
struct FunctionSymbolHash
struct FunctionSymbolsEqual
class FunctionToDelegateConversion
class GlobalVariableGroupSymbol
class GlobalVariableSymbol
class IntTypeSymbol
class IntValue
struct IntegralValue
struct IntegralValueHash
class InterfaceTypeCopyAssignment
class InterfaceTypeCopyConstructor
class InterfaceTypeDefaultConstructor
class InterfaceTypeMoveAssignment
class InterfaceTypeMoveConstructor
class InterfaceTypeSymbol
class IntrinsicConcepts
class IntrinsicFunction
class IsArrayTypePredicate
class IsBasicTypePredicate
class IsBoolTypePredicate
class IsByteTypePredicate
class IsCharTypePredicate
class IsClassDelegateTypePredicate
class IsClassTypePredicate
class IsConstTypePredicate
class IsDelegateTypePredicate
class IsDoubleTypePredicate
class IsEnumeratedTypePredicate
class IsFloatTypePredicate
class IsFloatingPointTypePredicate
class IsGenericPtrTypePredicate
class IsIntTypePredicate
class IsIntegralTypePredicate
class IsInterfaceTypePredicate
class IsLongTypePredicate
class IsLvalueReferenceTypePredicate
struct IsNonsystemModule
class IsPointerTypePredicate
class IsPolymorphicTypePredicate
class IsReferenceTypePredicate
class IsRvalueReferenceTypePredicate
class IsSByteTypePredicate
class IsShortTypePredicate
class IsSignedTypePredicate
class IsUCharTypePredicate
class IsUIntTypePredicate
class IsULongTypePredicate
class IsUShortTypePredicate
class IsUnsignedTypePredicate
class IsVoidTypePredicate
class IsWCharTypePredicate
struct LoadEditModuleResult
class LocalVariableSymbol
class LongTypeSymbol
class LongValue
class MemberExpressionTypeSymbol
class MemberFunctionSymbol
class MemberFunctionToClassDelegateConversion
class MemberVariableSymbol
class Module
class ModuleCache
class ModuleDependency
class ModuleImmutableException
struct ModuleTag
class NamespaceSymbol
class NoViableFunctionException
class NullPtrType
class NullValue
class Operation
class OperatorMangleMap
class ParameterSymbol
struct ParseResult
struct ParserData
class PointerCountIntrinsicFunction
class PointerValue
struct PriorityGreater
struct Resource
class ResourceTable
class SByteTypeSymbol
class SByteValue
class Scope
class ShortTypeSymbol
class ShortValue
class Source
class SourceFileCache
class SourceFileModuleMap
struct SourceFileModuleMapKey
class Sources
class StaticConstructorSymbol
class StringFunctionContainerSymbol
class StringLengthFunction
class StringValue
class StructuredValue
class Symbol
class SymbolCheckException
class SymbolCollector
class SymbolCreator
class SymbolCreatorVisitor
class SymbolFactory
class SymbolLocation
class SymbolReader
class SymbolTable
class SymbolWriter
class SystemModuleSet
class SystemModuleVersionTagVerifier
class TemplateParameterSymbol
class TrapFunction
struct TypeDerivationRec
class TypeIndex
class TypeMap
struct TypeOrConceptRequest
class TypePredicate
class TypeSymbol
class TypedefSymbol
class UCharTypeSymbol
class UCharValue
class UIntTypeSymbol
class UIntValue
class ULongTypeSymbol
class ULongValue
class UShortTypeSymbol
class UShortValue
class UStringValue
class UnderlyingTypeToEnumTypeConversion
class UuidValue
class Value
class VariableSymbol
class ViableFunctionSet
class VoidPtrToDelegateConversion
class VoidTypeSymbol
class WCharTypeSymbol
class WCharValue
class WStringValue
class Warning

Functions

uint32_t AccessFlag(Emitter& emitter, SymbolAccess access)
void AddAssertionLineNumber(int32_t lineNumber)
TypeDerivationRec AddConstDerivation(const TypeDerivationRec& typeDerivationRec)
TypeDerivationRec AddLvalueReferenceDerivation(const TypeDerivationRec& typeDerivationRec)
void AddMatches(std::vector<CCSymbolEntry>& matches, std::vector<CCSymbolEntry>& matchesToAdd)
TypeDerivationRec AddPointerDerivation(const TypeDerivationRec& typeDerivationRec)
TypeDerivationRec AddRvalueReferenceDerivation(const TypeDerivationRec& typeDerivationRec)
void AssignClassIds(std::vector<ClassInfo*>& classesByPriority)
void AssignKeys(std::vector<ClassInfo*>& classesByPriority)
void AssignLevels(std::unordered_map<boost::uuids::uuid, ClassInfo, boost::hash<boost::uuids::uuid>>& classIdMap)
bool BeginUnitTest()
ValueType CommonType(ValueType left, ValueType right)
bool CompareTypesForEquality(const TypeSymbol* left, const TypeSymbol* right)
boost::multiprecision::uint128_t ComputeClassId(ClassInfo* cls)
int CountCCComponents(const std::u32string& qualifiedName)
int CountPointerDerivations(const std::vector<Derivation>& derivations)
int CountQualifiedNameComponents(const std::u32string& qualifiedName)
std::vector<Module*> CreateFinishReadOrder(std::vector<Module*>& modules, std::unordered_map<Module*, ModuleDependency*>& dependencyMap, const Module* rootModule)
FunctionSymbol* CreateIntrinsic(IntrinsicFunction* intrinsic, SymbolTable& symbolTable, ContainerSymbol* parent)
void DefineCommandLineConditionalSymbol(const std::u32string& symbol)
std::u32string DerivationStr(Derivation derivation)
void DoParseSource(ParserData* parserData)
void Done()
void DoneEditModuleCache()
void DoneFunctionSymbol()
void DoneModule()
void DoneModuleCache()
void DoneSourceFileModuleMap()
void DoneSymbol()
void DoneSymbolTable()
void EndUnitTest(bool prevUnitTest)
std::string Expand(const std::string& errorMessage, const Span& span, const boost::uuids::uuid& moduleId)
std::string Expand(const std::string& errorMessage, const Span& primarySpan, const boost::uuids::uuid& primaryModuleId, const Span& referenceSpan, const boost::uuids::uuid& referenceModuleId)
std::string Expand(const std::string& errorMessage, const Span& primarySpan, const boost::uuids::uuid& primaryModuleId, const Span& referenceSpan, const boost::uuids::uuid& referenceModuleId, const std::string& title)
std::string Expand(const std::string& errorMessage, const Span& span, const boost::uuids::uuid& moduleId, const std::vector<std::pair<Span, boost::uuids::uuid>>& references)
std::string Expand(const std::string& errorMessage, const Span& span, const boost::uuids::uuid& moduleId, const std::vector<std::pair<Span, boost::uuids::uuid>>& references, const std::string& title)
void FinishReads(Module* rootModule, std::vector<Module*>& finishReadOrder, bool all, bool readRoot)
std::string FunctionSymbolFlagStr(FunctionSymbolFlags flags)
AccessCheckFunction GetAccessCheckFunction()
BackEnd GetBackEnd()
Module* GetCachedModule(const std::string& moduleFilePath)
int32_t GetClassIdVmtIndexOffset()
int32_t GetClassNameVmtIndexOffset()
std::vector<ClassInfo*> GetClassesByPriority(std::unordered_map<boost::uuids::uuid, ClassInfo, boost::hash<boost::uuids::uuid>>& classIdMap)
std::set<std::u32string> GetCommandLineDefines()
std::string GetCompilerVersion()
std::string GetConfig()
cmajor::debug::ContainerClassTemplateKind GetContainerClassTemplateKind(const std::u32string& fullClassName)
int32_t GetFunctionVmtIndexOffset()
bool GetGlobalFlag(GlobalFlags flag)
size_t GetHashCode<ValueT>(const ValueT& value) inline
int32_t GetImtsVmtIndexOffset()
Module* GetModuleById(const boost::uuids::uuid& moduleId)
Module* GetModuleBySourceFile(BackEnd backend, Config config, const std::string& sourceFilePath)
Module* GetModuleFromModuleCache(const std::string& moduleFilePath)
int32_t GetNextUnitTestAssertionNumber()
int GetNumBuildThreads()
int32_t GetNumUnitTestAssertions()
int GetOptimizationLevel()
Module* GetRootModuleForCurrentThread()
std::string GetSourceFilePath(int32_t fileIndex, const boost::uuids::uuid& moduleId)
int32_t GetTraceFunctionId(const std::string& functionFullName)
TypeSymbol* GetTypeFor(ValueType valueType, SymbolTable* symbolTable)
int32_t GetTypeIdVmtIndexOffset()
bool HasFrontConstDerivation(const std::vector<Derivation>& derivations)
bool HasLvalueReferenceDerivation(const std::vector<Derivation>& derivations)
bool HasPointerDerivation(const std::vector<Derivation>& derivations)
bool HasReferenceDerivation(const std::vector<Derivation>& derivations)
bool HasReferenceOrConstDerivation(const std::vector<Derivation>& derivations)
bool HasRootModuleForCurrentThread()
bool HasRvalueReferenceDerivation(const std::vector<Derivation>& derivations)
bool Implements(MemberFunctionSymbol* classMemFun, MemberFunctionSymbol* intfMemFun)
void Import(Target target, Module* rootModule, Module* module, const std::vector<std::string>& references, std::unordered_set<std::string>& importSet, std::vector<Module*>& modules, std::unordered_map<std::string, ModuleDependency*>& moduleDependencyMap, std::unordered_map<std::string, Module*>& readMap, bool& first)
void ImportModules(Target target, Module* rootModule, Module* module, std::unordered_set<std::string>& importSet, std::vector<Module*>& modules, std::unordered_map<std::string, ModuleDependency*>& dependencyMap, std::unordered_map<std::string, Module*>& readMap, bool& first)
void ImportModulesWithReferences(Target target, Module* rootModule, Module* module, const std::vector<std::string>& references, std::unordered_set<std::string>& importSet, std::vector<Module*>& modules, std::unordered_map<std::string, ModuleDependency*>& moduleDependencyMap, std::unordered_map<std::string, Module*>& readMap, bool& first)
bool InUnitTest()
void Init()
void InitCoreSymbolTable(SymbolTable& symbolTable)
void InitEditModuleCache()
void InitFunctionSymbol()
void InitModule()
void InitModuleCache()
void InitSourceFileModuleMap()
void InitSymbol()
void InitSymbolTable()
void InitTrap(SymbolTable& symbolTable)
bool IsModuleCached(const std::string& moduleFilePath)
bool IsSystemModule(const std::u32string& moduleName)
bool IsValidCCSymbol(Symbol* symbol, Module* module, FunctionSymbol* fromFunction, std::u32string& functionGroup)
void MakeBasicTypeConversions(SymbolTable& symbolTable, BoolTypeSymbol* boolType, SByteTypeSymbol* sbyteType, ByteTypeSymbol* byteType, ShortTypeSymbol* shortType, UShortTypeSymbol* ushortType, IntTypeSymbol* intType, UIntTypeSymbol* uintType, LongTypeSymbol* longType, ULongTypeSymbol* ulongType, FloatTypeSymbol* floatType, DoubleTypeSymbol* doubleType, CharTypeSymbol* charType, WCharTypeSymbol* wcharType, UCharTypeSymbol* ucharType)
void MakeBasicTypeOperations(SymbolTable& symbolTable, BoolTypeSymbol* boolType, SByteTypeSymbol* sbyteType, ByteTypeSymbol* byteType, ShortTypeSymbol* shortType, UShortTypeSymbol* ushortType, IntTypeSymbol* intType, UIntTypeSymbol* uintType, LongTypeSymbol* longType, ULongTypeSymbol* ulongType, FloatTypeSymbol* floatType, DoubleTypeSymbol* doubleType, CharTypeSymbol* charType, WCharTypeSymbol* wcharType, UCharTypeSymbol* ucharType, VoidTypeSymbol* voidType)
std::u32string MakeCCMatch(const std::vector<CCComponent>& components, const std::u32string& last)
std::vector<CCSymbolEntry> MakeCCMatches(const std::vector<CCComponent>& components, const std::vector<CCSymbolEntry>& matches)
void MakeClassIdFile(const std::unordered_set<ClassTypeSymbol*>& polymorphicClasses, const std::string& classIdFileName)
std::u32string MakeClassTemplateSpecializationName(ClassTypeSymbol* classTemplate, const std::vector<TypeSymbol*>& templateArgumentTypes)
std::string MakeCmajorRootDirRelativeFilePath(const std::string& cmajorRootDir, const std::string& filePath)
std::u32string MakeDerivedTypeName(TypeSymbol* baseType, const TypeDerivationRec& derivationRec)
std::string MakeEditModuleKey(const std::string& projectFilePath, const std::string& backendStr, const std::string& configurationStr)
void MakeFloatingPointTypeOperations(SymbolTable& symbolTable, TypeSymbol* type)
std::string MakeFullPathFromCmajorRootDirRelativeFilePath(const std::string& cmajorRootDir, const std::string& filePath)
std::u32string MakeGlobalVariableName(const std::u32string& groupName, const std::string& compileUnitId)
TypeDerivationRec MakePlainDerivationRec(const TypeDerivationRec& typeDerivationRec)
ConstantNode* MakePolymorphicClassArray(const std::unordered_set<ClassTypeSymbol*>& polymorphicClasses, const std::u32string& arrayName)
void MakeSignedIntegerTypeOperations(SymbolTable& symbolTable, TypeSymbol* type)
cmajor::debug::SourceSpan MakeSourceSpan(const Span& span, const boost::uuids::uuid& sourceModuleId)
ConstantNode* MakeStaticClassArray(const std::unordered_set<ClassTypeSymbol*>& classesHavingStaticConstructor, const std::u32string& arrayName)
SymbolLocation MakeSymbolLocation(const Span& span, Module* module)
void MakeUnsignedIntegerTypeOperations(SymbolTable& symbolTable, TypeSymbol* type)
void MapIdentifierToSymbolDefinition(IdentifierNode* identifierNode, Symbol* symbol)
void MapModule(Module* module)
void MapSourceFileToModuleId(BackEnd backend, Config config, const std::string& sourceFilePath, const boost::uuids::uuid& moduleId)
void MetaInit(SymbolTable& symbolTable)
std::string ModuleFlagStr(ModuleFlags flags)
void MoveNonSystemModulesTo(std::unique_ptr<ModuleCache>& cachePtr)
int NumberOfAncestors(ClassInfo& cls)
bool Overrides(FunctionSymbol* f, FunctionSymbol* g)
std::vector<CCComponent> ParseCCName(const std::u32string& qualifiedName)
std::vector<std::u32string> ParseQualifiedName(const std::u32string& qualifiedName)
void PrepareModuleForCompilation(Module* rootModule, const std::vector<std::string>& references, Target target)
void PutModuleToModuleCache(std::unique_ptr<Module>&& module)
void ReadTraceTable()
std::unique_ptr<Value> ReadValue(BinaryReader& reader, const Span& span, const boost::uuids::uuid& moduleId)
std::unique_ptr<ModuleCache> ReleaseModuleCache()
TypeDerivationRec RemoveConstDerivation(const TypeDerivationRec& typeDerivationRec)
void RemoveModuleFromCache(const std::string& moduleFilePath)
TypeDerivationRec RemovePointerDerivation(const TypeDerivationRec& typeDerivationRec)
TypeDerivationRec RemoveReferenceDerivation(const TypeDerivationRec& typeDerivationRec)
Module* ResetCachedModule(const std::string& moduleFilePath)
void ResetGlobalFlag(GlobalFlags flag)
void ResetGlobalFlags()
void ResetModuleCache()
void ResetUnitTestAssertionNumber()
void ResolveBaseClasses(std::unordered_map<boost::uuids::uuid, ClassInfo, boost::hash<boost::uuids::uuid>>& classIdMap)
std::string ResourceTypeStr(Type resourceType)
void RestoreModulesFrom(ModuleCache* prevCache)
void SetAccessCheckFunction(AccessCheckFunction accessCheckFunc)
void SetAssertionLineNumberVector(std::vector<int32_t>* assertionLineNumberVector_)
void SetBackEnd(BackEnd backend_)
void SetCacheModule(const std::string& moduleFilePath, std::unique_ptr<Module>&& module)
void SetCompilerVersion(const std::string& compilerVersion_)
void SetGlobalFlag(GlobalFlags flag)
void SetNumBuildThreads(int numBuildThreads_)
void SetOptimizationLevel(int optimizationLevel_)
void SetReadProjectFunction(ReadProjectFunc readProjectFunc)
void SetRootModuleForCurrentThread(Module* rootModule_)
void SetTypeBindingFunction(TypeBindingFunction typeBindingFunc)
void SetUseModuleCache(bool useModuleCache_)
std::unique_ptr<Element> SpanToDomElement(Module* module, const Span& span)
std::unique_ptr<JsonObject> SpanToJson(Module* module, const Span& span)
std::string SymbolFlagStr(SymbolFlags symbolFlags)
std::string SymbolFlagStr(SymbolFlags symbolFlags, bool noAccess)
std::string SymbolTypeStr(SymbolType symbolType)
cmajor::debug::DIPrimitiveType::Kind ToPrimitiveTypeKind(SymbolType symbolType)
bool TypesEqual(const TypeSymbol* left, const TypeSymbol* right) inline
TypeDerivationRec UnifyDerivations(const TypeDerivationRec& left, const TypeDerivationRec& right)
void UpdateModuleCache()
bool UseModuleCache()
std::string ValueTypeStr(ValueType valueType)
bool ValuesEqual<ValueT>(const ValueT& left, const ValueT& right) inline
void Visit(std::vector<Module*>& finishReadOrder, Module* module, std::unordered_set<Module*>& visited, std::unordered_set<Module*>& tempVisit, std::unordered_map<Module*, ModuleDependency*>& dependencyMap, const Module* rootModule)
void WriteTraceTable()
void WriteValue(Value* value, BinaryWriter& writer)
bool operator!=(IntegralValue left, IntegralValue right) inline
bool operator!=(const ArrayKey& left, const ArrayKey& right)
bool operator!=(const ClassTemplateSpecializationKey& left, const ClassTemplateSpecializationKey& right)
bool operator!=(const TypeDerivationRec& left, const TypeDerivationRec& right) inline
ClassTemplateSpecializationFlags operator&(ClassTemplateSpecializationFlags left, ClassTemplateSpecializationFlags right) inline
ClassTypeSymbolFlags operator&(ClassTypeSymbolFlags left, ClassTypeSymbolFlags right) inline
FunctionSymbolFlags operator&(FunctionSymbolFlags left, FunctionSymbolFlags right) inline
GlobalFlags operator&(GlobalFlags flags, GlobalFlags flag) inline
ModuleFlags operator&(ModuleFlags left, ModuleFlags right) inline
ScopeLookup operator&(ScopeLookup left, ScopeLookup right) inline
SymbolFlags operator&(SymbolFlags left, SymbolFlags right) inline
bool operator<(const SourceFileModuleMapKey& left, const SourceFileModuleMapKey& right)
bool operator<(const SymbolLocation& left, const SymbolLocation& right)
bool operator==(IntegralValue left, IntegralValue right)
bool operator==(const ArrayKey& left, const ArrayKey& right)
bool operator==(const ClassTemplateSpecializationKey& left, const ClassTemplateSpecializationKey& right)
bool operator==(const ConversionTableEntry& left, const ConversionTableEntry& right) inline
bool operator==(const SourceFileModuleMapKey& left, const SourceFileModuleMapKey& right)
bool operator==(const SymbolLocation& left, const SymbolLocation& right)
bool operator==(const TypeDerivationRec& left, const TypeDerivationRec& right) inline
ClassTemplateSpecializationFlags operator|(ClassTemplateSpecializationFlags left, ClassTemplateSpecializationFlags right) inline
ClassTypeSymbolFlags operator|(ClassTypeSymbolFlags left, ClassTypeSymbolFlags right) inline
FunctionSymbolFlags operator|(FunctionSymbolFlags left, FunctionSymbolFlags right) inline
GlobalFlags operator|(GlobalFlags flags, GlobalFlags flag) inline
ModuleFlags operator|(ModuleFlags left, ModuleFlags right) inline
SymbolFlags operator|(SymbolFlags left, SymbolFlags right) inline
ClassTemplateSpecializationFlags operator~(ClassTemplateSpecializationFlags flags) inline
ClassTypeSymbolFlags operator~(ClassTypeSymbolFlags operand) inline
FunctionSymbolFlags operator~(FunctionSymbolFlags flag) inline
GlobalFlags operator~(GlobalFlags flags) inline
ModuleFlags operator~(ModuleFlags flags) inline
ScopeLookup operator~(ScopeLookup subject) inline
SymbolFlags operator~(SymbolFlags flags) inline

Enumerations

enum class BackEnd
enum class CCComponentSeparator
enum class ClassTemplateSpecializationFlags
enum class ClassTypeSymbolFlags
enum class ConversionType
enum class Derivation
enum class FunctionSymbolFlags
enum class GlobalFlags
enum class LoadEditModuleResultKind
enum class ModuleFlags
enum class ScopeLookup
enum class SymbolAccess
enum class SymbolFlags
enum class SymbolType
enum class ValueType
enum class ValueType

Variables

std::vector<int32_t>* assertionLineNumberVector
BackEnd backend
const char* cmajorModuleTag
std::set<std::u32string> commandLineDefines
std::string compilerVersion
const int conceptRequestIndex
const int copyAssignmentIndex
const int copyConstructorIndex
const uint8_t currentModuleFormat
const int defaultConstructorIndex
GlobalFlags globalFlags
AccessCheckFunction hasAccess
bool inUnitTest
const int maxObjectLayoutSize
const int maxStaticLayoutSize
const uint8_t moduleFormat_1
const uint8_t moduleFormat_10
const uint8_t moduleFormat_11
const uint8_t moduleFormat_12
const uint8_t moduleFormat_13
const uint8_t moduleFormat_14
const uint8_t moduleFormat_15
const uint8_t moduleFormat_16
const uint8_t moduleFormat_17
const uint8_t moduleFormat_2
const uint8_t moduleFormat_3
const uint8_t moduleFormat_4
const uint8_t moduleFormat_5
const uint8_t moduleFormat_6
const uint8_t moduleFormat_7
const uint8_t moduleFormat_8
const uint8_t moduleFormat_9
const int moveAssignmentIndex
const int moveConstructorIndex
std::recursive_mutex mtx
int numBuildThreads
const int objectLayoutIndex
int optimizationLevel
const int prototypeIndex
ReadProjectFunc readProjectFunction
Module* rootModule
const int staticLayoutIndex
bool toolChainsRead
TypeBindingFunction typeBindingFunction
int32_t unitTestAssertionNumber
bool useModuleCache
SystemModuleVersionTagVerifier verifier

Function Details

AccessFlag Function

uint32_t cmajor::symbols::AccessFlag(Emitter& emitter, SymbolAccess access)

Definition at line 142 of Symbol.cpp

AddAssertionLineNumber Function

void cmajor::symbols::AddAssertionLineNumber(int32_t lineNumber)

Definition at line 178 of GlobalFlags.cpp :
179 {
180     if (assertionLineNumberVector)
181     {
182         assertionLineNumberVector->push_back(lineNumber);
183     }
184 }

Declaration at line 86 of GlobalFlags.hpp

AddConstDerivation Function

TypeDerivationRec cmajor::symbols::AddConstDerivation(const TypeDerivationRec & typeDerivationRec)

Definition at line 184 of DerivedTypeSymbol.cpp
Declaration at line 49 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::AddConst

AddLvalueReferenceDerivation Function

TypeDerivationRec cmajor::symbols::AddLvalueReferenceDerivation(const TypeDerivationRec & typeDerivationRec)

Definition at line 198 of DerivedTypeSymbol.cpp
Declaration at line 50 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::AddLvalueReference

AddMatches Function

void cmajor::symbols::AddMatches(std::vector<CCSymbolEntry >& matches, std::vector<CCSymbolEntry >& matchesToAdd)

Definition at line 417 of Scope.cpp
Declaration at line 55 of Scope.hpp

Called by: cmajor::symbols::ContainerScope::LookupBeginWith , cmajor::symbols::ContainerScope::LookupQualifiedBeginWith , cmajor::symbols::FileScope::LookupBeginWith , cmajor::symbols::Source::LookupSymbolsBeginningWith

AddPointerDerivation Function

TypeDerivationRec cmajor::symbols::AddPointerDerivation(const TypeDerivationRec & typeDerivationRec)

Definition at line 226 of DerivedTypeSymbol.cpp
Declaration at line 52 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::AddPointer

AddRvalueReferenceDerivation Function

TypeDerivationRec cmajor::symbols::AddRvalueReferenceDerivation(const TypeDerivationRec & typeDerivationRec)

Definition at line 212 of DerivedTypeSymbol.cpp
Declaration at line 51 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::AddRvalueReference

AssignClassIds Function

void cmajor::symbols::AssignClassIds(std::vector<ClassInfo *>& classesByPriority)

Definition at line 1897 of ClassTypeSymbol.cpp :
1898 {
1899     for (ClassInfo* cls : classesByPriority)
1900     {
1901         cls->id = ComputeClassId(cls);
1902     }
1903 }

AssignKeys Function

void cmajor::symbols::AssignKeys(std::vector<ClassInfo *>& classesByPriority)

Definition at line 1860 of ClassTypeSymbol.cpp

Calls: cmajor::symbols::Symbol::FullName

AssignLevels Function

void cmajor::symbols::AssignLevels(std::unordered_map<boost::uuids::uuid, ClassInfo , boost::hash<boost::uuids::uuid>>& classIdMap)

Definition at line 1830 of ClassTypeSymbol.cpp :
1831 {
1832     for (auto& p : classIdMap)
1833     {
1834         ClassInfo& cls = p.second;
1835         cls.level = NumberOfAncestors(cls);
1836     }
1837 }

BeginUnitTest Function

bool cmajor::symbols::BeginUnitTest()

Definition at line 137 of GlobalFlags.cpp :
138 {
139     bool prevUnitTest = inUnitTest;
140     inUnitTest = true;
141     return prevUnitTest;
142 }

Declaration at line 79 of GlobalFlags.hpp

CommonType Function

ValueType cmajor::symbols::CommonType(ValueType left, ValueType right)

Definition at line 214 of Value.cpp :
 215 {
 216     return commonType[uint8_t(left)][uint8_t(right)];
 217 }

Declaration at line 29 of Value.hpp

CompareTypesForEquality Function

bool cmajor::symbols::CompareTypesForEquality(const TypeSymbol * left, const TypeSymbol * right)

Definition at line 140 of TypeSymbol.cpp
Declaration at line 90 of TypeSymbol.hpp

Calls: cmajor::symbols::DerivedTypeSymbol::BaseType , cmajor::symbols::DerivedTypeSymbol::DerivationRec , cmajor::symbols::Symbol::GetSymbolType

ComputeClassId Function

boost::multiprecision::uint128_t cmajor::symbols::ComputeClassId(ClassInfo * cls)

Definition at line 1875 of ClassTypeSymbol.cpp

Calls: cmajor::symbols::Symbol::FullName

CountCCComponents Function

int cmajor::symbols::CountCCComponents(const std::u32string& qualifiedName)

Definition at line 301 of Scope.cpp

Called by: cmajor::symbols::ContainerScope::LookupBeginWith

CountPointerDerivations Function

int cmajor::symbols::CountPointerDerivations(const std::vector<Derivation >& derivations)

Definition at line 103 of DerivedTypeSymbol.cpp
Declaration at line 43 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::PointerCount , cmajor::symbols::DerivedTypeSymbol::RemoveDerivations

CountQualifiedNameComponents Function

int cmajor::symbols::CountQualifiedNameComponents(const std::u32string& qualifiedName)

Definition at line 118 of Scope.cpp

Called by: cmajor::symbols::ContainerScope::Lookup

CreateFinishReadOrder Function

std::vector<Module *> cmajor::symbols::CreateFinishReadOrder(std::vector<Module *>& modules, std::unordered_map<Module *, ModuleDependency *>& dependencyMap, const Module * rootModule)

Definition at line 384 of Module.cpp

Called by: cmajor::symbols::Module::PrepareForCompilation

CreateIntrinsic Function

FunctionSymbol * cmajor::symbols::CreateIntrinsic(IntrinsicFunction * intrinsic, SymbolTable & symbolTable, ContainerSymbol * parent)

Definition at line 38 of Meta.cpp

Calls: cmajor::symbols::FunctionSymbol::AddMember , cmajor::symbols::FunctionSymbol::ComputeName , cmajor::symbols::FunctionSymbol::SetGroupName , cmajor::symbols::FunctionSymbol::SetIntrinsic , cmajor::symbols::FunctionSymbol::SetReturnType , cmajor::symbols::IntrinsicFunction::GroupName , cmajor::symbols::IntrinsicFunction::NumberOfTypeParameters , cmajor::symbols::IntrinsicFunction::ReturnType , cmajor::symbols::Symbol::SetAccess , cmajor::symbols::Symbol::SetModule , cmajor::symbols::Symbol::SetParent , cmajor::symbols::SymbolTable::GetModule , cmajor::symbols::SymbolTable::SetTypeIdFor

DefineCommandLineConditionalSymbol Function

void cmajor::symbols::DefineCommandLineConditionalSymbol(const std::u32string& symbol)

Definition at line 113 of GlobalFlags.cpp :
114 {
115     commandLineDefines.insert(symbol);
116 }

Declaration at line 76 of GlobalFlags.hpp

DerivationStr Function

std::u32string cmajor::symbols::DerivationStr(Derivation derivation)

Definition at line 22 of DerivedTypeSymbol.cpp :
 23 {
 24     switch (derivation)
 25     {
 26         case Derivation::constDerivation: return U"C";
 27         case Derivation::lvalueRefDerivation: return U"R";
 28         case Derivation::rvalueRefDerivation: return U"RR";
 29         case Derivation::pointerDerivation: return U"P";
 30         default: return std::u32string();
 31     }
 32 }

Declaration at line 17 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::SimpleName

DoParseSource Function

void cmajor::symbols::DoParseSource(ParserData * parserData)

Definition at line 294 of Sources.cpp

Calls: cmajor::symbols::Source::Parse , cmajor::symbols::Source::Read , cmajor::symbols::Sources::GetSource

Done Function

void cmajor::symbols::Done()

Definition at line 28 of InitDone.cpp :
29 {
30     DoneEditModuleCache();
31     DoneSourceFileModuleMap();
32     DoneSymbolTable();
33     DoneModuleCache();
34     DoneModule();
35     DoneFunctionSymbol();
36     DoneSymbol();
37 }

Declaration at line 13 of InitDone.hpp

DoneEditModuleCache Function

void cmajor::symbols::DoneEditModuleCache()

Definition at line 153 of EditModuleCache.cpp :
154 {
155     EditModuleCache::Done();
156 }

Declaration at line 61 of EditModuleCache.hpp

Calls: cmajor::symbols::EditModuleCache::Done

DoneFunctionSymbol Function

void cmajor::symbols::DoneFunctionSymbol()

Definition at line 2326 of FunctionSymbol.cpp :
2327 {
2328     OperatorMangleMap::Done();
2329 }

Declaration at line 440 of FunctionSymbol.hpp

Calls: cmajor::symbols::OperatorMangleMap::Done

DoneModule Function

void cmajor::symbols::DoneModule()

Definition at line 2082 of Module.cpp :
2083 {
2084     ContainerClassTemplateMap::Done();
2085     SystemModuleSet::Done();
2086 }

Declaration at line 302 of Module.hpp

Calls: cmajor::symbols::ContainerClassTemplateMap::Done , cmajor::symbols::SystemModuleSet::Done

DoneModuleCache Function

void cmajor::symbols::DoneModuleCache()

Definition at line 381 of ModuleCache.cpp :
382 {
383     ModuleCache::Done();
384 }

Declaration at line 52 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Done

DoneSourceFileModuleMap Function

void cmajor::symbols::DoneSourceFileModuleMap()

Definition at line 108 of SourceFileModuleMap.cpp :
109 {
110     SourceFileModuleMap::Done();
111 }

Declaration at line 19 of SourceFileModuleMap.hpp

Calls: cmajor::symbols::SourceFileModuleMap::Done

DoneSymbol Function

void cmajor::symbols::DoneSymbol()

Definition at line 1304 of Symbol.cpp :
1305 {
1306     SymbolFactory::Done();
1307 }

Declaration at line 292 of Symbol.hpp

Calls: cmajor::symbols::SymbolFactory::Done

DoneSymbolTable Function

void cmajor::symbols::DoneSymbolTable()

Definition at line 2054 of SymbolTable.cpp :
2055 {
2056     IntrinsicConcepts::Done();
2057 }

Declaration at line 297 of SymbolTable.hpp

Calls: cmajor::symbols::IntrinsicConcepts::Done

EndUnitTest Function

void cmajor::symbols::EndUnitTest(bool prevUnitTest)

Definition at line 166 of GlobalFlags.cpp :
167 {
168     inUnitTest = prevUnitTest;
169 }

Declaration at line 84 of GlobalFlags.hpp

Expand Function

std::string cmajor::symbols::Expand(const std::string& errorMessage, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 20 of Exception.cpp :
 21 {
 22     std::vector<std::std::pair<Span, boost::uuids::uuid>>references;
 23     return Expand(errorMessage, span, moduleId, references);
 24 }

Expand Function

std::string cmajor::symbols::Expand(const std::string& errorMessage, const Span& primarySpan, const boost::uuids::uuid& primaryModuleId, const Span& referenceSpan, const boost::uuids::uuid& referenceModuleId)

Definition at line 26 of Exception.cpp :
 28 {
 29     std::vector<std::std::pair<Span, boost::uuids::uuid>>references(1, std::make_pair(referenceSpan, referenceModuleId));
 30     return Expand(errorMessage, primarySpan, primaryModuleId, references, "Error");
 31 }

Expand Function

std::string cmajor::symbols::Expand(const std::string& errorMessage, const Span& primarySpan, const boost::uuids::uuid& primaryModuleId, const Span& referenceSpan, const boost::uuids::uuid& referenceModuleId, const std::string& title)

Definition at line 33 of Exception.cpp :
 35 {
 36     std::vector<std::std::pair<Span, boost::uuids::uuid>>references(1, std::make_pair(referenceSpan, referenceModuleId));
 37     return Expand(errorMessage, primarySpan, primaryModuleId, references, title);
 38 }

Expand Function

std::string cmajor::symbols::Expand(const std::string& errorMessage, const Span& span, const boost::uuids::uuid& moduleId, const std::vector<std::pair<Span, boost::uuids::uuid>>& references)

Definition at line 40 of Exception.cpp :
 41 {
 42     return Expand(errorMessage, span, moduleId, references, "Error");
 43 }

Expand Function

std::string cmajor::symbols::Expand(const std::string& errorMessage, const Span& span, const boost::uuids::uuid& moduleId, const std::vector<std::pair<Span, boost::uuids::uuid>>& references, const std::string& title)

Definition at line 45 of Exception.cpp

Calls: cmajor::symbols::Module::GetErrorLines , cmajor::symbols::Module::GetFilePath

FinishReads Function

void cmajor::symbols::FinishReads(Module * rootModule, std::vector<Module *>& finishReadOrder, bool all, bool readRoot)

Definition at line 399 of Module.cpp

Calls: cmajor::symbols::Module::CreateSymbolTable , cmajor::symbols::Module::FilePathReadFrom , cmajor::symbols::Module::GetModuleIdMap , cmajor::symbols::Module::GetModuleNameTable , cmajor::symbols::Module::GetSymbolTable , cmajor::symbols::Module::HasSymbolTable , cmajor::symbols::Module::Id , cmajor::symbols::Module::ReferencedModules , cmajor::symbols::Module::SetImmutable , cmajor::symbols::Module::SymbolTablePos , cmajor::symbols::SymbolReader::GetAstReader , cmajor::symbols::SymbolReader::GetBinaryReader , cmajor::symbols::SymbolReader::SetArrayTypesTarget , cmajor::symbols::SymbolReader::SetClassTemplateSpecializationTarget , cmajor::symbols::SymbolReader::SetConversionsTarget , cmajor::symbols::SymbolReader::SetDerivedTypesTarget , cmajor::symbols::SymbolReader::SetFunctionRequestTarget , cmajor::symbols::SymbolReader::SetModule , cmajor::symbols::SymbolReader::SetRootModule , cmajor::symbols::SymbolReader::SetTypeAndConceptRequestTarget , cmajor::symbols::SymbolTable::FinishRead , cmajor::symbols::SymbolTable::Import , cmajor::symbols::SymbolTable::Read , sngcm::ast::AstReader::SetModuleMaps

Called by: cmajor::symbols::Module::PrepareForCompilation

FunctionSymbolFlagStr Function

std::string cmajor::symbols::FunctionSymbolFlagStr(FunctionSymbolFlags flags)

Definition at line 408 of FunctionSymbol.cpp
Declaration at line 123 of FunctionSymbol.hpp

Called by: cmajor::symbols::FunctionSymbol::FullNameWithSpecifiers , cmajor::symbols::FunctionSymbol::GetSpecifierStr , cmajor::symbols::StaticConstructorSymbol::FullNameWithSpecifiers

GetAccessCheckFunction Function

AccessCheckFunction cmajor::symbols::GetAccessCheckFunction()

Definition at line 35 of FunctionSymbol.cpp :
  36 {
  37     if (!hasAccess)
  38     {
  39         throw std::runtime_error("access check functio not set");
  40     }
  41     return hasAccess;
  42 }

Declaration at line 43 of FunctionSymbol.hpp

Called by: cmajor::symbols::ClassGroupTypeSymbol::IsValidCCClassGroup , cmajor::symbols::FunctionGroupSymbol::IsValidCCFunctionGroup

GetBackEnd Function

BackEnd cmajor::symbols::GetBackEnd()

Definition at line 21 of GlobalFlags.cpp :
 22 {
 23     return backend;
 24 }

Declaration at line 60 of GlobalFlags.hpp

Called by: cmajor::symbols::ClassTypeSymbol::CreateImt , cmajor::symbols::ClassTypeSymbol::CreateImts , cmajor::symbols::ClassTypeSymbol::VmtObject , cmajor::symbols::DelegateTypeSymbol::GenerateCall , cmajor::symbols::DerivedTypeSymbol::IrType , cmajor::symbols::DestructorSymbol::DontThrow , cmajor::symbols::FunctionSymbol::GenerateCall , cmajor::symbols::FunctionSymbol::GenerateVirtualCall , cmajor::symbols::InterfaceTypeSymbol::GenerateCall , cmajor::symbols::Module::PrepareForCompilation , cmajor::symbols::Module::ReadHeader

GetCachedModule Function

Module * cmajor::symbols::GetCachedModule(const std::string& moduleFilePath)

Definition at line 418 of ModuleCache.cpp :
419 {
420     std::lock_guard<std::recursive_mutex> lock(mtx);
421     return ModuleCache::Instance().GetCachedModule(moduleFilePath);
422 }

Declaration at line 59 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::GetCachedModule , cmajor::symbols::ModuleCache::Instance

GetClassIdVmtIndexOffset Function

int32_t cmajor::symbols::GetClassIdVmtIndexOffset()

Definition at line 34 of ClassTypeSymbol.cpp :
  35 {
  36     return 0;
  37 }

Declaration at line 81 of ClassTypeSymbol.hpp

GetClassNameVmtIndexOffset Function

int32_t cmajor::symbols::GetClassNameVmtIndexOffset()

Definition at line 44 of ClassTypeSymbol.cpp
Declaration at line 83 of ClassTypeSymbol.hpp

GetClassesByPriority Function

std::vector<ClassInfo *> cmajor::symbols::GetClassesByPriority(std::unordered_map<boost::uuids::uuid, ClassInfo , boost::hash<boost::uuids::uuid>>& classIdMap)

Definition at line 1848 of ClassTypeSymbol.cpp :
1849 {
1850     std::vector<ClassInfo*> classesByPriority;
1851     for (auto& p : classIdMap)
1852     {
1853         ClassInfo* cls = &p.second;
1854         classesByPriority.push_back(cls);
1855     }
1856     std::sort(classesByPriority.begin(), classesByPriority.end(), PriorityGreater());
1857     return classesByPriority;
1858 }

GetCommandLineDefines Function

std::set<std::u32string> cmajor::symbols::GetCommandLineDefines()

Definition at line 118 of GlobalFlags.cpp :
119 {
120     return commandLineDefines;
121 }

Declaration at line 77 of GlobalFlags.hpp

Called by: cmajor::symbols::Module::ClearDefines

GetCompilerVersion Function

std::string cmajor::symbols::GetCompilerVersion()

Definition at line 130 of GlobalFlags.cpp :
131 {
132     return compilerVersion;
133 }

Declaration at line 74 of GlobalFlags.hpp

GetConfig Function

std::string cmajor::symbols::GetConfig()

Definition at line 56 of GlobalFlags.cpp
Declaration at line 67 of GlobalFlags.hpp

Called by: cmajor::symbols::Module::PrepareForCompilation , cmajor::symbols::Module::ReadHeader

GetContainerClassTemplateKind Function

cmajor::debug::ContainerClassTemplateKind cmajor::symbols::GetContainerClassTemplateKind(const std::u32string& fullClassName)

Definition at line 158 of Module.cpp :
 159 {
 160     return ContainerClassTemplateMap::Instance().GetContainerClassTemplateKind(fullClassName);
 161 }

Declaration at line 31 of Module.hpp

Calls: cmajor::symbols::ContainerClassTemplateMap::GetContainerClassTemplateKind , cmajor::symbols::ContainerClassTemplateMap::Instance

Called by: cmajor::symbols::TypeIndex::AddType

GetFunctionVmtIndexOffset Function

int32_t cmajor::symbols::GetFunctionVmtIndexOffset()

Definition at line 76 of ClassTypeSymbol.cpp
Declaration at line 85 of ClassTypeSymbol.hpp

Called by: cmajor::symbols::ClassTypeSymbol::VmtObject , cmajor::symbols::ClassTypeSymbol::VmtPtrType , cmajor::symbols::FunctionSymbol::GenerateVirtualCall

GetGlobalFlag Function

bool cmajor::symbols::GetGlobalFlag(GlobalFlags flag)

Definition at line 51 of GlobalFlags.cpp :
 52 {
 53     return (globalFlags & flag) != GlobalFlags::none;
 54 }

Declaration at line 65 of GlobalFlags.hpp

Called by: cmajor::symbols::EditModuleCache::LoadEditModule , cmajor::symbols::FunctionSymbol::Read , cmajor::symbols::FunctionSymbol::SetSpecifiers , cmajor::symbols::FunctionSymbol::Write , cmajor::symbols::FunctionSymbolHash::operator() , cmajor::symbols::FunctionSymbolsEqual::operator() , cmajor::symbols::Module::PrepareForCompilation , cmajor::symbols::Module::ReadHeader , cmajor::symbols::SymbolCreatorVisitor::InsertTracer , cmajor::symbols::SymbolTable::AddLocalVariable , cmajor::symbols::SymbolTable::Import , cmajor::symbols::SymbolTable::Read , cmajor::symbols::SymbolTable::Write

GetHashCode Function

size_t cmajor::symbols::GetHashCode<ValueT>(const ValueT& value) inline

Definition at line 479 of Value.hpp :
480 {
481     return static_cast<size_t>(value.GetValue());
482 }

Called by: cmajor::symbols::IntegralValueHash::operator()

GetImtsVmtIndexOffset Function

int32_t cmajor::symbols::GetImtsVmtIndexOffset()

Definition at line 60 of ClassTypeSymbol.cpp
Declaration at line 84 of ClassTypeSymbol.hpp

Called by: cmajor::symbols::ClassToInterfaceConversion::GenerateCall

GetModuleById Function

Module * cmajor::symbols::GetModuleById(const boost::uuids::uuid& moduleId)

Definition at line 446 of ModuleCache.cpp :
447 {
448     std::lock_guard<std::recursive_mutex> lock(mtx);
449     return ModuleCache::Instance().GetModule(moduleId);
450 }

Declaration at line 63 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::GetModule , cmajor::symbols::ModuleCache::Instance

Called by: cmajor::symbols::Exception::AddToDiagnosticsElement , cmajor::symbols::Exception::ToJson , cmajor::symbols::Symbol::GetLocation , cmajor::symbols::SymbolWriter::Write

GetModuleBySourceFile Function

Module * cmajor::symbols::GetModuleBySourceFile(BackEnd backend, Config config, const std::string& sourceFilePath)

Definition at line 90 of SourceFileModuleMap.cpp
Declaration at line 17 of SourceFileModuleMap.hpp

Calls: cmajor::symbols::SourceFileModuleMap::GetModuleId , cmajor::symbols::SourceFileModuleMap::Instance

GetModuleFromModuleCache Function

Module * cmajor::symbols::GetModuleFromModuleCache(const std::string& moduleFilePath)

Definition at line 357 of ModuleCache.cpp :
358 {
359     std::lock_guard<std::recursive_mutex> lock(mtx);
360     Module* module = ModuleCache::Instance().GetModule(moduleFilePath);
361     return module;
362 }

Declaration at line 48 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::GetModule , cmajor::symbols::ModuleCache::Instance

GetNextUnitTestAssertionNumber Function

int32_t cmajor::symbols::GetNextUnitTestAssertionNumber()

Definition at line 156 of GlobalFlags.cpp :
157 {
158     return unitTestAssertionNumber++;
159 }

Declaration at line 82 of GlobalFlags.hpp

GetNumBuildThreads Function

int cmajor::symbols::GetNumBuildThreads()

Definition at line 101 of GlobalFlags.cpp :
102 {
103     return numBuildThreads;
104 }

Declaration at line 70 of GlobalFlags.hpp

GetNumUnitTestAssertions Function

int32_t cmajor::symbols::GetNumUnitTestAssertions()

Definition at line 161 of GlobalFlags.cpp :
162 {
163     return unitTestAssertionNumber;
164 }

Declaration at line 83 of GlobalFlags.hpp

GetOptimizationLevel Function

int cmajor::symbols::GetOptimizationLevel()

Definition at line 77 of GlobalFlags.cpp
Declaration at line 68 of GlobalFlags.hpp

GetRootModuleForCurrentThread Function

Module * cmajor::symbols::GetRootModuleForCurrentThread()

Definition at line 2033 of Module.cpp :
2034 {
2035     if (!rootModule)
2036     {
2037         throw std::runtime_error("root module for the current thread not set");
2038     }
2039     return rootModule;
2040 }

Declaration at line 298 of Module.hpp

Called by: cmajor::symbols::ClassTemplateSpecializationSymbol::UnifyTemplateArgumentType , cmajor::symbols::ClassTypeSymbol::CreateLayouts , cmajor::symbols::ClassTypeSymbol::Write , cmajor::symbols::ConceptSymbol::Write , cmajor::symbols::ContainerScope::ParentScope , cmajor::symbols::ContainerSymbol::AddMember , cmajor::symbols::ContainerSymbol::MakeClassGroupTypeSymbol , cmajor::symbols::DerivedTypeSymbol::AddConst , cmajor::symbols::DerivedTypeSymbol::AddLvalueReference , cmajor::symbols::DerivedTypeSymbol::AddPointer , cmajor::symbols::DerivedTypeSymbol::AddRvalueReference , cmajor::symbols::DerivedTypeSymbol::PlainType , cmajor::symbols::DerivedTypeSymbol::RemoveConst , cmajor::symbols::DerivedTypeSymbol::RemoveDerivations , cmajor::symbols::DerivedTypeSymbol::RemovePointer , cmajor::symbols::DerivedTypeSymbol::RemoveReference , cmajor::symbols::DerivedTypeSymbol::Unify , cmajor::symbols::EnumTypeSymbol::CreateDIType , cmajor::symbols::FunctionSymbol::Write , cmajor::symbols::Symbol::ClassInterfaceEnumDelegateOrNsNoThrow , cmajor::symbols::Symbol::ClassInterfaceEnumDelegateOrNsNoThrow , cmajor::symbols::Symbol::ClassInterfaceOrNsNoThrow , cmajor::symbols::Symbol::ClassInterfaceOrNsNoThrow , cmajor::symbols::Symbol::ClassOrNsNoThrow , cmajor::symbols::Symbol::ClassOrNsNoThrow , cmajor::symbols::Symbol::Ns , cmajor::symbols::Symbol::Ns , cmajor::symbols::SymbolCreatorVisitor::InsertTracer , cmajor::symbols::TypeSymbol::AddConst , cmajor::symbols::TypeSymbol::AddLvalueReference , cmajor::symbols::TypeSymbol::AddPointer , cmajor::symbols::TypeSymbol::AddRvalueReference

GetSourceFilePath Function

std::string cmajor::symbols::GetSourceFilePath(int32_t fileIndex, const boost::uuids::uuid& moduleId)

Definition at line 2002 of Module.cpp
Declaration at line 296 of Module.hpp

Calls: cmajor::symbols::Module::GetFilePath

GetTraceFunctionId Function

int32_t cmajor::symbols::GetTraceFunctionId(const std::string& functionFullName)

Definition at line 21 of Trace.cpp :
22 {
23     return soulng::util::GetTraceFunctionId(functionFullName);
24 }

Declaration at line 14 of Trace.hpp

GetTypeFor Function

TypeSymbol * cmajor::symbols::GetTypeFor(ValueType valueType, SymbolTable * symbolTable)

Definition at line 219 of Value.cpp
Declaration at line 31 of Value.hpp

Calls: cmajor::symbols::SymbolTable::GetTypeByName

GetTypeIdVmtIndexOffset Function

int32_t cmajor::symbols::GetTypeIdVmtIndexOffset()

Definition at line 39 of ClassTypeSymbol.cpp :
  40 {
  41     return 2;
  42 }

Declaration at line 82 of ClassTypeSymbol.hpp

HasFrontConstDerivation Function

bool cmajor::symbols::HasFrontConstDerivation(const std::vector<Derivation >& derivations)

Definition at line 34 of DerivedTypeSymbol.cpp :
 35 {
 36     if (!derivations.empty())
 37     {
 38         if (derivations[0] == Derivation::constDerivation)
 39         {
 40             return true;
 41         }
 42     }
 43     return false;
 44 }

Declaration at line 37 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::CreateDefaultIrValue , cmajor::symbols::DerivedTypeSymbol::IsConstType , cmajor::symbols::DerivedTypeSymbol::RemoveDerivations

HasLvalueReferenceDerivation Function

bool cmajor::symbols::HasLvalueReferenceDerivation(const std::vector<Derivation >& derivations)

Definition at line 58 of DerivedTypeSymbol.cpp :
 59 {
 60     for (Derivation derivation : derivations)
 61     {
 62         if (derivation == Derivation::lvalueRefDerivation)
 63         {
 64             return true;
 65         }
 66     }
 67     return false;
 68 }

Declaration at line 39 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::IsLvalueReferenceType , cmajor::symbols::DerivedTypeSymbol::RemoveDerivations

HasPointerDerivation Function

bool cmajor::symbols::HasPointerDerivation(const std::vector<Derivation >& derivations)

Definition at line 94 of DerivedTypeSymbol.cpp :
 95 {
 96     for (Derivation derivation : derivations)
 97     {
 98         if (derivation == Derivation::pointerDerivation) return true;
 99     }
100     return false;
101 }

Declaration at line 42 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::CreateDefaultIrValue , cmajor::symbols::DerivedTypeSymbol::GetValueType , cmajor::symbols::DerivedTypeSymbol::IsPointerType , cmajor::symbols::DerivedTypeSymbol::MakeValue , cmajor::symbols::SymbolTable::MakeDerivedType , cmajor::symbols::TypeSymbol::RemoveDerivations

HasReferenceDerivation Function

bool cmajor::symbols::HasReferenceDerivation(const std::vector<Derivation >& derivations)

Definition at line 46 of DerivedTypeSymbol.cpp :
 47 {
 48     for (Derivation derivation : derivations)
 49     {
 50         if (derivation == Derivation::lvalueRefDerivation || derivation == Derivation::rvalueRefDerivation)
 51         {
 52             return true;
 53         }
 54     }
 55     return false;
 56 }

Declaration at line 38 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::CreateDefaultIrValue , cmajor::symbols::DerivedTypeSymbol::IsReferenceType , cmajor::symbols::SymbolTable::MakeDerivedType

HasReferenceOrConstDerivation Function

bool cmajor::symbols::HasReferenceOrConstDerivation(const std::vector<Derivation >& derivations)

Definition at line 82 of DerivedTypeSymbol.cpp :
 83 {
 84     for (Derivation derivation : derivations)
 85     {
 86         if (derivation == Derivation::lvalueRefDerivation || derivation == Derivation::rvalueRefDerivation || derivation == Derivation::constDerivation)
 87         {
 88             return true;
 89         }
 90     }
 91     return false;
 92 }

Declaration at line 41 of DerivedTypeSymbol.hpp

HasRootModuleForCurrentThread Function

bool cmajor::symbols::HasRootModuleForCurrentThread()

Definition at line 2028 of Module.cpp :
2029 {
2030     return rootModule != nullptr;
2031 }

Declaration at line 297 of Module.hpp

HasRvalueReferenceDerivation Function

bool cmajor::symbols::HasRvalueReferenceDerivation(const std::vector<Derivation >& derivations)

Definition at line 70 of DerivedTypeSymbol.cpp :
 71 {
 72     for (Derivation derivation : derivations)
 73     {
 74         if (derivation == Derivation::rvalueRefDerivation)
 75         {
 76             return true;
 77         }
 78     }
 79     return false;
 80 }

Declaration at line 40 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::IsRvalueReferenceType , cmajor::symbols::DerivedTypeSymbol::RemoveDerivations

Implements Function

bool cmajor::symbols::Implements(MemberFunctionSymbol * classMemFun, MemberFunctionSymbol * intfMemFun)

Definition at line 1204 of ClassTypeSymbol.cpp

Calls: cmajor::symbols::FunctionSymbol::GroupName , cmajor::symbols::FunctionSymbol::Parameters , cmajor::symbols::FunctionSymbol::ReturnType

Called by: cmajor::symbols::ClassTypeSymbol::InitImts

Import Function

void cmajor::symbols::Import(Target target, Module * rootModule, Module * module, const std::vector<std::string>& references, std::unordered_set<std::string>& importSet, std::vector<Module *>& modules, std::unordered_map<std::string, ModuleDependency *>& moduleDependencyMap, std::unordered_map<std::string, Module *>& readMap, bool & first)

Definition at line 463 of Module.cpp

Calls: cmajor::symbols::Module::AddReferencedModule , cmajor::symbols::Module::AllRefModules , cmajor::symbols::Module::GetFileTable , cmajor::symbols::Module::GetFlag , cmajor::symbols::Module::GetModuleIdMap , cmajor::symbols::Module::GetModuleNameTable , cmajor::symbols::Module::Id , cmajor::symbols::Module::IsSystemModule , cmajor::symbols::Module::Name , cmajor::symbols::Module::ReadHeader , cmajor::symbols::Module::ReferenceFilePaths , cmajor::symbols::Module::RegisterFileTable , cmajor::symbols::Module::ResetFlag , cmajor::symbols::SymbolReader::GetAstReader , sngcm::ast::AstReader::SetModuleMaps

ImportModules Function

void cmajor::symbols::ImportModules(Target target, Module * rootModule, Module * module, std::unordered_set<std::string>& importSet, std::vector<Module *>& modules, std::unordered_map<std::string, ModuleDependency *>& dependencyMap, std::unordered_map<std::string, Module *>& readMap, bool & first)

Definition at line 677 of Module.cpp

Calls: cmajor::symbols::Module::ReferenceFilePaths

Called by: cmajor::symbols::Module::ReadHeader

ImportModulesWithReferences Function

void cmajor::symbols::ImportModulesWithReferences(Target target, Module * rootModule, Module * module, const std::vector<std::string>& references, std::unordered_set<std::string>& importSet, std::vector<Module *>& modules, std::unordered_map<std::string, ModuleDependency *>& moduleDependencyMap, std::unordered_map<std::string, Module *>& readMap, bool & first)

Definition at line 627 of Module.cpp

Calls: cmajor::symbols::Module::IsSystemModule

Called by: cmajor::symbols::Module::PrepareForCompilation

InUnitTest Function

bool cmajor::symbols::InUnitTest()

Definition at line 144 of GlobalFlags.cpp :
145 {
146     return inUnitTest;
147 }

Declaration at line 80 of GlobalFlags.hpp

Init Function

void cmajor::symbols::Init()

Definition at line 17 of InitDone.cpp :
18 {
19     InitSymbol();
20     InitFunctionSymbol();
21     InitModule();
22     InitModuleCache();
23     InitSymbolTable();
24     InitSourceFileModuleMap();
25     InitEditModuleCache();
26 }

Declaration at line 12 of InitDone.hpp

InitCoreSymbolTable Function

void cmajor::symbols::InitCoreSymbolTable(SymbolTable & symbolTable)

Definition at line 1939 of SymbolTable.cpp
Declaration at line 294 of SymbolTable.hpp

Calls: cmajor::symbols::ConceptSymbol::ComputeName , cmajor::symbols::IntrinsicConcepts::AddIntrinsicConcept , cmajor::symbols::IntrinsicConcepts::GetIntrinsicConcepts , cmajor::symbols::IntrinsicConcepts::Initialized , cmajor::symbols::IntrinsicConcepts::Instance , cmajor::symbols::IntrinsicConcepts::SetInitialized , cmajor::symbols::Symbol::SetAccess , cmajor::symbols::SymbolTable::AddTemplateParameter , cmajor::symbols::SymbolTable::AddTypeSymbolToGlobalScope , cmajor::symbols::SymbolTable::BeginConcept , cmajor::symbols::SymbolTable::Container , cmajor::symbols::SymbolTable::EndConcept , cmajor::symbols::SymbolTable::InitUuids

Called by: cmajor::symbols::Module::PrepareForCompilation

InitEditModuleCache Function

void cmajor::symbols::InitEditModuleCache()

Definition at line 148 of EditModuleCache.cpp :
149 {
150     EditModuleCache::Init();
151 }

Declaration at line 60 of EditModuleCache.hpp

Calls: cmajor::symbols::EditModuleCache::Init

InitFunctionSymbol Function

void cmajor::symbols::InitFunctionSymbol()

Definition at line 2321 of FunctionSymbol.cpp :
2322 {
2323     OperatorMangleMap::Init();
2324 }

Declaration at line 439 of FunctionSymbol.hpp

Calls: cmajor::symbols::OperatorMangleMap::Init

InitModule Function

void cmajor::symbols::InitModule()

Definition at line 2075 of Module.cpp :
2076 {
2077     sngcm::ast::SetModuleVersionTagVerifier(&verifier);
2078     SystemModuleSet::Init();
2079     ContainerClassTemplateMap::Init();
2080 }

Declaration at line 301 of Module.hpp

Calls: cmajor::symbols::ContainerClassTemplateMap::Init , cmajor::symbols::SystemModuleSet::Init

InitModuleCache Function

void cmajor::symbols::InitModuleCache()

Definition at line 376 of ModuleCache.cpp :
377 {
378     ModuleCache::Init();
379 }

Declaration at line 51 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Init

InitSourceFileModuleMap Function

void cmajor::symbols::InitSourceFileModuleMap()

Definition at line 103 of SourceFileModuleMap.cpp :
104 {
105     SourceFileModuleMap::Init();
106 }

Declaration at line 18 of SourceFileModuleMap.hpp

Calls: cmajor::symbols::SourceFileModuleMap::Init

InitSymbol Function

void cmajor::symbols::InitSymbol()

Definition at line 1299 of Symbol.cpp :
1300 {
1301     SymbolFactory::Init();
1302 }

Declaration at line 291 of Symbol.hpp

Calls: cmajor::symbols::SymbolFactory::Init

InitSymbolTable Function

void cmajor::symbols::InitSymbolTable()

Definition at line 2049 of SymbolTable.cpp :
2050 {
2051     IntrinsicConcepts::Init();
2052 }

Declaration at line 296 of SymbolTable.hpp

Calls: cmajor::symbols::IntrinsicConcepts::Init

InitTrap Function

void cmajor::symbols::InitTrap(SymbolTable & symbolTable)

Definition at line 51 of Trap.cpp :
52 {
53     symbolTable.AddFunctionSymbolToGlobalScope(new TrapFunction(symbolTable));
54 }

Declaration at line 22 of Trap.hpp

Calls: cmajor::symbols::SymbolTable::AddFunctionSymbolToGlobalScope

IsModuleCached Function

bool cmajor::symbols::IsModuleCached(const std::string& moduleFilePath)

Definition at line 412 of ModuleCache.cpp :
413 {
414     std::lock_guard<std::recursive_mutex> lock(mtx);
415     return ModuleCache::Instance().HasModule(moduleFilePath);
416 }

Declaration at line 58 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::HasModule , cmajor::symbols::ModuleCache::Instance

IsSystemModule Function

bool cmajor::symbols::IsSystemModule(const std::u32string& moduleName)

Definition at line 102 of Module.cpp :
 103 {
 104     return SystemModuleSet::Instance().IsSystemModule(moduleName);
 105 }

Declaration at line 30 of Module.hpp

Calls: cmajor::symbols::SystemModuleSet::Instance , cmajor::symbols::SystemModuleSet::IsSystemModule

IsValidCCSymbol Function

bool cmajor::symbols::IsValidCCSymbol(Symbol * symbol, Module * module, FunctionSymbol * fromFunction, std::u32string& functionGroup)

Definition at line 32 of Sources.cpp

Calls: cmajor::symbols::ClassGroupTypeSymbol::IsValidCCClassGroup , cmajor::symbols::FunctionGroupSymbol::IsValidCCFunctionGroup , cmajor::symbols::Symbol::FullName , cmajor::symbols::Symbol::GetSymbolType , cmajor::symbols::Symbol::Name

Called by: cmajor::symbols::Source::GetCCList

MakeBasicTypeConversions Function

void cmajor::symbols::MakeBasicTypeConversions(SymbolTable & symbolTable, BoolTypeSymbol * boolType, SByteTypeSymbol * sbyteType, ByteTypeSymbol * byteType, ShortTypeSymbol * shortType, UShortTypeSymbol * ushortType, IntTypeSymbol * intType, UIntTypeSymbol * uintType, LongTypeSymbol * longType, ULongTypeSymbol * ulongType, FloatTypeSymbol * floatType, DoubleTypeSymbol * doubleType, CharTypeSymbol * charType, WCharTypeSymbol * wcharType, UCharTypeSymbol * ucharType)

Definition at line 494 of BasicTypeOperation.cpp

Calls: cmajor::symbols::SymbolTable::AddFunctionSymbolToGlobalScope

MakeBasicTypeOperations Function

void cmajor::symbols::MakeBasicTypeOperations(SymbolTable & symbolTable, BoolTypeSymbol * boolType, SByteTypeSymbol * sbyteType, ByteTypeSymbol * byteType, ShortTypeSymbol * shortType, UShortTypeSymbol * ushortType, IntTypeSymbol * intType, UIntTypeSymbol * uintType, LongTypeSymbol * longType, ULongTypeSymbol * ulongType, FloatTypeSymbol * floatType, DoubleTypeSymbol * doubleType, CharTypeSymbol * charType, WCharTypeSymbol * wcharType, UCharTypeSymbol * ucharType, VoidTypeSymbol * voidType)

Definition at line 696 of BasicTypeOperation.cpp
Declaration at line 1096 of BasicTypeOperation.hpp

Calls: cmajor::symbols::SymbolTable::AddFunctionSymbolToGlobalScope

MakeCCMatch Function

std::u32string cmajor::symbols::MakeCCMatch(const std::vector<CCComponent >& components, const std::u32string& last)

Definition at line 362 of Scope.cpp

MakeCCMatches Function

std::vector<CCSymbolEntry > cmajor::symbols::MakeCCMatches(const std::vector<CCComponent >& components, const std::vector<CCSymbolEntry >& matches)

Definition at line 407 of Scope.cpp :
408 {
409     std::vector<CCSymbolEntry> ccMatches;
410     for (const CCSymbolEntry& match : matches)
411     {
412         ccMatches.push_back(CCSymbolEntry(match.symbol, match.ccPrefixLen, MakeCCMatch(components, match.replacement)));
413     }
414     return ccMatches;
415 }

Called by: cmajor::symbols::ContainerScope::LookupQualifiedBeginWith

MakeClassIdFile Function

void cmajor::symbols::MakeClassIdFile(const std::unordered_set<ClassTypeSymbol *>& polymorphicClasses, const std::string& classIdFileName)

Definition at line 1959 of ClassTypeSymbol.cpp
Declaration at line 257 of ClassTypeSymbol.hpp

Calls: cmajor::symbols::TypeSymbol::TypeId , soulng::util::BinaryWriter::Write , soulng::util::BinaryWriter::Write

MakeClassTemplateSpecializationName Function

std::u32string cmajor::symbols::MakeClassTemplateSpecializationName(ClassTypeSymbol * classTemplate, const std::vector<TypeSymbol *>& templateArgumentTypes)

Definition at line 20 of ClassTemplateSpecializationSymbol.cpp
Declaration at line 35 of ClassTemplateSpecializationSymbol.hpp

Calls: cmajor::symbols::ClassTypeSymbol::GroupName

Called by: cmajor::symbols::SymbolTable::CopyClassTemplateSpecialization , cmajor::symbols::SymbolTable::MakeClassTemplateSpecialization

MakeCmajorRootDirRelativeFilePath Function

std::string cmajor::symbols::MakeCmajorRootDirRelativeFilePath(const std::string& cmajorRootDir, const std::string& filePath)

Definition at line 31 of ResourceTable.cpp :
 32 {
 33     if (filePath.find(cmajorRootDir, 0) == 0)
 34     {
 35         return "$CMAJOR$" + filePath.substr(cmajorRootDir.size());
 36     }
 37     return filePath;
 38 }

Called by: cmajor::symbols::Resource::Write

MakeDerivedTypeName Function

std::u32string cmajor::symbols::MakeDerivedTypeName(TypeSymbol * baseType, const TypeDerivationRec & derivationRec)

Definition at line 278 of DerivedTypeSymbol.cpp
Declaration at line 35 of DerivedTypeSymbol.hpp

Calls: cmajor::symbols::Symbol::Name

Called by: cmajor::symbols::SymbolTable::MakeDerivedType

MakeEditModuleKey Function

std::string cmajor::symbols::MakeEditModuleKey(const std::string& projectFilePath, const std::string& backendStr, const std::string& configurationStr)

Definition at line 24 of EditModuleCache.cpp :
 25 {
 26     std::string editModuleKey = projectFilePath;
 27     editModuleKey.append(":").append(backendStr).append(":").append(configurationStr);
 28     return editModuleKey;
 29 }

Declaration at line 17 of EditModuleCache.hpp

Called by: cmajor::symbols::EditModuleCache::GetEditModule , cmajor::symbols::EditModuleCache::LoadEditModule

MakeFloatingPointTypeOperations Function

void cmajor::symbols::MakeFloatingPointTypeOperations(SymbolTable & symbolTable, TypeSymbol * type)

Definition at line 484 of BasicTypeOperation.cpp :
485 {
486     symbolTable.AddFunctionSymbolToGlobalScope(new BasicTypeUnaryOperation<BasicTypeUnaryPlus>(SymbolType::basicTypeUnaryPlus, type));
487     symbolTable.AddFunctionSymbolToGlobalScope(new BasicTypeUnaryOperation<BasicTypeFloatUnaryMinus>(SymbolType::basicTypeFloatUnaryMinus, type));
488     symbolTable.AddFunctionSymbolToGlobalScope(new BasicTypeBinaryOperation<BasicTypeFAdd>(SymbolType::basicTypeFAdd, type));
489     symbolTable.AddFunctionSymbolToGlobalScope(new BasicTypeBinaryOperation<BasicTypeFSub>(SymbolType::basicTypeFSub, type));
490     symbolTable.AddFunctionSymbolToGlobalScope(new BasicTypeBinaryOperation<BasicTypeFMul>(SymbolType::basicTypeFMul, type));
491     symbolTable.AddFunctionSymbolToGlobalScope(new BasicTypeBinaryOperation<BasicTypeFDiv>(SymbolType::basicTypeFDiv, type));
492 }

Calls: cmajor::symbols::SymbolTable::AddFunctionSymbolToGlobalScope

MakeFullPathFromCmajorRootDirRelativeFilePath Function

std::string cmajor::symbols::MakeFullPathFromCmajorRootDirRelativeFilePath(const std::string& cmajorRootDir, const std::string& filePath)

Definition at line 40 of ResourceTable.cpp :
 41 {
 42     if (filePath.find("$CMAJOR$") == 0)
 43     {
 44         return Path::Combine(cmajorRootDir, filePath.substr(8));
 45     }
 46     return filePath;
 47 }

Calls: soulng::util::Path::Combine

Called by: cmajor::symbols::Resource::Read

MakeGlobalVariableName Function

std::u32string cmajor::symbols::MakeGlobalVariableName(const std::u32string& groupName, const std::string& compileUnitId)

Definition at line 465 of VariableSymbol.cpp :
466 {
467     std::u32string name = groupName;
468     name.append(1, '_').append(ToUtf32(compileUnitId));
469     return name;
470 }

MakePlainDerivationRec Function

TypeDerivationRec cmajor::symbols::MakePlainDerivationRec(const TypeDerivationRec & typeDerivationRec)

Definition at line 116 of DerivedTypeSymbol.cpp
Declaration at line 45 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::PlainType

MakePolymorphicClassArray Function

ConstantNode* cmajor::symbols::MakePolymorphicClassArray(const std::unordered_set<ClassTypeSymbol *>& polymorphicClasses, const std::u32string& arrayName)

Definition at line 1905 of ClassTypeSymbol.cpp
Declaration at line 255 of ClassTypeSymbol.hpp

Calls: cmajor::symbols::TypeSymbol::TypeId

MakeSignedIntegerTypeOperations Function

void cmajor::symbols::MakeSignedIntegerTypeOperations(SymbolTable & symbolTable, TypeSymbol * type)

Definition at line 450 of BasicTypeOperation.cpp

Calls: cmajor::symbols::SymbolTable::AddFunctionSymbolToGlobalScope

MakeSourceSpan Function

cmajor::debug::SourceSpan cmajor::symbols::MakeSourceSpan(const Span& span, const boost::uuids::uuid& sourceModuleId)

Definition at line 343 of Module.cpp :
 344 {
 345     if (!span.Valid()) return cmajor::debug::SourceSpan();
 346     if (sourceModuleId.is_nil()) return cmajor::debug::SourceSpan();
 347     Module* module = GetModuleById(sourceModuleId);
 348     if (!module) return cmajor::debug::SourceSpan();
 349     return module->SpanToSourceSpan(span);
 350 }

Declaration at line 128 of Module.hpp

Calls: cmajor::symbols::Module::SpanToSourceSpan

MakeStaticClassArray Function

ConstantNode* cmajor::symbols::MakeStaticClassArray(const std::unordered_set<ClassTypeSymbol *>& classesHavingStaticConstructor, const std::u32string& arrayName)

Definition at line 1935 of ClassTypeSymbol.cpp
Declaration at line 256 of ClassTypeSymbol.hpp

Calls: cmajor::symbols::TypeSymbol::TypeId

MakeSymbolLocation Function

SymbolLocation cmajor::symbols::MakeSymbolLocation(const Span& span, Module * module)

Definition at line 180 of Symbol.cpp :
 181 {
 182     int32_t scol = 0;
 183     int32_t ecol = 0;
 184     module->GetColumns(span, scol, ecol);
 185     return SymbolLocation(module->Id(), span.fileIndex, span.line, scol, ecol);
 186 }

Calls: cmajor::symbols::Module::GetColumns , cmajor::symbols::Module::Id

Called by: cmajor::symbols::SymbolTable::MapIdentifierToSymbolDefinition

MakeUnsignedIntegerTypeOperations Function

void cmajor::symbols::MakeUnsignedIntegerTypeOperations(SymbolTable & symbolTable, TypeSymbol * type)

Definition at line 467 of BasicTypeOperation.cpp

Calls: cmajor::symbols::SymbolTable::AddFunctionSymbolToGlobalScope

MapIdentifierToSymbolDefinition Function

void cmajor::symbols::MapIdentifierToSymbolDefinition(IdentifierNode* identifierNode, Symbol * symbol)

Definition at line 67 of SymbolTable.cpp

Calls: cmajor::symbols::Module::GetSymbolTable , cmajor::symbols::Module::IsImmutable , cmajor::symbols::Symbol::GetSpan , cmajor::symbols::Symbol::SourceModuleId , cmajor::symbols::SymbolTable::MapIdentifierToSymbolDefinition , soulng::lexer::Span::Valid

MapModule Function

void cmajor::symbols::MapModule(Module * module)

Definition at line 452 of ModuleCache.cpp :
453 {
454     std::lock_guard<std::recursive_mutex> lock(mtx);
455     ModuleCache::Instance().MapModule(module);
456 }

Declaration at line 64 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Instance , cmajor::symbols::ModuleCache::MapModule

Called by: cmajor::symbols::Module::PrepareForCompilation , cmajor::symbols::Module::ReadHeader

MapSourceFileToModuleId Function

void cmajor::symbols::MapSourceFileToModuleId(BackEnd backend, Config config, const std::string& sourceFilePath, const boost::uuids::uuid& moduleId)

Definition at line 85 of SourceFileModuleMap.cpp :
 86 {
 87     SourceFileModuleMap::Instance().SetModuleId(backend, config, sourceFilePath, moduleId);
 88 }

Declaration at line 16 of SourceFileModuleMap.hpp

Calls: cmajor::symbols::SourceFileModuleMap::Instance , cmajor::symbols::SourceFileModuleMap::SetModuleId

Called by: cmajor::symbols::Module::UpdateSourceFileModuleMap

MetaInit Function

void cmajor::symbols::MetaInit(SymbolTable & symbolTable)

Definition at line 648 of Meta.cpp
Declaration at line 27 of Meta.hpp

Calls: cmajor::symbols::ContainerSymbol::AddMember , cmajor::symbols::SymbolTable::BeginNamespace , cmajor::symbols::SymbolTable::Container , cmajor::symbols::SymbolTable::EndNamespace

ModuleFlagStr Function

std::string cmajor::symbols::ModuleFlagStr(ModuleFlags flags)

Definition at line 189 of Module.cpp
Declaration at line 82 of Module.hpp

Called by: cmajor::symbols::Module::Dump

MoveNonSystemModulesTo Function

void cmajor::symbols::MoveNonSystemModulesTo(std::unique_ptr<ModuleCache >& cachePtr)

Definition at line 430 of ModuleCache.cpp :
431 {
432     std::lock_guard<std::recursive_mutex> lock(mtx);
433     if (!cachePtr)
434     {
435         cachePtr.reset(new ModuleCache());
436     }
437     ModuleCache::Instance().MoveNonSystemModulesTo(cachePtr.get());
438 }

Declaration at line 62 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Instance , cmajor::symbols::ModuleCache::MoveNonSystemModulesTo

NumberOfAncestors Function

int cmajor::symbols::NumberOfAncestors(ClassInfo & cls)

Definition at line 1818 of ClassTypeSymbol.cpp :
1819 {
1820     int numAncestors = 0;
1821     ClassInfo* baseClass = cls.baseClassInfo;
1822     while (baseClass)
1823     {
1824         ++numAncestors;
1825         baseClass = baseClass->baseClassInfo;
1826     }
1827     return numAncestors;
1828 }

Overrides Function

bool cmajor::symbols::Overrides(FunctionSymbol * f, FunctionSymbol * g)

Definition at line 1126 of ClassTypeSymbol.cpp

Calls: cmajor::symbols::FunctionSymbol::GroupName , cmajor::symbols::FunctionSymbol::Parameters , cmajor::symbols::VariableSymbol::GetType

Called by: cmajor::symbols::ClassTypeSymbol::InitVmt

ParseCCName Function

std::vector<CCComponent > cmajor::symbols::ParseCCName(const std::u32string& qualifiedName)

Definition at line 228 of Scope.cpp

Called by: cmajor::symbols::ContainerScope::LookupBeginWith

ParseQualifiedName Function

std::vector<std::u32string> cmajor::symbols::ParseQualifiedName(const std::u32string& qualifiedName)

Definition at line 173 of Scope.cpp

Called by: cmajor::symbols::ContainerScope::Lookup

PrepareModuleForCompilation Function

void cmajor::symbols::PrepareModuleForCompilation(Module * rootModule, const std::vector<std::string>& references, Target target)

Definition at line 344 of ModuleCache.cpp
Declaration at line 47 of ModuleCache.hpp

Calls: cmajor::symbols::Module::GetSymbolTable , cmajor::symbols::Module::PrepareForCompilation

Called by: cmajor::symbols::EditModuleCache::LoadEditModule

PutModuleToModuleCache Function

void cmajor::symbols::PutModuleToModuleCache(std::unique_ptr<Module >&& module)

Definition at line 364 of ModuleCache.cpp :
365 {
366     std::lock_guard<std::recursive_mutex> lock(mtx);
367     ModuleCache::Instance().PutModule(std::move(module));
368 }

Declaration at line 49 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Instance , cmajor::symbols::ModuleCache::PutModule

ReadTraceTable Function

void cmajor::symbols::ReadTraceTable()

Definition at line 26 of Trace.cpp :
27 {
28     soulng::util::ReadTraceTable();
29 }

Declaration at line 15 of Trace.hpp

ReadValue Function

std::unique_ptr<Value > cmajor::symbols::ReadValue(BinaryReader& reader, const Span& span, const boost::uuids::uuid& moduleId)

Definition at line 4262 of Value.cpp

Called by: cmajor::symbols::ConstantSymbol::Read , cmajor::symbols::EnumConstantSymbol::Read , cmajor::symbols::GlobalVariableSymbol::Read

ReleaseModuleCache Function

std::unique_ptr<ModuleCache > cmajor::symbols::ReleaseModuleCache()

Definition at line 397 of ModuleCache.cpp :
398 {
399     std::lock_guard<std::recursive_mutex> lock(mtx);
400     return ModuleCache::Release();
401 }

Declaration at line 56 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Release

RemoveConstDerivation Function

TypeDerivationRec cmajor::symbols::RemoveConstDerivation(const TypeDerivationRec & typeDerivationRec)

Definition at line 171 of DerivedTypeSymbol.cpp
Declaration at line 48 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::RemoveConst

RemoveModuleFromCache Function

void cmajor::symbols::RemoveModuleFromCache(const std::string& moduleFilePath)

Definition at line 440 of ModuleCache.cpp :
441 {
442     std::lock_guard<std::recursive_mutex> lock(mtx);
443     ModuleCache::Instance().RemoveModule(moduleFilePath);
444 }

Declaration at line 61 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Instance , cmajor::symbols::ModuleCache::RemoveModule

RemovePointerDerivation Function

TypeDerivationRec cmajor::symbols::RemovePointerDerivation(const TypeDerivationRec & typeDerivationRec)

Definition at line 142 of DerivedTypeSymbol.cpp
Declaration at line 47 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::RemovePointer

RemoveReferenceDerivation Function

TypeDerivationRec cmajor::symbols::RemoveReferenceDerivation(const TypeDerivationRec & typeDerivationRec)

Definition at line 129 of DerivedTypeSymbol.cpp
Declaration at line 46 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::RemoveReference

ResetCachedModule Function

Module * cmajor::symbols::ResetCachedModule(const std::string& moduleFilePath)

Definition at line 370 of ModuleCache.cpp :
371 {
372     std::lock_guard<std::recursive_mutex> lock(mtx);
373     return ModuleCache::Instance().ResetModule(moduleFilePath);
374 }

Declaration at line 50 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Instance , cmajor::symbols::ModuleCache::ResetModule

ResetGlobalFlag Function

void cmajor::symbols::ResetGlobalFlag(GlobalFlags flag)

Definition at line 46 of GlobalFlags.cpp :
 47 {
 48     globalFlags = globalFlags & ~flag;
 49 }

Declaration at line 64 of GlobalFlags.hpp

ResetGlobalFlags Function

void cmajor::symbols::ResetGlobalFlags()

Definition at line 186 of GlobalFlags.cpp
Declaration at line 62 of GlobalFlags.hpp

Called by: cmajor::symbols::EditModuleCache::LoadEditModule

ResetModuleCache Function

void cmajor::symbols::ResetModuleCache()

Definition at line 386 of ModuleCache.cpp :
387 {
388     DoneModuleCache();
389     InitModuleCache();
390 }

Declaration at line 53 of ModuleCache.hpp

ResetUnitTestAssertionNumber Function

void cmajor::symbols::ResetUnitTestAssertionNumber()

Definition at line 151 of GlobalFlags.cpp :
152 {
153     unitTestAssertionNumber = 0;
154 }

Declaration at line 81 of GlobalFlags.hpp

ResolveBaseClasses Function

void cmajor::symbols::ResolveBaseClasses(std::unordered_map<boost::uuids::uuid, ClassInfo , boost::hash<boost::uuids::uuid>>& classIdMap)

Definition at line 1795 of ClassTypeSymbol.cpp

Calls: cmajor::symbols::ClassTypeSymbol::BaseClass , cmajor::symbols::Symbol::FullName , cmajor::symbols::Symbol::GetSpan , cmajor::symbols::Symbol::SourceModuleId , cmajor::symbols::TypeSymbol::TypeId

ResourceTypeStr Function

std::string cmajor::symbols::ResourceTypeStr(Type resourceType)

Definition at line 20 of ResourceTable.cpp :
 21 {
 22     switch (resourceType)
 23     {
 24         case Resource::Type::bitmap: return "bitmap";
 25         case Resource::Type::icon: return "icon";
 26         case Resource::Type::cursor: return "cursor";
 27     }
 28     return std::string();
 29 }

Declaration at line 37 of ResourceTable.hpp

Called by: cmajor::symbols::Resource::Dump

RestoreModulesFrom Function

void cmajor::symbols::RestoreModulesFrom(ModuleCache * prevCache)

Definition at line 403 of ModuleCache.cpp :
404 {
405     std::lock_guard<std::recursive_mutex> lock(mtx);
406     if (prevCache)
407     {
408         ModuleCache::Instance().Restore(prevCache);
409     }
410 }

Declaration at line 57 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Instance , cmajor::symbols::ModuleCache::Restore

SetAccessCheckFunction Function

void cmajor::symbols::SetAccessCheckFunction(AccessCheckFunction accessCheckFunc)

Definition at line 30 of FunctionSymbol.cpp :
  31 {
  32     hasAccess = accessCheckFunc;
  33 }

Declaration at line 42 of FunctionSymbol.hpp

SetAssertionLineNumberVector Function

void cmajor::symbols::SetAssertionLineNumberVector(std::vector<int32_t>* assertionLineNumberVector_)

Definition at line 173 of GlobalFlags.cpp :
174 {
175     assertionLineNumberVector = assertionLineNumberVector_;
176 }

Declaration at line 85 of GlobalFlags.hpp

SetBackEnd Function

void cmajor::symbols::SetBackEnd(BackEnd backend_)

Definition at line 16 of GlobalFlags.cpp :
 17 {
 18     backend = backend_;
 19 }

Declaration at line 59 of GlobalFlags.hpp

Called by: cmajor::symbols::EditModuleCache::LoadEditModule

SetCacheModule Function

void cmajor::symbols::SetCacheModule(const std::string& moduleFilePath, std::unique_ptr<Module >&& module)

Definition at line 424 of ModuleCache.cpp :
425 {
426     std::lock_guard<std::recursive_mutex> lock(mtx);
427     ModuleCache::Instance().SetModule(moduleFilePath, std::move(module));
428 }

Declaration at line 60 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Instance , cmajor::symbols::ModuleCache::SetModule

SetCompilerVersion Function

void cmajor::symbols::SetCompilerVersion(const std::string& compilerVersion_)

Definition at line 125 of GlobalFlags.cpp :
126 {
127     compilerVersion = compilerVersion_;
128 }

Declaration at line 73 of GlobalFlags.hpp

SetGlobalFlag Function

void cmajor::symbols::SetGlobalFlag(GlobalFlags flag)

Definition at line 41 of GlobalFlags.cpp :
 42 {
 43     globalFlags = globalFlags | flag;
 44 }

Declaration at line 63 of GlobalFlags.hpp

Called by: cmajor::symbols::EditModuleCache::LoadEditModule

SetNumBuildThreads Function

void cmajor::symbols::SetNumBuildThreads(int numBuildThreads_)

Definition at line 106 of GlobalFlags.cpp :
107 {
108     numBuildThreads = numBuildThreads_;
109 }

Declaration at line 71 of GlobalFlags.hpp

SetOptimizationLevel Function

void cmajor::symbols::SetOptimizationLevel(int optimizationLevel_)

Definition at line 96 of GlobalFlags.cpp :
 97 {
 98     optimizationLevel = optimizationLevel_;
 99 }

Declaration at line 69 of GlobalFlags.hpp

SetReadProjectFunction Function

void cmajor::symbols::SetReadProjectFunction(ReadProjectFunc readProjectFunc)

Definition at line 19 of EditModuleCache.cpp :
 20 {
 21     readProjectFunction = readProjectFunc;
 22 }

Declaration at line 15 of EditModuleCache.hpp

SetRootModuleForCurrentThread Function

void cmajor::symbols::SetRootModuleForCurrentThread(Module * rootModule_)

Definition at line 2042 of Module.cpp :
2043 {
2044     rootModule = rootModule_;
2045 }

Declaration at line 299 of Module.hpp

Called by: cmajor::symbols::EditModuleCache::LoadEditModule

SetTypeBindingFunction Function

void cmajor::symbols::SetTypeBindingFunction(TypeBindingFunction typeBindingFunc)

Definition at line 27 of Sources.cpp :
 28 {
 29     typeBindingFunction = typeBindingFunc;
 30 }

Declaration at line 29 of Sources.hpp

SetUseModuleCache Function

void cmajor::symbols::SetUseModuleCache(bool useModuleCache_)

Definition at line 392 of ModuleCache.cpp :
393 {
394     useModuleCache = useModuleCache_;
395 }

Declaration at line 54 of ModuleCache.hpp

SpanToDomElement Function

std::unique_ptr<Element > cmajor::symbols::SpanToDomElement(Module * module, const Span& span)

Definition at line 104 of Exception.cpp

Calls: cmajor::symbols::Module::GetColumns , cmajor::symbols::Module::GetErrorLines , cmajor::symbols::Module::GetFilePath

Called by: cmajor::symbols::Exception::AddToDiagnosticsElement

SpanToJson Function

std::unique_ptr<JsonObject > cmajor::symbols::SpanToJson(Module * module, const Span& span)

Definition at line 82 of Exception.cpp

Calls: cmajor::symbols::Module::GetColumns , cmajor::symbols::Module::GetErrorLines , cmajor::symbols::Module::GetFilePath

Called by: cmajor::symbols::Exception::ToJson

SymbolFlagStr Function

std::string cmajor::symbols::SymbolFlagStr(SymbolFlags symbolFlags)

Definition at line 72 of Symbol.cpp :
  73 {
  74     return SymbolFlagStr(symbolFlags, false);
  75 }

Declaration at line 106 of Symbol.hpp

Called by: cmajor::symbols::FunctionSymbol::FullNameWithSpecifiers , cmajor::symbols::FunctionSymbol::GetSpecifierStr , cmajor::symbols::Symbol::FullNameWithSpecifiers , cmajor::symbols::Symbol::GetSpecifierStr

SymbolFlagStr Function

std::string cmajor::symbols::SymbolFlagStr(SymbolFlags symbolFlags, bool noAccess)

Definition at line 77 of Symbol.cpp
Declaration at line 107 of Symbol.hpp

Called by: cmajor::symbols::StaticConstructorSymbol::FullNameWithSpecifiers

SymbolTypeStr Function

std::string cmajor::symbols::SymbolTypeStr(SymbolType symbolType)

Definition at line 67 of Symbol.cpp :
  68 {
  69     return symbolTypeStr[static_cast<uint8_t>(symbolType)];
  70 }

Declaration at line 70 of Symbol.hpp

Called by: cmajor::symbols::SymbolFactory::CreateSymbol

ToPrimitiveTypeKind Function

cmajor::debug::DIPrimitiveType::Kind cmajor::symbols::ToPrimitiveTypeKind(SymbolType symbolType)

Definition at line 24 of TypeIndex.cpp

Called by: cmajor::symbols::TypeIndex::AddType

TypesEqual Function

bool cmajor::symbols::TypesEqual(const TypeSymbol * left, const TypeSymbol * right) inline

Definition at line 92 of TypeSymbol.hpp :
 93 {
 94     if (left->TypeId() == right->TypeId()) return true;
 95     return CompareTypesForEquality(left, right);
 96 }

Calls: cmajor::symbols::TypeSymbol::TypeId

Called by: cmajor::symbols::ArrayValue::As , cmajor::symbols::ClassTypeSymbol::HasBaseClass , cmajor::symbols::ClassTypeSymbol::HasBaseClass , cmajor::symbols::ClassTypeSymbol::IsRecursive , cmajor::symbols::DerivedTypeSymbol::IsRecursive , cmajor::symbols::FunctionSymbol::IsCopyAssignment , cmajor::symbols::FunctionSymbol::IsCopyConstructor , cmajor::symbols::FunctionSymbol::IsMoveAssignment , cmajor::symbols::FunctionSymbol::IsMoveConstructor , cmajor::symbols::FunctionSymbolsEqual::operator() , cmajor::symbols::StructuredValue::As , cmajor::symbols::Symbol::IsSameParentOrAncestorOf , cmajor::symbols::TypeSymbol::IsRecursive

UnifyDerivations Function

TypeDerivationRec cmajor::symbols::UnifyDerivations(const TypeDerivationRec & left, const TypeDerivationRec & right)

Definition at line 247 of DerivedTypeSymbol.cpp
Declaration at line 53 of DerivedTypeSymbol.hpp

Called by: cmajor::symbols::DerivedTypeSymbol::Unify

UpdateModuleCache Function

void cmajor::symbols::UpdateModuleCache()

Definition at line 458 of ModuleCache.cpp :
459 {
460     std::lock_guard<std::recursive_mutex> lock(mtx);
461     ModuleCache::Instance().Update();
462 }

Declaration at line 65 of ModuleCache.hpp

Calls: cmajor::symbols::ModuleCache::Instance , cmajor::symbols::ModuleCache::Update

UseModuleCache Function

bool cmajor::symbols::UseModuleCache()

Definition at line 27 of ModuleCache.cpp :
 28 {
 29     return useModuleCache;
 30 }

Declaration at line 55 of ModuleCache.hpp

ValueTypeStr Function

std::string cmajor::symbols::ValueTypeStr(ValueType valueType)

Definition at line 22 of Value.cpp :
  23 {
  24     return valueTypeStr[uint8_t(valueType)];
  25 }

Declaration at line 27 of Value.hpp

Called by: cmajor::symbols::ArrayValue::As , cmajor::symbols::BoolValue::As , cmajor::symbols::ByteValue::As , cmajor::symbols::CharValue::As , cmajor::symbols::DoubleValue::As , cmajor::symbols::FloatValue::As , cmajor::symbols::IntValue::As , cmajor::symbols::LongValue::As , cmajor::symbols::NullValue::As , cmajor::symbols::PointerValue::As , cmajor::symbols::SByteValue::As , cmajor::symbols::ShortValue::As , cmajor::symbols::StringValue::As , cmajor::symbols::StructuredValue::As , cmajor::symbols::UCharValue::As , cmajor::symbols::UIntValue::As , cmajor::symbols::ULongValue::As , cmajor::symbols::UShortValue::As , cmajor::symbols::UStringValue::As , cmajor::symbols::UuidValue::As , cmajor::symbols::WCharValue::As , cmajor::symbols::WStringValue::As

ValuesEqual Function

bool cmajor::symbols::ValuesEqual<ValueT>(const ValueT& left, const ValueT& right) inline

Definition at line 473 of Value.hpp :
474 {
475     return left.GetValue() == right.GetValue();
476 }

Visit Function

void cmajor::symbols::Visit(std::vector<Module *>& finishReadOrder, Module * module, std::unordered_set<Module *>& visited, std::unordered_set<Module *>& tempVisit, std::unordered_map<Module *, ModuleDependency *>& dependencyMap, const Module * rootModule)

Definition at line 352 of Module.cpp

Calls: cmajor::symbols::Module::Name , cmajor::symbols::ModuleDependency::ReferencedModules

WriteTraceTable Function

void cmajor::symbols::WriteTraceTable()

Definition at line 30 of Trace.cpp :
31 {
32     soulng::util::WriteTraceTable();
33 }

Declaration at line 16 of Trace.hpp

WriteValue Function

void cmajor::symbols::WriteValue(Value * value, BinaryWriter& writer)

Definition at line 4256 of Value.cpp :
4257 {
4258     writer.Write(static_cast<uint8_t>(value->GetValueType()));
4259     value->Write(writer);
4260 }

Declaration at line 502 of Value.hpp

Calls: cmajor::symbols::Value::GetValueType , cmajor::symbols::Value::Write

Called by: cmajor::symbols::ConstantSymbol::Write , cmajor::symbols::EnumConstantSymbol::Write , cmajor::symbols::GlobalVariableSymbol::Write

operator!= Function

bool cmajor::symbols::operator!=(IntegralValue left, IntegralValue right) inline

Definition at line 492 of Value.hpp :
493 {
494     return !(left == right);
495 }

operator!= Function

bool cmajor::symbols::operator!=(const ArrayKey & left, const ArrayKey & right)

Definition at line 62 of SymbolTable.cpp :
  63 {
  64     return !(left == right);
  65 }

Declaration at line 88 of SymbolTable.hpp

operator!= Function

bool cmajor::symbols::operator!=(const ClassTemplateSpecializationKey & left, const ClassTemplateSpecializationKey & right)

Definition at line 50 of SymbolTable.cpp :
  51 {
  52     return !(left == right);
  53 }

Declaration at line 78 of SymbolTable.hpp

operator!= Function

bool cmajor::symbols::operator!=(const TypeDerivationRec & left, const TypeDerivationRec & right) inline

Definition at line 30 of DerivedTypeSymbol.hpp :
 31 {
 32     return !(left == right);
 33 }

operator& Function

ClassTemplateSpecializationFlags cmajor::symbols::operator&(ClassTemplateSpecializationFlags left, ClassTemplateSpecializationFlags right) inline

Definition at line 25 of ClassTemplateSpecializationSymbol.hpp :
26 {
27     return ClassTemplateSpecializationFlags(uint8_t(left) & uint8_t(right));
28 }

operator& Function

ClassTypeSymbolFlags cmajor::symbols::operator&(ClassTypeSymbolFlags left, ClassTypeSymbolFlags right) inline

Definition at line 71 of ClassTypeSymbol.hpp :
 72 {
 73     return ClassTypeSymbolFlags(uint16_t(left) & uint16_t(right));
 74 }

operator& Function

FunctionSymbolFlags cmajor::symbols::operator&(FunctionSymbolFlags left, FunctionSymbolFlags right) inline

Definition at line 113 of FunctionSymbol.hpp :
114 {
115     return FunctionSymbolFlags(uint32_t(left) & uint32_t(right));
116 }

operator& Function

GlobalFlags cmajor::symbols::operator&(GlobalFlags flags, GlobalFlags flag) inline

Definition at line 31 of GlobalFlags.cpp :
 32 {
 33     return GlobalFlags(uint64_t(flags) & uint64_t(flag));
 34 }

operator& Function

ModuleFlags cmajor::symbols::operator&(ModuleFlags left, ModuleFlags right) inline

Definition at line 72 of Module.hpp :
 73 {
 74     return ModuleFlags(uint8_t(left) & uint8_t(right));
 75 }

operator& Function

ScopeLookup cmajor::symbols::operator&(ScopeLookup left, ScopeLookup right) inline

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

operator& Function

SymbolFlags cmajor::symbols::operator&(SymbolFlags left, SymbolFlags right) inline

Definition at line 91 of Symbol.hpp :
 92 {
 93     return SymbolFlags(uint8_t(left) & uint8_t(right));
 94 }

operator< Function

bool cmajor::symbols::operator<(const SourceFileModuleMapKey & left, const SourceFileModuleMapKey & right)

Definition at line 26 of SourceFileModuleMap.cpp :
 27 {
 28     if (left.backend < right.backend) return true;
 29     if (left.backend > right.backend) return false;
 30     if (left.config < right.config) return true;
 31     if (left.config > right.config) return false;
 32     return left.sourceFilePath < right.sourceFilePath;
 33 }

operator< Function

bool cmajor::symbols::operator<(const SymbolLocation & left, const SymbolLocation & right)

Definition at line 167 of Symbol.cpp
Declaration at line 127 of Symbol.hpp

operator== Function

bool cmajor::symbols::operator==(IntegralValue left, IntegralValue right)

Definition at line 4215 of Value.cpp
Declaration at line 490 of Value.hpp

Calls: cmajor::symbols::Value::GetValueType

operator== Function

bool cmajor::symbols::operator==(const ArrayKey & left, const ArrayKey & right)

Definition at line 55 of SymbolTable.cpp :
  56 {
  57     if (!TypesEqual(left.elementType, right.elementType)) return false;
  58     if (left.size != right.size) return false;
  59     return true;
  60 }

Declaration at line 87 of SymbolTable.hpp

operator== Function

bool cmajor::symbols::operator==(const ClassTemplateSpecializationKey & left, const ClassTemplateSpecializationKey & right)

Definition at line 38 of SymbolTable.cpp :
  39 {
  40     if (!TypesEqual(left.classTemplate, right.classTemplate)) return false;
  41     int n = left.templateArgumentTypes.size();
  42     if (n != right.templateArgumentTypes.size()) return false;
  43     for (int i = 0; i < n; ++i)
  44     {
  45         if (!TypesEqual(left.templateArgumentTypes[i], right.templateArgumentTypes[i])) return false;
  46     }
  47     return true;
  48 }

Declaration at line 77 of SymbolTable.hpp

operator== Function

bool cmajor::symbols::operator==(const ConversionTableEntry & left, const ConversionTableEntry & right) inline

Definition at line 24 of ConversionTable.hpp :
25 {
26     return TypesEqual(left.sourceType, right.sourceType) && TypesEqual(left.targetType, right.targetType);
27 }

operator== Function

bool cmajor::symbols::operator==(const SourceFileModuleMapKey & left, const SourceFileModuleMapKey & right)

Definition at line 21 of SourceFileModuleMap.cpp :
 22 {
 23     return left.backend == right.backend && left.config == right.config && left.sourceFilePath == right.sourceFilePath;
 24 }

operator== Function

bool cmajor::symbols::operator==(const SymbolLocation & left, const SymbolLocation & right)

Definition at line 162 of Symbol.cpp :
 163 {
 164     return left.moduleId == right.moduleId && left.fileIndex == right.fileIndex && left.line == right.line && left.scol == right.scol && left.ecol == right.ecol;
 165 }

Declaration at line 126 of Symbol.hpp

operator== Function

bool cmajor::symbols::operator==(const TypeDerivationRec & left, const TypeDerivationRec & right) inline

Definition at line 25 of DerivedTypeSymbol.hpp :
 26 {
 27     return left.derivations == right.derivations;
 28 }

operator| Function

ClassTemplateSpecializationFlags cmajor::symbols::operator|(ClassTemplateSpecializationFlags left, ClassTemplateSpecializationFlags right) inline

Definition at line 20 of ClassTemplateSpecializationSymbol.hpp :
21 {
22     return ClassTemplateSpecializationFlags(uint8_t(left) | uint8_t(right));
23 }

operator| Function

ClassTypeSymbolFlags cmajor::symbols::operator|(ClassTypeSymbolFlags left, ClassTypeSymbolFlags right) inline

Definition at line 66 of ClassTypeSymbol.hpp :
 67 {
 68     return ClassTypeSymbolFlags(uint16_t(left) | uint16_t(right));
 69 }

operator| Function

FunctionSymbolFlags cmajor::symbols::operator|(FunctionSymbolFlags left, FunctionSymbolFlags right) inline

Definition at line 108 of FunctionSymbol.hpp :
109 {
110     return FunctionSymbolFlags(uint32_t(left) | uint32_t(right));
111 }

operator| Function

GlobalFlags cmajor::symbols::operator|(GlobalFlags flags, GlobalFlags flag) inline

Definition at line 26 of GlobalFlags.cpp :
 27 {
 28     return GlobalFlags(uint64_t(flags) | uint64_t(flag));
 29 }

operator| Function

ModuleFlags cmajor::symbols::operator|(ModuleFlags left, ModuleFlags right) inline

Definition at line 67 of Module.hpp :
 68 {
 69     return ModuleFlags(uint8_t(left) | uint8_t(right));
 70 }

operator| Function

SymbolFlags cmajor::symbols::operator|(SymbolFlags left, SymbolFlags right) inline

Definition at line 96 of Symbol.hpp :
 97 {
 98     return SymbolFlags(uint8_t(left) | uint8_t(right));
 99 }

operator~ Function

ClassTemplateSpecializationFlags cmajor::symbols::operator~(ClassTemplateSpecializationFlags flags) inline

Definition at line 30 of ClassTemplateSpecializationSymbol.hpp :
31 {
32     return ClassTemplateSpecializationFlags(~uint8_t(flags));
33 }

operator~ Function

ClassTypeSymbolFlags cmajor::symbols::operator~(ClassTypeSymbolFlags operand) inline

Definition at line 76 of ClassTypeSymbol.hpp :
 77 {
 78     return ClassTypeSymbolFlags(~uint16_t(operand));
 79 }

operator~ Function

FunctionSymbolFlags cmajor::symbols::operator~(FunctionSymbolFlags flag) inline

Definition at line 118 of FunctionSymbol.hpp :
119 {
120     return FunctionSymbolFlags(~uint32_t(flag));
121 }

operator~ Function

GlobalFlags cmajor::symbols::operator~(GlobalFlags flags) inline

Definition at line 36 of GlobalFlags.cpp :
 37 {
 38     return GlobalFlags(~uint64_t(flags));
 39 }

operator~ Function

ModuleFlags cmajor::symbols::operator~(ModuleFlags flags) inline

Definition at line 77 of Module.hpp :
 78 {
 79     return ModuleFlags(~uint8_t(flags));
 80 }

operator~ Function

ScopeLookup cmajor::symbols::operator~(ScopeLookup subject) inline

Definition at line 42 of Scope.hpp :
 43 {
 44     return ScopeLookup(~uint8_t(subject));
 45 }

operator~ Function

SymbolFlags cmajor::symbols::operator~(SymbolFlags flags) inline

Definition at line 101 of Symbol.hpp :
102 {
103     return SymbolFlags(~uint8_t(flags));
104 }

top | up | prev | next