ryzom/tools/pd_parser/templatizer.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 NL_TEMPLATIZER_H
  18 #define NL_TEMPLATIZER_H
  19
  20 #include <nel/misc/types_nl.h>
  21 #include <nel/misc/common.h>
  22 #include <nel/misc/debug.h>
  23 #include <nel/misc/eval_num_expr.h>
  24
  25 #include <vector>
  26 #include <string>
  27 #include <map>
  28
  29 class ITemplatizerBloc;
  30
  31 const char      EnvSeparator = '/';
  32
  33
  34
  35
  36
  37
  38
  39
  40 /**
  41  * A Templatizer Env
  42  */
  43 class CTemplatizerEnv : public NLMISC::CEvalNumExpr
  44 {
  45 public:
  46
  47         /// Constructor
  48         CTemplatizerEnv(CTemplatizerEnv* parent) : Parent(parent), CurrentArrayNode(0)  { }
  49
  50         /// Destructor
  51         virtual ~CTemplatizerEnv();
  52
  53         /// Clear Env
  54         virtual void            clear();
  55
  56         /// Get value
  57         virtual std::string     get(const std::string& name);
  58
  59         /// Set value
  60         template<typename T>
  61         void            set(const std::string& name, const T& value)
  62         {
  63                 std::string::size_type dotpos = name.find(EnvSeparator);
  64                 std::string             child = name.substr(0, dotpos);
  65
  66                 if (dotpos == std::string::npos)
  67                 {
  68                         setAsRawText(name, NLMISC::toString(value));
  69                 }
  70                 else
  71                 {
  72                         getEnv(child)->set(name.substr(dotpos+1), value);
  73                 }
  74         }
  75
  76         /// Set a Define
  77         void                            define(const std::string& name)
  78         {
  79                 set(name, 1);
  80         }
  81
  82         /// Set a Conditional Define
  83         void                            define(bool isdef, const std::string& name)
  84         {
  85                 if (isdef)
  86                         set(name, 1);
  87         }
  88
  89         /// Does Variable exist?
  90         virtual bool            exists(const std::string& name) const
  91         {
  92                 TValueMap::const_iterator       it = Values.find(name);
  93                 if (it == Values.end())
  94                         return (Parent == NULL ? false : Parent->exists(name));
  95                 return true;
  96         }
  97
  98         /// Does Sub Environment exist?
  99         virtual bool            envExists(const std::string& name) const
 100         {
 101                 std::string::size_type dotpos = name.find(EnvSeparator);
 102                 std::string             child = name.substr(0, dotpos);
 103
 104                 if (child.empty())
 105                         return true;
 106
 107                 TEnvMap::const_iterator it = Envs.find(child);
 108                 if (it == Envs.end())
 109                         return false;
 110
 111                 return (dotpos == std::string::npos) ? true : (*it).second->envExists(name.substr(dotpos+1));
 112         }
 113
 114         /// Enter Sub Env, like getEnv() but it doesn't look in parent, and always goes in current env
 115         virtual CTemplatizerEnv*        getSubEnv(const std::string& name)
 116         {
 117                 std::string::size_type dotpos = name.find(EnvSeparator);
 118                 std::string             child = name.substr(0, dotpos);
 119
 120                 if (child.empty())
 121                         return this;
 122
 123                 CTemplatizerEnv*        env = NULL;
 124
 125                 if (child == ".")
 126                 {
 127                         env = this;
 128                 }
 129                 else if (child == "..")
 130                 {
 131                         env = (Parent != NULL ? Parent : this);
 132                 }
 133                 else if (child == "...")
 134                 {
 135                         env = getRootEnv();
 136                 }
 137                 else
 138                 {
 139                         TEnvMap::iterator       it = Envs.find(child);
 140                         if (it != Envs.end())
 141                         {
 142                                 env = (*it).second;
 143                         }
 144                         else
 145                         {
 146                                 env = new CTemplatizerEnv(this);
 147                                 Envs[child] = env;
 148                         }
 149
 150                 }
 151
 152                 return (dotpos == std::string::npos) ? env : env->getSubEnv(name.substr(dotpos+1));
 153         }
 154
 155         /// Get Sub Env
 156         virtual CTemplatizerEnv*        getEnv(const std::string& name)
 157         {
 158                 std::string::size_type dotpos = name.find(EnvSeparator);
 159                 std::string             child = name.substr(0, dotpos);
 160
 161                 if (child.empty())
 162                         return this;
 163
 164                 if (child == ".")
 165                 {
 166                         return (dotpos == std::string::npos) ? this : this->getSubEnv(name.substr(dotpos+1));
 167                 }
 168                 else if (child == "..")
 169                 {
 170                         CTemplatizerEnv*        env = (Parent != NULL ? Parent : this);
 171                         return (dotpos == std::string::npos) ? env : env->getSubEnv(name.substr(dotpos+1));
 172                 }
 173                 else if (child == "...")
 174                 {
 175                         CTemplatizerEnv*        env = getRootEnv();
 176                         return (dotpos == std::string::npos) ? env : env->getSubEnv(name.substr(dotpos+1));
 177                 }
 178                 else
 179                 {
 180                         TEnvMap::iterator       it = Envs.find(child);
 181                         if (it != Envs.end())
 182                         {
 183                                 return (dotpos == std::string::npos) ? (*it).second : (*it).second->getSubEnv(name.substr(dotpos+1));
 184                         }
 185                         else
 186                         {
 187                                 return Parent != NULL ? Parent->getEnv(name) : getSubEnv(name);
 188                         }
 189                 }
 190         }
 191
 192         /// Get Sub Env
 193         CTemplatizerEnv*        getEnv(uint node)
 194         {
 195                 return getEnv(NLMISC::toString("%08X", node));
 196         }
 197
 198         /// Evaluate string (string replacement)
 199         virtual std::string             eval(const std::string& text);
 200
 201         /// Get Next Array Node
 202         CTemplatizerEnv*        nextArrayNode(const std::string& array)
 203         {
 204                 CTemplatizerEnv*        aenv = getSubEnv(array);
 205                 uint                            node = (aenv->CurrentArrayNode)++;
 206                 return aenv->getSubEnv(NLMISC::toString("%08X", node));
 207         }
 208
 209         /// Set Sub Env
 210         virtual void            setSubEnv(const std::string& name, CTemplatizerEnv* subenv)
 211         {
 212                 Envs[name] = subenv;
 213         }
 214
 215         /// Get Parent Env
 216         virtual CTemplatizerEnv*        getParent()
 217         {
 218                 return Parent;
 219         }
 220
 221 public:
 222
 223         /// Parent Env
 224         CTemplatizerEnv*        Parent;
 225
 226         typedef std::map<std::string, ITemplatizerBloc*>        TValueMap;
 227         typedef std::map<std::string, CTemplatizerEnv*>         TEnvMap;
 228
 229         /// Contained Values
 230         TValueMap                       Values;
 231
 232         /// Sub Env
 233         TEnvMap                         Envs;
 234
 235         /// Get Root Env
 236         virtual CTemplatizerEnv*        getRootEnv()
 237         {
 238                 CTemplatizerEnv*        root = this;
 239                 while (root->getParent() != NULL)
 240                         root = root->getParent();
 241
 242                 return root;
 243         }
 244
 245         /// Current Array Node
 246         uint                            CurrentArrayNode;
 247
 248         /// Set As Raw Text
 249         virtual void            setAsRawText(const std::string& name, const std::string& text);
 250
 251         /// Set Value Node
 252         virtual void            setValueNode(const std::string& name, ITemplatizerBloc* bloc)
 253         {
 254                 Values[name] = bloc;
 255         }
 256
 257         /// Get Value Node
 258         virtual ITemplatizerBloc*       getValueNode(const std::string& name)
 259         {
 260                 ITemplatizerBloc*       node = NULL;
 261                 CTemplatizerEnv*        env = NULL;
 262                 return getValueNodeAndEnv(name, node, env) ? node : NULL;
 263         }
 264
 265         /// Get Value Node
 266         virtual bool            getValueNodeAndEnv(const std::string& name, ITemplatizerBloc*& node, CTemplatizerEnv*& env)
 267         {
 268                 std::string::size_type pos = name.find_last_of(EnvSeparator);
 269                 if (pos == std::string::npos)
 270                 {
 271                         node = getNode(name);
 272                         env = this;
 273                         while (node == NULL && env != NULL)
 274                         {
 275                                 env = env->getParent();
 276                                 if (env != NULL)
 277                                         node = env->getNode(name);
 278                         }
 279                 }
 280                 else
 281                 {
 282                         env = getEnv(name.substr(0, pos));
 283                         if (env != NULL)
 284                                 node = env->getNode(name.substr(pos+1));
 285                 }
 286
 287                 return node != NULL && env != NULL;
 288         }
 289
 290         virtual ITemplatizerBloc*       getNode(const std::string& name)
 291         {
 292                 TValueMap::iterator     it = Values.find(name);
 293                 return it == Values.end() ? NULL : (*it).second;
 294         }
 295
 296         virtual NLMISC::CEvalNumExpr::TReturnState      evalValue (const char *value, double &result, uint32 userData);
 297 };
 298
 299
 300 /**
 301  * A Templatizer Env
 302  */
 303 class CTemplatizerRefEnv : public CTemplatizerEnv
 304 {
 305 public:
 306
 307         /// Constructor
 308         CTemplatizerRefEnv(CTemplatizerEnv* ref) : CTemplatizerEnv(NULL), Reference(ref)        { }
 309
 310         /// Clear Env
 311         virtual void            clear()
 312         {
 313                 Reference = NULL;
 314         }
 315
 316         /// Get value
 317         virtual std::string     get(const std::string& name)
 318         {
 319                 return Reference->get(name);
 320         }
 321
 322         /// Does Variable exist?
 323         virtual bool            exists(const std::string& name) const
 324         {
 325                 return Reference->exists(name);
 326         }
 327
 328         /// Does Sub Environment exist?
 329         virtual bool            envExists(const std::string& name) const
 330         {
 331                 return Reference->envExists(name);
 332         }
 333
 334         /// Get Sub Env
 335         virtual CTemplatizerEnv*        getEnv(const std::string& name)
 336         {
 337                 return Reference->getEnv(name);
 338         }
 339
 340         /// Evaluate string (string replacement)
 341         virtual std::string                     eval(const std::string& text)
 342         {
 343                 return Reference->eval(text);
 344         }
 345
 346         /// Enter Sub Env, like getEnv() but it doesn't look in parent, and always goes in current env
 347         virtual CTemplatizerEnv*        getSubEnv(const std::string& name)
 348         {
 349                 return Reference->getSubEnv(name);
 350         }
 351
 352         /// Get Parent Env
 353         virtual CTemplatizerEnv*        getParent()
 354         {
 355                 return Reference->getParent();
 356         }
 357 public:
 358
 359         CTemplatizerEnv*        Reference;
 360
 361         /// Get Root Env
 362         virtual CTemplatizerEnv*        getRootEnv()
 363         {
 364                 return Reference->getRootEnv();
 365         }
 366
 367         /// Set As Raw Text
 368         virtual void            setAsRawText(const std::string& name, const std::string& text)
 369         {
 370                 Reference->setAsRawText(name, text);
 371         }
 372
 373         /// Set Value Node
 374         virtual void            setValueNode(const std::string& name, ITemplatizerBloc* bloc)
 375         {
 376                 Reference->setValueNode(name, bloc);
 377         }
 378
 379         /// Get Value Node
 380         virtual ITemplatizerBloc*       getValueNode(const std::string& name)
 381         {
 382                 return Reference->getValueNode(name);
 383         }
 384
 385         /// Get Value Node
 386         virtual bool    getValueNodeAndEnv(const std::string& name, ITemplatizerBloc*& node, CTemplatizerEnv*& env)
 387         {
 388                 return Reference->getValueNodeAndEnv(name, node, env);
 389         }
 390
 391         virtual ITemplatizerBloc*       getNode(const std::string& name)
 392         {
 393                 return Reference->getNode(name);
 394         }
 395 };
 396
 397
 398 /**
 399  * <Class description>
 400  * \author Benjamin Legros
 401  * \author Nevrax France
 402  * \date 2003
 403  */
 404 class CTemplatizer
 405 {
 406 public:
 407
 408         /// Constructor
 409         CTemplatizer();
 410
 411         /// Destructor
 412         ~CTemplatizer();
 413
 414
 415
 416         /**
 417          * Build templatizer from text
 418          */
 419         bool            build(const char* text);
 420
 421
 422         /**
 423          * Evaluate template and render to string
 424          */
 425         std::string     eval();
 426
 427
 428         /**
 429          * Set Value in env
 430          */
 431         template<typename T>
 432         void            set(const std::string& var, const T& value)
 433         {
 434                 if (RootEnv == NULL)
 435                         return;
 436
 437                 std::string::size_type pos = var.find_last_of(EnvSeparator);
 438
 439                 if (pos == std::string::npos)
 440                 {
 441                         RootEnv->set(var, value);
 442                 }
 443                 else
 444                 {
 445                         RootEnv->getEnv(var.substr(0, pos))->set(var.substr(pos+1), value);
 446                 }
 447         }
 448
 449 public:
 450
 451         ITemplatizerBloc*               RootBloc;
 452
 453         CTemplatizerEnv*                RootEnv;
 454
 455 };
 456
 457
 458
 459 class CTemplatizerParser
 460 {
 461 public:
 462
 463         CTemplatizerParser() : _Buffer(NULL), _Line(0), _Valid(false)   { }
 464         CTemplatizerParser(const CTemplatizerParser& ptr) : _Buffer(ptr._Buffer), _Line(ptr._Line), _Valid(ptr._Valid)  { }
 465         CTemplatizerParser(const char*  buffer, uint linestart = 1) : _Buffer(buffer), _Line(linestart), _Valid(_Buffer != NULL)        { }
 466
 467         char    operator * () const                     { return *_Buffer; }
 468         char    operator [] (int i) const       { return _Buffer[i]; }
 469
 470         CTemplatizerParser&     operator = (const CTemplatizerParser& ptr)
 471         {
 472                 _Buffer = ptr._Buffer;
 473                 _Line = ptr._Line;
 474                 _Valid = ptr._Valid;
 475                 return *this;
 476         }
 477
 478         CTemplatizerParser&     operator ++ ()
 479         {
 480                 if (*_Buffer == '\0')
 481                         return *this;
 482
 483                 if (*_Buffer == '\n')
 484                         ++_Line;
 485
 486                 ++_Buffer;
 487                 return *this;
 488         }
 489
 490         CTemplatizerParser      operator ++ (int)
 491         {
 492                 CTemplatizerParser      ret(*this);
 493                 ++(*this);
 494                 return ret;
 495         }
 496
 497         void    invalidate()    { _Valid = false; }
 498         bool    isValid() const { return _Valid; }
 499
 500         uint    getLine() const { return _Line; }
 501
 502 private:
 503
 504         const char*     _Buffer;
 505
 506         uint    _Line;
 507
 508         bool    _Valid;
 509
 510 };
 511
 512
 513
 514
 515 /**
 516  * A Templatizer node
 517  */
 518 class ITemplatizerBloc
 519 {
 520 public:
 521
 522         /// Constructor
 523         ITemplatizerBloc();
 524
 525         /// Destructor
 526         virtual ~ITemplatizerBloc();
 527
 528
 529
 530         /// Evaluate node
 531         virtual std::string     eval(CTemplatizerEnv* env)
 532         {
 533                 std::string     res;
 534                 uint    i;
 535                 for (i=0; i<Blocs.size(); ++i)
 536                         res += Blocs[i]->eval(env);
 537                 return res;
 538         }
 539
 540         /// Get Text (assuming this is a raw text bloc)
 541         virtual std::string     getText(CTemplatizerEnv* env)
 542         {
 543                 return "";
 544         }
 545
 546         /// Get Param list
 547         virtual const char**    getDefParamList()
 548         {
 549                 return NULL;
 550         }
 551
 552         /// Get Actual Bloc (not a reference)
 553         virtual ITemplatizerBloc*       getActualBloc()
 554         {
 555                 return this;
 556         }
 557
 558 public:
 559
 560         std::string     evalParam(const std::string& param, CTemplatizerEnv* env)
 561         {
 562                 TParamMap::iterator     it = Params.find(param);
 563                 if (it == Params.end())
 564                         return "";
 565                 return (*it).second->eval(env);
 566         }
 567
 568 public:
 569
 570         /// Bloc types
 571         enum TType
 572         {
 573                 Text,
 574         };
 575
 576         /// Bloc type
 577         TType                           Type;
 578
 579         typedef std::vector<ITemplatizerBloc*>                          TBlocList;
 580         typedef std::map<std::string, ITemplatizerBloc*>        TParamMap;
 581
 582         /// Params
 583         TParamMap                       Params;
 584
 585         /// Sub blocs
 586         TBlocList                       Blocs;
 587
 588
 589         /// Parse bloc
 590         static ITemplatizerBloc*        parseBloc(CTemplatizerParser& ptr);
 591
 592         /// Parse bloc header
 593         virtual CTemplatizerParser      parseHeader(CTemplatizerParser ptr);
 594
 595         /// Parse bloc internal data
 596         virtual CTemplatizerParser      parseInternal(CTemplatizerParser ptr);
 597
 598         /// Has A Internal Bloc of data
 599         virtual bool            hasInternal() const     { return true; }
 600 };
 601
 602
 603
 604
 605
 606 /// Root Templatizer
 607 class CTemplatizerRootBloc : public ITemplatizerBloc
 608 {
 609 public:
 610
 611 };
 612
 613 /// Reference Node
 614 class CTemplatizerReferenceBloc : public ITemplatizerBloc
 615 {
 616 public:
 617
 618         ITemplatizerBloc*       Reference;
 619
 620         /// Constructor
 621         CTemplatizerReferenceBloc(ITemplatizerBloc* ref = NULL) : Reference(ref)        {}
 622
 623         /// Destructor
 624         virtual ~CTemplatizerReferenceBloc()
 625         {
 626                 Reference = NULL;
 627         }
 628
 629         /// Evaluate node
 630         virtual std::string     eval(CTemplatizerEnv* env)
 631         {
 632                 std::string                     name = evalParam("name", env);
 633                 std::string                     ref = evalParam("ref", env);
 634                 ITemplatizerBloc*       refnode = env->getValueNode(ref);
 635                 if (refnode != NULL)
 636                         env->setValueNode(name, new CTemplatizerReferenceBloc(refnode));
 637                 else
 638                         nlwarning("Failed to create reference on '%s', not found", name.c_str());
 639                 return "";
 640         }
 641
 642         /// Get Text (assuming this is a raw text bloc)
 643         virtual std::string     getText(CTemplatizerEnv* env)
 644         {
 645                 return Reference->getText(env);
 646         }
 647
 648         /// Get Param list
 649         virtual const char**    getDefParamList()
 650         {
 651                 static const char*      args[] = { "name", "ref" };
 652                 return (const char**)args;
 653         }
 654
 655         /// Get Actual Bloc (not a reference)
 656         virtual ITemplatizerBloc*       getActualBloc()
 657         {
 658                 return Reference->getActualBloc();
 659         }
 660
 661         /// Has A Internal Bloc of data
 662         virtual bool            hasInternal() const     { return false; }
 663 };
 664
 665
 666 /// RefEnv Bloc
 667 class CTemplatizerRefEnvBloc : public ITemplatizerBloc
 668 {
 669 public:
 670
 671         /// Evaluate node
 672         virtual std::string     eval(CTemplatizerEnv* env)
 673         {
 674                 std::string                     name = evalParam("name", env);
 675                 std::string                     ref = evalParam("ref", env);
 676
 677                 CTemplatizerEnv*        refenv = env->getEnv(ref);
 678                 if (refenv != NULL)
 679                         env->setSubEnv(name, new CTemplatizerRefEnv(refenv));
 680                 else
 681                         nlwarning("Failed to create reference on env '%s', not found", name.c_str());
 682                 return "";
 683         }
 684
 685         /// Get Param list
 686         virtual const char**    getDefParamList()
 687         {
 688                 static const char*      args[] = { "name", "ref" };
 689                 return (const char**)args;
 690         }
 691
 692         /// Has A Internal Bloc of data
 693         virtual bool            hasInternal() const     { return false; }
 694 };
 695
 696
 697
 698
 699
 700 /**
 701  * Comment Bloc
 702  */
 703 class CTemplatizerCommentBloc : public ITemplatizerBloc
 704 {
 705 public:
 706
 707         virtual std::string     eval(CTemplatizerEnv* env)
 708         {
 709                 return "";
 710         }
 711
 712         /// Parse bloc internal data
 713         virtual CTemplatizerParser      parseInternal(CTemplatizerParser ptr);
 714
 715 };
 716
 717
 718 /**
 719  * Raw Text Bloc
 720  */
 721 class CTemplatizerRawTextBloc : public ITemplatizerBloc
 722 {
 723 public:
 724
 725         std::string             Text;
 726
 727         virtual std::string     eval(CTemplatizerEnv* env)
 728         {
 729                 return Text;
 730         }
 731
 732         virtual std::string     getText(CTemplatizerEnv* env)
 733         {
 734                 return Text;
 735         }
 736 };
 737
 738 // Set As Raw Text
 739 inline void     CTemplatizerEnv::setAsRawText(const std::string& name, const std::string& text)
 740 {
 741         CTemplatizerRawTextBloc*        bloc = new CTemplatizerRawTextBloc();
 742         bloc->Text = text;
 743         setValueNode(name, bloc);
 744 }
 745
 746 // Get value
 747 inline std::string      CTemplatizerEnv::get(const std::string& name)
 748 {
 749         ITemplatizerBloc*       bloc = getValueNode(name);
 750
 751         return (bloc == NULL) ? std::string("") : bloc->getText(this);
 752 }
 753
 754 // eval num expr override
 755 inline NLMISC::CEvalNumExpr::TReturnState       CTemplatizerEnv::evalValue (const char *value, double &result, uint32 userData)
 756 {
 757         if (*value != '$')
 758         {
 759                 return NLMISC::CEvalNumExpr::ValueError;
 760         }
 761
 762         std::string     strvalue = get(value+1);
 763
 764         if (sscanf(strvalue.c_str(), "%lf", &result) != 1)
 765         {
 766                 result = (strvalue.empty() ? 0.0 : 1.0);
 767         }
 768
 769         return NLMISC::CEvalNumExpr::NoError;
 770 }
 771
 772
 773
 774 /**
 775  * Text Bloc
 776  */
 777 class CTemplatizerTextBloc : public ITemplatizerBloc
 778 {
 779 public:
 780
 781         std::string             Text;
 782
 783         virtual std::string     eval(CTemplatizerEnv* env)
 784         {
 785                 return env->eval(Text);
 786         }
 787
 788         virtual std::string     getText(CTemplatizerEnv* env)
 789         {
 790                 return env->eval(Text);
 791         }
 792
 793         /// Parse bloc internal data
 794         virtual CTemplatizerParser      parseInternal(CTemplatizerParser ptr);
 795 };
 796
 797
 798
 799
 800 /**
 801  * Sub bloc
 802  */
 803 class CTemplatizerSubBloc : public ITemplatizerBloc
 804 {
 805 public:
 806
 807         virtual std::string     eval(CTemplatizerEnv* env)
 808         {
 809                 std::string                     subname = evalParam("name", env);
 810                 CTemplatizerEnv*        subenv = env->getSubEnv(subname);
 811
 812                 return ITemplatizerBloc::eval(subenv);
 813         }
 814
 815         /// Get Param list
 816         virtual const char**    getDefParamList()
 817         {
 818                 static const char*      args[] = { "name" };
 819                 return (const char**)args;
 820         }
 821 };
 822
 823
 824 /**
 825  * Loop bloc
 826  */
 827 class CTemplatizerLoopBloc : public ITemplatizerBloc
 828 {
 829 public:
 830
 831         virtual std::string     eval(CTemplatizerEnv* env)
 832         {
 833                 std::string                     subname = evalParam("name", env);
 834                 CTemplatizerEnv*        subenv = env->getSubEnv(subname);
 835
 836                 std::string                     res;
 837
 838                 CTemplatizerEnv::TEnvMap::iterator      it;
 839                 for (it=subenv->Envs.begin(); it!=subenv->Envs.end(); ++it)
 840                         res += ITemplatizerBloc::eval((*it).second);
 841
 842                 return res;
 843         }
 844
 845         /// Get Param list
 846         virtual const char**    getDefParamList()
 847         {
 848                 static const char*      args[] = { "name" };
 849                 return (const char**)args;
 850         }
 851 };
 852
 853
 854 /**
 855  * IfDefEnv bloc
 856  */
 857 class CTemplatizerIfDefEnvBloc : public ITemplatizerBloc
 858 {
 859 public:
 860
 861         virtual std::string     eval(CTemplatizerEnv* env)
 862         {
 863                 std::string                     subname = evalParam("name", env);
 864                 std::string                     evalinsub = evalParam("evalinsub", env);
 865
 866                 if (env->envExists(subname))
 867                 {
 868                         sint eval;
 869                         NLMISC::fromString(evalinsub, eval);
 870                         CTemplatizerEnv*        subenv = (eval ? env->getEnv(subname) : env);
 871                         return ITemplatizerBloc::eval(subenv);
 872                 }
 873
 874                 return "";
 875         }
 876
 877         /// Get Param list
 878         virtual const char**    getDefParamList()
 879         {
 880                 static const char*      args[] = { "name", "evalinsub" };
 881                 return (const char**)args;
 882         }
 883 };
 884
 885
 886 /**
 887  * IfDef bloc
 888  */
 889 class CTemplatizerIfDefBloc : public ITemplatizerBloc
 890 {
 891 public:
 892
 893         virtual std::string     eval(CTemplatizerEnv* env)
 894         {
 895                 std::string                     varname = evalParam("name", env);
 896
 897                 if (env->exists(varname))
 898                 {
 899                         return ITemplatizerBloc::eval(env);
 900                 }
 901
 902                 return "";
 903         }
 904
 905         /// Get Param list
 906         virtual const char**    getDefParamList()
 907         {
 908                 static const char*      args[] = { "name" };
 909                 return (const char**)args;
 910         }
 911 };
 912
 913
 914 /**
 915  * IfDefEnv bloc
 916  */
 917 class CTemplatizerIfNotDefEnvBloc : public ITemplatizerBloc
 918 {
 919 public:
 920
 921         virtual std::string     eval(CTemplatizerEnv* env)
 922         {
 923                 std::string                     subname = evalParam("name", env);
 924
 925                 if (!env->envExists(subname))
 926                 {
 927                         return ITemplatizerBloc::eval(env);
 928                 }
 929
 930                 return "";
 931         }
 932
 933         /// Get Param list
 934         virtual const char**    getDefParamList()
 935         {
 936                 static const char*      args[] = { "name" };
 937                 return (const char**)args;
 938         }
 939 };
 940
 941
 942 /**
 943  * IfDef bloc
 944  */
 945 class CTemplatizerIfNotDefBloc : public ITemplatizerBloc
 946 {
 947 public:
 948
 949         virtual std::string     eval(CTemplatizerEnv* env)
 950         {
 951                 std::string                     varname = evalParam("name", env);
 952
 953                 if (!env->exists(varname))
 954                 {
 955                         return ITemplatizerBloc::eval(env);
 956                 }
 957
 958                 return "";
 959         }
 960
 961         /// Get Param list
 962         virtual const char**    getDefParamList()
 963         {
 964                 static const char*      args[] = { "name" };
 965                 return (const char**)args;
 966         }
 967 };
 968
 969
 970 /**
 971  * Switch bloc
 972  */
 973 class CTemplatizerSwitchBloc : public ITemplatizerBloc
 974 {
 975 public:
 976
 977         virtual std::string     eval(CTemplatizerEnv* env)
 978         {
 979                 std::string                     switchvalue = evalParam("value", env);
 980
 981                 uint    i;
 982                 for (i=0; i<Blocs.size(); ++i)
 983                         if (Blocs[i]->evalParam("case", env) == switchvalue)
 984                                 return Blocs[i]->eval(env);
 985
 986                 return "";
 987         }
 988
 989         /// Get Param list
 990         virtual const char**    getDefParamList()
 991         {
 992                 static const char*      args[] = { "value" };
 993                 return (const char**)args;
 994         }
 995 };
 996
 997 /**
 998  * File bloc
 999  */
