Coverage Report

##### Coverage Report - org.webmacro.parser.WMParser_impl

Classes in this File | Line Coverage | Branch Coverage | Complexity
WMParser_impl |
50% | 821/1610
33% | 483/1425
| 7.061728395061729;7.062
WMParser_impl$1 |
N/A | N/A
N/A | N/A
| 7.061728395061729;7.062
WMParser_impl$JJCalls |
100% | 1/1
N/A | N/A
| 7.061728395061729;7.062
WMParser_impl$LookaheadSuccess |
100% | 1/1
N/A | N/A
| 7.061728395061729;7.062

1 |  |
     /* Generated By:JavaCC: Do not edit this line. WMParser_impl.java */
2 |  |
     package org.webmacro.parser;
3 |  |
4 |  |
     import java.io.FileReader;
5 |  |
     import java.io.InputStreamReader;
6 |  |
     import java.util.ArrayList;
7 |  |
     import java.util.Stack;
8 |  |
9 |  |
     import org.slf4j.Logger;
10 |  |
     import org.slf4j.LoggerFactory;
11 |  |
     import org.webmacro.Broker;
12 |  |
     import org.webmacro.Context;
13 |  |
     import org.webmacro.WM;
14 |  |
     import org.webmacro.directive.Directive;
15 |  |
     import org.webmacro.directive.DirectiveArgs;
16 |  |
     import org.webmacro.directive.DirectiveBuilder;
17 |  |
     import org.webmacro.directive.DirectiveDescriptor;
18 |  |
     import org.webmacro.directive.DirectiveProvider;
19 |  |
     import org.webmacro.directive.Directive.ArgDescriptor;
20 |  |
     import org.webmacro.directive.Directive.OptionChoice;
21 |  |
     import org.webmacro.directive.Directive.Subdirective;
22 |  |
     import org.webmacro.engine.Block;
23 |  |
     import org.webmacro.engine.BlockBuilder;
24 |  |
     import org.webmacro.engine.BuildContext;
25 |  |
     import org.webmacro.engine.BuildException;
26 |  |
     import org.webmacro.engine.Builder;
27 |  |
     import org.webmacro.engine.Expression;
28 |  |
     import org.webmacro.engine.FunctionCallBuilder;
29 |  |
     import org.webmacro.engine.ListBuilder;
30 |  |
     import org.webmacro.engine.MacroBuilder;
31 |  |
     import org.webmacro.engine.MapBuilder;
32 |  |
     import org.webmacro.engine.PropertyMethodBuilder;
33 |  |
     import org.webmacro.engine.QuotedStringBuilder;
34 |  |
     import org.webmacro.engine.VariableBuilder;
35 |  |
     import org.webmacro.resource.DelegatingTemplateProvider;
36 |  |
37 |  |
     /**
38 |  |
      * WMParser_impl
39 |  |
      *
40 |  |
      * JavaCC parser class for parsing WebMacro templates.
41 |  |
      * The supported entry point is WMDocument, which returns a BlockBuilder.
42 |  |
      *
43 |  |
      * @author Brian Goetz
44 |  |
      *
45 |  |
      */
46 |  |
47 |  |
     public class WMParser_impl implements WMParser_implConstants {
48 |  |
49 | 2 |
       static Logger _log =  LoggerFactory.getLogger(WMParser_impl.class);
50 |  |
       private Broker broker;
51 |  |
       private BackupCharStream stream;
52 | 228 |
       private Stack blockStack = new Stack();
53 |  |
       private String templateName;
54 |  |
55 |  |
       public WMParser_impl(Broker broker,
56 |  |
                            String templateName,
57 |  |
                            BackupCharStream stream) {
58 | 228 |
         this(stream);
59 | 228 |
         this.stream = stream;
60 | 228 |
         this.broker = broker;
61 | 228 |
         this.templateName = templateName;
62 | 228 |
       }
63 |  |
64 |  |
       public WMParser_impl(Broker broker,
65 |  |
                            String templateName,
66 |  |
                            java.io.Reader reader) {
67 | 228 |
         this(broker, templateName, new BackupCharStream(reader));
68 | 228 |
       }
69 |  |
70 |  |
       public void ReInit(String templateName, java.io.Reader reader) {
71 | 0 |
         this.templateName = templateName;
72 | 0 |
         stream.ReInit(reader);
73 | 0 |
         ReInit(stream);
74 | 0 |
       }
75 |  |
76 |  |
       // Standalone test harness
77 |  |
       public static void main(String[] args) throws Exception {
78 | 0 |
         WM wm = new WM();
79 | 0 |
         Broker broker = wm.getBroker();
80 |  |
         WMParser_impl parser;
81 |  |
82 | 0 |
         if (args.length >= 1)
83 | 0 |
           parser = new WMParser_impl(broker, args[0], new FileReader(args[0]));
84 |  |
         else
85 | 0 |
           parser = new WMParser_impl(broker, "stdin",
86 |  |
                                      new InputStreamReader(System.in));
87 |  |
88 | 0 |
         Builder bb = parser.WMDocument();
89 | 0 |
         Context context = null;
90 |  |
91 |  |
         try {
92 | 0 |
            context = wm.getContext();
93 | 0 |
            Object names[] = { "prop" };
94 | 0 |
            context.setProperty(names, "Example property");
95 | 0 |
            Block b = (Block) bb.build(new BuildContext(broker));
96 |  |
            // TemplateDumper d = new TemplateDumper();
97 |  |
            // b.accept(d);
98 |  |
            // System.out.println("---------------------------------------------");
99 | 0 |
            System.out.println((String) b.evaluate(context));
100 | 0 |
         } catch (Exception e) {
101 | 0 |
            e.printStackTrace();
102 | 0 |
         }
103 | 0 |
       }
104 |  |
105 |  |
106 |  |
       // JavaCC hack for doing lexical state transitions syntactically
107 |  |
108 |  |
       private void SetState(int state) {
109 | 28400 |
         if (state != token_source.curLexState) {
110 | 28400 |
           Token root = new Token(), last=root;
111 | 28400 |
           root.next = null;
112 |  |
113 |  |
           // First, we build a list of tokens to push back, in backwards order
114 | 39384 |
           while (token.next != null) {
115 | 10984 |
             Token t = token;
116 |  |
             // Find the token whose token.next is the last in the chain
117 | 11968 |
             while (t.next != null && t.next.next != null)
118 | 984 |
               t = t.next;
119 |  |
120 |  |
             // put it at the end of the new chain
121 | 10984 |
             last.next = t.next;
122 | 10984 |
             last = t.next;
123 |  |
124 |  |
             // If there are special tokens, these go before the regular tokens,
125 |  |
             // so we want to push them back onto the input stream in the order
126 |  |
             // we find them along the specialToken chain.
127 |  |
128 | 10984 |
             if (t.next.specialToken != null) {
129 | 28 |
               Token tt=t.next.specialToken;
130 | 56 |
               while (tt != null) {
131 | 28 |
                 last.next = tt;
132 | 28 |
                 last = tt;
133 | 28 |
                 tt.next = null;
134 | 28 |
                 tt = tt.specialToken;
135 |  |
               }
136 |  |
             }
137 | 10984 |
             t.next = null;
138 | 10984 |
           };
139 |  |
140 | 39412 |
           while (root.next != null) {
141 | 11012 |
             token_source.backup(root.next.image.length());
142 | 11012 |
             root.next = root.next.next;
143 |  |
           }
144 | 28400 |
           jj_ntk = -1;
145 | 28400 |
           token_source.SwitchTo(state);
146 |  |
         }
147 | 28400 |
       }
148 |  |
149 |  |
       private boolean lookahead_not_breaking_subd() {
150 | 2676 |
         boolean retVal = true;
151 | 2676 |
         Object o = blockStack.peek();
152 | 2676 |
         if (o == null)
153 | 518 |
           return true;
154 | 2158 |
         Subdirective[] subdirectives = (Subdirective[]) o;
155 |  |
156 | 2158 |
         if (getToken(1).kind == POUND
157 |  |
             && getToken(2).kind == STUFF) {
158 | 1050 |
           String word = getToken(2).image;
159 | 3144 |
           for (int i=0; i<subdirectives.length; i++)
160 | 2100 |
             if (subdirectives[i].isBreaking
161 |  |
                 && word.startsWith(subdirectives[i].name)
162 |  |
                 && (word.length() == subdirectives[i].name.length()
163 |  |
                     || !Character.isJavaIdentifierPart(
164 |  |
                           word.charAt(subdirectives[i].name.length())))) {
165 | 6 |
               retVal = false;
166 | 6 |
               break;
167 |  |
             }
168 |  |
         }
169 | 2158 |
         return retVal;
170 |  |
       }
171 |  |
172 |  |
173 | 2 |
       private static String SEMI_FEATURE =
174 |  |
         "Use of semicolon to delimit property reference -- use $( ) instead";
175 | 2 |
       private static String DDOLLAR_FEATURE =
176 |  |
         "Use of $$ to reference template property -- use single $ instead";
177 |  |
178 |  |
       // Warning routines
179 |  |
       private void warnDeprecated(String feature, int line, int col) {
180 | 0 |
         _log.warn("Deprecated feature: " + feature + " at " + templateName + ":" + line + "." + col);
181 | 0 |
       }
182 |  |
183 |  |
       Subdirective lookahead_subdirective(Subdirective[] subdirectives) throws ParseException {
184 | 1118 |
       int n=1;
185 |  |
     //  if (getToken(n).kind == WS)            ++n;
186 |  |
     //  if (getToken(n).kind == NEWLINE)       ++n;
187 |  |
     //  if (getToken(n).kind == WS)            ++n;
188 | 1118 |
       Token t = getToken(n);
189 | 2362 |
       while ( t.kind == WS || t.kind == NEWLINE ) {
190 | 1244 |
          t = getToken(++n);
191 |  |
       }
192 |  |
193 | 1118 |
       if (getToken(n).kind == POUND
194 |  |
           && getToken(n+1).kind == WORD) {
195 | 626 |
         String word = getToken(n+1).image;
196 | 1542 |
         for (int i=0; i<subdirectives.length; i++)
197 | 1252 |
           if (word.equals(subdirectives[i].name))
198 | 336 |
             return subdirectives[i];
199 |  |
       }
200 | 782 |
       return null;
201 |  |
       }
202 |  |
203 |  |
       boolean lookahead_keyword(String keyword) throws ParseException {
204 | 284 |
       int n=1;
205 | 284 |
       if (getToken(n).kind == WS)
206 | 0 |
         ++n;
207 | 284 |
       if (getToken(n).kind == WORD
208 |  |
           && getToken(n).image.equals(keyword))
209 | 0 |
         return true;
210 |  |
       else
211 | 284 |
         return false;
212 |  |
       }
213 |  |
214 |  |
       boolean lookahead_arg(ArgDescriptor arg) throws ParseException {
215 | 0 |
       if (arg.type == Directive.ArgType_KEYWORD)
216 | 0 |
         return lookahead_keyword(arg.keyword);
217 | 0 |
       else if (arg.type == Directive.ArgType_ASSIGN) {
218 | 0 |
         int n=1;
219 | 0 |
         if (getToken(n).kind == WS)
220 | 0 |
           ++n;
221 | 0 |
         return (getToken(n).kind == OP_SET);
222 |  |
       }
223 |  |
       else
224 | 0 |
         return false;
225 |  |
       }
226 |  |
227 |  |
       Object parse_arg(DirectiveDescriptor descriptor, ArgDescriptor arg) throws ParseException {
228 | 3556 |
       switch (arg.type) {
229 |  |
       case Directive.ArgType_CONDITION:
230 | 782 |
         return Conditional();
231 |  |
232 |  |
       case Directive.ArgType_BLOCK: {
233 | 1260 |
         BeforeBlock();
234 | 1260 |
         SetState(DEFAULT);
235 |  |
         BlockBuilder b;
236 | 1260 |
         b = Block(descriptor.hasBreakingSubdirectives
237 |  |
                   ? descriptor.subdirectives : null);
238 | 1260 |
         SetState(WM);
239 | 1260 |
         OptionalWs();
240 | 1260 |
         return b;
241 |  |
       }
242 |  |
243 |  |
       case Directive.ArgType_LITBLOCK: {
244 | 0 |
         BeforeBlock();
245 | 0 |
         SetState(DEFAULT);
246 | 0 |
         BlockBuilder b = LiteralBlock();
247 | 0 |
         SetState(WM);
248 | 0 |
         OptionalWs();
249 | 0 |
         return b;
250 |  |
       }
251 |  |
252 |  |
       case Directive.ArgType_LVALUE:
253 | 506 |
         return LValue();
254 |  |
255 |  |
       case Directive.ArgType_RVALUE:
256 | 502 |
         return RValue();
257 |  |
258 |  |
       case Directive.ArgType_QUOTEDSTRING:
259 | 0 |
         return QuotedString();
260 |  |
261 |  |
       case Directive.ArgType_NAME:
262 | 0 |
         return Word();
263 |  |
264 |  |
       case Directive.ArgType_STRING:
265 | 0 |
         return StringArg();
266 |  |
267 |  |
       case Directive.ArgType_ASSIGN:
268 | 364 |
         Punct_EQ();
269 | 360 |
         return "=";
270 |  |
271 |  |
       case Directive.ArgType_ARGLIST:
272 | 0 |
         return FormalArgList();
273 |  |
274 |  |
       case Directive.ArgType_KEYWORD:
275 | 142 |
         if (arg.optional && !lookahead_keyword(arg.keyword))
276 | 0 |
           return null;
277 |  |
         else {
278 | 142 |
           Keyword(arg.keyword);
279 | 142 |
           return arg.keyword;
280 |  |
         }
281 |  |
282 |  |
       default:
283 | 0 |
         throw new ParseException("ParseDirectiveArg: Unknown argument type "
284 |  |
                                  + arg.type);
285 |  |
       }
286 |  |
       }
287 |  |
288 |  |
       boolean parse_arg_group(DirectiveDescriptor descriptor,
289 |  |
                             ArgDescriptor[] args, int i,
290 |  |
                             DirectiveArgs da) throws ParseException, BuildException {
291 | 0 |
       if (args[i].optional)
292 | 0 |
         if (!lookahead_arg(args[args[i].children[0]]))
293 | 0 |
           return false;
294 | 0 |
       for (int j=0; j<args[i].subordinateArgs; j++) {
295 | 0 |
         ArgDescriptor child = args[args[i].children[j]];
296 | 0 |
         if (child.type == Directive.ArgType_GROUP) {
297 | 0 |
           parse_arg_group(descriptor, args, args[i].children[j], da);
298 |  |
         }
299 | 0 |
         else if (child.type == Directive.ArgType_CHOICE) {
300 | 0 |
           parse_arg_choice(descriptor, args, args[i].children[j], da);
301 |  |
         }
302 |  |
         else {
303 | 0 |
           Object o = parse_arg(descriptor, child);
304 | 0 |
           da.setArg(child.id, o);
305 |  |
         }
306 |  |
       }
307 | 0 |
       return true;
308 |  |
       }
309 |  |
310 |  |
       void parse_arg_choice(DirectiveDescriptor descriptor,
311 |  |
                           ArgDescriptor[] args,
312 |  |
                           int i,
313 |  |
                           DirectiveArgs da) throws ParseException, BuildException {
314 | 142 |
       boolean foundOne = false;
315 |  |
316 | 142 |
       OptionChoice oc = (OptionChoice) args[i];
317 | 142 |
       for (boolean more=true; more; ) {
318 | 426 |
         for (int j=0; j<args[i].subordinateArgs; j++) {
319 | 284 |
           more = false;
320 |  |
           // Each child is a GROUP, so we want to look at child's first child
321 | 284 |
           ArgDescriptor child = args[args[i].children[j]];
322 | 284 |
           if (lookahead_keyword(args[child.children[0]].keyword)) {
323 | 0 |
             foundOne = true;
324 | 0 |
             parse_arg_group(descriptor, args, args[i].children[j], da);
325 | 0 |
             if (oc.repeating)
326 | 0 |
               more = true;
327 |  |
             break;
328 |  |
           }
329 |  |
         }
330 |  |
       }
331 | 142 |
       if (!args[i].optional && !foundOne) {
332 | 0 |
         StringBuffer sb = new StringBuffer();
333 | 0 |
         for (int j=0; j<args[i].subordinateArgs; j++) {
334 | 0 |
           if (j>0) sb.append(", ");
335 | 0 |
           ArgDescriptor child = args[args[i].children[j]];
336 | 0 |
           sb.append(args[child.children[0]].keyword);
337 |  |
         }
338 | 0 |
         throw new ParseException("Expecting one of " + sb.toString());
339 |  |
       }
340 | 142 |
       }
341 |  |
342 |  |
       void parse_args(DirectiveDescriptor descriptor,
343 |  |
                     ArgDescriptor[] args, DirectiveArgs da) throws ParseException {
344 |  |
       try {
345 | 1624 |
         for (int i=0; i < args.length; ) {
346 | 3698 |
           ArgDescriptor arg = args[i];
347 |  |
348 | 3698 |
           if (arg.type == Directive.ArgType_GROUP)
349 | 0 |
             parse_arg_group(descriptor, args, i, da);
350 | 3698 |
           else if (arg.type == Directive.ArgType_CHOICE)
351 | 142 |
             parse_arg_choice(descriptor, args, i, da);
352 |  |
           else {
353 | 3556 |
             Object o = parse_arg(descriptor, arg);
354 | 3552 |
             da.setArg(arg.id, o);
355 |  |
           }
356 | 3694 |
           i = arg.nextArg;
357 | 3694 |
         }
358 |  |
       }
359 | 0 |
       catch (BuildException e) {
360 | 0 |
         throw new ParseException("BuildException", e);
361 | 1620 |
       }
362 | 1620 |
       }
363 |  |
364 |  |
       Builder parse_directive(String directive) throws ParseException, ParseException {
365 | 1288 |
       DirectiveBuilder db=null;
366 | 1288 |
       DirectiveDescriptor descriptor=null;
367 |  |
       Subdirective subd;
368 |  |
369 |  |
       try {
370 | 1288 |
         descriptor =
371 |  |
           (DirectiveDescriptor) broker.get(DirectiveProvider.DIRECTIVE_KEY,
372 |  |
                                            directive);
373 | 1288 |
         if (descriptor == null)
374 | 0 |
           return parse_macro(directive);
375 | 1288 |
         else if (!descriptor.valid)
376 | 0 |
           throw new ParseException("Descriptor for directive " + directive
377 |  |
                                    + " is not valid");
378 |  |
       }
379 | 0 |
       catch (Exception e) {
380 | 0 |
         throw new ParseException("No such directive #" + directive);
381 | 1288 |
       }
382 | 1288 |
       db = new DirectiveBuilder(descriptor);
383 | 1288 |
       parse_args(descriptor, descriptor.args, db);
384 |  |
385 | 1284 |
       if (descriptor.subdirectives != null
386 |  |
           && descriptor.subdirectives.length > 0) {
387 |  |
         DirectiveArgs da;
388 |  |
389 | 1118 |
         while ((subd = lookahead_subdirective(descriptor.subdirectives)) != null) {
390 |  |
           try {
391 | 336 |
             if (!db.subdirectiveOk(subd.id))
392 | 0 |
               break;
393 | 336 |
             SubdirectiveStart();
394 | 336 |
             da = db.newSubdirective(subd.id);
395 | 0 |
           } catch (BuildException e) {
396 | 0 |
             throw new ParseException("BuildException", e);
397 | 336 |
           };
398 | 336 |
           parse_args(descriptor, subd.args, da);
399 |  |
         }
400 |  |
       }
401 | 1284 |
       OptionalWsNl();
402 |  |
403 | 1284 |
       return db;
404 |  |
       }
405 |  |
406 |  |
       Builder parse_macro(String name) throws ParseException, ParseException {
407 | 0 |
       Token token = getToken(1);
408 | 0 |
       ListBuilder lb = MacroArgList();
409 | 0 |
       return new MacroBuilder(name, lb, token.beginLine, token.beginColumn);
410 |  |
       }
411 |  |
412 |  |
     /* Utility productions used by above JavaCode productions (State: WM) */
413 |  |
       final public void EatWsNlIfNl(BlockBuilder b) throws ParseException {
414 | 8 |
       int entryState = token_source.curLexState;
415 | 8 |
         SetState(WM);
416 | 8 |
         if (jj_2_1(2147483647)) {
417 | 8 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
418 |  |
           case WS:
419 | 4 |
             jj_consume_token(WS);
420 | 4 |
             break;
421 |  |
           default:
422 | 4 |
             jj_la1[0] = jj_gen;
423 |  |
             ;
424 |  |
           }
425 | 8 |
           jj_consume_token(NEWLINE);
426 |  |
         } else {
427 |  |
           ;
428 |  |
         }
429 | 8 |
         SetState(entryState);
430 | 8 |
       }
