aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-12-30 20:30:53 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/ryzom/tools/pd_parser/parse_node.h

1486 lines
32 KiB
C
Raw Normal View History

initial version
2010-05-06 00:08:41 +00:00
// 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() : IncludePDSLib(false), IncludeStandard(false), IncludeDbFile(false), Generate(true), SeparatedFlag(false) { }
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),
PDSMapped(false),
DerivatedFlag(false),
HasParent(false),
ParentIsHidden(false),
ForceReference(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),
Column(-1),
Columns(-1),
Id(0)
{
}
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
Reference in a new issue Copy permalink