top | up | prev | next

ast Namespace

Classes

class AddNode
class AddrOfNode
class AliasNode
class ArrayLiteralNode
class ArrayNode
class ArrowNode
class AsNode
class AssertStatementNode
class AssignmentStatementNode
class AstReader
class AstWriter
class Attribute
class AttributeNotUniqueException
class Attributes
class AxiomNode
class AxiomStatementNode
class BaseInitializerNode
class BaseNode
class BinaryConstraintNode
class BinaryNode
class BitAndNode
class BitOrNode
class BitXorNode
class BoolNode
class BooleanLiteralNode
class BreakStatementNode
class ByteLiteralNode
class ByteNode
class CaseStatementNode
class CastNode
class CatchNode
class CharLiteralNode
class CharNode
class ClassDelegateNode
class ClassMemberArranger
class ClassNode
class CloneContext
class CommentNode
class CommonConceptNode
class CommonConstraintNode
class CompileUnitNode
class ComplementNode
class CompoundStatementNode
class ConceptIdNode
class ConceptNode
class ConcreteNodeCreator
class ConditionalCompilationBinaryExpressionNode
class ConditionalCompilationConjunctionNode
class ConditionalCompilationDisjunctionNode
class ConditionalCompilationExpressionNode
class ConditionalCompilationNotNode
class ConditionalCompilationPartNode
class ConditionalCompilationPrimaryNode
class ConditionalCompilationStatementNode
class ConjunctionNode
class ConjunctiveConstraintNode
class ConstNode
class ConstantNode
class ConstraintNode
class ConstructNode
class ConstructionStatementNode
class ConstructorConstraintNode
class ConstructorNode
class ContinueStatementNode
class ConversionFunctionNode
class ConvertibleConceptNode
class ConvertibleConstraintNode
class CursorIdNode
class DefaultStatementNode
class DelegateNode
class DeleteStatementNode
class DerefNode
class DerivedConceptNode
class DerivedConstraintNode
class DestroyStatementNode
class DestructorConstraintNode
class DestructorNode
class DisjunctionNode
class DisjunctiveConstraintNode
class DivNode
class DoStatementNode
class DotNode
class DoubleLiteralNode
class DoubleNode
class EmptyStatementNode
class EnumConstantNode
class EnumTypeNode
class EqualNode
class EquivalenceNode
class ExplicitlyConvertibleConceptNode
class ExplicitlyConvertibleConstraintNode
class ExpressionStatementNode
class FloatLiteralNode
class FloatNode
class ForStatementNode
class FunctionConstraintNode
class FunctionNode
class GlobalVariableNode
class GotoCaseStatementNode
class GotoDefaultStatementNode
class GotoStatementNode
class GreaterNode
class GreaterOrEqualNode
class IdentifierNode
class IfStatementNode
class ImplicationNode
class IndexingNode
class InitializerNode
class IntLiteralNode
class IntNode
class InterfaceNode
class IntrinsicConstraintNode
class InvokeNode
class IsConstraintNode
class IsNode
class LValueRefNode
class LabelNode
class LabeledStatementNode
class LessNode
class LessOrEqualNode
class LiteralNode
class LongLiteralNode
class LongNode
class MemberFunctionConstraintNode
class MemberFunctionNode
class MemberInitializerNode
class MemberVariableNode
class MergeVisitor
class ModuleVersionTagVerifier
class MulNode
class MultiParamConstraintNode
class NamespaceCombiner
class NamespaceImportNode
class NamespaceNode
class NewNode
class Node
class NodeCreator
class NodeFactory
class NodeList
class NodeSelectorVisitor
class NonreferenceTypeConceptNode
class NonreferenceTypeConstraintNode
class NotEqualNode
class NotNode
class NullLiteralNode
class ParameterNode
class ParenthesizedConditionalCompilationExpressionNode
class ParenthesizedConstraintNode
class ParenthesizedExpressionNode
class PointerNode
class PostfixDecrementNode
class PostfixIncrementNode
class PredicateConstraintNode
class PrefixDecrementNode
class PrefixIncrementNode
class Project
class ProjectDeclaration
class ProjectDependencyDeclaration
class RValueRefNode
class RangeForStatementNode
class ReferenceDeclaration
class RemNode
class ResourceFileDeclaration
class ReturnStatementNode
class SByteLiteralNode
class SByteNode
class SameConceptNode
class SameConstraintNode
class ShiftLeftNode
class ShiftRightNode
class ShortLiteralNode
class ShortNode
class SignatureConstraintNode
class SizeOfNode
class Solution
class SolutionActiveProjectDeclaration
class SolutionDeclaration
class SolutionProjectDeclaration
class SourceFileDeclaration
class SourceTokenFormatter
class SourceWriter
class StatementNode
class StaticConstructorNode
class StringLiteralNode
class StructuredLiteralNode
class SubNode
class SwitchStatementNode
class SystemFileIndex
class TargetDeclaration
class TemplateIdNode
class TemplateParameterNode
class TextFileDeclaration
class ThisInitializerNode
class ThisNode
class ThrowStatementNode
class TryStatementNode
class TypeIdNode
class TypeNameConstraintNode
class TypeNameNode
class TypedefNode
class UCharLiteralNode
class UCharNode
class UIntLiteralNode
class UIntNode
class ULongLiteralNode
class ULongNode
class UShortLiteralNode
class UShortNode
class UStringLiteralNode
class UnaryMinusNode
class UnaryNode
class UnaryPlusNode
class UnnamedNamespaceProcessor
class UuidLiteralNode
class Visitor
class VoidNode
class WCharLiteralNode
class WCharNode
class WStringLiteralNode
class WhereConstraintNode
class WhileStatementNode