431 |  |
432 |  |
       final public void EatWsNlOrSpace(BlockBuilder b) throws ParseException {
433 | 1240 |
       int entryState = token_source.curLexState;
434 | 1240 |
       Token w, n=null;
435 | 1240 |
         SetState(WM);
436 | 1240 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
437 |  |
         case WS:
438 |  |
         case NEWLINE:
439 | 1240 |
           if (jj_2_3(2147483647)) {
440 | 1082 |
             jj_consume_token(NEWLINE);
441 | 158 |
           } else if (jj_2_4(2147483647)) {
442 | 158 |
             w = jj_consume_token(WS);
443 | 158 |
             if (jj_2_2(2147483647)) {
444 | 128 |
               n = jj_consume_token(NEWLINE);
445 |  |
             } else {
446 |  |
               ;
447 |  |
             }
448 | 158 |
                 if (n == null) b.addElement(w.image.substring(1));
449 |  |
           } else {
450 | 0 |
             jj_consume_token(-1);
451 | 0 |
             throw new ParseException();
452 |  |
           }
453 |  |
           break;
454 |  |
         default:
455 | 0 |
           jj_la1[1] = jj_gen;
456 |  |
           ;
457 |  |
         }
458 | 1240 |
         SetState(entryState);
459 | 1240 |
       }
460 |  |
461 |  |
       final public void BeforeBlock() throws ParseException {
462 | 1260 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
463 |  |
         case WS:
464 | 776 |
           jj_consume_token(WS);
465 | 776 |
           break;
466 |  |
         default:
467 | 484 |
           jj_la1[2] = jj_gen;
468 |  |
           ;
469 |  |
         }
470 | 1260 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
471 |  |
         case NEWLINE:
472 | 20 |
           jj_consume_token(NEWLINE);
473 | 20 |
           if (jj_2_5(2147483647)) {
474 | 8 |
             jj_consume_token(WS);
475 |  |
           } else {
476 |  |
             ;
477 |  |
           }
478 |  |
           break;
479 |  |
         default:
480 | 1240 |
           jj_la1[3] = jj_gen;
481 |  |
           ;
482 |  |
         }
483 | 1260 |
       }
484 |  |
485 |  |
       final public void OptionalWsNl() throws ParseException {
486 | 1284 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
487 |  |
         case WS:
488 | 0 |
           jj_consume_token(WS);
489 | 0 |
           break;
490 |  |
         default:
491 | 1284 |
           jj_la1[4] = jj_gen;
492 |  |
           ;
493 |  |
         }
494 | 1284 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
495 |  |
         case NEWLINE:
496 | 1266 |
           jj_consume_token(NEWLINE);
497 | 1266 |
           break;
498 |  |
         default:
499 | 18 |
           jj_la1[5] = jj_gen;
500 |  |
           ;
501 |  |
         }
502 | 1284 |
       }
503 |  |
504 |  |
       final public void OptionalWs() throws ParseException {
505 | 1260 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
506 |  |
         case WS:
507 | 404 |
           jj_consume_token(WS);
508 | 404 |
           break;
509 |  |
         default:
510 | 856 |
           jj_la1[6] = jj_gen;
511 |  |
           ;
512 |  |
         }
513 | 1260 |
       }
514 |  |
515 |  |
       final public void SubdirectiveStart() throws ParseException {
516 |  |
         label_1:
517 |  |
         while (true) {
518 | 336 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
519 |  |
           case WS:
520 |  |
           case NEWLINE:
521 |  |
             ;
522 | 0 |
             break;
523 |  |
           default:
524 | 336 |
             jj_la1[7] = jj_gen;
525 | 336 |
             break label_1;
526 |  |
           }
527 | 0 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
528 |  |
           case WS:
529 | 0 |
             jj_consume_token(WS);
530 | 0 |
             break;
531 |  |
           case NEWLINE:
532 | 0 |
             jj_consume_token(NEWLINE);
533 | 0 |
             break;
534 |  |
           default:
535 | 0 |
             jj_la1[8] = jj_gen;
536 | 0 |
             jj_consume_token(-1);
537 | 0 |
             throw new ParseException();
538 |  |
           }
539 |  |
         }
540 | 336 |
         jj_consume_token(POUND);
541 | 336 |
         jj_consume_token(WORD);
542 | 336 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
543 |  |
         case WS:
544 | 330 |
           jj_consume_token(WS);
545 | 330 |
           break;
546 |  |
         default:
547 | 6 |
           jj_la1[9] = jj_gen;
548 |  |
           ;
549 |  |
         }
550 | 336 |
       }
551 |  |
552 |  |
     /* Productions used by JavaCode productions to parse directive arguments.
553 |  |
        Correpond mostly to the defined argument types.  (State: WM) */
554 |  |
       final public Builder LValue() throws ParseException {
555 |  |
       Builder lv;
556 | 506 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
557 |  |
         case WS:
558 | 0 |
           jj_consume_token(WS);
559 | 0 |
           break;
560 |  |
         default:
561 | 506 |
           jj_la1[10] = jj_gen;
562 |  |
           ;
563 |  |
         }
564 | 506 |
         lv = VariableReference();
565 | 506 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
566 |  |
         case WS:
567 | 494 |
           jj_consume_token(WS);
568 | 494 |
           break;
569 |  |
         default:
570 | 12 |
           jj_la1[11] = jj_gen;
571 |  |
           ;
572 |  |
         }
573 | 506 |
         return lv;
574 |  |
       }
575 |  |
576 |  |
       final public Object RValue() throws ParseException {
577 |  |
       Object rv;
578 | 502 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
579 |  |
         case WS:
580 | 0 |
           jj_consume_token(WS);
581 | 0 |
           break;
582 |  |
         default:
583 | 502 |
           jj_la1[12] = jj_gen;
584 |  |
           ;
585 |  |
         }
586 | 502 |
         rv = Expression();
587 | 502 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
588 |  |
         case WS:
589 | 138 |
           jj_consume_token(WS);
590 | 138 |
           break;
591 |  |
         default:
592 | 364 |
           jj_la1[13] = jj_gen;
593 |  |
           ;
594 |  |
         }
595 | 502 |
         return rv;
596 |  |
       }
597 |  |
598 |  |
       final public void Punct_EQ() throws ParseException {
599 | 364 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
600 |  |
         case WS:
601 | 0 |
           jj_consume_token(WS);
602 | 0 |
           break;
603 |  |
         default:
604 | 364 |
           jj_la1[14] = jj_gen;
605 |  |
           ;
606 |  |
         }
607 | 364 |
         jj_consume_token(OP_SET);
608 | 360 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
609 |  |
         case WS:
610 | 328 |
           jj_consume_token(WS);
611 | 328 |
           break;
612 |  |
         default:
613 | 32 |
           jj_la1[15] = jj_gen;
614 |  |
           ;
615 |  |
         }
616 | 360 |
       }
617 |  |
618 |  |
       final public void Punct_COMMA() throws ParseException {
619 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
620 |  |
         case WS:
621 | 0 |
           jj_consume_token(WS);
622 | 0 |
           break;
623 |  |
         default:
624 | 0 |
           jj_la1[16] = jj_gen;
625 |  |
           ;
626 |  |
         }
627 | 0 |
         jj_consume_token(COMMA);
628 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
629 |  |
         case WS:
630 | 0 |
           jj_consume_token(WS);
631 | 0 |
           break;
632 |  |
         default:
633 | 0 |
           jj_la1[17] = jj_gen;
634 |  |
           ;
635 |  |
         }
636 | 0 |
       }
637 |  |
638 |  |
       final public void Punct_LPAREN() throws ParseException {
639 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
640 |  |
         case WS:
641 | 0 |
           jj_consume_token(WS);
642 | 0 |
           break;
643 |  |
         default:
644 | 0 |
           jj_la1[18] = jj_gen;
645 |  |
           ;
646 |  |
         }
647 | 0 |
         jj_consume_token(LPAREN);
648 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
649 |  |
         case WS:
650 | 0 |
           jj_consume_token(WS);
651 | 0 |
           break;
652 |  |
         default:
653 | 0 |
           jj_la1[19] = jj_gen;
654 |  |
           ;
655 |  |
         }
656 | 0 |
       }
657 |  |
658 |  |
       final public void Punct_RPAREN() throws ParseException {
659 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
660 |  |
         case WS:
661 | 0 |
           jj_consume_token(WS);
662 | 0 |
           break;
663 |  |
         default:
664 | 0 |
           jj_la1[20] = jj_gen;
665 |  |
           ;
666 |  |
         }
667 | 0 |
         jj_consume_token(RPAREN);
668 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
669 |  |
         case WS:
670 | 0 |
           jj_consume_token(WS);
671 | 0 |
           break;
672 |  |
         default:
673 | 0 |
           jj_la1[21] = jj_gen;
674 |  |
           ;
675 |  |
         }
676 | 0 |
       }
677 |  |
678 |  |
       final public void Keyword(String s) throws ParseException {
679 |  |
       Token t;
680 | 142 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
681 |  |
         case WS:
682 | 0 |
           jj_consume_token(WS);
683 | 0 |
           break;
684 |  |
         default:
685 | 142 |
           jj_la1[22] = jj_gen;
686 |  |
           ;
687 |  |
         }
688 | 142 |
         t = jj_consume_token(WORD);
689 | 142 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
690 |  |
         case WS:
691 | 142 |
           jj_consume_token(WS);
692 | 142 |
           break;
693 |  |
         default:
694 | 0 |
           jj_la1[23] = jj_gen;
695 |  |
           ;
696 |  |
         }
697 | 142 |
         if (!s.equals(t.image))
698 | 0 |
           {if (true) throw new ParseException("Encountered " + t.image + " at line "
699 |  |
                                    + t.beginLine + "; expecting " + s);}
700 | 142 |
       }
701 |  |
702 |  |
       final public String Word() throws ParseException {
703 |  |
       Token t;
704 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
705 |  |
         case WS:
706 | 0 |
           jj_consume_token(WS);
707 | 0 |
           break;
708 |  |
         default:
709 | 0 |
           jj_la1[24] = jj_gen;
710 |  |
           ;
711 |  |
         }
712 | 0 |
         t = jj_consume_token(WORD);
713 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
714 |  |
         case WS:
715 | 0 |
           jj_consume_token(WS);
716 | 0 |
           break;
717 |  |
         default:
718 | 0 |
           jj_la1[25] = jj_gen;
719 |  |
           ;
720 |  |
         }
721 | 0 |
         return t.image;
722 |  |
       }
723 |  |
724 |  |
       final public Object Conditional() throws ParseException {
725 |  |
       Object e;
726 | 782 |
         jj_consume_token(LPAREN);
727 | 782 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
728 |  |
         case WS:
729 | 0 |
           jj_consume_token(WS);
730 | 0 |
           break;
731 |  |
         default:
732 | 782 |
           jj_la1[26] = jj_gen;
733 |  |
           ;
734 |  |
         }
735 | 782 |
         e = Expression();
736 | 782 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
737 |  |
         case WS:
738 | 0 |
           jj_consume_token(WS);
739 | 0 |
           break;
740 |  |
         default:
741 | 782 |
           jj_la1[27] = jj_gen;
742 |  |
           ;
743 |  |
         }
744 | 782 |
         jj_consume_token(RPAREN);
745 | 782 |
         return e;
746 |  |
       }
747 |  |
748 |  |
     /* ******************* */
749 |  |
     /* Variable References */
750 |  |
     /* ******************* */
751 |  |
752 |  |
     /* Productions used in WM variable references.  State: WM.  */
753 |  |
754 |  |
     // Used by VariableReference; shouldn't be used outside it
755 |  |
       final public Object ObjectRoot() throws ParseException {
756 |  |
       Token t;
757 |  |
       ListBuilder argList;
758 |  |
       Object element;
759 | 5838 |
         if (jj_2_6(2147483647)) {
760 | 0 |
           t = jj_consume_token(WORD);
761 | 0 |
           jj_consume_token(LPAREN);
762 | 0 |
           argList = ArgList();
763 | 0 |
           jj_consume_token(RPAREN);
764 | 0 |
             element = new FunctionCallBuilder((String) t.image, argList);
765 |  |
         } else {
766 | 5838 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
767 |  |
           case WORD:
768 | 5838 |
             t = jj_consume_token(WORD);
769 | 5838 |
                      element=t.image;
770 | 5838 |
             break;
771 |  |
           default:
772 | 0 |
             jj_la1[28] = jj_gen;
773 | 0 |
             jj_consume_token(-1);
774 | 0 |
             throw new ParseException();
775 |  |
           }
776 |  |
         }
777 | 5838 |
         return element;
778 |  |
       }
779 |  |
780 |  |
     // Used by VariableReference; shouldn't be used outside it
