← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/surround/parser/QueryParser.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/surround/parser/QueryParser.java
1
 
/* Generated By:JavaCC: Do not edit this line. QueryParser.java */
2
 
package org.apache.lucene.queryParser.surround.parser;
3
 
 
4
 
import java.util.ArrayList;
5
 
import java.util.List;
6
 
import java.io.StringReader;
7
 
 
8
 
 
9
 
import org.apache.lucene.analysis.TokenStream;
10
 
 
11
 
import org.apache.lucene.queryParser.surround.query.SrndQuery;
12
 
import org.apache.lucene.queryParser.surround.query.FieldsQuery;
13
 
import org.apache.lucene.queryParser.surround.query.OrQuery;
14
 
import org.apache.lucene.queryParser.surround.query.AndQuery;
15
 
import org.apache.lucene.queryParser.surround.query.NotQuery;
16
 
import org.apache.lucene.queryParser.surround.query.DistanceQuery;
17
 
import org.apache.lucene.queryParser.surround.query.SrndTermQuery;
18
 
import org.apache.lucene.queryParser.surround.query.SrndPrefixQuery;
19
 
import org.apache.lucene.queryParser.surround.query.SrndTruncQuery;
20
 
 
21
 
/**
22
 
 * This class is generated by JavaCC.  The only method that clients should need
23
 
 * to call is <a href="#parse">parse()</a>.
24
 
 */
25
 
 
26
 
public class QueryParser implements QueryParserConstants {
27
 
  final int minimumPrefixLength = 3;
28
 
  final int minimumCharsInTrunc = 3;
29
 
  final String truncationErrorMessage = "Too unrestrictive truncation: ";
30
 
  final String boostErrorMessage = "Cannot handle boost value: ";
31
 
 
32
 
  /* CHECKME: These should be the same as for the tokenizer. How? */
33
 
  final char truncator = '*';
34
 
  final char anyChar = '?';
35
 
  final char quote = '\"';
36
 
  final char fieldOperator = ':';
37
 
  final char comma = ','; /* prefix list separator */
38
 
  final char carat = '^'; /* weight operator */
39
 
 
40
 
  static public SrndQuery parse(String query) throws ParseException {
41
 
    QueryParser parser = new QueryParser();
42
 
    return parser.parse2(query);
43
 
  }
44
 
 
45
 
  public QueryParser() {
46
 
    this(new FastCharStream(new StringReader("")));
47
 
  }
48
 
 
49
 
  public SrndQuery parse2(String query) throws ParseException {
50
 
    ReInit(new FastCharStream(new StringReader(query)));
51
 
    try {
52
 
      return TopSrndQuery();
53
 
    } catch (TokenMgrError tme) {
54
 
      throw new ParseException(tme.getMessage());
55
 
    }
56
 
  }
57
 
 
58
 
  protected SrndQuery getFieldsQuery(
59
 
      SrndQuery q, ArrayList<String> fieldNames) {
60
 
    /* FIXME: check acceptable subquery: at least one subquery should not be
61
 
     * a fields query.
62
 
     */
63
 
    return new FieldsQuery(q, fieldNames, fieldOperator);
64
 
  }
65
 
 
66
 
  protected SrndQuery getOrQuery(List<SrndQuery> queries, boolean infix, Token orToken) {
67
 
    return new OrQuery(queries, infix, orToken.image);
68
 
  }
69
 
 
70
 
  protected SrndQuery getAndQuery(List<SrndQuery> queries, boolean infix, Token andToken) {
71
 
    return new AndQuery( queries, infix, andToken.image);
72
 
  }
73
 
 
74
 
  protected SrndQuery getNotQuery(List<SrndQuery> queries, Token notToken) {
75
 
    return new NotQuery( queries, notToken.image);
76
 
  }
77
 
 
78
 
  protected static int getOpDistance(String distanceOp) {
79
 
    /* W, 2W, 3W etc -> 1, 2 3, etc. Same for N, 2N ... */
80
 
    return distanceOp.length() == 1
81
 
      ? 1
82
 
      : Integer.parseInt( distanceOp.substring( 0, distanceOp.length() - 1));
83
 
  }
84
 
 
85
 
  protected static void checkDistanceSubQueries(DistanceQuery distq, String opName)
86
 