1000 class CTemplatizerFileBloc : public ITemplatizerBloc
1001 {
1002 public:
1003
1004         virtual std::string     eval(CTemplatizerEnv* env)
1005         {
1006                 std::string     clearfile = evalParam("clear", env);
1007                 std::string     filename = evalParam("name", env);
1008
1009                 std::string     result = ITemplatizerBloc::eval(env);
1010
1011                 FILE*   f;
1012                 f = NLMISC::nlfopen(filename, (clearfile == "true" ? "w" : "a"));
1013                 if (f != NULL)
1014                 {
1015                         fwrite(result.c_str(), 1, result.size(), f);
1016                         fclose(f);
1017                 }
1018
1019                 return result;
1020         }
1021
1022         /// Get Param list
1023         virtual const char**    getDefParamList()
1024         {
1025                 static const char*      args[] = { "name" };
1026                 return (const char**)args;
1027         }
1028 };
1029
1030 /**
1031  * Set bloc
1032  */
1033 class CTemplatizerSetBloc : public ITemplatizerBloc
1034 {
1035 public:
1036
1037         virtual std::string     eval(CTemplatizerEnv* env)
1038         {
1039                 std::string     var = evalParam("name", env);
1040                 std::string     result = ITemplatizerBloc::eval(env);
1041
1042                 env->set(var, result);
1043
1044                 return "";
1045         }
1046
1047         /// Get Param list
1048         virtual const char**    getDefParamList()
1049         {
1050                 static const char*      args[] = { "name" };
1051                 return (const char**)args;
1052         }
1053 };
1054
1055 /**
1056  * Append bloc
1057  */
1058 class CTemplatizerAppendBloc : public ITemplatizerBloc
1059 {
1060 public:
1061
1062         virtual std::string     eval(CTemplatizerEnv* env)
1063         {
1064                 std::string     var = evalParam("name", env);
1065                 std::string     result = ITemplatizerBloc::eval(env);
1066
1067                 ITemplatizerBloc*       bloc = env->getValueNode(var);
1068                 if (bloc == NULL)
1069                         return "";
1070
1071                 CTemplatizerRawTextBloc*        text = dynamic_cast<CTemplatizerRawTextBloc*>(bloc->getActualBloc());
1072                 if (text == NULL)
1073                         return "";
1074
1075                 text->Text += result;
1076
1077                 return "";
1078         }
1079
1080         /// Get Param list
1081         virtual const char**    getDefParamList()
1082         {
1083                 static const char*      args[] = { "name" };
1084                 return (const char**)args;
1085         }
1086 };
1087
1088 /**
1089  * Define Bloc
1090  */
1091 class CTemplatizerDefineBloc : public ITemplatizerBloc
1092 {
1093 public:
1094
1095         virtual std::string     eval(CTemplatizerEnv* env)
1096         {
1097                 std::string     name = evalParam("name", env);
1098                 env->setValueNode(name, new CTemplatizerReferenceBloc(this));
1099                 return "";
1100         }
1101
1102         virtual std::string     getText(CTemplatizerEnv* env)
1103         {
1104                 return ITemplatizerBloc::eval(env);
1105         }
1106
1107         /// Get Param list
1108         virtual const char**    getDefParamList()
1109         {
1110                 static const char*      args[] = { "name" };
1111                 return (const char**)args;
1112         }
1113 };
1114
1115 /**
1116  * If Bloc
1117  */
1118 class CTemplatizerIfBloc : public ITemplatizerBloc
1119 {
1120 public:
1121
1122         virtual std::string     eval(CTemplatizerEnv* env)
1123         {
1124                 std::string     value = evalParam("cond", env);
1125                 double          result;
1126                 NLMISC::CEvalNumExpr::TReturnState      res = env->evalExpression(value.c_str(), result, NULL);
1127
1128                 if (res == NLMISC::CEvalNumExpr::NoError && result != 0.0)
1129                 {
1130                         return ITemplatizerBloc::eval(env);
1131                 }
1132                 else
1133                 {
1134                         return "";
1135                 }
1136         }
1137
1138         /// Get Param list
1139         virtual const char**    getDefParamList()
1140         {
1141                 static const char*      args[] = { "cond" };
1142                 return (const char**)args;
1143         }
1144 };
1145
1146 /**
1147  * If Not Bloc
1148  */
1149 class CTemplatizerIfNotBloc : public ITemplatizerBloc
1150 {
1151 public:
1152
1153         virtual std::string     eval(CTemplatizerEnv* env)
1154         {
1155                 std::string     value = evalParam("cond", env);
1156
1157                 if (value.empty())
1158                 {
1159                         return ITemplatizerBloc::eval(env);
1160                 }
1161                 else
1162                 {
1163                         return "";
1164                 }
1165         }
1166
1167         /// Get Param list
1168         virtual const char**    getDefParamList()
1169         {
1170                 static const char*      args[] = { "cond" };
1171                 return (const char**)args;
1172         }
1173 };
1174
1175 /**
1176  * Join bloc
1177  */
1178 class CTemplatizerJoinBloc : public ITemplatizerBloc
1179 {
1180 public:
1181
1182         virtual std::string     eval(CTemplatizerEnv* env)
1183         {
1184                 std::string     sep = evalParam("separator", env);
1185
1186                 std::string     res;
1187                 uint    i;
1188                 for (i=0; i<Blocs.size(); ++i)
1189                 {
1190                         std::string     token = Blocs[i]->eval(env);
1191
1192                         if (token.empty())
1193                                 continue;
1194
1195                         if (!res.empty())
1196                                 res += sep;
1197
1198                         res += token;
1199                 }
1200                 return res;
1201         }
1202
1203         /// Get Param list
1204         virtual const char**    getDefParamList()
1205         {
1206                 static const char*      args[] = { "separator" };
1207                 return (const char**)args;
1208         }
1209 };
1210
1211 /**
1212  * User Defined function call
1213  */
1214 class CTemplatizerUserFunctionBloc : public ITemplatizerBloc
1215 {
1216 public:
1217
1218         CTemplatizerUserFunctionBloc(const std::string& name) : Name(name)      {}
1219
1220         std::string             Name;
1221
1222         virtual std::string     eval(CTemplatizerEnv* env)
1223         {
1224                 ITemplatizerBloc*       func = NULL;
1225                 CTemplatizerEnv*        fenv = NULL;
1226                 if (!env->getValueNodeAndEnv(Name, func, fenv))
1227                 {
1228                         nlwarning("Unknown user function '%s'", Name.c_str());
1229                         return "";
1230                 }
1231
1232                 // subenv is child of object env, not of current env
1233                 CTemplatizerEnv*        subenv = new CTemplatizerEnv(fenv);
1234
1235                 // deport params in subenv
1236                 // \todo : eval param in current env
1237                 TParamMap::iterator     it;
1238                 for (it=Params.begin(); it!=Params.end(); ++it)
1239                         subenv->setAsRawText((*it).first, (*it).second->getText(env));
1240                         //subenv->setValueNode((*it).first, new CTemplatizerReferenceBloc((*it).second));
1241
1242                 std::string     res = func->getText(subenv);
1243
1244                 delete subenv;
1245
1246                 return res;
1247         }
1248
1249         /// Get Param list
1250         virtual const char**    getDefParamList()
1251         {
1252                 return NULL;
1253         }
1254
1255         /// Has A Internal Bloc of data
1256         virtual bool            hasInternal() const
1257         {
1258                 return false;
1259         }
1260 };
1261
1262 /**
1263  * Class
1264  */
1265 class CTemplatizerClassBloc : public ITemplatizerBloc
1266 {
1267 public:
1268
1269         virtual std::string     eval(CTemplatizerEnv* env)
1270         {
1271                 std::string     name = evalParam("name", env);
1272                 env->setValueNode(name, new CTemplatizerReferenceBloc(this));
1273                 return "";
1274         }
1275
1276         virtual std::string     instantiate(CTemplatizerEnv* env)
1277         {
1278                 return ITemplatizerBloc::eval(env);
1279         }
1280
1281         /// Get Param list
1282         virtual const char**    getDefParamList()
1283         {
1284                 static const char*      args[] = { "name" };
1285                 return (const char**)args;
1286         }
1287 };
1288
1289 /**
1290  * Class
1291  */
1292 class CTemplatizerObjectBloc : public ITemplatizerBloc
1293 {
1294 public:
1295
1296         virtual std::string     eval(CTemplatizerEnv* env)
1297         {
1298                 std::string     classname = evalParam("class", env);
1299                 std::string     name = evalParam("name", env);
1300
1301                 ITemplatizerBloc*       bloc = env->getValueNode(classname);
1302                 if (bloc == NULL)
1303                 {
1304                         nlwarning("Unknown class '%s'", classname.c_str());
1305                         return "";
1306                 }
1307
1308                 CTemplatizerClassBloc*  classbloc = dynamic_cast<CTemplatizerClassBloc*>(bloc->getActualBloc());
1309                 if (classbloc == NULL)
1310                 {
1311                         nlwarning("object '%s' is not a class", classname.c_str());
1312                         return "";
1313                 }
1314
1315                 CTemplatizerEnv* objectenv = env->getSubEnv(name);
1316                 objectenv->clear();
1317
1318                 return classbloc->instantiate(objectenv);
1319         }
1320
1321         /// Get Param list
1322         virtual const char**    getDefParamList()
1323         {
1324                 static const char*      args[] = { "class", "name" };
1325                 return (const char**)args;
1326         }
1327
1328         /// Has A Internal Bloc of data
1329         virtual bool            hasInternal() const     { return false; }
1330 };
1331
1332
1333 /**
1334  * Breakpoint
1335  */
1336 class CTemplatizerBreakpointBloc : public ITemplatizerBloc
1337 {
1338 public:
1339
1340         virtual std::string     eval(CTemplatizerEnv* env)
1341         {
1342                 std::string     value = evalParam("name", env);
1343                 return "";
1344         }
1345
1346         /// Get Param list
1347         virtual const char**    getDefParamList()
1348         {
1349                 static const char*      args[] = { "name" };
1350                 return (const char**)args;
1351         }
1352 };
1353
1354
1355 #endif // NL_TEMPLATIZER_H
1356
1357 /* End of templatizer.h */