781 |  |
       final public void VariableReferenceGuts(ArrayList v) throws ParseException {
782 |  |
       Token t;
783 |  |
       Object element;
784 |  |
       ListBuilder argList;
785 | 5838 |
         element = ObjectRoot();
786 | 5838 |
                              v.add(element);
787 |  |
         label_2:
788 |  |
         while (true) {
789 | 10992 |
           if (jj_2_7(2147483647)) {
790 |  |
             ;
791 |  |
           } else {
792 |  |
             break label_2;
793 |  |
           }
794 | 5154 |
           jj_consume_token(DOT);
795 | 5154 |
           t = jj_consume_token(WORD);
796 | 5154 |
                                                 element = t.image;
797 | 5154 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
798 |  |
           case LPAREN:
799 | 2132 |
             jj_consume_token(LPAREN);
800 | 2132 |
             argList = ArgList();
801 | 2132 |
             jj_consume_token(RPAREN);
802 | 2132 |
              element = new PropertyMethodBuilder((String) element, argList);
803 | 2132 |
             break;
804 |  |
           default:
805 | 3022 |
             jj_la1[29] = jj_gen;
806 |  |
             ;
807 |  |
           }
808 | 5154 |
           v.add(element);
809 |  |
         }
810 | 5838 |
       }
811 |  |
812 |  |
       final public Builder VariableReference() throws ParseException {
813 | 5838 |
       ArrayList v = new ArrayList();
814 |  |
       Token t;
815 | 5838 |
         jj_consume_token(DOLLAR);
816 | 5838 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
817 |  |
         case DOLLAR:
818 | 0 |
           t = jj_consume_token(DOLLAR);
819 | 0 |
                      warnDeprecated(DDOLLAR_FEATURE, t.beginLine, t.beginColumn);
820 | 0 |
           break;
821 |  |
         default:
822 | 5838 |
           jj_la1[30] = jj_gen;
823 |  |
           ;
824 |  |
         }
825 | 5838 |
         if (jj_2_8(2)) {
826 | 0 |
           t = jj_consume_token(WORD);
827 | 0 |
           jj_consume_token(SEMI);
828 | 0 |
                          v.add(t.image); warnDeprecated(SEMI_FEATURE, t.beginLine, t.beginColumn);
829 |  |
         } else {
830 | 5838 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
831 |  |
           case WORD:
832 | 5750 |
             VariableReferenceGuts(v);
833 | 5750 |
             break;
834 |  |
           case LPAREN:
835 | 88 |
             jj_consume_token(LPAREN);
836 | 88 |
             VariableReferenceGuts(v);
837 | 88 |
             jj_consume_token(RPAREN);
838 | 88 |
             break;
839 |  |
           default:
840 | 0 |
             jj_la1[31] = jj_gen;
841 | 0 |
             jj_consume_token(-1);
842 | 0 |
             throw new ParseException();
843 |  |
           }
844 |  |
         }
845 | 5838 |
         Object[] names = v.toArray();
846 | 5838 |
         return new VariableBuilder(names);
847 |  |
       }
848 |  |
849 |  |
     /* ********************** */
850 |  |
     /* Expression Productions */
851 |  |
     /* ********************** */
852 |  |
853 |  |
     /* Productions used in parsing WM expressions.  State: WM.
854 |  |
        Most general expression type is Expression() */
855 |  |
856 |  |
     // State: preserved
857 |  |
       final public Builder QuotedString() throws ParseException {
858 | 424 |
       int entryState = token_source.curLexState;
859 |  |
       Token t;
860 | 424 |
       QuotedStringBuilder qs = new QuotedStringBuilder();
861 |  |
       Object dr;
862 | 424 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
863 |  |
         case QUOTE:
864 | 424 |
           jj_consume_token(QUOTE);
865 | 424 |
                   SetState(QS);
866 |  |
           label_3:
867 |  |
           while (true) {
868 | 846 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
869 |  |
             case DOLLAR:
870 |  |
             case QCHAR:
871 |  |
             case SLASH:
872 |  |
             case QS_TEXT:
873 |  |
               ;
874 | 422 |
               break;
875 |  |
             default:
876 | 424 |
               jj_la1[32] = jj_gen;
877 | 424 |
               break label_3;
878 |  |
             }
879 | 422 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
880 |  |
             case QS_TEXT:
881 | 312 |
               t = jj_consume_token(QS_TEXT);
882 | 312 |
                         qs.addElement(t.image);
883 | 312 |
               break;
884 |  |
             case QCHAR:
885 | 0 |
               t = jj_consume_token(QCHAR);
886 | 0 |
                         qs.addElement(t.image.substring(1));
887 | 0 |
               break;
888 |  |
             case SLASH:
889 | 0 |
               t = jj_consume_token(SLASH);
890 | 0 |
                         qs.addElement(t.image);
891 | 0 |
               break;
892 |  |
             default:
893 | 110 |
               jj_la1[33] = jj_gen;
894 | 110 |
               if (jj_2_9(2147483647)) {
895 | 110 |
                 dr = DollarReference();
896 | 110 |
               qs.addElement(dr);
897 |  |
               } else {
898 | 0 |
                 jj_consume_token(-1);
899 | 0 |
                 throw new ParseException();
900 |  |
               }
901 |  |
             }
902 |  |
           }
903 | 424 |
           jj_consume_token(QUOTE);
904 | 424 |
           break;
905 |  |
         case SQUOTE:
906 | 0 |
           jj_consume_token(SQUOTE);
907 | 0 |
                    SetState(SQS);
908 |  |
           label_4:
909 |  |
           while (true) {
910 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
911 |  |
             case DOLLAR:
912 |  |
             case QCHAR:
913 |  |
             case SLASH:
914 |  |
             case SQS_TEXT:
915 |  |
               ;
916 | 0 |
               break;
917 |  |
             default:
918 | 0 |
               jj_la1[34] = jj_gen;
919 | 0 |
               break label_4;
920 |  |
             }
921 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
922 |  |
             case SQS_TEXT:
923 | 0 |
               t = jj_consume_token(SQS_TEXT);
924 | 0 |
                          qs.addElement(t.image);
925 | 0 |
               break;
926 |  |
             case QCHAR:
927 | 0 |
               t = jj_consume_token(QCHAR);
928 | 0 |
                         qs.addElement(t.image.substring(1));
929 | 0 |
               break;
930 |  |
             case SLASH:
931 | 0 |
               t = jj_consume_token(SLASH);
932 | 0 |
                         qs.addElement(t.image);
933 | 0 |
               break;
934 |  |
             default:
935 | 0 |
               jj_la1[35] = jj_gen;
936 | 0 |
               if (jj_2_10(2147483647)) {
937 | 0 |
                 dr = DollarReference();
938 | 0 |
               qs.addElement(dr);
939 |  |
               } else {
940 | 0 |
                 jj_consume_token(-1);
941 | 0 |
                 throw new ParseException();
942 |  |
               }
943 |  |
             }
944 |  |
           }
945 | 0 |
           jj_consume_token(SQUOTE);
946 | 0 |
           break;
947 |  |
         default:
948 | 0 |
           jj_la1[36] = jj_gen;
949 | 0 |
           jj_consume_token(-1);
950 | 0 |
           throw new ParseException();
951 |  |
         }
952 | 424 |
         SetState(entryState);
953 | 424 |
         return qs;
954 |  |
       }
955 |  |
956 |  |
     // State: WM
957 |  |
       final public Builder StringArg() throws ParseException {
958 |  |
       Builder b;
959 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
960 |  |
         case QUOTE:
961 |  |
         case SQUOTE:
962 | 0 |
           b = QuotedString();
963 | 0 |
           break;
964 |  |
         case DOLLAR:
965 | 0 |
           b = VariableReference();
966 | 0 |
           break;
967 |  |
         default:
968 | 0 |
           jj_la1[37] = jj_gen;
969 | 0 |
           jj_consume_token(-1);
970 | 0 |
           throw new ParseException();
971 |  |
         }
972 | 0 |
         return b;
973 |  |
       }
974 |  |
975 |  |
       final public MapBuilder MapArgList() throws ParseException {
976 | 0 |
         MapBuilder map = new MapBuilder();
977 |  |
         Object key, value;
978 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
979 |  |
         case LBRACE:
980 |  |
         case DOLLAR:
981 |  |
         case QUOTE:
982 |  |
         case SQUOTE:
983 |  |
         case NULL:
984 |  |
         case TRUE:
985 |  |
         case FALSE:
986 |  |
         case UNDEFINED:
987 |  |
         case LPAREN:
988 |  |
         case LBRACKET:
989 |  |
         case OP_MINUS:
990 |  |
         case OP_NOT:
991 |  |
         case NUMBER:
992 | 0 |
           key = Expression();
993 | 0 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
994 |  |
           case WS:
995 |  |
           case NEWLINE:
996 |  |
             label_5:
997 |  |
             while (true) {
998 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
999 |  |
               case WS:
1000 | 0 |
                 jj_consume_token(WS);
1001 | 0 |
                 break;
1002 |  |
               case NEWLINE:
1003 | 0 |
                 jj_consume_token(NEWLINE);
1004 | 0 |
                 break;
1005 |  |
               default:
1006 | 0 |
                 jj_la1[38] = jj_gen;
1007 | 0 |
                 jj_consume_token(-1);
1008 | 0 |
                 throw new ParseException();
1009 |  |
               }
1010 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1011 |  |
               case WS:
1012 |  |
               case NEWLINE:
1013 |  |
                 ;
1014 | 0 |
                 break;
1015 |  |
               default:
1016 | 0 |
                 jj_la1[39] = jj_gen;
1017 | 0 |
                 break label_5;
1018 |  |
               }
1019 |  |
             }
1020 |  |
             break;
1021 |  |
           default:
1022 | 0 |
             jj_la1[40] = jj_gen;
1023 |  |
             ;
1024 |  |
           }
1025 | 0 |
           jj_consume_token(COLON);
1026 | 0 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1027 |  |
           case WS:
1028 |  |
           case NEWLINE:
1029 |  |
             label_6:
1030 |  |
             while (true) {
1031 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1032 |  |
               case WS:
1033 | 0 |
                 jj_consume_token(WS);
1034 | 0 |
                 break;
1035 |  |
               case NEWLINE:
1036 | 0 |
                 jj_consume_token(NEWLINE);
1037 | 0 |
                 break;
1038 |  |
               default:
1039 | 0 |
                 jj_la1[41] = jj_gen;
1040 | 0 |
                 jj_consume_token(-1);
1041 | 0 |
                 throw new ParseException();
1042 |  |
               }
1043 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1044 |  |
               case WS:
1045 |  |
               case NEWLINE:
1046 |  |
                 ;
1047 | 0 |
                 break;
1048 |  |
               default:
1049 | 0 |
                 jj_la1[42] = jj_gen;
1050 | 0 |
                 break label_6;
1051 |  |
               }
1052 |  |
             }
1053 |  |
             break;
1054 |  |
           default:
1055 | 0 |
             jj_la1[43] = jj_gen;
1056 |  |
             ;
1057 |  |
           }
1058 | 0 |
           value = Expression();
1059 | 0 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1060 |  |
           case WS:
1061 |  |
           case NEWLINE:
1062 |  |
             label_7:
1063 |  |
             while (true) {
1064 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1065 |  |
               case WS:
1066 | 0 |
                 jj_consume_token(WS);
1067 | 0 |
                 break;
1068 |  |
               case NEWLINE:
1069 | 0 |
                 jj_consume_token(NEWLINE);
1070 | 0 |
                 break;
1071 |  |
               default:
1072 | 0 |
                 jj_la1[44] = jj_gen;
1073 | 0 |
                 jj_consume_token(-1);
1074 | 0 |
                 throw new ParseException();
1075 |  |
               }
1076 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1077 |  |
               case WS:
1078 |  |
               case NEWLINE:
1079 |  |
                 ;
1080 | 0 |
                 break;
1081 |  |
               default:
1082 | 0 |
                 jj_la1[45] = jj_gen;
1083 | 0 |
                 break label_7;
1084 |  |
               }
1085 |  |
             }
1086 |  |
             break;
1087 |  |
           default:
1088 | 0 |
             jj_la1[46] = jj_gen;
1089 |  |
             ;
1090 |  |
           }
1091 | 0 |
                                                                                                                    map.put(key, value);
1092 |  |
           label_8:
1093 |  |
           while (true) {
1094 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1095 |  |
             case COMMA:
1096 |  |
               ;
1097 | 0 |
               break;
1098 |  |
             default:
1099 | 0 |
               jj_la1[47] = jj_gen;
1100 | 0 |
               break label_8;
1101 |  |
             }
1102 | 0 |
             jj_consume_token(COMMA);
1103 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1104 |  |
             case WS:
1105 |  |
             case NEWLINE:
1106 |  |
               label_9:
1107 |  |
               while (true) {
1108 | 0 |
                 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1109 |  |
                 case WS:
1110 | 0 |
                   jj_consume_token(WS);
1111 | 0 |
                   break;
1112 |  |
                 case NEWLINE:
1113 | 0 |
                   jj_consume_token(NEWLINE);
1114 | 0 |
                   break;
1115 |  |
                 default:
1116 | 0 |
                   jj_la1[48] = jj_gen;
1117 | 0 |
                   jj_consume_token(-1);
1118 | 0 |
                   throw new ParseException();
1119 |  |
                 }
1120 | 0 |
                 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1121 |  |
                 case WS:
1122 |  |
                 case NEWLINE:
1123 |  |
                   ;
1124 | 0 |
                   break;
1125 |  |
                 default:
1126 | 0 |
                   jj_la1[49] = jj_gen;
1127 | 0 |
                   break label_9;
1128 |  |
                 }
1129 |  |
               }
1130 |  |
               break;
1131 |  |
             default:
1132 | 0 |
               jj_la1[50] = jj_gen;
1133 |  |
               ;
1134 |  |
             }
1135 | 0 |
             key = Expression();
1136 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1137 |  |
             case WS:
1138 |  |
             case NEWLINE:
1139 |  |
               label_10:
1140 |  |
               while (true) {
1141 | 0 |
                 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1142 |  |
                 case WS:
1143 | 0 |
                   jj_consume_token(WS);
1144 | 0 |
                   break;
1145 |  |
                 case NEWLINE:
1146 | 0 |
                   jj_consume_token(NEWLINE);
1147 | 0 |
                   break;
1148 |  |
                 default:
1149 | 0 |
                   jj_la1[51] = jj_gen;
1150 | 0 |
                   jj_consume_token(-1);
1151 | 0 |
                   throw new ParseException();
1152 |  |
                 }
1153 | 0 |
                 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1154 |  |
                 case WS:
1155 |  |
                 case NEWLINE:
1156 |  |
                   ;
1157 | 0 |
                   break;
1158 |  |
                 default:
1159 | 0 |
                   jj_la1[52] = jj_gen;
1160 | 0 |
                   break label_10;
1161 |  |
                 }
1162 |  |
               }
1163 |  |
               break;
1164 |  |
             default:
1165 | 0 |
               jj_la1[53] = jj_gen;
1166 |  |
               ;
1167 |  |
             }
1168 | 0 |
             jj_consume_token(COLON);
1169 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1170 |  |
             case WS:
1171 |  |
             case NEWLINE:
1172 |  |
               label_11:
1173 |  |
               while (true) {
1174 | 0 |
                 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1175 |  |
                 case WS:
1176 | 0 |
                   jj_consume_token(WS);
1177 | 0 |
                   break;
1178 |  |
                 case NEWLINE:
1179 | 0 |
                   jj_consume_token(NEWLINE);
1180 | 0 |
                   break;
1181 |  |
                 default:
1182 | 0 |
                   jj_la1[54] = jj_gen;
1183 | 0 |
                   jj_consume_token(-1);
1184 | 0 |
                   throw new ParseException();
1185 |  |
                 }
1186 | 0 |
                 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1187 |  |
                 case WS:
1188 |  |
                 case NEWLINE:
1189 |  |
                   ;
1190 | 0 |
                   break;
1191 |  |
                 default:
1192 | 0 |
                   jj_la1[55] = jj_gen;
1193 | 0 |
                   break label_11;
1194 |  |
                 }
1195 |  |
               }
1196 |  |
               break;
1197 |  |
             default:
1198 | 0 |
               jj_la1[56] = jj_gen;
1199 |  |
               ;
1200 |  |
             }
1201 | 0 |
             value = Expression();
1202 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1203 |  |
             case WS:
1204 |  |
             case NEWLINE:
1205 |  |
               label_12:
1206 |  |
               while (true) {
1207 | 0 |
                 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1208 |  |
                 case WS:
1209 | 0 |
                   jj_consume_token(WS);
1210 | 0 |
                   break;
1211 |  |
                 case NEWLINE:
1212 | 0 |
                   jj_consume_token(NEWLINE);
1213 | 0 |
                   break;
1214 |  |
                 default:
1215 | 0 |
                   jj_la1[57] = jj_gen;
1216 | 0 |
                   jj_consume_token(-1);
1217 | 0 |
                   throw new ParseException();
1218 |  |
                 }
1219 | 0 |
                 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1220 |  |
                 case WS:
1221 |  |
                 case NEWLINE:
1222 |  |
                   ;
1223 | 0 |
                   break;
1224 |  |
                 default:
1225 | 0 |
                   jj_la1[58] = jj_gen;
1226 | 0 |
                   break label_12;
1227 |  |
                 }
1228 |  |
               }
1229 |  |
               break;
1230 |  |
             default:
1231 | 0 |
               jj_la1[59] = jj_gen;
1232 |  |
               ;
1233 |  |
             }