  throws ParseException {
87
 
    String m = distq.distanceSubQueryNotAllowed();
88
 
    if (m != null) {
89
 
      throw new ParseException("Operator " + opName + ": " + m);
90
 
    }
91
 
  }
92
 
 
93
 
  protected SrndQuery getDistanceQuery(
94
 
        List<SrndQuery> queries,
95
 
        boolean infix,
96
 
        Token dToken,
97
 
        boolean ordered) throws ParseException {
98
 
    DistanceQuery dq = new DistanceQuery(queries,
99
 
                                        infix,
100
 
                                        getOpDistance(dToken.image),
101
 
                                        dToken.image,
102
 
                                        ordered);
103
 
    checkDistanceSubQueries(dq, dToken.image);
104
 
    return dq;
105
 
  }
106
 
 
107
 
  protected SrndQuery getTermQuery(
108
 
        String term, boolean quoted) {
109
 
    return new SrndTermQuery(term, quoted);
110
 
  }
111
 
 
112
 
  protected boolean allowedSuffix(String suffixed) {
113
 
    return (suffixed.length() - 1) >= minimumPrefixLength;
114
 
  }
115
 
 
116
 
  protected SrndQuery getPrefixQuery(
117
 
      String prefix, boolean quoted) {
118
 
    return new SrndPrefixQuery(prefix, quoted, truncator);
119
 
  }
120
 
 
121
 
  protected boolean allowedTruncation(String truncated) {
122
 
    /* At least 3 normal characters needed. */
123
 
    int nrNormalChars = 0;
124
 
    for (int i = 0; i < truncated.length(); i++) {
125
 
      char c = truncated.charAt(i);
126
 
      if ((c != truncator) && (c != anyChar)) {
127
 
        nrNormalChars++;
128
 
      }
129
 
    }
130
 
    return nrNormalChars >= minimumCharsInTrunc;
131
 
  }
132
 
 
133
 
  protected SrndQuery getTruncQuery(String truncated) {
134
 
    return new SrndTruncQuery(truncated, truncator, anyChar);
135
 
  }
136
 
 
137
 
  final public SrndQuery TopSrndQuery() throws ParseException {
138
 
  SrndQuery q;
139
 
    q = FieldsQuery();
140
 
    jj_consume_token(0);
141
 
   {if (true) return q;}
142
 
    throw new Error("Missing return statement in function");
143
 
  }
144
 
 
145
 
  final public SrndQuery FieldsQuery() throws ParseException {
146
 
  SrndQuery q;
147
 
  ArrayList<String> fieldNames;
148
 
    fieldNames = OptionalFields();
149
 
    q = OrQuery();
150
 
   {if (true) return (fieldNames == null) ? q : getFieldsQuery(q, fieldNames);}
151
 
    throw new Error("Missing return statement in function");
152
 
  }
153
 
 
154
 
  final public ArrayList<String> OptionalFields() throws ParseException {
155
 
  Token fieldName;
156
 
  ArrayList<String> fieldNames = null;
157
 
    label_1:
158
 
    while (true) {
159
 
      if (jj_2_1(2)) {
160
 
        ;
161
 
      } else {
162
 
        break label_1;
163
 
      }
164
 
      // to the colon
165
 
          fieldName = jj_consume_token(TERM);
166
 
      jj_consume_token(COLON);
167
 
      if (fieldNames == null) {
168
 
        fieldNames = new ArrayList<String>();
169
 
      }
170
 
      fieldNames.add(fieldName.image);
171
 
    }
172
 
   {if (true) return fieldNames;}
173
 
    throw new Error("Missing return statement in function");
174
 
  }
175
 
 
176
 
  final public SrndQuery OrQuery() throws ParseException {
177
 
  SrndQuery q;
178
 
  ArrayList<SrndQuery> queries = null;
179
 
  Token oprt = null;
180
 
    q = AndQuery();
181
 
    label_2:
182
 
    while (true) {
183
 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
184
 
      case OR:
185
 
        ;
186
 
        break;
187
 
      default:
188
 
        jj_la1[0] = jj_gen;
189
 
        break label_2;
190
 
      }
191
 
      oprt = jj_consume_token(OR);
192
 
                  /* keep only last used operator */
193
 
      if (queries == null) {
194
 
        queries = new ArrayList<SrndQuery>();
195
 
        queries.add(q);
196
 
      }
197
 
      q = AndQuery();
198
 
      queries.add(q);
199
 
    }
200
 
