Source Code Cross Referenced for SyntaxTreeBuilder.java in  » RSS-RDF » sesame » org » openrdf » query » parser » sparql » ast » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » RSS RDF » sesame » org.openrdf.query.parser.sparql.ast 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


0001:        /* Generated By:JJTree&JavaCC: Do not edit this line. SyntaxTreeBuilder.java */
0002:        package org.openrdf.query.parser.sparql.ast;
0003:
0004:        import java.io.StringReader;
0005:
0006:        import org.openrdf.model.URI;
0007:        import org.openrdf.model.vocabulary.RDF;
0008:        import org.openrdf.model.vocabulary.XMLSchema;
0009:        import org.openrdf.query.algebra.Compare.CompareOp;
0010:        import org.openrdf.query.algebra.MathExpr.MathOp;
0011:
0012:        public class SyntaxTreeBuilder/*@bgen(jjtree)*/implements 
0013:                SyntaxTreeBuilderTreeConstants, SyntaxTreeBuilderConstants {/*@bgen(jjtree)*/
0014:            protected JJTSyntaxTreeBuilderState jjtree = new JJTSyntaxTreeBuilderState();
0015:
0016:            /**
0017:             * Parses the supplied SPARQL query and builds a syntax tree from it.
0018:             *
0019:             * @param query A SPARQL query string.
0020:             * @return The root of the syntax tree.
0021:             * @throws TokenMgrError If the query was syntactically incorrect.
0022:             * @throws ParseException If the query was syntactically incorrect.
0023:             */
0024:            public static ASTQueryContainer parseQuery(String query)
0025:                    throws TokenMgrError, ParseException {
0026:                SyntaxTreeBuilder stb = new SyntaxTreeBuilder(new StringReader(
0027:                        query));
0028:                return stb.QueryContainer();
0029:            }
0030:
0031:            /**
0032:             * Trims <tt>n</tt> character from the start and end of the supplied string.
0033:             */
0034:            private static String _trimString(String s, int n) {
0035:                if (s.length() >= 2) {
0036:                    s = s.substring(n, s.length() - n);
0037:                }
0038:                return s;
0039:            }
0040:
0041:            //
0042:            // grammar
0043:            //
0044:            final public ASTQueryContainer QueryContainer()
0045:                    throws ParseException {
0046:                /*@bgen(jjtree) QueryContainer */
0047:                ASTQueryContainer jjtn000 = new ASTQueryContainer(
0048:                        JJTQUERYCONTAINER);
0049:                boolean jjtc000 = true;
0050:                jjtree.openNodeScope(jjtn000);
0051:                try {
0052:                    Prolog();
0053:                    Query();
0054:                    jj_consume_token(0);
0055:                    jjtree.closeNodeScope(jjtn000, true);
0056:                    jjtc000 = false;
0057:                    {
0058:                        if (true)
0059:                            return jjtn000;
0060:                    }
0061:                } catch (Throwable jjte000) {
0062:                    if (jjtc000) {
0063:                        jjtree.clearNodeScope(jjtn000);
0064:                        jjtc000 = false;
0065:                    } else {
0066:                        jjtree.popNode();
0067:                    }
0068:                    if (jjte000 instanceof  RuntimeException) {
0069:                        {
0070:                            if (true)
0071:                                throw (RuntimeException) jjte000;
0072:                        }
0073:                    }
0074:                    if (jjte000 instanceof  ParseException) {
0075:                        {
0076:                            if (true)
0077:                                throw (ParseException) jjte000;
0078:                        }
0079:                    }
0080:                    {
0081:                        if (true)
0082:                            throw (Error) jjte000;
0083:                    }
0084:                } finally {
0085:                    if (jjtc000) {
0086:                        jjtree.closeNodeScope(jjtn000, true);
0087:                    }
0088:                }
0089:                throw new Error("Missing return statement in function");
0090:            }
0091:
0092:            final public void Prolog() throws ParseException {
0093:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0094:                case BASE:
0095:                    BaseDecl();
0096:                    break;
0097:                default:
0098:                    jj_la1[0] = jj_gen;
0099:                    ;
0100:                }
0101:                label_1: while (true) {
0102:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0103:                    case PREFIX:
0104:                        ;
0105:                        break;
0106:                    default:
0107:                        jj_la1[1] = jj_gen;
0108:                        break label_1;
0109:                    }
0110:                    PrefixDecl();
0111:                }
0112:            }
0113:
0114:            final public void BaseDecl() throws ParseException {
0115:                /*@bgen(jjtree) BaseDecl */
0116:                ASTBaseDecl jjtn000 = new ASTBaseDecl(JJTBASEDECL);
0117:                boolean jjtc000 = true;
0118:                jjtree.openNodeScope(jjtn000);
0119:                Token t;
0120:                try {
0121:                    jj_consume_token(BASE);
0122:                    t = jj_consume_token(Q_IRI_REF);
0123:                    jjtree.closeNodeScope(jjtn000, true);
0124:                    jjtc000 = false;
0125:                    jjtn000.setIRI(_trimString(t.image, 1));
0126:                } finally {
0127:                    if (jjtc000) {
0128:                        jjtree.closeNodeScope(jjtn000, true);
0129:                    }
0130:                }
0131:            }
0132:
0133:            final public void PrefixDecl() throws ParseException {
0134:                /*@bgen(jjtree) PrefixDecl */
0135:                ASTPrefixDecl jjtn000 = new ASTPrefixDecl(JJTPREFIXDECL);
0136:                boolean jjtc000 = true;
0137:                jjtree.openNodeScope(jjtn000);
0138:                Token prefix;
0139:                try {
0140:                    jj_consume_token(PREFIX);
0141:                    prefix = jj_consume_token(PNAME_NS);
0142:                    IRI();
0143:                    jjtree.closeNodeScope(jjtn000, true);
0144:                    jjtc000 = false;
0145:                    // Remove trailing colon from prefix
0146:                    String prefixStr = prefix.image;
0147:                    prefixStr = prefixStr.substring(0, prefixStr.length() - 1);
0148:
0149:                    jjtn000.setPrefix(prefixStr);
0150:                } catch (Throwable jjte000) {
0151:                    if (jjtc000) {
0152:                        jjtree.clearNodeScope(jjtn000);
0153:                        jjtc000 = false;
0154:                    } else {
0155:                        jjtree.popNode();
0156:                    }
0157:                    if (jjte000 instanceof  RuntimeException) {
0158:                        {
0159:                            if (true)
0160:                                throw (RuntimeException) jjte000;
0161:                        }
0162:                    }
0163:                    if (jjte000 instanceof  ParseException) {
0164:                        {
0165:                            if (true)
0166:                                throw (ParseException) jjte000;
0167:                        }
0168:                    }
0169:                    {
0170:                        if (true)
0171:                            throw (Error) jjte000;
0172:                    }
0173:                } finally {
0174:                    if (jjtc000) {
0175:                        jjtree.closeNodeScope(jjtn000, true);
0176:                    }
0177:                }
0178:            }
0179:
0180:            final public void Query() throws ParseException {
0181:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0182:                case SELECT:
0183:                    SelectQuery();
0184:                    break;
0185:                case CONSTRUCT:
0186:                    ConstructQuery();
0187:                    break;
0188:                case DESCRIBE:
0189:                    DescribeQuery();
0190:                    break;
0191:                case ASK:
0192:                    AskQuery();
0193:                    break;
0194:                default:
0195:                    jj_la1[2] = jj_gen;
0196:                    jj_consume_token(-1);
0197:                    throw new ParseException();
0198:                }
0199:            }
0200:
0201:            final public void SelectQuery() throws ParseException {
0202:                /*@bgen(jjtree) SelectQuery */
0203:                ASTSelectQuery jjtn000 = new ASTSelectQuery(JJTSELECTQUERY);
0204:                boolean jjtc000 = true;
0205:                jjtree.openNodeScope(jjtn000);
0206:                try {
0207:                    Select();
0208:                    label_2: while (true) {
0209:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0210:                        case FROM:
0211:                            ;
0212:                            break;
0213:                        default:
0214:                            jj_la1[3] = jj_gen;
0215:                            break label_2;
0216:                        }
0217:                        DatasetClause();
0218:                    }
0219:                    WhereClause();
0220:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0221:                    case ORDER:
0222:                        OrderClause();
0223:                        break;
0224:                    default:
0225:                        jj_la1[4] = jj_gen;
0226:                        ;
0227:                    }
0228:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0229:                    case LIMIT:
0230:                    case OFFSET:
0231:                        LimitOffsetClauses();
0232:                        break;
0233:                    default:
0234:                        jj_la1[5] = jj_gen;
0235:                        ;
0236:                    }
0237:                } catch (Throwable jjte000) {
0238:                    if (jjtc000) {
0239:                        jjtree.clearNodeScope(jjtn000);
0240:                        jjtc000 = false;
0241:                    } else {
0242:                        jjtree.popNode();
0243:                    }
0244:                    if (jjte000 instanceof  RuntimeException) {
0245:                        {
0246:                            if (true)
0247:                                throw (RuntimeException) jjte000;
0248:                        }
0249:                    }
0250:                    if (jjte000 instanceof  ParseException) {
0251:                        {
0252:                            if (true)
0253:                                throw (ParseException) jjte000;
0254:                        }
0255:                    }
0256:                    {
0257:                        if (true)
0258:                            throw (Error) jjte000;
0259:                    }
0260:                } finally {
0261:                    if (jjtc000) {
0262:                        jjtree.closeNodeScope(jjtn000, true);
0263:                    }
0264:                }
0265:            }
0266:
0267:            final public void Select() throws ParseException {
0268:                /*@bgen(jjtree) Select */
0269:                ASTSelect jjtn000 = new ASTSelect(JJTSELECT);
0270:                boolean jjtc000 = true;
0271:                jjtree.openNodeScope(jjtn000);
0272:                try {
0273:                    jj_consume_token(SELECT);
0274:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0275:                    case DISTINCT:
0276:                    case REDUCED:
0277:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0278:                        case DISTINCT:
0279:                            jj_consume_token(DISTINCT);
0280:                            jjtn000.setDistinct(true);
0281:                            break;
0282:                        case REDUCED:
0283:                            jj_consume_token(REDUCED);
0284:                            jjtn000.setReduced(true);
0285:                            break;
0286:                        default:
0287:                            jj_la1[6] = jj_gen;
0288:                            jj_consume_token(-1);
0289:                            throw new ParseException();
0290:                        }
0291:                        break;
0292:                    default:
0293:                        jj_la1[7] = jj_gen;
0294:                        ;
0295:                    }
0296:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0297:                    case STAR:
0298:                        jj_consume_token(STAR);
0299:                        jjtree.closeNodeScope(jjtn000, true);
0300:                        jjtc000 = false;
0301:                        jjtn000.setWildcard(true);
0302:                        break;
0303:                    case VAR1:
0304:                    case VAR2:
0305:                        label_3: while (true) {
0306:                            Var();
0307:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0308:                            case VAR1:
0309:                            case VAR2:
0310:                                ;
0311:                                break;
0312:                            default:
0313:                                jj_la1[8] = jj_gen;
0314:                                break label_3;
0315:                            }
0316:                        }
0317:                        break;
0318:                    default:
0319:                        jj_la1[9] = jj_gen;
0320:                        jj_consume_token(-1);
0321:                        throw new ParseException();
0322:                    }
0323:                } catch (Throwable jjte000) {
0324:                    if (jjtc000) {
0325:                        jjtree.clearNodeScope(jjtn000);
0326:                        jjtc000 = false;
0327:                    } else {
0328:                        jjtree.popNode();
0329:                    }
0330:                    if (jjte000 instanceof  RuntimeException) {
0331:                        {
0332:                            if (true)
0333:                                throw (RuntimeException) jjte000;
0334:                        }
0335:                    }
0336:                    if (jjte000 instanceof  ParseException) {
0337:                        {
0338:                            if (true)
0339:                                throw (ParseException) jjte000;
0340:                        }
0341:                    }
0342:                    {
0343:                        if (true)
0344:                            throw (Error) jjte000;
0345:                    }
0346:                } finally {
0347:                    if (jjtc000) {
0348:                        jjtree.closeNodeScope(jjtn000, true);
0349:                    }
0350:                }
0351:            }
0352:
0353:            final public void ConstructQuery() throws ParseException {
0354:                /*@bgen(jjtree) ConstructQuery */
0355:                ASTConstructQuery jjtn000 = new ASTConstructQuery(
0356:                        JJTCONSTRUCTQUERY);
0357:                boolean jjtc000 = true;
0358:                jjtree.openNodeScope(jjtn000);
0359:                try {
0360:                    Construct();
0361:                    label_4: while (true) {
0362:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0363:                        case FROM:
0364:                            ;
0365:                            break;
0366:                        default:
0367:                            jj_la1[10] = jj_gen;
0368:                            break label_4;
0369:                        }
0370:                        DatasetClause();
0371:                    }
0372:                    WhereClause();
0373:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0374:                    case ORDER:
0375:                        OrderClause();
0376:                        break;
0377:                    default:
0378:                        jj_la1[11] = jj_gen;
0379:                        ;
0380:                    }
0381:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0382:                    case LIMIT:
0383:                    case OFFSET:
0384:                        LimitOffsetClauses();
0385:                        break;
0386:                    default:
0387:                        jj_la1[12] = jj_gen;
0388:                        ;
0389:                    }
0390:                } catch (Throwable jjte000) {
0391:                    if (jjtc000) {
0392:                        jjtree.clearNodeScope(jjtn000);
0393:                        jjtc000 = false;
0394:                    } else {
0395:                        jjtree.popNode();
0396:                    }
0397:                    if (jjte000 instanceof  RuntimeException) {
0398:                        {
0399:                            if (true)
0400:                                throw (RuntimeException) jjte000;
0401:                        }
0402:                    }
0403:                    if (jjte000 instanceof  ParseException) {
0404:                        {
0405:                            if (true)
0406:                                throw (ParseException) jjte000;
0407:                        }
0408:                    }
0409:                    {
0410:                        if (true)
0411:                            throw (Error) jjte000;
0412:                    }
0413:                } finally {
0414:                    if (jjtc000) {
0415:                        jjtree.closeNodeScope(jjtn000, true);
0416:                    }
0417:                }
0418:            }
0419:
0420:            final public void Construct() throws ParseException {
0421:                /*@bgen(jjtree) Construct */
0422:                ASTConstruct jjtn000 = new ASTConstruct(JJTCONSTRUCT);
0423:                boolean jjtc000 = true;
0424:                jjtree.openNodeScope(jjtn000);
0425:                try {
0426:                    jj_consume_token(CONSTRUCT);
0427:                    jj_consume_token(LBRACE);
0428:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0429:                    case LPAREN:
0430:                    case LBRACK:
0431:                    case NIL:
0432:                    case ANON:
0433:                    case TRUE:
0434:                    case FALSE:
0435:                    case Q_IRI_REF:
0436:                    case PNAME_NS:
0437:                    case PNAME_LN:
0438:                    case BLANK_NODE_LABEL:
0439:                    case VAR1:
0440:                    case VAR2:
0441:                    case INTEGER:
0442:                    case INTEGER_POSITIVE:
0443:                    case INTEGER_NEGATIVE:
0444:                    case DECIMAL:
0445:                    case DECIMAL_POSITIVE:
0446:                    case DECIMAL_NEGATIVE:
0447:                    case DOUBLE:
0448:                    case DOUBLE_POSITIVE:
0449:                    case DOUBLE_NEGATIVE:
0450:                    case STRING_LITERAL1:
0451:                    case STRING_LITERAL2:
0452:                    case STRING_LITERAL_LONG1:
0453:                    case STRING_LITERAL_LONG2:
0454:                        TriplesBlock();
0455:                        break;
0456:                    default:
0457:                        jj_la1[13] = jj_gen;
0458:                        ;
0459:                    }
0460:                    jj_consume_token(RBRACE);
0461:                } catch (Throwable jjte000) {
0462:                    if (jjtc000) {
0463:                        jjtree.clearNodeScope(jjtn000);
0464:                        jjtc000 = false;
0465:                    } else {
0466:                        jjtree.popNode();
0467:                    }
0468:                    if (jjte000 instanceof  RuntimeException) {
0469:                        {
0470:                            if (true)
0471:                                throw (RuntimeException) jjte000;
0472:                        }
0473:                    }
0474:                    if (jjte000 instanceof  ParseException) {
0475:                        {
0476:                            if (true)
0477:                                throw (ParseException) jjte000;
0478:                        }
0479:                    }
0480:                    {
0481:                        if (true)
0482:                            throw (Error) jjte000;
0483:                    }
0484:                } finally {
0485:                    if (jjtc000) {
0486:                        jjtree.closeNodeScope(jjtn000, true);
0487:                    }
0488:                }
0489:            }
0490:
0491:            final public void DescribeQuery() throws ParseException {
0492:                /*@bgen(jjtree) DescribeQuery */
0493:                ASTDescribeQuery jjtn000 = new ASTDescribeQuery(
0494:                        JJTDESCRIBEQUERY);
0495:                boolean jjtc000 = true;
0496:                jjtree.openNodeScope(jjtn000);
0497:                try {
0498:                    Describe();
0499:                    label_5: while (true) {
0500:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0501:                        case FROM:
0502:                            ;
0503:                            break;
0504:                        default:
0505:                            jj_la1[14] = jj_gen;
0506:                            break label_5;
0507:                        }
0508:                        DatasetClause();
0509:                    }
0510:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0511:                    case LBRACE:
0512:                    case WHERE:
0513:                        WhereClause();
0514:                        break;
0515:                    default:
0516:                        jj_la1[15] = jj_gen;
0517:                        ;
0518:                    }
0519:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0520:                    case ORDER:
0521:                        OrderClause();
0522:                        break;
0523:                    default:
0524:                        jj_la1[16] = jj_gen;
0525:                        ;
0526:                    }
0527:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0528:                    case LIMIT:
0529:                    case OFFSET:
0530:                        LimitOffsetClauses();
0531:                        break;
0532:                    default:
0533:                        jj_la1[17] = jj_gen;
0534:                        ;
0535:                    }
0536:                } catch (Throwable jjte000) {
0537:                    if (jjtc000) {
0538:                        jjtree.clearNodeScope(jjtn000);
0539:                        jjtc000 = false;
0540:                    } else {
0541:                        jjtree.popNode();
0542:                    }
0543:                    if (jjte000 instanceof  RuntimeException) {
0544:                        {
0545:                            if (true)
0546:                                throw (RuntimeException) jjte000;
0547:                        }
0548:                    }
0549:                    if (jjte000 instanceof  ParseException) {
0550:                        {
0551:                            if (true)
0552:                                throw (ParseException) jjte000;
0553:                        }
0554:                    }
0555:                    {
0556:                        if (true)
0557:                            throw (Error) jjte000;
0558:                    }
0559:                } finally {
0560:                    if (jjtc000) {
0561:                        jjtree.closeNodeScope(jjtn000, true);
0562:                    }
0563:                }
0564:            }
0565:
0566:            final public void Describe() throws ParseException {
0567:                /*@bgen(jjtree) Describe */
0568:                ASTDescribe jjtn000 = new ASTDescribe(JJTDESCRIBE);
0569:                boolean jjtc000 = true;
0570:                jjtree.openNodeScope(jjtn000);
0571:                try {
0572:                    jj_consume_token(DESCRIBE);
0573:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0574:                    case STAR:
0575:                        jj_consume_token(STAR);
0576:                        jjtree.closeNodeScope(jjtn000, true);
0577:                        jjtc000 = false;
0578:                        jjtn000.setWildcard(true);
0579:                        break;
0580:                    case Q_IRI_REF:
0581:                    case PNAME_NS:
0582:                    case PNAME_LN:
0583:                    case VAR1:
0584:                    case VAR2:
0585:                        label_6: while (true) {
0586:                            VarOrIRIref();
0587:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0588:                            case Q_IRI_REF:
0589:                            case PNAME_NS:
0590:                            case PNAME_LN:
0591:                            case VAR1:
0592:                            case VAR2:
0593:                                ;
0594:                                break;
0595:                            default:
0596:                                jj_la1[18] = jj_gen;
0597:                                break label_6;
0598:                            }
0599:                        }
0600:                        break;
0601:                    default:
0602:                        jj_la1[19] = jj_gen;
0603:                        jj_consume_token(-1);
0604:                        throw new ParseException();
0605:                    }
0606:                } catch (Throwable jjte000) {
0607:                    if (jjtc000) {
0608:                        jjtree.clearNodeScope(jjtn000);
0609:                        jjtc000 = false;
0610:                    } else {
0611:                        jjtree.popNode();
0612:                    }
0613:                    if (jjte000 instanceof  RuntimeException) {
0614:                        {
0615:                            if (true)
0616:                                throw (RuntimeException) jjte000;
0617:                        }
0618:                    }
0619:                    if (jjte000 instanceof  ParseException) {
0620:                        {
0621:                            if (true)
0622:                                throw (ParseException) jjte000;
0623:                        }
0624:                    }
0625:                    {
0626:                        if (true)
0627:                            throw (Error) jjte000;
0628:                    }
0629:                } finally {
0630:                    if (jjtc000) {
0631:                        jjtree.closeNodeScope(jjtn000, true);
0632:                    }
0633:                }
0634:            }
0635:
0636:            final public void AskQuery() throws ParseException {
0637:                /*@bgen(jjtree) AskQuery */
0638:                ASTAskQuery jjtn000 = new ASTAskQuery(JJTASKQUERY);
0639:                boolean jjtc000 = true;
0640:                jjtree.openNodeScope(jjtn000);
0641:                try {
0642:                    jj_consume_token(ASK);
0643:                    label_7: while (true) {
0644:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0645:                        case FROM:
0646:                            ;
0647:                            break;
0648:                        default:
0649:                            jj_la1[20] = jj_gen;
0650:                            break label_7;
0651:                        }
0652:                        DatasetClause();
0653:                    }
0654:                    WhereClause();
0655:                } catch (Throwable jjte000) {
0656:                    if (jjtc000) {
0657:                        jjtree.clearNodeScope(jjtn000);
0658:                        jjtc000 = false;
0659:                    } else {
0660:                        jjtree.popNode();
0661:                    }
0662:                    if (jjte000 instanceof  RuntimeException) {
0663:                        {
0664:                            if (true)
0665:                                throw (RuntimeException) jjte000;
0666:                        }
0667:                    }
0668:                    if (jjte000 instanceof  ParseException) {
0669:                        {
0670:                            if (true)
0671:                                throw (ParseException) jjte000;
0672:                        }
0673:                    }
0674:                    {
0675:                        if (true)
0676:                            throw (Error) jjte000;
0677:                    }
0678:                } finally {
0679:                    if (jjtc000) {
0680:                        jjtree.closeNodeScope(jjtn000, true);
0681:                    }
0682:                }
0683:            }
0684:
0685:            final public void DatasetClause() throws ParseException {
0686:                /*@bgen(jjtree) DatasetClause */
0687:                ASTDatasetClause jjtn000 = new ASTDatasetClause(
0688:                        JJTDATASETCLAUSE);
0689:                boolean jjtc000 = true;
0690:                jjtree.openNodeScope(jjtn000);
0691:                try {
0692:                    jj_consume_token(FROM);
0693:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0694:                    case NAMED:
0695:                        jj_consume_token(NAMED);
0696:                        jjtn000.setNamed(true);
0697:                        break;
0698:                    default:
0699:                        jj_la1[21] = jj_gen;
0700:                        ;
0701:                    }
0702:                    IRIref();
0703:                } catch (Throwable jjte000) {
0704:                    if (jjtc000) {
0705:                        jjtree.clearNodeScope(jjtn000);
0706:                        jjtc000 = false;
0707:                    } else {
0708:                        jjtree.popNode();
0709:                    }
0710:                    if (jjte000 instanceof  RuntimeException) {
0711:                        {
0712:                            if (true)
0713:                                throw (RuntimeException) jjte000;
0714:                        }
0715:                    }
0716:                    if (jjte000 instanceof  ParseException) {
0717:                        {
0718:                            if (true)
0719:                                throw (ParseException) jjte000;
0720:                        }
0721:                    }
0722:                    {
0723:                        if (true)
0724:                            throw (Error) jjte000;
0725:                    }
0726:                } finally {
0727:                    if (jjtc000) {
0728:                        jjtree.closeNodeScope(jjtn000, true);
0729:                    }
0730:                }
0731:            }
0732:
0733:            final public void WhereClause() throws ParseException {
0734:                /*@bgen(jjtree) WhereClause */
0735:                ASTWhereClause jjtn000 = new ASTWhereClause(JJTWHERECLAUSE);
0736:                boolean jjtc000 = true;
0737:                jjtree.openNodeScope(jjtn000);
0738:                try {
0739:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0740:                    case WHERE:
0741:                        jj_consume_token(WHERE);
0742:                        break;
0743:                    default:
0744:                        jj_la1[22] = jj_gen;
0745:                        ;
0746:                    }
0747:                    GroupGraphPattern();
0748:                } catch (Throwable jjte000) {
0749:                    if (jjtc000) {
0750:                        jjtree.clearNodeScope(jjtn000);
0751:                        jjtc000 = false;
0752:                    } else {
0753:                        jjtree.popNode();
0754:                    }
0755:                    if (jjte000 instanceof  RuntimeException) {
0756:                        {
0757:                            if (true)
0758:                                throw (RuntimeException) jjte000;
0759:                        }
0760:                    }
0761:                    if (jjte000 instanceof  ParseException) {
0762:                        {
0763:                            if (true)
0764:                                throw (ParseException) jjte000;
0765:                        }
0766:                    }
0767:                    {
0768:                        if (true)
0769:                            throw (Error) jjte000;
0770:                    }
0771:                } finally {
0772:                    if (jjtc000) {
0773:                        jjtree.closeNodeScope(jjtn000, true);
0774:                    }
0775:                }
0776:            }
0777:
0778:            final public void OrderClause() throws ParseException {
0779:                /*@bgen(jjtree) OrderClause */
0780:                ASTOrderClause jjtn000 = new ASTOrderClause(JJTORDERCLAUSE);
0781:                boolean jjtc000 = true;
0782:                jjtree.openNodeScope(jjtn000);
0783:                try {
0784:                    jj_consume_token(ORDER);
0785:                    jj_consume_token(BY);
0786:                    label_8: while (true) {
0787:                        OrderCondition();
0788:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0789:                        case LPAREN:
0790:                        case ASC:
0791:                        case DESC:
0792:                        case STR:
0793:                        case LANG:
0794:                        case LANGMATCHES:
0795:                        case DATATYPE:
0796:                        case BOUND:
0797:                        case SAMETERM:
0798:                        case IS_IRI:
0799:                        case IS_BLANK:
0800:                        case IS_LITERAL:
0801:                        case REGEX:
0802:                        case Q_IRI_REF:
0803:                        case PNAME_NS:
0804:                        case PNAME_LN:
0805:                        case VAR1:
0806:                        case VAR2:
0807:                            ;
0808:                            break;
0809:                        default:
0810:                            jj_la1[23] = jj_gen;
0811:                            break label_8;
0812:                        }
0813:                    }
0814:                } catch (Throwable jjte000) {
0815:                    if (jjtc000) {
0816:                        jjtree.clearNodeScope(jjtn000);
0817:                        jjtc000 = false;
0818:                    } else {
0819:                        jjtree.popNode();
0820:                    }
0821:                    if (jjte000 instanceof  RuntimeException) {
0822:                        {
0823:                            if (true)
0824:                                throw (RuntimeException) jjte000;
0825:                        }
0826:                    }
0827:                    if (jjte000 instanceof  ParseException) {
0828:                        {
0829:                            if (true)
0830:                                throw (ParseException) jjte000;
0831:                        }
0832:                    }
0833:                    {
0834:                        if (true)
0835:                            throw (Error) jjte000;
0836:                    }
0837:                } finally {
0838:                    if (jjtc000) {
0839:                        jjtree.closeNodeScope(jjtn000, true);
0840:                    }
0841:                }
0842:            }
0843:
0844:            final public void OrderCondition() throws ParseException {
0845:                /*@bgen(jjtree) OrderCondition */
0846:                ASTOrderCondition jjtn000 = new ASTOrderCondition(
0847:                        JJTORDERCONDITION);
0848:                boolean jjtc000 = true;
0849:                jjtree.openNodeScope(jjtn000);
0850:                try {
0851:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0852:                    case LPAREN:
0853:                    case ASC:
0854:                    case DESC:
0855:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0856:                        case ASC:
0857:                        case DESC:
0858:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0859:                            case ASC:
0860:                                jj_consume_token(ASC);
0861:                                break;
0862:                            case DESC:
0863:                                jj_consume_token(DESC);
0864:                                jjtn000.setAscending(false);
0865:                                break;
0866:                            default:
0867:                                jj_la1[24] = jj_gen;
0868:                                jj_consume_token(-1);
0869:                                throw new ParseException();
0870:                            }
0871:                            break;
0872:                        default:
0873:                            jj_la1[25] = jj_gen;
0874:                            ;
0875:                        }
0876:                        BrackettedExpression();
0877:                        break;
0878:                    case Q_IRI_REF:
0879:                    case PNAME_NS:
0880:                    case PNAME_LN:
0881:                        FunctionCall();
0882:                        break;
0883:                    case STR:
0884:                    case LANG:
0885:                    case LANGMATCHES:
0886:                    case DATATYPE:
0887:                    case BOUND:
0888:                    case SAMETERM:
0889:                    case IS_IRI:
0890:                    case IS_BLANK:
0891:                    case IS_LITERAL:
0892:                    case REGEX:
0893:                        BuiltInCall();
0894:                        break;
0895:                    case VAR1:
0896:                    case VAR2:
0897:                        Var();
0898:                        break;
0899:                    default:
0900:                        jj_la1[26] = jj_gen;
0901:                        jj_consume_token(-1);
0902:                        throw new ParseException();
0903:                    }
0904:                } catch (Throwable jjte000) {
0905:                    if (jjtc000) {
0906:                        jjtree.clearNodeScope(jjtn000);
0907:                        jjtc000 = false;
0908:                    } else {
0909:                        jjtree.popNode();
0910:                    }
0911:                    if (jjte000 instanceof  RuntimeException) {
0912:                        {
0913:                            if (true)
0914:                                throw (RuntimeException) jjte000;
0915:                        }
0916:                    }
0917:                    if (jjte000 instanceof  ParseException) {
0918:                        {
0919:                            if (true)
0920:                                throw (ParseException) jjte000;
0921:                        }
0922:                    }
0923:                    {
0924:                        if (true)
0925:                            throw (Error) jjte000;
0926:                    }
0927:                } finally {
0928:                    if (jjtc000) {
0929:                        jjtree.closeNodeScope(jjtn000, true);
0930:                    }
0931:                }
0932:            }
0933:
0934:            final public void LimitOffsetClauses() throws ParseException {
0935:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0936:                case LIMIT:
0937:                    Limit();
0938:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0939:                    case OFFSET:
0940:                        Offset();
0941:                        break;
0942:                    default:
0943:                        jj_la1[27] = jj_gen;
0944:                        ;
0945:                    }
0946:                    break;
0947:                case OFFSET:
0948:                    Offset();
0949:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0950:                    case LIMIT:
0951:                        Limit();
0952:                        break;
0953:                    default:
0954:                        jj_la1[28] = jj_gen;
0955:                        ;
0956:                    }
0957:                    break;
0958:                default:
0959:                    jj_la1[29] = jj_gen;
0960:                    jj_consume_token(-1);
0961:                    throw new ParseException();
0962:                }
0963:            }
0964:
0965:            final public void Limit() throws ParseException {
0966:                /*@bgen(jjtree) Limit */
0967:                ASTLimit jjtn000 = new ASTLimit(JJTLIMIT);
0968:                boolean jjtc000 = true;
0969:                jjtree.openNodeScope(jjtn000);
0970:                Token t;
0971:                try {
0972:                    jj_consume_token(LIMIT);
0973:                    t = jj_consume_token(INTEGER);
0974:                    jjtree.closeNodeScope(jjtn000, true);
0975:                    jjtc000 = false;
0976:                    jjtn000.setValue(Integer.parseInt(t.image));
0977:                } finally {
0978:                    if (jjtc000) {
0979:                        jjtree.closeNodeScope(jjtn000, true);
0980:                    }
0981:                }
0982:            }
0983:
0984:            final public void Offset() throws ParseException {
0985:                /*@bgen(jjtree) Offset */
0986:                ASTOffset jjtn000 = new ASTOffset(JJTOFFSET);
0987:                boolean jjtc000 = true;
0988:                jjtree.openNodeScope(jjtn000);
0989:                Token t;
0990:                try {
0991:                    jj_consume_token(OFFSET);
0992:                    t = jj_consume_token(INTEGER);
0993:                    jjtree.closeNodeScope(jjtn000, true);
0994:                    jjtc000 = false;
0995:                    jjtn000.setValue(Integer.parseInt(t.image));
0996:                } finally {
0997:                    if (jjtc000) {
0998:                        jjtree.closeNodeScope(jjtn000, true);
0999:                    }
1000:                }
1001:            }
1002:
1003:            final public void GroupGraphPattern() throws ParseException {
1004:                /*@bgen(jjtree) GraphPatternGroup */
1005:                ASTGraphPatternGroup jjtn000 = new ASTGraphPatternGroup(
1006:                        JJTGRAPHPATTERNGROUP);
1007:                boolean jjtc000 = true;
1008:                jjtree.openNodeScope(jjtn000);
1009:                try {
1010:                    jj_consume_token(LBRACE);
1011:                    GraphPattern();
1012:                    jj_consume_token(RBRACE);
1013:                } catch (Throwable jjte000) {
1014:                    if (jjtc000) {
1015:                        jjtree.clearNodeScope(jjtn000);
1016:                        jjtc000 = false;
1017:                    } else {
1018:                        jjtree.popNode();
1019:                    }
1020:                    if (jjte000 instanceof  RuntimeException) {
1021:                        {
1022:                            if (true)
1023:                                throw (RuntimeException) jjte000;
1024:                        }
1025:                    }
1026:                    if (jjte000 instanceof  ParseException) {
1027:                        {
1028:                            if (true)
1029:                                throw (ParseException) jjte000;
1030:                        }
1031:                    }
1032:                    {
1033:                        if (true)
1034:                            throw (Error) jjte000;
1035:                    }
1036:                } finally {
1037:                    if (jjtc000) {
1038:                        jjtree.closeNodeScope(jjtn000, true);
1039:                    }
1040:                }
1041:            }
1042:
1043:            final public void GraphPattern() throws ParseException {
1044:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1045:                case LPAREN:
1046:                case LBRACK:
1047:                case NIL:
1048:                case ANON:
1049:                case FILTER:
1050:                case TRUE:
1051:                case FALSE:
1052:                case Q_IRI_REF:
1053:                case PNAME_NS:
1054:                case PNAME_LN:
1055:                case BLANK_NODE_LABEL:
1056:                case VAR1:
1057:                case VAR2:
1058:                case INTEGER:
1059:                case INTEGER_POSITIVE:
1060:                case INTEGER_NEGATIVE:
1061:                case DECIMAL:
1062:                case DECIMAL_POSITIVE:
1063:                case DECIMAL_NEGATIVE:
1064:                case DOUBLE:
1065:                case DOUBLE_POSITIVE:
1066:                case DOUBLE_NEGATIVE:
1067:                case STRING_LITERAL1:
1068:                case STRING_LITERAL2:
1069:                case STRING_LITERAL_LONG1:
1070:                case STRING_LITERAL_LONG2:
1071:                    BasicGraphPattern();
1072:                    break;
1073:                default:
1074:                    jj_la1[30] = jj_gen;
1075:                    ;
1076:                }
1077:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1078:                case LBRACE:
1079:                case OPTIONAL:
1080:                case GRAPH:
1081:                    GraphPatternNotTriples();
1082:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1083:                    case DOT:
1084:                        jj_consume_token(DOT);
1085:                        break;
1086:                    default:
1087:                        jj_la1[31] = jj_gen;
1088:                        ;
1089:                    }
1090:                    GraphPattern();
1091:                    break;
1092:                default:
1093:                    jj_la1[32] = jj_gen;
1094:                    ;
1095:                }
1096:            }
1097:
1098:            final public void BasicGraphPattern() throws ParseException {
1099:                /*@bgen(jjtree) BasicGraphPattern */
1100:                ASTBasicGraphPattern jjtn000 = new ASTBasicGraphPattern(
1101:                        JJTBASICGRAPHPATTERN);
1102:                boolean jjtc000 = true;
1103:                jjtree.openNodeScope(jjtn000);
1104:                try {
1105:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1106:                    case LPAREN:
1107:                    case LBRACK:
1108:                    case NIL:
1109:                    case ANON:
1110:                    case TRUE:
1111:                    case FALSE:
1112:                    case Q_IRI_REF:
1113:                    case PNAME_NS:
1114:                    case PNAME_LN:
1115:                    case BLANK_NODE_LABEL:
1116:                    case VAR1:
1117:                    case VAR2:
1118:                    case INTEGER:
1119:                    case INTEGER_POSITIVE:
1120:                    case INTEGER_NEGATIVE:
1121:                    case DECIMAL:
1122:                    case DECIMAL_POSITIVE:
1123:                    case DECIMAL_NEGATIVE:
1124:                    case DOUBLE:
1125:                    case DOUBLE_POSITIVE:
1126:                    case DOUBLE_NEGATIVE:
1127:                    case STRING_LITERAL1:
1128:                    case STRING_LITERAL2:
1129:                    case STRING_LITERAL_LONG1:
1130:                    case STRING_LITERAL_LONG2:
1131:                        TriplesBlock();
1132:                        label_9: while (true) {
1133:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1134:                            case FILTER:
1135:                                ;
1136:                                break;
1137:                            default:
1138:                                jj_la1[33] = jj_gen;
1139:                                break label_9;
1140:                            }
1141:                            Filter();
1142:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1143:                            case DOT:
1144:                                jj_consume_token(DOT);
1145:                                break;
1146:                            default:
1147:                                jj_la1[34] = jj_gen;
1148:                                ;
1149:                            }
1150:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1151:                            case LPAREN:
1152:                            case LBRACK:
1153:                            case NIL:
1154:                            case ANON:
1155:                            case TRUE:
1156:                            case FALSE:
1157:                            case Q_IRI_REF:
1158:                            case PNAME_NS:
1159:                            case PNAME_LN:
1160:                            case BLANK_NODE_LABEL:
1161:                            case VAR1:
1162:                            case VAR2:
1163:                            case INTEGER:
1164:                            case INTEGER_POSITIVE:
1165:                            case INTEGER_NEGATIVE:
1166:                            case DECIMAL:
1167:                            case DECIMAL_POSITIVE:
1168:                            case DECIMAL_NEGATIVE:
1169:                            case DOUBLE:
1170:                            case DOUBLE_POSITIVE:
1171:                            case DOUBLE_NEGATIVE:
1172:                            case STRING_LITERAL1:
1173:                            case STRING_LITERAL2:
1174:                            case STRING_LITERAL_LONG1:
1175:                            case STRING_LITERAL_LONG2:
1176:                                TriplesBlock();
1177:                                break;
1178:                            default:
1179:                                jj_la1[35] = jj_gen;
1180:                                ;
1181:                            }
1182:                        }
1183:                        break;
1184:                    case FILTER:
1185:                        label_10: while (true) {
1186:                            Filter();
1187:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1188:                            case DOT:
1189:                                jj_consume_token(DOT);
1190:                                break;
1191:                            default:
1192:                                jj_la1[36] = jj_gen;
1193:                                ;
1194:                            }
1195:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1196:                            case LPAREN:
1197:                            case LBRACK:
1198:                            case NIL:
1199:                            case ANON:
1200:                            case TRUE:
1201:                            case FALSE:
1202:                            case Q_IRI_REF:
1203:                            case PNAME_NS:
1204:                            case PNAME_LN:
1205:                            case BLANK_NODE_LABEL:
1206:                            case VAR1:
1207:                            case VAR2:
1208:                            case INTEGER:
1209:                            case INTEGER_POSITIVE:
1210:                            case INTEGER_NEGATIVE:
1211:                            case DECIMAL:
1212:                            case DECIMAL_POSITIVE:
1213:                            case DECIMAL_NEGATIVE:
1214:                            case DOUBLE:
1215:                            case DOUBLE_POSITIVE:
1216:                            case DOUBLE_NEGATIVE:
1217:                            case STRING_LITERAL1:
1218:                            case STRING_LITERAL2:
1219:                            case STRING_LITERAL_LONG1:
1220:                            case STRING_LITERAL_LONG2:
1221:                                TriplesBlock();
1222:                                break;
1223:                            default:
1224:                                jj_la1[37] = jj_gen;
1225:                                ;
1226:                            }
1227:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1228:                            case FILTER:
1229:                                ;
1230:                                break;
1231:                            default:
1232:                                jj_la1[38] = jj_gen;
1233:                                break label_10;
1234:                            }
1235:                        }
1236:                        break;
1237:                    default:
1238:                        jj_la1[39] = jj_gen;
1239:                        jj_consume_token(-1);
1240:                        throw new ParseException();
1241:                    }
1242:                } catch (Throwable jjte000) {
1243:                    if (jjtc000) {
1244:                        jjtree.clearNodeScope(jjtn000);
1245:                        jjtc000 = false;
1246:                    } else {
1247:                        jjtree.popNode();
1248:                    }
1249:                    if (jjte000 instanceof  RuntimeException) {
1250:                        {
1251:                            if (true)
1252:                                throw (RuntimeException) jjte000;
1253:                        }
1254:                    }
1255:                    if (jjte000 instanceof  ParseException) {
1256:                        {
1257:                            if (true)
1258:                                throw (ParseException) jjte000;
1259:                        }
1260:                    }
1261:                    {
1262:                        if (true)
1263:                            throw (Error) jjte000;
1264:                    }
1265:                } finally {
1266:                    if (jjtc000) {
1267:                        jjtree.closeNodeScope(jjtn000, true);
1268:                    }
1269:                }
1270:            }
1271:
1272:            final public void TriplesBlock() throws ParseException {
1273:                TriplesSameSubject();
1274:                label_11: while (true) {
1275:                    if (jj_2_1(2)) {
1276:                        ;
1277:                    } else {
1278:                        break label_11;
1279:                    }
1280:                    jj_consume_token(DOT);
1281:                    TriplesSameSubject();
1282:                }
1283:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1284:                case DOT:
1285:                    jj_consume_token(DOT);
1286:                    break;
1287:                default:
1288:                    jj_la1[40] = jj_gen;
1289:                    ;
1290:                }
1291:            }
1292:
1293:            final public void GraphPatternNotTriples() throws ParseException {
1294:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1295:                case OPTIONAL:
1296:                    OptionalGraphPattern();
1297:                    break;
1298:                case LBRACE:
1299:                    GroupOrUnionGraphPattern();
1300:                    break;
1301:                case GRAPH:
1302:                    GraphGraphPattern();
1303:                    break;
1304:                default:
1305:                    jj_la1[41] = jj_gen;
1306:                    jj_consume_token(-1);
1307:                    throw new ParseException();
1308:                }
1309:            }
1310:
1311:            final public void OptionalGraphPattern() throws ParseException {
1312:                /*@bgen(jjtree) OptionalGraphPattern */
1313:                ASTOptionalGraphPattern jjtn000 = new ASTOptionalGraphPattern(
1314:                        JJTOPTIONALGRAPHPATTERN);
1315:                boolean jjtc000 = true;
1316:                jjtree.openNodeScope(jjtn000);
1317:                try {
1318:                    jj_consume_token(OPTIONAL);
1319:                    jj_consume_token(LBRACE);
1320:                    GraphPattern();
1321:                    jj_consume_token(RBRACE);
1322:                } catch (Throwable jjte000) {
1323:                    if (jjtc000) {
1324:                        jjtree.clearNodeScope(jjtn000);
1325:                        jjtc000 = false;
1326:                    } else {
1327:                        jjtree.popNode();
1328:                    }
1329:                    if (jjte000 instanceof  RuntimeException) {
1330:                        {
1331:                            if (true)
1332:                                throw (RuntimeException) jjte000;
1333:                        }
1334:                    }
1335:                    if (jjte000 instanceof  ParseException) {
1336:                        {
1337:                            if (true)
1338:                                throw (ParseException) jjte000;
1339:                        }
1340:                    }
1341:                    {
1342:                        if (true)
1343:                            throw (Error) jjte000;
1344:                    }
1345:                } finally {
1346:                    if (jjtc000) {
1347:                        jjtree.closeNodeScope(jjtn000, true);
1348:                    }
1349:                }
1350:            }
1351:
1352:            final public void GraphGraphPattern() throws ParseException {
1353:                /*@bgen(jjtree) GraphGraphPattern */
1354:                ASTGraphGraphPattern jjtn000 = new ASTGraphGraphPattern(
1355:                        JJTGRAPHGRAPHPATTERN);
1356:                boolean jjtc000 = true;
1357:                jjtree.openNodeScope(jjtn000);
1358:                try {
1359:                    jj_consume_token(GRAPH);
1360:                    VarOrIRIref();
1361:                    GroupGraphPattern();
1362:                } catch (Throwable jjte000) {
1363:                    if (jjtc000) {
1364:                        jjtree.clearNodeScope(jjtn000);
1365:                        jjtc000 = false;
1366:                    } else {
1367:                        jjtree.popNode();
1368:                    }
1369:                    if (jjte000 instanceof  RuntimeException) {
1370:                        {
1371:                            if (true)
1372:                                throw (RuntimeException) jjte000;
1373:                        }
1374:                    }
1375:                    if (jjte000 instanceof  ParseException) {
1376:                        {
1377:                            if (true)
1378:                                throw (ParseException) jjte000;
1379:                        }
1380:                    }
1381:                    {
1382:                        if (true)
1383:                            throw (Error) jjte000;
1384:                    }
1385:                } finally {
1386:                    if (jjtc000) {
1387:                        jjtree.closeNodeScope(jjtn000, true);
1388:                    }
1389:                }
1390:            }
1391:
1392:            final public void GroupOrUnionGraphPattern() throws ParseException {
1393:                GroupGraphPattern();
1394:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1395:                case UNION:
1396:                    jj_consume_token(UNION);
1397:                    ASTUnionGraphPattern jjtn001 = new ASTUnionGraphPattern(
1398:                            JJTUNIONGRAPHPATTERN);
1399:                    boolean jjtc001 = true;
1400:                    jjtree.openNodeScope(jjtn001);
1401:                    try {
1402:                        GroupOrUnionGraphPattern();
1403:                    } catch (Throwable jjte001) {
1404:                        if (jjtc001) {
1405:                            jjtree.clearNodeScope(jjtn001);
1406:                            jjtc001 = false;
1407:                        } else {
1408:                            jjtree.popNode();
1409:                        }
1410:                        if (jjte001 instanceof  RuntimeException) {
1411:                            {
1412:                                if (true)
1413:                                    throw (RuntimeException) jjte001;
1414:                            }
1415:                        }
1416:                        if (jjte001 instanceof  ParseException) {
1417:                            {
1418:                                if (true)
1419:                                    throw (ParseException) jjte001;
1420:                            }
1421:                        }
1422:                        {
1423:                            if (true)
1424:                                throw (Error) jjte001;
1425:                        }
1426:                    } finally {
1427:                        if (jjtc001) {
1428:                            jjtree.closeNodeScope(jjtn001, 2);
1429:                        }
1430:                    }
1431:                    break;
1432:                default:
1433:                    jj_la1[42] = jj_gen;
1434:                    ;
1435:                }
1436:            }
1437:
1438:            final public void Filter() throws ParseException {
1439:                jj_consume_token(FILTER);
1440:                Constraint();
1441:            }
1442:
1443:            final public void Constraint() throws ParseException {
1444:                /*@bgen(jjtree) Constraint */
1445:                ASTConstraint jjtn000 = new ASTConstraint(JJTCONSTRAINT);
1446:                boolean jjtc000 = true;
1447:                jjtree.openNodeScope(jjtn000);
1448:                try {
1449:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1450:                    case LPAREN:
1451:                        BrackettedExpression();
1452:                        break;
1453:                    case STR:
1454:                    case LANG:
1455:                    case LANGMATCHES:
1456:                    case DATATYPE:
1457:                    case BOUND:
1458:                    case SAMETERM:
1459:                    case IS_IRI:
1460:                    case IS_BLANK:
1461:                    case IS_LITERAL:
1462:                    case REGEX:
1463:                        BuiltInCall();
1464:                        break;
1465:                    case Q_IRI_REF:
1466:                    case PNAME_NS:
1467:                    case PNAME_LN:
1468:                        FunctionCall();
1469:                        break;
1470:                    default:
1471:                        jj_la1[43] = jj_gen;
1472:                        jj_consume_token(-1);
1473:                        throw new ParseException();
1474:                    }
1475:                } catch (Throwable jjte000) {
1476:                    if (jjtc000) {
1477:                        jjtree.clearNodeScope(jjtn000);
1478:                        jjtc000 = false;
1479:                    } else {
1480:                        jjtree.popNode();
1481:                    }
1482:                    if (jjte000 instanceof  RuntimeException) {
1483:                        {
1484:                            if (true)
1485:                                throw (RuntimeException) jjte000;
1486:                        }
1487:                    }
1488:                    if (jjte000 instanceof  ParseException) {
1489:                        {
1490:                            if (true)
1491:                                throw (ParseException) jjte000;
1492:                        }
1493:                    }
1494:                    {
1495:                        if (true)
1496:                            throw (Error) jjte000;
1497:                    }
1498:                } finally {
1499:                    if (jjtc000) {
1500:                        jjtree.closeNodeScope(jjtn000, true);
1501:                    }
1502:                }
1503:            }
1504:
1505:            final public void FunctionCall() throws ParseException {
1506:                /*@bgen(jjtree) FunctionCall */
1507:                ASTFunctionCall jjtn000 = new ASTFunctionCall(JJTFUNCTIONCALL);
1508:                boolean jjtc000 = true;
1509:                jjtree.openNodeScope(jjtn000);
1510:                try {
1511:                    IRIref();
1512:                    ArgList();
1513:                } catch (Throwable jjte000) {
1514:                    if (jjtc000) {
1515:                        jjtree.clearNodeScope(jjtn000);
1516:                        jjtc000 = false;
1517:                    } else {
1518:                        jjtree.popNode();
1519:                    }
1520:                    if (jjte000 instanceof  RuntimeException) {
1521:                        {
1522:                            if (true)
1523:                                throw (RuntimeException) jjte000;
1524:                        }
1525:                    }
1526:                    if (jjte000 instanceof  ParseException) {
1527:                        {
1528:                            if (true)
1529:                                throw (ParseException) jjte000;
1530:                        }
1531:                    }
1532:                    {
1533:                        if (true)
1534:                            throw (Error) jjte000;
1535:                    }
1536:                } finally {
1537:                    if (jjtc000) {
1538:                        jjtree.closeNodeScope(jjtn000, true);
1539:                    }
1540:                }
1541:            }
1542:
1543:            final public void ArgList() throws ParseException {
1544:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1545:                case NIL:
1546:                    jj_consume_token(NIL);
1547:                    break;
1548:                case LPAREN:
1549:                    jj_consume_token(LPAREN);
1550:                    Expression();
1551:                    label_12: while (true) {
1552:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1553:                        case COMMA:
1554:                            ;
1555:                            break;
1556:                        default:
1557:                            jj_la1[44] = jj_gen;
1558:                            break label_12;
1559:                        }
1560:                        jj_consume_token(COMMA);
1561:                        Expression();
1562:                    }
1563:                    jj_consume_token(RPAREN);
1564:                    break;
1565:                default:
1566:                    jj_la1[45] = jj_gen;
1567:                    jj_consume_token(-1);
1568:                    throw new ParseException();
1569:                }
1570:            }
1571:
1572:            final public void TriplesSameSubject() throws ParseException {
1573:                /*@bgen(jjtree) TriplesSameSubject */
1574:                ASTTriplesSameSubject jjtn000 = new ASTTriplesSameSubject(
1575:                        JJTTRIPLESSAMESUBJECT);
1576:                boolean jjtc000 = true;
1577:                jjtree.openNodeScope(jjtn000);
1578:                try {
1579:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1580:                    case NIL:
1581:                    case ANON:
1582:                    case TRUE:
1583:                    case FALSE:
1584:                    case Q_IRI_REF:
1585:                    case PNAME_NS:
1586:                    case PNAME_LN:
1587:                    case BLANK_NODE_LABEL:
1588:                    case VAR1:
1589:                    case VAR2:
1590:                    case INTEGER:
1591:                    case INTEGER_POSITIVE:
1592:                    case INTEGER_NEGATIVE:
1593:                    case DECIMAL:
1594:                    case DECIMAL_POSITIVE:
1595:                    case DECIMAL_NEGATIVE:
1596:                    case DOUBLE:
1597:                    case DOUBLE_POSITIVE:
1598:                    case DOUBLE_NEGATIVE:
1599:                    case STRING_LITERAL1:
1600:                    case STRING_LITERAL2:
1601:                    case STRING_LITERAL_LONG1:
1602:                    case STRING_LITERAL_LONG2:
1603:                        VarOrTerm();
1604:                        PropertyList();
1605:                        break;
1606:                    case LPAREN:
1607:                    case LBRACK:
1608:                        TriplesNode();
1609:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1610:                        case IS_A:
1611:                        case Q_IRI_REF:
1612:                        case PNAME_NS:
1613:                        case PNAME_LN:
1614:                        case VAR1:
1615:                        case VAR2:
1616:                            PropertyList();
1617:                            break;
1618:                        default:
1619:                            jj_la1[46] = jj_gen;
1620:                            ;
1621:                        }
1622:                        break;
1623:                    default:
1624:                        jj_la1[47] = jj_gen;
1625:                        jj_consume_token(-1);
1626:                        throw new ParseException();
1627:                    }
1628:                } catch (Throwable jjte000) {
1629:                    if (jjtc000) {
1630:                        jjtree.clearNodeScope(jjtn000);
1631:                        jjtc000 = false;
1632:                    } else {
1633:                        jjtree.popNode();
1634:                    }
1635:                    if (jjte000 instanceof  RuntimeException) {
1636:                        {
1637:                            if (true)
1638:                                throw (RuntimeException) jjte000;
1639:                        }
1640:                    }
1641:                    if (jjte000 instanceof  ParseException) {
1642:                        {
1643:                            if (true)
1644:                                throw (ParseException) jjte000;
1645:                        }
1646:                    }
1647:                    {
1648:                        if (true)
1649:                            throw (Error) jjte000;
1650:                    }
1651:                } finally {
1652:                    if (jjtc000) {
1653:                        jjtree.closeNodeScope(jjtn000, true);
1654:                    }
1655:                }
1656:            }
1657:
1658:            final public void PropertyList() throws ParseException {
1659:                /*@bgen(jjtree) PropertyList */
1660:                ASTPropertyList jjtn000 = new ASTPropertyList(JJTPROPERTYLIST);
1661:                boolean jjtc000 = true;
1662:                jjtree.openNodeScope(jjtn000);
1663:                try {
1664:                    Verb();
1665:                    ObjectList();
1666:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1667:                    case SEMICOLON:
1668:                        jj_consume_token(SEMICOLON);
1669:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1670:                        case IS_A:
1671:                        case Q_IRI_REF:
1672:                        case PNAME_NS:
1673:                        case PNAME_LN:
1674:                        case VAR1:
1675:                        case VAR2:
1676:                            PropertyList();
1677:                            break;
1678:                        default:
1679:                            jj_la1[48] = jj_gen;
1680:                            ;
1681:                        }
1682:                        break;
1683:                    default:
1684:                        jj_la1[49] = jj_gen;
1685:                        ;
1686:                    }
1687:                } catch (Throwable jjte000) {
1688:                    if (jjtc000) {
1689:                        jjtree.clearNodeScope(jjtn000);
1690:                        jjtc000 = false;
1691:                    } else {
1692:                        jjtree.popNode();
1693:                    }
1694:                    if (jjte000 instanceof  RuntimeException) {
1695:                        {
1696:                            if (true)
1697:                                throw (RuntimeException) jjte000;
1698:                        }
1699:                    }
1700:                    if (jjte000 instanceof  ParseException) {
1701:                        {
1702:                            if (true)
1703:                                throw (ParseException) jjte000;
1704:                        }
1705:                    }
1706:                    {
1707:                        if (true)
1708:                            throw (Error) jjte000;
1709:                    }
1710:                } finally {
1711:                    if (jjtc000) {
1712:                        jjtree.closeNodeScope(jjtn000, true);
1713:                    }
1714:                }
1715:            }
1716:
1717:            final public void ObjectList() throws ParseException {
1718:                /*@bgen(jjtree) ObjectList */
1719:                ASTObjectList jjtn000 = new ASTObjectList(JJTOBJECTLIST);
1720:                boolean jjtc000 = true;
1721:                jjtree.openNodeScope(jjtn000);
1722:                try {
1723:                    Object();
1724:                    label_13: while (true) {
1725:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1726:                        case COMMA:
1727:                            ;
1728:                            break;
1729:                        default:
1730:                            jj_la1[50] = jj_gen;
1731:                            break label_13;
1732:                        }
1733:                        jj_consume_token(COMMA);
1734:                        Object();
1735:                    }
1736:                } catch (Throwable jjte000) {
1737:                    if (jjtc000) {
1738:                        jjtree.clearNodeScope(jjtn000);
1739:                        jjtc000 = false;
1740:                    } else {
1741:                        jjtree.popNode();
1742:                    }
1743:                    if (jjte000 instanceof  RuntimeException) {
1744:                        {
1745:                            if (true)
1746:                                throw (RuntimeException) jjte000;
1747:                        }
1748:                    }
1749:                    if (jjte000 instanceof  ParseException) {
1750:                        {
1751:                            if (true)
1752:                                throw (ParseException) jjte000;
1753:                        }
1754:                    }
1755:                    {
1756:                        if (true)
1757:                            throw (Error) jjte000;
1758:                    }
1759:                } finally {
1760:                    if (jjtc000) {
1761:                        jjtree.closeNodeScope(jjtn000, true);
1762:                    }
1763:                }
1764:            }
1765:
1766:            final public void Object() throws ParseException {
1767:                GraphNode();
1768:            }
1769:
1770:            final public void Verb() throws ParseException {
1771:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1772:                case Q_IRI_REF:
1773:                case PNAME_NS:
1774:                case PNAME_LN:
1775:                case VAR1:
1776:                case VAR2:
1777:                    VarOrIRIref();
1778:                    break;
1779:                case IS_A:
1780:                    jj_consume_token(IS_A);
1781:                    ASTIRI jjtn001 = new ASTIRI(JJTIRI);
1782:                    boolean jjtc001 = true;
1783:                    jjtree.openNodeScope(jjtn001);
1784:                    try {
1785:                        jjtree.closeNodeScope(jjtn001, true);
1786:                        jjtc001 = false;
1787:                        jjtn001.setValue(RDF.TYPE.toString());
1788:                    } finally {
1789:                        if (jjtc001) {
1790:                            jjtree.closeNodeScope(jjtn001, true);
1791:                        }
1792:                    }
1793:                    break;
1794:                default:
1795:                    jj_la1[51] = jj_gen;
1796:                    jj_consume_token(-1);
1797:                    throw new ParseException();
1798:                }
1799:            }
1800:
1801:            final public void TriplesNode() throws ParseException {
1802:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1803:                case LPAREN:
1804:                    Collection();
1805:                    break;
1806:                case LBRACK:
1807:                    BlankNodePropertyList();
1808:                    break;
1809:                default:
1810:                    jj_la1[52] = jj_gen;
1811:                    jj_consume_token(-1);
1812:                    throw new ParseException();
1813:                }
1814:            }
1815:
1816:            final public void BlankNodePropertyList() throws ParseException {
1817:                /*@bgen(jjtree) BlankNodePropertyList */
1818:                ASTBlankNodePropertyList jjtn000 = new ASTBlankNodePropertyList(
1819:                        JJTBLANKNODEPROPERTYLIST);
1820:                boolean jjtc000 = true;
1821:                jjtree.openNodeScope(jjtn000);
1822:                try {
1823:                    jj_consume_token(LBRACK);
1824:                    PropertyList();
1825:                    jj_consume_token(RBRACK);
1826:                } catch (Throwable jjte000) {
1827:                    if (jjtc000) {
1828:                        jjtree.clearNodeScope(jjtn000);
1829:                        jjtc000 = false;
1830:                    } else {
1831:                        jjtree.popNode();
1832:                    }
1833:                    if (jjte000 instanceof  RuntimeException) {
1834:                        {
1835:                            if (true)
1836:                                throw (RuntimeException) jjte000;
1837:                        }
1838:                    }
1839:                    if (jjte000 instanceof  ParseException) {
1840:                        {
1841:                            if (true)
1842:                                throw (ParseException) jjte000;
1843:                        }
1844:                    }
1845:                    {
1846:                        if (true)
1847:                            throw (Error) jjte000;
1848:                    }
1849:                } finally {
1850:                    if (jjtc000) {
1851:                        jjtree.closeNodeScope(jjtn000, true);
1852:                    }
1853:                }
1854:            }
1855:
1856:            final public void Collection() throws ParseException {
1857:                /*@bgen(jjtree) Collection */
1858:                ASTCollection jjtn000 = new ASTCollection(JJTCOLLECTION);
1859:                boolean jjtc000 = true;
1860:                jjtree.openNodeScope(jjtn000);
1861:                try {
1862:                    jj_consume_token(LPAREN);
1863:                    label_14: while (true) {
1864:                        GraphNode();
1865:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1866:                        case LPAREN:
1867:                        case LBRACK:
1868:                        case NIL:
1869:                        case ANON:
1870:                        case TRUE:
1871:                        case FALSE:
1872:                        case Q_IRI_REF:
1873:                        case PNAME_NS:
1874:                        case PNAME_LN:
1875:                        case BLANK_NODE_LABEL:
1876:                        case VAR1:
1877:                        case VAR2:
1878:                        case INTEGER:
1879:                        case INTEGER_POSITIVE:
1880:                        case INTEGER_NEGATIVE:
1881:                        case DECIMAL:
1882:                        case DECIMAL_POSITIVE:
1883:                        case DECIMAL_NEGATIVE:
1884:                        case DOUBLE:
1885:                        case DOUBLE_POSITIVE:
1886:                        case DOUBLE_NEGATIVE:
1887:                        case STRING_LITERAL1:
1888:                        case STRING_LITERAL2:
1889:                        case STRING_LITERAL_LONG1:
1890:                        case STRING_LITERAL_LONG2:
1891:                            ;
1892:                            break;
1893:                        default:
1894:                            jj_la1[53] = jj_gen;
1895:                            break label_14;
1896:                        }
1897:                    }
1898:                    jj_consume_token(RPAREN);
1899:                } catch (Throwable jjte000) {
1900:                    if (jjtc000) {
1901:                        jjtree.clearNodeScope(jjtn000);
1902:                        jjtc000 = false;
1903:                    } else {
1904:                        jjtree.popNode();
1905:                    }
1906:                    if (jjte000 instanceof  RuntimeException) {
1907:                        {
1908:                            if (true)
1909:                                throw (RuntimeException) jjte000;
1910:                        }
1911:                    }
1912:                    if (jjte000 instanceof  ParseException) {
1913:                        {
1914:                            if (true)
1915:                                throw (ParseException) jjte000;
1916:                        }
1917:                    }
1918:                    {
1919:                        if (true)
1920:                            throw (Error) jjte000;
1921:                    }
1922:                } finally {
1923:                    if (jjtc000) {
1924:                        jjtree.closeNodeScope(jjtn000, true);
1925:                    }
1926:                }
1927:            }
1928:
1929:            final public void GraphNode() throws ParseException {
1930:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1931:                case NIL:
1932:                case ANON:
1933:                case TRUE:
1934:                case FALSE:
1935:                case Q_IRI_REF:
1936:                case PNAME_NS:
1937:                case PNAME_LN:
1938:                case BLANK_NODE_LABEL:
1939:                case VAR1:
1940:                case VAR2:
1941:                case INTEGER:
1942:                case INTEGER_POSITIVE:
1943:                case INTEGER_NEGATIVE:
1944:                case DECIMAL:
1945:                case DECIMAL_POSITIVE:
1946:                case DECIMAL_NEGATIVE:
1947:                case DOUBLE:
1948:                case DOUBLE_POSITIVE:
1949:                case DOUBLE_NEGATIVE:
1950:                case STRING_LITERAL1:
1951:                case STRING_LITERAL2:
1952:                case STRING_LITERAL_LONG1:
1953:                case STRING_LITERAL_LONG2:
1954:                    VarOrTerm();
1955:                    break;
1956:                case LPAREN:
1957:                case LBRACK:
1958:                    TriplesNode();
1959:                    break;
1960:                default:
1961:                    jj_la1[54] = jj_gen;
1962:                    jj_consume_token(-1);
1963:                    throw new ParseException();
1964:                }
1965:            }
1966:
1967:            final public void VarOrTerm() throws ParseException {
1968:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1969:                case VAR1:
1970:                case VAR2:
1971:                    Var();
1972:                    break;
1973:                case NIL:
1974:                case ANON:
1975:                case TRUE:
1976:                case FALSE:
1977:                case Q_IRI_REF:
1978:                case PNAME_NS:
1979:                case PNAME_LN:
1980:                case BLANK_NODE_LABEL:
1981:                case INTEGER:
1982:                case INTEGER_POSITIVE:
1983:                case INTEGER_NEGATIVE:
1984:                case DECIMAL:
1985:                case DECIMAL_POSITIVE:
1986:                case DECIMAL_NEGATIVE:
1987:                case DOUBLE:
1988:                case DOUBLE_POSITIVE:
1989:                case DOUBLE_NEGATIVE:
1990:                case STRING_LITERAL1:
1991:                case STRING_LITERAL2:
1992:                case STRING_LITERAL_LONG1:
1993:                case STRING_LITERAL_LONG2:
1994:                    GraphTerm();
1995:                    break;
1996:                default:
1997:                    jj_la1[55] = jj_gen;
1998:                    jj_consume_token(-1);
1999:                    throw new ParseException();
2000:                }
2001:            }
2002:
2003:            final public void VarOrIRIref() throws ParseException {
2004:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2005:                case VAR1:
2006:                case VAR2:
2007:                    Var();
2008:                    break;
2009:                case Q_IRI_REF:
2010:                case PNAME_NS:
2011:                case PNAME_LN:
2012:                    IRIref();
2013:                    break;
2014:                default:
2015:                    jj_la1[56] = jj_gen;
2016:                    jj_consume_token(-1);
2017:                    throw new ParseException();
2018:                }
2019:            }
2020:
2021:            final public void Var() throws ParseException {
2022:                /*@bgen(jjtree) Var */
2023:                ASTVar jjtn000 = new ASTVar(JJTVAR);
2024:                boolean jjtc000 = true;
2025:                jjtree.openNodeScope(jjtn000);
2026:                Token t;
2027:                try {
2028:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2029:                    case VAR1:
2030:                        t = jj_consume_token(VAR1);
2031:                        break;
2032:                    case VAR2:
2033:                        t = jj_consume_token(VAR2);
2034:                        break;
2035:                    default:
2036:                        jj_la1[57] = jj_gen;
2037:                        jj_consume_token(-1);
2038:                        throw new ParseException();
2039:                    }
2040:                    jjtree.closeNodeScope(jjtn000, true);
2041:                    jjtc000 = false;
2042:                    jjtn000.setName(t.image.substring(1));
2043:                } finally {
2044:                    if (jjtc000) {
2045:                        jjtree.closeNodeScope(jjtn000, true);
2046:                    }
2047:                }
2048:            }
2049:
2050:            final public void GraphTerm() throws ParseException {
2051:                boolean positive = true;
2052:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2053:                case Q_IRI_REF:
2054:                case PNAME_NS:
2055:                case PNAME_LN:
2056:                    IRIref();
2057:                    break;
2058:                case STRING_LITERAL1:
2059:                case STRING_LITERAL2:
2060:                case STRING_LITERAL_LONG1:
2061:                case STRING_LITERAL_LONG2:
2062:                    RDFLiteral();
2063:                    break;
2064:                case INTEGER:
2065:                case INTEGER_POSITIVE:
2066:                case INTEGER_NEGATIVE:
2067:                case DECIMAL:
2068:                case DECIMAL_POSITIVE:
2069:                case DECIMAL_NEGATIVE:
2070:                case DOUBLE:
2071:                case DOUBLE_POSITIVE:
2072:                case DOUBLE_NEGATIVE:
2073:                    NumericLiteral();
2074:                    break;
2075:                case TRUE:
2076:                case FALSE:
2077:                    BooleanLiteral();
2078:                    break;
2079:                case ANON:
2080:                case BLANK_NODE_LABEL:
2081:                    BlankNode();
2082:                    break;
2083:                case NIL:
2084:                    jj_consume_token(NIL);
2085:                    ASTIRI jjtn001 = new ASTIRI(JJTIRI);
2086:                    boolean jjtc001 = true;
2087:                    jjtree.openNodeScope(jjtn001);
2088:                    try {
2089:                        jjtree.closeNodeScope(jjtn001, true);
2090:                        jjtc001 = false;
2091:                        jjtn001.setValue(RDF.NIL.toString());
2092:                    } finally {
2093:                        if (jjtc001) {
2094:                            jjtree.closeNodeScope(jjtn001, true);
2095:                        }
2096:                    }
2097:                    break;
2098:                default:
2099:                    jj_la1[58] = jj_gen;
2100:                    jj_consume_token(-1);
2101:                    throw new ParseException();
2102:                }
2103:            }
2104:
2105:            final public void Expression() throws ParseException {
2106:                ConditionalOrExpression();
2107:            }
2108:
2109:            final public void ConditionalOrExpression() throws ParseException {
2110:                ConditionalAndExpression();
2111:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2112:                case OR:
2113:                    jj_consume_token(OR);
2114:                    ASTOr jjtn001 = new ASTOr(JJTOR);
2115:                    boolean jjtc001 = true;
2116:                    jjtree.openNodeScope(jjtn001);
2117:                    try {
2118:                        ConditionalOrExpression();
2119:                    } catch (Throwable jjte001) {
2120:                        if (jjtc001) {
2121:                            jjtree.clearNodeScope(jjtn001);
2122:                            jjtc001 = false;
2123:                        } else {
2124:                            jjtree.popNode();
2125:                        }
2126:                        if (jjte001 instanceof  RuntimeException) {
2127:                            {
2128:                                if (true)
2129:                                    throw (RuntimeException) jjte001;
2130:                            }
2131:                        }
2132:                        if (jjte001 instanceof  ParseException) {
2133:                            {
2134:                                if (true)
2135:                                    throw (ParseException) jjte001;
2136:                            }
2137:                        }
2138:                        {
2139:                            if (true)
2140:                                throw (Error) jjte001;
2141:                        }
2142:                    } finally {
2143:                        if (jjtc001) {
2144:                            jjtree.closeNodeScope(jjtn001, 2);
2145:                        }
2146:                    }
2147:                    break;
2148:                default:
2149:                    jj_la1[59] = jj_gen;
2150:                    ;
2151:                }
2152:            }
2153:
2154:            final public void ConditionalAndExpression() throws ParseException {
2155:                ValueLogical();
2156:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2157:                case AND:
2158:                    jj_consume_token(AND);
2159:                    ASTAnd jjtn001 = new ASTAnd(JJTAND);
2160:                    boolean jjtc001 = true;
2161:                    jjtree.openNodeScope(jjtn001);
2162:                    try {
2163:                        ConditionalAndExpression();
2164:                    } catch (Throwable jjte001) {
2165:                        if (jjtc001) {
2166:                            jjtree.clearNodeScope(jjtn001);
2167:                            jjtc001 = false;
2168:                        } else {
2169:                            jjtree.popNode();
2170:                        }
2171:                        if (jjte001 instanceof  RuntimeException) {
2172:                            {
2173:                                if (true)
2174:                                    throw (RuntimeException) jjte001;
2175:                            }
2176:                        }
2177:                        if (jjte001 instanceof  ParseException) {
2178:                            {
2179:                                if (true)
2180:                                    throw (ParseException) jjte001;
2181:                            }
2182:                        }
2183:                        {
2184:                            if (true)
2185:                                throw (Error) jjte001;
2186:                        }
2187:                    } finally {
2188:                        if (jjtc001) {
2189:                            jjtree.closeNodeScope(jjtn001, 2);
2190:                        }
2191:                    }
2192:                    break;
2193:                default:
2194:                    jj_la1[60] = jj_gen;
2195:                    ;
2196:                }
2197:            }
2198:
2199:            final public void ValueLogical() throws ParseException {
2200:                RelationalExpression();
2201:            }
2202:
2203:            final public void RelationalExpression() throws ParseException {
2204:                NumericExpression();
2205:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2206:                case EQ:
2207:                case NE:
2208:                case GT:
2209:                case LT:
2210:                case LE:
2211:                case GE:
2212:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2213:                    case EQ:
2214:                        jj_consume_token(EQ);
2215:                        NumericExpression();
2216:                        ASTCompare jjtn001 = new ASTCompare(JJTCOMPARE);
2217:                        boolean jjtc001 = true;
2218:                        jjtree.openNodeScope(jjtn001);
2219:                        try {
2220:                            jjtree.closeNodeScope(jjtn001, 2);
2221:                            jjtc001 = false;
2222:                            jjtn001.setOperator(CompareOp.EQ);
2223:                        } finally {
2224:                            if (jjtc001) {
2225:                                jjtree.closeNodeScope(jjtn001, 2);
2226:                            }
2227:                        }
2228:                        break;
2229:                    case NE:
2230:                        jj_consume_token(NE);
2231:                        NumericExpression();
2232:                        ASTCompare jjtn002 = new ASTCompare(JJTCOMPARE);
2233:                        boolean jjtc002 = true;
2234:                        jjtree.openNodeScope(jjtn002);
2235:                        try {
2236:                            jjtree.closeNodeScope(jjtn002, 2);
2237:                            jjtc002 = false;
2238:                            jjtn002.setOperator(CompareOp.NE);
2239:                        } finally {
2240:                            if (jjtc002) {
2241:                                jjtree.closeNodeScope(jjtn002, 2);
2242:                            }
2243:                        }
2244:                        break;
2245:                    case LT:
2246:                        jj_consume_token(LT);
2247:                        NumericExpression();
2248:                        ASTCompare jjtn003 = new ASTCompare(JJTCOMPARE);
2249:                        boolean jjtc003 = true;
2250:                        jjtree.openNodeScope(jjtn003);
2251:                        try {
2252:                            jjtree.closeNodeScope(jjtn003, 2);
2253:                            jjtc003 = false;
2254:                            jjtn003.setOperator(CompareOp.LT);
2255:                        } finally {
2256:                            if (jjtc003) {
2257:                                jjtree.closeNodeScope(jjtn003, 2);
2258:                            }
2259:                        }
2260:                        break;
2261:                    case LE:
2262:                        jj_consume_token(LE);
2263:                        NumericExpression();
2264:                        ASTCompare jjtn004 = new ASTCompare(JJTCOMPARE);
2265:                        boolean jjtc004 = true;
2266:                        jjtree.openNodeScope(jjtn004);
2267:                        try {
2268:                            jjtree.closeNodeScope(jjtn004, 2);
2269:                            jjtc004 = false;
2270:                            jjtn004.setOperator(CompareOp.LE);
2271:                        } finally {
2272:                            if (jjtc004) {
2273:                                jjtree.closeNodeScope(jjtn004, 2);
2274:                            }
2275:                        }
2276:                        break;
2277:                    case GE:
2278:                        jj_consume_token(GE);
2279:                        NumericExpression();
2280:                        ASTCompare jjtn005 = new ASTCompare(JJTCOMPARE);
2281:                        boolean jjtc005 = true;
2282:                        jjtree.openNodeScope(jjtn005);
2283:                        try {
2284:                            jjtree.closeNodeScope(jjtn005, 2);
2285:                            jjtc005 = false;
2286:                            jjtn005.setOperator(CompareOp.GE);
2287:                        } finally {
2288:                            if (jjtc005) {
2289:                                jjtree.closeNodeScope(jjtn005, 2);
2290:                            }
2291:                        }
2292:                        break;
2293:                    case GT:
2294:                        jj_consume_token(GT);
2295:                        NumericExpression();
2296:                        ASTCompare jjtn006 = new ASTCompare(JJTCOMPARE);
2297:                        boolean jjtc006 = true;
2298:                        jjtree.openNodeScope(jjtn006);
2299:                        try {
2300:                            jjtree.closeNodeScope(jjtn006, 2);
2301:                            jjtc006 = false;
2302:                            jjtn006.setOperator(CompareOp.GT);
2303:                        } finally {
2304:                            if (jjtc006) {
2305:                                jjtree.closeNodeScope(jjtn006, 2);
2306:                            }
2307:                        }
2308:                        break;
2309:                    default:
2310:                        jj_la1[61] = jj_gen;
2311:                        jj_consume_token(-1);
2312:                        throw new ParseException();
2313:                    }
2314:                    break;
2315:                default:
2316:                    jj_la1[62] = jj_gen;
2317:                    ;
2318:                }
2319:            }
2320:
2321:            final public void NumericExpression() throws ParseException {
2322:                AdditiveExpression();
2323:            }
2324:
2325:            final public void AdditiveExpression() throws ParseException {
2326:                MultiplicativeExpression();
2327:                label_15: while (true) {
2328:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2329:                    case PLUS:
2330:                    case MINUS:
2331:                    case INTEGER_POSITIVE:
2332:                    case INTEGER_NEGATIVE:
2333:                    case DECIMAL_POSITIVE:
2334:                    case DECIMAL_NEGATIVE:
2335:                    case DOUBLE_POSITIVE:
2336:                    case DOUBLE_NEGATIVE:
2337:                        ;
2338:                        break;
2339:                    default:
2340:                        jj_la1[63] = jj_gen;
2341:                        break label_15;
2342:                    }
2343:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2344:                    case PLUS:
2345:                        jj_consume_token(PLUS);
2346:                        MultiplicativeExpression();
2347:                        ASTMath jjtn001 = new ASTMath(JJTMATH);
2348:                        boolean jjtc001 = true;
2349:                        jjtree.openNodeScope(jjtn001);
2350:                        try {
2351:                            jjtree.closeNodeScope(jjtn001, 2);
2352:                            jjtc001 = false;
2353:                            jjtn001.setOperator(MathOp.PLUS);
2354:                        } finally {
2355:                            if (jjtc001) {
2356:                                jjtree.closeNodeScope(jjtn001, 2);
2357:                            }
2358:                        }
2359:                        break;
2360:                    case MINUS:
2361:                        jj_consume_token(MINUS);
2362:                        MultiplicativeExpression();
2363:                        ASTMath jjtn002 = new ASTMath(JJTMATH);
2364:                        boolean jjtc002 = true;
2365:                        jjtree.openNodeScope(jjtn002);
2366:                        try {
2367:                            jjtree.closeNodeScope(jjtn002, 2);
2368:                            jjtc002 = false;
2369:                            jjtn002.setOperator(MathOp.MINUS);
2370:                        } finally {
2371:                            if (jjtc002) {
2372:                                jjtree.closeNodeScope(jjtn002, 2);
2373:                            }
2374:                        }
2375:                        break;
2376:                    case INTEGER_POSITIVE:
2377:                    case DECIMAL_POSITIVE:
2378:                    case DOUBLE_POSITIVE:
2379:                        NumericLiteralPositive();
2380:                        ASTMath jjtn003 = new ASTMath(JJTMATH);
2381:                        boolean jjtc003 = true;
2382:                        jjtree.openNodeScope(jjtn003);
2383:                        try {
2384:                            jjtree.closeNodeScope(jjtn003, 2);
2385:                            jjtc003 = false;
2386:                            jjtn003.setOperator(MathOp.PLUS);
2387:                        } finally {
2388:                            if (jjtc003) {
2389:                                jjtree.closeNodeScope(jjtn003, 2);
2390:                            }
2391:                        }
2392:                        break;
2393:                    case INTEGER_NEGATIVE:
2394:                    case DECIMAL_NEGATIVE:
2395:                    case DOUBLE_NEGATIVE:
2396:                        NumericLiteralNegative();
2397:                        ASTMath jjtn004 = new ASTMath(JJTMATH);
2398:                        boolean jjtc004 = true;
2399:                        jjtree.openNodeScope(jjtn004);
2400:                        try {
2401:                            jjtree.closeNodeScope(jjtn004, 2);
2402:                            jjtc004 = false;
2403:                            jjtn004.setOperator(MathOp.PLUS);
2404:                        } finally {
2405:                            if (jjtc004) {
2406:                                jjtree.closeNodeScope(jjtn004, 2);
2407:                            }
2408:                        }
2409:                        break;
2410:                    default:
2411:                        jj_la1[64] = jj_gen;
2412:                        jj_consume_token(-1);
2413:                        throw new ParseException();
2414:                    }
2415:                }
2416:            }
2417:
2418:            final public void MultiplicativeExpression() throws ParseException {
2419:                UnaryExpression();
2420:                label_16: while (true) {
2421:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2422:                    case STAR:
2423:                    case SLASH:
2424:                        ;
2425:                        break;
2426:                    default:
2427:                        jj_la1[65] = jj_gen;
2428:                        break label_16;
2429:                    }
2430:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2431:                    case STAR:
2432:                        jj_consume_token(STAR);
2433:                        UnaryExpression();
2434:                        ASTMath jjtn001 = new ASTMath(JJTMATH);
2435:                        boolean jjtc001 = true;
2436:                        jjtree.openNodeScope(jjtn001);
2437:                        try {
2438:                            jjtree.closeNodeScope(jjtn001, 2);
2439:                            jjtc001 = false;
2440:                            jjtn001.setOperator(MathOp.MULTIPLY);
2441:                        } finally {
2442:                            if (jjtc001) {
2443:                                jjtree.closeNodeScope(jjtn001, 2);
2444:                            }
2445:                        }
2446:                        break;
2447:                    case SLASH:
2448:                        jj_consume_token(SLASH);
2449:                        UnaryExpression();
2450:                        ASTMath jjtn002 = new ASTMath(JJTMATH);
2451:                        boolean jjtc002 = true;
2452:                        jjtree.openNodeScope(jjtn002);
2453:                        try {
2454:                            jjtree.closeNodeScope(jjtn002, 2);
2455:                            jjtc002 = false;
2456:                            jjtn002.setOperator(MathOp.DIVIDE);
2457:                        } finally {
2458:                            if (jjtc002) {
2459:                                jjtree.closeNodeScope(jjtn002, 2);
2460:                            }
2461:                        }
2462:                        break;
2463:                    default:
2464:                        jj_la1[66] = jj_gen;
2465:                        jj_consume_token(-1);
2466:                        throw new ParseException();
2467:                    }
2468:                }
2469:            }
2470:
2471:            final public void UnaryExpression() throws ParseException {
2472:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2473:                case NOT:
2474:                    jj_consume_token(NOT);
2475:                    ASTNot jjtn001 = new ASTNot(JJTNOT);
2476:                    boolean jjtc001 = true;
2477:                    jjtree.openNodeScope(jjtn001);
2478:                    try {
2479:                        PrimaryExpression();
2480:                    } catch (Throwable jjte001) {
2481:                        if (jjtc001) {
2482:                            jjtree.clearNodeScope(jjtn001);
2483:                            jjtc001 = false;
2484:                        } else {
2485:                            jjtree.popNode();
2486:                        }
2487:                        if (jjte001 instanceof  RuntimeException) {
2488:                            {
2489:                                if (true)
2490:                                    throw (RuntimeException) jjte001;
2491:                            }
2492:                        }
2493:                        if (jjte001 instanceof  ParseException) {
2494:                            {
2495:                                if (true)
2496:                                    throw (ParseException) jjte001;
2497:                            }
2498:                        }
2499:                        {
2500:                            if (true)
2501:                                throw (Error) jjte001;
2502:                        }
2503:                    } finally {
2504:                        if (jjtc001) {
2505:                            jjtree.closeNodeScope(jjtn001, true);
2506:                        }
2507:                    }
2508:                    break;
2509:                case LPAREN:
2510:                case PLUS:
2511:                case STR:
2512:                case LANG:
2513:                case LANGMATCHES:
2514:                case DATATYPE:
2515:                case BOUND:
2516:                case SAMETERM:
2517:                case IS_IRI:
2518:                case IS_BLANK:
2519:                case IS_LITERAL:
2520:                case REGEX:
2521:                case TRUE:
2522:                case FALSE:
2523:                case Q_IRI_REF:
2524:                case PNAME_NS:
2525:                case PNAME_LN:
2526:                case VAR1:
2527:                case VAR2:
2528:                case INTEGER:
2529:                case INTEGER_POSITIVE:
2530:                case INTEGER_NEGATIVE:
2531:                case DECIMAL:
2532:                case DECIMAL_POSITIVE:
2533:                case DECIMAL_NEGATIVE:
2534:                case DOUBLE:
2535:                case DOUBLE_POSITIVE:
2536:                case DOUBLE_NEGATIVE:
2537:                case STRING_LITERAL1:
2538:                case STRING_LITERAL2:
2539:                case STRING_LITERAL_LONG1:
2540:                case STRING_LITERAL_LONG2:
2541:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2542:                    case PLUS:
2543:                        jj_consume_token(PLUS);
2544:                        break;
2545:                    default:
2546:                        jj_la1[67] = jj_gen;
2547:                        ;
2548:                    }
2549:                    PrimaryExpression();
2550:                    break;
2551:                case MINUS:
2552:                    UnaryMinus();
2553:                    PrimaryExpression();
2554:                    ASTMath jjtn002 = new ASTMath(JJTMATH);
2555:                    boolean jjtc002 = true;
2556:                    jjtree.openNodeScope(jjtn002);
2557:                    try {
2558:                        jjtree.closeNodeScope(jjtn002, 2);
2559:                        jjtc002 = false;
2560:                        jjtn002.setOperator(MathOp.MULTIPLY);
2561:                    } finally {
2562:                        if (jjtc002) {
2563:                            jjtree.closeNodeScope(jjtn002, 2);
2564:                        }
2565:                    }
2566:                    break;
2567:                default:
2568:                    jj_la1[68] = jj_gen;
2569:                    jj_consume_token(-1);
2570:                    throw new ParseException();
2571:                }
2572:            }
2573:
2574:            final public void UnaryMinus() throws ParseException {
2575:                /*@bgen(jjtree) NumericLiteral */
2576:                ASTNumericLiteral jjtn000 = new ASTNumericLiteral(
2577:                        JJTNUMERICLITERAL);
2578:                boolean jjtc000 = true;
2579:                jjtree.openNodeScope(jjtn000);
2580:                try {
2581:                    jj_consume_token(MINUS);
2582:                    jjtree.closeNodeScope(jjtn000, true);
2583:                    jjtc000 = false;
2584:                    jjtn000.setValue("-1");
2585:                    jjtn000.setDatatype(XMLSchema.INTEGER);
2586:                } finally {
2587:                    if (jjtc000) {
2588:                        jjtree.closeNodeScope(jjtn000, true);
2589:                    }
2590:                }
2591:            }
2592:
2593:            final public void PrimaryExpression() throws ParseException {
2594:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2595:                case LPAREN:
2596:                    BrackettedExpression();
2597:                    break;
2598:                case STR:
2599:                case LANG:
2600:                case LANGMATCHES:
2601:                case DATATYPE:
2602:                case BOUND:
2603:                case SAMETERM:
2604:                case IS_IRI:
2605:                case IS_BLANK:
2606:                case IS_LITERAL:
2607:                case REGEX:
2608:                    BuiltInCall();
2609:                    break;
2610:                default:
2611:                    jj_la1[69] = jj_gen;
2612:                    if (jj_2_2(2)) {
2613:                        FunctionCall();
2614:                    } else {
2615:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2616:                        case Q_IRI_REF:
2617:                        case PNAME_NS:
2618:                        case PNAME_LN:
2619:                            IRIref();
2620:                            break;
2621:                        case STRING_LITERAL1:
2622:                        case STRING_LITERAL2:
2623:                        case STRING_LITERAL_LONG1:
2624:                        case STRING_LITERAL_LONG2:
2625:                            RDFLiteral();
2626:                            break;
2627:                        case INTEGER:
2628:                        case INTEGER_POSITIVE:
2629:                        case INTEGER_NEGATIVE:
2630:                        case DECIMAL:
2631:                        case DECIMAL_POSITIVE:
2632:                        case DECIMAL_NEGATIVE:
2633:                        case DOUBLE:
2634:                        case DOUBLE_POSITIVE:
2635:                        case DOUBLE_NEGATIVE:
2636:                            NumericLiteral();
2637:                            break;
2638:                        case TRUE:
2639:                        case FALSE:
2640:                            BooleanLiteral();
2641:                            break;
2642:                        case VAR1:
2643:                        case VAR2:
2644:                            Var();
2645:                            break;
2646:                        default:
2647:                            jj_la1[70] = jj_gen;
2648:                            jj_consume_token(-1);
2649:                            throw new ParseException();
2650:                        }
2651:                    }
2652:                }
2653:            }
2654:
2655:            final public void BrackettedExpression() throws ParseException {
2656:                jj_consume_token(LPAREN);
2657:                Expression();
2658:                jj_consume_token(RPAREN);
2659:            }
2660:
2661:            final public void BuiltInCall() throws ParseException {
2662:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2663:                case STR:
2664:                    Str();
2665:                    break;
2666:                case LANG:
2667:                    Lang();
2668:                    break;
2669:                case LANGMATCHES:
2670:                    LangMatches();
2671:                    break;
2672:                case DATATYPE:
2673:                    Datatype();
2674:                    break;
2675:                case BOUND:
2676:                    Bound();
2677:                    break;
2678:                case SAMETERM:
2679:                    SameTerm();
2680:                    break;
2681:                case IS_IRI:
2682:                    IsIRI();
2683:                    break;
2684:                case IS_BLANK:
2685:                    IsBlank();
2686:                    break;
2687:                case IS_LITERAL:
2688:                    IsLiteral();
2689:                    break;
2690:                case REGEX:
2691:                    RegexExpression();
2692:                    break;
2693:                default:
2694:                    jj_la1[71] = jj_gen;
2695:                    jj_consume_token(-1);
2696:                    throw new ParseException();
2697:                }
2698:            }
2699:
2700:            final public void Str() throws ParseException {
2701:                /*@bgen(jjtree) Str */
2702:                ASTStr jjtn000 = new ASTStr(JJTSTR);
2703:                boolean jjtc000 = true;
2704:                jjtree.openNodeScope(jjtn000);
2705:                try {
2706:                    jj_consume_token(STR);
2707:                    jj_consume_token(LPAREN);
2708:                    Expression();
2709:                    jj_consume_token(RPAREN);
2710:                } catch (Throwable jjte000) {
2711:                    if (jjtc000) {
2712:                        jjtree.clearNodeScope(jjtn000);
2713:                        jjtc000 = false;
2714:                    } else {
2715:                        jjtree.popNode();
2716:                    }
2717:                    if (jjte000 instanceof  RuntimeException) {
2718:                        {
2719:                            if (true)
2720:                                throw (RuntimeException) jjte000;
2721:                        }
2722:                    }
2723:                    if (jjte000 instanceof  ParseException) {
2724:                        {
2725:                            if (true)
2726:                                throw (ParseException) jjte000;
2727:                        }
2728:                    }
2729:                    {
2730:                        if (true)
2731:                            throw (Error) jjte000;
2732:                    }
2733:                } finally {
2734:                    if (jjtc000) {
2735:                        jjtree.closeNodeScope(jjtn000, true);
2736:                    }
2737:                }
2738:            }
2739:
2740:            final public void Lang() throws ParseException {
2741:                /*@bgen(jjtree) Lang */
2742:                ASTLang jjtn000 = new ASTLang(JJTLANG);
2743:                boolean jjtc000 = true;
2744:                jjtree.openNodeScope(jjtn000);
2745:                try {
2746:                    jj_consume_token(LANG);
2747:                    jj_consume_token(LPAREN);
2748:                    Expression();
2749:                    jj_consume_token(RPAREN);
2750:                } catch (Throwable jjte000) {
2751:                    if (jjtc000) {
2752:                        jjtree.clearNodeScope(jjtn000);
2753:                        jjtc000 = false;
2754:                    } else {
2755:                        jjtree.popNode();
2756:                    }
2757:                    if (jjte000 instanceof  RuntimeException) {
2758:                        {
2759:                            if (true)
2760:                                throw (RuntimeException) jjte000;
2761:                        }
2762:                    }
2763:                    if (jjte000 instanceof  ParseException) {
2764:                        {
2765:                            if (true)
2766:                                throw (ParseException) jjte000;
2767:                        }
2768:                    }
2769:                    {
2770:                        if (true)
2771:                            throw (Error) jjte000;
2772:                    }
2773:                } finally {
2774:                    if (jjtc000) {
2775:                        jjtree.closeNodeScope(jjtn000, true);
2776:                    }
2777:                }
2778:            }
2779:
2780:            final public void LangMatches() throws ParseException {
2781:                /*@bgen(jjtree) LangMatches */
2782:                ASTLangMatches jjtn000 = new ASTLangMatches(JJTLANGMATCHES);
2783:                boolean jjtc000 = true;
2784:                jjtree.openNodeScope(jjtn000);
2785:                try {
2786:                    jj_consume_token(LANGMATCHES);
2787:                    jj_consume_token(LPAREN);
2788:                    Expression();
2789:                    jj_consume_token(COMMA);
2790:                    Expression();
2791:                    jj_consume_token(RPAREN);
2792:                } catch (Throwable jjte000) {
2793:                    if (jjtc000) {
2794:                        jjtree.clearNodeScope(jjtn000);
2795:                        jjtc000 = false;
2796:                    } else {
2797:                        jjtree.popNode();
2798:                    }
2799:                    if (jjte000 instanceof  RuntimeException) {
2800:                        {
2801:                            if (true)
2802:                                throw (RuntimeException) jjte000;
2803:                        }
2804:                    }
2805:                    if (jjte000 instanceof  ParseException) {
2806:                        {
2807:                            if (true)
2808:                                throw (ParseException) jjte000;
2809:                        }
2810:                    }
2811:                    {
2812:                        if (true)
2813:                            throw (Error) jjte000;
2814:                    }
2815:                } finally {
2816:                    if (jjtc000) {
2817:                        jjtree.closeNodeScope(jjtn000, true);
2818:                    }
2819:                }
2820:            }
2821:
2822:            final public void Datatype() throws ParseException {
2823:                /*@bgen(jjtree) Datatype */
2824:                ASTDatatype jjtn000 = new ASTDatatype(JJTDATATYPE);
2825:                boolean jjtc000 = true;
2826:                jjtree.openNodeScope(jjtn000);
2827:                try {
2828:                    jj_consume_token(DATATYPE);
2829:                    jj_consume_token(LPAREN);
2830:                    Expression();
2831:                    jj_consume_token(RPAREN);
2832:                } catch (Throwable jjte000) {
2833:                    if (jjtc000) {
2834:                        jjtree.clearNodeScope(jjtn000);
2835:                        jjtc000 = false;
2836:                    } else {
2837:                        jjtree.popNode();
2838:                    }
2839:                    if (jjte000 instanceof  RuntimeException) {
2840:                        {
2841:                            if (true)
2842:                                throw (RuntimeException) jjte000;
2843:                        }
2844:                    }
2845:                    if (jjte000 instanceof  ParseException) {
2846:                        {
2847:                            if (true)
2848:                                throw (ParseException) jjte000;
2849:                        }
2850:                    }
2851:                    {
2852:                        if (true)
2853:                            throw (Error) jjte000;
2854:                    }
2855:                } finally {
2856:                    if (jjtc000) {
2857:                        jjtree.closeNodeScope(jjtn000, true);
2858:                    }
2859:                }
2860:            }
2861:
2862:            final public void Bound() throws ParseException {
2863:                /*@bgen(jjtree) Bound */
2864:                ASTBound jjtn000 = new ASTBound(JJTBOUND);
2865:                boolean jjtc000 = true;
2866:                jjtree.openNodeScope(jjtn000);
2867:                try {
2868:                    jj_consume_token(BOUND);
2869:                    jj_consume_token(LPAREN);
2870:                    Var();
2871:                    jj_consume_token(RPAREN);
2872:                } catch (Throwable jjte000) {
2873:                    if (jjtc000) {
2874:                        jjtree.clearNodeScope(jjtn000);
2875:                        jjtc000 = false;
2876:                    } else {
2877:                        jjtree.popNode();
2878:                    }
2879:                    if (jjte000 instanceof  RuntimeException) {
2880:                        {
2881:                            if (true)
2882:                                throw (RuntimeException) jjte000;
2883:                        }
2884:                    }
2885:                    if (jjte000 instanceof  ParseException) {
2886:                        {
2887:                            if (true)
2888:                                throw (ParseException) jjte000;
2889:                        }
2890:                    }
2891:                    {
2892:                        if (true)
2893:                            throw (Error) jjte000;
2894:                    }
2895:                } finally {
2896:                    if (jjtc000) {
2897:                        jjtree.closeNodeScope(jjtn000, true);
2898:                    }
2899:                }
2900:            }
2901:
2902:            final public void SameTerm() throws ParseException {
2903:                /*@bgen(jjtree) SameTerm */
2904:                ASTSameTerm jjtn000 = new ASTSameTerm(JJTSAMETERM);
2905:                boolean jjtc000 = true;
2906:                jjtree.openNodeScope(jjtn000);
2907:                try {
2908:                    jj_consume_token(SAMETERM);
2909:                    jj_consume_token(LPAREN);
2910:                    Expression();
2911:                    jj_consume_token(COMMA);
2912:                    Expression();
2913:                    jj_consume_token(RPAREN);
2914:                } catch (Throwable jjte000) {
2915:                    if (jjtc000) {
2916:                        jjtree.clearNodeScope(jjtn000);
2917:                        jjtc000 = false;
2918:                    } else {
2919:                        jjtree.popNode();
2920:                    }
2921:                    if (jjte000 instanceof  RuntimeException) {
2922:                        {
2923:                            if (true)
2924:                                throw (RuntimeException) jjte000;
2925:                        }
2926:                    }
2927:                    if (jjte000 instanceof  ParseException) {
2928:                        {
2929:                            if (true)
2930:                                throw (ParseException) jjte000;
2931:                        }
2932:                    }
2933:                    {
2934:                        if (true)
2935:                            throw (Error) jjte000;
2936:                    }
2937:                } finally {
2938:                    if (jjtc000) {
2939:                        jjtree.closeNodeScope(jjtn000, true);
2940:                    }
2941:                }
2942:            }
2943:
2944:            final public void IsIRI() throws ParseException {
2945:                /*@bgen(jjtree) IsIRI */
2946:                ASTIsIRI jjtn000 = new ASTIsIRI(JJTISIRI);
2947:                boolean jjtc000 = true;
2948:                jjtree.openNodeScope(jjtn000);
2949:                try {
2950:                    jj_consume_token(IS_IRI);
2951:                    jj_consume_token(LPAREN);
2952:                    Expression();
2953:                    jj_consume_token(RPAREN);
2954:                } catch (Throwable jjte000) {
2955:                    if (jjtc000) {
2956:                        jjtree.clearNodeScope(jjtn000);
2957:                        jjtc000 = false;
2958:                    } else {
2959:                        jjtree.popNode();
2960:                    }
2961:                    if (jjte000 instanceof  RuntimeException) {
2962:                        {
2963:                            if (true)
2964:                                throw (RuntimeException) jjte000;
2965:                        }
2966:                    }
2967:                    if (jjte000 instanceof  ParseException) {
2968:                        {
2969:                            if (true)
2970:                                throw (ParseException) jjte000;
2971:                        }
2972:                    }
2973:                    {
2974:                        if (true)
2975:                            throw (Error) jjte000;
2976:                    }
2977:                } finally {
2978:                    if (jjtc000) {
2979:                        jjtree.closeNodeScope(jjtn000, true);
2980:                    }
2981:                }
2982:            }
2983:
2984:            final public void IsBlank() throws ParseException {
2985:                /*@bgen(jjtree) IsBlank */
2986:                ASTIsBlank jjtn000 = new ASTIsBlank(JJTISBLANK);
2987:                boolean jjtc000 = true;
2988:                jjtree.openNodeScope(jjtn000);
2989:                try {
2990:                    jj_consume_token(IS_BLANK);
2991:                    jj_consume_token(LPAREN);
2992:                    Expression();
2993:                    jj_consume_token(RPAREN);
2994:                } catch (Throwable jjte000) {
2995:                    if (jjtc000) {
2996:                        jjtree.clearNodeScope(jjtn000);
2997:                        jjtc000 = false;
2998:                    } else {
2999:                        jjtree.popNode();
3000:                    }
3001:                    if (jjte000 instanceof  RuntimeException) {
3002:                        {
3003:                            if (true)
3004:                                throw (RuntimeException) jjte000;
3005:                        }
3006:                    }
3007:                    if (jjte000 instanceof  ParseException) {
3008:                        {
3009:                            if (true)
3010:                                throw (ParseException) jjte000;
3011:                        }
3012:                    }
3013:                    {
3014:                        if (true)
3015:                            throw (Error) jjte000;
3016:                    }
3017:                } finally {
3018:                    if (jjtc000) {
3019:                        jjtree.closeNodeScope(jjtn000, true);
3020:                    }
3021:                }
3022:            }
3023:
3024:            final public void IsLiteral() throws ParseException {
3025:                /*@bgen(jjtree) IsLiteral */
3026:                ASTIsLiteral jjtn000 = new ASTIsLiteral(JJTISLITERAL);
3027:                boolean jjtc000 = true;
3028:                jjtree.openNodeScope(jjtn000);
3029:                try {
3030:                    jj_consume_token(IS_LITERAL);
3031:                    jj_consume_token(LPAREN);
3032:                    Expression();
3033:                    jj_consume_token(RPAREN);
3034:                } catch (Throwable jjte000) {
3035:                    if (jjtc000) {
3036:                        jjtree.clearNodeScope(jjtn000);
3037:                        jjtc000 = false;
3038:                    } else {
3039:                        jjtree.popNode();
3040:                    }
3041:                    if (jjte000 instanceof  RuntimeException) {
3042:                        {
3043:                            if (true)
3044:                                throw (RuntimeException) jjte000;
3045:                        }
3046:                    }
3047:                    if (jjte000 instanceof  ParseException) {
3048:                        {
3049:                            if (true)
3050:                                throw (ParseException) jjte000;
3051:                        }
3052:                    }
3053:                    {
3054:                        if (true)
3055:                            throw (Error) jjte000;
3056:                    }
3057:                } finally {
3058:                    if (jjtc000) {
3059:                        jjtree.closeNodeScope(jjtn000, true);
3060:                    }
3061:                }
3062:            }
3063:
3064:            final public void RegexExpression() throws ParseException {
3065:                /*@bgen(jjtree) RegexExpression */
3066:                ASTRegexExpression jjtn000 = new ASTRegexExpression(
3067:                        JJTREGEXEXPRESSION);
3068:                boolean jjtc000 = true;
3069:                jjtree.openNodeScope(jjtn000);
3070:                try {
3071:                    jj_consume_token(REGEX);
3072:                    jj_consume_token(LPAREN);
3073:                    Expression();
3074:                    jj_consume_token(COMMA);
3075:                    Expression();
3076:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3077:                    case COMMA:
3078:                        jj_consume_token(COMMA);
3079:                        Expression();
3080:                        break;
3081:                    default:
3082:                        jj_la1[72] = jj_gen;
3083:                        ;
3084:                    }
3085:                    jj_consume_token(RPAREN);
3086:                } catch (Throwable jjte000) {
3087:                    if (jjtc000) {
3088:                        jjtree.clearNodeScope(jjtn000);
3089:                        jjtc000 = false;
3090:                    } else {
3091:                        jjtree.popNode();
3092:                    }
3093:                    if (jjte000 instanceof  RuntimeException) {
3094:                        {
3095:                            if (true)
3096:                                throw (RuntimeException) jjte000;
3097:                        }
3098:                    }
3099:                    if (jjte000 instanceof  ParseException) {
3100:                        {
3101:                            if (true)
3102:                                throw (ParseException) jjte000;
3103:                        }
3104:                    }
3105:                    {
3106:                        if (true)
3107:                            throw (Error) jjte000;
3108:                    }
3109:                } finally {
3110:                    if (jjtc000) {
3111:                        jjtree.closeNodeScope(jjtn000, true);
3112:                    }
3113:                }
3114:            }
3115:
3116:            final public void RDFLiteral() throws ParseException {
3117:                /*@bgen(jjtree) RDFLiteral */
3118:                ASTRDFLiteral jjtn000 = new ASTRDFLiteral(JJTRDFLITERAL);
3119:                boolean jjtc000 = true;
3120:                jjtree.openNodeScope(jjtn000);
3121:                Token t;
3122:                try {
3123:                    String();
3124:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3125:                    case DT_PREFIX:
3126:                    case LANGTAG:
3127:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3128:                        case LANGTAG:
3129:                            t = jj_consume_token(LANGTAG);
3130:                            jjtn000.setLang(t.image.substring(1));
3131:                            break;
3132:                        case DT_PREFIX:
3133:                            jj_consume_token(DT_PREFIX);
3134:                            IRIref();
3135:                            break;
3136:                        default:
3137:                            jj_la1[73] = jj_gen;
3138:                            jj_consume_token(-1);
3139:                            throw new ParseException();
3140:                        }
3141:                        break;
3142:                    default:
3143:                        jj_la1[74] = jj_gen;
3144:                        ;
3145:                    }
3146:                } catch (Throwable jjte000) {
3147:                    if (jjtc000) {
3148:                        jjtree.clearNodeScope(jjtn000);
3149:                        jjtc000 = false;
3150:                    } else {
3151:                        jjtree.popNode();
3152:                    }
3153:                    if (jjte000 instanceof  RuntimeException) {
3154:                        {
3155:                            if (true)
3156:                                throw (RuntimeException) jjte000;
3157:                        }
3158:                    }
3159:                    if (jjte000 instanceof  ParseException) {
3160:                        {
3161:                            if (true)
3162:                                throw (ParseException) jjte000;
3163:                        }
3164:                    }
3165:                    {
3166:                        if (true)
3167:                            throw (Error) jjte000;
3168:                    }
3169:                } finally {
3170:                    if (jjtc000) {
3171:                        jjtree.closeNodeScope(jjtn000, true);
3172:                    }
3173:                }
3174:            }
3175:
3176:            final public void NumericLiteral() throws ParseException {
3177:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3178:                case INTEGER:
3179:                case DECIMAL:
3180:                case DOUBLE:
3181:                    NumericLiteralUnsigned();
3182:                    break;
3183:                case INTEGER_POSITIVE:
3184:                case DECIMAL_POSITIVE:
3185:                case DOUBLE_POSITIVE:
3186:                    NumericLiteralPositive();
3187:                    break;
3188:                case INTEGER_NEGATIVE:
3189:                case DECIMAL_NEGATIVE:
3190:                case DOUBLE_NEGATIVE:
3191:                    NumericLiteralNegative();
3192:                    break;
3193:                default:
3194:                    jj_la1[75] = jj_gen;
3195:                    jj_consume_token(-1);
3196:                    throw new ParseException();
3197:                }
3198:            }
3199:
3200:            final public void NumericLiteralUnsigned() throws ParseException {
3201:                /*@bgen(jjtree) NumericLiteral */
3202:                ASTNumericLiteral jjtn000 = new ASTNumericLiteral(
3203:                        JJTNUMERICLITERAL);
3204:                boolean jjtc000 = true;
3205:                jjtree.openNodeScope(jjtn000);
3206:                Token t;
3207:                URI datatype;
3208:                try {
3209:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3210:                    case INTEGER:
3211:                        t = jj_consume_token(INTEGER);
3212:                        datatype = XMLSchema.INTEGER;
3213:                        break;
3214:                    case DECIMAL:
3215:                        t = jj_consume_token(DECIMAL);
3216:                        datatype = XMLSchema.DECIMAL;
3217:                        break;
3218:                    case DOUBLE:
3219:                        t = jj_consume_token(DOUBLE);
3220:                        datatype = XMLSchema.DOUBLE;
3221:                        break;
3222:                    default:
3223:                        jj_la1[76] = jj_gen;
3224:                        jj_consume_token(-1);
3225:                        throw new ParseException();
3226:                    }
3227:                    jjtree.closeNodeScope(jjtn000, true);
3228:                    jjtc000 = false;
3229:                    jjtn000.setValue(t.image);
3230:                    jjtn000.setDatatype(datatype);
3231:                } finally {
3232:                    if (jjtc000) {
3233:                        jjtree.closeNodeScope(jjtn000, true);
3234:                    }
3235:                }
3236:            }
3237:
3238:            final public void NumericLiteralPositive() throws ParseException {
3239:                /*@bgen(jjtree) NumericLiteral */
3240:                ASTNumericLiteral jjtn000 = new ASTNumericLiteral(
3241:                        JJTNUMERICLITERAL);
3242:                boolean jjtc000 = true;
3243:                jjtree.openNodeScope(jjtn000);
3244:                Token t;
3245:                URI datatype;
3246:                try {
3247:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3248:                    case INTEGER_POSITIVE:
3249:                        t = jj_consume_token(INTEGER_POSITIVE);
3250:                        datatype = XMLSchema.INTEGER;
3251:                        break;
3252:                    case DECIMAL_POSITIVE:
3253:                        t = jj_consume_token(DECIMAL_POSITIVE);
3254:                        datatype = XMLSchema.DECIMAL;
3255:                        break;
3256:                    case DOUBLE_POSITIVE:
3257:                        t = jj_consume_token(DOUBLE_POSITIVE);
3258:                        datatype = XMLSchema.DOUBLE;
3259:                        break;
3260:                    default:
3261:                        jj_la1[77] = jj_gen;
3262:                        jj_consume_token(-1);
3263:                        throw new ParseException();
3264:                    }
3265:                    jjtree.closeNodeScope(jjtn000, true);
3266:                    jjtc000 = false;
3267:                    jjtn000.setValue(t.image);
3268:                    jjtn000.setDatatype(datatype);
3269:                } finally {
3270:                    if (jjtc000) {
3271:                        jjtree.closeNodeScope(jjtn000, true);
3272:                    }
3273:                }
3274:            }
3275:
3276:            final public void NumericLiteralNegative() throws ParseException {
3277:                /*@bgen(jjtree) NumericLiteral */
3278:                ASTNumericLiteral jjtn000 = new ASTNumericLiteral(
3279:                        JJTNUMERICLITERAL);
3280:                boolean jjtc000 = true;
3281:                jjtree.openNodeScope(jjtn000);
3282:                Token t;
3283:                URI datatype;
3284:                try {
3285:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3286:                    case INTEGER_NEGATIVE:
3287:                        t = jj_consume_token(INTEGER_NEGATIVE);
3288:                        datatype = XMLSchema.INTEGER;
3289:                        break;
3290:                    case DECIMAL_NEGATIVE:
3291:                        t = jj_consume_token(DECIMAL_NEGATIVE);
3292:                        datatype = XMLSchema.DECIMAL;
3293:                        break;
3294:                    case DOUBLE_NEGATIVE:
3295:                        t = jj_consume_token(DOUBLE_NEGATIVE);
3296:                        datatype = XMLSchema.DOUBLE;
3297:                        break;
3298:                    default:
3299:                        jj_la1[78] = jj_gen;
3300:                        jj_consume_token(-1);
3301:                        throw new ParseException();
3302:                    }
3303:                    jjtree.closeNodeScope(jjtn000, true);
3304:                    jjtc000 = false;
3305:                    jjtn000.setValue(t.image);
3306:                    jjtn000.setDatatype(datatype);
3307:                } finally {
3308:                    if (jjtc000) {
3309:                        jjtree.closeNodeScope(jjtn000, true);
3310:                    }
3311:                }
3312:            }
3313:
3314:            final public void BooleanLiteral() throws ParseException {
3315:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3316:                case TRUE:
3317:                    ASTTrue jjtn001 = new ASTTrue(JJTTRUE);
3318:                    boolean jjtc001 = true;
3319:                    jjtree.openNodeScope(jjtn001);
3320:                    try {
3321:                        jj_consume_token(TRUE);
3322:                    } finally {
3323:                        if (jjtc001) {
3324:                            jjtree.closeNodeScope(jjtn001, true);
3325:                        }
3326:                    }
3327:                    break;
3328:                case FALSE:
3329:                    ASTFalse jjtn002 = new ASTFalse(JJTFALSE);
3330:                    boolean jjtc002 = true;
3331:                    jjtree.openNodeScope(jjtn002);
3332:                    try {
3333:                        jj_consume_token(FALSE);
3334:                    } finally {
3335:                        if (jjtc002) {
3336:                            jjtree.closeNodeScope(jjtn002, true);
3337:                        }
3338:                    }
3339:                    break;
3340:                default:
3341:                    jj_la1[79] = jj_gen;
3342:                    jj_consume_token(-1);
3343:                    throw new ParseException();
3344:                }
3345:            }
3346:
3347:            final public void String() throws ParseException {
3348:                /*@bgen(jjtree) String */
3349:                ASTString jjtn000 = new ASTString(JJTSTRING);
3350:                boolean jjtc000 = true;
3351:                jjtree.openNodeScope(jjtn000);
3352:                Token t;
3353:                try {
3354:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3355:                    case STRING_LITERAL1:
3356:                    case STRING_LITERAL2:
3357:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3358:                        case STRING_LITERAL1:
3359:                            t = jj_consume_token(STRING_LITERAL1);
3360:                            break;
3361:                        case STRING_LITERAL2:
3362:                            t = jj_consume_token(STRING_LITERAL2);
3363:                            break;
3364:                        default:
3365:                            jj_la1[80] = jj_gen;
3366:                            jj_consume_token(-1);
3367:                            throw new ParseException();
3368:                        }
3369:                        jjtree.closeNodeScope(jjtn000, true);
3370:                        jjtc000 = false;
3371:                        jjtn000.setValue(_trimString(t.image, 1));
3372:                        break;
3373:                    case STRING_LITERAL_LONG1:
3374:                    case STRING_LITERAL_LONG2:
3375:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3376:                        case STRING_LITERAL_LONG1:
3377:                            t = jj_consume_token(STRING_LITERAL_LONG1);
3378:                            break;
3379:                        case STRING_LITERAL_LONG2:
3380:                            t = jj_consume_token(STRING_LITERAL_LONG2);
3381:                            break;
3382:                        default:
3383:                            jj_la1[81] = jj_gen;
3384:                            jj_consume_token(-1);
3385:                            throw new ParseException();
3386:                        }
3387:                        jjtree.closeNodeScope(jjtn000, true);
3388:                        jjtc000 = false;
3389:                        jjtn000.setValue(_trimString(t.image, 3));
3390:                        break;
3391:                    default:
3392:                        jj_la1[82] = jj_gen;
3393:                        jj_consume_token(-1);
3394:                        throw new ParseException();
3395:                    }
3396:                } finally {
3397:                    if (jjtc000) {
3398:                        jjtree.closeNodeScope(jjtn000, true);
3399:                    }
3400:                }
3401:            }
3402:
3403:            final public void IRIref() throws ParseException {
3404:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3405:                case Q_IRI_REF:
3406:                    IRI();
3407:                    break;
3408:                case PNAME_NS:
3409:                case PNAME_LN:
3410:                    PrefixedName();
3411:                    break;
3412:                default:
3413:                    jj_la1[83] = jj_gen;
3414:                    jj_consume_token(-1);
3415:                    throw new ParseException();
3416:                }
3417:            }
3418:
3419:            final public void PrefixedName() throws ParseException {
3420:                /*@bgen(jjtree) QName */
3421:                ASTQName jjtn000 = new ASTQName(JJTQNAME);
3422:                boolean jjtc000 = true;
3423:                jjtree.openNodeScope(jjtn000);
3424:                Token t;
3425:                try {
3426:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3427:                    case PNAME_LN:
3428:                        t = jj_consume_token(PNAME_LN);
3429:                        break;
3430:                    case PNAME_NS:
3431:                        t = jj_consume_token(PNAME_NS);
3432:                        break;
3433:                    default:
3434:                        jj_la1[84] = jj_gen;
3435:                        jj_consume_token(-1);
3436:                        throw new ParseException();
3437:                    }
3438:                    jjtree.closeNodeScope(jjtn000, true);
3439:                    jjtc000 = false;
3440:                    jjtn000.setValue(t.image);
3441:                } finally {
3442:                    if (jjtc000) {
3443:                        jjtree.closeNodeScope(jjtn000, true);
3444:                    }
3445:                }
3446:            }
3447:
3448:            final public void BlankNode() throws ParseException {
3449:                /*@bgen(jjtree) BlankNode */
3450:                ASTBlankNode jjtn000 = new ASTBlankNode(JJTBLANKNODE);
3451:                boolean jjtc000 = true;
3452:                jjtree.openNodeScope(jjtn000);
3453:                Token t;
3454:                try {
3455:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3456:                    case BLANK_NODE_LABEL:
3457:                        t = jj_consume_token(BLANK_NODE_LABEL);
3458:                        jjtree.closeNodeScope(jjtn000, true);
3459:                        jjtc000 = false;
3460:                        jjtn000.setID(t.image.substring(2));
3461:                        break;
3462:                    case ANON:
3463:                        jj_consume_token(ANON);
3464:                        break;
3465:                    default:
3466:                        jj_la1[85] = jj_gen;
3467:                        jj_consume_token(-1);
3468:                        throw new ParseException();
3469:                    }
3470:                } finally {
3471:                    if (jjtc000) {
3472:                        jjtree.closeNodeScope(jjtn000, true);
3473:                    }
3474:                }
3475:            }
3476:
3477:            final public void IRI() throws ParseException {
3478:                /*@bgen(jjtree) IRI */
3479:                ASTIRI jjtn000 = new ASTIRI(JJTIRI);
3480:                boolean jjtc000 = true;
3481:                jjtree.openNodeScope(jjtn000);
3482:                Token t;
3483:                try {
3484:                    t = jj_consume_token(Q_IRI_REF);
3485:                    jjtree.closeNodeScope(jjtn000, true);
3486:                    jjtc000 = false;
3487:                    jjtn000.setValue(_trimString(t.image, 1));
3488:                } finally {
3489:                    if (jjtc000) {
3490:                        jjtree.closeNodeScope(jjtn000, true);
3491:                    }
3492:                }
3493:            }
3494:
3495:            final private boolean jj_2_1(int xla) {
3496:                jj_la = xla;
3497:                jj_lastpos = jj_scanpos = token;
3498:                try {
3499:                    return !jj_3_1();
3500:                } catch (LookaheadSuccess ls) {
3501:                    return true;
3502:                } finally {
3503:                    jj_save(0, xla);
3504:                }
3505:            }
3506:
3507:            final private boolean jj_2_2(int xla) {
3508:                jj_la = xla;
3509:                jj_lastpos = jj_scanpos = token;
3510:                try {
3511:                    return !jj_3_2();
3512:                } catch (LookaheadSuccess ls) {
3513:                    return true;
3514:                } finally {
3515:                    jj_save(1, xla);
3516:                }
3517:            }
3518:
3519:            final private boolean jj_3R_41() {
3520:                if (jj_3R_46())
3521:                    return true;
3522:                return false;
3523:            }
3524:
3525:            final private boolean jj_3R_44() {
3526:                if (jj_3R_48())
3527:                    return true;
3528:                return false;
3529:            }
3530:
3531:            final private boolean jj_3R_40() {
3532:                if (jj_3R_45())
3533:                    return true;
3534:                return false;
3535:            }
3536:
3537:            final private boolean jj_3R_27() {
3538:                if (jj_scan_token(LPAREN))
3539:                    return true;
3540:                return false;
3541:            }
3542:
3543:            final private boolean jj_3R_39() {
3544:                if (jj_3R_44())
3545:                    return true;
3546:                return false;
3547:            }
3548:
3549:            final private boolean jj_3R_33() {
3550:                Token xsp;
3551:                xsp = jj_scanpos;
3552:                if (jj_scan_token(65)) {
3553:                    jj_scanpos = xsp;
3554:                    if (jj_scan_token(64))
3555:                        return true;
3556:                }
3557:                return false;
3558:            }
3559:
3560:            final private boolean jj_3R_22() {
3561:                Token xsp;
3562:                xsp = jj_scanpos;
3563:                if (jj_scan_token(27)) {
3564:                    jj_scanpos = xsp;
3565:                    if (jj_3R_27())
3566:                        return true;
3567:                }
3568:                return false;
3569:            }
3570:
3571:            final private boolean jj_3R_35() {
3572:                Token xsp;
3573:                xsp = jj_scanpos;
3574:                if (jj_3R_38()) {
3575:                    jj_scanpos = xsp;
3576:                    if (jj_3R_39()) {
3577:                        jj_scanpos = xsp;
3578:                        if (jj_3R_40()) {
3579:                            jj_scanpos = xsp;
3580:                            if (jj_3R_41()) {
3581:                                jj_scanpos = xsp;
3582:                                if (jj_3R_42()) {
3583:                                    jj_scanpos = xsp;
3584:                                    if (jj_3R_43())
3585:                                        return true;
3586:                                }
3587:                            }
3588:                        }
3589:                    }
3590:                }
3591:                return false;
3592:            }
3593:
3594:            final private boolean jj_3R_38() {
3595:                if (jj_3R_21())
3596:                    return true;
3597:                return false;
3598:            }
3599:
3600:            final private boolean jj_3R_26() {
3601:                if (jj_3R_33())
3602:                    return true;
3603:                return false;
3604:            }
3605:
3606:            final private boolean jj_3R_18() {
3607:                if (jj_3R_21())
3608:                    return true;
3609:                if (jj_3R_22())
3610:                    return true;
3611:                return false;
3612:            }
3613:
3614:            final private boolean jj_3R_25() {
3615:                if (jj_3R_32())
3616:                    return true;
3617:                return false;
3618:            }
3619:
3620:            final private boolean jj_3R_21() {
3621:                Token xsp;
3622:                xsp = jj_scanpos;
3623:                if (jj_3R_25()) {
3624:                    jj_scanpos = xsp;
3625:                    if (jj_3R_26())
3626:                        return true;
3627:                }
3628:                return false;
3629:            }
3630:
3631:            final private boolean jj_3R_34() {
3632:                Token xsp;
3633:                xsp = jj_scanpos;
3634:                if (jj_scan_token(67)) {
3635:                    jj_scanpos = xsp;
3636:                    if (jj_scan_token(68))
3637:                        return true;
3638:                }
3639:                return false;
3640:            }
3641:
3642:            final private boolean jj_3R_56() {
3643:                Token xsp;
3644:                xsp = jj_scanpos;
3645:                if (jj_scan_token(87)) {
3646:                    jj_scanpos = xsp;
3647:                    if (jj_scan_token(88))
3648:                        return true;
3649:                }
3650:                return false;
3651:            }
3652:
3653:            final private boolean jj_3R_55() {
3654:                Token xsp;
3655:                xsp = jj_scanpos;
3656:                if (jj_scan_token(85)) {
3657:                    jj_scanpos = xsp;
3658:                    if (jj_scan_token(86))
3659:                        return true;
3660:                }
3661:                return false;
3662:            }
3663:
3664:            final private boolean jj_3R_48() {
3665:                Token xsp;
3666:                xsp = jj_scanpos;
3667:                if (jj_3R_55()) {
3668:                    jj_scanpos = xsp;
3669:                    if (jj_3R_56())
3670:                        return true;
3671:                }
3672:                return false;
3673:            }
3674:
3675:            final private boolean jj_3R_53() {
3676:                if (jj_scan_token(FALSE))
3677:                    return true;
3678:                return false;
3679:            }
3680:
3681:            final private boolean jj_3R_52() {
3682:                if (jj_scan_token(TRUE))
3683:                    return true;
3684:                return false;
3685:            }
3686:
3687:            final private boolean jj_3R_29() {
3688:                if (jj_3R_35())
3689:                    return true;
3690:                return false;
3691:            }
3692:
3693:            final private boolean jj_3R_46() {
3694:                Token xsp;
3695:                xsp = jj_scanpos;
3696:                if (jj_3R_52()) {
3697:                    jj_scanpos = xsp;
3698:                    if (jj_3R_53())
3699:                        return true;
3700:                }
3701:                return false;
3702:            }
3703:
3704:            final private boolean jj_3R_28() {
3705:                if (jj_3R_34())
3706:                    return true;
3707:                return false;
3708:            }
3709:
3710:            final private boolean jj_3R_23() {
3711:                Token xsp;
3712:                xsp = jj_scanpos;
3713:                if (jj_3R_28()) {
3714:                    jj_scanpos = xsp;
3715:                    if (jj_3R_29())
3716:                        return true;
3717:                }
3718:                return false;
3719:            }
3720:
3721:            final private boolean jj_3R_68() {
3722:                if (jj_scan_token(DOUBLE_NEGATIVE))
3723:                    return true;
3724:                return false;
3725:            }
3726:
3727:            final private boolean jj_3R_67() {
3728:                if (jj_scan_token(DECIMAL_NEGATIVE))
3729:                    return true;
3730:                return false;
3731:            }
3732:
3733:            final private boolean jj_3R_66() {
3734:                if (jj_scan_token(INTEGER_NEGATIVE))
3735:                    return true;
3736:                return false;
3737:            }
3738:
3739:            final private boolean jj_3_1() {
3740:                if (jj_scan_token(DOT))
3741:                    return true;
3742:                if (jj_3R_17())
3743:                    return true;
3744:                return false;
3745:            }
3746:
3747:            final private boolean jj_3R_59() {
3748:                Token xsp;
3749:                xsp = jj_scanpos;
3750:                if (jj_3R_66()) {
3751:                    jj_scanpos = xsp;
3752:                    if (jj_3R_67()) {
3753:                        jj_scanpos = xsp;
3754:                        if (jj_3R_68())
3755:                            return true;
3756:                    }
3757:                }
3758:                return false;
3759:            }
3760:
3761:            final private boolean jj_3R_36() {
3762:                if (jj_scan_token(LPAREN))
3763:                    return true;
3764:                return false;
3765:            }
3766:
3767:            final private boolean jj_3R_65() {
3768:                if (jj_scan_token(DOUBLE_POSITIVE))
3769:                    return true;
3770:                return false;
3771:            }
3772:
3773:            final private boolean jj_3R_64() {
3774:                if (jj_scan_token(DECIMAL_POSITIVE))
3775:                    return true;
3776:                return false;
3777:            }
3778:
3779:            final private boolean jj_3R_63() {
3780:                if (jj_scan_token(INTEGER_POSITIVE))
3781:                    return true;
3782:                return false;
3783:            }
3784:
3785:            final private boolean jj_3R_37() {
3786:                if (jj_scan_token(LBRACK))
3787:                    return true;
3788:                return false;
3789:            }
3790:
3791:            final private boolean jj_3R_31() {
3792:                if (jj_3R_37())
3793:                    return true;
3794:                return false;
3795:            }
3796:
3797:            final private boolean jj_3R_58() {
3798:                Token xsp;
3799:                xsp = jj_scanpos;
3800:                if (jj_3R_63()) {
3801:                    jj_scanpos = xsp;
3802:                    if (jj_3R_64()) {
3803:                        jj_scanpos = xsp;
3804:                        if (jj_3R_65())
3805:                            return true;
3806:                    }
3807:                }
3808:                return false;
3809:            }
3810:
3811:            final private boolean jj_3R_30() {
3812:                if (jj_3R_36())
3813:                    return true;
3814:                return false;
3815:            }
3816:
3817:            final private boolean jj_3R_24() {
3818:                Token xsp;
3819:                xsp = jj_scanpos;
3820:                if (jj_3R_30()) {
3821:                    jj_scanpos = xsp;
3822:                    if (jj_3R_31())
3823:                        return true;
3824:                }
3825:                return false;
3826:            }
3827:
3828:            final private boolean jj_3R_62() {
3829:                if (jj_scan_token(DOUBLE))
3830:                    return true;
3831:                return false;
3832:            }
3833:
3834:            final private boolean jj_3R_61() {
3835:                if (jj_scan_token(DECIMAL))
3836:                    return true;
3837:                return false;
3838:            }
3839:
3840:            final private boolean jj_3R_60() {
3841:                if (jj_scan_token(INTEGER))
3842:                    return true;
3843:                return false;
3844:            }
3845:
3846:            final private boolean jj_3R_51() {
3847:                if (jj_3R_59())
3848:                    return true;
3849:                return false;
3850:            }
3851:
3852:            final private boolean jj_3R_57() {
3853:                Token xsp;
3854:                xsp = jj_scanpos;
3855:                if (jj_3R_60()) {
3856:                    jj_scanpos = xsp;
3857:                    if (jj_3R_61()) {
3858:                        jj_scanpos = xsp;
3859:                        if (jj_3R_62())
3860:                            return true;
3861:                    }
3862:                }
3863:                return false;
3864:            }
3865:
3866:            final private boolean jj_3R_50() {
3867:                if (jj_3R_58())
3868:                    return true;
3869:                return false;
3870:            }
3871:
3872:            final private boolean jj_3R_49() {
3873:                if (jj_3R_57())
3874:                    return true;
3875:                return false;
3876:            }
3877:
3878:            final private boolean jj_3R_45() {
3879:                Token xsp;
3880:                xsp = jj_scanpos;
3881:                if (jj_3R_49()) {
3882:                    jj_scanpos = xsp;
3883:                    if (jj_3R_50()) {
3884:                        jj_scanpos = xsp;
3885:                        if (jj_3R_51())
3886:                            return true;
3887:                    }
3888:                }
3889:                return false;
3890:            }
3891:
3892:            final private boolean jj_3R_32() {
3893:                if (jj_scan_token(Q_IRI_REF))
3894:                    return true;
3895:                return false;
3896:            }
3897:
3898:            final private boolean jj_3R_20() {
3899:                if (jj_3R_24())
3900:                    return true;
3901:                return false;
3902:            }
3903:
3904:            final private boolean jj_3R_43() {
3905:                if (jj_scan_token(NIL))
3906:                    return true;
3907:                return false;
3908:            }
3909:
3910:            final private boolean jj_3R_54() {
3911:                if (jj_scan_token(BLANK_NODE_LABEL))
3912:                    return true;
3913:                return false;
3914:            }
3915:
3916:            final private boolean jj_3_2() {
3917:                if (jj_3R_18())
3918:                    return true;
3919:                return false;
3920:            }
3921:
3922:            final private boolean jj_3R_47() {
3923:                Token xsp;
3924:                xsp = jj_scanpos;
3925:                if (jj_3R_54()) {
3926:                    jj_scanpos = xsp;
3927:                    if (jj_scan_token(28))
3928:                        return true;
3929:                }
3930:                return false;
3931:            }
3932:
3933:            final private boolean jj_3R_17() {
3934:                Token xsp;
3935:                xsp = jj_scanpos;
3936:                if (jj_3R_19()) {
3937:                    jj_scanpos = xsp;
3938:                    if (jj_3R_20())
3939:                        return true;
3940:                }
3941:                return false;
3942:            }
3943:
3944:            final private boolean jj_3R_19() {
3945:                if (jj_3R_23())
3946:                    return true;
3947:                return false;
3948:            }
3949:
3950:            final private boolean jj_3R_42() {
3951:                if (jj_3R_47())
3952:                    return true;
3953:                return false;
3954:            }
3955:
3956:            public SyntaxTreeBuilderTokenManager token_source;
3957:            JavaCharStream jj_input_stream;
3958:            public Token token, jj_nt;
3959:            private int jj_ntk;
3960:            private Token jj_scanpos, jj_lastpos;
3961:            private int jj_la;
3962:            public boolean lookingAhead = false;
3963:            private boolean jj_semLA;
3964:            private int jj_gen;
3965:            final private int[] jj_la1 = new int[86];
3966:            static private int[] jj_la1_0;
3967:            static private int[] jj_la1_1;
3968:            static private int[] jj_la1_2;
3969:            static private int[] jj_la1_3;
3970:            static {
3971:                jj_la1_0();
3972:                jj_la1_1();
3973:                jj_la1_2();
3974:                jj_la1_3();
3975:            }
3976:
3977:            private static void jj_la1_0() {
3978:                jj_la1_0 = new int[] { 0x40000000, 0x80000000, 0x0, 0x0, 0x0,
3979:                        0x0, 0x0, 0x0, 0x0, 0x1000000, 0x0, 0x0, 0x0,
3980:                        0x18000110, 0x0, 0x40, 0x0, 0x0, 0x0, 0x1000000, 0x0,
3981:                        0x0, 0x0, 0x10, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0,
3982:                        0x18000110, 0x1000, 0x40, 0x0, 0x1000, 0x18000110,
3983:                        0x1000, 0x18000110, 0x0, 0x18000110, 0x1000, 0x40, 0x0,
3984:                        0x10, 0x800, 0x8000010, 0x20000000, 0x18000110,
3985:                        0x20000000, 0x400, 0x800, 0x20000000, 0x110,
3986:                        0x18000110, 0x18000110, 0x18000000, 0x0, 0x0,
3987:                        0x18000000, 0x100000, 0x200000, 0x7e000, 0x7e000,
3988:                        0xc00000, 0xc00000, 0x3000000, 0x3000000, 0x400000,
3989:                        0xc80010, 0x10, 0x0, 0x0, 0x800, 0x4000000, 0x4000000,
3990:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3991:                        0x10000000, };
3992:            }
3993:
3994:            private static void jj_la1_1() {
3995:                jj_la1_1 = new int[] { 0x0, 0x0, 0xf, 0x40, 0x200, 0x6000,
3996:                        0x30, 0x30, 0x0, 0x0, 0x40, 0x200, 0x6000, 0xe0000000,
3997:                        0x40, 0x100, 0x200, 0x6000, 0x80000000, 0x80000000,
3998:                        0x40, 0x80, 0x100, 0x9ff81800, 0x1800, 0x1800,
3999:                        0x9ff81800, 0x4000, 0x2000, 0x6000, 0xe0040000, 0x0,
4000:                        0x18000, 0x40000, 0x0, 0xe0000000, 0x0, 0xe0000000,
4001:                        0x40000, 0xe0040000, 0x0, 0x18000, 0x20000, 0x9ff80000,
4002:                        0x0, 0x0, 0x80000000, 0xe0000000, 0x80000000, 0x0, 0x0,
4003:                        0x80000000, 0x0, 0xe0000000, 0xe0000000, 0xe0000000,
4004:                        0x80000000, 0x0, 0xe0000000, 0x0, 0x0, 0x0, 0x0, 0x0,
4005:                        0x0, 0x0, 0x0, 0x0, 0xfff80000, 0x1ff80000, 0xe0000000,
4006:                        0x1ff80000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4007:                        0x60000000, 0x0, 0x0, 0x0, 0x80000000, 0x0, 0x0, };
4008:            }
4009:
4010:            private static void jj_la1_2() {
4011:                jj_la1_2 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4012:                        0x18, 0x18, 0x0, 0x0, 0x0, 0x1f873df, 0x0, 0x0, 0x0,
4013:                        0x0, 0x1b, 0x1b, 0x0, 0x0, 0x0, 0x1b, 0x0, 0x0, 0x1b,
4014:                        0x0, 0x0, 0x0, 0x1f873df, 0x0, 0x0, 0x0, 0x0,
4015:                        0x1f873df, 0x0, 0x1f873df, 0x0, 0x1f873df, 0x0, 0x0,
4016:                        0x0, 0x3, 0x0, 0x0, 0x1b, 0x1f873df, 0x1b, 0x0, 0x0,
4017:                        0x1b, 0x0, 0x1f873df, 0x1f873df, 0x1f873df, 0x1b, 0x18,
4018:                        0x1f873c7, 0x0, 0x0, 0x0, 0x0, 0x183180, 0x183180, 0x0,
4019:                        0x0, 0x0, 0x1f873db, 0x0, 0x1f873db, 0x0, 0x0, 0x20,
4020:                        0x20, 0x1873c0, 0x4240, 0x81080, 0x102100, 0x0,
4021:                        0x600000, 0x1800000, 0x1e00000, 0x3, 0x3, 0x4, };
4022:            }
4023:
4024:            private static void jj_la1_3() {
4025:                jj_la1_3 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4026:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4027:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4028:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4029:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4030:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4031:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4032:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4033:                        0x0, };
4034:            }
4035:
4036:            final private JJCalls[] jj_2_rtns = new JJCalls[2];
4037:            private boolean jj_rescan = false;
4038:            private int jj_gc = 0;
4039:
4040:            public SyntaxTreeBuilder(java.io.InputStream stream) {
4041:                this (stream, null);
4042:            }
4043:
4044:            public SyntaxTreeBuilder(java.io.InputStream stream, String encoding) {
4045:                try {
4046:                    jj_input_stream = new JavaCharStream(stream, encoding, 1, 1);
4047:                } catch (java.io.UnsupportedEncodingException e) {
4048:                    throw new RuntimeException(e);
4049:                }
4050:                token_source = new SyntaxTreeBuilderTokenManager(
4051:                        jj_input_stream);
4052:                token = new Token();
4053:                jj_ntk = -1;
4054:                jj_gen = 0;
4055:                for (int i = 0; i < 86; i++)
4056:                    jj_la1[i] = -1;
4057:                for (int i = 0; i < jj_2_rtns.length; i++)
4058:                    jj_2_rtns[i] = new JJCalls();
4059:            }
4060:
4061:            public void ReInit(java.io.InputStream stream) {
4062:                ReInit(stream, null);
4063:            }
4064:
4065:            public void ReInit(java.io.InputStream stream, String encoding) {
4066:                try {
4067:                    jj_input_stream.ReInit(stream, encoding, 1, 1);
4068:                } catch (java.io.UnsupportedEncodingException e) {
4069:                    throw new RuntimeException(e);
4070:                }
4071:                token_source.ReInit(jj_input_stream);
4072:                token = new Token();
4073:                jj_ntk = -1;
4074:                jjtree.reset();
4075:                jj_gen = 0;
4076:                for (int i = 0; i < 86; i++)
4077:                    jj_la1[i] = -1;
4078:                for (int i = 0; i < jj_2_rtns.length; i++)
4079:                    jj_2_rtns[i] = new JJCalls();
4080:            }
4081:
4082:            public SyntaxTreeBuilder(java.io.Reader stream) {
4083:                jj_input_stream = new JavaCharStream(stream, 1, 1);
4084:                token_source = new SyntaxTreeBuilderTokenManager(
4085:                        jj_input_stream);
4086:                token = new Token();
4087:                jj_ntk = -1;
4088:                jj_gen = 0;
4089:                for (int i = 0; i < 86; i++)
4090:                    jj_la1[i] = -1;
4091:                for (int i = 0; i < jj_2_rtns.length; i++)
4092:                    jj_2_rtns[i] = new JJCalls();
4093:            }
4094:
4095:            public void ReInit(java.io.Reader stream) {
4096:                jj_input_stream.ReInit(stream, 1, 1);
4097:                token_source.ReInit(jj_input_stream);
4098:                token = new Token();
4099:                jj_ntk = -1;
4100:                jjtree.reset();
4101:                jj_gen = 0;
4102:                for (int i = 0; i < 86; i++)
4103:                    jj_la1[i] = -1;
4104:                for (int i = 0; i < jj_2_rtns.length; i++)
4105:                    jj_2_rtns[i] = new JJCalls();
4106:            }
4107:
4108:            public SyntaxTreeBuilder(SyntaxTreeBuilderTokenManager tm) {
4109:                token_source = tm;
4110:                token = new Token();
4111:                jj_ntk = -1;
4112:                jj_gen = 0;
4113:                for (int i = 0; i < 86; i++)
4114:                    jj_la1[i] = -1;
4115:                for (int i = 0; i < jj_2_rtns.length; i++)
4116:                    jj_2_rtns[i] = new JJCalls();
4117:            }
4118:
4119:            public void ReInit(SyntaxTreeBuilderTokenManager tm) {
4120:                token_source = tm;
4121:                token = new Token();
4122:                jj_ntk = -1;
4123:                jjtree.reset();
4124:                jj_gen = 0;
4125:                for (int i = 0; i < 86; i++)
4126:                    jj_la1[i] = -1;
4127:                for (int i = 0; i < jj_2_rtns.length; i++)
4128:                    jj_2_rtns[i] = new JJCalls();
4129:            }
4130:
4131:            final private Token jj_consume_token(int kind)
4132:                    throws ParseException {
4133:                Token oldToken;
4134:                if ((oldToken = token).next != null)
4135:                    token = token.next;
4136:                else
4137:                    token = token.next = token_source.getNextToken();
4138:                jj_ntk = -1;
4139:                if (token.kind == kind) {
4140:                    jj_gen++;
4141:                    if (++jj_gc > 100) {
4142:                        jj_gc = 0;
4143:                        for (int i = 0; i < jj_2_rtns.length; i++) {
4144:                            JJCalls c = jj_2_rtns[i];
4145:                            while (c != null) {
4146:                                if (c.gen < jj_gen)
4147:                                    c.first = null;
4148:                                c = c.next;
4149:                            }
4150:                        }
4151:                    }
4152:                    return token;
4153:                }
4154:                token = oldToken;
4155:                jj_kind = kind;
4156:                throw generateParseException();
4157:            }
4158:
4159:            static private final class LookaheadSuccess extends java.lang.Error {
4160:            }
4161:
4162:            final private LookaheadSuccess jj_ls = new LookaheadSuccess();
4163:
4164:            final private boolean jj_scan_token(int kind) {
4165:                if (jj_scanpos == jj_lastpos) {
4166:                    jj_la--;
4167:                    if (jj_scanpos.next == null) {
4168:                        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
4169:                                .getNextToken();
4170:                    } else {
4171:                        jj_lastpos = jj_scanpos = jj_scanpos.next;
4172:                    }
4173:                } else {
4174:                    jj_scanpos = jj_scanpos.next;
4175:                }
4176:                if (jj_rescan) {
4177:                    int i = 0;
4178:                    Token tok = token;
4179:                    while (tok != null && tok != jj_scanpos) {
4180:                        i++;
4181:                        tok = tok.next;
4182:                    }
4183:                    if (tok != null)
4184:                        jj_add_error_token(kind, i);
4185:                }
4186:                if (jj_scanpos.kind != kind)
4187:                    return true;
4188:                if (jj_la == 0 && jj_scanpos == jj_lastpos)
4189:                    throw jj_ls;
4190:                return false;
4191:            }
4192:
4193:            final public Token getNextToken() {
4194:                if (token.next != null)
4195:                    token = token.next;
4196:                else
4197:                    token = token.next = token_source.getNextToken();
4198:                jj_ntk = -1;
4199:                jj_gen++;
4200:                return token;
4201:            }
4202:
4203:            final public Token getToken(int index) {
4204:                Token t = lookingAhead ? jj_scanpos : token;
4205:                for (int i = 0; i < index; i++) {
4206:                    if (t.next != null)
4207:                        t = t.next;
4208:                    else
4209:                        t = t.next = token_source.getNextToken();
4210:                }
4211:                return t;
4212:            }
4213:
4214:            final private int jj_ntk() {
4215:                if ((jj_nt = token.next) == null)
4216:                    return (jj_ntk = (token.next = token_source.getNextToken()).kind);
4217:                else
4218:                    return (jj_ntk = jj_nt.kind);
4219:            }
4220:
4221:            private java.util.Vector jj_expentries = new java.util.Vector();
4222:            private int[] jj_expentry;
4223:            private int jj_kind = -1;
4224:            private int[] jj_lasttokens = new int[100];
4225:            private int jj_endpos;
4226:
4227:            private void jj_add_error_token(int kind, int pos) {
4228:                if (pos >= 100)
4229:                    return;
4230:                if (pos == jj_endpos + 1) {
4231:                    jj_lasttokens[jj_endpos++] = kind;
4232:                } else if (jj_endpos != 0) {
4233:                    jj_expentry = new int[jj_endpos];
4234:                    for (int i = 0; i < jj_endpos; i++) {
4235:                        jj_expentry[i] = jj_lasttokens[i];
4236:                    }
4237:                    boolean exists = false;
4238:                    for (java.util.Enumeration e = jj_expentries.elements(); e
4239:                            .hasMoreElements();) {
4240:                        int[] oldentry = (int[]) (e.nextElement());
4241:                        if (oldentry.length == jj_expentry.length) {
4242:                            exists = true;
4243:                            for (int i = 0; i < jj_expentry.length; i++) {
4244:                                if (oldentry[i] != jj_expentry[i]) {
4245:                                    exists = false;
4246:                                    break;
4247:                                }
4248:                            }
4249:                            if (exists)
4250:                                break;
4251:                        }
4252:                    }
4253:                    if (!exists)
4254:                        jj_expentries.addElement(jj_expentry);
4255:                    if (pos != 0)
4256:                        jj_lasttokens[(jj_endpos = pos) - 1] = kind;
4257:                }
4258:            }
4259:
4260:            public ParseException generateParseException() {
4261:                jj_expentries.removeAllElements();
4262:                boolean[] la1tokens = new boolean[106];
4263:                if (jj_kind >= 0) {
4264:                    la1tokens[jj_kind] = true;
4265:                    jj_kind = -1;
4266:                }
4267:                for (int i = 0; i < 86; i++) {
4268:                    if (jj_la1[i] == jj_gen) {
4269:                        for (int j = 0; j < 32; j++) {
4270:                            if ((jj_la1_0[i] & (1 << j)) != 0) {
4271:                                la1tokens[j] = true;
4272:                            }
4273:                            if ((jj_la1_1[i] & (1 << j)) != 0) {
4274:                                la1tokens[32 + j] = true;
4275:                            }
4276:                            if ((jj_la1_2[i] & (1 << j)) != 0) {
4277:                                la1tokens[64 + j] = true;
4278:                            }
4279:                            if ((jj_la1_3[i] & (1 << j)) != 0) {
4280:                                la1tokens[96 + j] = true;
4281:                            }
4282:                        }
4283:                    }
4284:                }
4285:                for (int i = 0; i < 106; i++) {
4286:                    if (la1tokens[i]) {
4287:                        jj_expentry = new int[1];
4288:                        jj_expentry[0] = i;
4289:                        jj_expentries.addElement(jj_expentry);
4290:                    }
4291:                }
4292:                jj_endpos = 0;
4293:                jj_rescan_token();
4294:                jj_add_error_token(0, 0);
4295:                int[][] exptokseq = new int[jj_expentries.size()][];
4296:                for (int i = 0; i < jj_expentries.size(); i++) {
4297:                    exptokseq[i] = (int[]) jj_expentries.elementAt(i);
4298:                }
4299:                return new ParseException(token, exptokseq, tokenImage);
4300:            }
4301:
4302:            final public void enable_tracing() {
4303:            }
4304:
4305:            final public void disable_tracing() {
4306:            }
4307:
4308:            final private void jj_rescan_token() {
4309:                jj_rescan = true;
4310:                for (int i = 0; i < 2; i++) {
4311:                    try {
4312:                        JJCalls p = jj_2_rtns[i];
4313:                        do {
4314:                            if (p.gen > jj_gen) {
4315:                                jj_la = p.arg;
4316:                                jj_lastpos = jj_scanpos = p.first;
4317:                                switch (i) {
4318:                                case 0:
4319:                                    jj_3_1();
4320:                                    break;
4321:                                case 1:
4322:                                    jj_3_2();
4323:                                    break;
4324:                                }
4325:                            }
4326:                            p = p.next;
4327:                        } while (p != null);
4328:                    } catch (LookaheadSuccess ls) {
4329:                    }
4330:                }
4331:                jj_rescan = false;
4332:            }
4333:
4334:            final private void jj_save(int index, int xla) {
4335:                JJCalls p = jj_2_rtns[index];
4336:                while (p.gen > jj_gen) {
4337:                    if (p.next == null) {
4338:                        p = p.next = new JJCalls();
4339:                        break;
4340:                    }
4341:                    p = p.next;
4342:                }
4343:                p.gen = jj_gen + xla - jj_la;
4344:                p.first = token;
4345:                p.arg = xla;
4346:            }
4347:
4348:            static final class JJCalls {
4349:                int gen;
4350:                Token first;
4351:                int arg;
4352:                JJCalls next;
4353:            }
4354:
4355:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.