Public Types
       | 
    
    
      | typedef std::deque< TElement * >  | 
      TElementList | 
    
    
      
         
        Public Methods
       | 
    
    
      |   | 
      
TModuleSym (const std::string &) | 
    
    
      |   | 
      
~TModuleSym () | 
    
    
      | void  | 
      
uses (const TModuleList &) | 
    
    
      | 
TModuleList &  | 
      
uses () | 
    
    
      | const TModuleList &  | 
      
uses () const | 
    
    
      | void  | 
      
use (TModuleSym *) | 
    
    
      | 
def::TArrayDef *  | 
      
createArrayDef (def::TDef *ABase) | 
    
    
      | 
def::TBitsetDef *  | 
      
createBitsetDef (scopes::TScope *AParentScope) | 
    
    
      | 
def::TCastDef *  | 
      
createCastDef (def::TDef *ASource, def::TDef *ATarget) | 
    
    
      | 
def::TClassDef *  | 
      
createClassDef (scopes::TScope *AParentScope) | 
    
    
      | 
def::TConstDef *  | 
      
createConstDef (def::TDef *ARef) | 
    
    
      | 
def::TEnumDef *  | 
      
createEnumDef () | 
    
    
      | 
def::TEnumRangeDef *  | 
      
createEnumRangeDef (def::TEnumDef *ABase, crosspl::uint64 AMin, crosspl::uint64 AMax) | 
    
    
      | 
def::TFloatDef *  | 
      
createFloatDef (def::TFloatDef::TFloatType AType) | 
    
    
      | 
def::TMethodDef *  | 
      
createMethodDef () | 
    
    
      | 
def::TExternalInfo *  | 
      
createExternalInfo () | 
    
    
      | 
def::TMethodPtrDef *  | 
      
createMethodPtrDef (def::TMethodDef *APtrOfMethod) | 
    
    
      | def::TOperatorDef *  | 
      
createOperatorDef (TOperatorStyle AStyle) | 
    
    
      | 
def::TDataMemberPointerDef *  | 
      
createDataMemberPtrDef (def::TClassDef *ABaseClass, def::TDef *ADataPointer) | 
    
    
      | 
def::TMethodMemberPointerDef *  | 
      
createMethodMemberPtrDef (def::TClassDef *ABaseClass, def::TMethodDef *AMethodPointer) | 
    
    
      | 
def::TPointerDef *  | 
      
createPointerDef (def::TDef *AComposite) | 
    
    
      | 
def::TPropertyDef *  | 
      
createPropertyDef () | 
    
    
      | 
def::TRangeDef *  | 
      
createRangeDef (crosspl::int64 AMin, crosspl::int64 AMax, def::TRangeDef::TBaseType ABaseType=def::TRangeDef::btAuto) | 
    
    
      | 
def::TRangeDef *  | 
      
createRangeDef (def::TRangeDef::TBaseType ABaseType) | 
    
    
      | 
def::TRecordDef *  | 
      
createRecordDef (scopes::TScope *AParentScope) | 
    
    
      | 
def::TReferenceDef *  | 
      
createReferenceDef (def::TDef *AComposite) | 
    
    
      | 
def::TSequenceDef *  | 
      
createSequenceDef () | 
    
    
      | 
def::TSetDef *  | 
      
createSetDef (def::TDef *ADef) | 
    
    
      | 
def::TTemplateDef *  | 
      
createTemplateDef (def::TDef *ADefault) | 
    
    
      | 
def::TTypeRefDef *  | 
      
createTypeRefDef (def::TDef *ABase) | 
    
    
      | 
def::TParam *  | 
      
createParam (const std::string &AName, def::TParam::TStyle AStyle, def::TDef *AType, expr::TExpression *AInit=0) | 
    
    
      | 
TBitsetDataSym *  | 
      
createBitsetDataSym (const std::string &AName, unsigned ALow, unsigned AHigh, def::TBitsetDef *ADef) | 
    
    
      | 
TCastSym *  | 
      
createCastSym (def::TCastDef *ACastDef, scopes::TScope *AParentScope) | 
    
    
      | 
TDataSym *  | 
      
createDataSym (const std::string &AName, def::TDef *ADef) | 
    
    
      | 
TMethodSym *  | 
      
createMethodSym (const std::string &AName, def::TMethodDef *AMethodDef, scopes::TScope *AParentScope) | 
    
    
      | 
TOperatorSym *  | 
      
createOperatorSym (def::TOperatorDef *ADef, scopes::TScope *AParentScope) | 
    
    
      | 
TPropertySym *  | 
      
createPropertySym (const std::string &AName, def::TPropertyDef *ADef) | 
    
    
      | 
TTypeSym *  | 
      
createTypeSym (const std::string &AName, def::TDef *ATypeOf) | 
    
    
      | 
