bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/SimanticsDataParser.h

   1 /** \file
   2  *  This C header file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23
   3  *
   4  *     -  From the grammar source file : C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g
   5  *     -                            On : 2010-03-26 13:33:27
   6  *     -                for the parser : SimanticsDataParserParser *
   7  * Editing it, at least manually, is not wise.
   8  *
   9  * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
  10  *
  11  *
  12  * The parser SimanticsDataParser has the callable functions (rules) shown below,
  13  * which will invoke the code for the associated rule in the source grammar
  14  * assuming that the input stream is pointing to a token/text stream that could begin
  15  * this rule.
  16  *
  17  * For instance if you call the first (topmost) rule in a parser grammar, you will
  18  * get the results of a full parse, but calling a rule half way through the grammar will
  19  * allow you to pass part of a full token stream to the parser, such as for syntax checking
  20  * in editors and so on.
  21  *
  22  * The parser entry points are called indirectly (by function pointer to function) via
  23  * a parser context typedef pSimanticsDataParser, which is returned from a call to SimanticsDataParserNew().
  24  *
  25  * The methods in pSimanticsDataParser are  as follows:
  26  *
  27  *  - SimanticsDataParser_typeDefinitions_return      pSimanticsDataParser->typeDefinitions(pSimanticsDataParser)
  28  *  - SimanticsDataParser_typeDefinition_return      pSimanticsDataParser->typeDefinition(pSimanticsDataParser)
  29  *  - SimanticsDataParser_unionType_return      pSimanticsDataParser->unionType(pSimanticsDataParser)
  30  *  - SimanticsDataParser_unionComponent_return      pSimanticsDataParser->unionComponent(pSimanticsDataParser)
  31  *  - SimanticsDataParser_type_return      pSimanticsDataParser->type(pSimanticsDataParser)
  32  *  - SimanticsDataParser_arrayLength_return      pSimanticsDataParser->arrayLength(pSimanticsDataParser)
  33  *  - SimanticsDataParser_basicType_return      pSimanticsDataParser->basicType(pSimanticsDataParser)
  34  *  - SimanticsDataParser_tupleType_return      pSimanticsDataParser->tupleType(pSimanticsDataParser)
  35  *  - SimanticsDataParser_recordType_return      pSimanticsDataParser->recordType(pSimanticsDataParser)
  36  *  - SimanticsDataParser_component_return      pSimanticsDataParser->component(pSimanticsDataParser)
  37  *  - SimanticsDataParser_typeReference_return      pSimanticsDataParser->typeReference(pSimanticsDataParser)
  38  *  - SimanticsDataParser_parameter_return      pSimanticsDataParser->parameter(pSimanticsDataParser)
  39  *  - SimanticsDataParser_parameterValue_return      pSimanticsDataParser->parameterValue(pSimanticsDataParser)
  40  *  - SimanticsDataParser_range_return      pSimanticsDataParser->range(pSimanticsDataParser)
  41  *  - SimanticsDataParser_number_return      pSimanticsDataParser->number(pSimanticsDataParser)
  42  *  - SimanticsDataParser_string_return      pSimanticsDataParser->string(pSimanticsDataParser)
  43  *  - SimanticsDataParser_boolean_return      pSimanticsDataParser->boolean(pSimanticsDataParser)
  44  *  - SimanticsDataParser_valueDefinitions_return      pSimanticsDataParser->valueDefinitions(pSimanticsDataParser)
  45  *  - SimanticsDataParser_valueDefinition_return      pSimanticsDataParser->valueDefinition(pSimanticsDataParser)
  46  *  - SimanticsDataParser_value_return      pSimanticsDataParser->value(pSimanticsDataParser)
  47  *  - SimanticsDataParser_basicValue_return      pSimanticsDataParser->basicValue(pSimanticsDataParser)
  48  *  - SimanticsDataParser_array_return      pSimanticsDataParser->array(pSimanticsDataParser)
  49  *  - SimanticsDataParser_tuple_return      pSimanticsDataParser->tuple(pSimanticsDataParser)
  50  *  - SimanticsDataParser_taggedValue_return      pSimanticsDataParser->taggedValue(pSimanticsDataParser)
  51  *  - SimanticsDataParser_record_return      pSimanticsDataParser->record(pSimanticsDataParser)
  52  *  - SimanticsDataParser_recordAssignment_return      pSimanticsDataParser->recordAssignment(pSimanticsDataParser)
  53  *  - SimanticsDataParser_map_return      pSimanticsDataParser->map(pSimanticsDataParser)
  54  *  - SimanticsDataParser_mapAssignment_return      pSimanticsDataParser->mapAssignment(pSimanticsDataParser)
  55  *
  56  * The return type for any particular rule is of course determined by the source
  57  * grammar file.
  58  */
  59 // [The "BSD licence"]
  60 // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
  61 // http://www.temporal-wave.com
  62 // http://www.linkedin.com/in/jimidle
  63 //
  64 // All rights reserved.
  65 //
  66 // Redistribution and use in source and binary forms, with or without
  67 // modification, are permitted provided that the following conditions
  68 // are met:
  69 // 1. Redistributions of source code must retain the above copyright
  70 //    notice, this list of conditions and the following disclaimer.
  71 // 2. Redistributions in binary form must reproduce the above copyright
  72 //    notice, this list of conditions and the following disclaimer in the
  73 //    documentation and/or other materials provided with the distribution.
  74 // 3. The name of the author may not be used to endorse or promote products
  75 //    derived from this software without specific prior written permission.
  76 //
  77 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  78 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  79 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  80 // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  81 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  82 // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  83 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  84 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  85 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  86 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  87
  88 #ifndef _SimanticsDataParser_H
  89 #define _SimanticsDataParser_H
  90 /* =============================================================================
  91  * Standard antlr3 C runtime definitions
  92  */
  93 #include    <antlr3.h>
  94
  95 /* End of standard antlr 3 runtime definitions
  96  * =============================================================================
  97  */
  98
  99 #ifdef __cplusplus
 100 extern "C" {
 101 #endif
 102
 103 // Forward declare the context typedef so that we can use it before it is
 104 // properly defined. Delegators and delegates (from import statements) are
 105 // interdependent and their context structures contain pointers to each other
 106 // C only allows such things to be declared if you pre-declare the typedef.
 107 //
 108 typedef struct SimanticsDataParser_Ctx_struct SimanticsDataParser, * pSimanticsDataParser;
 109
 110
 111
 112 #ifdef  ANTLR3_WINDOWS
 113 // Disable: Unreferenced parameter,                                                     - Rules with parameters that are not used
 114 //          constant conditional,                                                       - ANTLR realizes that a prediction is always true (synpred usually)
 115 //          initialized but unused variable                                     - tree rewrite variables declared but not needed
 116 //          Unreferenced local variable                                         - lexer rule declares but does not always use _type
 117 //          potentially unitialized variable used                       - retval always returned from a rule
 118 //                      unreferenced local function has been removed    - susually getTokenNames or freeScope, they can go without warnigns
 119 //
 120 // These are only really displayed at warning level /W4 but that is the code ideal I am aiming at
 121 // and the codegen must generate some of these warnings by necessity, apart from 4100, which is
 122 // usually generated when a parser rule is given a parameter that it does not use. Mostly though
 123 // this is a matter of orthogonality hence I disable that one.
 124 //
 125 #pragma warning( disable : 4100 )
 126 #pragma warning( disable : 4101 )
 127 #pragma warning( disable : 4127 )
 128 #pragma warning( disable : 4189 )
 129 #pragma warning( disable : 4505 )
 130 #pragma warning( disable : 4701 )
 131 #endif
 132 typedef struct SimanticsDataParser_typeDefinitions_return_struct
 133 {
 134     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 135      */
 136     pANTLR3_COMMON_TOKEN    start;
 137     pANTLR3_COMMON_TOKEN    stop;
 138     pANTLR3_BASE_TREE   tree;
 139
 140 }
 141     SimanticsDataParser_typeDefinitions_return;
 142
 143 typedef struct SimanticsDataParser_typeDefinition_return_struct
 144 {
 145     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 146      */
 147     pANTLR3_COMMON_TOKEN    start;
 148     pANTLR3_COMMON_TOKEN    stop;
 149     pANTLR3_BASE_TREE   tree;
 150
 151 }
 152     SimanticsDataParser_typeDefinition_return;
 153
 154 typedef struct SimanticsDataParser_unionType_return_struct
 155 {
 156     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 157      */
 158     pANTLR3_COMMON_TOKEN    start;
 159     pANTLR3_COMMON_TOKEN    stop;
 160     pANTLR3_BASE_TREE   tree;
 161
 162 }
 163     SimanticsDataParser_unionType_return;
 164
 165 typedef struct SimanticsDataParser_unionComponent_return_struct
 166 {
 167     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 168      */
 169     pANTLR3_COMMON_TOKEN    start;
 170     pANTLR3_COMMON_TOKEN    stop;
 171     pANTLR3_BASE_TREE   tree;
 172
 173 }
 174     SimanticsDataParser_unionComponent_return;
 175
 176 typedef struct SimanticsDataParser_type_return_struct
 177 {
 178     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 179      */
 180     pANTLR3_COMMON_TOKEN    start;
 181     pANTLR3_COMMON_TOKEN    stop;
 182     pANTLR3_BASE_TREE   tree;
 183
 184 }
 185     SimanticsDataParser_type_return;
 186
 187 typedef struct SimanticsDataParser_arrayLength_return_struct
 188 {
 189     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 190      */
 191     pANTLR3_COMMON_TOKEN    start;
 192     pANTLR3_COMMON_TOKEN    stop;
 193     pANTLR3_BASE_TREE   tree;
 194
 195 }
 196     SimanticsDataParser_arrayLength_return;
 197
 198 typedef struct SimanticsDataParser_basicType_return_struct
 199 {
 200     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 201      */
 202     pANTLR3_COMMON_TOKEN    start;
 203     pANTLR3_COMMON_TOKEN    stop;
 204     pANTLR3_BASE_TREE   tree;
 205
 206 }
 207     SimanticsDataParser_basicType_return;
 208
 209 typedef struct SimanticsDataParser_tupleType_return_struct
 210 {
 211     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 212      */
 213     pANTLR3_COMMON_TOKEN    start;
 214     pANTLR3_COMMON_TOKEN    stop;
 215     pANTLR3_BASE_TREE   tree;
 216
 217 }
 218     SimanticsDataParser_tupleType_return;
 219
 220 typedef struct SimanticsDataParser_recordType_return_struct
 221 {
 222     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 223      */
 224     pANTLR3_COMMON_TOKEN    start;
 225     pANTLR3_COMMON_TOKEN    stop;
 226     pANTLR3_BASE_TREE   tree;
 227
 228 }
 229     SimanticsDataParser_recordType_return;
 230
 231 typedef struct SimanticsDataParser_component_return_struct
 232 {
 233     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 234      */
 235     pANTLR3_COMMON_TOKEN    start;
 236     pANTLR3_COMMON_TOKEN    stop;
 237     pANTLR3_BASE_TREE   tree;
 238
 239 }
 240     SimanticsDataParser_component_return;
 241
 242 typedef struct SimanticsDataParser_typeReference_return_struct
 243 {
 244     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 245      */
 246     pANTLR3_COMMON_TOKEN    start;
 247     pANTLR3_COMMON_TOKEN    stop;
 248     pANTLR3_BASE_TREE   tree;
 249
 250 }
 251     SimanticsDataParser_typeReference_return;
 252
 253 typedef struct SimanticsDataParser_parameter_return_struct
 254 {
 255     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 256      */
 257     pANTLR3_COMMON_TOKEN    start;
 258     pANTLR3_COMMON_TOKEN    stop;
 259     pANTLR3_BASE_TREE   tree;
 260
 261 }
 262     SimanticsDataParser_parameter_return;
 263
 264 typedef struct SimanticsDataParser_parameterValue_return_struct
 265 {
 266     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 267      */
 268     pANTLR3_COMMON_TOKEN    start;
 269     pANTLR3_COMMON_TOKEN    stop;
 270     pANTLR3_BASE_TREE   tree;
 271
 272 }
 273     SimanticsDataParser_parameterValue_return;
 274
 275 typedef struct SimanticsDataParser_range_return_struct
 276 {
 277     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 278      */
 279     pANTLR3_COMMON_TOKEN    start;
 280     pANTLR3_COMMON_TOKEN    stop;
 281     pANTLR3_BASE_TREE   tree;
 282
 283 }
 284     SimanticsDataParser_range_return;
 285
 286 typedef struct SimanticsDataParser_number_return_struct
 287 {
 288     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 289      */
 290     pANTLR3_COMMON_TOKEN    start;
 291     pANTLR3_COMMON_TOKEN    stop;
 292     pANTLR3_BASE_TREE   tree;
 293
 294 }
 295     SimanticsDataParser_number_return;
 296
 297 typedef struct SimanticsDataParser_string_return_struct
 298 {
 299     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 300      */
 301     pANTLR3_COMMON_TOKEN    start;
 302     pANTLR3_COMMON_TOKEN    stop;
 303     pANTLR3_BASE_TREE   tree;
 304
 305 }
 306     SimanticsDataParser_string_return;
 307
 308 typedef struct SimanticsDataParser_boolean_return_struct
 309 {
 310     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 311      */
 312     pANTLR3_COMMON_TOKEN    start;
 313     pANTLR3_COMMON_TOKEN    stop;
 314     pANTLR3_BASE_TREE   tree;
 315
 316 }
 317     SimanticsDataParser_boolean_return;
 318
 319 typedef struct SimanticsDataParser_valueDefinitions_return_struct
 320 {
 321     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 322      */
 323     pANTLR3_COMMON_TOKEN    start;
 324     pANTLR3_COMMON_TOKEN    stop;
 325     pANTLR3_BASE_TREE   tree;
 326
 327 }
 328     SimanticsDataParser_valueDefinitions_return;
 329
 330 typedef struct SimanticsDataParser_valueDefinition_return_struct
 331 {
 332     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 333      */
 334     pANTLR3_COMMON_TOKEN    start;
 335     pANTLR3_COMMON_TOKEN    stop;
 336     pANTLR3_BASE_TREE   tree;
 337
 338 }
 339     SimanticsDataParser_valueDefinition_return;
 340
 341 typedef struct SimanticsDataParser_value_return_struct
 342 {
 343     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 344      */
 345     pANTLR3_COMMON_TOKEN    start;
 346     pANTLR3_COMMON_TOKEN    stop;
 347     pANTLR3_BASE_TREE   tree;
 348
 349 }
 350     SimanticsDataParser_value_return;
 351
 352 typedef struct SimanticsDataParser_basicValue_return_struct
 353 {
 354     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 355      */
 356     pANTLR3_COMMON_TOKEN    start;
 357     pANTLR3_COMMON_TOKEN    stop;
 358     pANTLR3_BASE_TREE   tree;
 359
 360 }
 361     SimanticsDataParser_basicValue_return;
 362
 363 typedef struct SimanticsDataParser_array_return_struct
 364 {
 365     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 366      */
 367     pANTLR3_COMMON_TOKEN    start;
 368     pANTLR3_COMMON_TOKEN    stop;
 369     pANTLR3_BASE_TREE   tree;
 370
 371 }
 372     SimanticsDataParser_array_return;
 373
 374 typedef struct SimanticsDataParser_tuple_return_struct
 375 {
 376     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 377      */
 378     pANTLR3_COMMON_TOKEN    start;
 379     pANTLR3_COMMON_TOKEN    stop;
 380     pANTLR3_BASE_TREE   tree;
 381
 382 }
 383     SimanticsDataParser_tuple_return;
 384
 385 typedef struct SimanticsDataParser_taggedValue_return_struct
 386 {
 387     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 388      */
 389     pANTLR3_COMMON_TOKEN    start;
 390     pANTLR3_COMMON_TOKEN    stop;
 391     pANTLR3_BASE_TREE   tree;
 392
 393 }
 394     SimanticsDataParser_taggedValue_return;
 395
 396 typedef struct SimanticsDataParser_record_return_struct
 397 {
 398     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 399      */
 400     pANTLR3_COMMON_TOKEN    start;
 401     pANTLR3_COMMON_TOKEN    stop;
 402     pANTLR3_BASE_TREE   tree;
 403
 404 }
 405     SimanticsDataParser_record_return;
 406
 407 typedef struct SimanticsDataParser_recordAssignment_return_struct
 408 {
 409     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 410      */
 411     pANTLR3_COMMON_TOKEN    start;
 412     pANTLR3_COMMON_TOKEN    stop;
 413     pANTLR3_BASE_TREE   tree;
 414
 415 }
 416     SimanticsDataParser_recordAssignment_return;
 417
 418 typedef struct SimanticsDataParser_map_return_struct
 419 {
 420     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 421      */
 422     pANTLR3_COMMON_TOKEN    start;
 423     pANTLR3_COMMON_TOKEN    stop;
 424     pANTLR3_BASE_TREE   tree;
 425
 426 }
 427     SimanticsDataParser_map_return;
 428
 429 typedef struct SimanticsDataParser_mapAssignment_return_struct
 430 {
 431     /** Generic return elements for ANTLR3 rules that are not in tree parsers or returning trees
 432      */
 433     pANTLR3_COMMON_TOKEN    start;
 434     pANTLR3_COMMON_TOKEN    stop;
 435     pANTLR3_BASE_TREE   tree;
 436
 437 }
 438     SimanticsDataParser_mapAssignment_return;
 439
 440
 441
 442 /** Context tracking structure for SimanticsDataParser
 443  */
 444 struct SimanticsDataParser_Ctx_struct
 445 {
 446     /** Built in ANTLR3 context tracker contains all the generic elements
 447      *  required for context tracking.
 448      */
 449     pANTLR3_PARSER   pParser;
 450
 451
 452      SimanticsDataParser_typeDefinitions_return (*typeDefinitions)      (struct SimanticsDataParser_Ctx_struct * ctx);
 453      SimanticsDataParser_typeDefinition_return (*typeDefinition)        (struct SimanticsDataParser_Ctx_struct * ctx);
 454      SimanticsDataParser_unionType_return (*unionType)  (struct SimanticsDataParser_Ctx_struct * ctx);
 455      SimanticsDataParser_unionComponent_return (*unionComponent)        (struct SimanticsDataParser_Ctx_struct * ctx);
 456      SimanticsDataParser_type_return (*type)    (struct SimanticsDataParser_Ctx_struct * ctx);
 457      SimanticsDataParser_arrayLength_return (*arrayLength)      (struct SimanticsDataParser_Ctx_struct * ctx);
 458      SimanticsDataParser_basicType_return (*basicType)  (struct SimanticsDataParser_Ctx_struct * ctx);
 459      SimanticsDataParser_tupleType_return (*tupleType)  (struct SimanticsDataParser_Ctx_struct * ctx);
 460      SimanticsDataParser_recordType_return (*recordType)        (struct SimanticsDataParser_Ctx_struct * ctx);
 461      SimanticsDataParser_component_return (*component)  (struct SimanticsDataParser_Ctx_struct * ctx);
 462      SimanticsDataParser_typeReference_return (*typeReference)  (struct SimanticsDataParser_Ctx_struct * ctx);
 463      SimanticsDataParser_parameter_return (*parameter)  (struct SimanticsDataParser_Ctx_struct * ctx);
 464      SimanticsDataParser_parameterValue_return (*parameterValue)        (struct SimanticsDataParser_Ctx_struct * ctx);
 465      SimanticsDataParser_range_return (*range)  (struct SimanticsDataParser_Ctx_struct * ctx);
 466      SimanticsDataParser_number_return (*number)        (struct SimanticsDataParser_Ctx_struct * ctx);
 467      SimanticsDataParser_string_return (*string)        (struct SimanticsDataParser_Ctx_struct * ctx);
 468      SimanticsDataParser_boolean_return (*boolean)      (struct SimanticsDataParser_Ctx_struct * ctx);
 469      SimanticsDataParser_valueDefinitions_return (*valueDefinitions)    (struct SimanticsDataParser_Ctx_struct * ctx);
 470      SimanticsDataParser_valueDefinition_return (*valueDefinition)      (struct SimanticsDataParser_Ctx_struct * ctx);
 471      SimanticsDataParser_value_return (*value)  (struct SimanticsDataParser_Ctx_struct * ctx);
 472      SimanticsDataParser_basicValue_return (*basicValue)        (struct SimanticsDataParser_Ctx_struct * ctx);
 473      SimanticsDataParser_array_return (*array)  (struct SimanticsDataParser_Ctx_struct * ctx);
 474      SimanticsDataParser_tuple_return (*tuple)  (struct SimanticsDataParser_Ctx_struct * ctx);
 475      SimanticsDataParser_taggedValue_return (*taggedValue)      (struct SimanticsDataParser_Ctx_struct * ctx);
 476      SimanticsDataParser_record_return (*record)        (struct SimanticsDataParser_Ctx_struct * ctx);
 477      SimanticsDataParser_recordAssignment_return (*recordAssignment)    (struct SimanticsDataParser_Ctx_struct * ctx);
 478      SimanticsDataParser_map_return (*map)      (struct SimanticsDataParser_Ctx_struct * ctx);
 479      SimanticsDataParser_mapAssignment_return (*mapAssignment)  (struct SimanticsDataParser_Ctx_struct * ctx);
 480     // Delegated rules
 481     const char * (*getGrammarFileName)();
 482     void            (*free)   (struct SimanticsDataParser_Ctx_struct * ctx);
 483     /* @headerFile.members() */
 484     pANTLR3_BASE_TREE_ADAPTOR   adaptor;
 485     pANTLR3_VECTOR_FACTORY              vectors;
 486     /* End @headerFile.members() */
 487 };
 488
 489 // Function protoypes for the constructor functions that external translation units
 490 // such as delegators and delegates may wish to call.
 491 //
 492 ANTLR3_API pSimanticsDataParser SimanticsDataParserNew         (pANTLR3_COMMON_TOKEN_STREAM instream);
 493 ANTLR3_API pSimanticsDataParser SimanticsDataParserNewSSD      (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state);
 494
 495 /** Symbolic definitions of all the tokens that the parser will work with.
 496  * \{
 497  *
 498  * Antlr will define EOF, but we can't use that as it it is too common in
 499  * in C header files and that would be confusing. There is no way to filter this out at the moment
 500  * so we just undef it here for now. That isn't the value we get back from C recognizers
 501  * anyway. We are looking for ANTLR3_TOKEN_EOF.
 502  */
 503 #ifdef  EOF
 504 #undef  EOF
 505 #endif
 506 #ifdef  Tokens
 507 #undef  Tokens
 508 #endif
 509 #define RECORD_TYPE      7
 510 #define EXPONENT      25
 511 #define TUPLE_TYPE      8
 512 #define VALUE_DEFINITION      14
 513 #define OCTAL_ESC      33
 514 #define ARRAY_TYPE      9
 515 #define FLOAT      26
 516 #define ID      23
 517 #define EOF      -1
 518 #define TUPLE      18
 519 #define ESC_SEQ      29
 520 #define UNION_TYPE      6
 521 #define TYPE_REFERENCE      10
 522 #define TYPE_COMPONENT      12
 523 #define COMMENT      27
 524 #define TYPE_ANNOTATION      11
 525 #define ARRAY      17
 526 #define T__42      42
 527 #define T__43      43
 528 #define T__40      40
 529 #define T__41      41
 530 #define RECORD      20
 531 #define T__46      46
 532 #define T__47      47
 533 #define T__44      44
 534 #define T__45      45
 535 #define TAGGED_VALUE      19
 536 #define T__48      48
 537 #define T__49      49
 538 #define VALUE_DEFINITIONS      13
 539 #define UNICODE_ESC      32
 540 #define HEX_DIGIT      31
 541 #define INT      24
 542 #define VARIANT      16
 543 #define WS      28
 544 #define T__34      34
 545 #define TYPE_DEFINITIONS      4
 546 #define T__35      35
 547 #define T__36      36
 548 #define T__37      37
 549 #define T__38      38
 550 #define T__39      39
 551 #define MAP      21
 552 #define TYPE_DEFINITION      5
 553 #define ASSIGNMENT      22
 554 #define NO_VALUE      15
 555 #define STRING      30
 556 #ifdef  EOF
 557 #undef  EOF
 558 #define EOF     ANTLR3_TOKEN_EOF
 559 #endif
 560
 561 #ifndef TOKENSOURCE
 562 #define TOKENSOURCE(lxr) lxr->pLexer->rec->state->tokSource
 563 #endif
 564
 565 /* End of token definitions for SimanticsDataParser
 566  * =============================================================================
 567  */
 568 /** \} */
 569
 570 #ifdef __cplusplus
 571 }
 572 #endif
 573
 574 #endif
 575
 576 /* END - Note:Keep extra line feed to satisfy UNIX systems */