Coverage Report - org.apache.commons.flatfile.dsl.EntityTreeParser
 
Classes in this File Line Coverage Branch Coverage Complexity
EntityTreeParser
92%
444/482
63%
138/219
0
 
 1  
 // $ANTLR 2.7.7 (20060906): "EntityTreeParser.g" -> "EntityTreeParser.java"$
 2  
 
 3  
 package org.apache.commons.flatfile.dsl;
 4  
 
 5  
 import java.io.IOException;
 6  
 
 7  
 import java.util.List;
 8  
 import java.util.Stack;
 9  
 import java.util.Iterator;
 10  
 import java.util.ArrayList;
 11  
 import java.util.HashMap;
 12  
 
 13  
 import org.apache.commons.flatfile.*;
 14  
 import org.apache.commons.flatfile.util.ApplyOptions;
 15  
 
 16  
 import antlr.TreeParser;
 17  
 import antlr.Token;
 18  
 import antlr.collections.AST;
 19  
 import antlr.RecognitionException;
 20  
 import antlr.ANTLRException;
 21  
 import antlr.NoViableAltException;
 22  
 import antlr.MismatchedTokenException;
 23  
 import antlr.SemanticException;
 24  
 import antlr.collections.impl.BitSet;
 25  
 import antlr.ASTPair;
 26  
 import antlr.collections.impl.ASTArray;
 27  
 
 28  
 
 29  
 public class EntityTreeParser extends antlr.TreeParser       implements EntityTreeParserTokenTypes
 30  
  {
 31  
 
 32  
         private java.lang.ref.WeakReference<ParserEntityFactory> entityFactoryRef;
 33  32
         private Stack<String> stk = new Stack<String>();
 34  
 
 35  
         public synchronized Entity createEntity(EntityDefinition def) {
 36  71
                 String name = def.getName();
 37  71
                 if (stk.contains(def.getName())) {
 38  0
                         throw new IllegalStateException("Circular reference detected for entity type " + name);
 39  
                 }
 40  71
                 stk.push(def.getName());
 41  
                 try {
 42  71
                         Entity result = entity(def.getAst());
 43  70
                         runChecks(def, result);
 44  69
                         return result;
 45  0
                 } catch (ANTLRException e) {
 46  0
                         throw new RuntimeException(e);
 47  
                 } finally {
 48  71
                         String x = stk.pop();
 49  71
                         if (!x.equals(def.getName())) {
 50  0
                                 throw new IllegalStateException("Stack out of balance; encountered " + x);
 51  
                         }
 52  71
                 }
 53  
         }
 54  
 
 55  
         public void setEntityFactory(ParserEntityFactory entityFactory) {
 56  32
                 this.entityFactoryRef = new java.lang.ref.WeakReference<ParserEntityFactory>(entityFactory);
 57  32
         }
 58  
 
 59  
         private void runChecks(EntityDefinition def, Entity e) {
 60  70
                 for (AST check : def.getChecks()) {
 61  10
                         switch (check.getType()) {
 62  
                                 case LENGTH :
 63  10
                                         int expected = Integer.parseInt(check.getText());
 64  10
                                         int actual = e.length();
 65  10
                                         if (expected != actual) {
 66  1
                                                 throw new IllegalStateException(
 67  
                                                                 "expected entity " + def.getName() + " length=" + expected + "; actually " + actual);
 68  
                                         }
 69  
                                         break;
 70  
                                 default :
 71  0
                                         throw new IllegalArgumentException("Unknown check: " + check);
 72  
                         }
 73  
                 }
 74  69
         }
 75  
 
 76  
         private byte[] getBytes(String s) {
 77  
                 try {
 78  79
                         return s.getBytes("UTF-8");
 79  0
                 } catch (IOException e) {
 80  0
                         throw new RuntimeException(e);
 81  
                 }
 82  
         }
 83  
 
 84  
         private ParserEntityFactory getEntityFactory() {
 85  423
                 return entityFactoryRef.get();
 86  
         }
 87  32
 public EntityTreeParser() {
 88  32
         tokenNames = _tokenNames;
 89  32
 }
 90  
 
 91  
         public final void load(AST _t) throws RecognitionException {
 92  
                 
 93  32
                 AST load_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 94  32
                 AST e = null;
 95  32
                 AST c = null;
 96  32
                 List<AST> checks = new ArrayList<AST>(); String name = null;
 97  
                 
 98  32
                 AST __t2 = _t;
 99  32
                 AST tmp1_AST_in = (AST)_t;
 100  32
                 match(_t,ROOT);
 101  32
                 _t = _t.getFirstChild();
 102  
                 {
 103  
                 _loop4:
 104  
                 do {
 105  35
                         if (_t==null) _t=ASTNULL;
 106  35
                         if ((_t.getType()==OPTIONS)) {
 107  3
                                 defaultOptions(_t);
 108  3
                                 _t = _retTree;
 109  
                         }
 110  
                         else {
 111  
                                 break _loop4;
 112  
                         }
 113  
                         
 114  
                 } while (true);
 115  
                 }
 116  
                 {
 117  32
                 int _cnt9=0;
 118  
                 _loop9:
 119  
                 do {
 120  305
                         if (_t==null) _t=ASTNULL;
 121  305
                         if ((_t.getType()==ASSIGN)) {
 122  273
                                 AST __t6 = _t;
 123  273
                                 AST tmp2_AST_in = (AST)_t;
 124  273
                                 match(_t,ASSIGN);
 125  273
                                 _t = _t.getFirstChild();
 126  273
                                 name=name(_t);
 127  273
                                 _t = _retTree;
 128  273
                                 e = (AST)_t;
 129  273
                                 if ( _t==null ) throw new MismatchedTokenException();
 130  273
                                 _t = _t.getNextSibling();
 131  273
                                 _t = __t6;
 132  273
                                 _t = _t.getNextSibling();
 133  
                                 {
 134  
                                 _loop8:
 135  
                                 do {
 136  283
                                         if (_t==null) _t=ASTNULL;
 137  283
                                         if ((_t.getType()==CHECK)) {
 138  10
                                                 AST tmp3_AST_in = (AST)_t;
 139  10
                                                 match(_t,CHECK);
 140  10
                                                 _t = _t.getNextSibling();
 141  10
                                                 c = (AST)_t;
 142  10
                                                 if ( _t==null ) throw new MismatchedTokenException();
 143  10
                                                 _t = _t.getNextSibling();
 144  
                                                 
 145  10
                                                                                                 checks.add(c);
 146  
                                                                                         
 147  10
                                         }
 148  
                                         else {
 149  
                                                 break _loop8;
 150  
                                         }
 151  
                                         
 152  
                                 } while (true);
 153  
                                 }
 154  
                                 
 155  273
                                                                         EntityDefinition ed = new EntityDefinition(name, e);
 156  273
                                                                         if (!checks.isEmpty()) {
 157  10
                                                                                 ed.setChecks(new ArrayList<AST>(checks));
 158  10
                                                                                 checks.clear();
 159  
                                                                         }
 160  273
                                                                         getEntityFactory().add(name, ed);
 161  
                                                                 
 162  273
                         }
 163  
                         else {
 164  32
                                 if ( _cnt9>=1 ) { break _loop9; } else {throw new NoViableAltException(_t);}
 165  
                         }
 166  
                         
 167  273
                         _cnt9++;
 168  273
                 } while (true);
 169  
                 }
 170  32
                 _t = __t2;
 171  32
                 _t = _t.getNextSibling();
 172  32
                 _retTree = _t;
 173  32
         }
 174  
         
 175  
         protected final void defaultOptions(AST _t) throws RecognitionException {
 176  
                 
 177  3
                 AST defaultOptions_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 178  3
                 AST o = null;
 179  3
                 HashMap<String, String> m = new HashMap<String, String>(); String key = null, value = null;
 180  
                 
 181  3
                 AST __t11 = _t;
 182  3
                 o = _t==ASTNULL ? null :(AST)_t;
 183  3
                 match(_t,OPTIONS);
 184  3
                 _t = _t.getFirstChild();
 185  
                 {
 186  3
                 int _cnt14=0;
 187  
                 _loop14:
 188  
                 do {
 189  7
                         if (_t==null) _t=ASTNULL;
 190  7
                         if ((_t.getType()==ASSIGN)) {
 191  4
                                 AST __t13 = _t;
 192  4
                                 AST tmp4_AST_in = (AST)_t;
 193  4
                                 match(_t,ASSIGN);
 194  4
                                 _t = _t.getFirstChild();
 195  4
                                 key=optionKV(_t);
 196  4
                                 _t = _retTree;
 197  4
                                 value=optionKV(_t);
 198  4
                                 _t = _retTree;
 199  4
                                 m.put(key, value);
 200  4
                                 _t = __t13;
 201  4
                                 _t = _t.getNextSibling();
 202  4
                         }
 203  
                         else {
 204  3
                                 if ( _cnt14>=1 ) { break _loop14; } else {throw new NoViableAltException(_t);}
 205  
                         }
 206  
                         
 207  4
                         _cnt14++;
 208  4
                 } while (true);
 209  
                 }
 210  3
                 _t = __t11;
 211  3
                 _t = _t.getNextSibling();
 212  3
                 getEntityFactory().setDefaultOptions(o.getText(), m);
 213  3
                 _retTree = _t;
 214  3
         }
 215  
         
 216  
         protected final String  name(AST _t) throws RecognitionException {
 217  378
                 String s = null;
 218  
                 
 219  378
                 AST name_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 220  378
                 AST i = null;
 221  
                 
 222  378
                 if (_t==null) _t=ASTNULL;
 223  378
                 switch ( _t.getType()) {
 224  
                 case IDENT:
 225  
                 {
 226  364
                         i = (AST)_t;
 227  364
                         match(_t,IDENT);
 228  364
                         _t = _t.getNextSibling();
 229  364
                         s = i.getText();
 230  364
                         break;
 231  
                 }
 232  
                 case ANON:
 233  
                 {
 234  14
                         AST tmp5_AST_in = (AST)_t;
 235  14
                         match(_t,ANON);
 236  14
                         _t = _t.getNextSibling();
 237  14
                         break;
 238  
                 }
 239  
                 default:
 240  
                 {
 241  0
                         throw new NoViableAltException(_t);
 242  
                 }
 243  
                 }
 244  378
                 _retTree = _t;
 245  378
                 return s;
 246  
         }
 247  
         
 248  
         protected final String  optionKV(AST _t) throws RecognitionException {
 249  114
                 String result = null;
 250  
                 
 251  114
                 AST optionKV_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 252  114
                 AST c = null;
 253  114
                 AST s = null;
 254  114
                 AST n = null;
 255  114
                 AST i = null;
 256  
                 
 257  114
                 if (_t==null) _t=ASTNULL;
 258  114
                 switch ( _t.getType()) {
 259  
                 case CHAR_LITERAL:
 260  
                 {
 261  14
                         c = (AST)_t;
 262  14
                         match(_t,CHAR_LITERAL);
 263  14
                         _t = _t.getNextSibling();
 264  14
                         result = c.getText();
 265  14
                         break;
 266  
                 }
 267  
                 case STRING_LITERAL:
 268  
                 {
 269  12
                         s = (AST)_t;
 270  12
                         match(_t,STRING_LITERAL);
 271  12
                         _t = _t.getNextSibling();
 272  12
                         result = s.getText();
 273  12
                         break;
 274  
                 }
 275  
                 case NUMBER:
 276  
                 {
 277  0
                         n = (AST)_t;
 278  0
                         match(_t,NUMBER);
 279  0
                         _t = _t.getNextSibling();
 280  0
                         result = n.getText();
 281  0
                         break;
 282  
                 }
 283  
                 case IDENT:
 284  
                 {
 285  88
                         i = (AST)_t;
 286  88
                         match(_t,IDENT);
 287  88
                         _t = _t.getNextSibling();
 288  88
                         result = i.getText();
 289  88
                         break;
 290  
                 }
 291  
                 default:
 292  
                 {
 293  0
                         throw new NoViableAltException(_t);
 294  
                 }
 295  
                 }
 296  114
                 _retTree = _t;
 297  114
                 return result;
 298  
         }
 299  
         
 300  
         protected final Entity  entity(AST _t) throws RecognitionException {
 301  214
                 Entity e = null;
 302  
                 
 303  214
                 AST entity_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 304  
                 
 305  214
                 if (_t==null) _t=ASTNULL;
 306  214
                 switch ( _t.getType()) {
 307  
                 case ARRAY:
 308  
                 {
 309  38
                         e=array(_t);
 310  38
                         _t = _retTree;
 311  38
                         break;
 312  
                 }
 313  
                 case FIELD:
 314  
                 {
 315  128
                         e=field(_t);
 316  127
                         _t = _retTree;
 317  127
                         break;
 318  
                 }
 319  
                 case MAP:
 320  
                 {
 321  29
                         e=map(_t);
 322  29
                         _t = _retTree;
 323  29
                         break;
 324  
                 }
 325  
                 case TYPEREF:
 326  
                 {
 327  19
                         e=typeRef(_t);
 328  19
                         _t = _retTree;
 329  19
                         break;
 330  
                 }
 331  
                 default:
 332  
                 {
 333  0
                         throw new NoViableAltException(_t);
 334  
                 }
 335  
                 }
 336  213
                 _retTree = _t;
 337  213
                 return e;
 338  
         }
 339  
         
 340  
         protected final IndexedEntityCollection  array(AST _t) throws RecognitionException {
 341  38
                 IndexedEntityCollection a = null;
 342  
                 
 343  38
                 AST array_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 344  38
                 AST l = null;
 345  38
                 AST m = null;
 346  38
                 AST n = null;
 347  38
                 Entity prototype = null, e = null; Integer len = null, min = null, max = null;
 348  
                 
 349  38
                 AST __t22 = _t;
 350  38
                 AST tmp6_AST_in = (AST)_t;
 351  38
                 match(_t,ARRAY);
 352  38
                 _t = _t.getFirstChild();
 353  
                 {
 354  38
                 if (_t==null) _t=ASTNULL;
 355  38
                 switch ( _t.getType()) {
 356  
                 case LENGTH:
 357  
                 {
 358  31
                         l = (AST)_t;
 359  31
                         match(_t,LENGTH);
 360  31
                         _t = _t.getNextSibling();
 361  31
                         len = Integer.valueOf(l.getText());
 362  31
                         break;
 363  
                 }
 364  
                 case RANGE:
 365  
                 {
 366  4
                         AST __t24 = _t;
 367  4
                         AST tmp7_AST_in = (AST)_t;
 368  4
                         match(_t,RANGE);
 369  4
                         _t = _t.getFirstChild();
 370  
                         {
 371  4
                         if (_t==null) _t=ASTNULL;
 372  4
                         switch ( _t.getType()) {
 373  
                         case MIN:
 374  
                         {
 375  3
                                 m = (AST)_t;
 376  3
                                 match(_t,MIN);
 377  3
                                 _t = _t.getNextSibling();
 378  3
                                 min = Integer.valueOf(m.getText());
 379  3
                                 break;
 380  
                         }
 381  
                         case 3:
 382  
                         case MAX:
 383  
                         {
 384  1
                                 break;
 385  
                         }
 386  
                         default:
 387  
                         {
 388  0
                                 throw new NoViableAltException(_t);
 389  
                         }
 390  
                         }
 391  
                         }
 392  
                         {
 393  4
                         if (_t==null) _t=ASTNULL;
 394  4
                         switch ( _t.getType()) {
 395  
                         case MAX:
 396  
                         {
 397  3
                                 n = (AST)_t;
 398  3
                                 match(_t,MAX);
 399  3
                                 _t = _t.getNextSibling();
 400  3
                                 max = Integer.valueOf(n.getText());
 401  3
                                 break;
 402  
                         }
 403  
                         case 3:
 404  
                         {
 405  1
                                 break;
 406  
                         }
 407  
                         default:
 408  
                         {
 409  0
                                 throw new NoViableAltException(_t);
 410  
                         }
 411  
                         }
 412  
                         }
 413  4
                         _t = __t24;
 414  4
                         _t = _t.getNextSibling();
 415  4
                         break;
 416  
                 }
 417  
                 case PROTOTYPE:
 418  
                 {
 419  3
                         break;
 420  
                 }
 421  
                 default:
 422  
                 {
 423  0
                         throw new NoViableAltException(_t);
 424  
                 }
 425  
                 }
 426  
                 }
 427  38
                 AST __t27 = _t;
 428  38
                 AST tmp8_AST_in = (AST)_t;
 429  38
                 match(_t,PROTOTYPE);
 430  38
                 _t = _t.getFirstChild();
 431  38
                 prototype=entity(_t);
 432  38
                 _t = _retTree;
 433  38
                 _t = __t27;
 434  38
                 _t = _t.getNextSibling();
 435  38
                         a = new EntityArray(prototype);
 436  38
                                                 if (len != null) {
 437  31
                                                         ((EntityArray) a).setSize(len.intValue());
 438  
                                                 } else {
 439  7
                                                         if (min != null) {
 440  3
                                                                 ((EntityArray) a).setMinimumSize(min.intValue());
 441  
                                                         }
 442  7
                                                         if (max != null) {
 443  3
                                                                 ((EntityArray) a).setMaximumSize(max.intValue());
 444  
                                                         }
 445  
                                                 }
 446  
                                         
 447  
                 {
 448  38
                 if (_t==null) _t=ASTNULL;
 449  38
                 switch ( _t.getType()) {
 450  
                 case OPTIONS:
 451  
                 {
 452  8
                         entityOptions(_t,a);
 453  8
                         _t = _retTree;
 454  8
                         break;
 455  
                 }
 456  
                 case 3:
 457  
                 case VALUE:
 458  
                 case ALL:
 459  
                 {
 460  30
                         break;
 461  
                 }
 462  
                 default:
 463  
                 {
 464  0
                         throw new NoViableAltException(_t);
 465  
                 }
 466  
                 }
 467  
                 }
 468  
                 {
 469  38
                 if (_t==null) _t=ASTNULL;
 470  38
                 switch ( _t.getType()) {
 471  
                 case VALUE:
 472  
                 case ALL:
 473  
                 {
 474  4
                         e=value(_t,a);
 475  4
                         _t = _retTree;
 476  4
                         a = (IndexedEntityCollection) e;
 477  4
                         break;
 478  
                 }
 479  
                 case 3:
 480  
                 {
 481  34
                         break;
 482  
                 }
 483  
                 default:
 484  
                 {
 485  0
                         throw new NoViableAltException(_t);
 486  
                 }
 487  
                 }
 488  
                 }
 489  38
                 _t = __t22;
 490  38
                 _t = _t.getNextSibling();
 491  38
                 _retTree = _t;
 492  38
                 return a;
 493  
         }
 494  
         
 495  
         protected final Entity  field(AST _t) throws RecognitionException {
 496  128
                 Entity e = null;
 497  
                 
 498  128
                 AST field_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 499  
                 
 500  128
                 AST __t34 = _t;
 501  128
                 AST tmp9_AST_in = (AST)_t;
 502  128
                 match(_t,FIELD);
 503  128
                 _t = _t.getFirstChild();
 504  128
                 e=fieldDef(_t);
 505  127
                 _t = _retTree;
 506  127
                 _t = __t34;
 507  127
                 _t = _t.getNextSibling();
 508  127
                 _retTree = _t;
 509  127
                 return e;
 510  
         }
 511  
         
 512  
         protected final NamedEntityCollection  map(AST _t) throws RecognitionException {
 513  29
                 NamedEntityCollection m = new EntityMap();
 514  
                 
 515  29
                 AST map_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 516  29
                 String name = null; Entity temp = null;
 517  
                 
 518  29
                 AST __t45 = _t;
 519  29
                 AST tmp10_AST_in = (AST)_t;
 520  29
                 match(_t,MAP);
 521  29
                 _t = _t.getFirstChild();
 522  
                 {
 523  29
                 int _cnt48=0;
 524  
                 _loop48:
 525  
                 do {
 526  134
                         if (_t==null) _t=ASTNULL;
 527  134
                         if ((_t.getType()==ASSIGN)) {
 528  105
                                 AST __t47 = _t;
 529  105
                                 AST tmp11_AST_in = (AST)_t;
 530  105
                                 match(_t,ASSIGN);
 531  105
                                 _t = _t.getFirstChild();
 532  105
                                 name=name(_t);
 533  105
                                 _t = _retTree;
 534  105
                                 temp=entity(_t);
 535  105
                                 _t = _retTree;
 536  105
                                 ((EntityMap) m).add(name, temp);
 537  105
                                 _t = __t47;
 538  105
                                 _t = _t.getNextSibling();
 539  105
                         }
 540  
                         else {
 541  29
                                 if ( _cnt48>=1 ) { break _loop48; } else {throw new NoViableAltException(_t);}
 542  
                         }
 543  
                         
 544  105
                         _cnt48++;
 545  105
                 } while (true);
 546  
                 }
 547  
                 {
 548  29
                 if (_t==null) _t=ASTNULL;
 549  29
                 switch ( _t.getType()) {
 550  
                 case OPTIONS:
 551  
                 {
 552  7
                         entityOptions(_t,m);
 553  7
                         _t = _retTree;
 554  7
                         break;
 555  
                 }
 556  
                 case 3:
 557  
                 case VALUE:
 558  
                 case ALL:
 559  
                 {
 560  22
                         break;
 561  
                 }
 562  
                 default:
 563  
                 {
 564  0
                         throw new NoViableAltException(_t);
 565  
                 }
 566  
                 }
 567  
                 }
 568  
                 {
 569  29
                 if (_t==null) _t=ASTNULL;
 570  29
                 switch ( _t.getType()) {
 571  
                 case VALUE:
 572  
                 case ALL:
 573  
                 {
 574  6
                         temp=value(_t,m);
 575  6
                         _t = _retTree;
 576  6
                         m = (NamedEntityCollection) temp;
 577  6
                         break;
 578  
                 }
 579  
                 case 3:
 580  
                 {
 581  23
                         break;
 582  
                 }
 583  
                 default:
 584  
                 {
 585  0
                         throw new NoViableAltException(_t);
 586  
                 }
 587  
                 }
 588  
                 }
 589  29
                 _t = __t45;
 590  29
                 _t = _t.getNextSibling();
 591  29
                 _retTree = _t;
 592  29
                 return m;
 593  
         }
 594  
         
 595  
         protected final Entity  typeRef(AST _t) throws RecognitionException {
 596  19
                 Entity e = null;
 597  
                 
 598  19
                 AST typeRef_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 599  19
                 AST t = null;
 600  
                 
 601  19
                 AST __t18 = _t;
 602  19
                 t = _t==ASTNULL ? null :(AST)_t;
 603  19
                 match(_t,TYPEREF);
 604  19
                 _t = _t.getFirstChild();
 605  19
                 e = getEntityFactory().getEntity(t.getText());
 606  
                 {
 607  19
                 if (_t==null) _t=ASTNULL;
 608  19
                 switch ( _t.getType()) {
 609  
                 case OPTIONS:
 610  
                 {
 611  0
                         entityOptions(_t,e);
 612  0
                         _t = _retTree;
 613  0
                         break;
 614  
                 }
 615  
                 case 3:
 616  
                 case VALUE:
 617  
                 case ALL:
 618  
                 {
 619  19
                         break;
 620  
                 }
 621  
                 default:
 622  
                 {
 623  0
                         throw new NoViableAltException(_t);
 624  
                 }
 625  
                 }
 626  
                 }
 627  
                 {
 628  19
                 if (_t==null) _t=ASTNULL;
 629  19
                 switch ( _t.getType()) {
 630  
                 case VALUE:
 631  
                 case ALL:
 632  
                 {
 633  2
                         e=value(_t,e);
 634  2
                         _t = _retTree;
 635  2
                         break;
 636  
                 }
 637  
                 case 3:
 638  
                 {
 639  17
                         break;
 640  
                 }
 641  
                 default:
 642  
                 {
 643  0
                         throw new NoViableAltException(_t);
 644  
                 }
 645  
                 }
 646  
                 }
 647  19
                 _t = __t18;
 648  19
                 _t = _t.getNextSibling();
 649  19
                 _retTree = _t;
 650  19
                 return e;
 651  
         }
 652  
         
 653  
         protected final void entityOptions(AST _t,
 654  
                 Entity e
 655  
         ) throws RecognitionException {
 656  
                 
 657  32
                 AST entityOptions_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 658  
                 
 659  32
                 AST __t53 = _t;
 660  32
                 AST tmp12_AST_in = (AST)_t;
 661  32
                 match(_t,OPTIONS);
 662  32
                 _t = _t.getFirstChild();
 663  
                 {
 664  32
                 int _cnt55=0;
 665  
                 _loop55:
 666  
                 do {
 667  85
                         if (_t==null) _t=ASTNULL;
 668  85
                         if ((_t.getType()==ASSIGN)) {
 669  53
                                 entityOption(_t,e);
 670  53
                                 _t = _retTree;
 671  
                         }
 672  
                         else {
 673  32
                                 if ( _cnt55>=1 ) { break _loop55; } else {throw new NoViableAltException(_t);}
 674  
                         }
 675  
                         
 676  53
                         _cnt55++;
 677  53
                 } while (true);
 678  
                 }
 679  32
                 _t = __t53;
 680  32
                 _t = _t.getNextSibling();
 681  32
                 _retTree = _t;
 682  32
         }
 683  
         
 684  
         protected final Entity  value(AST _t,
 685  
                 Entity e
 686  
         ) throws RecognitionException {
 687  40
                 Entity result = e;
 688  
                 
 689  40
                 AST value_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 690  40
                 AST a = null;
 691  40
                 AST v = null;
 692  
                 
 693  
                 try {      // for error handling
 694  
                         {
 695  40
                         if (_t==null) _t=ASTNULL;
 696  40
                         switch ( _t.getType()) {
 697  
                         case ALL:
 698  
                         {
 699  7
                                 a = (AST)_t;
 700  7
                                 match(_t,ALL);
 701  7
                                 _t = _t.getNextSibling();
 702  7
                                 e.fill(getBytes(a.getText())[0]);
 703  7
                                 break;
 704  
                         }
 705  
                         case VALUE:
 706  
                         {
 707  33
                                 v = (AST)_t;
 708  33
                                 match(_t,VALUE);
 709  33
                                 _t = _t.getNextSibling();
 710  33
                                 e.setValue(getBytes(v.getText()));
 711  32
                                 break;
 712  
                         }
 713  
                         default:
 714  
                         {
 715  0
                                 throw new NoViableAltException(_t);
 716  
                         }
 717  
                         }
 718  
                         }
 719  
                         {
 720  39
                         if (_t==null) _t=ASTNULL;
 721  39
                         switch ( _t.getType()) {
 722  
                         case IMMUTABLE:
 723  
                         {
 724  2
                                 result=immutable(_t,e);
 725  2
                                 _t = _retTree;
 726  2
                                 break;
 727  
                         }
 728  
                         case 3:
 729  
                         {
 730  37
                                 break;
 731  
                         }
 732  
                         default:
 733  
                         {
 734  0
                                 throw new NoViableAltException(_t);
 735  
                         }
 736  
                         }
 737  
                         }
 738  
                 }
 739  0
                 catch (IOException exc) {
 740  
                         
 741  0
                                         throw new RuntimeException(exc);
 742  
                                 
 743  39
                 }
 744  39
                 _retTree = _t;
 745  39
                 return result;
 746  
         }
 747  
         
 748  
         protected final Entity  immutable(AST _t,
 749  
                 Entity e
 750  
         ) throws RecognitionException {
 751  11
                 Entity result = null;
 752  
                 
 753  11
                 AST immutable_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 754  
                 
 755  11
                 AST tmp13_AST_in = (AST)_t;
 756  11
                 match(_t,IMMUTABLE);
 757  11
                 _t = _t.getNextSibling();
 758  11
                 result = ImmutableEntity.getInstance(e);
 759  11
                 _retTree = _t;
 760  11
                 return result;
 761  
         }
 762  
         
 763  
         protected final Entity  fieldDef(AST _t) throws RecognitionException {
 764  128
                 Entity e = null;
 765  
                 
 766  128
                 AST fieldDef_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 767  128
                 AST l = null;
 768  128
                 AST v = null;
 769  128
                 AST n = null;
 770  128
                 AST x = null;
 771  128
                 AST v2 = null;
 772  
                 
 773  
                 {
 774  128
                 if (_t==null) _t=ASTNULL;
 775  128
                 switch ( _t.getType()) {
 776  
                 case LENGTH:
 777  
                 {
 778  76
                         l = (AST)_t;
 779  76
                         match(_t,LENGTH);
 780  76
                         _t = _t.getNextSibling();
 781  76
                         e = getEntityFactory().createField(Integer.parseInt(l.getText()));
 782  
                         {
 783  76
                         if (_t==null) _t=ASTNULL;
 784  76
                         switch ( _t.getType()) {
 785  
                         case OPTIONS:
 786  
                         {
 787  17
                                 entityOptions(_t,e);
 788  17
                                 _t = _retTree;
 789  17
                                 break;
 790  
                         }
 791  
                         case 3:
 792  
                         case VALUE:
 793  
                         case ALL:
 794  
                         {
 795  59
                                 break;
 796  
                         }
 797  
                         default:
 798  
                         {
 799  0
                                 throw new NoViableAltException(_t);
 800  
                         }
 801  
                         }
 802  
                         }
 803  
                         {
 804  76
                         if (_t==null) _t=ASTNULL;
 805  76
                         switch ( _t.getType()) {
 806  
                         case VALUE:
 807  
                         case ALL:
 808  
                         {
 809  28
                                 e=value(_t,e);
 810  27
                                 _t = _retTree;
 811  27
                                 break;
 812  
                         }
 813  
                         case 3:
 814  
                         {
 815  48
                                 break;
 816  
                         }
 817  
                         default:
 818  
                         {
 819  0
                                 throw new NoViableAltException(_t);
 820  
                         }
 821  
                         }
 822  
                         }
 823  
                         break;
 824  
                 }
 825  
                 case VALUE:
 826  
                 {
 827  38
                         v = (AST)_t;
 828  38
                         match(_t,VALUE);
 829  38
                         _t = _t.getNextSibling();
 830  38
                         e = getEntityFactory().createField(getBytes(v.getText()));
 831  
                         {
 832  38
                         if (_t==null) _t=ASTNULL;
 833  38
                         switch ( _t.getType()) {
 834  
                         case IMMUTABLE:
 835  
                         {
 836  9
                                 e=immutable(_t,e);
 837  9
                                 _t = _retTree;
 838  9
                                 break;
 839  
                         }
 840  
                         case 3:
 841  
                         {
 842  29
                                 break;
 843  
                         }
 844  
                         default:
 845  
                         {
 846  0
                                 throw new NoViableAltException(_t);
 847  
                         }
 848  
                         }
 849  
                         }
 850  
                         break;
 851  
                 }
 852  
                 case RANGE:
 853  
                 {
 854  14
                         AST __t40 = _t;
 855  14
                         AST tmp14_AST_in = (AST)_t;
 856  14
                         match(_t,RANGE);
 857  14
                         _t = _t.getFirstChild();
 858  14
                         e = getEntityFactory().createDynamicField();
 859  
                         {
 860  14
                         if (_t==null) _t=ASTNULL;
 861  14
                         switch ( _t.getType()) {
 862  
                         case MIN:
 863  
                         {
 864  7
                                 n = (AST)_t;
 865  7
                                 match(_t,MIN);
 866  7
                                 _t = _t.getNextSibling();
 867  7
                                 ((DynamicField) e).getBounds().setMinimum(Integer.parseInt(n.getText()));
 868  7
                                 break;
 869  
                         }
 870  
                         case 3:
 871  
                         case MAX:
 872  
                         {
 873  7
                                 break;
 874  
                         }
 875  
                         default:
 876  
                         {
 877  0
                                 throw new NoViableAltException(_t);
 878  
                         }
 879  
                         }
 880  
                         }
 881  
                         {
 882  14
                         if (_t==null) _t=ASTNULL;
 883  14
                         switch ( _t.getType()) {
 884  
                         case MAX:
 885  
                         {
 886  8
                                 x = (AST)_t;
 887  8
                                 match(_t,MAX);
 888  8
                                 _t = _t.getNextSibling();
 889  8
                                 ((DynamicField) e).getBounds().setMaximum(Integer.parseInt(x.getText()));
 890  8
                                 break;
 891  
                         }
 892  
                         case 3:
 893  
                         {
 894  6
                                 break;
 895  
                         }
 896  
                         default:
 897  
                         {
 898  0
                                 throw new NoViableAltException(_t);
 899  
                         }
 900  
                         }
 901  
                         }
 902  14
                         _t = __t40;
 903  14
                         _t = _t.getNextSibling();
 904  
                         {
 905  14
                         if (_t==null) _t=ASTNULL;
 906  14
                         switch ( _t.getType()) {
 907  
                         case VALUE:
 908  
                         {
 909  1
                                 v2 = (AST)_t;
 910  1
                                 match(_t,VALUE);
 911  1
                                 _t = _t.getNextSibling();
 912  1
                                 e.setValue(getBytes(v2.getText()));
 913  1
                                 break;
 914  
                         }
 915  
                         case 3:
 916  
                         {
 917  13
                                 break;
 918  
                         }
 919  
                         default:
 920  
                         {
 921  0
                                 throw new NoViableAltException(_t);
 922  
                         }
 923  
                         }
 924  
                         }
 925  
                         break;
 926  
                 }
 927  
                 default:
 928  
                 {
 929  0
                         throw new NoViableAltException(_t);
 930  
                 }
 931  
                 }
 932  
                 }
 933  127
                 _retTree = _t;
 934  127
                 return e;
 935  
         }
 936  
         
 937  
         protected final void entityOption(AST _t,
 938  
                 Entity e
 939  
         ) throws RecognitionException {
 940  
                 
 941  53
                 AST entityOption_AST_in = (_t == ASTNULL) ? null : (AST)_t;
 942  53
                 String key = null, value = null;
 943  
                 
 944  53
                 AST __t57 = _t;
 945  53
                 AST tmp15_AST_in = (AST)_t;
 946  53
                 match(_t,ASSIGN);
 947  53
                 _t = _t.getFirstChild();
 948  53
                 key=optionKV(_t);
 949  53
                 _t = _retTree;
 950  53
                 value=optionKV(_t);
 951  53
                 _t = _retTree;
 952  53
                 ApplyOptions.apply(e, key, value);
 953  53
                 _t = __t57;
 954  53
                 _t = _t.getNextSibling();
 955  53
                 _retTree = _t;
 956  53
         }
 957  
         
 958  
         
 959  1
         public static final String[] _tokenNames = {
 960  
                 "<0>",
 961  
                 "EOF",
 962  
                 "<2>",
 963  
                 "NULL_TREE_LOOKAHEAD",
 964  
                 "ROOT",
 965  
                 "CHECK",
 966  
                 "VALUE",
 967  
                 "ALL",
 968  
                 "FIELD",
 969  
                 "LENGTH",
 970  
                 "ARRAY",
 971  
                 "IMMUTABLE",
 972  
                 "MAP",
 973  
                 "PROTOTYPE",
 974  
                 "OPTIONS",
 975  
                 "MIN",
 976  
                 "MAX",
 977  
                 "OPTION_BLOCK",
 978  
                 "SEMI",
 979  
                 "IDENT",
 980  
                 "ANON",
 981  
                 "COLON",
 982  
                 "TYPEREF",
 983  
                 "LBRACK",
 984  
                 "RBRACK",
 985  
                 "CHAR_LITERAL",
 986  
                 "STAR",
 987  
                 "STRING_LITERAL",
 988  
                 "BANG",
 989  
                 "LPAREN",
 990  
                 "RPAREN",
 991  
                 "LCURLY",
 992  
                 "COMMA",
 993  
                 "RCURLY",
 994  
                 "NUMBER",
 995  
                 "RANGE",
 996  
                 "ASSIGN",
 997  
                 "WS",
 998  
                 "SL_COMMENT",
 999  
                 "ML_COMMENT",
 1000  
                 "NL",
 1001  
                 "PTIDENT",
 1002  
                 "CHAR_BODY",
 1003  
                 "STRING_BODY",
 1004  
                 "ESC",
 1005  
                 "UNICODE",
 1006  
                 "OCTAL",
 1007  
                 "HEX_DIGIT"
 1008  
         };
 1009  
         
 1010  
         }
 1011