names::TName *  | 
      
createName (symbols::TSymbol *ASymbol) | 
    
    
      | 
names::TMethodName *  | 
      
createMethodName (const std::string &AName) | 
    
    
      | names::TTypeName *  | 
      
createTypeName (symbols::TTypeSym *ASymbol) | 
    
    
      | 
names::TClassName *  | 
      
createClassName (symbols::TTypeSym *ASymbol) | 
    
    
      | 
names::TDataName *  | 
      
createDataName (symbols::TDataSym *ASymbol) | 
    
    
      | 
names::TModuleName *  | 
      
createModuleName (symbols::TModuleSym *AModule) | 
    
    
      | 
names::TDependentName *  | 
      
createDependentName (const std::string &AText, names::TDependentName *ANested) | 
    
    
      | 
scopes::TScope *  | 
      
createScope (scopes::TScope::TScopeType, scopes::TScope *AParent) | 
    
    
      | 
expr::TArrayExpr *  | 
      
createArrayExpr () | 
    
    
      | 
expr::TCondExpr *  | 
      
createCondExpr (expr::TExpression *ACondition, expr::TExpression *ATrueExpr, expr::TExpression *AFalseExpr) | 
    
    
      | 
expr::TMethodCallExpr *  | 
      
createMethodCallExpr (symbols::TMethodSym *AMethod, const TExprList &AArguments, expr::TExpression *ASelf=0) | 
    
    
      | 
expr::TNameExpr *  | 
      
createNameExpr (names::TName *AName) | 
    
    
      | 
expr::TNewExpr *  | 
      
createNewExpr (def::TDef *ANewType, stmt::TCallStmt *AConstructor) | 
    
    
      | 
expr::TOperatorExpr *  | 
      
createOperatorExpr (TOperatorStyle AStyle, const std::deque< expr::TExpression * > &AArguments) | 
    
    
      | 
expr::TOperatorExpr *  | 
      
createOperatorExpr (TOperatorStyle AStyle, expr::TExpression *ALeft, expr::TExpression *ARight=0) | 
    
    
      | 
expr::TPMDerefExpr *  | 
      
createPMDerefExpr (expr::TExpression *ALeft, expr::TExpression *ARight) | 
    
    
      | 
expr::TQualExpr *  | 
      
createQualExpr (expr::TExpression *ABase, expr::TExpression *AQualifier) | 
    
    
      | 
expr::TIsExpr *  | 
      
createIsExpr (expr::TExpression *AObject, def::TDef *ARTTIType) | 
    
    
      | 
expr::TAsExpr *  | 
      
createAsExpr (expr::TExpression *AObject, def::TDef *ARTTIType) | 
    
    
      | expr::TSymbolExpr *  | 
      
createSymbolExpr (TSymbol *ASymbol, def::TClassDef *AQualifier) | 
    
    
      | expr::TSymbolExpr *  | 
      
createSymbolExpr (const TSymbolList &ASymbols, def::TClassDef *AQualifier) | 
    
    
      | expr::TMethodSymExpr *  | 
      
createMethodSymExpr (TMethodSym *ASymbol, def::TClassDef *AQualifier) | 
    
    
      | expr::TMethodSymExpr *  | 
      
createMethodSymExpr (const std::deque< symbols::TMethodSym * > &ASymbols, def::TClassDef *AQualifier) | 
    
    
      | expr::TDataSymExpr *  | 
      
createDataSymExpr (TDataSym *ASymbol, def::TClassDef *AQualifier) | 
    
    
      | expr::TDataSymExpr *  | 
      
createDataSymExpr (const TDataSymList &ASymbols, def::TClassDef *AQualifier) | 
    
    
      | expr::TTypeSymExpr *  | 
      
createTypeSymExpr (TTypeSym *ASymbol, def::TClassDef *AQualifier) | 
    
    
      | expr::TTypeSymExpr *  | 
      
createTypeSymExpr (const TTypeSymList &ASymbols, def::TClassDef *AQualifier) | 
    
    
      | expr::TModuleSymExpr *  | 
      
createModuleSymExpr (TModuleSym *ASymbol, def::TClassDef *AQualifier) | 
    
    
      | expr::TModuleSymExpr *  | 
      
createModuleSymExpr (const TModuleSymList &ASymbols, def::TClassDef *AQualifier) | 
    
    
      | 
expr::TInt32Expr *  | 
      
createInt32Expr (crosspl::int32 AValue, def::TRangeDef *ADef) | 
    
    
      | 
expr::TUInt32Expr *  | 
      
createUInt32Expr (crosspl::uint32 AValue, def::TRangeDef *ADef) | 
    
    
      | 
expr::TInt64Expr *  | 
      
