| Csemantic::AstChecker | |
| ►Cast::AstNode | Base class for all AST nodes. Helps unify printing and dot printing |
| ►Cast::Decl | Base class for all declarations |
| Cast::ClassDecl | |
| Cast::InterfaceDecl | |
| Cast::MethodDecl | |
| ►Cast::TypedDecl | Represents a variable declaration with: a name, a type and an optional initializer |
| Cast::FieldDecl | Represents a typed declaration with access modifiers |
| Cast::VarDecl | Represents a scoped (i.e., local) typed variable declaration |
| ►Cast::DeclContext | Base class for all declaration contexts (i.e., methods) |
| Cast::ClassDecl | |
| Cast::CompilationUnit | |
| Cast::InterfaceDecl | |
| Cast::LinkingUnit | |
| Cast::MethodDecl | |
| ►Cast::Stmt | Base class for all statements |
| Cast::BlockStatement | |
| Cast::DeclStmt | |
| Cast::ExprStmt | |
| Cast::ForStmt | |
| Cast::IfStmt | |
| Cast::NullStmt | |
| Cast::ReturnStmt | |
| Cast::WhileStmt | |
| ►Cast::Type | Base class for all types |
| Cast::ArrayType | Represents an (unsized) array type |
| Cast::BuiltInType | Represents a primitive type in the Java language |
| Cast::MethodType | This is a synthetic MethodType that should not exist inside the AST |
| ►Cast::ReferenceType | Represents a reference type. This is a type that refers to either a class or an interface declaration. Creation of a reference type must result in a declaration being resolved to it |
| Cast::UnresolvedType | Represents an unresolved reference type. This means that the underlying reference type is not yet resolved to a declaration. This class is used to represent types whose names are qualified with multiple parts, or simple type names |
| Csemantic::CFGBuilder | |
| Csemantic::CFGNode | |
| Ctir::Type::ChildTypeArray | |
| Ccodegen::CodeGenerator | |
| Ctir::CompilationUnit | |
| Csemantic::ConstantReturnType | |
| Ctir::Context | |
| Ctir::ContextPImpl | |
| Csemantic::DataflowAnalysis | |
| Cdiagnostics::DiagnosticBuilder | |
| Cdiagnostics::DiagnosticEngine | |
| Cdiagnostics::DiagnosticStorage | |
| Cutils::DotPrinter | A class to help print DOT graphs! |
| Csemantic::CFGNode::EmptyExpr | |
| ►Cstd::exception | |
| Cparsetree::ParseTreeException | |
| Cast::Expr | |
| Cast::ExprEvaluator< T > | |
| ►Cast::ExprEvaluator< ast::Type const * > | |
| Csemantic::ExprTypeResolver | Will resolve all types in the Expression. If a type cannot be resolved, then we assume an invalid type error has occurred (i.e., type checking) |
| ►Cast::ExprEvaluator< ConstantReturnType const * > | |
| Csemantic::ConstantTypeResolver | Will resolve a constant boolean expression if possible, or return a nullptr if the expression is not a constant expression |
| ►Cast::ExprEvaluator< details::ValueWrapper > | |
| Ccodegen::CGExprEvaluator | The code generator expression evaluator. This class is responsible for evaluating expressions and returning the corresponding tir::Value* |
| ►Cast::ExprEvaluator< ExprStaticCheckerData > | |
| Csemantic::ExprStaticChecker | |
| ►Cast::ExprEvaluator< internal::ExprResolverTy > | |
| Csemantic::ExprResolver | |
| Csemantic::internal::ExprNameWrapper | Represents a wrapper around a name that is being resolved. This is a list of either ExprNameWrapper or ast::ExprNodeList |
| ►Cast::ExprNode | |
| ►Cast::exprnode::ExprOp | |
| Cast::exprnode::ArrayAccess | |
| Cast::exprnode::ArrayInstanceCreation | |
| Cast::exprnode::BinaryOp | |
| Cast::exprnode::Cast | |
| Cast::exprnode::ClassInstanceCreation | |
| Cast::exprnode::MemberAccess | |
| Cast::exprnode::MethodInvocation | |
| Cast::exprnode::UnaryOp | |
| ►Cast::exprnode::ExprValue | |
| Cast::exprnode::LiteralNode | |
| ►Cast::exprnode::MemberName | |
| Cast::exprnode::MethodName | |
| Cast::exprnode::ThisNode | |
| Cast::exprnode::TypeNode | |
| Cast::ExprNodeList | A list of ExprNodes* that can be iterated and concatenated |
| Csemantic::ExprStaticCheckerData | |
| Csemantic::ExprStaticCheckerState | |
| ►Cstd::false_type | |
| Cutils::details::dependent_false< T > | |
| Cutils::details::is_callable< T, R, class > | |
| Cutils::details::function_ref< TSignature > | |
| Cutils::details::function_ref< TReturn(TArgs...)> | |
| Cutils::details::function_ref< void(T)> | |
| Cutils::Generator< T > | |
| Csemantic::HierarchyChecker | |
| Cast::ImportDeclaration | |
| Ctir::IRBuilder | |
| ►Cstd::is_convertible | |
| Cutils::details::is_callable< T, R, void_t< std::result_of_t< T > > > | |
| Cutils::Generator< T >::Iter | |
| CJoos1WParser | |
| Ccodegen::Mangler | |
| ►Cstd::pmr::memory_resource | |
| Cutils::CustomBufferResource | |
| Cast::Modifiers | |
| ►Cparsetree::Node | The basic type-tagged node in the parse tree |
| Cparsetree::BasicType | A lex node in the parse tree representing a basic type |
| Cparsetree::Identifier | A lex node in the parse tree representing an identifier |
| Cparsetree::Literal | A lex node in the parse tree representing a literal value |
| Cparsetree::Modifier | A lex node in the parse tree representing a modifier |
| Cparsetree::Operator | A lex node in the parse tree representing an operator |
| ►Cstd::ostream | |
| Cdiagnostics::DiagnosticStream | |
| Cparsetree::ParseTreeVisitor | |
| ►Cutils::Pass | |
| CDFAPass | |
| CExprResolverPass | |
| CGlobalDCE | |
| CIRContextPass | |
| CMemToReg | |
| CPrintCFG | |
| CSimplifyCFG | |
| Cjoos1::AstBuilderPass | |
| Cjoos1::AstContextPass | |
| Cjoos1::HierarchyCheckerPass | |
| Cjoos1::Joos1WParserPass | |
| Cjoos1::LinkerPass | |
| Cjoos1::NameResolverPass | |
| Cjoos1::PrintASTPass | |
| Cutils::PassManager | |
| Cutils::PassOptions | |
| Csemantic::NameResolver::Pkg | Represents a tree of packages. The leaf nodes are declarations |
| Cutils::Generator< T >::promise_type | |
| Cutils::range_ref< T > | A non-owning, lightweight view of a range whose element types are convertible to T |
| Cast::ReturnType | Represents the return type of a method. This wraps ast::Type to allow for void return types (we don't consider void a type) |
| ►Cstd::runtime_error | |
| Cutils::AssertError | |
| Cutils::FatalError | |
| Cast::ScopeID | Immutable struct that represents a unique identifier for a scope. This captures the position of the lexical scope in the AST to be used after AST construction, when lexical information has been lost |
| Cast::Semantic | |
| Cutils::details::signature_helper< TSignature > | |
| Cutils::details::signature_helper< TReturn(TArgs...)> | |
| CSourceFile | An opaque identifier representing a source file |
| CSourceLocation | A specific location (line, column) in a source file |
| CSourceManager | |
| CSourceRange | A range of locations in a source file |
| Cparsetree::ParseTreeVisitor::TmpVarDecl | |
| ►Cstd::true_type | |
| Cutils::details::is_callable< T, void, void_t< std::result_of_t< T > > > | |
| ►Ctir::Type | Type is the base class for all types in the TIR. It is immutable once created and is uniqued within a Context. The uniquing means that two types in the same context are equal if and only if they have the same address in memory |
| Ctir::ArrayType | |
| Ctir::FunctionType | |
| Ctir::IntegerType | |
| Ctir::OpaquePointerType | The type of a pointer to an opaque type |
| Ctir::StructType | |
| ►Cast::TypeResolver | Abstract base representing a (stateful) class used to resolve types |
| Csemantic::NameResolver | |
| ►Ctir::Value | |
| Ctir::Argument | |
| Ctir::BasicBlock | |
| ►Ctir::User | |
| ►Ctir::Constant | |
| Ctir::ConstantInt | |
| Ctir::ConstantNullPointer | |
| ►Ctir::GlobalObject | |
| Ctir::Function | |
| Ctir::GlobalVariable | |
| ►Ctir::Instruction | Base class for all instructions in the TIR. Instructions are also Values, but they are not constants. Instructions are stored as a linked list, possibly belonging to a BasicBlock, or not. Instructions are also Users, meaning they can have other Values as operands (children) |
| Ctir::AllocaInst | Alloca instruction. This instruction allocates memory on the stack. This is equivalent to the TIR TEMP() node |
| Ctir::BinaryInst | Binary instruction. This instruction performs a binary operation on two values. The type of the result is the same as the type of the two operands (which must be the same type also) |
| Ctir::BranchInst | Conditional branch instruction. This instruction is a terminator and branches to one of two basic blocks based on the condition. The condition value must be an i1 type |
| Ctir::CallInst | Call instruction. This instruction calls a function with the given arguments. It returns the result of the function call |
| Ctir::CmpInst | Compare instruction. This instruction compares two values (of the same type) and returns a boolean value (i1) based on the comparison |
| Ctir::GetElementPtrInst | |
| Ctir::ICastInst | Integer cast instruction. This instruction can either truncate, zero-extend, or sign-extend an integer value to a different integer type |
| Ctir::LoadInst | Load instruction. This instruction loads a value from a pointer. The size of the value loaded is determined by the type of the load instr, not by the type of the pointer. Pointer types are opaque |
| Ctir::ReturnInst | Return instruction. This instruction is a terminator and returns either a value or nothing (void) |
| Ctir::StoreInst | Store instruction. This instruction stores a value to a pointer |
| Ccodegen::details::ValueWrapper | Wraps a value for expression evaluation. This distinguishes an LValue from an RValue, wrapping the tir::Value* mapped from an ExprValue. The criteria for an L/R value is as follows: |
| ►CyyFlexLexer | |
| CJoos1WLexer | |
1.9.1