Functions

void AddNamespaceImportsForUnnamedNamespaces(CompileUnitNode& cu)
void ArrangeClassMembers(CompileUnitNode& cu)
std::string CmajorResourceDir()
std::string CmajorRootDir()
std::string CmajorSystemLibDir(const std::string& config, BackEnd backend)
std::string CmajorSystemModuleFilePath(const std::string& config, BackEnd backend)
std::string CmajorSystemWindowsModuleFilePath(const std::string& config)
void CombineNamespaces(CompileUnitNode& cu)
LiteralNode* CreateCharacterLiteralNode(const Span& span, char32_t value, int chrLitPrefix)
LiteralNode* CreateFloatingLiteralNode(const Span& span, double value, bool float_)
LiteralNode* CreateIntegerLiteralNode(const Span& span, uint64_t value, bool unsignedSuffix)
LiteralNode* CreateStringLiteralNode(const Span& span, const std::u32string& value, int strLitPrefix)
void Done()
int16_t GetFileId(int32_t fileIndex) inline
int16_t GetModuleId(int32_t fileIndex) inline
void Init()
int32_t MakeFileIndex(int16_t moduleId, int16_t fileId) inline
Node* MakeNextEnumConstantValue(const Span& span, EnumTypeNode* enumType)
void Merge(CompileUnitNode& source, CompileUnitNode& target)
void NodeDone()
void NodeInit()
std::string NodeTypeStr(NodeType nodeType)
const std::string& OutDir()
void SetModuleVersionTagVerifier(ModuleVersionTagVerifier* verifier)
void SetOutDir(const std::string& outDir_)
std::string SpecifierStr(Specifiers specifiers)
bool StaticConstructorSpecifiers(Specifiers specifiers)
void SystemFileIndexInit()
void Visit(std::vector<std::u32string>& order, const std::u32string& projectName, std::unordered_set<std::u32string>& visited, std::unordered_set<std::u32string>& tempVisit, const std::unordered_map<std::u32string, ProjectDependencyDeclaration*>& dependencyMap, Solution* solution)
NsFlags operator&(NsFlags left, NsFlags right) constexpr inline
Specifiers operator&(Specifiers left, Specifiers right) inline
NsFlags operator|(NsFlags left, NsFlags right) constexpr inline
Specifiers operator|(Specifiers left, Specifiers right) inline
Specifiers operator~(Specifiers operand) inline