createInt64Expr (crosspl::int64 AValue, def::TRangeDef *ADef) | 
    
    
      | 
expr::TUInt64Expr *  | 
      
createUInt64Expr (crosspl::uint64 AValue, def::TRangeDef *ADef) | 
    
    
      | 
expr::TFloat64Expr *  | 
      
createFloat64Expr (crosspl::float64 AValue, def::TFloatDef *ADef) | 
    
    
      | 
expr::TFloat80Expr *  | 
      
createFloat80Expr (crosspl::float80 AValue, def::TFloatDef *ADef) | 
    
    
      | 
expr::TStringExpr *  | 
      
createStringExpr (const std::string &AValue, def::TArrayDef *ADef) | 
    
    
      | 
expr::TCharExpr *  | 
      
createCharExpr (crosspl::char8 AValue, def::TRangeDef *ADef) | 
    
    
      | 
expr::TWideCharExpr *  | 
      
createCharExpr (crosspl::char16 AValue, def::TRangeDef *ADef) | 
    
    
      | 
expr::TBoolExpr *  | 
      
createBoolExpr (bool AValue, def::TRangeDef *ADef) | 
    
    
      | 
expr::TPointerExpr *  | 
      
createPointerExpr (void *AValue, def::TPointerDef *ADef) | 
    
    
      | 
expr::TEnumExpr *  | 
      
createEnumExpr (unsigned int AValue, def::TEnumDef *ADef) | 
    
    
      | 
expr::TTypeidExpr *  | 
      
createTypeidExpr (def::TDef *AValue, def::TTypeRefDef *ADef) | 
    
    
      | 
stmt::TAsmStmt *  | 
      
createAsmStmt () | 
    
    
      | 
stmt::TAssignStmt *  | 
      
createAssignStmt (expr::TExpression *ALeft, expr::TExpression *ARight) | 
    
    
      | stmt::TCallStmt *  | 
      
createCallStmt (expr::TExpression *ARef, const TExprList &AArguments) | 
    
    
      | 
stmt::TCaseStmt *  | 
      
createCaseStmt (expr::TExpression *ACaseExpr) | 
    
    
      | 
stmt::TCompoundStmt *  | 
      
createCompoundStmt (const TStmtList &AStmtList) | 
    
    
      | 
stmt::TExprStmt *  | 
      
createExprStmt (expr::TExpression *AExpr) | 
    
    
      | 
stmt::TForStmt *  | 
      
createForStmt (expr::TExpression *ACounter, expr::TExpression *AInit, expr::TExpression *ADone, expr::TExpression *AStep, stmt::TStatement *AStatement) | 
    
    
      | 
stmt::TIfStmt *  | 
      
createIfStmt (expr::TExpression *ACondition, stmt::TStatement *AThenStmt, stmt::TStatement *AElseStmt) | 
    
    
      | 
stmt::TRepeatStmt *  | 
      
createRepeatStmt (expr::TExpression *ACondition, stmt::TStatement *AStatement) | 
    
    
      | 
stmt::TWhileStmt *  | 
      
createWhileStmt (expr::TExpression *ACondition, stmt::TStatement *AStatement) | 
    
    
      | 
stmt::TRaiseStmt *  | 
      
createRaiseStmt (expr::TExpression *AExpr) | 
    
    
      | 
stmt::TReturnStmt *  | 
      
createReturnStmt (expr::TExpression *AReturnExpr) | 
    
    
      | 
stmt::TTryStmt *  | 
      
createExceptStmt (const TStmtList &AStmtList, stmt::TTryStmt::TStyle AStyle, const TStmtList &) | 
    
    
      | 
stmt::TWithStmt *  | 
      
createWithStmt (const TExprList &AWithExpr, stmt::TStatement *AStmt) | 
    
    
      
         
        Public Attributes
       | 
    
    
      | 
TElementList  | 
      FElements | 
    
    
      
         
        Protected Types
       | 
    
    
      | typedef std::deque< def::TDef * >  | 
      TDefList | 
    
    
      | typedef std::deque< TSymbol * >  | 
      TSymbolList | 
    
    
      | typedef std::deque< TDataSym * >  | 
      TDataSymList | 
    
    
      | typedef std::deque< TTypeSym * >  | 
      TTypeSymList | 
    
    
      | typedef std::deque< TModuleSym * >  | 
      TModuleSymList | 
    
    
      | typedef std::deque< stmt::TStatement * >  | 
      TStmtList | 
    
    
      | typedef std::deque< expr::TExpression * >  | 
      TExprList | 
    
    
      | typedef std::deque< TModuleSym * >  | 
      TModuleList | 
    
    
      
         
        Protected Attributes
       | 
    
    
      | 
TModuleList  | 
      FUses | 
    
    
      
         
        Friends
       | 
    
    
      | class  | 
      TElement |