1234 | 0 |
                                                                                                                                                       map.put(key, value);
1235 |  |
           }
1236 |  |
           break;
1237 |  |
         default:
1238 | 0 |
           jj_la1[60] = jj_gen;
1239 |  |
           ;
1240 |  |
         }
1241 | 0 |
         return map;
1242 |  |
       }
1243 |  |
1244 |  |
       final public MapBuilder CurlyMap() throws ParseException {
1245 |  |
         MapBuilder map;
1246 | 0 |
         jj_consume_token(LBRACE);
1247 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1248 |  |
         case WS:
1249 |  |
         case NEWLINE:
1250 |  |
           label_13:
1251 |  |
           while (true) {
1252 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1253 |  |
             case WS:
1254 | 0 |
               jj_consume_token(WS);
1255 | 0 |
               break;
1256 |  |
             case NEWLINE:
1257 | 0 |
               jj_consume_token(NEWLINE);
1258 | 0 |
               break;
1259 |  |
             default:
1260 | 0 |
               jj_la1[61] = jj_gen;
1261 | 0 |
               jj_consume_token(-1);
1262 | 0 |
               throw new ParseException();
1263 |  |
             }
1264 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1265 |  |
             case WS:
1266 |  |
             case NEWLINE:
1267 |  |
               ;
1268 | 0 |
               break;
1269 |  |
             default:
1270 | 0 |
               jj_la1[62] = jj_gen;
1271 | 0 |
               break label_13;
1272 |  |
             }
1273 |  |
           }
1274 |  |
           break;
1275 |  |
         default:
1276 | 0 |
           jj_la1[63] = jj_gen;
1277 |  |
           ;
1278 |  |
         }
1279 | 0 |
         map = MapArgList();
1280 | 0 |
                                                        SetState(DEFAULT);
1281 | 0 |
         jj_consume_token(RBRACE);
1282 | 0 |
                                                                                      SetState(WM);
1283 | 0 |
         return map;
1284 |  |
       }
1285 |  |
1286 |  |
       final public ListBuilder ArgList() throws ParseException {
1287 | 2132 |
       ListBuilder list = new ListBuilder();
1288 |  |
       Object e;
1289 | 2132 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1290 |  |
         case LBRACE:
1291 |  |
         case DOLLAR:
1292 |  |
         case QUOTE:
1293 |  |
         case SQUOTE:
1294 |  |
         case NULL:
1295 |  |
         case TRUE:
1296 |  |
         case FALSE:
1297 |  |
         case UNDEFINED:
1298 |  |
         case WS:
1299 |  |
         case LPAREN:
1300 |  |
         case LBRACKET:
1301 |  |
         case OP_MINUS:
1302 |  |
         case OP_NOT:
1303 |  |
         case NUMBER:
1304 | 1682 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1305 |  |
           case WS:
1306 | 0 |
             jj_consume_token(WS);
1307 | 0 |
             break;
1308 |  |
           default:
1309 | 1682 |
             jj_la1[64] = jj_gen;
1310 |  |
             ;
1311 |  |
           }
1312 | 1682 |
           e = Expression();
1313 | 1682 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1314 |  |
           case WS:
1315 | 0 |
             jj_consume_token(WS);
1316 | 0 |
             break;
1317 |  |
           default:
1318 | 1682 |
             jj_la1[65] = jj_gen;
1319 |  |
             ;
1320 |  |
           }
1321 | 1682 |
                                        list.addElement(e);
1322 |  |
           label_14:
1323 |  |
           while (true) {
1324 | 1816 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1325 |  |
             case COMMA:
1326 |  |
               ;
1327 | 134 |
               break;
1328 |  |
             default:
1329 | 1682 |
               jj_la1[66] = jj_gen;
1330 | 1682 |
               break label_14;
1331 |  |
             }
1332 | 134 |
             jj_consume_token(COMMA);
1333 | 134 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1334 |  |
             case WS:
1335 | 20 |
               jj_consume_token(WS);
1336 | 20 |
               break;
1337 |  |
             default:
1338 | 114 |
               jj_la1[67] = jj_gen;
1339 |  |
               ;
1340 |  |
             }
1341 | 134 |
             e = Expression();
1342 | 134 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1343 |  |
             case WS:
1344 | 0 |
               jj_consume_token(WS);
1345 | 0 |
               break;
1346 |  |
             default:
1347 | 134 |
               jj_la1[68] = jj_gen;
1348 |  |
               ;
1349 |  |
             }
1350 | 134 |
                                                  list.addElement(e);
1351 |  |
           }
1352 |  |
           break;
1353 |  |
         default:
1354 | 450 |
           jj_la1[69] = jj_gen;
1355 |  |
           ;
1356 |  |
         }
1357 | 2132 |
         return list;
1358 |  |
       }
1359 |  |
1360 |  |
       final public ListBuilder BracketList() throws ParseException {
1361 |  |
       ListBuilder list;
1362 | 0 |
         jj_consume_token(LBRACKET);
1363 | 0 |
         list = ArgList();
1364 | 0 |
         jj_consume_token(RBRACKET);
1365 | 0 |
         return list;
1366 |  |
       }
1367 |  |
1368 |  |
       final public Object[] FormalArgList() throws ParseException {
1369 | 0 |
       ArrayList list=new ArrayList();
1370 |  |
       Token name;
1371 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1372 |  |
         case LPAREN:
1373 | 0 |
           jj_consume_token(LPAREN);
1374 | 0 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1375 |  |
           case DOLLAR:
1376 |  |
           case WS:
1377 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1378 |  |
             case WS:
1379 | 0 |
               jj_consume_token(WS);
1380 | 0 |
               break;
1381 |  |
             default:
1382 | 0 |
               jj_la1[70] = jj_gen;
1383 |  |
               ;
1384 |  |
             }
1385 | 0 |
             jj_consume_token(DOLLAR);
1386 | 0 |
             name = jj_consume_token(WORD);
1387 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1388 |  |
             case WS:
1389 | 0 |
               jj_consume_token(WS);
1390 | 0 |
               break;
1391 |  |
             default:
1392 | 0 |
               jj_la1[71] = jj_gen;
1393 |  |
               ;
1394 |  |
             }
1395 | 0 |
                                                list.add(name.image);
1396 |  |
             label_15:
1397 |  |
             while (true) {
1398 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1399 |  |
               case COMMA:
1400 |  |
                 ;
1401 | 0 |
                 break;
1402 |  |
               default:
1403 | 0 |
                 jj_la1[72] = jj_gen;
1404 | 0 |
                 break label_15;
1405 |  |
               }
1406 | 0 |
               jj_consume_token(COMMA);
1407 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1408 |  |
               case WS:
1409 | 0 |
                 jj_consume_token(WS);
1410 | 0 |
                 break;
1411 |  |
               default:
1412 | 0 |
                 jj_la1[73] = jj_gen;
1413 |  |
                 ;
1414 |  |
               }
1415 | 0 |
               jj_consume_token(DOLLAR);
1416 | 0 |
               name = jj_consume_token(WORD);
1417 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1418 |  |
               case WS:
1419 | 0 |
                 jj_consume_token(WS);
1420 | 0 |
                 break;
1421 |  |
               default:
1422 | 0 |
                 jj_la1[74] = jj_gen;
1423 |  |
                 ;
1424 |  |
               }
1425 | 0 |
                                                        list.add(name.image);
1426 |  |
             }
1427 |  |
             break;
1428 |  |
           default:
1429 | 0 |
             jj_la1[75] = jj_gen;
1430 |  |
             ;
1431 |  |
           }
1432 | 0 |
           jj_consume_token(RPAREN);
1433 | 0 |
           break;
1434 |  |
         default:
1435 | 0 |
           jj_la1[76] = jj_gen;
1436 |  |
           ;
1437 |  |
         }
1438 | 0 |
         return list.toArray();
1439 |  |
       }
1440 |  |
1441 |  |
       final public ListBuilder MacroArgList() throws ParseException {
1442 | 0 |
       ListBuilder list=new ListBuilder();
1443 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1444 |  |
         case LPAREN:
1445 | 0 |
           jj_consume_token(LPAREN);
1446 | 0 |
           list = ArgList();
1447 | 0 |
           jj_consume_token(RPAREN);
1448 | 0 |
           break;
1449 |  |
         default:
1450 | 0 |
           jj_la1[77] = jj_gen;
1451 |  |
           ;
1452 |  |
         }
1453 | 0 |
         return list;
1454 |  |
       }
1455 |  |
1456 |  |
       final public Object Term() throws ParseException {
1457 |  |
       Object e;
1458 |  |
       Token t;
1459 | 3338 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1460 |  |
         case DOLLAR:
1461 | 2724 |
           e = VariableReference();
1462 | 2724 |
           break;
1463 |  |
         case LPAREN:
1464 | 6 |
           jj_consume_token(LPAREN);
1465 | 6 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1466 |  |
           case WS:
1467 | 0 |
             jj_consume_token(WS);
1468 | 0 |
             break;
1469 |  |
           default:
1470 | 6 |
             jj_la1[78] = jj_gen;
1471 |  |
             ;
1472 |  |
           }
1473 | 6 |
           e = Expression();
1474 | 6 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1475 |  |
           case WS:
1476 | 0 |
             jj_consume_token(WS);
1477 | 0 |
             break;
1478 |  |
           default:
1479 | 6 |
             jj_la1[79] = jj_gen;
1480 |  |
             ;
1481 |  |
           }
1482 | 6 |
           jj_consume_token(RPAREN);
1483 | 6 |
           break;
1484 |  |
         case QUOTE:
1485 |  |
         case SQUOTE:
1486 | 424 |
           e = QuotedString();
1487 | 424 |
           break;
1488 |  |
         case LBRACKET:
1489 | 0 |
           e = BracketList();
1490 | 0 |
           break;
1491 |  |
         case LBRACE:
1492 | 0 |
           e = CurlyMap();
1493 | 0 |
           break;
1494 |  |
         case NULL:
1495 | 54 |
           jj_consume_token(NULL);
1496 | 54 |
                              e = null;
1497 | 54 |
           break;
1498 |  |
         case TRUE:
1499 | 36 |
           jj_consume_token(TRUE);
1500 | 36 |
                              e = Boolean.TRUE;
1501 | 36 |
           break;
1502 |  |
         case FALSE:
1503 | 16 |
           jj_consume_token(FALSE);
1504 | 16 |
                              e = Boolean.FALSE;
1505 | 16 |
           break;
1506 |  |
         case UNDEFINED:
1507 | 0 |
           jj_consume_token(UNDEFINED);
1508 | 0 |
                              e = org.webmacro.engine.UndefinedMacro.getInstance();
1509 | 0 |
           break;
1510 |  |
         case OP_NOT:
1511 | 42 |
           jj_consume_token(OP_NOT);
1512 | 42 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1513 |  |
           case WS:
1514 | 0 |
             jj_consume_token(WS);
1515 | 0 |
             break;
1516 |  |
           default:
1517 | 42 |
             jj_la1[80] = jj_gen;
1518 |  |
             ;
1519 |  |
           }
1520 | 42 |
           e = Term();
1521 | 42 |
                                      e = new Expression.NotBuilder(e);
1522 | 42 |
           break;
1523 |  |
         case NUMBER:
1524 | 32 |
           t = jj_consume_token(NUMBER);
1525 | 32 |
             try { e = new Integer(t.image); }
1526 | 32 |
             catch (NumberFormatException ex) { e=null; }
1527 | 0 |
           break;
1528 |  |
         case OP_MINUS:
1529 | 4 |
           jj_consume_token(OP_MINUS);
1530 | 4 |
           t = jj_consume_token(NUMBER);
1531 | 4 |
             try { int i = Integer.parseInt(t.image); e = new Integer(-i); }
1532 | 4 |
             catch (NumberFormatException ex) { e=null; }
1533 | 0 |
           break;
1534 |  |
         default:
1535 | 0 |
           jj_la1[81] = jj_gen;
1536 | 0 |
           jj_consume_token(-1);
1537 | 0 |
           throw new ParseException();
1538 |  |
         }
1539 | 3338 |
         return e;
1540 |  |
       }
1541 |  |
1542 |  |
       final public Object Factor() throws ParseException {
1543 |  |
       Object e, e2;
1544 |  |
       Token op;
1545 | 3296 |
         e = Term();
1546 |  |
         label_16:
1547 |  |
         while (true) {
1548 | 3296 |
           if (jj_2_11(2)) {
1549 |  |
             ;
1550 |  |
           } else {
1551 |  |
             break label_16;
1552 |  |
           }
1553 | 0 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1554 |  |
           case WS:
1555 | 0 |
             jj_consume_token(WS);
1556 | 0 |
             break;
1557 |  |
           default:
1558 | 0 |
             jj_la1[82] = jj_gen;
1559 |  |
             ;
1560 |  |
           }
1561 | 0 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1562 |  |
           case OP_MULT:
1563 | 0 |
             op = jj_consume_token(OP_MULT);
1564 | 0 |
             break;
1565 |  |
           case OP_DIV:
1566 | 0 |
             op = jj_consume_token(OP_DIV);
1567 | 0 |
             break;
1568 |  |
           default:
1569 | 0 |
             jj_la1[83] = jj_gen;
1570 | 0 |
             jj_consume_token(-1);
1571 | 0 |
             throw new ParseException();
1572 |  |
           }
1573 | 0 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1574 |  |
           case WS:
1575 | 0 |
             jj_consume_token(WS);
1576 | 0 |
             break;
1577 |  |
           default:
1578 | 0 |
             jj_la1[84] = jj_gen;
1579 |  |
             ;
1580 |  |
           }
1581 | 0 |
           e2 = Term();
1582 | 0 |
           if (op.kind == OP_MULT)
1583 | 0 |
             e = new Expression.MultiplyBuilder(e, e2);
1584 | 0 |
           else if (op.kind == OP_DIV)
1585 | 0 |
             e = new Expression.DivideBuilder(e, e2);
1586 |  |
           else
1587 | 0 |
             {if (true) throw new ParseException("internal parser error in Factor()");}
1588 |  |
         }
1589 | 3296 |
         return e;
1590 |  |
       }
1591 |  |
1592 |  |
       final public Object AExpression() throws ParseException {
1593 |  |
       Object e, e2;
1594 |  |
       Token op;
1595 | 3290 |
         e = Factor();
1596 |  |
         label_17:
1597 |  |
         while (true) {
1598 | 3296 |
           if (jj_2_12(2)) {
1599 |  |
             ;
1600 |  |
           } else {
1601 |  |
             break label_17;
1602 |  |
           }
1603 | 6 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1604 |  |
           case WS:
1605 | 6 |
             jj_consume_token(WS);
1606 | 6 |
             break;
1607 |  |
           default:
1608 | 0 |
             jj_la1[85] = jj_gen;
1609 |  |
             ;
1610 |  |
           }
1611 | 6 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1612 |  |
           case OP_PLUS:
1613 | 0 |
             op = jj_consume_token(OP_PLUS);
1614 | 0 |
             break;
1615 |  |
           case OP_MINUS:
1616 | 6 |
             op = jj_consume_token(OP_MINUS);
1617 | 6 |
             break;
1618 |  |
           default:
1619 | 0 |
             jj_la1[86] = jj_gen;
1620 | 0 |
             jj_consume_token(-1);
1621 | 0 |
             throw new ParseException();
1622 |  |
           }
1623 | 6 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1624 |  |
           case WS:
1625 | 6 |
             jj_consume_token(WS);
1626 | 6 |
             break;
1627 |  |
           default:
1628 | 0 |
             jj_la1[87] = jj_gen;
1629 |  |
             ;
1630 |  |
           }
1631 | 6 |
           e2 = Factor();
1632 | 6 |
           if (op.kind == OP_PLUS)
1633 | 0 |
             e = new Expression.AddBuilder(e, e2);
1634 | 6 |
           else if (op.kind == OP_MINUS)
1635 | 6 |
             e = new Expression.SubtractBuilder(e, e2);
1636 |  |
           else
1637 | 0 |
             {if (true) throw new ParseException("internal parser error in AExpression()");}
1638 |  |
         }
1639 | 3290 |
         return e;
1640 |  |
       }
1641 |  |
1642 |  |
       final public Token RelOp() throws ParseException {
1643 |  |
       Token t;
1644 | 112 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1645 |  |
         case OP_EQ:
1646 | 44 |
           t = jj_consume_token(OP_EQ);
1647 | 44 |
           break;
1648 |  |
         case OP_SET:
1649 | 0 |
           t = jj_consume_token(OP_SET);
1650 | 0 |
           break;
1651 |  |
         case OP_NE:
1652 | 58 |
           t = jj_consume_token(OP_NE);
1653 | 58 |
           break;
1654 |  |
         case OP_GT:
1655 | 8 |
           t = jj_consume_token(OP_GT);
1656 | 8 |
           break;
1657 |  |
         case OP_GE:
1658 | 0 |
           t = jj_consume_token(OP_GE);
1659 | 0 |
           break;
1660 |  |
         case OP_LE:
1661 | 0 |
           t = jj_consume_token(OP_LE);
1662 | 0 |
           break;
1663 |  |
         case OP_LT:
1664 | 2 |
           t = jj_consume_token(OP_LT);
1665 | 2 |
           break;
1666 |  |
         default:
1667 | 0 |
           jj_la1[88] = jj_gen;
1668 | 0 |
           jj_consume_token(-1);
1669 | 0 |
           throw new ParseException();
1670 |  |
         }
