ryzom/tools/pd_parser/parser_rules.cpp

   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
  18
  19 #include "parser_rules.h"
  20
  21 /*
  22  * Main Bloc
  23  */
  24 PARSE_START_NO_DESCRIPTION(Main, CParseNode)
  25
  26         while (!tokenizer.end())
  27         {
  28                 PARSE_MARK
  29                 PARSE_ALTERNATIVE(Db)
  30                 PARSE_FAIL
  31         }
  32
  33 PARSE_END
  34
  35
  36 /*
  37  * Db Bloc
  38  */
  39 PARSE_START(Db, CDbNode)
  40
  41         PARSE_KEYWORD(Db)
  42         PARSE_MARK
  43         PARSE_IDENTIFIER(Name)
  44         PARSE_MARK
  45
  46         PARSE_OPT_KEYWORD_IN(String, MainFile);
  47
  48         PARSE_START_BLOC
  49
  50                 PARSE_MARK
  51
  52                 PARSE_ALTERNATIVE(File)
  53                 PARSE_ALTERNATIVE(UsePch)
  54                 PARSE_FAIL
  55
  56                 PARSE_MARK
  57
  58         PARSE_END_BLOC
  59
  60         PARSE_MARK
  61
  62 PARSE_END
  63
  64
  65 /*
  66  * File Bloc
  67  */
  68 PARSE_START(File, CFileNode)
  69
  70         PARSE_OPT_BEFORE(File)
  71                 PARSE_OPT_IN(Separated, SeparatedFlag);
  72         PARSE_END_OPT_BEFORE()
  73
  74         PARSE_KEYWORD(File)
  75         PARSE_MARK
  76         PARSE_STRING(Name)
  77         PARSE_MARK
  78
  79         main->IncludeAs = main->Name;
  80
  81         PARSE_OPT_KEYWORD_IN(String, IncludeAs);
  82
  83         PARSE_START_BLOC
  84
  85                 PARSE_MARK
  86
  87                 PARSE_ALTERNATIVE(Include)
  88                 PARSE_ALTERNATIVE(Type)
  89                 PARSE_ALTERNATIVE(Class)
  90                 PARSE_ALTERNATIVE(Enum)
  91                 PARSE_ALTERNATIVE(Dimension)
  92                 //PARSE_ALTERNATIVE(CppCode)
  93                 PARSE_ALTERNATIVE(LogMsg)
  94                 PARSE_ALTERNATIVE(LogContext)
  95                 PARSE_FAIL
  96
  97                 PARSE_MARK
  98
  99         PARSE_END_BLOC
 100
 101         PARSE_MARK
 102
 103 PARSE_END
 104
 105
 106 /*
 107  * Include Bloc
 108  */
 109 PARSE_START(Include, CIncludeNode)
 110
 111         PARSE_KEYWORD(Include)
 112         PARSE_MARK
 113         PARSE_STRING(Name)
 114         PARSE_MARK
 115
 116 PARSE_END
 117
 118 /*
 119  * Include Bloc
 120  */
 121 PARSE_START(UsePch, CUsePchNode)
 122
 123         PARSE_KEYWORD(UsePch)
 124         PARSE_MARK
 125         PARSE_STRING(Name)
 126         PARSE_MARK
 127
 128 PARSE_END
 129
 130
 131 /*
 132  * Cpp Code Bloc
 133  */
 134 PARSE_START(CppCode, CCppCodeNode)
 135
 136         PARSE_OPT_KEYWORD_IN(Identifier, Name)
 137         PARSE_KEYWORD_IN(CppCode, RawCode)
 138         PARSE_MARK
 139
 140 PARSE_END
 141
 142
 143 /*
 144  * Type Bloc
 145  */
 146 PARSE_START(Type, CTypeNode)
 147
 148         PARSE_OPT_BEFORE(Type)
 149                 PARSE_OPT_IN(Extern, ExternFlag);
 150         PARSE_END_OPT_BEFORE()
 151
 152         PARSE_KEYWORD(Type)
 153         PARSE_MARK
 154         if (main->ExternFlag)
 155         {
 156                 PARSE_SCOPE_IDF(Name)
 157         }
 158         else
 159         {
 160                 PARSE_IDENTIFIER(Name)
 161         }
 162
 163         main->DisplayName = main->Name;
 164
 165         PARSE_MARK
 166         if (tokenizer.current() == TokenOpenParenthesis)
 167         {
 168                 tokenizer.next();
 169                 PARSE_MARK
 170                 PARSE_IDENTIFIER(CppType)
 171                 PARSE_MARK
 172                 PARSE_KEYWORD(Comma)
 173                 PARSE_MARK
 174                 PARSE_IDENTIFIER(StorageType)
 175                 PARSE_MARK
 176                 PARSE_KEYWORD(CloseParenthesis)
 177                 PARSE_MARK
 178
 179                 if (tokenizer.current() == TokenOpenBrace)
 180                 {
 181                         tokenizer.next();
 182
 183                         PARSE_MARK
 184                         PARSE_IDENTIFIER(Temp)
 185                         if (main->Temp == main->CppType)
 186                         {
 187                                 PARSE_MARK
 188                                 PARSE_KEYWORD(OpenParenthesis)
 189                                 PARSE_MARK
 190                                 PARSE_IDENTIFIER(Temp)
 191                                 if (main->Temp != main->StorageType)
 192                                         PARSE_FAIL
 193                                 PARSE_MARK
 194                                 PARSE_KEYWORD(CloseParenthesis)
 195                                 PARSE_MARK
 196                                 PARSE_NODE(CppCode, ToCppType)
 197                                 PARSE_MARK
 198                         }
 199                         else if (main->Temp == main->StorageType)
 200                         {
 201                                 PARSE_MARK
 202                                 PARSE_KEYWORD(OpenParenthesis)
 203                                 PARSE_MARK
 204                                 PARSE_IDENTIFIER(Temp)
 205                                 if (main->Temp != main->CppType)
 206                                         PARSE_FAIL
 207                                 PARSE_MARK
 208                                 PARSE_KEYWORD(CloseParenthesis)
 209                                 PARSE_MARK
 210                                 PARSE_NODE(CppCode, ToStorageType)
 211                                 PARSE_MARK
 212                         }
 213                         else
 214                                 PARSE_FAIL
 215
 216                         if (tokenizer.current() != TokenCloseBrace)
 217                         {
 218                                 PARSE_IDENTIFIER(Temp)
 219                                 PARSE_MARK
 220                                 if (main->Temp == main->CppType && main->ToCppType == NULL)
 221                                 {
 222                                         PARSE_MARK
 223                                         PARSE_KEYWORD(OpenParenthesis)
 224                                         PARSE_MARK
 225                                         PARSE_IDENTIFIER(Temp)
 226                                         if (main->Temp != main->StorageType)
 227                                                 PARSE_FAIL
 228                                         PARSE_MARK
 229                                         PARSE_KEYWORD(CloseParenthesis)
 230                                         PARSE_MARK
 231                                         PARSE_NODE(CppCode, ToCppType)
 232                                         PARSE_MARK
 233                                 }
 234                                 else if (main->Temp == main->StorageType && main->ToStorageType == NULL)
 235                                 {
 236                                         PARSE_MARK
 237                                         PARSE_KEYWORD(OpenParenthesis)
 238                                         PARSE_MARK
 239                                         PARSE_IDENTIFIER(Temp)
 240                                         if (main->Temp != main->CppType)
 241                                                 PARSE_FAIL
 242                                         PARSE_MARK
 243                                         PARSE_KEYWORD(CloseParenthesis)
 244                                         PARSE_MARK
 245                                         PARSE_NODE(CppCode, ToStorageType)
 246                                         PARSE_MARK
 247                                 }
 248                                 else
 249                                         PARSE_FAIL
 250                         }
 251
 252                         PARSE_KEYWORD(CloseBrace)
 253                 }
 254                 else
 255                 {
 256                         PARSE_KEYWORD(SemiColon)
 257                 }
 258         }
 259         else
 260         {
 261                 PARSE_IDENTIFIER(CppType)
 262                 main->StorageType = main->CppType;
 263                 PARSE_MARK
 264                 PARSE_KEYWORD(SemiColon)
 265         }
 266
 267         PARSE_MARK
 268
 269 PARSE_END
 270
 271
 272 /*
 273  * Class Bloc
 274  */
 275 PARSE_START(Class, CClassNode)
 276
 277         PARSE_OPT_BEFORE(Class)
 278                 PARSE_OPT_IN(Mapped, MappedFlag);
 279                 PARSE_OPT_IN(Derived, DerivatedFlag);
 280         PARSE_END_OPT_BEFORE()
 281
 282         PARSE_KEYWORD(Class)
 283         PARSE_MARK
 284         PARSE_IDENTIFIER(Name)
 285         PARSE_MARK
 286
 287         PARSE_OPT(Colon)
 288                 PARSE_MARK
 289                 PARSE_IDENTIFIER(Inherited)
 290                 PARSE_MARK
 291         PARSE_END_OPT
 292
 293         PARSE_OPT(Key)
 294                 PARSE_MARK
 295                 PARSE_KEYWORD(OpenParenthesis)
 296                 PARSE_MARK
 297                 PARSE_IDENTIFIER(ClassKey)
 298                 PARSE_MARK
 299                 PARSE_KEYWORD(CloseParenthesis)
 300                 PARSE_MARK
 301         PARSE_END_OPT
 302
 303         PARSE_OPT(Implements)
 304                 PARSE_MARK
 305                 PARSE_IDENTIFIER(Implements)
 306                 PARSE_MARK
 307         PARSE_END_OPT
 308
 309         PARSE_OPT(Reserve)
 310                 PARSE_MARK
 311                 PARSE_KEYWORD(OpenParenthesis)
 312                 PARSE_MARK
 313                 PARSE_IDENTIFIER(Reserve)
 314                 PARSE_MARK
 315                 PARSE_KEYWORD(CloseParenthesis)
 316                 PARSE_MARK
 317         PARSE_END_OPT
 318
 319         PARSE_START_BLOC
 320
 321                 PARSE_MARK
 322
 323                 PARSE_ALTERNATIVE(CppCode)
 324                 PARSE_ALTERNATIVE(Declaration)
 325                 PARSE_FAIL
 326
 327                 PARSE_MARK
 328
 329         PARSE_END_BLOC
 330
 331         PARSE_MARK
 332
 333 PARSE_END
 334
 335
 336 /*
 337  * Declaration Bloc
 338  */
 339 PARSE_START(Declaration, CDeclarationNode)
 340
 341         PARSE_OPT_BEFORE_2(Identifier, ScopedIdentifier)
 342                 PARSE_OPT_IN(WriteTrigger, WriteTriggerFlag);
 343                 PARSE_OPT_IN(InitFill, InitFillFlag);
 344                 PARSE_OPT_IN(Parent, ParentFlag);
 345                 PARSE_OPT_IN(Hidden, HiddenFlag);
 346                 PARSE_OPT_IN(Mirrored, MirroredFlag);
 347         PARSE_END_OPT_BEFORE()
 348
 349         if (main->ParentFlag)
 350         {
 351                 PARSE_IDENTIFIER(ParentClass);
 352                 PARSE_MARK
 353                 PARSE_KEYWORD(Colon)
 354                 PARSE_MARK
 355                 PARSE_IDENTIFIER(ParentField);
 356                 PARSE_MARK
 357                 PARSE_IDENTIFIER(Name);
 358                 PARSE_MARK
 359         }
 360         else
 361         {
 362                 PARSE_SCOPE_IDF(Type);
 363                 PARSE_MARK
 364
 365                 PARSE_OPT(Colon)
 366                         PARSE_MARK
 367                         PARSE_IDENTIFIER(ForwardRefAttribute);
 368                         PARSE_MARK
 369                 PARSE_END_OPT
 370
 371                 PARSE_OPT(OpenBracket)
 372                         PARSE_MARK
 373                         PARSE_IDENTIFIER(ArrayIndex);
 374                         PARSE_MARK
 375                         main->ArrayFlag = true;
 376                         PARSE_KEYWORD(CloseBracket)
 377                         PARSE_MARK
 378
 379                         PARSE_IDENTIFIER(Name);
 380                         PARSE_MARK
 381
 382                 PARSE_NEXT_OPT(LessThan)
 383                         main->SetFlag = true;
 384                         PARSE_MARK
 385                         PARSE_KEYWORD(GreaterThan)
 386                         PARSE_MARK
 387
 388                         PARSE_IDENTIFIER(Name);
 389                         PARSE_MARK
 390
 391                 PARSE_LAST_OPT
 392
 393                         PARSE_IDENTIFIER(Name);
 394                         PARSE_MARK
 395
 396                         PARSE_OPT(Equal)
 397                                 //PARSE_VALUE(DefaultValue)
 398                                 PARSE_KEYWORD_IN(CppCode, DefaultValue)
 399                         PARSE_END_OPT
 400
 401                 PARSE_END_OPT
 402         }
 403
 404         if (tokenizer.current() == TokenOpenBrace)
 405         {
 406                 PARSE_START_BLOC
 407                         PARSE_MARK
 408
 409                         CDeclarationNode::CUserCode     UCode;
 410
 411                         PARSE_KEYWORD_IN_TEMP(Identifier, UCode.Event)
 412
 413                         PARSE_OPT_LIST(OpenParenthesis, CloseParenthesis)
 414
 415                                 std::string     UCodeAtom;
 416                                 PARSE_KEYWORD_IN_TEMP(Identifier, UCodeAtom)
 417                                 if (!UCode.CodeSpecializer.empty())
 418                                         UCode.CodeSpecializer += ".";
 419                                 UCode.CodeSpecializer += UCodeAtom;
 420
 421                         PARSE_END_OPT_LIST(CloseParenthesis, Dot)
 422
 423                         PARSE_KEYWORD_IN_TEMP(CppCode, UCode.UserCode)
 424
 425                         main->UserCodes.push_back(UCode);
 426
 427                         PARSE_MARK
 428                 PARSE_END_BLOC
 429         }
 430         else
 431         {
 432                 PARSE_KEYWORD(SemiColon);
 433         }
 434
 435         PARSE_MARK
 436
 437 PARSE_END
 438
 439
 440 /*
 441  * Enum Bloc
 442  */
 443 PARSE_START(Enum, CEnumNode)
 444
 445         PARSE_KEYWORD(Enum)
 446         PARSE_MARK
 447         PARSE_IDENTIFIER(Name)
 448
 449         PARSE_START_LIST(OpenBrace, CloseBrace)
 450
 451                 PARSE_MARK
 452
 453                 PARSE_ALTERNATIVE(EnumRange)
 454                 PARSE_ALTERNATIVE(EnumSimpleValue)
 455                 PARSE_FAIL
 456
 457                 PARSE_MARK
 458
 459         PARSE_END_LIST(CloseBrace, Comma)
 460
 461         PARSE_OPT_KEYWORD_IN(Identifier, EndRange)
 462
 463         PARSE_MARK
 464
 465 PARSE_END
 466
 467 //
 468 PARSE_START(EnumSimpleValue, CEnumSimpleValueNode)
 469
 470         PARSE_LIST_KEYWORDS(Identifier, Names, Or)
 471
 472 PARSE_END
 473
 474 //
 475 PARSE_START(EnumRange, CEnumRangeNode)
 476
 477         PARSE_IDENTIFIER(Name)
 478
 479         PARSE_START_LIST(OpenBrace, CloseBrace)
 480
 481                 PARSE_MARK
 482
 483                 PARSE_ALTERNATIVE(EnumRange)
 484                 PARSE_ALTERNATIVE(EnumSimpleValue)
 485                 PARSE_FAIL
 486
 487                 PARSE_MARK
 488
 489         PARSE_END_LIST(CloseBrace, Comma)
 490         PARSE_MARK
 491
 492         PARSE_OPT_KEYWORD_IN(Identifier, EndRange)
 493
 494         PARSE_MARK
 495
 496 PARSE_END
 497
 498
 499 /*
 500  * Dimension Bloc
 501  */
 502 PARSE_START(Dimension, CDimensionNode)
 503
 504         PARSE_KEYWORD(Dimension)
 505         PARSE_MARK
 506         PARSE_IDENTIFIER(Name)
 507         PARSE_MARK
 508         PARSE_INT(Dimension)
 509         PARSE_MARK
 510         PARSE_KEYWORD(SemiColon);
 511         PARSE_MARK
 512
 513 PARSE_END
 514
 515
 516 /*
 517  * LogMsg Bloc
 518  */
 519 PARSE_START(LogMsg, CLogMsgNode)
 520
 521         PARSE_KEYWORD(LogMsg)
 522         PARSE_MARK
 523         PARSE_IDENTIFIER(Name)
 524         PARSE_MARK
 525
 526         PARSE_KEYWORD(OpenParenthesis)
 527         PARSE_MARK
 528         PARSE_LIST_2_KEYWORDS(Identifier, Identifier, Params, Comma)
 529         PARSE_KEYWORD(CloseParenthesis)
 530         PARSE_MARK
 531
 532         PARSE_KEYWORD(OpenBrace)
 533         PARSE_MARK
 534         PARSE_LIST_KEYWORDS(String, Logs, Comma)
 535         PARSE_MARK
 536
 537         PARSE_KEYWORD(CloseBrace)
 538         PARSE_MARK
 539
 540 PARSE_END
 541
 542 PARSE_START(LogContext, CLogMsgNode)
 543
 544         PARSE_KEYWORD(LogContext)
 545         PARSE_MARK
 546         PARSE_IDENTIFIER(Name)
 547         PARSE_MARK
 548
 549         main->Context = true;
 550
 551         PARSE_KEYWORD(OpenParenthesis)
 552         PARSE_MARK
 553         PARSE_LIST_2_KEYWORDS(Identifier, Identifier, Params, Comma)
 554         PARSE_KEYWORD(CloseParenthesis)
 555         PARSE_MARK
 556
 557         PARSE_KEYWORD(OpenBrace)
 558         PARSE_MARK
 559         PARSE_LIST_KEYWORDS(String, Logs, Comma)
 560         PARSE_MARK
 561
 562         PARSE_KEYWORD(CloseBrace)
 563         PARSE_MARK
 564
 565 PARSE_END
 566