   {if (true) return (queries == null) ? q : getOrQuery(queries, true /* infix */, oprt);}
201
 
    throw new Error("Missing return statement in function");
202
 
  }
203
 
 
204
 
  final public SrndQuery AndQuery() throws ParseException {
205
 
  SrndQuery q;
206
 
  ArrayList<SrndQuery> queries = null;
207
 
  Token oprt = null;
208
 
    q = NotQuery();
209
 
    label_3:
210
 
    while (true) {
211
 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
212
 
      case AND:
213
 
        ;
214
 
        break;
215
 
      default:
216
 
        jj_la1[1] = jj_gen;
217
 
        break label_3;
218
 
      }
219
 
      oprt = jj_consume_token(AND);
220
 
                   /* keep only last used operator */
221
 
      if (queries == null) {
222
 
        queries = new ArrayList<SrndQuery>();
223
 
        queries.add(q);
224
 
      }
225
 
      q = NotQuery();
226
 
      queries.add(q);
227
 
    }
228
 
   {if (true) return (queries == null) ? q : getAndQuery(queries, true /* infix */, oprt);}
229
 
    throw new Error("Missing return statement in function");
230
 
  }
231
 
 
232
 
  final public SrndQuery NotQuery() throws ParseException {
233
 
  SrndQuery q;
234
 
  ArrayList<SrndQuery> queries = null;
235
 
  Token oprt = null;
236
 
    q = NQuery();
237
 
    label_4:
238
 
    while (true) {
239
 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
240
 
      case NOT:
241
 
        ;
242
 
        break;
243
 
      default:
244
 
        jj_la1[2] = jj_gen;
245
 
        break label_4;
246
 
      }
247
 
      oprt = jj_consume_token(NOT);
248
 
                    /* keep only last used operator */
249
 
      if (queries == null) {
250
 
        queries = new ArrayList<SrndQuery>();
251
 
        queries.add(q);
252
 
      }
253
 
      q = NQuery();
254
 
      queries.add(q);
255
 
    }
256
 
   {if (true) return (queries == null) ? q : getNotQuery(queries, oprt);}
257
 
    throw new Error("Missing return statement in function");
258
 
  }
259
 
 
260
 
  final public SrndQuery NQuery() throws ParseException {
261
 
  SrndQuery q;
262
 
  ArrayList<SrndQuery> queries;
263
 
  Token dt;
264
 
    q = WQuery();
265
 
    label_5:
266
 
    while (true) {
267
 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
268
 
      case N:
269
 
        ;
270
 
        break;
271
 
      default:
272
 
        jj_la1[3] = jj_gen;
273
 
        break label_5;
274
 
      }
275
 
      dt = jj_consume_token(N);
276
 
      queries = new ArrayList<SrndQuery>();
277
 
      queries.add(q); /* left associative */
278
 
 
279
 
      q = WQuery();
280
 
      queries.add(q);
281
 
      q = getDistanceQuery(queries, true /* infix */, dt, false /* not ordered */);
282
 
    }
283
 
   {if (true) return q;}
284
 
    throw new Error("Missing return statement in function");
285
 
  }
286
 
 
287
 
  final public SrndQuery WQuery() throws ParseException {
288
 
  SrndQuery q;
289
 
  ArrayList<SrndQuery> queries;
290
 
  Token wt;
291
 
    q = PrimaryQuery();
292
 
    label_6:
293
 
    while (true) {
294
 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
295
 
      case W:
296
 
        ;
297
 
        break;
298
 
      default:
299
 
        jj_la1[4] = jj_gen;
300
 
        break label_6;
301
 
      }
302
 
      wt = jj_consume_token(W);
303
 
      queries = new ArrayList<SrndQuery>();
304
 
      queries.add(q); /* left associative */
305
 
 
306
 
      q = PrimaryQuery();
307
 
      queries.add(q);
308
 
      q = getDistanceQuery(queries, true /* infix */, wt, true /* ordered */);
309
 
    }
