Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
rapture.generated.DParseParser Maven / Gradle / Ivy
package rapture.generated;
import rapture.dsl.dparse.*;
import rapture.common.model.DocumentAttribute;
import rapture.common.DocumentAttributeFactory;
import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import org.antlr.runtime.tree.*;
@SuppressWarnings ("all" )
public class DParseParser extends Parser public static final String[] tokenNames = new String[] {
" " , " " , " " , " " , "AGO" , "AND" , "COLON" , "COMMA" ,
"DASH" , "DAY" , "DIGIT" , "DOLLAR" , "DOT" , "HASH" , "HOUR" , "LETTER" , "MINUTE" ,
"MONTH" , "PLUS" , "QUERY" , "SECOND" , "SINGLE_QUOTE" , "SLASH" , "SPACE" ,
"STRING" , "TODAY" , "TOMORROW" , "TONIGHT" , "UNDER" , "WEEK" , "YEAR" , "YESTERDAY"
};
public static final int EOF=-1 ;
public static final int AGO=4 ;
public static final int AND=5 ;
public static final int COLON=6 ;
public static final int COMMA=7 ;
public static final int DASH=8 ;
public static final int DAY=9 ;
public static final int DIGIT=10 ;
public static final int DOLLAR=11 ;
public static final int DOT=12 ;
public static final int HASH=13 ;
public static final int HOUR=14 ;
public static final int LETTER=15 ;
public static final int MINUTE=16 ;
public static final int MONTH=17 ;
public static final int PLUS=18 ;
public static final int QUERY=19 ;
public static final int SECOND=20 ;
public static final int SINGLE_QUOTE=21 ;
public static final int SLASH=22 ;
public static final int SPACE=23 ;
public static final int STRING=24 ;
public static final int TODAY=25 ;
public static final int TOMORROW=26 ;
public static final int TONIGHT=27 ;
public static final int UNDER=28 ;
public static final int WEEK=29 ;
public static final int YEAR=30 ;
public static final int YESTERDAY=31 ;
public Parser[] getDelegates() {
return new Parser[] {};
}
public DParseParser (TokenStream input) this (input, new RecognizerSharedState());
}
public DParseParser (TokenStream input, RecognizerSharedState state) super (input, state);
}
protected TreeAdaptor adaptor = new CommonTreeAdaptor();
public void setTreeAdaptor (TreeAdaptor adaptor) this .adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor () return adaptor;
}
@Override public String[] getTokenNames() { return DParseParser.tokenNames; }
@Override public String getGrammarFileName () return "/Users/amkimian/Development/cloud/Rapture/Libs/RaptureCore/src/main/antlr3/rapture/dsl/dparse/DParseParser.g" ; }
public String getErrorMessage (RecognitionException e,
String[] tokenNames)
this .getClass().getName());
String msg = null ;
if ( e instanceof NoViableAltException ) {
NoViableAltException nvae = (NoViableAltException)e;
msg = " no viable alt; token=" +e.token+
" (decision=" +nvae.decisionNumber+
" state " +nvae.stateNumber+")" +
" decision=<<" +nvae.grammarDecisionDescription+">>" ;
}
else {
msg = super .getErrorMessage(e, tokenNames);
}
return stack+" " +msg;
}
public String getTokenErrorDisplay (Token t) return t.toString();
}
public static class displayname_return extends ParserRuleReturnScope public String type;
public String disp;
public BaseDirective directive;
public DocumentAttribute attribute;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.displayname_return displayname () throws RecognitionException {
DParseParser.displayname_return retval = new DParseParser.displayname_return();
retval.start = input.LT(1 );
Object root_0 = null ;
ParserRuleReturnScope typePart1 =null ;
ParserRuleReturnScope namePart2 =null ;
ParserRuleReturnScope queryDirective3 =null ;
ParserRuleReturnScope attributePart4 =null ;
try {
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_typePart_in_displayname79);
typePart1=typePart();
state._fsp--;
adaptor.addChild(root_0, typePart1.getTree());
int alt1=2 ;
int LA1_0 = input.LA(1 );
if ( (LA1_0==SLASH) ) {
int LA1_1 = input.LA(2 );
if ( (LA1_1==DIGIT||LA1_1==DOT||LA1_1==LETTER||LA1_1==UNDER) ) {
alt1=1 ;
}
}
switch (alt1) {
case 1 :
{
pushFollow(FOLLOW_namePart_in_displayname81);
namePart2=namePart();
state._fsp--;
adaptor.addChild(root_0, namePart2.getTree());
}
break ;
}
int alt2=2 ;
int LA2_0 = input.LA(1 );
if ( (LA2_0==QUERY) ) {
alt2=1 ;
}
switch (alt2) {
case 1 :
{
pushFollow(FOLLOW_queryDirective_in_displayname84);
queryDirective3=queryDirective();
state._fsp--;
adaptor.addChild(root_0, queryDirective3.getTree());
}
break ;
}
int alt3=2 ;
int LA3_0 = input.LA(1 );
if ( (LA3_0==SLASH) ) {
alt3=1 ;
}
switch (alt3) {
case 1 :
{
pushFollow(FOLLOW_attributePart_in_displayname87);
attributePart4=attributePart();
state._fsp--;
adaptor.addChild(root_0, attributePart4.getTree());
}
break ;
}
retval.type = (typePart1!=null ?input.toString(typePart1.start,typePart1.stop):null );
if ((namePart2!=null ?input.toString(namePart2.start,namePart2.stop):null ) != null ) {
retval.disp = (namePart2!=null ?input.toString(namePart2.start,namePart2.stop):null ).substring(1 );
}
retval.directive = (queryDirective3!=null ?((DParseParser.queryDirective_return)queryDirective3).directive:null );
retval.attribute = (attributePart4!=null ?((DParseParser.attributePart_return)attributePart4).attributeRet:null );
if (retval.attribute != null ) {
retval.attribute.setKey(input.toString(retval.start,input.LT(-1 )));
}
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class typePart_return extends ParserRuleReturnScope @Override
public Object getTree () return tree; }
};
public final DParseParser.typePart_return typePart () throws RecognitionException {
DParseParser.typePart_return retval = new DParseParser.typePart_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token set5=null ;
Object set5_tree=null ;
try {
{
root_0 = (Object)adaptor.nil();
int cnt4=0 ;
loop4:
while (true ) {
int alt4=2 ;
int LA4_0 = input.LA(1 );
if ( (LA4_0==DIGIT||LA4_0==LETTER||LA4_0==UNDER) ) {
alt4=1 ;
}
switch (alt4) {
case 1 :
{
set5=input.LT(1 );
if ( input.LA(1 )==DIGIT||input.LA(1 )==LETTER||input.LA(1 )==UNDER ) {
input.consume();
adaptor.addChild(root_0, (Object)adaptor.create(set5));
state.errorRecovery=false ;
}
else {
MismatchedSetException mse = new MismatchedSetException(null ,input);
throw mse;
}
}
break ;
default :
if ( cnt4 >= 1 ) break loop4;
EarlyExitException eee = new EarlyExitException(4 , input);
throw eee;
}
cnt4++;
}
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class path_return extends ParserRuleReturnScope @Override
public Object getTree () return tree; }
};
public final DParseParser.path_return path () throws RecognitionException {
DParseParser.path_return retval = new DParseParser.path_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token SLASH6=null ;
Token set7=null ;
Object SLASH6_tree=null ;
Object set7_tree=null ;
try {
{
root_0 = (Object)adaptor.nil();
SLASH6=(Token)match(input,SLASH,FOLLOW_SLASH_in_path125);
SLASH6_tree = (Object)adaptor.create(SLASH6);
adaptor.addChild(root_0, SLASH6_tree);
int cnt5=0 ;
loop5:
while (true ) {
int alt5=2 ;
int LA5_0 = input.LA(1 );
if ( (LA5_0==DIGIT||LA5_0==DOT||LA5_0==LETTER||LA5_0==UNDER) ) {
alt5=1 ;
}
switch (alt5) {
case 1 :
{
set7=input.LT(1 );
if ( input.LA(1 )==DIGIT||input.LA(1 )==DOT||input.LA(1 )==LETTER||input.LA(1 )==UNDER ) {
input.consume();
adaptor.addChild(root_0, (Object)adaptor.create(set7));
state.errorRecovery=false ;
}
else {
MismatchedSetException mse = new MismatchedSetException(null ,input);
throw mse;
}
}
break ;
default :
if ( cnt5 >= 1 ) break loop5;
EarlyExitException eee = new EarlyExitException(5 , input);
throw eee;
}
cnt5++;
}
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class namePart_return extends ParserRuleReturnScope @Override
public Object getTree () return tree; }
};
public final DParseParser.namePart_return namePart () throws RecognitionException {
DParseParser.namePart_return retval = new DParseParser.namePart_return();
retval.start = input.LT(1 );
Object root_0 = null ;
ParserRuleReturnScope path8 =null ;
try {
{
root_0 = (Object)adaptor.nil();
int cnt6=0 ;
loop6:
while (true ) {
int alt6=2 ;
int LA6_0 = input.LA(1 );
if ( (LA6_0==SLASH) ) {
int LA6_2 = input.LA(2 );
if ( (LA6_2==DIGIT||LA6_2==DOT||LA6_2==LETTER||LA6_2==UNDER) ) {
alt6=1 ;
}
}
switch (alt6) {
case 1 :
{
pushFollow(FOLLOW_path_in_namePart150);
path8=path();
state._fsp--;
adaptor.addChild(root_0, path8.getTree());
}
break ;
default :
if ( cnt6 >= 1 ) break loop6;
EarlyExitException eee = new EarlyExitException(6 , input);
throw eee;
}
cnt6++;
}
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class queryDirective_return extends ParserRuleReturnScope public BaseDirective directive;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.queryDirective_return queryDirective () throws RecognitionException {
DParseParser.queryDirective_return retval = new DParseParser.queryDirective_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token QUERY9=null ;
ParserRuleReturnScope absoluteVersion10 =null ;
Object QUERY9_tree=null ;
try {
{
root_0 = (Object)adaptor.nil();
QUERY9=(Token)match(input,QUERY,FOLLOW_QUERY_in_queryDirective163);
QUERY9_tree = (Object)adaptor.create(QUERY9);
adaptor.addChild(root_0, QUERY9_tree);
pushFollow(FOLLOW_absoluteVersion_in_queryDirective165);
absoluteVersion10=absoluteVersion();
state._fsp--;
adaptor.addChild(root_0, absoluteVersion10.getTree());
retval.directive = (absoluteVersion10!=null ?((DParseParser.absoluteVersion_return)absoluteVersion10).directive:null );
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class attributePart_return extends ParserRuleReturnScope public DocumentAttribute attributeRet;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.attributePart_return attributePart () throws RecognitionException {
DParseParser.attributePart_return retval = new DParseParser.attributePart_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token SLASH11=null ;
ParserRuleReturnScope attribute12 =null ;
Object SLASH11_tree=null ;
try {
{
root_0 = (Object)adaptor.nil();
SLASH11=(Token)match(input,SLASH,FOLLOW_SLASH_in_attributePart178);
SLASH11_tree = (Object)adaptor.create(SLASH11);
adaptor.addChild(root_0, SLASH11_tree);
pushFollow(FOLLOW_attribute_in_attributePart180);
attribute12=attribute();
state._fsp--;
adaptor.addChild(root_0, attribute12.getTree());
retval.attributeRet = (attribute12!=null ?((DParseParser.attribute_return)attribute12).att:null );
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class valuetime_return extends ParserRuleReturnScope public ValueTime vt;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.valuetime_return valuetime () throws RecognitionException {
DParseParser.valuetime_return retval = new DParseParser.valuetime_return();
retval.start = input.LT(1 );
Object root_0 = null ;
ParserRuleReturnScope amount =null ;
ParserRuleReturnScope td =null ;
retval.vt = new ValueTime();
try {
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_number_in_valuetime203);
amount=number();
state._fsp--;
adaptor.addChild(root_0, amount.getTree());
pushFollow(FOLLOW_timedimension_in_valuetime207);
td=timedimension();
state._fsp--;
adaptor.addChild(root_0, td.getTree());
retval.vt.setAmount((amount!=null ?input.toString(amount.start,amount.stop):null )); retval.vt.setDimension((td!=null ?((DParseParser.timedimension_return)td).d:null ));
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class datetime_return extends ParserRuleReturnScope public BaseDirective directive;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.datetime_return datetime () throws RecognitionException {
DParseParser.datetime_return retval = new DParseParser.datetime_return();
retval.start = input.LT(1 );
Object root_0 = null ;
ParserRuleReturnScope absolutetime13 =null ;
ParserRuleReturnScope relativetime14 =null ;
ParserRuleReturnScope relativeversion15 =null ;
try {
int alt7=3 ;
switch ( input.LA(1 ) ) {
case DOLLAR:
{
alt7=1 ;
}
break ;
case DIGIT:
{
alt7=2 ;
}
break ;
case DASH:
{
alt7=3 ;
}
break ;
default :
NoViableAltException nvae =
new NoViableAltException("" , 7 , 0 , input);
throw nvae;
}
switch (alt7) {
case 1 :
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_absolutetime_in_datetime226);
absolutetime13=absolutetime();
state._fsp--;
adaptor.addChild(root_0, absolutetime13.getTree());
retval.directive = (absolutetime13!=null ?((DParseParser.absolutetime_return)absolutetime13).directive:null );
}
break ;
case 2 :
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_relativetime_in_datetime236);
relativetime14=relativetime();
state._fsp--;
adaptor.addChild(root_0, relativetime14.getTree());
retval.directive = (relativetime14!=null ?((DParseParser.relativetime_return)relativetime14).directive:null );
}
break ;
case 3 :
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_relativeversion_in_datetime247);
relativeversion15=relativeversion();
state._fsp--;
adaptor.addChild(root_0, relativeversion15.getTree());
retval.directive = (relativeversion15!=null ?((DParseParser.relativeversion_return)relativeversion15).directive:null );
}
break ;
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class relativetime_return extends ParserRuleReturnScope public RelativeDirective directive;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.relativetime_return relativetime () throws RecognitionException {
DParseParser.relativetime_return retval = new DParseParser.relativetime_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token set16=null ;
Token AGO17=null ;
ParserRuleReturnScope v1 =null ;
ParserRuleReturnScope v2 =null ;
Object set16_tree=null ;
Object AGO17_tree=null ;
retval.directive = new RelativeDirective();
try {
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_valuetime_in_relativetime274);
v1=valuetime();
state._fsp--;
adaptor.addChild(root_0, v1.getTree());
retval.directive.addValue((v1!=null ?((DParseParser.valuetime_return)v1).vt:null ));
loop8:
while (true ) {
int alt8=2 ;
int LA8_0 = input.LA(1 );
if ( (LA8_0==AND||LA8_0==COMMA) ) {
alt8=1 ;
}
switch (alt8) {
case 1 :
{
set16=input.LT(1 );
if ( input.LA(1 )==AND||input.LA(1 )==COMMA ) {
input.consume();
adaptor.addChild(root_0, (Object)adaptor.create(set16));
state.errorRecovery=false ;
}
else {
MismatchedSetException mse = new MismatchedSetException(null ,input);
throw mse;
}
pushFollow(FOLLOW_valuetime_in_relativetime290);
v2=valuetime();
state._fsp--;
adaptor.addChild(root_0, v2.getTree());
retval.directive.addValue((v2!=null ?((DParseParser.valuetime_return)v2).vt:null ));
}
break ;
default :
break loop8;
}
}
AGO17=(Token)match(input,AGO,FOLLOW_AGO_in_relativetime297);
AGO17_tree = (Object)adaptor.create(AGO17);
adaptor.addChild(root_0, AGO17_tree);
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class timedimension_return extends ParserRuleReturnScope public Dimension d;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.timedimension_return timedimension () throws RecognitionException {
DParseParser.timedimension_return retval = new DParseParser.timedimension_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token HOUR18=null ;
Token MINUTE19=null ;
Token DAY20=null ;
Token WEEK21=null ;
Token MONTH22=null ;
Token YEAR23=null ;
Token SECOND24=null ;
Object HOUR18_tree=null ;
Object MINUTE19_tree=null ;
Object DAY20_tree=null ;
Object WEEK21_tree=null ;
Object MONTH22_tree=null ;
Object YEAR23_tree=null ;
Object SECOND24_tree=null ;
try {
int alt9=7 ;
switch ( input.LA(1 ) ) {
case HOUR:
{
alt9=1 ;
}
break ;
case MINUTE:
{
alt9=2 ;
}
break ;
case DAY:
{
alt9=3 ;
}
break ;
case WEEK:
{
alt9=4 ;
}
break ;
case MONTH:
{
alt9=5 ;
}
break ;
case YEAR:
{
alt9=6 ;
}
break ;
case SECOND:
{
alt9=7 ;
}
break ;
default :
NoViableAltException nvae =
new NoViableAltException("" , 9 , 0 , input);
throw nvae;
}
switch (alt9) {
case 1 :
{
root_0 = (Object)adaptor.nil();
HOUR18=(Token)match(input,HOUR,FOLLOW_HOUR_in_timedimension324);
HOUR18_tree = (Object)adaptor.create(HOUR18);
adaptor.addChild(root_0, HOUR18_tree);
retval.d = Dimension.HOUR;
}
break ;
case 2 :
{
root_0 = (Object)adaptor.nil();
MINUTE19=(Token)match(input,MINUTE,FOLLOW_MINUTE_in_timedimension342);
MINUTE19_tree = (Object)adaptor.create(MINUTE19);
adaptor.addChild(root_0, MINUTE19_tree);
retval.d = Dimension.MINUTE;
}
break ;
case 3 :
{
root_0 = (Object)adaptor.nil();
DAY20=(Token)match(input,DAY,FOLLOW_DAY_in_timedimension359);
DAY20_tree = (Object)adaptor.create(DAY20);
adaptor.addChild(root_0, DAY20_tree);
retval.d = Dimension.DAY;
}
break ;
case 4 :
{
root_0 = (Object)adaptor.nil();
WEEK21=(Token)match(input,WEEK,FOLLOW_WEEK_in_timedimension376);
WEEK21_tree = (Object)adaptor.create(WEEK21);
adaptor.addChild(root_0, WEEK21_tree);
retval.d = Dimension.WEEK;
}
break ;
case 5 :
{
root_0 = (Object)adaptor.nil();
MONTH22=(Token)match(input,MONTH,FOLLOW_MONTH_in_timedimension393);
MONTH22_tree = (Object)adaptor.create(MONTH22);
adaptor.addChild(root_0, MONTH22_tree);
retval.d = Dimension.MONTH;
}
break ;
case 6 :
{
root_0 = (Object)adaptor.nil();
YEAR23=(Token)match(input,YEAR,FOLLOW_YEAR_in_timedimension410);
YEAR23_tree = (Object)adaptor.create(YEAR23);
adaptor.addChild(root_0, YEAR23_tree);
retval.d = Dimension.YEAR;
}
break ;
case 7 :
{
root_0 = (Object)adaptor.nil();
SECOND24=(Token)match(input,SECOND,FOLLOW_SECOND_in_timedimension427);
SECOND24_tree = (Object)adaptor.create(SECOND24);
adaptor.addChild(root_0, SECOND24_tree);
retval.d = Dimension.SECOND;
}
break ;
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class time_return extends ParserRuleReturnScope public RaptureTime t;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.time_return time () throws RecognitionException {
DParseParser.time_return retval = new DParseParser.time_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token COLON25=null ;
Token COLON26=null ;
ParserRuleReturnScope h =null ;
ParserRuleReturnScope m =null ;
ParserRuleReturnScope s =null ;
Object COLON25_tree=null ;
Object COLON26_tree=null ;
retval.t = new RaptureTime();
try {
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_number_in_time449);
h=number();
state._fsp--;
adaptor.addChild(root_0, h.getTree());
retval.t.setHour((h!=null ?input.toString(h.start,h.stop):null ));
COLON25=(Token)match(input,COLON,FOLLOW_COLON_in_time453);
COLON25_tree = (Object)adaptor.create(COLON25);
adaptor.addChild(root_0, COLON25_tree);
pushFollow(FOLLOW_number_in_time457);
m=number();
state._fsp--;
adaptor.addChild(root_0, m.getTree());
retval.t.setMinute((m!=null ?input.toString(m.start,m.stop):null ));
COLON26=(Token)match(input,COLON,FOLLOW_COLON_in_time461);
COLON26_tree = (Object)adaptor.create(COLON26);
adaptor.addChild(root_0, COLON26_tree);
pushFollow(FOLLOW_number_in_time465);
s=number();
state._fsp--;
adaptor.addChild(root_0, s.getTree());
retval.t.setSecond((s!=null ?input.toString(s.start,s.stop):null ));
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class date_return extends ParserRuleReturnScope public RaptureDate d;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.date_return date () throws RecognitionException {
DParseParser.date_return retval = new DParseParser.date_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token SLASH27=null ;
Token SLASH28=null ;
ParserRuleReturnScope y =null ;
ParserRuleReturnScope m =null ;
ParserRuleReturnScope da =null ;
Object SLASH27_tree=null ;
Object SLASH28_tree=null ;
retval.d = new RaptureDate();
try {
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_number_in_date489);
y=number();
state._fsp--;
adaptor.addChild(root_0, y.getTree());
retval.d.setYear((y!=null ?input.toString(y.start,y.stop):null ));
SLASH27=(Token)match(input,SLASH,FOLLOW_SLASH_in_date498);
SLASH27_tree = (Object)adaptor.create(SLASH27);
adaptor.addChild(root_0, SLASH27_tree);
pushFollow(FOLLOW_number_in_date502);
m=number();
state._fsp--;
adaptor.addChild(root_0, m.getTree());
retval.d.setMonth((m!=null ?input.toString(m.start,m.stop):null ));
SLASH28=(Token)match(input,SLASH,FOLLOW_SLASH_in_date511);
SLASH28_tree = (Object)adaptor.create(SLASH28);
adaptor.addChild(root_0, SLASH28_tree);
pushFollow(FOLLOW_number_in_date515);
da=number();
state._fsp--;
adaptor.addChild(root_0, da.getTree());
retval.d.setDay((da!=null ?input.toString(da.start,da.stop):null ));
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class absolutetime_return extends ParserRuleReturnScope public AbsoluteDirective directive;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.absolutetime_return absolutetime () throws RecognitionException {
DParseParser.absolutetime_return retval = new DParseParser.absolutetime_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token DOLLAR29=null ;
Token DASH31=null ;
ParserRuleReturnScope date30 =null ;
ParserRuleReturnScope time32 =null ;
Object DOLLAR29_tree=null ;
Object DASH31_tree=null ;
retval.directive = new AbsoluteDirective();
try {
{
root_0 = (Object)adaptor.nil();
DOLLAR29=(Token)match(input,DOLLAR,FOLLOW_DOLLAR_in_absolutetime537);
DOLLAR29_tree = (Object)adaptor.create(DOLLAR29);
adaptor.addChild(root_0, DOLLAR29_tree);
pushFollow(FOLLOW_date_in_absolutetime539);
date30=date();
state._fsp--;
adaptor.addChild(root_0, date30.getTree());
retval.directive.setDate((date30!=null ?((DParseParser.date_return)date30).d:null ));
DASH31=(Token)match(input,DASH,FOLLOW_DASH_in_absolutetime543);
DASH31_tree = (Object)adaptor.create(DASH31);
adaptor.addChild(root_0, DASH31_tree);
pushFollow(FOLLOW_time_in_absolutetime545);
time32=time();
state._fsp--;
adaptor.addChild(root_0, time32.getTree());
retval.directive.setTime((time32!=null ?((DParseParser.time_return)time32).t:null ));
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class relativeversion_return extends ParserRuleReturnScope public RelativeVersion directive;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.relativeversion_return relativeversion () throws RecognitionException {
DParseParser.relativeversion_return retval = new DParseParser.relativeversion_return();
retval.start = input.LT(1 );
Object root_0 = null ;
ParserRuleReturnScope negnumber33 =null ;
retval.directive = new RelativeVersion();
try {
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_negnumber_in_relativeversion564);
negnumber33=negnumber();
state._fsp--;
adaptor.addChild(root_0, negnumber33.getTree());
retval.directive.setBack((negnumber33!=null ?input.toString(negnumber33.start,negnumber33.stop):null ));
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class absoluteVersion_return extends ParserRuleReturnScope public AbsoluteVersion directive;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.absoluteVersion_return absoluteVersion () throws RecognitionException {
DParseParser.absoluteVersion_return retval = new DParseParser.absoluteVersion_return();
retval.start = input.LT(1 );
Object root_0 = null ;
ParserRuleReturnScope number34 =null ;
retval.directive = new AbsoluteVersion();
try {
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_number_in_absoluteVersion583);
number34=number();
state._fsp--;
adaptor.addChild(root_0, number34.getTree());
retval.directive.setVersion((number34!=null ?input.toString(number34.start,number34.stop):null ));
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class attribute_return extends ParserRuleReturnScope public DocumentAttribute att;
Object tree;
@Override
public Object getTree () return tree; }
};
public final DParseParser.attribute_return attribute () throws RecognitionException {
DParseParser.attribute_return retval = new DParseParser.attribute_return();
retval.start = input.LT(1 );
Object root_0 = null ;
ParserRuleReturnScope attributePartType35 =null ;
ParserRuleReturnScope attributePartKey36 =null ;
try {
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_attributePartType_in_attribute597);
attributePartType35=attributePartType();
state._fsp--;
adaptor.addChild(root_0, attributePartType35.getTree());
int alt10=2 ;
int LA10_0 = input.LA(1 );
if ( (LA10_0==SLASH) ) {
alt10=1 ;
}
switch (alt10) {
case 1 :
{
pushFollow(FOLLOW_attributePartKey_in_attribute599);
attributePartKey36=attributePartKey();
state._fsp--;
adaptor.addChild(root_0, attributePartKey36.getTree());
}
break ;
}
retval.att = DocumentAttributeFactory.create((attributePartType35!=null ?input.toString(attributePartType35.start,attributePartType35.stop):null ).substring(1 ));
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class negnumber_return extends ParserRuleReturnScope @Override
public Object getTree () return tree; }
};
public final DParseParser.negnumber_return negnumber () throws RecognitionException {
DParseParser.negnumber_return retval = new DParseParser.negnumber_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token DASH37=null ;
ParserRuleReturnScope number38 =null ;
Object DASH37_tree=null ;
try {
{
root_0 = (Object)adaptor.nil();
DASH37=(Token)match(input,DASH,FOLLOW_DASH_in_negnumber610);
DASH37_tree = (Object)adaptor.create(DASH37);
adaptor.addChild(root_0, DASH37_tree);
pushFollow(FOLLOW_number_in_negnumber612);
number38=number();
state._fsp--;
adaptor.addChild(root_0, number38.getTree());
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class number_return extends ParserRuleReturnScope @Override
public Object getTree () return tree; }
};
public final DParseParser.number_return number () throws RecognitionException {
DParseParser.number_return retval = new DParseParser.number_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token DIGIT39=null ;
Object DIGIT39_tree=null ;
try {
{
root_0 = (Object)adaptor.nil();
int cnt11=0 ;
loop11:
while (true ) {
int alt11=2 ;
int LA11_0 = input.LA(1 );
if ( (LA11_0==DIGIT) ) {
alt11=1 ;
}
switch (alt11) {
case 1 :
{
DIGIT39=(Token)match(input,DIGIT,FOLLOW_DIGIT_in_number618);
DIGIT39_tree = (Object)adaptor.create(DIGIT39);
adaptor.addChild(root_0, DIGIT39_tree);
}
break ;
default :
if ( cnt11 >= 1 ) break loop11;
EarlyExitException eee = new EarlyExitException(11 , input);
throw eee;
}
cnt11++;
}
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class attributePartType_return extends ParserRuleReturnScope @Override
public Object getTree () return tree; }
};
public final DParseParser.attributePartType_return attributePartType () throws RecognitionException {
DParseParser.attributePartType_return retval = new DParseParser.attributePartType_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token DOLLAR40=null ;
Token LETTER41=null ;
Object DOLLAR40_tree=null ;
Object LETTER41_tree=null ;
try {
{
root_0 = (Object)adaptor.nil();
DOLLAR40=(Token)match(input,DOLLAR,FOLLOW_DOLLAR_in_attributePartType627);
DOLLAR40_tree = (Object)adaptor.create(DOLLAR40);
adaptor.addChild(root_0, DOLLAR40_tree);
int cnt12=0 ;
loop12:
while (true ) {
int alt12=2 ;
int LA12_0 = input.LA(1 );
if ( (LA12_0==LETTER) ) {
alt12=1 ;
}
switch (alt12) {
case 1 :
{
LETTER41=(Token)match(input,LETTER,FOLLOW_LETTER_in_attributePartType629);
LETTER41_tree = (Object)adaptor.create(LETTER41);
adaptor.addChild(root_0, LETTER41_tree);
}
break ;
default :
if ( cnt12 >= 1 ) break loop12;
EarlyExitException eee = new EarlyExitException(12 , input);
throw eee;
}
cnt12++;
}
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static class attributePartKey_return extends ParserRuleReturnScope @Override
public Object getTree () return tree; }
};
public final DParseParser.attributePartKey_return attributePartKey () throws RecognitionException {
DParseParser.attributePartKey_return retval = new DParseParser.attributePartKey_return();
retval.start = input.LT(1 );
Object root_0 = null ;
Token SLASH42=null ;
Token STRING43=null ;
Object SLASH42_tree=null ;
Object STRING43_tree=null ;
try {
{
root_0 = (Object)adaptor.nil();
SLASH42=(Token)match(input,SLASH,FOLLOW_SLASH_in_attributePartKey637);
SLASH42_tree = (Object)adaptor.create(SLASH42);
adaptor.addChild(root_0, SLASH42_tree);
STRING43=(Token)match(input,STRING,FOLLOW_STRING_in_attributePartKey639);
STRING43_tree = (Object)adaptor.create(STRING43);
adaptor.addChild(root_0, STRING43_tree);
}
retval.stop = input.LT(-1 );
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1 ), re);
}
finally {
}
return retval;
}
public static final BitSet FOLLOW_typePart_in_displayname79 = new BitSet(new long []{0x0000000000480002L });
public static final BitSet FOLLOW_namePart_in_displayname81 = new BitSet(new long []{0x0000000000480002L });
public static final BitSet FOLLOW_queryDirective_in_displayname84 = new BitSet(new long []{0x0000000000400002L });
public static final BitSet FOLLOW_attributePart_in_displayname87 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_SLASH_in_path125 = new BitSet(new long []{0x0000000010009400L });
public static final BitSet FOLLOW_path_in_namePart150 = new BitSet(new long []{0x0000000000400002L });
public static final BitSet FOLLOW_QUERY_in_queryDirective163 = new BitSet(new long []{0x0000000000000400L });
public static final BitSet FOLLOW_absoluteVersion_in_queryDirective165 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_SLASH_in_attributePart178 = new BitSet(new long []{0x0000000000000800L });
public static final BitSet FOLLOW_attribute_in_attributePart180 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_number_in_valuetime203 = new BitSet(new long []{0x0000000060134200L });
public static final BitSet FOLLOW_timedimension_in_valuetime207 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_absolutetime_in_datetime226 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_relativetime_in_datetime236 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_relativeversion_in_datetime247 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_valuetime_in_relativetime274 = new BitSet(new long []{0x00000000000000B0L });
public static final BitSet FOLLOW_set_in_relativetime280 = new BitSet(new long []{0x0000000000000400L });
public static final BitSet FOLLOW_valuetime_in_relativetime290 = new BitSet(new long []{0x00000000000000B0L });
public static final BitSet FOLLOW_AGO_in_relativetime297 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_HOUR_in_timedimension324 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_MINUTE_in_timedimension342 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_DAY_in_timedimension359 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_WEEK_in_timedimension376 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_MONTH_in_timedimension393 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_YEAR_in_timedimension410 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_SECOND_in_timedimension427 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_number_in_time449 = new BitSet(new long []{0x0000000000000040L });
public static final BitSet FOLLOW_COLON_in_time453 = new BitSet(new long []{0x0000000000000400L });
public static final BitSet FOLLOW_number_in_time457 = new BitSet(new long []{0x0000000000000040L });
public static final BitSet FOLLOW_COLON_in_time461 = new BitSet(new long []{0x0000000000000400L });
public static final BitSet FOLLOW_number_in_time465 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_number_in_date489 = new BitSet(new long []{0x0000000000400000L });
public static final BitSet FOLLOW_SLASH_in_date498 = new BitSet(new long []{0x0000000000000400L });
public static final BitSet FOLLOW_number_in_date502 = new BitSet(new long []{0x0000000000400000L });
public static final BitSet FOLLOW_SLASH_in_date511 = new BitSet(new long []{0x0000000000000400L });
public static final BitSet FOLLOW_number_in_date515 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_DOLLAR_in_absolutetime537 = new BitSet(new long []{0x0000000000000400L });
public static final BitSet FOLLOW_date_in_absolutetime539 = new BitSet(new long []{0x0000000000000100L });
public static final BitSet FOLLOW_DASH_in_absolutetime543 = new BitSet(new long []{0x0000000000000400L });
public static final BitSet FOLLOW_time_in_absolutetime545 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_negnumber_in_relativeversion564 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_number_in_absoluteVersion583 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_attributePartType_in_attribute597 = new BitSet(new long []{0x0000000000400002L });
public static final BitSet FOLLOW_attributePartKey_in_attribute599 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_DASH_in_negnumber610 = new BitSet(new long []{0x0000000000000400L });
public static final BitSet FOLLOW_number_in_negnumber612 = new BitSet(new long []{0x0000000000000002L });
public static final BitSet FOLLOW_DIGIT_in_number618 = new BitSet(new long []{0x0000000000000402L });
public static final BitSet FOLLOW_DOLLAR_in_attributePartType627 = new BitSet(new long []{0x0000000000008000L });
public static final BitSet FOLLOW_LETTER_in_attributePartType629 = new BitSet(new long []{0x0000000000008002L });
public static final BitSet FOLLOW_SLASH_in_attributePartKey637 = new BitSet(new long []{0x0000000001000000L });
public static final BitSet FOLLOW_STRING_in_attributePartKey639 = new BitSet(new long []{0x0000000000000002L });
}