Enumerations

enum class BackEnd
enum class NodeType
enum class NsFlags
enum class ProjectDeclarationType
enum class Specifiers
enum class Target

Variables

const uint32_t firstSystemFileIndex
ModuleVersionTagVerifier* moduleVersionTagVerifier
std::mutex mtx
std::string outDir

Function Details

AddNamespaceImportsForUnnamedNamespaces Function

void sngcm::ast::AddNamespaceImportsForUnnamedNamespaces(CompileUnitNode & cu)

Definition at line 188 of CompileUnit.cpp :
189 {
190     UnnamedNamespaceProcessor processor;
191     cu.Accept(processor);
192 }

Declaration at line 38 of CompileUnit.hpp

Calls: sngcm::ast::CompileUnitNode::Accept

ArrangeClassMembers Function

void sngcm::ast::ArrangeClassMembers(CompileUnitNode & cu)

Definition at line 141 of CompileUnit.cpp :
142 {
143     ClassMemberArranger arranger;
144     cu.Accept(arranger);
145 }

Declaration at line 37 of CompileUnit.hpp

Calls: sngcm::ast::CompileUnitNode::Accept

CmajorResourceDir Function

std::string sngcm::ast::CmajorResourceDir()

Definition at line 60 of Project.cpp :
 61 {
 62     boost::filesystem::path rd(CmajorRootDir());
 63     rd /= "res";
 64     return GetFullPath(rd.generic_string());
 65 }

Declaration at line 31 of Project.hpp

CmajorRootDir Function

std::string sngcm::ast::CmajorRootDir()

Definition at line 24 of Project.cpp :
 25 {
 26     char* e = getenv("CMAJOR_ROOT");
 27     if (e == nullptr || !*e)
 28     {
 29         throw std::runtime_error("please set 'CMAJOR_ROOT' environment variable to contain /path/to/cmajor directory.");
 30     }
 31     return std::string(e);
 32 }

Declaration at line 29 of Project.hpp

CmajorSystemLibDir Function

std::string sngcm::ast::CmajorSystemLibDir(const std::string& config, BackEnd backend)

Definition at line 34 of Project.cpp
Declaration at line 30 of Project.hpp

CmajorSystemModuleFilePath Function

std::string sngcm::ast::CmajorSystemModuleFilePath(const std::string& config, BackEnd backend)

Definition at line 79 of Project.cpp :
 80 {
 81     boost::filesystem::path smfp(CmajorSystemLibDir(config, backend));
 82     smfp /= "System.cmm";
 83     return GetFullPath(smfp.generic_string());
 84 }

Declaration at line 32 of Project.hpp

CmajorSystemWindowsModuleFilePath Function

std::string sngcm::ast::CmajorSystemWindowsModuleFilePath(const std::string& config)

Definition at line 86 of Project.cpp :
 87 {
 88     boost::filesystem::path smfp(CmajorSystemLibDir(config, BackEnd::llvm));
 89     smfp /= "System.Windows.cmm";
 90     return GetFullPath(smfp.generic_string());
 91 }

Declaration at line 33 of Project.hpp

CombineNamespaces Function

void sngcm::ast::CombineNamespaces(CompileUnitNode & cu)

Definition at line 103 of CompileUnit.cpp :
104 {
105     NamespaceCombiner combiner;
106     cu.Accept(combiner);
107 }

Declaration at line 36 of CompileUnit.hpp

Calls: sngcm::ast::CompileUnitNode::Accept

CreateCharacterLiteralNode Function

LiteralNode * sngcm::ast::CreateCharacterLiteralNode(const Span& span, char32_t value, int chrLitPrefix)

Definition at line 76 of Literal.cpp
Declaration at line 27 of Literal.hpp