1671 | 112 |
         return t;
1672 |  |
       }
1673 |  |
1674 |  |
       final public Object CExpression() throws ParseException {
1675 |  |
       // Note that CExpression is a little different from other binary
1676 |  |
       // expression rules, as we don't want to accept a == b == c
1677 |  |
       // Thanks to Aldona Majorek for pointing this out
1678 |  |
1679 | 3178 |
       Object e1, e2=null;
1680 | 3178 |
       Token op=null;
1681 | 3178 |
         e1 = AExpression();
1682 | 3178 |
         if (jj_2_13(2)) {
1683 | 112 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1684 |  |
           case WS:
1685 | 112 |
             jj_consume_token(WS);
1686 | 112 |
             break;
1687 |  |
           default:
1688 | 0 |
             jj_la1[89] = jj_gen;
1689 |  |
             ;
1690 |  |
           }
1691 | 112 |
           op = RelOp();
1692 | 112 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1693 |  |
           case WS:
1694 | 112 |
             jj_consume_token(WS);
1695 | 112 |
             break;
1696 |  |
           default:
1697 | 0 |
             jj_la1[90] = jj_gen;
1698 |  |
             ;
1699 |  |
           }
1700 | 112 |
           e2 = AExpression();
1701 |  |
         } else {
1702 |  |
           ;
1703 |  |
         }
1704 | 3178 |
         if (op == null)
1705 | 3066 |
           return e1;
1706 | 112 |
         else switch (op.kind) {
1707 | 44 |
           case OP_EQ:  {if (true) return new Expression.CompareEqBuilder(e1, e2);}
1708 | 0 |
           case OP_SET: {if (true) return new Expression.CompareEqBuilder(e1, e2);}
1709 | 58 |
           case OP_NE:  {if (true) return new Expression.CompareNeBuilder(e1, e2);}
1710 | 8 |
           case OP_GT:  {if (true) return new Expression.CompareGtBuilder(e1, e2);}
1711 | 0 |
           case OP_GE:  {if (true) return new Expression.CompareGeBuilder(e1, e2);}
1712 | 0 |
           case OP_LE:  {if (true) return new Expression.CompareLeBuilder(e1, e2);}
1713 | 2 |
           case OP_LT:  {if (true) return new Expression.CompareLtBuilder(e1, e2);}
1714 |  |
           default:
1715 | 0 |
             throw new ParseException("internal parser error in CExpression()");
1716 |  |
         }
1717 |  |
       }
1718 |  |
1719 |  |
       final public Object AndExpression() throws ParseException {
1720 |  |
       Object e, e2;
1721 | 3124 |
         e = CExpression();
1722 |  |
         label_18:
1723 |  |
         while (true) {
1724 | 3178 |
           if (jj_2_14(2)) {
1725 |  |
             ;
1726 |  |
           } else {
1727 |  |
             break label_18;
1728 |  |
           }
1729 | 54 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1730 |  |
           case WS:
1731 | 54 |
             jj_consume_token(WS);
1732 | 54 |
             break;
1733 |  |
           default:
1734 | 0 |
             jj_la1[91] = jj_gen;
1735 |  |
             ;
1736 |  |
           }
1737 | 54 |
           jj_consume_token(OP_AND);
1738 | 54 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1739 |  |
           case WS:
1740 | 54 |
             jj_consume_token(WS);
1741 | 54 |
             break;
1742 |  |
           default:
1743 | 0 |
             jj_la1[92] = jj_gen;
1744 |  |
             ;
1745 |  |
           }
1746 | 54 |
           e2 = CExpression();
1747 | 54 |
           e = new Expression.AndBuilder(e, e2);
1748 |  |
         }
1749 | 3124 |
         return e;
1750 |  |
       }
1751 |  |
1752 |  |
       final public Object OrExpression() throws ParseException {
1753 |  |
       Object e, e2;
1754 | 3106 |
         e = AndExpression();
1755 |  |
         label_19:
1756 |  |
         while (true) {
1757 | 3124 |
           if (jj_2_15(2)) {
1758 |  |
             ;
1759 |  |
           } else {
1760 |  |
             break label_19;
1761 |  |
           }
1762 | 18 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1763 |  |
           case WS:
1764 | 18 |
             jj_consume_token(WS);
1765 | 18 |
             break;
1766 |  |
           default:
1767 | 0 |
             jj_la1[93] = jj_gen;
1768 |  |
             ;
1769 |  |
           }
1770 | 18 |
           jj_consume_token(OP_OR);
1771 | 18 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1772 |  |
           case WS:
1773 | 18 |
             jj_consume_token(WS);
1774 | 18 |
             break;
1775 |  |
           default:
1776 | 0 |
             jj_la1[94] = jj_gen;
1777 |  |
             ;
1778 |  |
           }
1779 | 18 |
           e2 = AndExpression();
1780 | 18 |
           e = new Expression.OrBuilder(e, e2);
1781 |  |
         }
1782 | 3106 |
         return e;
1783 |  |
       }
1784 |  |
1785 |  |
       final public Object Expression() throws ParseException {
1786 | 3106 |
       Object e=null;
1787 | 3106 |
         e = OrExpression();
1788 | 3106 |
         return e;
1789 |  |
       }
1790 |  |
1791 |  |
       void EatWsNl() throws ParseException {
1792 | 0 |
       int entryState = token_source.curLexState;
1793 | 0 |
       SetState(WM);
1794 | 0 |
       OptionalWsNl();
1795 | 0 |
       SetState(entryState);
1796 | 0 |
       }
1797 |  |
1798 |  |
     // Parses an entire directive.  Treats # as text if the previous character
1799 |  |
     // is a letter, digit, or certain special characters (=, ', ")
1800 |  |
       final public void Directive(ParserBlockBuilder b) throws ParseException {
1801 |  |
       Token t;
1802 |  |
       Object o;
1803 | 1350 |
         jj_consume_token(POUND);
1804 | 1350 |
         SetState(WM);
1805 | 1350 |
         if (jj_2_16(2147483647) && (b.directiveOk())) {
1806 | 1288 |
           t = jj_consume_token(WORD);
1807 | 1288 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1808 |  |
           case WS:
1809 | 1210 |
             jj_consume_token(WS);
1810 | 1210 |
             break;
1811 |  |
           default:
1812 | 78 |
             jj_la1[95] = jj_gen;
1813 |  |
             ;
1814 |  |
           }
1815 | 1288 |
           o = parse_directive(t.image);
1816 | 1284 |
              b.eatTrailingWsNl(); b.addElement(o, t.beginLine, t.beginColumn);
1817 |  |
         } else {
1818 | 62 |
             b.addElement("#");
1819 |  |
         }
1820 | 1346 |
         SetState(DEFAULT);
1821 | 1346 |
       }
1822 |  |
1823 |  |
     // Parses an entire directive.  Treats ## as text if the previous character
1824 |  |
     // is a letter, digit, or certain special characters (=, ', ")
1825 |  |
       final public void Comment(ParserBlockBuilder b) throws ParseException {
1826 | 7204 |
         jj_consume_token(POUNDPOUND);
1827 | 7204 |
         SetState(COMMENT);
1828 | 7204 |
         if (b.directiveOk()) {
1829 | 7204 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1830 |  |
           case RESTOFLINE:
1831 | 5018 |
             jj_consume_token(RESTOFLINE);
1832 | 5018 |
             break;
1833 |  |
           default:
1834 | 2186 |
             jj_la1[96] = jj_gen;
1835 |  |
             ;
1836 |  |
           }
1837 | 7204 |
                              b.eatTrailingWsNl();
1838 |  |
         } else {
1839 | 0 |
             b.addElement("##");
1840 |  |
         }
1841 | 7204 |
         SetState(DEFAULT);
1842 | 7204 |
       }
1843 |  |
1844 |  |
       final public Object DollarReference() throws ParseException {
1845 | 2716 |
       int entryState = token_source.curLexState;
1846 |  |
       Object o;
1847 | 2716 |
         SetState(WM);
1848 | 2716 |
         if (jj_2_17(2147483647)) {
1849 | 2608 |
           o = VariableReference();
1850 |  |
         } else {
1851 | 108 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1852 |  |
           case DOLLAR:
1853 | 108 |
             jj_consume_token(DOLLAR);
1854 | 108 |
                      o = "$";
1855 | 108 |
             break;
1856 |  |
           default:
1857 | 0 |
             jj_la1[97] = jj_gen;
1858 | 0 |
             jj_consume_token(-1);
1859 | 0 |
             throw new ParseException();
1860 |  |
           }
1861 |  |
         }
1862 | 2716 |
         SetState(entryState);
1863 | 2716 |
         return o;
1864 |  |
       }
1865 |  |
1866 |  |
       final public void WMContent(ParserBlockBuilder b) throws ParseException {
1867 |  |
       Token t;
1868 |  |
       Object dr;
1869 | 18184 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1870 |  |
         case STUFF:
1871 | 9108 |
           t = jj_consume_token(STUFF);
1872 | 9108 |
                           b.addElement(t.image);
1873 | 9108 |
           break;
1874 |  |
         case QCHAR:
1875 | 144 |
           t = jj_consume_token(QCHAR);
1876 | 144 |
                           b.addElement(t.image.substring(1)); b.markLiteral();
1877 | 144 |
           break;
1878 |  |
         case SLASH:
1879 | 0 |
           t = jj_consume_token(SLASH);
1880 | 0 |
                           b.addElement(t.image);
1881 | 0 |
           break;
1882 |  |
         case POUND:
1883 | 638 |
           Directive(b);
1884 | 634 |
           break;
1885 |  |
         case POUNDPOUND:
1886 | 7202 |
           Comment(b);
1887 | 7202 |
           break;
1888 |  |
         default:
1889 | 1092 |
           jj_la1[98] = jj_gen;
1890 | 1092 |
           if (jj_2_18(2147483647)) {
1891 | 1092 |
                                 t=getToken(1);
1892 | 1092 |
             dr = DollarReference();
1893 | 1092 |
             b.addElement(dr, t.beginLine, t.beginColumn);
1894 |  |
           } else {
1895 | 0 |
             jj_consume_token(-1);
1896 | 0 |
             throw new ParseException();
1897 |  |
           }
1898 |  |
         }
1899 | 18180 |
       }
1900 |  |
1901 |  |
       final public void WMContentNoDirective(ParserBlockBuilder b) throws ParseException {
1902 |  |
       Token t;
1903 |  |
       Object dr;
1904 | 4966 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1905 |  |
         case STUFF:
1906 | 3342 |
           t = jj_consume_token(STUFF);
1907 | 3342 |
                           b.addElement(t.image);
1908 | 3342 |
           break;
1909 |  |
         case QCHAR:
1910 | 108 |
           t = jj_consume_token(QCHAR);
1911 | 108 |
                           b.addElement(t.image.substring(1)); b.markLiteral();
1912 | 108 |
           break;
1913 |  |
         case SLASH:
1914 | 0 |
           t = jj_consume_token(SLASH);
1915 | 0 |
                           b.addElement(t.image);
1916 | 0 |
           break;
1917 |  |
         case POUNDPOUND:
1918 | 2 |
           Comment(b);
1919 | 2 |
           break;
1920 |  |
         default:
1921 | 1514 |
           jj_la1[99] = jj_gen;
1922 | 1514 |
           if (jj_2_19(2147483647)) {
1923 | 1514 |
                                 t=getToken(1);
1924 | 1514 |
             dr = DollarReference();
1925 | 1514 |
             b.addElement(dr, t.beginLine, t.beginColumn);
1926 |  |
           } else {
1927 | 0 |
             jj_consume_token(-1);
1928 | 0 |
             throw new ParseException();
1929 |  |
           }
1930 |  |
         }
1931 | 4966 |
       }
1932 |  |
1933 |  |
       final public void LiteralWMContent(ParserBlockBuilder b) throws ParseException {
1934 |  |
       Token t;
1935 | 0 |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1936 |  |
         case QCHAR:
1937 | 0 |
           t = jj_consume_token(QCHAR);
1938 | 0 |
                     b.addElement(t.image.substring(1));
1939 | 0 |
           break;
1940 |  |
         case STUFF:
1941 |  |
         case POUNDPOUND:
1942 |  |
         case DOLLAR:
1943 |  |
         case SLASH:
1944 |  |
         case POUND:
1945 | 0 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1946 |  |
           case STUFF:
1947 | 0 |
             t = jj_consume_token(STUFF);
1948 | 0 |
             break;
1949 |  |
           case SLASH:
1950 | 0 |
             t = jj_consume_token(SLASH);
1951 | 0 |
             break;
1952 |  |
           case POUND:
1953 | 0 |
             t = jj_consume_token(POUND);
1954 | 0 |
             break;
1955 |  |
           case DOLLAR:
1956 | 0 |
             t = jj_consume_token(DOLLAR);
1957 | 0 |
             break;
1958 |  |
           case POUNDPOUND:
1959 | 0 |
             t = jj_consume_token(POUNDPOUND);
1960 | 0 |
             break;
1961 |  |
           default:
1962 | 0 |
             jj_la1[100] = jj_gen;
1963 | 0 |
             jj_consume_token(-1);
1964 | 0 |
             throw new ParseException();
1965 |  |
           }
1966 | 0 |
             b.addElement(t.image);
1967 | 0 |
           break;
1968 |  |
         default:
1969 | 0 |
           jj_la1[101] = jj_gen;
1970 | 0 |
           jj_consume_token(-1);
1971 | 0 |
           throw new ParseException();
1972 |  |
         }
1973 | 0 |
       }
1974 |  |
1975 |  |
       final public BlockBuilder LiteralBlock() throws ParseException {
1976 | 0 |
       ParserBlockBuilder block = new ParserBlockBuilder(templateName);
1977 |  |
       Token t;
1978 | 0 |
         if (jj_2_20(2147483647)) {
1979 | 0 |
           jj_consume_token(LBRACE);
1980 |  |
           label_20:
1981 |  |
           while (true) {
1982 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1983 |  |
             case STUFF:
1984 |  |
             case END:
1985 |  |
             case BEGIN:
1986 |  |
             case POUNDPOUND:
1987 |  |
             case DOLLAR:
1988 |  |
             case QCHAR:
1989 |  |
             case SLASH:
1990 |  |
             case POUND:
1991 |  |
               ;
1992 | 0 |
               break;
1993 |  |
             default:
1994 | 0 |
               jj_la1[102] = jj_gen;
1995 | 0 |
               break label_20;
1996 |  |
             }
1997 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1998 |  |
             case STUFF:
1999 |  |
             case POUNDPOUND:
2000 |  |
             case DOLLAR:
2001 |  |
             case QCHAR:
2002 |  |
             case SLASH:
2003 |  |
             case POUND:
2004 | 0 |
               LiteralWMContent(block);
2005 | 0 |
               break;
2006 |  |
             case END:
2007 |  |
             case BEGIN:
2008 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2009 |  |
               case BEGIN:
2010 | 0 |
                 t = jj_consume_token(BEGIN);
2011 | 0 |
                 break;
2012 |  |
               case END:
2013 | 0 |
                 t = jj_consume_token(END);
2014 | 0 |
                 break;
2015 |  |
               default:
2016 | 0 |
                 jj_la1[103] = jj_gen;
2017 | 0 |
                 jj_consume_token(-1);
2018 | 0 |
                 throw new ParseException();
2019 |  |
               }
2020 | 0 |
                                             block.addElement(t.image);
2021 | 0 |
               break;
2022 |  |
             default:
2023 | 0 |
               jj_la1[104] = jj_gen;
2024 | 0 |
               jj_consume_token(-1);
2025 | 0 |
               throw new ParseException();
2026 |  |
             }
2027 |  |
           }
2028 | 0 |
           jj_consume_token(RBRACE);
2029 |  |
         } else {
2030 | 0 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2031 |  |
           case STUFF:
2032 |  |
           case RBRACE:
2033 |  |
           case END:
2034 |  |
           case BEGIN:
2035 |  |
           case LBRACE:
2036 |  |
           case POUNDPOUND:
2037 |  |
           case DOLLAR:
2038 |  |
           case QCHAR:
2039 |  |
           case SLASH:
2040 |  |
           case POUND:
2041 | 0 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2042 |  |
             case BEGIN:
2043 | 0 |
               jj_consume_token(BEGIN);
2044 | 0 |
               break;
2045 |  |
             default:
2046 | 0 |
               jj_la1[105] = jj_gen;
2047 |  |
               ;
2048 |  |
             }
2049 |  |
             label_21:
2050 |  |
             while (true) {
2051 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2052 |  |
               case STUFF:
2053 |  |
               case RBRACE:
2054 |  |
               case LBRACE:
2055 |  |
               case POUNDPOUND:
2056 |  |
               case DOLLAR:
2057 |  |
               case QCHAR:
2058 |  |
               case SLASH:
2059 |  |
               case POUND:
2060 |  |
                 ;
2061 | 0 |
                 break;
2062 |  |
               default:
2063 | 0 |
                 jj_la1[106] = jj_gen;
2064 | 0 |
                 break label_21;
2065 |  |
               }
2066 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2067 |  |
               case STUFF:
2068 |  |
               case POUNDPOUND:
2069 |  |
               case DOLLAR:
2070 |  |
               case QCHAR:
2071 |  |
               case SLASH:
2072 |  |
               case POUND:
2073 | 0 |
                 LiteralWMContent(block);
2074 | 0 |
                 break;
2075 |  |
               case RBRACE:
2076 |  |
               case LBRACE:
2077 | 0 |
                 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2078 |  |
                 case LBRACE:
2079 | 0 |
                   t = jj_consume_token(LBRACE);
2080 | 0 |
                   break;
2081 |  |
                 case RBRACE:
2082 | 0 |
                   t = jj_consume_token(RBRACE);
2083 | 0 |
                   break;
2084 |  |
                 default:
2085 | 0 |
                   jj_la1[107] = jj_gen;
2086 | 0 |
                   jj_consume_token(-1);
2087 | 0 |
                   throw new ParseException();
2088 |  |
                 }
2089 | 0 |
                                             block.addElement(t.image);
2090 | 0 |
                 break;
2091 |  |
               default:
2092 | 0 |
                 jj_la1[108] = jj_gen;
2093 | 0 |
                 jj_consume_token(-1);
2094 | 0 |
                 throw new ParseException();
2095 |  |
               }
2096 |  |
             }
2097 | 0 |
             jj_consume_token(END);
2098 | 0 |
             break;
2099 |  |
           default:
2100 | 0 |
             jj_la1[109] = jj_gen;
2101 | 0 |
             jj_consume_token(-1);
2102 | 0 |
             throw new ParseException();
2103 |  |
           }
2104 |  |
         }
2105 | 0 |
         return block;
2106 |  |
       }
2107 |  |
2108 |  |
       final public BlockBuilder Block(Subdirective[] subdirectives) throws ParseException {
2109 | 1260 |
       ParserBlockBuilder block = new ParserBlockBuilder(templateName);
2110 |  |
       Token t;
2111 | 1260 |
         blockStack.push(subdirectives);
2112 | 1260 |
         if (jj_2_23(2147483647)) {
2113 | 8 |
           jj_consume_token(LBRACE);
2114 | 8 |
           EatWsNlIfNl(block);
2115 |  |
           label_22:
2116 |  |
           while (true) {
2117 | 28 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2118 |  |
             case STUFF:
2119 |  |
             case END:
2120 |  |
             case BEGIN:
2121 |  |
             case POUNDPOUND:
2122 |  |
             case DOLLAR:
2123 |  |
             case QCHAR:
2124 |  |
             case SLASH:
2125 |  |
             case POUND:
2126 |  |
               ;
2127 | 20 |
               break;
2128 |  |
             default:
2129 | 8 |
               jj_la1[110] = jj_gen;
2130 | 8 |
               break label_22;
2131 |  |
             }
2132 | 20 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2133 |  |
             case STUFF:
2134 |  |
             case POUNDPOUND:
2135 |  |
             case DOLLAR:
2136 |  |
             case QCHAR:
2137 |  |
             case SLASH:
2138 |  |
             case POUND:
2139 | 20 |
               WMContent(block);
2140 | 20 |
               break;
2141 |  |
             case END:
2142 |  |
             case BEGIN:
2143 | 0 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2144 |  |
               case BEGIN:
2145 | 0 |
                 t = jj_consume_token(BEGIN);
2146 | 0 |
                 break;
2147 |  |
               case END:
2148 | 0 |
                 t = jj_consume_token(END);
2149 | 0 |
                 break;
2150 |  |
               default:
2151 | 0 |
                 jj_la1[111] = jj_gen;
2152 | 0 |
                 jj_consume_token(-1);
2153 | 0 |
                 throw new ParseException();
2154 |  |
               }
2155 | 0 |
                                           block.addElement(t.image);
2156 | 0 |
               break;
2157 |  |
             default:
2158 | 0 |
               jj_la1[112] = jj_gen;
2159 | 0 |
               jj_consume_token(-1);
2160 | 0 |
               throw new ParseException();
2161 |  |
             }
2162 |  |
           }
2163 | 8 |
           jj_consume_token(RBRACE);
2164 |  |
         } else {
2165 | 1252 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2166 |  |
           case BEGIN:
2167 | 1240 |
             jj_consume_token(BEGIN);
2168 | 1240 |
             EatWsNlOrSpace(block);
2169 | 1240 |
             break;
2170 |  |
           default:
2171 | 12 |
             jj_la1[113] = jj_gen;
2172 |  |
             ;
2173 |  |
           }
2174 |  |
           label_23:
2175 |  |
           while (true) {
2176 | 7062 |
             if (jj_2_21(1)) {
2177 |  |
               ;
2178 |  |
             } else {
2179 |  |
               break label_23;
2180 |  |
             }
2181 | 5810 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2182 |  |
             case STUFF:
2183 |  |
             case POUNDPOUND:
2184 |  |
             case DOLLAR:
2185 |  |
             case QCHAR:
2186 |  |
             case SLASH:
2187 | 4966 |
               WMContentNoDirective(block);
2188 | 4966 |
               break;
2189 |  |
             case 0:
2190 | 0 |
               jj_consume_token(0);
2191 | 0 |
               throw new ParseException("Unclosed block beginning at line " + token.beginLine + ".  Check for invalid directive options or missing a #end");
2192 |  |
             case RBRACE:
2193 |  |
             case LBRACE:
2194 | 132 |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2195 |  |
               case LBRACE:
2196 | 66 |
                 t = jj_consume_token(LBRACE);
2197 | 66 |
                 break;
2198 |  |
               case RBRACE:
2199 | 66 |
                 t = jj_consume_token(RBRACE);
2200 | 66 |
                 break;
2201 |  |
               default:
2202 | 0 |
                 jj_la1[114] = jj_gen;
2203 | 0 |
                 jj_consume_token(-1);
2204 | 0 |
                 throw new ParseException();
2205 |  |
               }
2206 | 132 |
                                           block.addElement(t.image);
2207 | 132 |
               break;
2208 |  |
             default:
2209 | 712 |
               jj_la1[115] = jj_gen;
2210 | 712 |
               if (jj_2_22(2147483647) && (lookahead_not_breaking_subd())) {
2211 | 712 |
                 Directive(block);
2212 |  |
               } else {
2213 | 0 |
                 jj_consume_token(-1);
2214 | 0 |
                 throw new ParseException();
2215 |  |
               }
2216 |  |
             }
2217 |  |
           }
2218 | 1252 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2219 |  |
           case END:
2220 | 1246 |
             jj_consume_token(END);
2221 | 1246 |
                        block.eatOneWs();
2222 | 1246 |
             break;
2223 |  |
           default:
2224 | 6 |
             jj_la1[116] = jj_gen;
2225 |  |
             ;
2226 |  |
           }
2227 |  |
         }
2228 | 1260 |
         blockStack.pop();
2229 | 1260 |
         return block;
2230 |  |
       }
2231 |  |
2232 |  |
       final public BlockBuilder WMDocument() throws ParseException {
2233 | 228 |
       ParserBlockBuilder block = new ParserBlockBuilder(templateName);
2234 |  |
       Token t;
2235 |  |
         label_24:
2236 |  |
         while (true) {
2237 | 18558 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2238 |  |
           case STUFF:
2239 |  |
           case RBRACE:
2240 |  |
           case END:
2241 |  |
           case BEGIN:
2242 |  |
           case LBRACE:
2243 |  |
           case POUNDPOUND:
2244 |  |
           case DOLLAR:
2245 |  |
           case QCHAR:
2246 |  |
           case SLASH:
2247 |  |
           case POUND:
2248 |  |
             ;
2249 | 18334 |
             break;
2250 |  |
           default:
2251 | 224 |
             jj_la1[117] = jj_gen;
2252 | 224 |
             break label_24;
2253 |  |
           }
2254 | 18334 |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2255 |  |
           case STUFF:
2256 |  |
           case POUNDPOUND:
2257 |  |
           case DOLLAR:
2258 |  |
           case QCHAR:
2259 |  |
           case SLASH:
2260 |  |
           case POUND:
2261 | 18164 |
             WMContent(block);
2262 | 18160 |
             break;
2263 |  |
           case RBRACE:
2264 |  |
           case END:
2265 |  |
           case BEGIN:
2266 |  |
           case LBRACE:
2267 | 170 |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2268 |  |
             case BEGIN:
2269 | 0 |
               t = jj_consume_token(BEGIN);
2270 | 0 |
               break;
2271 |  |
             case END:
2272 | 0 |
               t = jj_consume_token(END);
2273 | 0 |
               break;
2274 |  |
             case LBRACE:
2275 | 86 |
               t = jj_consume_token(LBRACE);
2276 | 86 |
               break;
2277 |  |
             case RBRACE:
2278 | 84 |
               t = jj_consume_token(RBRACE);
2279 | 84 |
               break;
2280 |  |
             default:
2281 | 0 |
               jj_la1[118] = jj_gen;
2282 | 0 |
               jj_consume_token(-1);
2283 | 0 |
               throw new ParseException();
2284 |  |
             }
2285 | 170 |
               block.addElement(t.image);
2286 | 170 |
             break;
2287 |  |
           default:
2288 | 0 |
             jj_la1[119] = jj_gen;
2289 | 0 |
             jj_consume_token(-1);
2290 | 0 |
             throw new ParseException();
2291 |  |
           }
2292 |  |
         }
2293 | 224 |
         jj_consume_token(0);
2294 | 224 |
         return block;
2295 |  |
       }
2296 |  |
2297 |  |
       private boolean jj_2_1(int xla) {
2298 | 8 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2299 | 8 |
         try { return !jj_3_1(); }
2300 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2301 | 8 |
         finally { jj_save(0, xla); }
2302 |  |
       }
2303 |  |
2304 |  |
       private boolean jj_2_2(int xla) {
2305 | 158 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2306 | 158 |
         try { return !jj_3_2(); }
2307 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2308 | 158 |
         finally { jj_save(1, xla); }
2309 |  |
       }
2310 |  |
2311 |  |
       private boolean jj_2_3(int xla) {
2312 | 1240 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2313 | 1240 |
         try { return !jj_3_3(); }
2314 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2315 | 1240 |
         finally { jj_save(2, xla); }
2316 |  |
       }
2317 |  |
2318 |  |
       private boolean jj_2_4(int xla) {
2319 | 158 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2320 | 158 |
         try { return !jj_3_4(); }
2321 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2322 | 158 |
         finally { jj_save(3, xla); }
2323 |  |
       }
2324 |  |
2325 |  |
       private boolean jj_2_5(int xla) {
2326 | 20 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2327 | 20 |
         try { return !jj_3_5(); }
2328 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2329 | 20 |
         finally { jj_save(4, xla); }
2330 |  |
       }
2331 |  |
2332 |  |
       private boolean jj_2_6(int xla) {
2333 | 5838 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2334 | 5838 |
         try { return !jj_3_6(); }
2335 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2336 | 5838 |
         finally { jj_save(5, xla); }
2337 |  |
       }
2338 |  |
2339 |  |
       private boolean jj_2_7(int xla) {
2340 | 10992 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2341 | 10992 |
         try { return !jj_3_7(); }
2342 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2343 | 10992 |
         finally { jj_save(6, xla); }
2344 |  |
       }
2345 |  |
2346 |  |
       private boolean jj_2_8(int xla) {
2347 | 5838 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2348 | 5838 |
         try { return !jj_3_8(); }
2349 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2350 | 5838 |
         finally { jj_save(7, xla); }
2351 |  |
       }
2352 |  |
2353 |  |
       private boolean jj_2_9(int xla) {
2354 | 110 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2355 | 110 |
         try { return !jj_3_9(); }
2356 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2357 | 110 |
         finally { jj_save(8, xla); }
2358 |  |
       }
2359 |  |
2360 |  |
       private boolean jj_2_10(int xla) {
2361 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2362 | 0 |
         try { return !jj_3_10(); }
2363 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2364 | 0 |
         finally { jj_save(9, xla); }
2365 |  |
       }
2366 |  |
2367 |  |
       private boolean jj_2_11(int xla) {
2368 | 3296 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2369 | 3296 |
         try { return !jj_3_11(); }
2370 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2371 | 3296 |
         finally { jj_save(10, xla); }
2372 |  |
       }
2373 |  |
2374 |  |
       private boolean jj_2_12(int xla) {
2375 | 3296 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2376 | 3296 |
         try { return !jj_3_12(); }
2377 | 6 |
         catch(LookaheadSuccess ls) { return true; }
2378 | 3296 |
         finally { jj_save(11, xla); }
2379 |  |
       }
2380 |  |
2381 |  |
       private boolean jj_2_13(int xla) {
2382 | 3178 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2383 | 3178 |
         try { return !jj_3_13(); }
2384 | 112 |
         catch(LookaheadSuccess ls) { return true; }
2385 | 3178 |
         finally { jj_save(12, xla); }
2386 |  |
       }
2387 |  |
2388 |  |
       private boolean jj_2_14(int xla) {
2389 | 3178 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2390 | 3178 |
         try { return !jj_3_14(); }
2391 | 54 |
         catch(LookaheadSuccess ls) { return true; }
2392 | 3178 |
         finally { jj_save(13, xla); }
2393 |  |
       }
2394 |  |
2395 |  |
       private boolean jj_2_15(int xla) {
2396 | 3124 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2397 | 3124 |
         try { return !jj_3_15(); }
2398 | 18 |
         catch(LookaheadSuccess ls) { return true; }
2399 | 3124 |
         finally { jj_save(14, xla); }
2400 |  |
       }
2401 |  |
2402 |  |
       private boolean jj_2_16(int xla) {
2403 | 1350 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2404 | 1350 |
         try { return !jj_3_16(); }
2405 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2406 | 1350 |
         finally { jj_save(15, xla); }
2407 |  |
       }
2408 |  |
2409 |  |
       private boolean jj_2_17(int xla) {
2410 | 2716 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2411 | 2716 |
         try { return !jj_3_17(); }
2412 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2413 | 2716 |
         finally { jj_save(16, xla); }
2414 |  |
       }
2415 |  |
2416 |  |
       private boolean jj_2_18(int xla) {
2417 | 1092 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2418 | 1092 |
         try { return !jj_3_18(); }
2419 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2420 | 1092 |
         finally { jj_save(17, xla); }
2421 |  |
       }
2422 |  |
2423 |  |
       private boolean jj_2_19(int xla) {
2424 | 1514 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2425 | 1514 |
         try { return !jj_3_19(); }
2426 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2427 | 1514 |
         finally { jj_save(18, xla); }
2428 |  |
       }
2429 |  |
2430 |  |
       private boolean jj_2_20(int xla) {
2431 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2432 | 0 |
         try { return !jj_3_20(); }
2433 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2434 | 0 |
         finally { jj_save(19, xla); }
2435 |  |
       }
2436 |  |
2437 |  |
       private boolean jj_2_21(int xla) {
2438 | 7062 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2439 | 7062 |
         try { return !jj_3_21(); }
2440 | 5810 |
         catch(LookaheadSuccess ls) { return true; }
2441 | 7062 |
         finally { jj_save(20, xla); }
2442 |  |
       }
2443 |  |
2444 |  |
       private boolean jj_2_22(int xla) {
2445 | 712 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2446 | 712 |
         try { return !jj_3_22(); }
2447 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2448 | 712 |
         finally { jj_save(21, xla); }
2449 |  |
       }
2450 |  |
2451 |  |
       private boolean jj_2_23(int xla) {
2452 | 1260 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2453 | 1260 |
         try { return !jj_3_23(); }
2454 | 0 |
         catch(LookaheadSuccess ls) { return true; }
2455 | 1260 |
         finally { jj_save(22, xla); }
2456 |  |
       }
2457 |  |
2458 |  |
       private boolean jj_3_5() {
2459 | 20 |
         if (jj_scan_token(WS)) return true;
2460 |  |
         Token xsp;
2461 | 20 |
         xsp = jj_scanpos;
2462 | 20 |
         if (jj_scan_token(14)) {
2463 | 16 |
         jj_scanpos = xsp;
2464 | 16 |
         if (jj_scan_token(15)) return true;
2465 |  |
         }
2466 | 8 |
         return false;
2467 |  |
       }
2468 |  |
2469 |  |
       private boolean jj_3R_28() {
2470 | 0 |
         if (jj_3R_26()) return true;
2471 | 0 |
         return false;
2472 |  |
       }
2473 |  |
2474 |  |
       private boolean jj_3_19() {
2475 | 1514 |
         if (jj_scan_token(DOLLAR)) return true;
2476 | 1514 |
         return false;
2477 |  |
       }
