// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/> // Copyright (C) 2010 Winch Gate Property Limited // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as // published by the Free Software Foundation, either version 3 of the // License, or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Affero General Public License for more details. // // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. #ifndef RY_PD_PARSE_NODE_H #define RY_PD_PARSE_NODE_H #include "tokenizer.h" #include "cpp_output.h" #include "templatizer.h" extern CTokenizer Tokenizer; extern std::string getFunctionPrefix; extern std::string setFunctionPrefix; extern std::string newFunction; extern std::string deleteFunction; extern std::string indexVariable; extern std::string valueVariable; extern std::string keyVariable; extern std::string objectVariable; extern std::string staticCreateFunction; extern std::string staticRemoveFunction; extern std::string staticSetUserFactoryFunction; extern std::string staticLoadFunction; extern std::string staticUnloadFunction; extern std::string staticGetFunction; extern std::string initFunction; extern std::string destroyFunction; extern std::string registerFunction; extern std::string registerAttributesFunction; extern std::string unregisterFunction; extern std::string unregisterAttributesFunction; extern std::string fetchFunction; extern std::string setParentFunction; extern std::string setUnnotifiedParentFunction; extern std::string getTableFunction; extern std::string unlinkFunction; extern std::string staticInitFactoryFunction; extern std::string staticFactoryFunction; extern std::string staticFetchFunction; extern std::string staticInitFunction; extern std::string logStartFunction; extern std::string logStopFunction; class CFileNode; class CDbNode; class CTypeNode; class CClassNode; class CIndexNode; class CEnumNode; class CDimensionNode; class CLogMsgNode; // class CParseNode { public: CParseNode() : Parent(NULL), FileNode(NULL), DbNode(NULL), Env(NULL) {} virtual ~CParseNode() { uint i; for (i=0; i<Nodes.size(); ++i) delete Nodes[i]; } CParseNode* Parent; std::vector<CParseNode*> Nodes; CTokenizer::CToken StartToken; std::string Name; std::string Description; /// virtual bool prolog() { return true; } virtual bool epilog() { return true; } /// bool execute() { if (!prolog()) return false; uint i; for (i=0; i<Nodes.size(); ++i) if (!Nodes[i]->execute()) return false; return epilog(); } /// Issue error void error(const std::string &errMsg, const char *errType = "semantic") { Tokenizer.error(StartToken, errType, errMsg.c_str() ); } /// CParseNode* getNode(const std::string &name) { uint i; for (i=0; i<Nodes.size(); ++i) if (Nodes[i]->Name == name) return Nodes[i]; return NULL; } /// void getFileLine(uint &line, uint &col, std::string &file) { Tokenizer.getFileLine(StartToken, line, col, file); } /// CFileNode* getFileNode(); CDbNode* getDbNode(); CFileNode* FileNode; CDbNode* DbNode; CCppOutput& hOutput(); CCppOutput& cppOutput(); CCppOutput& inlineOutput(); CTypeNode* getTypeNode(const std::string &name, bool genError = true); CEnumNode* getEnumNode(const std::string &name, bool genError = true); CDimensionNode* getDimensionNode(const std::string &name, bool genError = true); CIndexNode* getIndexNode(const std::string &name, bool genError = true); CClassNode* getClassNode(const std::string &name, bool genError = true); CTemplatizerEnv* Env; template<typename T> void setEnv(const std::string& var, const T& val) { nlassert(Env != NULL); Env->set(var, val); } void define(const std::string& var) { nlassert(Env != NULL); Env->set(var, 1); } void define(bool isdef, const std::string& var) { nlassert(Env != NULL); if (isdef) Env->set(var, 1); } }; // // // class CDbNode : public CParseNode { public: CDbNode() : DbXml(false), DbSummary(false) {} // bool addTypeNode(const std::string &name, const std::string &displayName = std::string(""), const std::string &defaultValue = std::string("")); // std::vector<CFileNode*> FileNodes; std::vector<CTypeNode*> TypeNodes; std::vector<CClassNode*> ClassNodes; std::vector<CLogMsgNode*> LogNodes; CCppOutput DbXml; CCppOutput DbHpp; CCppOutput DbHppInline; CCppOutput DbCpp; CCppOutput DbSummary; std::string MainFile; std::string Pch; std::vector<std::string> xmlDescription; CFunctionGenerator initDb; CFunctionGenerator readyDb; CFunctionGenerator updateDb; CFunctionGenerator releaseDb; CFunctionGenerator logChatDb; CFunctionGenerator logTellDb; std::set<std::string> Implemented; /// virtual bool prolog(); virtual bool epilog(); void pass1(); void pass2(); void pass3(); void pass4(); void buildClassOrder(std::vector<CClassNode*>& classesOrder, std::vector<CFileNode*>& filesOrder); void generateClassesDeclaration(); void generateIncludes(std::vector<CFileNode*>& filesOrder); void generateClassesContent(std::vector<CClassNode*>& classesOrder); void generateLogContent(); std::string getDbFile() { return MainFile.empty() ? Name : MainFile; } // get file path from this file std::string getFileNoExtPath(const std::string& file); }; // // // class CIncludeNode; class CFileNode : public CParseNode { public: CFileNode() : SeparatedFlag(false), IncludeStandard(false), IncludePDSLib(false), IncludeDbFile(false), Generate(true) { } std::string IncludeAs; bool SeparatedFlag; CCppOutput Hpp; CCppOutput HppInline; CCppOutput Cpp; bool IncludeStandard; bool IncludePDSLib; bool IncludeDbFile; std::vector<CIncludeNode*> IncludeNodes; bool Generate; std::set<CFileNode*> Dependencies; void checkDependencies(std::set<CFileNode*> &beingChecked, std::set<CFileNode*> &checkedFiles, std::vector<CFileNode*> &filesOrder); /// virtual bool prolog(); virtual bool epilog(); // virtual bool generateProlog(); virtual bool generateEpilog(); // void writeFile(); // get file path from this file std::string getFileNoExtPath(const std::string& file); }; // // // class CIncludeNode : public CParseNode { public: /// virtual bool prolog(); }; // // // class CUsePchNode : public CParseNode { public: /// virtual bool prolog(); }; // // // class CCppCodeNode : public CParseNode { public: std::string RawCode; /// virtual bool prolog(); }; // // // class CTypeNode : public CParseNode { public: CTypeNode() : ToCppType(NULL), ToStorageType(NULL), ExternFlag(false), InternFlag(false), Id(0) { } std::string CppType; std::string StorageType; std::string DisplayName; CParseNode* ToCppType; CParseNode* ToStorageType; bool ExternFlag; bool InternFlag; std::string Temp; uint32 Size; uint Id; std::string DefaultValue; virtual bool isEnum() { return false; } virtual bool isDimension() { return false; } virtual bool isIndex() { return false; } virtual std::string checkCode(const std::string& var) { return ""; } std::string storageToCpp() { if (ToCppType != NULL) return "__pds_cnv_type_"+NLMISC::toString(Id)+"_s2c"; else return "("+CppType+")"; } std::string cppToStorage() { if (ToStorageType != NULL) return "__pds_cnv_type_"+NLMISC::toString(Id)+"_c2s"; else return "("+StorageType+")"; } std::string castToCpp(const std::string& var) { if (CppType != StorageType) { return storageToCpp()+"("+var+")"; } else { return var; } } std::string castToStorage(const std::string& var) { if (CppType != StorageType) { return cppToStorage()+"("+var+")"; } else { return var; } } std::string getCppType() { if (CppType == "CEntityId") return "NLMISC::CEntityId"; else if (CppType == "CSheetId") return "NLMISC::CSheetId"; else return CppType; } std::string castToPDS(const std::string& var) { if (isEnum()) { return "(uint32)"+var; } else if (ExternFlag) { return "("+StorageType+")"+var; } else { //return "("+getName()+")"; return castToStorage(var); } } std::string castFromUser(const std::string& var) { return "("+getName()+")"+var; } virtual std::string getName() { return DisplayName.empty() ? Name : DisplayName; } std::string getDefaultValue() { if (DefaultValue.empty()) { if (CppType == "CEntityId") return "NLMISC::CEntityId::Unknown"; if (CppType == "CSheetId") return "NLMISC::CSheetId::Unknown"; return castFromUser("0"); } else { return DefaultValue; } } virtual std::string getPrintfFmt() { if (CppType == "CEntityId" || CppType == "CSheetId") return "%s"; if (CppType == "double" || CppType == "float") return "%f"; if (CppType == "sint64") return "%\"NL_I64\"d"; if (CppType == "uint64") return "%\"NL_I64\"u"; if (CppType == "sint32" || CppType == "sint16" || CppType == "sint8") return "%d"; if (CppType == "uint32" || CppType == "uint16" || CppType == "uint8") return "%u"; if (CppType == "char" || CppType == "ucchar") return "%c"; if (CppType == "bool") return "%s"; return "%d"; } virtual std::string getPrintfVal(const std::string& var) { if (CppType == "CEntityId" || CppType == "CSheetId") return var+".toString()"; if (CppType == "double" || CppType == "float" || CppType == "sint64" || CppType == "uint64" || CppType == "sint32" || CppType == "sint16" || CppType == "sint8" || CppType == "uint32" || CppType == "uint16" || CppType == "uint8" || CppType == "char" || CppType == "ucchar") return var; if (CppType == "bool") return "("+var+" ? \"true\" : \"false\")"; return "(uint32)"+var; } /// virtual bool prolog(); /// virtual bool generateContent(); virtual void generateApplyCode(CClassGenerator::SMethodId& method, const std::string& token, const std::string& value) { method.add("__pdr.pop("+token+", "+value+");"); } virtual void generateStoreCode(CClassGenerator::SMethodId& method, const std::string& token, const std::string& value) { method.add("__pdr.push("+token+", "+value+");"); } }; // // // class CDeclarationNode; class CCallContext; enum TDeclarationType { SimpleType, SimpleClass, ForwardRef, BackRef, ArrayType, ArrayClass, ArrayRef, Set }; struct CColumn { std::string Name; uint32 ByteSize; TDeclarationType Type; std::string TypeStr; uint TypeId; }; class CClassNode : public CParseNode { public: CClassNode() : IsBackReferenced(false), HasInheritance(false), IsInSet(false), IsInArray(false), IsInArrayRef(false), MappedFlag(false), DerivatedFlag(false), HasParent(false), ParentIsHidden(false), ForceReference(false), PDSMapped(false), MapClass(NULL), Columns(-1), Id(0), HasRowAccess(false), HasTableAccess(false), indexUsedInInit(false), indexUsedInDestroy(false), indexUsedInFetch(false), tableAndRowIndicesUsedInFetch(false), indexUsedInRegister(false), indexUsedInUnregister(false), indexUsedInNotifyInit(false), indexUsedInNotifyRelease(false) { } std::string Inherited; std::string ClassKey; std::string Implements; std::set<CClassNode*> Dependencies; std::vector<std::string> ChildrenClasses; bool IsBackReferenced; bool HasInheritance; bool IsInSet; bool IsInArray; bool IsInArrayRef; bool MappedFlag; bool DerivatedFlag; bool HasParent; bool ParentIsHidden; bool ForceReference; std::string ParentClass; std::string Reserve; bool PDSMapped; CClassNode *MapClass; std::vector<CDeclarationNode*> Init; std::string InitProto; std::string InitCallArgs; sint Columns; uint Id; std::vector<CDeclarationNode*> Attributes; bool HasRowAccess; bool HasTableAccess; std::set<std::string> Friends; std::set<std::string> ForwardFriends; std::set<CClassNode*> Legacy; /// virtual bool prolog(); virtual bool epilog(); CDeclarationNode* getDeclarationNode(const std::string &name); CDeclarationNode* getKey(); CDeclarationNode* getClassKey(); CDeclarationNode* getDeclaration(const std::string& name); bool useEntityId(); void checkClassReferences(); void fillAttributes(); void fillRefs(); void computeFriends(); void checkDependencies(std::set<CClassNode*> &beingChecked, std::set<CClassNode*> &checkedClasses, std::vector<CClassNode*> &classesOrder); void buildInit(); void computeAttributesColumns(); std::string getId() { return (HasInheritance ? NLMISC::toString("__BaseTable") : NLMISC::toString(Id)); } std::string getUserCode(const std::string& name); // CClassGenerator Gen; CClassGenerator::SMethodId InitId; CClassGenerator::SMethodId DestroyId; CClassGenerator::SMethodId FetchId; CClassGenerator::SMethodId RegisterId; CClassGenerator::SMethodId RegisterAttributesId; CClassGenerator::SMethodId UnregisterId; CClassGenerator::SMethodId UnregisterAttributesId; CClassGenerator::SMethodId SetParentId; CClassGenerator::SMethodId SetUnnotifiedParentId; CClassGenerator::SMethodId NotifyInitId; CClassGenerator::SMethodId NotifyReleaseId; CClassGenerator::SMethodId UserInitId; CClassGenerator::SMethodId UserReleaseId; // CClassGenerator::SMethodId ClearId; CClassGenerator::SMethodId StoreId; CClassGenerator::SMethodId ApplyId; bool indexUsedInInit; bool indexUsedInDestroy; bool indexUsedInFetch; bool tableAndRowIndicesUsedInFetch; bool indexUsedInRegister; bool indexUsedInUnregister; bool indexUsedInNotifyInit; bool indexUsedInNotifyRelease; bool generateContent(); void generateContentInCall(CCallContext *context); }; class CDeclarationNode : public CParseNode { public: CDeclarationNode() : InitFillFlag(false), WriteTriggerFlag(false), ParentFlag(false), HiddenFlag(false), MirroredFlag(false), ArrayFlag(false), SetFlag(false), IsRef(false), IsType(false), IsKey(false), Id(0), Column(-1), Columns(-1) { } bool InitFillFlag; bool WriteTriggerFlag; bool ParentFlag; bool HiddenFlag; bool MirroredFlag; std::string ParentClass; std::string ParentField; std::string Type; bool ArrayFlag; std::string ArrayIndex; bool SetFlag; std::string ForwardRefAttribute; bool IsRef; bool IsType; bool IsKey; std::string DefaultValue; struct CUserCode { std::string Event; std::string CodeSpecializer; std::string UserCode; }; std::vector<CUserCode> UserCodes; std::string getUserCode(const std::string &name, const std::string &specialize = std::string("")) { uint i; // first look for a specialized code for (i=0; i<UserCodes.size(); ++i) if (UserCodes[i].Event == name && UserCodes[i].CodeSpecializer == specialize) return UserCodes[i].UserCode; // then look for a default code for (i=0; i<UserCodes.size(); ++i) if (UserCodes[i].Event == name && UserCodes[i].CodeSpecializer == "") return UserCodes[i].UserCode; return ""; } TDeclarationType DeclarationType; std::string XmlNode; std::vector<CColumn> ColumnList; uint Id; sint Column; sint Columns; CClassNode* ClassNode; CClassNode* getParentClass() { return dynamic_cast<CClassNode*>(Parent); } /// virtual bool prolog(); virtual bool epilog(); // std::string getFunc() const { return lcFirst(getFunctionPrefix+Name); } std::string setFunc() const { return lcFirst(setFunctionPrefix+Name); } std::string newFunc() const { return lcFirst(newFunction+Name); } std::string deleteFunc() const { return lcFirst(deleteFunction+Name); } std::string unlinkFunc() const { return lcFirst(unlinkFunction+Name); } std::string cppName() const { return "_"+Name; } std::string tokenName() const { return "__Tok"+Name; } // std::string displayPrintfPrefix(); std::string displayCppCode(std::string replVar = ""); std::string toUint64(std::string replVar = ""); // void generateContent(CCallContext *context = NULL); void generateTypeContent(CCallContext *context = NULL); void generateClassContent(CCallContext *context = NULL); void generateBackRefContent(); void generateForwardRefContent(); void generateArrayTypeContent(CCallContext *context = NULL); void generateArrayClassContent(CCallContext *context = NULL); void generateArrayRefContent(CCallContext *context = NULL); void generateSetContent(CCallContext *context = NULL); void generateArrayApplyCode(); void generateArrayStoreCode(); void generateArrayEndCode(); void generateClassPtrApplyCode(const std::string& value); void generateClassPtrStoreCode(const std::string& value); std::string getAccessorName(CCallContext *context, const std::string& accessortype, const std::string& sep = "::"); }; // // // class CIndexNode : public CTypeNode { public: CIndexNode() { CppType = "uint32"; StorageType = "uint32"; } virtual bool isIndex() { return true; } virtual std::string getSizeName() { return Name+"Size"; } virtual uint getSize() = 0; virtual std::string getIndexName(uint32 value) const { return NLMISC::toString(value); } virtual std::string getToStringCode(const std::string& var) const { return "NLMISC::toString("+var+")"; } virtual std::string getFromStringCode(const std::string& var) const { return "atoi("+var+")"; } virtual std::string checkCode(const std::string& var) { return "nlassert("+var+"<"+getSizeName()+");"; } }; // // // class CEnumNode : public CIndexNode { public: CEnumNode() : CurrentValue(0), MinValue(0), MaxValue(0) { } uint32 CurrentValue; uint32 MinValue; uint32 MaxValue; std::vector<std::pair<std::string, uint32> > Values; std::string EndRange; virtual bool isEnum() { return true; } virtual std::string getName() { std::string trunc = Name.substr(1); return "C"+trunc+"::"+(DisplayName.empty() ? Name : DisplayName); } virtual uint getSize() { return MaxValue-MinValue; } bool prolog(); bool epilog(); /// virtual bool generateContent(); std::string getIndexName(uint32 value) const { std::string result = ""; uint i; for (i=0; i<Values.size(); ++i) if (Values[i].second == value) result = Values[i].first; return result; } std::string getUnscopedUseSize() const { return "___"+Name+"_useSize"; } std::string getUnknownValue() const { return "Unknown"; } std::string getUseSize() const { std::string trunc = Name.substr(1); return "C"+trunc+"::"+getUnscopedUseSize(); } std::string getSizeName() { std::string trunc = Name.substr(1); return "C"+trunc+"::"+getUnscopedUseSize(); } virtual std::string getToStringCode(const std::string& var) const { std::string trunc = Name.substr(1); return "C"+trunc+"::toString("+var+")"; } virtual std::string getFromStringCode(const std::string& var) const { std::string trunc = Name.substr(1); return "C"+trunc+"::fromString("+var+")"; } virtual void generateApplyCode(CClassGenerator::SMethodId& method, const std::string& token, const std::string& value) { method.add("{"); method.add("std::string\tvaluename;"); method.add("__pdr.pop("+token+", valuename);"); method.add(value+" = "+getFromStringCode("valuename")+";"); method.add("}"); } virtual void generateStoreCode(CClassGenerator::SMethodId& method, const std::string& token, const std::string& value) { method.add("{"); method.add("std::string\tvaluename = "+getToStringCode(value)+";"); method.add("__pdr.push("+token+", valuename);"); method.add("}"); } }; class CEnumSimpleValueNode : public CEnumNode { public: std::vector<std::string> Names; bool prolog(); bool epilog(); }; class CEnumRangeNode : public CEnumNode { public: bool prolog(); bool epilog(); }; // // // class CDimensionNode : public CIndexNode { public: public: CDimensionNode() { } virtual bool isDimension() { return true; } std::string getSizeName() { return Name+"Size"; } bool prolog(); bool epilog(); sint Dimension; virtual uint getSize() { return Dimension; } /// virtual bool generateContent(); }; // // // class CLogMsgNode : public CParseNode { public: CLogMsgNode() : Context(false) { } bool prolog(); bool epilog() { return true; } std::vector<std::pair<std::string, std::string> > Params; std::vector<std::string> Logs; bool Context; uint Id; void generateContent(); }; class CExtLogTypeNode : public CParseNode { public: std::string ExtLogType; }; // // // class CCallContext { public: std::vector<CDeclarationNode*> Context; std::string RootTable; std::string RootRow; uint Column; CCallContext(CDeclarationNode* decl = NULL) { if (decl != NULL) Context.push_back(decl); } bool hasRootEntityIdKey() { CDeclarationNode* k = getRootCaller()->getClassKey(); if (k != NULL) { return (getRootCaller()->getTypeNode(getRootCaller()->getKey()->Type)->CppType == "CEntityId"); } return false; } /** * Generates the name of the pointed variable * For instance: PhysicalScoresBase, where PhysicalScores is an array and Base is an attribute in this array * Actually concats all fields names */ std::string getCallString() { uint i; std::string res = ""; for (i=0; i<Context.size(); ++i) res += Context[i]->Name; return res; } CClassNode* getRootCaller() { return (CClassNode*)Context[0]->Parent; } CDeclarationNode* getRootDeclaration() { return Context[0]; } /** * Generates the access prototype argument list * Actually only generates indexes for arrays */ std::string getDebugCallStringFmt() { uint i, idx=0; std::string res = ""; for (i=0; i<Context.size(); ++i) { CDeclarationNode* decl = Context[i]; if (decl->DeclarationType == ArrayClass || decl->DeclarationType == ArrayType) { if (!res.empty()) res += ", "; CTypeNode* tnd = decl->getTypeNode(decl->ArrayIndex); res += indexVariable+NLMISC::toString(idx++)+"="+tnd->getPrintfFmt(); } } return res; } /** * Generates the access prototype argument list * Actually only generates indexes for arrays */ std::string getDebugCallStringVal() { uint i, idx=0; std::string res = ""; for (i=0; i<Context.size(); ++i) { CDeclarationNode* decl = Context[i]; if (decl->DeclarationType == ArrayClass || decl->DeclarationType == ArrayType) { if (!res.empty()) res += ", "; CTypeNode* tnd = decl->getTypeNode(decl->ArrayIndex); res += tnd->getPrintfVal(indexVariable+NLMISC::toString(idx++)); } } return res; } /** * Generates the access prototype argument list * Actually only generates indexes for arrays */ std::string getCallArgList() { std::string res = ""; uint i, idx=0; for (i=0; i<Context.size(); ++i) { CDeclarationNode* decl = Context[i]; if (decl->DeclarationType == ArrayClass || decl->DeclarationType == ArrayType) { if (!res.empty()) res += ", "; CTypeNode* tnd = decl->getTypeNode(decl->ArrayIndex); res += tnd->getName()+ " "+indexVariable+NLMISC::toString(idx++); } } return res; } /** * Generates the c++ path to the variable * For instance: _PhysicalScores[__i0].Base, where PhysicalScores is an array and Base is an attribute in this array */ std::string getCallPath() { std::string res = ""; uint i, idx=0; for (i=0; i<Context.size(); ++i) { CDeclarationNode* decl = Context[i]; if (!res.empty()) res += "."; res += decl->cppName(); if (decl->DeclarationType == ArrayClass || decl->DeclarationType == ArrayType) { res += "["+indexVariable+NLMISC::toString(idx++)+"]"; } } return res; } /** * Generates the c++ path to the variable * For instance: _PhysicalScores[__i0].Base, where PhysicalScores is an array and Base is an attribute in this array */ std::string getUserCodeContext() { std::string res = ""; uint i; if (Context.empty()) return res; res = Context[0]->getParentClass()->Name; for (i=0; i<Context.size(); ++i) res += "."+Context[i]->Name; return res; } /** * Generates check code for all types accessors */ std::vector<std::string> getCheckCode() { std::vector<std::string> res; uint i, idx=0; for (i=0; i<Context.size(); ++i) { CDeclarationNode* decl = Context[i]; if (decl->DeclarationType == ArrayType || decl->DeclarationType == ArrayRef || decl->DeclarationType == ArrayClass) { CIndexNode* ind = decl->getIndexNode(decl->ArrayIndex); std::string code = ind->checkCode(indexVariable+NLMISC::toString(idx++)); if (!code.empty()) res.push_back(code); } } return res; } /** * Get current context index */ uint getContextIndex() { uint i, idx=0; for (i=0; i<Context.size(); ++i) { CDeclarationNode* decl = Context[i]; if (decl->DeclarationType == ArrayClass || decl->DeclarationType == ArrayType) idx++; } return idx-1; } CCallContext getSubContext(CDeclarationNode* decl) { CCallContext ctx = *this; ctx.Context.push_back(decl); return ctx; } std::string getColumn() { std::string res = ""; uint i, idx=0; for (i=0; i<Context.size(); ++i) { CDeclarationNode* decl = Context[i]; if (decl->Column != 0) { if (!res.empty()) res += "+"; res += NLMISC::toString(decl->Column); } if (decl->DeclarationType == ArrayType || decl->DeclarationType == ArrayRef) { if (!res.empty()) res += "+"; res += indexVariable+NLMISC::toString(idx++); } else if (decl->DeclarationType == ArrayClass) { if (!res.empty()) res += "+"; CClassNode* sub = decl->getClassNode(decl->Type); res += indexVariable+NLMISC::toString(idx++)+"*"+NLMISC::toString(sub->Columns); } } if (res.empty()) res = "0"; return res; } }; // // INLINES // inline CFileNode* CParseNode::getFileNode() { if (FileNode != NULL) return FileNode; CParseNode* node = this; CFileNode* fnode = NULL; while (node != NULL && (fnode = dynamic_cast<CFileNode*>(node)) == NULL) node = node->Parent; if (fnode == NULL) error("Can't find file node", "internal"); FileNode = fnode; return fnode; } inline CDbNode* CParseNode::getDbNode() { if (DbNode != NULL) return DbNode; CParseNode* node = this; CDbNode* fnode = NULL; while (node != NULL && (fnode = dynamic_cast<CDbNode*>(node)) == NULL) node = node->Parent; if (fnode == NULL) error("Can't find db node", "internal"); DbNode = fnode; return fnode; } inline CCppOutput& CParseNode::hOutput() { CFileNode *fnode = getFileNode(); return fnode->Hpp; } inline CCppOutput& CParseNode::cppOutput() { CFileNode *fnode = getFileNode(); return fnode->Cpp; } inline CCppOutput& CParseNode::inlineOutput() { CFileNode *fnode = getFileNode(); return fnode->HppInline; } inline CTypeNode *CParseNode::getTypeNode(const std::string &name, bool genError) { CDbNode* db = getDbNode(); uint i; for (i=0; i<db->TypeNodes.size(); ++i) if (db->TypeNodes[i]->Name == name) return db->TypeNodes[i]; if (genError) error("Can't find type '"+name+"'"); return NULL; } inline CEnumNode *CParseNode::getEnumNode(const std::string &name, bool genError) { CEnumNode* node = dynamic_cast<CEnumNode*>(getTypeNode(name, genError)); if (node == NULL && genError) error("Can't find enum '"+name+"'"); return node; } inline CDimensionNode *CParseNode::getDimensionNode(const std::string &name, bool genError) { CDimensionNode* node = dynamic_cast<CDimensionNode*>(getTypeNode(name, genError)); if (node == NULL && genError) error("Can't find dimension '"+name+"'"); return node; } inline CIndexNode *CParseNode::getIndexNode(const std::string &name, bool genError) { CIndexNode* node = dynamic_cast<CIndexNode*>(getTypeNode(name, genError)); if (node == NULL && genError) error("Can't find index type '"+name+"' (neither enum nor dimension)"); return node; } inline CClassNode *CParseNode::getClassNode(const std::string &name, bool genError) { CDbNode* db = getDbNode(); uint i; for (i=0; i<db->ClassNodes.size(); ++i) if (db->ClassNodes[i]->Name == name) return db->ClassNodes[i]; if (genError) error("Can't find class '"+name+"'"); return NULL; } inline bool CDbNode::addTypeNode(const std::string &name, const std::string &displayName, const std::string &defaultValue) { CTypeNode *node = new CTypeNode(); node->Name = name; node->DisplayName = displayName; node->CppType = name; node->StorageType = name; node->ToCppType = NULL; node->ToStorageType = NULL; node->DefaultValue = defaultValue; node->ExternFlag = false; node->InternFlag = true; node->Parent = this; Nodes.insert(Nodes.begin(), node); return true; } inline CDeclarationNode* CClassNode::getDeclarationNode(const std::string &name) { CDeclarationNode *node; if ((node = dynamic_cast<CDeclarationNode*>(getNode(name))) == NULL) error("declaration '"+name+"' not found"); return node; } inline bool CClassNode::useEntityId() { //return !ClassKey.empty() && getTypeNode(getKey()->Type)->CppType == "CEntityId"; CDeclarationNode* k = getClassKey(); return k!=NULL && getTypeNode(k->Type)->CppType == "CEntityId"; } inline CDeclarationNode* CClassNode::getClassKey() { if (ClassKey.empty()) { if (Inherited.empty()) return NULL; CClassNode* p = getClassNode(Inherited); return p->getClassKey(); } else { return getKey(); } } inline CDeclarationNode* CClassNode::getKey() { CDeclarationNode* key = NULL; CClassNode* classNode = this; while (classNode != NULL) { key = dynamic_cast<CDeclarationNode*>(classNode->getNode(classNode->ClassKey)); if (key != NULL) return key; classNode = getClassNode(Inherited, false); } error("key declaration '"+ClassKey+"' not found"); return NULL; //return getDeclarationNode(ClassKey); } inline CDeclarationNode* CClassNode::getDeclaration(const std::string& name) { CDeclarationNode* decl = NULL; CClassNode* classNode = this; while (classNode != NULL) { decl = dynamic_cast<CDeclarationNode*>(classNode->getNode(name)); if (decl != NULL) return decl; classNode = getClassNode(classNode->Inherited, false); } error("declaration '"+name+"' not found"); return NULL; } #endif