310
 
   {if (true) return q;}
311
 
    throw new Error("Missing return statement in function");
312
 
  }
313
 
 
314
 
  final public SrndQuery PrimaryQuery() throws ParseException {
315
 
                             /* bracketed weighted query or weighted term */
316
 
  SrndQuery q;
317
 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
318
 
    case LPAREN:
319
 
      jj_consume_token(LPAREN);
320
 
      q = FieldsQuery();
321
 
      jj_consume_token(RPAREN);
322
 
      break;
323
 
    case OR:
324
 
    case AND:
325
 
    case W:
326
 
    case N:
327
 
      q = PrefixOperatorQuery();
328
 
      break;
329
 
    case TRUNCQUOTED:
330
 
    case QUOTED:
331
 
    case SUFFIXTERM:
332
 
    case TRUNCTERM:
333
 
    case TERM:
334
 
      q = SimpleTerm();
335
 
      break;
336
 
    default:
337
 
      jj_la1[5] = jj_gen;
338
 
      jj_consume_token(-1);
339
 
      throw new ParseException();
340
 
    }
341
 
    OptionalWeights(q);
342
 
   {if (true) return q;}
343
 
    throw new Error("Missing return statement in function");
344
 
  }
345
 
 
346
 
  final public SrndQuery PrefixOperatorQuery() throws ParseException {
347
 
  Token oprt;
348
 
  List<SrndQuery> queries;
349
 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
350
 
    case OR:
351
 
      oprt = jj_consume_token(OR);
352
 
      /* prefix OR */
353
 
          queries = FieldsQueryList();
354
 
     {if (true) return getOrQuery(queries, false /* not infix */, oprt);}
355
 
      break;
356
 
    case AND:
357
 
      oprt = jj_consume_token(AND);
358
 
      /* prefix AND */
359
 
          queries = FieldsQueryList();
360
 
     {if (true) return getAndQuery(queries, false /* not infix */, oprt);}
361
 
      break;
362
 
    case N:
363
 
      oprt = jj_consume_token(N);
364
 
      /* prefix N */
365
 
          queries = FieldsQueryList();
366
 
     {if (true) return getDistanceQuery(queries, false /* not infix */, oprt, false /* not ordered */);}
367
 
      break;
368
 
    case W:
369
 
      oprt = jj_consume_token(W);
370
 
      /* prefix W */
371
 
          queries = FieldsQueryList();
372
 
     {if (true) return getDistanceQuery(queries, false  /* not infix */, oprt, true /* ordered */);}
373
 
      break;
374
 
    default:
375
 
      jj_la1[6] = jj_gen;
376
 
      jj_consume_token(-1);
377
 
      throw new ParseException();
378
 
    }
379
 
    throw new Error("Missing return statement in function");
380
 
  }
381
 
 
382
 
  final public List<SrndQuery> FieldsQueryList() throws ParseException {
383
 
  SrndQuery q;
384
 
  ArrayList<SrndQuery> queries = new ArrayList<SrndQuery>();
385
 
    jj_consume_token(LPAREN);
386
 
    q = FieldsQuery();
387
 
                     queries.add(q);
388
 
    label_7:
389
 
    while (true) {
390
 
      jj_consume_token(COMMA);
391
 
      q = FieldsQuery();
392
 
                              queries.add(q);
393
 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
394
 
      case COMMA:
395
 
        ;
396
 
        break;
397
 
      default:
398
 
        jj_la1[7] = jj_gen;
399
 
        break label_7;
400
 
      }
401
 
    }
402
 
    jj_consume_token(RPAREN);
403
 
   {if (true) return queries;}
404
 
    throw new Error("Missing return statement in function");
405
 
  }