CreateFloatingLiteralNode Function

LiteralNode * sngcm::ast::CreateFloatingLiteralNode(const Span& span, double value, bool float_)

Definition at line 64 of Literal.cpp :
 65 {
 66     if (float_)
 67     {
 68         return new FloatLiteralNode(span, static_cast<float>(value));
 69     }
 70     else
 71     {
 72         return new DoubleLiteralNode(span, value);
 73     }
 74 }

Declaration at line 26 of Literal.hpp

CreateIntegerLiteralNode Function

LiteralNode * sngcm::ast::CreateIntegerLiteralNode(const Span& span, uint64_t value, bool unsignedSuffix)

Definition at line 40 of Literal.cpp
Declaration at line 25 of Literal.hpp

CreateStringLiteralNode Function

LiteralNode * sngcm::ast::CreateStringLiteralNode(const Span& span, const std::u32string& value, int strLitPrefix)

Definition at line 96 of Literal.cpp
Declaration at line 28 of Literal.hpp

Done Function

void sngcm::ast::Done()

Definition at line 18 of InitDone.cpp :
19 {
20     NodeDone();
21 }

Declaration at line 13 of InitDone.hpp

GetFileId Function

int16_t sngcm::ast::GetFileId(int32_t fileIndex) inline

Definition at line 40 of AstReader.hpp :
41 {
42     return static_cast<int16_t>(fileIndex & 0xFFFF);
43 }

Called by: sngcm::ast::AstReader::ReadSpan

GetModuleId Function

int16_t sngcm::ast::GetModuleId(int32_t fileIndex) inline

Definition at line 35 of AstReader.hpp :
36 {
37     return static_cast<int16_t>((fileIndex >> 16) & 0xFFFF);
38 }

Init Function

void sngcm::ast::Init()

Definition at line 12 of InitDone.cpp :
13 {
14     NodeInit();
15     SystemFileIndexInit();
16 }

Declaration at line 12 of InitDone.hpp

MakeFileIndex Function

int32_t sngcm::ast::MakeFileIndex(int16_t moduleId, int16_t fileId) inline

Definition at line 30 of AstReader.hpp :
31 {
32     return (static_cast<int32_t>(moduleId) << 16) | fileId;
33 }

Called by: sngcm::ast::AstReader::ReadSpan

MakeNextEnumConstantValue Function

Node * sngcm::ast::MakeNextEnumConstantValue(const Span& span, EnumTypeNode * enumType)

Definition at line 144 of Enumeration.cpp
Declaration at line 68 of Enumeration.hpp

Calls: sngcm::ast::EnumConstantNode::GetValue , sngcm::ast::EnumTypeNode::GetLastConstant , sngcm::ast::EnumTypeNode::GetUnderlyingType , sngcm::ast::Node::Clone , sngcm::ast::Node::IsUnsignedTypeNode

Merge Function

void sngcm::ast::Merge(CompileUnitNode & source, CompileUnitNode & target)

Definition at line 185 of Merge.cpp :
186 {
187     MergeVisitor visitor(target.GlobalNs());
188     source.GlobalNs()->Accept(visitor);
189 }

Declaration at line 14 of Merge.hpp

Calls: sngcm::ast::CompileUnitNode::GlobalNs , sngcm::ast::NamespaceNode::Accept

NodeDone Function

void sngcm::ast::NodeDone()

Definition at line 417 of Node.cpp :
418 {
419     NodeFactory::Done();
420 }

Declaration at line 153 of Node.hpp

Calls: sngcm::ast::NodeFactory::Done

NodeInit Function

void sngcm::ast::NodeInit()

Definition at line 412 of Node.cpp :
413 {
414     NodeFactory::Init();
415 }

Declaration at line 152 of Node.hpp

Calls: sngcm::ast::NodeFactory::Init

NodeTypeStr Function

std::string sngcm::ast::NodeTypeStr(NodeType nodeType)