2478 |  |
2479 |  |
       private boolean jj_3R_52() {
2480 | 0 |
         if (jj_scan_token(LBRACE)) return true;
2481 | 0 |
         return false;
2482 |  |
       }
2483 |  |
2484 |  |
       private boolean jj_3_6() {
2485 | 5838 |
         if (jj_scan_token(WORD)) return true;
2486 | 5838 |
         if (jj_scan_token(LPAREN)) return true;
2487 | 0 |
         return false;
2488 |  |
       }
2489 |  |
2490 |  |
       private boolean jj_3R_57() {
2491 | 3610 |
         if (jj_3R_61()) return true;
2492 | 0 |
         return false;
2493 |  |
       }
2494 |  |
2495 |  |
       private boolean jj_3R_56() {
2496 | 3612 |
         if (jj_3R_60()) return true;
2497 | 0 |
         return false;
2498 |  |
       }
2499 |  |
2500 |  |
       private boolean jj_3R_55() {
2501 | 3612 |
         if (jj_scan_token(SLASH)) return true;
2502 | 0 |
         return false;
2503 |  |
       }
2504 |  |
2505 |  |
       private boolean jj_3R_54() {
2506 | 3720 |
         if (jj_scan_token(QCHAR)) return true;
2507 | 0 |
         return false;
2508 |  |
       }
2509 |  |
2510 |  |
       private boolean jj_3_2() {
2511 | 158 |
         if (jj_scan_token(NEWLINE)) return true;
2512 | 128 |
         return false;
2513 |  |
       }
2514 |  |
2515 |  |
       private boolean jj_3_11() {
2516 |  |
         Token xsp;
2517 | 3296 |
         xsp = jj_scanpos;
2518 | 3296 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2519 | 3296 |
         xsp = jj_scanpos;
2520 | 3296 |
         if (jj_scan_token(47)) {
2521 | 3296 |
         jj_scanpos = xsp;
2522 | 3296 |
         if (jj_scan_token(48)) return true;
2523 |  |
         }
2524 | 0 |
         xsp = jj_scanpos;
2525 | 0 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2526 | 0 |
         if (jj_3R_25()) return true;
2527 | 0 |
         return false;
2528 |  |
       }
2529 |  |
2530 |  |
       private boolean jj_3_18() {
2531 | 1092 |
         if (jj_scan_token(DOLLAR)) return true;
2532 | 1092 |
         return false;
2533 |  |
       }
2534 |  |
2535 |  |
       private boolean jj_3R_53() {
2536 | 7062 |
         if (jj_scan_token(STUFF)) return true;
2537 | 0 |
         return false;
2538 |  |
       }
2539 |  |
2540 |  |
       private boolean jj_3_15() {
2541 |  |
         Token xsp;
2542 | 3124 |
         xsp = jj_scanpos;
2543 | 3124 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2544 | 3124 |
         if (jj_scan_token(OP_OR)) return true;
2545 | 0 |
         xsp = jj_scanpos;
2546 | 0 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2547 | 0 |
         if (jj_3R_30()) return true;
2548 | 0 |
         return false;
2549 |  |
       }
2550 |  |
2551 |  |
       private boolean jj_3R_47() {
2552 |  |
         Token xsp;
2553 | 7062 |
         xsp = jj_scanpos;
2554 | 7062 |
         if (jj_3R_53()) {
2555 | 3720 |
         jj_scanpos = xsp;
2556 | 3720 |
         if (jj_3R_54()) {
2557 | 3612 |
         jj_scanpos = xsp;
2558 | 3612 |
         if (jj_3R_55()) {
2559 | 3612 |
         jj_scanpos = xsp;
2560 | 3612 |
         if (jj_3R_56()) {
2561 | 3610 |
         jj_scanpos = xsp;
2562 | 3610 |
         if (jj_3R_57()) return true;
2563 |  |
         }
2564 |  |
         }
2565 |  |
         }
2566 |  |
         }
2567 | 0 |
         return false;
2568 |  |
       }
2569 |  |
2570 |  |
       private boolean jj_3R_26() {
2571 | 0 |
         if (jj_3R_25()) return true;
2572 | 0 |
         return false;
2573 |  |
       }
2574 |  |
2575 |  |
       private boolean jj_3_4() {
2576 | 158 |
         if (jj_scan_token(WS)) return true;
2577 | 158 |
         return false;
2578 |  |
       }
2579 |  |
2580 |  |
       private boolean jj_3R_46() {
2581 | 0 |
         if (jj_scan_token(OP_MINUS)) return true;
2582 | 0 |
         return false;
2583 |  |
       }
2584 |  |
2585 |  |
       private boolean jj_3_10() {
2586 | 0 |
         if (jj_scan_token(DOLLAR)) return true;
2587 | 0 |
         return false;
2588 |  |
       }
2589 |  |
2590 |  |
       private boolean jj_3_3() {
2591 | 1240 |
         if (jj_scan_token(NEWLINE)) return true;
2592 | 1082 |
         return false;
2593 |  |
       }
2594 |  |
2595 |  |
       private boolean jj_3R_45() {
2596 | 0 |
         if (jj_scan_token(NUMBER)) return true;
2597 | 0 |
         return false;
2598 |  |
       }
2599 |  |
2600 |  |
       private boolean jj_3R_44() {
2601 | 0 |
         if (jj_scan_token(OP_NOT)) return true;
2602 | 0 |
         return false;
2603 |  |
       }
2604 |  |
2605 |  |
       private boolean jj_3R_43() {
2606 | 0 |
         if (jj_scan_token(UNDEFINED)) return true;
2607 | 0 |
         return false;
2608 |  |
       }
2609 |  |
2610 |  |
       private boolean jj_3_14() {
2611 |  |
         Token xsp;
2612 | 3178 |
         xsp = jj_scanpos;
2613 | 3178 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2614 | 3178 |
         if (jj_scan_token(OP_AND)) return true;
2615 | 0 |
         xsp = jj_scanpos;
2616 | 0 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2617 | 0 |
         if (jj_3R_29()) return true;
2618 | 0 |
         return false;
2619 |  |
       }
2620 |  |
2621 |  |
       private boolean jj_3R_42() {
2622 | 0 |
         if (jj_scan_token(FALSE)) return true;
2623 | 0 |
         return false;
2624 |  |
       }
2625 |  |
2626 |  |
       private boolean jj_3R_41() {
2627 | 0 |
         if (jj_scan_token(TRUE)) return true;
2628 | 0 |
         return false;
2629 |  |
       }
2630 |  |
2631 |  |
       private boolean jj_3R_40() {
2632 | 0 |
         if (jj_scan_token(NULL)) return true;
2633 | 0 |
         return false;
2634 |  |
       }
2635 |  |
2636 |  |
       private boolean jj_3R_39() {
2637 | 0 |
         if (jj_3R_52()) return true;
2638 | 0 |
         return false;
2639 |  |
       }
2640 |  |
2641 |  |
       private boolean jj_3_9() {
2642 | 110 |
         if (jj_scan_token(DOLLAR)) return true;
2643 | 110 |
         return false;
2644 |  |
       }
2645 |  |
2646 |  |
       private boolean jj_3R_30() {
2647 | 0 |
         if (jj_3R_29()) return true;
2648 | 0 |
         return false;
2649 |  |
       }
2650 |  |
2651 |  |
       private boolean jj_3_22() {
2652 | 712 |
         if (jj_scan_token(POUND)) return true;
2653 | 712 |
         return false;
2654 |  |
       }
2655 |  |
2656 |  |
       private boolean jj_3R_38() {
2657 | 0 |
         if (jj_3R_51()) return true;
2658 | 0 |
         return false;
2659 |  |
       }
2660 |  |
2661 |  |
       private boolean jj_3_17() {
2662 | 2716 |
         if (jj_scan_token(DOLLAR)) return true;
2663 |  |
         Token xsp;
2664 | 2716 |
         xsp = jj_scanpos;
2665 | 2716 |
         if (jj_scan_token(20)) jj_scanpos = xsp;
2666 | 2716 |
         xsp = jj_scanpos;
2667 | 2716 |
         if (jj_scan_token(32)) jj_scanpos = xsp;
2668 | 2716 |
         if (jj_scan_token(WORD)) return true;
2669 | 2608 |
         return false;
2670 |  |
       }
2671 |  |
2672 |  |
       private boolean jj_3R_37() {
2673 | 0 |
         if (jj_3R_50()) return true;
2674 | 0 |
         return false;
2675 |  |
       }
2676 |  |
2677 |  |
       private boolean jj_3R_36() {
2678 | 0 |
         if (jj_scan_token(LPAREN)) return true;
2679 | 0 |
         return false;
2680 |  |
       }
2681 |  |
2682 |  |
       private boolean jj_3_1() {
2683 |  |
         Token xsp;
2684 | 8 |
         xsp = jj_scanpos;
2685 | 8 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2686 | 8 |
         if (jj_scan_token(NEWLINE)) return true;
2687 | 8 |
         return false;
2688 |  |
       }
2689 |  |
2690 |  |
       private boolean jj_3R_35() {
2691 | 0 |
         if (jj_3R_49()) return true;
2692 | 0 |
         return false;
2693 |  |
       }
2694 |  |
2695 |  |
       private boolean jj_3R_63() {
2696 | 2096 |
         if (jj_scan_token(DOLLAR)) return true;
2697 | 0 |
         return false;
2698 |  |
       }
2699 |  |
2700 |  |
       private boolean jj_3R_59() {
2701 | 0 |
         if (jj_scan_token(SQUOTE)) return true;
2702 | 0 |
         return false;
2703 |  |
       }
2704 |  |
2705 |  |
       private boolean jj_3R_25() {
2706 |  |
         Token xsp;
2707 | 0 |
         xsp = jj_scanpos;
2708 | 0 |
         if (jj_3R_35()) {
2709 | 0 |
         jj_scanpos = xsp;
2710 | 0 |
         if (jj_3R_36()) {
2711 | 0 |
         jj_scanpos = xsp;
2712 | 0 |
         if (jj_3R_37()) {
2713 | 0 |
         jj_scanpos = xsp;
2714 | 0 |
         if (jj_3R_38()) {
2715 | 0 |
         jj_scanpos = xsp;
2716 | 0 |
         if (jj_3R_39()) {
2717 | 0 |
         jj_scanpos = xsp;
2718 | 0 |
         if (jj_3R_40()) {
2719 | 0 |
         jj_scanpos = xsp;
2720 | 0 |
         if (jj_3R_41()) {
2721 | 0 |
         jj_scanpos = xsp;
2722 | 0 |
         if (jj_3R_42()) {
2723 | 0 |
         jj_scanpos = xsp;
2724 | 0 |
         if (jj_3R_43()) {
2725 | 0 |
         jj_scanpos = xsp;
2726 | 0 |
         if (jj_3R_44()) {
2727 | 0 |
         jj_scanpos = xsp;
2728 | 0 |
         if (jj_3R_45()) {
2729 | 0 |
         jj_scanpos = xsp;
2730 | 0 |
         if (jj_3R_46()) return true;
2731 |  |
         }
2732 |  |
         }
2733 |  |
         }
2734 |  |
         }
2735 |  |
         }
2736 |  |
         }
2737 |  |
         }
2738 |  |
         }
2739 |  |
         }
2740 |  |
         }
2741 |  |
         }
2742 | 0 |
         return false;
2743 |  |
       }
2744 |  |
2745 |  |
       private boolean jj_3R_34() {
2746 | 1958 |
         if (jj_3R_48()) return true;
2747 | 0 |
         return false;
2748 |  |
       }
2749 |  |
2750 |  |
       private boolean jj_3R_62() {
2751 | 3610 |
         if (jj_3R_49()) return true;
2752 | 0 |
         return false;
2753 |  |
       }
2754 |  |
2755 |  |
       private boolean jj_3R_33() {
2756 |  |
         Token xsp;
2757 | 2096 |
         xsp = jj_scanpos;
2758 | 2096 |
         if (jj_scan_token(15)) {
2759 | 2030 |
         jj_scanpos = xsp;
2760 | 2030 |
         if (jj_scan_token(12)) return true;
2761 |  |
         }
2762 | 0 |
         return false;
2763 |  |
       }
2764 |  |
2765 |  |
       private boolean jj_3R_32() {
2766 | 2096 |
         if (jj_scan_token(0)) return true;
2767 | 0 |
         return false;
2768 |  |
       }
2769 |  |
2770 |  |
       private boolean jj_3R_61() {
2771 |  |
         Token xsp;
2772 | 3610 |
         xsp = jj_scanpos;
2773 | 3610 |
         if (jj_3R_62()) {
2774 | 2096 |
         jj_scanpos = xsp;
2775 | 2096 |
         if (jj_3R_63()) return true;
2776 |  |
         }
2777 | 0 |
         return false;
2778 |  |
       }
2779 |  |
2780 |  |
       private boolean jj_3_21() {
2781 |  |
         Token xsp;
2782 | 7062 |
         xsp = jj_scanpos;
2783 | 7062 |
         if (jj_3R_31()) {
2784 | 2096 |
         jj_scanpos = xsp;
2785 | 2096 |
         if (jj_3R_32()) {
2786 | 2096 |
         jj_scanpos = xsp;
2787 | 2096 |
         if (jj_3R_33()) {
2788 | 1964 |
         jj_scanpos = xsp;
2789 | 1964 |
         jj_lookingAhead = true;
2790 | 1964 |
         jj_semLA = lookahead_not_breaking_subd();
2791 | 1964 |
         jj_lookingAhead = false;
2792 | 1964 |
         if (!jj_semLA || jj_3R_34()) return true;
2793 |  |
         }
2794 |  |
         }
2795 |  |
         }
2796 | 0 |
         return false;
2797 |  |
       }
2798 |  |
2799 |  |
       private boolean jj_3R_31() {
2800 | 7062 |
         if (jj_3R_47()) return true;
2801 | 0 |
         return false;
2802 |  |
       }
2803 |  |
2804 |  |
       private boolean jj_3R_58() {
2805 | 0 |
         if (jj_scan_token(QUOTE)) return true;
2806 | 0 |
         return false;
2807 |  |
       }
2808 |  |
2809 |  |
       private boolean jj_3_23() {
2810 | 1260 |
         if (jj_scan_token(LBRACE)) return true;
2811 | 8 |
         return false;
2812 |  |
       }
2813 |  |
2814 |  |
       private boolean jj_3_13() {
2815 |  |
         Token xsp;
2816 | 3178 |
         xsp = jj_scanpos;
2817 | 3178 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2818 | 3178 |
         if (jj_3R_27()) return true;
2819 | 0 |
         xsp = jj_scanpos;
2820 | 0 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2821 | 0 |
         if (jj_3R_28()) return true;
2822 | 0 |
         return false;
2823 |  |
       }
2824 |  |
2825 |  |
       private boolean jj_3R_50() {
2826 |  |
         Token xsp;
2827 | 0 |
         xsp = jj_scanpos;
2828 | 0 |
         if (jj_3R_58()) {
2829 | 0 |
         jj_scanpos = xsp;
2830 | 0 |
         if (jj_3R_59()) return true;
2831 |  |
         }
2832 | 0 |
         return false;
2833 |  |
       }
2834 |  |
2835 |  |
       private boolean jj_3R_29() {
2836 | 0 |
         if (jj_3R_28()) return true;
2837 | 0 |
         return false;
2838 |  |
       }
2839 |  |
2840 |  |
       private boolean jj_3R_60() {
2841 | 3612 |
         if (jj_scan_token(POUNDPOUND)) return true;
2842 | 0 |
         return false;
2843 |  |
       }
2844 |  |
2845 |  |
       private boolean jj_3_16() {
2846 | 1350 |
         if (jj_scan_token(WORD)) return true;
2847 | 1350 |
         return false;
2848 |  |
       }
2849 |  |
2850 |  |
       private boolean jj_3R_27() {
2851 |  |
         Token xsp;
2852 | 3178 |
         xsp = jj_scanpos;
2853 | 3178 |
         if (jj_scan_token(42)) {
2854 | 3134 |
         jj_scanpos = xsp;
2855 | 3134 |
         if (jj_scan_token(43)) {
2856 | 3134 |
         jj_scanpos = xsp;
2857 | 3134 |
         if (jj_scan_token(44)) {
2858 | 3076 |
         jj_scanpos = xsp;
2859 | 3076 |
         if (jj_scan_token(40)) {
2860 | 3068 |
         jj_scanpos = xsp;
2861 | 3068 |
         if (jj_scan_token(41)) {
2862 | 3068 |
         jj_scanpos = xsp;
2863 | 3068 |
         if (jj_scan_token(39)) {
2864 | 3068 |
         jj_scanpos = xsp;
2865 | 3068 |
         if (jj_scan_token(38)) return true;
2866 |  |
         }
2867 |  |
         }
2868 |  |
         }
2869 |  |
         }
2870 |  |
         }
2871 |  |
         }
2872 | 0 |
         return false;
2873 |  |
       }
2874 |  |
2875 |  |
       private boolean jj_3_20() {
2876 | 0 |
         if (jj_scan_token(LBRACE)) return true;
2877 | 0 |
         return false;
2878 |  |
       }