406
 
 
407
 
  final public SrndQuery SimpleTerm() throws ParseException {
408
 
  Token term;
409
 
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
410
 
    case TERM:
411
 
      term = jj_consume_token(TERM);
412
 
     {if (true) return getTermQuery(term.image, false /* not quoted */);}
413
 
      break;
414
 
    case QUOTED:
415
 
      term = jj_consume_token(QUOTED);
416
 
     {if (true) return getTermQuery(term.image.substring(1, term.image.length()-1), true /* quoted */);}
417
 
      break;
418
 
    case SUFFIXTERM:
419
 
      term = jj_consume_token(SUFFIXTERM);
420
 
                        /* ending in * */
421
 
      if (! allowedSuffix(term.image)) {
422
 
        {if (true) throw new ParseException(truncationErrorMessage + term.image);}
423
 
      }
424
 
      {if (true) return getPrefixQuery(term.image.substring(0, term.image.length()-1), false /* not quoted */);}
425
 
      break;
426
 
    case TRUNCTERM:
427
 
      term = jj_consume_token(TRUNCTERM);
428
 
                       /* with at least one * or ? */
429
 
      if (! allowedTruncation(term.image)) {
430
 
        {if (true) throw new ParseException(truncationErrorMessage + term.image);}
431
 
      }
432
 
      {if (true) return getTruncQuery(term.image);}
433
 
      break;
434
 
    case TRUNCQUOTED:
435
 
      term = jj_consume_token(TRUNCQUOTED);
436
 
                         /* eg. "9b-b,m"* */
437
 
      if ((term.image.length() - 3) < minimumPrefixLength) {
438
 
        {if (true) throw new ParseException(truncationErrorMessage + term.image);}
439
 
      }
440
 
      {if (true) return getPrefixQuery(term.image.substring(1, term.image.length()-2), true /* quoted */);}
441
 
      break;
442
 
    default:
443
 
      jj_la1[8] = jj_gen;
444
 
      jj_consume_token(-1);
445
 
      throw new ParseException();
446
 
    }
447
 
    throw new Error("Missing return statement in function");
448
 
  }
449
 
 
450
 
  final public void OptionalWeights(SrndQuery q) throws ParseException {
451
 
  Token weight=null;
452
 
    label_8:
453
 
    while (true) {
454
 
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
455
 
      case CARAT:
456
 
        ;
457
 
        break;
458
 
      default:
459
 
        jj_la1[9] = jj_gen;
460
 
        break label_8;
461
 
      }
462
 
      jj_consume_token(CARAT);
463
 
      weight = jj_consume_token(NUMBER);
464
 
      float f;
465
 
      try {
466
 
        f = Float.valueOf(weight.image).floatValue();
467
 
      } catch (Exception floatExc) {
468
 
        {if (true) throw new ParseException(boostErrorMessage + weight.image + " (" + floatExc + ")");}
469
 
      }
470
 
      if (f <= 0.0) {
471
 
        {if (true) throw new ParseException(boostErrorMessage + weight.image);}
472
 
      }
473
 
      q.setWeight(f * q.getWeight()); /* left associative, fwiw */
474
 
 
475
 
    }
476
 
  }
477
 
 
478
 
  private boolean jj_2_1(int xla) {
479
 
    jj_la = xla; jj_lastpos = jj_scanpos = token;
480
 
    try { return !jj_3_1(); }
481
 
    catch(LookaheadSuccess ls) { return true; }
482
 
    finally { jj_save(0, xla); }
483
 
  }
484
 
 
485
 
  private boolean jj_3_1() {
486
 
    if (jj_scan_token(TERM)) return true;
487
 
    if (jj_scan_token(COLON)) return true;
488
 
    return false;
489
 
  }
490
 
 
491
 
  /** Generated Token Manager. */
492
 
  public QueryParserTokenManager token_source;
493
 
  /** Current token. */
494
 
  public Token token;
495
 
  /** Next token. */
496
 
  public Token jj_nt;
497
 
  private int jj_ntk;
498
 
  private Token jj_scanpos, jj_lastpos;
499
 
  private int jj_la;
500
 
  private int jj_gen;
501
 
  final private int[] jj_la1 = new int[10];
502
 
  static private int[] jj_la1_0;
503
 
  static {
504
 
      jj_la1_init_0();
505
 
   }
506
 
   private static void jj_la1_init_0() {
507
 
      jj_la1_0 = new int[] {0x100,0x200,0x400,0x1000,0x800,0x7c3b00,0x1b00,0x8000,0x7c0000,0x20000,};
508
 
   }
509
 
  final private JJCalls[] jj_2_rtns = new JJCalls[1];
510
 
  private boolean jj_rescan = false;
511
 
  private int jj_gc = 0;
