bundles/org.simantics.databoard/src/org/simantics/databoard/parser/DataParser.java

   1 /* DataParser.java */
   2 /* Generated By:JavaCC: Do not edit this line. DataParser.java */
   3 package org.simantics.databoard.parser;
   4
   5 import org.simantics.databoard.parser.ast.type.*;
   6 import org.simantics.databoard.parser.ast.value.*;
   7 import java.util.ArrayList;
   8 import java.util.List;
   9 import java.util.Collections;
  10
  11 /**
  12  * Parser for data type definitions.
  13  * @author Hannu Niemist�
  14  */
  15 public class DataParser implements DataParserConstants {
  16
  17 /*** Type parser ***************************************************/
  18   final public
  19 List<AstTypeDefinition> typeDefinitions() throws ParseException {AstTypeDefinition def;
  20     List<AstTypeDefinition> result = new ArrayList<AstTypeDefinition>();
  21     label_1:
  22     while (true) {
  23       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
  24       case 21:{
  25         ;
  26         break;
  27         }
  28       default:
  29         jj_la1[0] = jj_gen;
  30         break label_1;
  31       }
  32       def = typeDefinition();
  33 result.add(def);
  34     }
  35     jj_consume_token(0);
  36 {if ("" != null) return result;}
  37     throw new Error("Missing return statement in function");
  38   }
  39
  40   final public AstTypeDefinition typeDefinition() throws ParseException {Token name;
  41     AstType type;
  42     jj_consume_token(21);
  43     name = jj_consume_token(IDENT);
  44     jj_consume_token(18);
  45     type = type();
  46 {if ("" != null) return new AstTypeDefinition(name.image, type);}
  47     throw new Error("Missing return statement in function");
  48   }
  49
  50   final public AstType type() throws ParseException {AstType type;
  51     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
  52     case 5:
  53     case 10:
  54     case 26:
  55     case IDENT:{
  56       type = simpleType();
  57 {if ("" != null) return type;}
  58       break;
  59       }
  60     case 12:{
  61       type = unionType();
  62 {if ("" != null) return type;}
  63       break;
  64       }
  65     default:
  66       jj_la1[1] = jj_gen;
  67       jj_consume_token(-1);
  68       throw new ParseException();
  69     }
  70     throw new Error("Missing return statement in function");
  71   }
  72
  73   final public AstType unionType() throws ParseException {List<AstComponent> components = new ArrayList<AstComponent>(4);
  74     label_2:
  75     while (true) {
  76       jj_consume_token(12);
  77       unionComponent(components);
  78       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
  79       case 12:{
  80         ;
  81         break;
  82         }
  83       default:
  84         jj_la1[2] = jj_gen;
  85         break label_2;
  86       }
  87     }
  88 {if ("" != null) return new AstUnionType(components);}
  89     throw new Error("Missing return statement in function");
  90   }
  91
  92   final private void unionComponent(List<AstComponent> components) throws ParseException {Token tag;
  93     AstType type;
  94     tag = jj_consume_token(IDENT);
  95     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
  96     case 5:
  97     case 10:
  98     case 26:
  99     case IDENT:{
 100       type = simpleType();
 101 components.add(new AstComponent(tag.image, type));
 102       break;
 103       }
 104     default:
 105       jj_la1[3] = jj_gen;
 106 components.add(new AstComponent(tag.image, AstRecordType.EMPTY_RECORD));
 107     }
 108   }
 109
 110   final public AstType simpleType() throws ParseException {AstType type;
 111     type = basicType();
 112     label_3:
 113     while (true) {
 114       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 115       case 8:{
 116         ;
 117         break;
 118         }
 119       default:
 120         jj_la1[4] = jj_gen;
 121         break label_3;
 122       }
 123       jj_consume_token(8);
 124       type = arraySuffix(type);
 125     }
 126 {if ("" != null) return type;}
 127     throw new Error("Missing return statement in function");
 128   }
 129
 130   final private AstType arraySuffix(AstType componentType) throws ParseException {Token t1, t2;
 131     Integer v1;
 132     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 133     case 9:{
 134       jj_consume_token(9);
 135 {if ("" != null) return new AstArrayType(componentType, null, null);}
 136       break;
 137       }
 138     case 16:{
 139       jj_consume_token(16);
 140       t1 = jj_consume_token(INTEGER);
 141       jj_consume_token(9);
 142 v1 = Integer.parseInt(t1.image);
 143         {if ("" != null) return new AstArrayType(componentType, null, v1);}
 144       break;
 145       }
 146     case INTEGER:{
 147       t1 = jj_consume_token(INTEGER);
 148 v1 = Integer.parseInt(t1.image);
 149       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 150       case 9:{
 151         jj_consume_token(9);
 152 {if ("" != null) return new AstArrayType(componentType, v1, v1);}
 153         break;
 154         }
 155       case 16:{
 156         jj_consume_token(16);
 157         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 158         case 9:{
 159           jj_consume_token(9);
 160 {if ("" != null) return new AstArrayType(componentType, v1, null);}
 161           break;
 162           }
 163         case INTEGER:{
 164           t2 = jj_consume_token(INTEGER);
 165           jj_consume_token(9);
 166 {if ("" != null) return new AstArrayType(componentType, v1, Integer.parseInt(t2.image));}
 167           break;
 168           }
 169         default:
 170           jj_la1[5] = jj_gen;
 171           jj_consume_token(-1);
 172           throw new ParseException();
 173         }
 174         break;
 175         }
 176       default:
 177         jj_la1[6] = jj_gen;
 178         jj_consume_token(-1);
 179         throw new ParseException();
 180       }
 181       break;
 182       }
 183     default:
 184       jj_la1[7] = jj_gen;
 185       jj_consume_token(-1);
 186       throw new ParseException();
 187     }
 188     throw new Error("Missing return statement in function");
 189   }
 190
 191   final public AstType basicType() throws ParseException {AstType type;
 192     boolean referable = false;
 193     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 194     case 5:{
 195       jj_consume_token(5);
 196       type = tupleType();
 197       jj_consume_token(6);
 198 {if ("" != null) return type;}
 199       break;
 200       }
 201     case 10:
 202     case 26:{
 203       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 204       case 26:{
 205         jj_consume_token(26);
 206 referable=true;
 207         break;
 208         }
 209       default:
 210         jj_la1[8] = jj_gen;
 211         ;
 212       }
 213       jj_consume_token(10);
 214       type = recordType(referable);
 215       jj_consume_token(11);
 216 {if ("" != null) return type;}
 217       break;
 218       }
 219     case IDENT:{
 220       type = typeReference();
 221 {if ("" != null) return type;}
 222       break;
 223       }
 224     default:
 225       jj_la1[9] = jj_gen;
 226       jj_consume_token(-1);
 227       throw new ParseException();
 228     }
 229     throw new Error("Missing return statement in function");
 230   }
 231
 232   final public AstType typeReference() throws ParseException {Token name;
 233     List<AstType> parameters = Collections.emptyList();
 234     List<AstAttribute> attributes = Collections.emptyList();
 235     name = jj_consume_token(IDENT);
 236     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 237     case 5:{
 238       jj_consume_token(5);
 239 parameters = new ArrayList<AstType>(2);
 240           attributes = new ArrayList<AstAttribute>(2);
 241       parameter(parameters, attributes);
 242       label_4:
 243       while (true) {
 244         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 245         case 15:{
 246           ;
 247           break;
 248           }
 249         default:
 250           jj_la1[10] = jj_gen;
 251           break label_4;
 252         }
 253         jj_consume_token(15);
 254         parameter(parameters, attributes);
 255       }
 256       jj_consume_token(6);
 257       break;
 258       }
 259     default:
 260       jj_la1[11] = jj_gen;
 261       ;
 262     }
 263 {if ("" != null) return new AstTypeReference(name.image, parameters, attributes);}
 264     throw new Error("Missing return statement in function");
 265   }
 266
 267   final private void parameter(List<AstType> parameters, List<AstAttribute> attributes) throws ParseException {Token key;
 268     String value;
 269     AstType type;
 270     if (jj_2_1(2147483647)) {
 271       key = jj_consume_token(IDENT);
 272       jj_consume_token(18);
 273       value = attributeValue();
 274 attributes.add(new AstAttribute(key.image, value));
 275     } else {
 276       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 277       case 5:
 278       case 10:
 279       case 12:
 280       case 26:
 281       case IDENT:{
 282         type = type();
 283 parameters.add(type);
 284         break;
 285         }
 286       default:
 287         jj_la1[12] = jj_gen;
 288         jj_consume_token(-1);
 289         throw new ParseException();
 290       }
 291     }
 292   }
 293
 294   final public String numericValue() throws ParseException {
 295     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 296     case INTEGER:
 297     case FLOAT:{
 298       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 299       case INTEGER:{
 300         jj_consume_token(INTEGER);
 301         break;
 302         }
 303       case FLOAT:{
 304         jj_consume_token(FLOAT);
 305         break;
 306         }
 307       default:
 308         jj_la1[13] = jj_gen;
 309         jj_consume_token(-1);
 310         throw new ParseException();
 311       }
 312 {if ("" != null) return token.image;}
 313       break;
 314       }
 315     case 34:{
 316       jj_consume_token(34);
 317       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 318       case INTEGER:{
 319         jj_consume_token(INTEGER);
 320         break;
 321         }
 322       case FLOAT:{
 323         jj_consume_token(FLOAT);
 324         break;
 325         }
 326       default:
 327         jj_la1[14] = jj_gen;
 328         jj_consume_token(-1);
 329         throw new ParseException();
 330       }
 331 {if ("" != null) return "-" + token.image;}
 332       break;
 333       }
 334     default:
 335       jj_la1[15] = jj_gen;
 336       jj_consume_token(-1);
 337       throw new ParseException();
 338     }
 339     throw new Error("Missing return statement in function");
 340   }
 341
 342   final public String range() throws ParseException {Token open, close;
 343   String first = "", second = "";
 344     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 345     case 8:{
 346       jj_consume_token(8);
 347       break;
 348       }
 349     case 5:{
 350       jj_consume_token(5);
 351       break;
 352       }
 353     default:
 354       jj_la1[16] = jj_gen;
 355       jj_consume_token(-1);
 356       throw new ParseException();
 357     }
 358 open = token;
 359     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 360     case INTEGER:
 361     case FLOAT:
 362     case 34:{
 363       first = numericValue();
 364       break;
 365       }
 366     default:
 367       jj_la1[17] = jj_gen;
 368       ;
 369     }
 370     jj_consume_token(16);
 371     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 372     case INTEGER:
 373     case FLOAT:
 374     case 34:{
 375       second = numericValue();
 376       break;
 377       }
 378     default:
 379       jj_la1[18] = jj_gen;
 380       ;
 381     }
 382     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 383     case 9:{
 384       jj_consume_token(9);
 385       break;
 386       }
 387     case 6:{
 388       jj_consume_token(6);
 389       break;
 390       }
 391     default:
 392       jj_la1[19] = jj_gen;
 393       jj_consume_token(-1);
 394       throw new ParseException();
 395     }
 396 close = token;
 397 {if ("" != null) return open.image + first + ".." + second + close.image;}
 398     throw new Error("Missing return statement in function");
 399   }
 400
 401   final public String attributeValue() throws ParseException {String str;
 402     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 403     case 22:
 404     case 23:
 405     case STRING:{
 406       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 407       case STRING:{
 408         jj_consume_token(STRING);
 409         break;
 410         }
 411       case 22:{
 412         jj_consume_token(22);
 413         break;
 414         }
 415       case 23:{
 416         jj_consume_token(23);
 417         break;
 418         }
 419       default:
 420         jj_la1[20] = jj_gen;
 421         jj_consume_token(-1);
 422         throw new ParseException();
 423       }
 424 {if ("" != null) return token.image;}
 425       break;
 426       }
 427     case INTEGER:
 428     case FLOAT:
 429     case 34:{
 430       str = numericValue();
 431 {if ("" != null) return str;}
 432       break;
 433       }
 434     case 5:
 435     case 8:{
 436       str = range();
 437 {if ("" != null) return str;}
 438       break;
 439       }
 440     default:
 441       jj_la1[21] = jj_gen;
 442       jj_consume_token(-1);
 443       throw new ParseException();
 444     }
 445     throw new Error("Missing return statement in function");
 446   }
 447
 448   final public AstType tupleType() throws ParseException {AstType type;
 449   ArrayList<AstType> types;
 450     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 451     case 5:
 452     case 10:
 453     case 12:
 454     case 26:
 455     case IDENT:{
 456       type = type();
 457 types = new ArrayList<AstType>(3); types.add(type);
 458       label_5:
 459       while (true) {
 460         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 461         case 15:{
 462           ;
 463           break;
 464           }
 465         default:
 466           jj_la1[22] = jj_gen;
 467           break label_5;
 468         }
 469         jj_consume_token(15);
 470         type = type();
 471 types.add(type);
 472       }
 473 if(types.size()==1)
 474             {if ("" != null) return types.get(0);}
 475         else
 476             {if ("" != null) return new AstTupleType(types);}
 477       break;
 478       }
 479     default:
 480       jj_la1[23] = jj_gen;
 481 {if ("" != null) return new AstTupleType(Collections.<AstType>emptyList());}
 482     }
 483     throw new Error("Missing return statement in function");
 484   }
 485
 486   final public AstType recordType(boolean referable) throws ParseException {AstComponent component;
 487     ArrayList<AstComponent> components;
 488     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 489     case 21:
 490     case 26:
 491     case IDENT:{
 492       component = component();
 493 components = new ArrayList<AstComponent>(3); components.add(component);
 494       label_6:
 495       while (true) {
 496         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 497         case 15:{
 498           ;
 499           break;
 500           }
 501         default:
 502           jj_la1[24] = jj_gen;
 503           break label_6;
 504         }
 505         jj_consume_token(15);
 506         component = component();
 507 components.add(component);
 508       }
 509 {if ("" != null) return new AstRecordType(referable, components);}
 510       break;
 511       }
 512     default:
 513       jj_la1[25] = jj_gen;
 514 {if ("" != null) return new AstRecordType(referable, Collections.<AstComponent>emptyList());}
 515     }
 516     throw new Error("Missing return statement in function");
 517   }
 518
 519   final public AstComponent component() throws ParseException {Token field;
 520     AstType type;
 521     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 522     case IDENT:{
 523       field = jj_consume_token(IDENT);
 524       break;
 525       }
 526     case 21:{
 527       field = jj_consume_token(21);
 528       break;
 529       }
 530     case 26:{
 531       field = jj_consume_token(26);
 532       break;
 533       }
 534     default:
 535       jj_la1[26] = jj_gen;
 536       jj_consume_token(-1);
 537       throw new ParseException();
 538     }
 539     jj_consume_token(14);
 540     type = type();
 541 {if ("" != null) return new AstComponent(field.image, type);}
 542     throw new Error("Missing return statement in function");
 543   }
 544
 545 /*** Value parser **************************************************/
 546   final public
 547 List<AstValueDefinition> valueDefinitions() throws ParseException {AstValueDefinition def;
 548     List<AstValueDefinition> result = new ArrayList<AstValueDefinition>();
 549     label_7:
 550     while (true) {
 551       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 552       case IDENT:{
 553         ;
 554         break;
 555         }
 556       default:
 557         jj_la1[27] = jj_gen;
 558         break label_7;
 559       }
 560       def = valueDefinition();
 561 result.add(def);
 562     }
 563     jj_consume_token(0);
 564 {if ("" != null) return result;}
 565     throw new Error("Missing return statement in function");
 566   }
 567
 568   final public AstValueDefinition valueDefinition() throws ParseException {Token name;
 569     AstValue value;
 570     AstType type;
 571     name = jj_consume_token(IDENT);
 572     jj_consume_token(14);
 573     type = type();
 574     jj_consume_token(18);
 575     value = value();
 576 {if ("" != null) return new AstValueDefinition(name.image, type, value);}
 577     throw new Error("Missing return statement in function");
 578   }
 579
 580   final public AstValue value() throws ParseException {AstValue value;
 581     AstType type;
 582     value = basicValue();
 583     label_8:
 584     while (true) {
 585       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 586       case 14:{
 587         ;
 588         break;
 589         }
 590       default:
 591         jj_la1[28] = jj_gen;
 592         break label_8;
 593       }
 594       jj_consume_token(14);
 595       type = type();
 596 value = new AstVariant(value, type);
 597     }
 598 {if ("" != null) return value;}
 599     throw new Error("Missing return statement in function");
 600   }
 601
 602   final public AstValue basicValue() throws ParseException {Token tag;
 603     AstValue temp;
 604     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 605     case 24:{
 606       jj_consume_token(24);
 607 {if ("" != null) return AstNull.NULL;}
 608       break;
 609       }
 610     case STRING:{
 611       jj_consume_token(STRING);
 612 {if ("" != null) return new AstString(token.image);}
 613       break;
 614       }
 615     case LONG_STRING:{
 616       jj_consume_token(LONG_STRING);
 617 {if ("" != null) return new AstString(token.image);}
 618       break;
 619       }
 620     case INTEGER:{
 621       jj_consume_token(INTEGER);
 622 {if ("" != null) return new AstInteger(token.image);}
 623       break;
 624       }
 625     case FLOAT:{
 626       jj_consume_token(FLOAT);
 627 {if ("" != null) return new AstFloat(token.image);}
 628       break;
 629       }
 630     case 22:{
 631       jj_consume_token(22);
 632 {if ("" != null) return AstBoolean.TRUE;}
 633       break;
 634       }
 635     case 23:{
 636       jj_consume_token(23);
 637 {if ("" != null) return AstBoolean.FALSE;}
 638       break;
 639       }
 640     case 25:{
 641       jj_consume_token(25);
 642       jj_consume_token(10);
 643       temp = map();
 644       jj_consume_token(11);
 645 {if ("" != null) return temp;}
 646       break;
 647       }
 648     case 8:{
 649       jj_consume_token(8);
 650       temp = array();
 651       jj_consume_token(9);
 652 {if ("" != null) return temp;}
 653       break;
 654       }
 655     case 10:{
 656       jj_consume_token(10);
 657       temp = record();
 658       jj_consume_token(11);
 659 {if ("" != null) return temp;}
 660       break;
 661       }
 662     case 5:{
 663       jj_consume_token(5);
 664       temp = tuple();
 665       jj_consume_token(6);
 666 {if ("" != null) return temp;}
 667       break;
 668       }
 669     case IDENT:{
 670       tag = jj_consume_token(IDENT);
 671       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 672       case 5:
 673       case 8:
 674       case 10:
 675       case 22:
 676       case 23:
 677       case 24:
 678       case 25:
 679       case STRING:
 680       case LONG_STRING:
 681       case INTEGER:
 682       case FLOAT:
 683       case IDENT:{
 684         temp = basicValue();
 685 {if ("" != null) return new AstTaggedValue(tag.image, temp);}
 686         break;
 687         }
 688       default:
 689         jj_la1[29] = jj_gen;
 690 {if ("" != null) return new AstReference(tag.image);}
 691       }
 692       break;
 693       }
 694     default:
 695       jj_la1[30] = jj_gen;
 696       jj_consume_token(-1);
 697       throw new ParseException();
 698     }
 699     throw new Error("Missing return statement in function");
 700   }
 701
 702   final public AstArray array() throws ParseException {ArrayList<AstValue> components;
 703     AstValue value;
 704     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 705     case 5:
 706     case 8:
 707     case 10:
 708     case 22:
 709     case 23:
 710     case 24:
 711     case 25:
 712     case STRING:
 713     case LONG_STRING:
 714     case INTEGER:
 715     case FLOAT:
 716     case IDENT:{
 717 components = new ArrayList<AstValue>();
 718       value = value();
 719 components.add(value);
 720       label_9:
 721       while (true) {
 722         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 723         case 15:{
 724           ;
 725           break;
 726           }
 727         default:
 728           jj_la1[31] = jj_gen;
 729           break label_9;
 730         }
 731         jj_consume_token(15);
 732         value = value();
 733 components.add(value);
 734       }
 735 {if ("" != null) return new AstArray(components);}
 736       break;
 737       }
 738     default:
 739       jj_la1[32] = jj_gen;
 740 {if ("" != null) return AstArray.EMPTY;}
 741     }
 742     throw new Error("Missing return statement in function");
 743   }
 744
 745   final public AstValue tuple() throws ParseException {ArrayList<AstValue> components;
 746     AstValue value;
 747     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 748     case 5:
 749     case 8:
 750     case 10:
 751     case 22:
 752     case 23:
 753     case 24:
 754     case 25:
 755     case STRING:
 756     case LONG_STRING:
 757     case INTEGER:
 758     case FLOAT:
 759     case IDENT:{
 760 components = new ArrayList<AstValue>();
 761       value = value();
 762 components.add(value);
 763       label_10:
 764       while (true) {
 765         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 766         case 15:{
 767           ;
 768           break;
 769           }
 770         default:
 771           jj_la1[33] = jj_gen;
 772           break label_10;
 773         }
 774         jj_consume_token(15);
 775         value = value();
 776 components.add(value);
 777       }
 778 if(components.size() == 1)
 779             {if ("" != null) return components.get(0);}
 780         else
 781             {if ("" != null) return new AstTuple(components);}
 782       break;
 783       }
 784     default:
 785       jj_la1[34] = jj_gen;
 786 {if ("" != null) return AstTuple.EMPTY;}
 787     }
 788     throw new Error("Missing return statement in function");
 789   }
 790
 791   final public AstRecord record() throws ParseException {ArrayList<AstComponentAssignment> components;
 792     AstComponentAssignment assignment;
 793     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 794     case IDENT:{
 795 components = new ArrayList<AstComponentAssignment>();
 796       assignment = assignment();
 797 components.add(assignment);
 798       label_11:
 799       while (true) {
 800         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 801         case 15:{
 802           ;
 803           break;
 804           }
 805         default:
 806           jj_la1[35] = jj_gen;
 807           break label_11;
 808         }
 809         jj_consume_token(15);
 810         assignment = assignment();
 811 components.add(assignment);
 812       }
 813 {if ("" != null) return new AstRecord(components);}
 814       break;
 815       }
 816     default:
 817       jj_la1[36] = jj_gen;
 818 {if ("" != null) return AstRecord.EMPTY;}
 819     }
 820     throw new Error("Missing return statement in function");
 821   }
 822
 823   final public AstMap map() throws ParseException {ArrayList<AstMapAssignment> components;
 824     AstMapAssignment assignment;
 825     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 826     case 5:
 827     case 8:
 828     case 10:
 829     case 22:
 830     case 23:
 831     case 24:
 832     case 25:
 833     case STRING:
 834     case LONG_STRING:
 835     case INTEGER:
 836     case FLOAT:
 837     case IDENT:{
 838 components = new ArrayList<AstMapAssignment>();
 839       assignment = mapAssignment();
 840 components.add(assignment);
 841       label_12:
 842       while (true) {
 843         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
 844         case 15:{
 845           ;
 846           break;
 847           }
 848         default:
 849           jj_la1[37] = jj_gen;
 850           break label_12;
 851         }
 852         jj_consume_token(15);
 853         assignment = mapAssignment();
 854 components.add(assignment);
 855       }
 856 {if ("" != null) return new AstMap(components);}
 857       break;
 858       }
 859     default:
 860       jj_la1[38] = jj_gen;
 861 {if ("" != null) return AstMap.EMPTY;}
 862     }
 863     throw new Error("Missing return statement in function");
 864   }
 865
 866   final public AstComponentAssignment assignment() throws ParseException {Token name;
 867     AstValue value;
 868     name = jj_consume_token(IDENT);
 869     jj_consume_token(18);
 870     value = value();
 871 {if ("" != null) return new AstComponentAssignment(name.image, value);}
 872     throw new Error("Missing return statement in function");
 873   }
 874
 875   final public AstMapAssignment mapAssignment() throws ParseException {AstValue key;
 876     AstValue value;
 877     key = value();
 878     jj_consume_token(18);
 879     value = value();
 880 {if ("" != null) return new AstMapAssignment(key, value);}
 881     throw new Error("Missing return statement in function");
 882   }
 883
 884   private boolean jj_2_1(int xla)
 885  {
 886     jj_la = xla; jj_lastpos = jj_scanpos = token;
 887     try { return !jj_3_1(); }
 888     catch(LookaheadSuccess ls) { return true; }
 889     finally { jj_save(0, xla); }
 890   }
 891
 892   private boolean jj_3_1()
 893  {
 894     if (jj_scan_token(IDENT)) return true;
 895     if (jj_scan_token(18)) return true;
 896     return false;
 897   }
 898
 899   /** Generated Token Manager. */
 900   public DataParserTokenManager token_source;
 901   SimpleCharStream jj_input_stream;
 902   /** Current token. */
 903   public Token token;
 904   /** Next token. */
 905   public Token jj_nt;
 906   private int jj_ntk;
 907   private Token jj_scanpos, jj_lastpos;
 908   private int jj_la;
 909   private int jj_gen;
 910   final private int[] jj_la1 = new int[39];
 911   static private int[] jj_la1_0;
 912   static private int[] jj_la1_1;
 913   static {
 914       jj_la1_init_0();
 915       jj_la1_init_1();
 916    }
 917    private static void jj_la1_init_0() {
 918       jj_la1_0 = new int[] {0x200000,0x4001420,0x1000,0x4000420,0x100,0x40000200,0x10200,0x40010200,0x4000000,0x4000420,0x8000,0x20,0x4001420,0xc0000000,0xc0000000,0xc0000000,0x120,0xc0000000,0xc0000000,0x240,0x8c00000,0xc8c00120,0x8000,0x4001420,0x8000,0x4200000,0x4200000,0x0,0x4000,0xdbc00520,0xdbc00520,0x8000,0xdbc00520,0x8000,0xdbc00520,0x8000,0x0,0x8000,0xdbc00520,};
 919    }
 920    private static void jj_la1_init_1() {
 921       jj_la1_1 = new int[] {0x0,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x0,0x4,0x0,0x4,0x4,0x0,0x0,0x4,0x0,0x1,0x0,0x1,0x1,0x1,0x0,0x1,0x1,0x0,0x1,0x0,0x1,0x0,0x1,0x0,0x1,};
 922    }
 923   final private JJCalls[] jj_2_rtns = new JJCalls[1];
 924   private boolean jj_rescan = false;
 925   private int jj_gc = 0;
 926
 927   /** Constructor with InputStream. */
 928   public DataParser(java.io.InputStream stream) {
 929      this(stream, null);
 930   }
 931   /** Constructor with InputStream and supplied encoding */
 932   public DataParser(java.io.InputStream stream, String encoding) {
 933     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
 934     token_source = new DataParserTokenManager(jj_input_stream);
 935     token = new Token();
 936     jj_ntk = -1;
 937     jj_gen = 0;
 938     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
 939     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 940   }
 941
 942   /** Reinitialise. */
 943   public void ReInit(java.io.InputStream stream) {
 944      ReInit(stream, null);
 945   }
 946   /** Reinitialise. */
 947   public void ReInit(java.io.InputStream stream, String encoding) {
 948     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
 949     token_source.ReInit(jj_input_stream);
 950     token = new Token();
 951     jj_ntk = -1;
 952     jj_gen = 0;
 953     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
 954     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 955   }
 956
 957   /** Constructor. */
 958   public DataParser(java.io.Reader stream) {
 959     jj_input_stream = new SimpleCharStream(stream, 1, 1);
 960     token_source = new DataParserTokenManager(jj_input_stream);
 961     token = new Token();
 962     jj_ntk = -1;
 963     jj_gen = 0;
 964     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
 965     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 966   }
 967
 968   /** Reinitialise. */
 969   public void ReInit(java.io.Reader stream) {
 970         if (jj_input_stream == null) {
 971       jj_input_stream = new SimpleCharStream(stream, 1, 1);
 972    } else {
 973       jj_input_stream.ReInit(stream, 1, 1);
 974    }
 975    if (token_source == null) {
 976       token_source = new DataParserTokenManager(jj_input_stream);
 977    }
 978
 979     token_source.ReInit(jj_input_stream);
 980     token = new Token();
 981     jj_ntk = -1;
 982     jj_gen = 0;
 983     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
 984     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 985   }
 986
 987   /** Constructor with generated Token Manager. */
 988   public DataParser(DataParserTokenManager tm) {
 989     token_source = tm;
 990     token = new Token();
 991     jj_ntk = -1;
 992     jj_gen = 0;
 993     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
 994     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 995   }
 996
 997   /** Reinitialise. */
 998   public void ReInit(DataParserTokenManager tm) {
 999     token_source = tm;
1000     token = new Token();
1001     jj_ntk = -1;
1002     jj_gen = 0;
1003     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
1004     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1005   }
1006
1007   private Token jj_consume_token(int kind) throws ParseException {
1008     Token oldToken;
1009     if ((oldToken = token).next != null) token = token.next;
1010     else token = token.next = token_source.getNextToken();
1011     jj_ntk = -1;
1012     if (token.kind == kind) {
1013       jj_gen++;
1014       if (++jj_gc > 100) {
1015         jj_gc = 0;
1016         for (int i = 0; i < jj_2_rtns.length; i++) {
1017           JJCalls c = jj_2_rtns[i];
1018           while (c != null) {
1019             if (c.gen < jj_gen) c.first = null;
1020             c = c.next;
1021           }
1022         }
1023       }
1024       return token;
1025     }
1026     token = oldToken;
1027     jj_kind = kind;
1028     throw generateParseException();
1029   }
1030
1031   @SuppressWarnings("serial")
1032   static private final class LookaheadSuccess extends java.lang.Error { }
1033   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
1034   private boolean jj_scan_token(int kind) {
1035     if (jj_scanpos == jj_lastpos) {
1036       jj_la--;
1037       if (jj_scanpos.next == null) {
1038         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
1039       } else {
1040         jj_lastpos = jj_scanpos = jj_scanpos.next;
1041       }
1042     } else {
1043       jj_scanpos = jj_scanpos.next;
1044     }
1045     if (jj_rescan) {
1046       int i = 0; Token tok = token;
1047       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
1048       if (tok != null) jj_add_error_token(kind, i);
1049     }
1050     if (jj_scanpos.kind != kind) return true;
1051     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
1052     return false;
1053   }
1054
1055
1056 /** Get the next Token. */
1057   final public Token getNextToken() {
1058     if (token.next != null) token = token.next;
1059     else token = token.next = token_source.getNextToken();
1060     jj_ntk = -1;
1061     jj_gen++;
1062     return token;
1063   }
1064
1065 /** Get the specific Token. */
1066   final public Token getToken(int index) {
1067     Token t = token;
1068     for (int i = 0; i < index; i++) {
1069       if (t.next != null) t = t.next;
1070       else t = t.next = token_source.getNextToken();
1071     }
1072     return t;
1073   }
1074
1075   private int jj_ntk_f() {
1076     if ((jj_nt=token.next) == null)
1077       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
1078     else
1079       return (jj_ntk = jj_nt.kind);
1080   }
1081
1082   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
1083   private int[] jj_expentry;
1084   private int jj_kind = -1;
1085   private int[] jj_lasttokens = new int[100];
1086   private int jj_endpos;
1087
1088   private void jj_add_error_token(int kind, int pos) {
1089     if (pos >= 100) {
1090        return;
1091     }
1092
1093     if (pos == jj_endpos + 1) {
1094       jj_lasttokens[jj_endpos++] = kind;
1095     } else if (jj_endpos != 0) {
1096       jj_expentry = new int[jj_endpos];
1097
1098       for (int i = 0; i < jj_endpos; i++) {
1099         jj_expentry[i] = jj_lasttokens[i];
1100       }
1101
1102       for (int[] oldentry : jj_expentries) {
1103         if (oldentry.length == jj_expentry.length) {
1104           boolean isMatched = true;
1105
1106           for (int i = 0; i < jj_expentry.length; i++) {
1107             if (oldentry[i] != jj_expentry[i]) {
1108               isMatched = false;
1109               break;
1110             }
1111
1112           }
1113           if (isMatched) {
1114             jj_expentries.add(jj_expentry);
1115             break;
1116           }
1117         }
1118       }
1119
1120       if (pos != 0) {
1121         jj_lasttokens[(jj_endpos = pos) - 1] = kind;
1122       }
1123     }
1124   }
1125
1126   /** Generate ParseException. */
1127   public ParseException generateParseException() {
1128     jj_expentries.clear();
1129     boolean[] la1tokens = new boolean[35];
1130     if (jj_kind >= 0) {
1131       la1tokens[jj_kind] = true;
1132       jj_kind = -1;
1133     }
1134     for (int i = 0; i < 39; i++) {
1135       if (jj_la1[i] == jj_gen) {
1136         for (int j = 0; j < 32; j++) {
1137           if ((jj_la1_0[i] & (1<<j)) != 0) {
1138             la1tokens[j] = true;
1139           }
1140           if ((jj_la1_1[i] & (1<<j)) != 0) {
1141             la1tokens[32+j] = true;
1142           }
1143         }
1144       }
1145     }
1146     for (int i = 0; i < 35; i++) {
1147       if (la1tokens[i]) {
1148         jj_expentry = new int[1];
1149         jj_expentry[0] = i;
1150         jj_expentries.add(jj_expentry);
1151       }
1152     }
1153     jj_endpos = 0;
1154     jj_rescan_token();
1155     jj_add_error_token(0, 0);
1156     int[][] exptokseq = new int[jj_expentries.size()][];
1157     for (int i = 0; i < jj_expentries.size(); i++) {
1158       exptokseq[i] = jj_expentries.get(i);
1159     }
1160     return new ParseException(token, exptokseq, tokenImage);
1161   }
1162
1163   /** Enable tracing. */
1164   final public void enable_tracing() {
1165   }
1166
1167   /** Disable tracing. */
1168   final public void disable_tracing() {
1169   }
1170
1171   private void jj_rescan_token() {
1172     jj_rescan = true;
1173     for (int i = 0; i < 1; i++) {
1174       try {
1175         JJCalls p = jj_2_rtns[i];
1176
1177         do {
1178           if (p.gen > jj_gen) {
1179             jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
1180             switch (i) {
1181               case 0: jj_3_1(); break;
1182             }
1183           }
1184           p = p.next;
1185         } while (p != null);
1186
1187         } catch(LookaheadSuccess ls) { }
1188     }
1189     jj_rescan = false;
1190   }
1191
1192   private void jj_save(int index, int xla) {
1193     JJCalls p = jj_2_rtns[index];
1194     while (p.gen > jj_gen) {
1195       if (p.next == null) { p = p.next = new JJCalls(); break; }
1196       p = p.next;
1197     }
1198
1199     p.gen = jj_gen + xla - jj_la;
1200     p.first = token;
1201     p.arg = xla;
1202   }
1203
1204   static final class JJCalls {
1205     int gen;
1206     Token first;
1207     int arg;
1208     JJCalls next;
1209   }
1210
1211 }