ryzom/tools/pd_parser/parse_node.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #ifndef RY_PD_PARSE_NODE_H
  18 #define RY_PD_PARSE_NODE_H
  19
  20 #include "tokenizer.h"
  21 #include "cpp_output.h"
  22 #include "templatizer.h"
  23
  24 extern CTokenizer                                               Tokenizer;
  25
  26 extern std::string                                              getFunctionPrefix;
  27 extern std::string                                              setFunctionPrefix;
  28 extern std::string                                              newFunction;
  29 extern std::string                                              deleteFunction;
  30
  31 extern std::string                                              indexVariable;
  32 extern std::string                                              valueVariable;
  33 extern std::string                                              keyVariable;
  34 extern std::string                                              objectVariable;
  35
  36 extern std::string                                              staticCreateFunction;
  37 extern std::string                                              staticRemoveFunction;
  38 extern std::string                                              staticSetUserFactoryFunction;
  39 extern std::string                                              staticLoadFunction;
  40 extern std::string                                              staticUnloadFunction;
  41 extern std::string                                              staticGetFunction;
  42
  43 extern std::string                                              initFunction;
  44 extern std::string                                              destroyFunction;
  45 extern std::string                                              registerFunction;
  46 extern std::string                                              registerAttributesFunction;
  47 extern std::string                                              unregisterFunction;
  48 extern std::string                                              unregisterAttributesFunction;
  49 extern std::string                                              fetchFunction;
  50 extern std::string                                              setParentFunction;
  51 extern std::string                                              setUnnotifiedParentFunction;
  52 extern std::string                                              getTableFunction;
  53 extern std::string                                              unlinkFunction;
  54
  55 extern std::string                                              staticInitFactoryFunction;
  56 extern std::string                                              staticFactoryFunction;
  57 extern std::string                                              staticFetchFunction;
  58 extern std::string                                              staticInitFunction;
  59
  60 extern std::string                                              logStartFunction;
  61 extern std::string                                              logStopFunction;
  62
  63
  64 class CFileNode;
  65 class CDbNode;
  66 class CTypeNode;
  67 class CClassNode;
  68 class CIndexNode;
  69 class CEnumNode;
  70 class CDimensionNode;
  71 class CLogMsgNode;
  72
  73 //
  74 class CParseNode
  75 {
  76 public:
  77
  78         CParseNode() : Parent(NULL), FileNode(NULL), DbNode(NULL), Env(NULL)    {}
  79
  80         virtual ~CParseNode()
  81         {
  82                 uint i;
  83                 for (i=0; i<Nodes.size(); ++i)
  84                         delete Nodes[i];
  85         }
  86
  87         CParseNode*                                     Parent;
  88         std::vector<CParseNode*>        Nodes;
  89         CTokenizer::CToken                      StartToken;
  90         std::string                                     Name;
  91         std::string                                     Description;
  92
  93
  94
  95         ///
  96         virtual bool    prolog()        { return true; }
  97         virtual bool    epilog()        { return true; }
  98
  99         ///
 100         bool                    execute()
 101         {
 102                 if (!prolog())
 103                         return false;
 104
 105                 uint    i;
 106                 for (i=0; i<Nodes.size(); ++i)
 107                         if (!Nodes[i]->execute())
 108                                 return false;
 109
 110                 return epilog();
 111         }
 112
 113
 114
 115         /// Issue error
 116         void                    error(const std::string &errMsg, const char *errType = "semantic")
 117         {
 118                 Tokenizer.error(StartToken, errType, errMsg.c_str() );
 119         }
 120
 121         ///
 122         CParseNode*             getNode(const std::string &name)
 123         {
 124                 uint    i;
 125                 for (i=0; i<Nodes.size(); ++i)
 126                         if (Nodes[i]->Name == name)
 127                                 return Nodes[i];
 128                 return NULL;
 129         }
 130
 131         ///
 132         void                    getFileLine(uint &line, uint &col, std::string &file)
 133         {
 134                 Tokenizer.getFileLine(StartToken, line, col, file);
 135         }
 136
 137         ///
 138         CFileNode*              getFileNode();
 139         CDbNode*                getDbNode();
 140
 141         CFileNode*              FileNode;
 142         CDbNode*                DbNode;
 143
 144         CCppOutput&             hOutput();
 145         CCppOutput&             cppOutput();
 146         CCppOutput&             inlineOutput();
 147
 148         CTypeNode*              getTypeNode(const std::string &name, bool genError = true);
 149         CEnumNode*              getEnumNode(const std::string &name, bool genError = true);
 150         CDimensionNode* getDimensionNode(const std::string &name, bool genError = true);
 151         CIndexNode*             getIndexNode(const std::string &name, bool genError = true);
 152         CClassNode*             getClassNode(const std::string &name, bool genError = true);
 153
 154         CTemplatizerEnv*        Env;
 155         template<typename T>
 156         void                    setEnv(const std::string& var, const T& val)
 157         {
 158                 nlassert(Env != NULL);
 159                 Env->set(var, val);
 160         }
 161         void                    define(const std::string& var)
 162         {
 163                 nlassert(Env != NULL);
 164                 Env->set(var, 1);
 165         }
 166         void                    define(bool isdef, const std::string& var)
 167         {
 168                 nlassert(Env != NULL);
 169                 if (isdef)
 170                         Env->set(var, 1);
 171         }
 172 };
 173
 174
 175 //
 176 //
 177 //
 178 class CDbNode : public CParseNode
 179 {
 180 public:
 181         CDbNode() : DbXml(false), DbSummary(false)      {}
 182
 183         //
 184         bool                    addTypeNode(const std::string &name, const std::string &displayName = std::string(""), const std::string &defaultValue = std::string(""));
 185
 186         //
 187         std::vector<CFileNode*>         FileNodes;
 188         std::vector<CTypeNode*>         TypeNodes;
 189         std::vector<CClassNode*>        ClassNodes;
 190         std::vector<CLogMsgNode*>       LogNodes;
 191         CCppOutput                                      DbXml;
 192         CCppOutput                                      DbHpp;
 193         CCppOutput                                      DbHppInline;
 194         CCppOutput                                      DbCpp;
 195
 196         CCppOutput                                      DbSummary;
 197
 198         std::string                                     MainFile;
 199
 200         std::string                                     Pch;
 201
 202         std::vector<std::string>        xmlDescription;
 203         CFunctionGenerator                      initDb;
 204         CFunctionGenerator                      readyDb;
 205         CFunctionGenerator                      updateDb;
 206         CFunctionGenerator                      releaseDb;
 207         CFunctionGenerator                      logChatDb;
 208         CFunctionGenerator                      logTellDb;
 209
 210         std::set<std::string>           Implemented;
 211
 212         ///
 213         virtual bool    prolog();
 214         virtual bool    epilog();
 215
 216         void                    pass1();
 217         void                    pass2();
 218         void                    pass3();
 219         void                    pass4();
 220
 221         void                    buildClassOrder(std::vector<CClassNode*>& classesOrder, std::vector<CFileNode*>& filesOrder);
 222
 223         void                    generateClassesDeclaration();
 224         void                    generateIncludes(std::vector<CFileNode*>& filesOrder);
 225
 226         void                    generateClassesContent(std::vector<CClassNode*>& classesOrder);
 227
 228         void                    generateLogContent();
 229
 230         std::string             getDbFile()                             { return MainFile.empty() ? Name : MainFile; }
 231
 232         // get file path from this file
 233         std::string             getFileNoExtPath(const std::string& file);
 234 };
 235
 236 //
 237 //
 238 //
 239 class CIncludeNode;
 240 class CFileNode : public CParseNode
 241 {
 242 public:
 243
 244         CFileNode() : SeparatedFlag(false), IncludeStandard(false), IncludePDSLib(false), IncludeDbFile(false), Generate(true)  { }
 245
 246         std::string             IncludeAs;
 247
 248         bool                    SeparatedFlag;
 249
 250         CCppOutput              Hpp;
 251         CCppOutput              HppInline;
 252         CCppOutput              Cpp;
 253
 254         bool                                            IncludeStandard;
 255         bool                                            IncludePDSLib;
 256         bool                                            IncludeDbFile;
 257         std::vector<CIncludeNode*>      IncludeNodes;
 258
 259         bool                                            Generate;
 260
 261         std::set<CFileNode*>            Dependencies;
 262
 263         void    checkDependencies(std::set<CFileNode*> &beingChecked,
 264                                                           std::set<CFileNode*> &checkedFiles,
 265                                                           std::vector<CFileNode*> &filesOrder);
 266
 267         ///
 268         virtual bool    prolog();
 269         virtual bool    epilog();
 270
 271         //
 272         virtual bool    generateProlog();
 273         virtual bool    generateEpilog();
 274
 275         //
 276         void                    writeFile();
 277
 278         // get file path from this file
 279         std::string             getFileNoExtPath(const std::string& file);
 280 };
 281
 282 //
 283 //
 284 //
 285 class CIncludeNode : public CParseNode
 286 {
 287 public:
 288
 289         ///
 290         virtual bool    prolog();
 291 };
 292
 293 //
 294 //
 295 //
 296 class CUsePchNode : public CParseNode
 297 {
 298 public:
 299
 300         ///
 301         virtual bool    prolog();
 302 };
 303
 304 //
 305 //
 306 //
 307 class CCppCodeNode : public CParseNode
 308 {
 309 public:
 310
 311         std::string             RawCode;
 312
 313         ///
 314         virtual bool    prolog();
 315 };
 316
 317 //
 318 //
 319 //
 320 class CTypeNode : public CParseNode
 321 {
 322 public:
 323         CTypeNode() :
 324                 ToCppType(NULL),
 325                 ToStorageType(NULL),
 326                 ExternFlag(false),
 327                 InternFlag(false),
 328                 Id(0)
 329         {
 330         }
 331
 332         std::string             CppType;
 333         std::string             StorageType;
 334         std::string             DisplayName;
 335
 336         CParseNode*             ToCppType;
 337         CParseNode*             ToStorageType;
 338
 339         bool                    ExternFlag;
 340         bool                    InternFlag;
 341
 342         std::string             Temp;
 343
 344         uint32                  Size;
 345         uint                    Id;
 346
 347         std::string             DefaultValue;
 348
 349         virtual bool            isEnum()                { return false; }
 350         virtual bool            isDimension()   { return false; }
 351         virtual bool            isIndex()               { return false; }
 352
 353         virtual std::string     checkCode(const std::string& var)       { return ""; }
 354
 355         std::string                     storageToCpp()
 356         {
 357                 if (ToCppType != NULL)
 358                         return "__pds_cnv_type_"+NLMISC::toString(Id)+"_s2c";
 359                 else
 360                         return "("+CppType+")";
 361         }
 362
 363         std::string                     cppToStorage()
 364         {
 365                 if (ToStorageType != NULL)
 366                         return "__pds_cnv_type_"+NLMISC::toString(Id)+"_c2s";
 367                 else
 368                         return "("+StorageType+")";
 369         }
 370
 371
 372
 373         std::string                     castToCpp(const std::string& var)
 374         {
 375                 if (CppType != StorageType)
 376                 {
 377                         return storageToCpp()+"("+var+")";
 378                 }
 379                 else
 380                 {
 381                         return var;
 382                 }
 383         }
 384
 385         std::string                     castToStorage(const std::string& var)
 386         {
 387                 if (CppType != StorageType)
 388                 {
 389                         return cppToStorage()+"("+var+")";
 390                 }
 391                 else
 392                 {
 393                         return var;
 394                 }
 395         }
 396
 397         std::string                     getCppType()
 398         {
 399                 if (CppType == "CEntityId")
 400                         return "NLMISC::CEntityId";
 401                 else if (CppType == "CSheetId")
 402                         return "NLMISC::CSheetId";
 403                 else
 404                         return CppType;
 405         }
 406
 407
 408
 409
 410         std::string                     castToPDS(const std::string& var)
 411         {
 412                 if (isEnum())
 413                 {
 414                         return "(uint32)"+var;
 415                 }
 416                 else if (ExternFlag)
 417                 {
 418                         return "("+StorageType+")"+var;
 419                 }
 420                 else
 421                 {
 422                         //return "("+getName()+")";
 423                         return castToStorage(var);
 424                 }
 425         }
 426
 427         std::string                     castFromUser(const std::string& var)
 428         {
 429                 return "("+getName()+")"+var;
 430         }
 431
 432
 433
 434         virtual std::string     getName()               { return DisplayName.empty() ? Name : DisplayName; }
 435
 436         std::string                     getDefaultValue()
 437         {
 438                 if (DefaultValue.empty())
 439                 {
 440                         if (CppType == "CEntityId")     return "NLMISC::CEntityId::Unknown";
 441                         if (CppType == "CSheetId")      return "NLMISC::CSheetId::Unknown";
 442                         return castFromUser("0");
 443                 }
 444                 else
 445                 {
 446                         return DefaultValue;
 447                 }
 448         }
 449
 450
 451
 452         virtual std::string     getPrintfFmt()
 453         {
 454                 if (CppType == "CEntityId" || CppType == "CSheetId")
 455                         return "%s";
 456                 if (CppType == "double" || CppType == "float")
 457                         return "%f";
 458                 if (CppType == "sint64")
 459                         return "%\"NL_I64\"d";
 460                 if (CppType == "uint64")
 461                         return "%\"NL_I64\"u";
 462                 if (CppType == "sint32" || CppType == "sint16" || CppType == "sint8")
 463                         return "%d";
 464                 if (CppType == "uint32" || CppType == "uint16" || CppType == "uint8")
 465                         return "%u";
 466                 if (CppType == "char" || CppType == "ucchar")
 467                         return "%c";
 468                 if (CppType == "bool")
 469                         return "%s";
 470                 return "%d";
 471         }
 472
 473         virtual std::string getPrintfVal(const std::string& var)
 474         {
 475                 if (CppType == "CEntityId" || CppType == "CSheetId")
 476                         return var+".toString()";
 477                 if (CppType == "double" || CppType == "float" ||
 478                         CppType == "sint64" || CppType == "uint64" ||
 479                         CppType == "sint32" || CppType == "sint16" || CppType == "sint8" ||
 480                         CppType == "uint32" || CppType == "uint16" || CppType == "uint8" ||
 481                         CppType == "char" || CppType == "ucchar")
 482                         return var;
 483                 if (CppType == "bool")
 484                         return "("+var+" ? \"true\" : \"false\")";
 485                 return "(uint32)"+var;
 486         }
 487
 488
 489         ///
 490         virtual bool    prolog();
 491
 492         ///
 493         virtual bool    generateContent();
 494
 495         virtual void    generateApplyCode(CClassGenerator::SMethodId& method, const std::string& token, const std::string& value)
 496         {
 497                 method.add("__pdr.pop("+token+", "+value+");");
 498         }
 499
 500         virtual void    generateStoreCode(CClassGenerator::SMethodId& method, const std::string& token, const std::string& value)
 501         {
 502                 method.add("__pdr.push("+token+", "+value+");");
 503         }
 504 };
 505
 506
 507
 508
 509
 510
 511
 512 //
 513 //
 514 //
 515 class CDeclarationNode;
 516 class CCallContext;
 517
 518 enum TDeclarationType
 519 {
 520         SimpleType,
 521         SimpleClass,
 522         ForwardRef,
 523         BackRef,
 524         ArrayType,
 525         ArrayClass,
 526         ArrayRef,
 527         Set
 528 };
 529
 530 struct CColumn
 531 {
 532         std::string                             Name;
 533         uint32                                  ByteSize;
 534         TDeclarationType                Type;
 535         std::string                             TypeStr;
 536         uint                                    TypeId;
 537 };
 538
 539 class CClassNode : public CParseNode
 540 {
 541 public:
 542
 543         CClassNode() :
 544                 IsBackReferenced(false),
 545                 HasInheritance(false),
 546                 IsInSet(false),
 547                 IsInArray(false),
 548                 IsInArrayRef(false),
 549                 MappedFlag(false),
 550                 DerivatedFlag(false),
 551                 HasParent(false),
 552                 ParentIsHidden(false),
 553                 ForceReference(false),
 554                 PDSMapped(false),
 555                 MapClass(NULL),
 556                 Columns(-1),
 557                 Id(0),
 558                 HasRowAccess(false),
 559                 HasTableAccess(false),
 560                 indexUsedInInit(false),
 561                 indexUsedInDestroy(false),
 562                 indexUsedInFetch(false),
 563                 tableAndRowIndicesUsedInFetch(false),
 564                 indexUsedInRegister(false),
 565                 indexUsedInUnregister(false),
 566                 indexUsedInNotifyInit(false),
 567                 indexUsedInNotifyRelease(false)
 568         {
 569         }
 570
 571         std::string                                     Inherited;
 572         std::string                                     ClassKey;
 573         std::string                                     Implements;
 574         std::set<CClassNode*>           Dependencies;
 575
 576         std::vector<std::string>        ChildrenClasses;
 577         bool                                            IsBackReferenced;
 578         bool                                            HasInheritance;
 579         bool                                            IsInSet;
 580         bool                                            IsInArray;
 581         bool                                            IsInArrayRef;
 582         bool                                            MappedFlag;
 583         bool                                            DerivatedFlag;
 584         bool                                            HasParent;
 585         bool                                            ParentIsHidden;
 586         bool                                            ForceReference;
 587         std::string                                     ParentClass;
 588         std::string                                     Reserve;
 589
 590         bool                                            PDSMapped;
 591
 592         CClassNode                                      *MapClass;
 593
 594         std::vector<CDeclarationNode*>  Init;
 595         std::string                                     InitProto;
 596         std::string                                     InitCallArgs;
 597
 598         sint                                            Columns;
 599
 600         uint                                            Id;
 601
 602         std::vector<CDeclarationNode*>  Attributes;
 603
 604         bool                                            HasRowAccess;
 605         bool                                            HasTableAccess;
 606
 607         std::set<std::string>           Friends;
 608         std::set<std::string>           ForwardFriends;
 609
 610         std::set<CClassNode*>           Legacy;
 611
 612         ///
 613         virtual bool    prolog();
 614         virtual bool    epilog();
 615
 616         CDeclarationNode*       getDeclarationNode(const std::string &name);
 617         CDeclarationNode*       getKey();
 618         CDeclarationNode*       getClassKey();
 619         CDeclarationNode*       getDeclaration(const std::string& name);
 620
 621         bool                            useEntityId();
 622
 623         void                    checkClassReferences();
 624         void                    fillAttributes();
 625         void                    fillRefs();
 626         void                    computeFriends();
 627
 628         void    checkDependencies(std::set<CClassNode*> &beingChecked,
 629                                                           std::set<CClassNode*> &checkedClasses,
 630                                                           std::vector<CClassNode*> &classesOrder);
 631
 632         void    buildInit();
 633
 634         void    computeAttributesColumns();
 635
 636         std::string                                     getId() { return (HasInheritance ? NLMISC::toString("__BaseTable") : NLMISC::toString(Id)); }
 637
 638         std::string                                     getUserCode(const std::string& name);
 639
 640         //
 641
 642         CClassGenerator         Gen;
 643
 644         CClassGenerator::SMethodId      InitId;
 645         CClassGenerator::SMethodId      DestroyId;
 646         CClassGenerator::SMethodId      FetchId;
 647         CClassGenerator::SMethodId      RegisterId;
 648         CClassGenerator::SMethodId      RegisterAttributesId;
 649         CClassGenerator::SMethodId      UnregisterId;
 650         CClassGenerator::SMethodId      UnregisterAttributesId;
 651         CClassGenerator::SMethodId      SetParentId;
 652         CClassGenerator::SMethodId      SetUnnotifiedParentId;
 653         CClassGenerator::SMethodId      NotifyInitId;
 654         CClassGenerator::SMethodId      NotifyReleaseId;
 655
 656         CClassGenerator::SMethodId      UserInitId;
 657         CClassGenerator::SMethodId      UserReleaseId;
 658
 659         //
 660         CClassGenerator::SMethodId      ClearId;
 661         CClassGenerator::SMethodId      StoreId;
 662         CClassGenerator::SMethodId      ApplyId;
 663
 664         bool    indexUsedInInit;
 665         bool    indexUsedInDestroy;
 666         bool    indexUsedInFetch;
 667         bool    tableAndRowIndicesUsedInFetch;
 668         bool    indexUsedInRegister;
 669         bool    indexUsedInUnregister;
 670         bool    indexUsedInNotifyInit;
 671         bool    indexUsedInNotifyRelease;
 672
 673         bool    generateContent();
 674         void    generateContentInCall(CCallContext *context);
 675 };
 676
 677 class CDeclarationNode : public CParseNode
 678 {
 679 public:
 680
 681         CDeclarationNode() :
 682                 InitFillFlag(false),
 683                 WriteTriggerFlag(false),
 684                 ParentFlag(false),
 685                 HiddenFlag(false),
 686                 MirroredFlag(false),
 687                 ArrayFlag(false),
 688                 SetFlag(false),
 689                 IsRef(false),
 690                 IsType(false),
 691                 IsKey(false),
 692                 Id(0),
 693                 Column(-1),
 694                 Columns(-1)
 695         {
 696         }
 697
 698         bool                    InitFillFlag;
 699         bool                    WriteTriggerFlag;
 700         bool                    ParentFlag;
 701         bool                    HiddenFlag;
 702         bool                    MirroredFlag;
 703
 704         std::string             ParentClass;
 705         std::string             ParentField;
 706
 707         std::string             Type;
 708
 709         bool                    ArrayFlag;
 710         std::string             ArrayIndex;
 711         bool                    SetFlag;
 712         std::string             ForwardRefAttribute;
 713
 714         bool                    IsRef;
 715         bool                    IsType;
 716         bool                    IsKey;
 717
 718         std::string             DefaultValue;
 719
 720         struct CUserCode
 721         {
 722                 std::string             Event;
 723                 std::string             CodeSpecializer;
 724                 std::string             UserCode;
 725         };
 726
 727         std::vector<CUserCode>  UserCodes;
 728
 729         std::string             getUserCode(const std::string &name, const std::string &specialize = std::string(""))
 730         {
 731                 uint    i;
 732                 // first look for a specialized code
 733                 for (i=0; i<UserCodes.size(); ++i)
 734                         if (UserCodes[i].Event == name && UserCodes[i].CodeSpecializer == specialize)
 735                                 return UserCodes[i].UserCode;
 736                 // then look for a default code
 737                 for (i=0; i<UserCodes.size(); ++i)
 738                         if (UserCodes[i].Event == name && UserCodes[i].CodeSpecializer.empty())
 739                                 return UserCodes[i].UserCode;
 740                 return "";
 741         }
 742
 743         TDeclarationType        DeclarationType;
 744
 745         std::string             XmlNode;
 746         std::vector<CColumn>    ColumnList;
 747
 748         uint                    Id;
 749
 750         sint                    Column;
 751         sint                    Columns;
 752
 753         CClassNode*             ClassNode;
 754         CClassNode*             getParentClass()        { return dynamic_cast<CClassNode*>(Parent); }
 755
 756         ///
 757         virtual bool    prolog();
 758         virtual bool    epilog();
 759
 760         //
 761         std::string             getFunc() const         { return lcFirst(getFunctionPrefix+Name); }
 762         std::string             setFunc() const         { return lcFirst(setFunctionPrefix+Name); }
 763         std::string             newFunc() const         { return lcFirst(newFunction+Name); }
 764         std::string             deleteFunc() const      { return lcFirst(deleteFunction+Name); }
 765         std::string             unlinkFunc() const      { return lcFirst(unlinkFunction+Name); }
 766         std::string             cppName() const         { return "_"+Name; }
 767         std::string             tokenName() const       { return "__Tok"+Name; }
 768
 769         //
 770         std::string             displayPrintfPrefix();
 771         std::string             displayCppCode(std::string replVar = "");
 772         std::string             toUint64(std::string replVar = "");
 773
 774         //
 775         void                    generateContent(CCallContext *context = NULL);
 776
 777         void                    generateTypeContent(CCallContext *context = NULL);
 778         void                    generateClassContent(CCallContext *context = NULL);
 779         void                    generateBackRefContent();
 780         void                    generateForwardRefContent();
 781         void                    generateArrayTypeContent(CCallContext *context = NULL);
 782         void                    generateArrayClassContent(CCallContext *context = NULL);
 783         void                    generateArrayRefContent(CCallContext *context = NULL);
 784         void                    generateSetContent(CCallContext *context = NULL);
 785
 786
 787         void                    generateArrayApplyCode();
 788         void                    generateArrayStoreCode();
 789         void                    generateArrayEndCode();
 790
 791         void                    generateClassPtrApplyCode(const std::string& value);
 792         void                    generateClassPtrStoreCode(const std::string& value);
 793
 794         std::string             getAccessorName(CCallContext *context, const std::string& accessortype, const std::string& sep = "::");
 795 };
 796
 797
 798
 799 //
 800 //
 801 //
 802 class CIndexNode : public CTypeNode
 803 {
 804 public:
 805
 806         CIndexNode()
 807         {
 808                 CppType = "uint32";
 809                 StorageType = "uint32";
 810         }
 811
 812         virtual bool            isIndex()               { return true; }
 813
 814         virtual std::string     getSizeName()   { return Name+"Size"; }
 815         virtual uint            getSize() = 0;
 816
 817         virtual std::string     getIndexName(uint32 value) const
 818         {
 819                 return NLMISC::toString(value);
 820         }
 821
 822         virtual std::string     getToStringCode(const std::string& var) const
 823         {
 824                 return "NLMISC::toString("+var+")";
 825         }
 826
 827         virtual std::string     getFromStringCode(const std::string& var) const
 828         {
 829                 return "atoi("+var+")";
 830         }
 831
 832         virtual std::string     checkCode(const std::string& var)       { return "nlassert("+var+"<"+getSizeName()+");"; }
 833 };
 834
 835
 836 //
 837 //
 838 //
 839 class CEnumNode : public CIndexNode
 840 {
 841 public:
 842         CEnumNode() :
 843                 CurrentValue(0),
 844                 MinValue(0),
 845                 MaxValue(0)
 846         {
 847         }
 848
 849         uint32                  CurrentValue;
 850
 851         uint32                  MinValue;
 852         uint32                  MaxValue;
 853         std::vector<std::pair<std::string, uint32> >    Values;
 854         std::string             EndRange;
 855
 856         virtual bool            isEnum()                { return true; }
 857         virtual std::string     getName()
 858         {
 859                 std::string     trunc = Name.substr(1);
 860                 return "C"+trunc+"::"+(DisplayName.empty() ? Name : DisplayName);
 861         }
 862
 863         virtual uint            getSize()               { return MaxValue-MinValue; }
 864
 865         bool    prolog();
 866         bool    epilog();
 867
 868         ///
 869         virtual bool    generateContent();
 870
 871         std::string             getIndexName(uint32 value) const
 872         {
 873                 std::string     result;
 874
 875                 uint    i;
 876                 for (i=0; i<Values.size(); ++i)
 877                         if (Values[i].second == value)
 878                                 result = Values[i].first;
 879
 880                 return result;
 881         }
 882
 883         std::string             getUnscopedUseSize() const
 884         {
 885                 return "___"+Name+"_useSize";
 886         }
 887
 888         std::string             getUnknownValue() const
 889         {
 890                 return "Unknown";
 891         }
 892
 893         std::string             getUseSize() const
 894         {
 895                 std::string     trunc = Name.substr(1);
 896                 return "C"+trunc+"::"+getUnscopedUseSize();
 897         }
 898
 899         std::string             getSizeName()
 900         {
 901                 std::string     trunc = Name.substr(1);
 902                 return "C"+trunc+"::"+getUnscopedUseSize();
 903         }
 904
 905         virtual std::string     getToStringCode(const std::string& var) const
 906         {
 907                 std::string     trunc = Name.substr(1);
 908                 return "C"+trunc+"::toString("+var+")";
 909         }
 910
 911         virtual std::string     getFromStringCode(const std::string& var) const
 912         {
 913                 std::string     trunc = Name.substr(1);
 914                 return "C"+trunc+"::fromString("+var+")";
 915         }
 916
 917         virtual void    generateApplyCode(CClassGenerator::SMethodId& method, const std::string& token, const std::string& value)
 918         {
 919                 method.add("{");
 920                 method.add("std::string\tvaluename;");
 921                 method.add("__pdr.pop("+token+", valuename);");
 922                 method.add(value+" = "+getFromStringCode("valuename")+";");
 923                 method.add("}");
 924         }
 925
 926         virtual void    generateStoreCode(CClassGenerator::SMethodId& method, const std::string& token, const std::string& value)
 927         {
 928                 method.add("{");
 929                 method.add("std::string\tvaluename = "+getToStringCode(value)+";");
 930                 method.add("__pdr.push("+token+", valuename);");
 931                 method.add("}");
 932         }
 933 };
 934
 935 class CEnumSimpleValueNode : public CEnumNode
 936 {
 937 public:
 938
 939         std::vector<std::string>        Names;
 940
 941         bool    prolog();
 942         bool    epilog();
 943 };
 944
 945 class CEnumRangeNode : public CEnumNode
 946 {
 947 public:
 948
 949         bool    prolog();
 950         bool    epilog();
 951 };
 952
 953
 954
 955
 956 //
 957 //
 958 //
 959 class CDimensionNode : public CIndexNode
 960 {
 961 public:
 962
 963 public:
 964         CDimensionNode()
 965         {
 966         }
 967
 968         virtual bool            isDimension()   { return true; }
 969         std::string                     getSizeName()   { return Name+"Size"; }
 970
 971         bool    prolog();
 972         bool    epilog();
 973
 974         sint    Dimension;
 975
 976         virtual uint            getSize()               { return Dimension; }
 977
 978         ///
 979         virtual bool    generateContent();
 980 };
 981
 982
 983 //
 984 //
 985 //
 986 class CLogMsgNode : public CParseNode
 987 {
 988 public:
 989
 990         CLogMsgNode() : Context(false)
 991         {
 992         }
 993
 994         bool    prolog();
 995         bool    epilog()
 996         {
 997                 return true;
 998         }
 999
1000         std::vector<std::pair<std::string, std::string> >       Params;
1001         std::vector<std::string>                                                        Logs;
1002
1003         bool                                                                                            Context;
1004
1005         uint                    Id;
1006
1007         void    generateContent();
1008 };
1009
1010 class CExtLogTypeNode : public CParseNode
1011 {
1012 public:
1013
1014         std::string     ExtLogType;
1015
1016 };
1017
1018
1019
1020
1021 //
1022 //
1023 //
1024 class CCallContext
1025 {
1026 public:
1027
1028         std::vector<CDeclarationNode*>  Context;
1029
1030         std::string                             RootTable;
1031         std::string                             RootRow;
1032         uint                                    Column;
1033
1034         CCallContext(CDeclarationNode* decl = NULL)
1035         {
1036                 if (decl != NULL)
1037                         Context.push_back(decl);
1038         }
1039
1040         bool    hasRootEntityIdKey()
1041         {
1042                 CDeclarationNode*       k = getRootCaller()->getClassKey();
1043                 if (k != NULL)
1044                 {
1045                          return (getRootCaller()->getTypeNode(getRootCaller()->getKey()->Type)->CppType == "CEntityId");
1046                 }
1047                 return false;
1048         }
1049
1050         /**
1051          * Generates the name of the pointed variable
1052          * For instance: PhysicalScoresBase, where PhysicalScores is an array and Base is an attribute in this array
1053          * Actually concats all fields names
1054          */
1055         std::string                             getCallString()
1056         {
1057                 uint    i;
1058                 std::string     res;
1059                 for (i=0; i<Context.size(); ++i)
1060                         res += Context[i]->Name;
1061                 return res;
1062         }
1063
1064         CClassNode*                             getRootCaller()
1065         {
1066                 return (CClassNode*)Context[0]->Parent;
1067         }
1068
1069         CDeclarationNode*               getRootDeclaration()
1070         {
1071                 return Context[0];
1072         }
1073
1074         /**
1075          * Generates the access prototype argument list
1076          * Actually only generates indexes for arrays
1077          */
1078         std::string                             getDebugCallStringFmt()
1079         {
1080                 uint            i, idx=0;
1081                 std::string     res;
1082
1083                 for (i=0; i<Context.size(); ++i)
1084                 {
1085                         CDeclarationNode*       decl = Context[i];
1086
1087                         if (decl->DeclarationType == ArrayClass || decl->DeclarationType == ArrayType)
1088                         {
1089                                 if (!res.empty())
1090                                         res += ", ";
1091
1092                                 CTypeNode*      tnd = decl->getTypeNode(decl->ArrayIndex);
1093                                 res += indexVariable+NLMISC::toString(idx++)+"="+tnd->getPrintfFmt();
1094                         }
1095                 }
1096
1097                 return res;
1098         }
1099
1100
1101         /**
1102          * Generates the access prototype argument list
1103          * Actually only generates indexes for arrays
1104          */
1105         std::string                             getDebugCallStringVal()
1106         {
1107                 uint            i, idx=0;
1108                 std::string     res;
1109
1110                 for (i=0; i<Context.size(); ++i)
1111                 {
1112                         CDeclarationNode*       decl = Context[i];
1113
1114                         if (decl->DeclarationType == ArrayClass || decl->DeclarationType == ArrayType)
1115                         {
1116                                 if (!res.empty())
1117                                         res += ", ";
1118
1119                                 CTypeNode*      tnd = decl->getTypeNode(decl->ArrayIndex);
1120                                 res += tnd->getPrintfVal(indexVariable+NLMISC::toString(idx++));
1121                         }
1122                 }
1123
1124                 return res;
1125         }
1126
1127
1128         /**
1129          * Generates the access prototype argument list
1130          * Actually only generates indexes for arrays
1131          */
1132         std::string                             getCallArgList()
1133         {
1134                 std::string     res;
1135                 uint            i, idx=0;
1136
1137                 for (i=0; i<Context.size(); ++i)
1138                 {
1139                         CDeclarationNode*       decl = Context[i];
1140
1141                         if (decl->DeclarationType == ArrayClass || decl->DeclarationType == ArrayType)
1142                         {
1143                                 if (!res.empty())
1144                                         res += ", ";
1145
1146                                 CTypeNode*      tnd = decl->getTypeNode(decl->ArrayIndex);
1147                                 res += tnd->getName()+ " "+indexVariable+NLMISC::toString(idx++);
1148                         }
1149                 }
1150                 return res;
1151         }
1152
1153         /**
1154          * Generates the c++ path to the variable
1155          * For instance: _PhysicalScores[__i0].Base, where PhysicalScores is an array and Base is an attribute in this array
1156          */
1157         std::string                             getCallPath()
1158         {
1159                 std::string     res;
1160                 uint            i, idx=0;
1161
1162                 for (i=0; i<Context.size(); ++i)
1163                 {
1164                         CDeclarationNode*       decl = Context[i];
1165
1166                         if (!res.empty())
1167                                 res += ".";
1168
1169                         res += decl->cppName();
1170
1171                         if (decl->DeclarationType == ArrayClass || decl->DeclarationType == ArrayType)
1172                         {
1173                                 res += "["+indexVariable+NLMISC::toString(idx++)+"]";
1174                         }
1175                 }
1176                 return res;
1177         }
1178
1179         /**
1180          * Generates the c++ path to the variable
1181          * For instance: _PhysicalScores[__i0].Base, where PhysicalScores is an array and Base is an attribute in this array
1182          */
1183         std::string                             getUserCodeContext()
1184         {
1185                 std::string     res;
1186                 uint            i;
1187
1188                 if (Context.empty())
1189                         return res;
1190
1191                 res = Context[0]->getParentClass()->Name;
1192
1193                 for (i=0; i<Context.size(); ++i)
1194                         res += "."+Context[i]->Name;
1195
1196                 return res;
1197         }
1198
1199         /**
1200          * Generates check code for all types accessors
1201          */
1202         std::vector<std::string>        getCheckCode()
1203         {
1204                 std::vector<std::string>        res;
1205                 uint            i, idx=0;
1206
1207                 for (i=0; i<Context.size(); ++i)
1208                 {
1209                         CDeclarationNode*       decl = Context[i];
1210
1211                         if (decl->DeclarationType == ArrayType || decl->DeclarationType == ArrayRef || decl->DeclarationType == ArrayClass)
1212                         {
1213                                 CIndexNode*     ind = decl->getIndexNode(decl->ArrayIndex);
1214                                 std::string     code = ind->checkCode(indexVariable+NLMISC::toString(idx++));
1215                                 if (!code.empty())
1216                                         res.push_back(code);
1217                         }
1218                 }
1219
1220                 return res;
1221         }
1222
1223         /**
1224          * Get current context index
1225          */
1226         uint                                    getContextIndex()
1227         {
1228                 uint            i, idx=0;
1229
1230                 for (i=0; i<Context.size(); ++i)
1231                 {
1232                         CDeclarationNode*       decl = Context[i];
1233                         if (decl->DeclarationType == ArrayClass || decl->DeclarationType == ArrayType)
1234                                 idx++;
1235                 }
1236                 return idx-1;
1237         }
1238
1239         CCallContext                    getSubContext(CDeclarationNode* decl)
1240         {
1241                 CCallContext    ctx = *this;
1242                 ctx.Context.push_back(decl);
1243                 return ctx;
1244         }
1245
1246         std::string                             getColumn()
1247         {
1248                 std::string     res;
1249                 uint            i, idx=0;
1250
1251                 for (i=0; i<Context.size(); ++i)
1252                 {
1253                         CDeclarationNode*       decl = Context[i];
1254                         if (decl->Column != 0)
1255                         {
1256                                 if (!res.empty())
1257                                         res += "+";
1258                                 res += NLMISC::toString(decl->Column);
1259                         }
1260
1261                         if (decl->DeclarationType == ArrayType || decl->DeclarationType == ArrayRef)
1262                         {
1263                                 if (!res.empty())
1264                                         res += "+";
1265                                 res += indexVariable+NLMISC::toString(idx++);
1266                         }
1267                         else if (decl->DeclarationType == ArrayClass)
1268                         {
1269                                 if (!res.empty())
1270                                         res += "+";
1271                                 CClassNode*     sub = decl->getClassNode(decl->Type);
1272                                 res += indexVariable+NLMISC::toString(idx++)+"*"+NLMISC::toString(sub->Columns);
1273                         }
1274                 }
1275
1276                 if (res.empty())
1277                         res = "0";
1278
1279                 return res;
1280         }
1281 };
1282
1283
1284
1285
1286
1287
1288 //
1289 // INLINES
1290 //
1291
1292 inline CFileNode*       CParseNode::getFileNode()
1293 {
1294         if (FileNode != NULL)
1295                 return FileNode;
1296
1297         CParseNode*     node = this;
1298         CFileNode*      fnode = NULL;
1299
1300         while (node != NULL && (fnode = dynamic_cast<CFileNode*>(node)) == NULL)
1301                 node = node->Parent;
1302
1303         if (fnode == NULL)
1304                 error("Can't find file node", "internal");
1305
1306         FileNode = fnode;
1307
1308         return fnode;
1309 }
1310
1311 inline CDbNode* CParseNode::getDbNode()
1312 {
1313         if (DbNode != NULL)
1314                 return DbNode;
1315
1316         CParseNode*     node = this;
1317         CDbNode*        fnode = NULL;
1318
1319         while (node != NULL && (fnode = dynamic_cast<CDbNode*>(node)) == NULL)
1320                 node = node->Parent;
1321
1322         if (fnode == NULL)
1323                 error("Can't find db node", "internal");
1324
1325         DbNode = fnode;
1326
1327         return fnode;
1328 }
1329
1330 inline CCppOutput&      CParseNode::hOutput()
1331 {
1332         CFileNode       *fnode = getFileNode();
1333         return fnode->Hpp;
1334 }
1335
1336 inline CCppOutput&      CParseNode::cppOutput()
1337 {
1338         CFileNode       *fnode = getFileNode();
1339         return fnode->Cpp;
1340 }
1341
1342 inline CCppOutput&      CParseNode::inlineOutput()
1343 {
1344         CFileNode       *fnode = getFileNode();
1345         return fnode->HppInline;
1346 }
1347
1348
1349 inline CTypeNode        *CParseNode::getTypeNode(const std::string &name, bool genError)
1350 {
1351         CDbNode*        db = getDbNode();
1352         uint            i;
1353         for (i=0; i<db->TypeNodes.size(); ++i)
1354                 if (db->TypeNodes[i]->Name == name)
1355                         return db->TypeNodes[i];
1356         if (genError)
1357                 error("Can't find type '"+name+"'");
1358         return NULL;
1359 }
1360
1361 inline CEnumNode        *CParseNode::getEnumNode(const std::string &name, bool genError)
1362 {
1363         CEnumNode*      node = dynamic_cast<CEnumNode*>(getTypeNode(name, genError));
1364         if (node == NULL && genError)
1365                 error("Can't find enum '"+name+"'");
1366         return node;
1367 }
1368
1369 inline CDimensionNode   *CParseNode::getDimensionNode(const std::string &name, bool genError)
1370 {
1371         CDimensionNode* node = dynamic_cast<CDimensionNode*>(getTypeNode(name, genError));
1372         if (node == NULL && genError)
1373                 error("Can't find dimension '"+name+"'");
1374         return node;
1375 }
1376
1377 inline CIndexNode       *CParseNode::getIndexNode(const std::string &name, bool genError)
1378 {
1379         CIndexNode*     node = dynamic_cast<CIndexNode*>(getTypeNode(name, genError));
1380         if (node == NULL && genError)
1381                 error("Can't find index type '"+name+"' (neither enum nor dimension)");
1382         return node;
1383 }
1384
1385 inline CClassNode       *CParseNode::getClassNode(const std::string &name, bool genError)
1386 {
1387         CDbNode*        db = getDbNode();
1388         uint            i;
1389         for (i=0; i<db->ClassNodes.size(); ++i)
1390                 if (db->ClassNodes[i]->Name == name)
1391                         return db->ClassNodes[i];
1392         if (genError)
1393                 error("Can't find class '"+name+"'");
1394         return NULL;
1395 }
1396
1397 inline bool                     CDbNode::addTypeNode(const std::string &name, const std::string &displayName, const std::string &defaultValue)
1398 {
1399         CTypeNode               *node = new CTypeNode();
1400
1401         node->Name = name;
1402         node->DisplayName = displayName;
1403         node->CppType = name;
1404         node->StorageType = name;
1405
1406         node->ToCppType = NULL;
1407         node->ToStorageType = NULL;
1408
1409         node->DefaultValue = defaultValue;
1410
1411         node->ExternFlag = false;
1412         node->InternFlag = true;
1413         node->Parent = this;
1414
1415         Nodes.insert(Nodes.begin(), node);
1416
1417         return true;
1418 }
1419
1420
1421 inline CDeclarationNode*        CClassNode::getDeclarationNode(const std::string &name)
1422 {
1423         CDeclarationNode        *node;
1424         if ((node = dynamic_cast<CDeclarationNode*>(getNode(name))) == NULL)
1425                 error("declaration '"+name+"' not found");
1426         return node;
1427 }
1428
1429 inline bool     CClassNode::useEntityId()
1430 {
1431          //return !ClassKey.empty() && getTypeNode(getKey()->Type)->CppType == "CEntityId";
1432         CDeclarationNode*       k = getClassKey();
1433          return k!=NULL && getTypeNode(k->Type)->CppType == "CEntityId";
1434 }
1435
1436 inline CDeclarationNode*        CClassNode::getClassKey()
1437 {
1438         if (ClassKey.empty())
1439         {
1440                 if (Inherited.empty())
1441                         return NULL;
1442                 CClassNode*     p = getClassNode(Inherited);
1443                 return p->getClassKey();
1444         }
1445         else
1446         {
1447                 return getKey();
1448         }
1449 }
1450
1451
1452 inline CDeclarationNode*        CClassNode::getKey()
1453 {
1454         CDeclarationNode*       key = NULL;
1455         CClassNode*                     classNode = this;
1456         while (classNode != NULL)
1457         {
1458                 key = dynamic_cast<CDeclarationNode*>(classNode->getNode(classNode->ClassKey));
1459                 if (key != NULL)
1460                         return key;
1461                 classNode = getClassNode(Inherited, false);
1462         }
1463         error("key declaration '"+ClassKey+"' not found");
1464         return NULL;
1465         //return getDeclarationNode(ClassKey);
1466 }
1467
1468 inline CDeclarationNode*        CClassNode::getDeclaration(const std::string& name)
1469 {
1470         CDeclarationNode*       decl = NULL;
1471         CClassNode*                     classNode = this;
1472         while (classNode != NULL)
1473         {
1474                 decl = dynamic_cast<CDeclarationNode*>(classNode->getNode(name));
1475                 if (decl != NULL)
1476                         return decl;
1477                 classNode = getClassNode(classNode->Inherited, false);
1478         }
1479         error("declaration '"+name+"' not found");
1480         return NULL;
1481 }
1482
1483
1484
1485 #endif