512
 
 
513
 
  /** Constructor with user supplied CharStream. */
514
 
  public QueryParser(CharStream stream) {
515
 
    token_source = new QueryParserTokenManager(stream);
516
 
    token = new Token();
517
 
    jj_ntk = -1;
518
 
    jj_gen = 0;
519
 
    for (int i = 0; i < 10; i++) jj_la1[i] = -1;
520
 
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
521
 
  }
522
 
 
523
 
  /** Reinitialise. */
524
 
  public void ReInit(CharStream stream) {
525
 
    token_source.ReInit(stream);
526
 
    token = new Token();
527
 
    jj_ntk = -1;
528
 
    jj_gen = 0;
529
 
    for (int i = 0; i < 10; i++) jj_la1[i] = -1;
530
 
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
531
 
  }
532
 
 
533
 
  /** Constructor with generated Token Manager. */
534
 
  public QueryParser(QueryParserTokenManager tm) {
535
 
    token_source = tm;
536
 
    token = new Token();
537
 
    jj_ntk = -1;
538
 
    jj_gen = 0;
539
 
    for (int i = 0; i < 10; i++) jj_la1[i] = -1;
540
 
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
541
 
  }
542
 
 
543
 
  /** Reinitialise. */
544
 
  public void ReInit(QueryParserTokenManager tm) {
545
 
    token_source = tm;
546
 
    token = new Token();
547
 
    jj_ntk = -1;
548
 
    jj_gen = 0;
549
 
    for (int i = 0; i < 10; i++) jj_la1[i] = -1;
550
 
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
551
 
  }
552
 
 
553
 
  private Token jj_consume_token(int kind) throws ParseException {
554
 
    Token oldToken;
555
 
    if ((oldToken = token).next != null) token = token.next;
556
 
    else token = token.next = token_source.getNextToken();
557
 
    jj_ntk = -1;
558
 
    if (token.kind == kind) {
559
 
      jj_gen++;
560
 
      if (++jj_gc > 100) {
561
 
        jj_gc = 0;
562
 
        for (int i = 0; i < jj_2_rtns.length; i++) {
563
 
          JJCalls c = jj_2_rtns[i];
564
 
          while (c != null) {
565
 
            if (c.gen < jj_gen) c.first = null;
566
 
            c = c.next;
567
 
          }
568
 
        }
569
 
      }
570
 
      return token;
571
 
    }
572
 
    token = oldToken;
573
 
    jj_kind = kind;
574
 
    throw generateParseException();
575
 
  }
576
 
 
577
 
  static private final class LookaheadSuccess extends java.lang.Error { }
578
 
  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
579
 
  private boolean jj_scan_token(int kind) {
580
 
    if (jj_scanpos == jj_lastpos) {
581
 
      jj_la--;
582
 
      if (jj_scanpos.next == null) {
583
 
        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
584
 
      } else {
585
 
        jj_lastpos = jj_scanpos = jj_scanpos.next;
586
 
      }
587
 
    } else {
588
 
      jj_scanpos = jj_scanpos.next;
589
 
    }
590
 
    if (jj_rescan) {
591
 
      int i = 0; Token tok = token;
592
 
      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
593
 
      if (tok != null) jj_add_error_token(kind, i);
594
 
    }
595
 
    if (jj_scanpos.kind != kind) return true;
596
 
    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
597
 
    return false;
598
 
  }
599
 
 
600
 
 
601
 
/** Get the next Token. */
602
 
  final public Token getNextToken() {
603
 
    if (token.next != null) token = token.next;
604
 
    else token = token.next = token_source.getNextToken();
605
 
    jj_ntk = -1;
606
 
    jj_gen++;
607
 
    return token;
608
 
  }
609
 
 
610
 
/** Get the specific Token. */
611
 
  final public Token getToken(int index) {
612
 
    Token t = token;
613
 
    for (int i = 0; i < index; i++) {
614
 
      if (t.next != null) t = t.next;
615
 
      else t = t.next = token_source.getNextToken();
616
 
    }
617
 
    return t;
618
 
  }
619
 
 
620
 
  private int jj_ntk() {
621
 
    if ((jj_nt=token.next) == null)
622
 
      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
623
 
    else
624
 
      return (jj_ntk = jj_nt.kind);
625
 
  }