Definition at line 63 of Node.cpp :
 64 {
 65     return nodeTypeStr[static_cast<size_t>(nodeType)];
 66 }

Declaration at line 55 of Node.hpp

Called by: sngcm::ast::NodeFactory::CreateNode

OutDir Function

const std::string& sngcm::ast::OutDir()

Definition at line 74 of Project.cpp :
 75 {
 76     return outDir;
 77 }

Declaration at line 35 of Project.hpp

SetModuleVersionTagVerifier Function

void sngcm::ast::SetModuleVersionTagVerifier(ModuleVersionTagVerifier * verifier)

Definition at line 19 of Project.cpp :
 20 {
 21     moduleVersionTagVerifier = verifier;
 22 }

Declaration at line 27 of Project.hpp

SetOutDir Function

void sngcm::ast::SetOutDir(const std::string& outDir_)

Definition at line 69 of Project.cpp :
 70 {
 71     outDir = outDir_;
 72 }

Declaration at line 34 of Project.hpp

SpecifierStr Function

std::string sngcm::ast::SpecifierStr(Specifiers specifiers)

Definition at line 10 of Specifier.cpp
Declaration at line 58 of Specifier.hpp

Called by: sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit , sngcm::ast::SourceWriter::Visit

StaticConstructorSpecifiers Function

bool sngcm::ast::StaticConstructorSpecifiers(Specifiers specifiers)

Definition at line 164 of Specifier.cpp :
165 {
166     if ((specifiers & Specifiers::static_) == Specifiers::none) return false;
167     return true;
168 }

Declaration at line 56 of Specifier.hpp

SystemFileIndexInit Function

void sngcm::ast::SystemFileIndexInit()

Definition at line 97 of SystemFileIndex.cpp :
 98 {
 99     SystemFileIndex::Init();
100 }

Declaration at line 34 of SystemFileIndex.hpp

Calls: sngcm::ast::SystemFileIndex::Init

Visit Function

void sngcm::ast::Visit(std::vector<std::u32string>& order, const std::u32string& projectName, std::unordered_set<std::u32string>& visited, std::unordered_set<std::u32string>& tempVisit, const std::unordered_map<std::u32string, ProjectDependencyDeclaration *>& dependencyMap, Solution * solution)

Definition at line 97 of Solution.cpp

Calls: sngcm::ast::ProjectDependencyDeclaration::DependsOnProjects , sngcm::ast::Solution::FilePath , sngcm::ast::Solution::Name

Called by: sngcm::ast::Solution::CreateBuildOrder

operator& Function

NsFlags sngcm::ast::operator&(NsFlags left, NsFlags right) constexpr inline

Definition at line 25 of Namespace.hpp :
26 {
27     return static_cast<NsFlags>(static_cast<int8_t>(left) & static_cast<int8_t>(right));
28 }

operator& Function

Specifiers sngcm::ast::operator&(Specifiers left, Specifiers right) inline

Definition at line 46 of Specifier.hpp :
47 {
48     return static_cast<Specifiers>(static_cast<int32_t>(left) & static_cast<int32_t>(right));
49 }

operator| Function

NsFlags sngcm::ast::operator|(NsFlags left, NsFlags right) constexpr inline

Definition at line 20 of Namespace.hpp :
21 {
22     return static_cast<NsFlags>(static_cast<int8_t>(left) | static_cast<int8_t>(right));
23 }

operator| Function

Specifiers sngcm::ast::operator|(Specifiers left, Specifiers right) inline

Definition at line 41 of Specifier.hpp :
42 {
43     return static_cast<Specifiers>(static_cast<int32_t>(left) | static_cast<int32_t>(right));
44 }

operator~ Function

Specifiers sngcm::ast::operator~(Specifiers operand) inline

Definition at line 51 of Specifier.hpp :
52 {
53     return static_cast<Specifiers>(~static_cast<int32_t>(operand));
54 }

top | up | prev | next