2879 |  |
2880 |  |
       private boolean jj_3R_51() {
2881 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
2882 | 0 |
         return false;
2883 |  |
       }
2884 |  |
2885 |  |
       private boolean jj_3R_48() {
2886 | 1958 |
         if (jj_scan_token(POUND)) return true;
2887 | 0 |
         return false;
2888 |  |
       }
2889 |  |
2890 |  |
       private boolean jj_3_8() {
2891 | 5838 |
         if (jj_scan_token(WORD)) return true;
2892 | 5750 |
         if (jj_scan_token(SEMI)) return true;
2893 | 0 |
         return false;
2894 |  |
       }
2895 |  |
2896 |  |
       private boolean jj_3R_49() {
2897 | 3610 |
         if (jj_scan_token(DOLLAR)) return true;
2898 | 0 |
         return false;
2899 |  |
       }
2900 |  |
2901 |  |
       private boolean jj_3_7() {
2902 | 10996 |
         if (jj_scan_token(DOT)) return true;
2903 | 5158 |
         if (jj_scan_token(WORD)) return true;
2904 | 5154 |
         return false;
2905 |  |
       }
2906 |  |
2907 |  |
       private boolean jj_3_12() {
2908 |  |
         Token xsp;
2909 | 3296 |
         xsp = jj_scanpos;
2910 | 3296 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2911 | 3296 |
         xsp = jj_scanpos;
2912 | 3296 |
         if (jj_scan_token(45)) {
2913 | 3296 |
         jj_scanpos = xsp;
2914 | 3296 |
         if (jj_scan_token(46)) return true;
2915 |  |
         }
2916 | 0 |
         xsp = jj_scanpos;
2917 | 0 |
         if (jj_scan_token(30)) jj_scanpos = xsp;
2918 | 0 |
         if (jj_3R_26()) return true;
2919 | 0 |
         return false;
2920 |  |
       }
2921 |  |
2922 |  |
       /** Generated Token Manager. */
2923 |  |
       public WMParser_implTokenManager token_source;
2924 |  |
       /** Current token. */
2925 |  |
       public Token token;
2926 |  |
       /** Next token. */
2927 |  |
       public Token jj_nt;
2928 |  |
       private int jj_ntk;
2929 |  |
       private Token jj_scanpos, jj_lastpos;
2930 |  |
       private int jj_la;
2931 |  |
       /** Whether we are looking ahead. */
2932 | 228 |
       private boolean jj_lookingAhead = false;
2933 |  |
       private boolean jj_semLA;
2934 |  |
       private int jj_gen;
2935 | 228 |
       final private int[] jj_la1 = new int[120];
2936 |  |
       static private int[] jj_la1_0;
2937 |  |
       static private int[] jj_la1_1;
2938 |  |
       static {
2939 | 2 |
           jj_la1_init_0();
2940 | 2 |
           jj_la1_init_1();
2941 | 2 |
        }
2942 |  |
        private static void jj_la1_init_0() {
2943 | 2 |
           jj_la1_0 = new int[] {0x40000000,0xc0000000,0x40000000,0x80000000,0x40000000,0x80000000,0x40000000,0xc0000000,0xc0000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x0,0x0,0x100000,0x0,0x700000,0x600000,0x700000,0x600000,0x3000000,0x3100000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0x0,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0xc0000000,0x3f108000,0xc0000000,0xc0000000,0xc0000000,0x40000000,0x40000000,0x0,0x40000000,0x40000000,0x7f108000,0x40000000,0x40000000,0x0,0x40000000,0x40000000,0x40100000,0x0,0x0,0x40000000,0x40000000,0x40000000,0x3f108000,0x40000000,0x0,0x40000000,0x40000000,0x0,0x40000000,0x0,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000000,0x40000,0x100000,0xe20800,0x620800,0xd20800,0xf20800,0xf26800,0x6000,0xf26800,0x4000,0xf29800,0x9000,0xf29800,0xf2f800,0xf26800,0x6000,0xf26800,0x4000,0x9000,0x729801,0x2000,0xf2f800,0xf000,0xf2f800,};
2944 | 2 |
        }
2945 |  |
        private static void jj_la1_init_1() {
2946 | 2 |
           jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x1,0x0,0x400001,0x2000000,0x2000000,0x4000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x884005,0x0,0x0,0x0,0x0,0x0,0x100000,0x0,0x0,0x884005,0x0,0x0,0x100000,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x884005,0x0,0x18000,0x0,0x0,0x6000,0x0,0x1fc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
2947 | 2 |
        }
2948 | 228 |
       final private JJCalls[] jj_2_rtns = new JJCalls[23];
2949 | 228 |
       private boolean jj_rescan = false;
2950 | 228 |
       private int jj_gc = 0;
2951 |  |
2952 |  |
       /** Constructor with user supplied CharStream. */
2953 | 228 |
       public WMParser_impl(CharStream stream) {
2954 | 228 |
         token_source = new WMParser_implTokenManager(stream);
2955 | 228 |
         token = new Token();
2956 | 228 |
         jj_ntk = -1;
2957 | 228 |
         jj_gen = 0;
2958 | 228 |
         for (int i = 0; i < 120; i++) jj_la1[i] = -1;
2959 | 228 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2960 | 228 |
       }
2961 |  |
2962 |  |
       /** Reinitialise. */
2963 |  |
       public void ReInit(CharStream stream) {
2964 | 0 |
         token_source.ReInit(stream);
2965 | 0 |
         token = new Token();
2966 | 0 |
         jj_ntk = -1;
2967 | 0 |
         jj_lookingAhead = false;
2968 | 0 |
         jj_gen = 0;
2969 | 0 |
         for (int i = 0; i < 120; i++) jj_la1[i] = -1;
2970 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2971 | 0 |
       }
2972 |  |
2973 |  |
       /** Constructor with generated Token Manager. */
2974 | 0 |
       public WMParser_impl(WMParser_implTokenManager tm) {
2975 | 0 |
         token_source = tm;
2976 | 0 |
         token = new Token();
2977 | 0 |
         jj_ntk = -1;
2978 | 0 |
         jj_gen = 0;
2979 | 0 |
         for (int i = 0; i < 120; i++) jj_la1[i] = -1;
2980 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2981 | 0 |
       }
2982 |  |
2983 |  |
       /** Reinitialise. */
2984 |  |
       public void ReInit(WMParser_implTokenManager tm) {
2985 | 0 |
         token_source = tm;
2986 | 0 |
         token = new Token();
2987 | 0 |
         jj_ntk = -1;
2988 | 0 |
         jj_gen = 0;
2989 | 0 |
         for (int i = 0; i < 120; i++) jj_la1[i] = -1;
2990 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2991 | 0 |
       }
2992 |  |
2993 |  |
       private Token jj_consume_token(int kind) throws ParseException {
2994 |  |
         Token oldToken;
2995 | 68444 |
         if ((oldToken = token).next != null) token = token.next;
2996 | 708 |
         else token = token.next = token_source.getNextToken();
2997 | 68444 |
         jj_ntk = -1;
2998 | 68444 |
         if (token.kind == kind) {
2999 | 68440 |
           jj_gen++;
3000 | 68440 |
           if (++jj_gc > 100) {
3001 | 566 |
             jj_gc = 0;
3002 | 13584 |
             for (int i = 0; i < jj_2_rtns.length; i++) {
3003 | 13018 |
               JJCalls c = jj_2_rtns[i];
3004 | 26036 |
               while (c != null) {
3005 | 13018 |
                 if (c.gen < jj_gen) c.first = null;
3006 | 13018 |
                 c = c.next;
3007 |  |
               }
3008 |  |
             }
3009 |  |
           }
3010 | 68440 |
           return token;
3011 |  |
         }
3012 | 4 |
         token = oldToken;
3013 | 4 |
         jj_kind = kind;
3014 | 4 |
         throw generateParseException();
3015 |  |
       }
3016 |  |
3017 | 456 |
       static private final class LookaheadSuccess extends java.lang.Error {
3018 |  |
           // The things I will do to apease IDEs
3019 |  |
           private static final long serialVersionUID = 1L;
3020 |  |
       }
3021 | 228 |
       final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3022 |  |
       private boolean jj_scan_token(int kind) {
3023 | 147124 |
         if (jj_scanpos == jj_lastpos) {
3024 | 77048 |
           jj_la--;
3025 | 77048 |
           if (jj_scanpos.next == null) {
3026 | 29418 |
             jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3027 |  |
           } else {
3028 | 47630 |
             jj_lastpos = jj_scanpos = jj_scanpos.next;
3029 |  |
           }
3030 |  |
         } else {
3031 | 70076 |
           jj_scanpos = jj_scanpos.next;
3032 |  |
         }
3033 | 147124 |
         if (jj_rescan) {
3034 | 4 |
           int i = 0; Token tok = token;
3035 | 8 |
           while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3036 | 4 |
           if (tok != null) jj_add_error_token(kind, i);
3037 |  |
         }
3038 | 147124 |
         if (jj_scanpos.kind != kind) return true;
3039 | 40836 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
3040 | 34836 |
         return false;
3041 |  |
       }
3042 |  |
3043 |  |
3044 |  |
     /** Get the next Token. */
3045 |  |
       final public Token getNextToken() {
3046 | 0 |
         if (token.next != null) token = token.next;
3047 | 0 |
         else token = token.next = token_source.getNextToken();
3048 | 0 |
         jj_ntk = -1;
3049 | 0 |
         jj_gen++;
3050 | 0 |
         return token;
3051 |  |
       }
3052 |  |
3053 |  |
     /** Get the specific Token. */
3054 |  |
       final public Token getToken(int index) {
3055 | 12164 |
         Token t = jj_lookingAhead ? jj_scanpos : token;
3056 | 31552 |
         for (int i = 0; i < index; i++) {
3057 | 19388 |
           if (t.next != null) t = t.next;
3058 | 2796 |
           else t = t.next = token_source.getNextToken();
3059 |  |
         }
3060 | 12164 |
         return t;
3061 |  |
       }
3062 |  |
3063 |  |
       private int jj_ntk() {
3064 | 60590 |
         if ((jj_nt=token.next) == null)
3065 | 46506 |
           return (jj_ntk = (token.next=token_source.getNextToken()).kind);
3066 |  |
         else
3067 | 14084 |
           return (jj_ntk = jj_nt.kind);
3068 |  |
       }
3069 |  |
3070 | 228 |
       private java.util.List jj_expentries = new java.util.ArrayList();
3071 |  |
       private int[] jj_expentry;
3072 | 228 |
       private int jj_kind = -1;
3073 | 228 |
       private int[] jj_lasttokens = new int[100];
3074 |  |
       private int jj_endpos;
3075 |  |
3076 |  |
       private void jj_add_error_token(int kind, int pos) {
3077 | 8 |
         if (pos >= 100) return;
3078 | 8 |
         if (pos == jj_endpos + 1) {
3079 | 4 |
           jj_lasttokens[jj_endpos++] = kind;
3080 | 4 |
         } else if (jj_endpos != 0) {
3081 | 4 |
           jj_expentry = new int[jj_endpos];
3082 | 8 |
           for (int i = 0; i < jj_endpos; i++) {
3083 | 4 |
             jj_expentry[i] = jj_lasttokens[i];
3084 |  |
           }
3085 | 4 |
           jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) {
3086 | 8 |
             int[] oldentry = (int[])(it.next());
3087 | 8 |
             if (oldentry.length == jj_expentry.length) {
3088 | 8 |
               for (int i = 0; i < jj_expentry.length; i++) {
3089 | 8 |
                 if (oldentry[i] != jj_expentry[i]) {
3090 | 8 |
                   continue jj_entries_loop;
3091 |  |
                 }
3092 |  |
               }
3093 | 0 |
               jj_expentries.add(jj_expentry);
3094 | 0 |
               break jj_entries_loop;
3095 |  |
             }
3096 | 0 |
           }
3097 | 4 |
           if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3098 |  |
         }
3099 | 8 |
       }
3100 |  |
3101 |  |
       /** Generate ParseException. */
3102 |  |
       public ParseException generateParseException() {
3103 | 4 |
         jj_expentries.clear();
3104 | 4 |
         boolean[] la1tokens = new boolean[59];
3105 | 4 |
         if (jj_kind >= 0) {
3106 | 4 |
           la1tokens[jj_kind] = true;
3107 | 4 |
           jj_kind = -1;
3108 |  |
         }
3109 | 484 |
         for (int i = 0; i < 120; i++) {
3110 | 480 |
           if (jj_la1[i] == jj_gen) {
3111 | 264 |
             for (int j = 0; j < 32; j++) {
3112 | 256 |
               if ((jj_la1_0[i] & (1<<j)) != 0) {
3113 | 8 |
                 la1tokens[j] = true;
3114 |  |
               }
3115 | 256 |
               if ((jj_la1_1[i] & (1<<j)) != 0) {
3116 | 0 |
                 la1tokens[32+j] = true;
3117 |  |
               }
3118 |  |
             }
3119 |  |
           }
3120 |  |
         }
3121 | 240 |
         for (int i = 0; i < 59; i++) {
3122 | 236 |
           if (la1tokens[i]) {
3123 | 8 |
             jj_expentry = new int[1];
3124 | 8 |
             jj_expentry[0] = i;
3125 | 8 |
             jj_expentries.add(jj_expentry);
3126 |  |
           }
3127 |  |
         }
3128 | 4 |
         jj_endpos = 0;
3129 | 4 |
         jj_rescan_token();
3130 | 4 |
         jj_add_error_token(0, 0);
3131 | 4 |
         int[][] exptokseq = new int[jj_expentries.size()][];
3132 | 12 |
         for (int i = 0; i < jj_expentries.size(); i++) {
3133 | 8 |
           exptokseq[i] = (int[])jj_expentries.get(i);
3134 |  |
         }
3135 | 4 |
         return new ParseException(token, exptokseq, tokenImage);
3136 |  |
       }
3137 |  |
3138 |  |
       /** Enable tracing. */
3139 |  |
       final public void enable_tracing() {
3140 | 0 |
       }
3141 |  |
3142 |  |
       /** Disable tracing. */
3143 |  |
       final public void disable_tracing() {
3144 | 0 |
       }
3145 |  |
3146 |  |
       private void jj_rescan_token() {
3147 | 4 |
         jj_rescan = true;
3148 | 96 |
         for (int i = 0; i < 23; i++) {
3149 |  |
         try {
3150 | 92 |
           JJCalls p = jj_2_rtns[i];
3151 |  |
           do {
3152 | 92 |
             if (p.gen > jj_gen) {
3153 | 4 |
               jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3154 | 4 |
               switch (i) {
3155 | 0 |
                 case 0: jj_3_1(); break;
3156 | 0 |
                 case 1: jj_3_2(); break;
3157 | 0 |
                 case 2: jj_3_3(); break;
3158 | 0 |
                 case 3: jj_3_4(); break;
3159 | 0 |
                 case 4: jj_3_5(); break;
3160 | 0 |
                 case 5: jj_3_6(); break;
3161 | 4 |
                 case 6: jj_3_7(); break;
3162 | 0 |
                 case 7: jj_3_8(); break;
3163 | 0 |
                 case 8: jj_3_9(); break;
3164 | 0 |
                 case 9: jj_3_10(); break;
3165 | 0 |
                 case 10: jj_3_11(); break;
3166 | 0 |
                 case 11: jj_3_12(); break;
3167 | 0 |
                 case 12: jj_3_13(); break;
3168 | 0 |
                 case 13: jj_3_14(); break;
3169 | 0 |
                 case 14: jj_3_15(); break;
3170 | 0 |
                 case 15: jj_3_16(); break;
3171 | 0 |
                 case 16: jj_3_17(); break;
3172 | 0 |
                 case 17: jj_3_18(); break;
3173 | 0 |
                 case 18: jj_3_19(); break;
3174 | 0 |
                 case 19: jj_3_20(); break;
3175 | 0 |
                 case 20: jj_3_21(); break;
3176 | 0 |
                 case 21: jj_3_22(); break;
3177 | 0 |
                 case 22: jj_3_23(); break;
3178 |  |
               }
3179 |  |
             }
3180 | 92 |
             p = p.next;
3181 | 92 |
           } while (p != null);
3182 | 92 |
           } catch(LookaheadSuccess ls) { }
3183 |  |
         }
3184 | 4 |
         jj_rescan = false;
3185 | 4 |
       }
3186 |  |
3187 |  |
       private void jj_save(int index, int xla) {
3188 | 56140 |
         JJCalls p = jj_2_rtns[index];
3189 | 56140 |
         while (p.gen > jj_gen) {
3190 | 0 |
           if (p.next == null) { p = p.next = new JJCalls(); break; }
3191 | 0 |
           p = p.next;
3192 |  |
         }
3193 | 56140 |
         p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3194 | 56140 |
       }
3195 |  |
3196 | 5244 |
       static final class JJCalls {
3197 |  |
         int gen;
3198 |  |
         Token first;
3199 |  |
         int arg;
3200 |  |
         JJCalls next;
3201 |  |
       }
3202 |  |
3203 |  |
     }