626
 
 
627
 
  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
628
 
  private int[] jj_expentry;
629
 
  private int jj_kind = -1;
630
 
  private int[] jj_lasttokens = new int[100];
631
 
  private int jj_endpos;
632
 
 
633
 
  private void jj_add_error_token(int kind, int pos) {
634
 
    if (pos >= 100) return;
635
 
    if (pos == jj_endpos + 1) {
636
 
      jj_lasttokens[jj_endpos++] = kind;
637
 
    } else if (jj_endpos != 0) {
638
 
      jj_expentry = new int[jj_endpos];
639
 
      for (int i = 0; i < jj_endpos; i++) {
640
 
        jj_expentry[i] = jj_lasttokens[i];
641
 
      }
642
 
      jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) {
643
 
        int[] oldentry = (int[])(it.next());
644
 
        if (oldentry.length == jj_expentry.length) {
645
 
          for (int i = 0; i < jj_expentry.length; i++) {
646
 
            if (oldentry[i] != jj_expentry[i]) {
647
 
              continue jj_entries_loop;
648
 
            }
649
 
          }
650
 
          jj_expentries.add(jj_expentry);
651
 
          break jj_entries_loop;
652
 
        }
653
 
      }
654
 
      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
655
 
    }
656
 
  }
657
 
 
658
 
  /** Generate ParseException. */
659
 
  public ParseException generateParseException() {
660
 
    jj_expentries.clear();
661
 
    boolean[] la1tokens = new boolean[24];
662
 
    if (jj_kind >= 0) {
663
 
      la1tokens[jj_kind] = true;
664
 
      jj_kind = -1;
665
 
    }
666
 
    for (int i = 0; i < 10; i++) {
667
 
      if (jj_la1[i] == jj_gen) {
668
 
        for (int j = 0; j < 32; j++) {
669
 
          if ((jj_la1_0[i] & (1<<j)) != 0) {
670
 
            la1tokens[j] = true;
671
 
          }
672
 
        }
673
 
      }
674
 
    }
675
 
    for (int i = 0; i < 24; i++) {
676
 
      if (la1tokens[i]) {
677
 
        jj_expentry = new int[1];
678
 
        jj_expentry[0] = i;
679
 
        jj_expentries.add(jj_expentry);
680
 
      }
681
 
    }
682
 
    jj_endpos = 0;
683
 
    jj_rescan_token();
684
 
    jj_add_error_token(0, 0);
685
 
    int[][] exptokseq = new int[jj_expentries.size()][];
686
 
    for (int i = 0; i < jj_expentries.size(); i++) {
687
 
      exptokseq[i] = jj_expentries.get(i);
688
 
    }
689
 
    return new ParseException(token, exptokseq, tokenImage);
690
 
  }
691
 
 
692
 
  /** Enable tracing. */
693
 
  final public void enable_tracing() {
694
 
  }
695
 
 
696
 
  /** Disable tracing. */
697
 
  final public void disable_tracing() {
698
 
  }
699
 
 
700
 
  private void jj_rescan_token() {
701
 
    jj_rescan = true;
702
 
    for (int i = 0; i < 1; i++) {
703
 
    try {
704
 
      JJCalls p = jj_2_rtns[i];
705
 
      do {
706
 
        if (p.gen > jj_gen) {
707
 
          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
708
 
          switch (i) {
709
 
            case 0: jj_3_1(); break;
710
 
          }
711
 
        }
712
 
        p = p.next;
713
 
      } while (p != null);
714
 
      } catch(LookaheadSuccess ls) { }
715
 
    }
716
 
    jj_rescan = false;
717
 
  }
718
 
 
719
 
  private void jj_save(int index, int xla) {
720
 
    JJCalls p = jj_2_rtns[index];
721
 
    while (p.gen > jj_gen) {
722
 
      if (p.next == null) { p = p.next = new JJCalls(); break; }
723
 
      p = p.next;
724
 
    }
725
 
    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
726
 
  }
727
 
 
728
 
  static final class JJCalls {
729
 
    int gen;
730
 
    Token first;
731
 
    int arg;
732
 
    JJCalls next;
733
 
  }
734
 
 
735
 
}