[Saga-devel] saga SVN commit 3335: /trunk/saga/impl/packages/sd/
Andre Merzky
andre at merzky.net
Tue Jan 20 04:01:13 CST 2009
Great! Does that mean we can move external/antlr to the
glite adaptor, too?
Cheers, Andre.
Quoting [paul.livesey at stfc.ac.uk] (Jan 20 2009):
>
> User: svn_plivesey
> Date: 2009/01/20 03:40 AM
>
> Removed:
> /trunk/saga/impl/packages/sd/
> sdTokenTypes.hpp, sdTokenTypes.txt, sd_grammar.g, sd_internalnode.hpp, sd_leafnode.hpp, sd_lexer.cpp, sd_lexer.hpp, sd_node.hpp, sd_parser.cpp, sd_parser.hpp, sd_parser_ext.hpp
>
> Modified:
> /trunk/saga/impl/packages/sd/
> Makefile
>
> Log:
> Antlr lexer/parser removed and put somewhere more
> sensible, like the glite adaptor where it's actually used!
>
> Makefile changed to reflect this move.
>
> File Changes:
>
> Directory: /trunk/saga/impl/packages/sd/
> ========================================
>
> File [modified]: Makefile
> Delta lines: +2 -24
> ===================================================================
> --- trunk/saga/impl/packages/sd/Makefile 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/Makefile 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -7,35 +7,13 @@
>
> SAGA_ROOT = ../../../../
>
> -GRAMMAR_FILE = sd_grammar.g
> -GRAMMAR_SRC = sd_parser.cpp sd_lexer.cpp
> -GRAMMAR_HDR = sd_parser.hpp sd_lexer.hpp sdTokenTypes.hpp
> -GRAMMAR_TXT = sdTokenTypes.txt
> -
> -SAGA_HDR = $(sort $(wildcard *.hpp) $(GRAMMAR_HDR))
> -SAGA_SRC = $(sort $(wildcard *.cpp) $(GRAMMAR_SRC))
> +SAGA_HDR = $(wildcard *.hpp)
> +SAGA_SRC = $(wildcard *.cpp)
> SAGA_LIB_OBJ = $(SAGA_SRC:%.cpp=%.o)
> SAGA_LIB_OBJ += $(wildcard $(SAGA_ROOT)/saga/saga/packages/sd/*.o)
>
> SAGA_PACKAGE_NAME = sd
> -SAGA_PACKAGE_REQUIREMENTS = ANTLR
>
> include $(SAGA_ROOT)/make/saga.package.mk
> --include $(SAGA_ROOT)/make/saga.config.antlr.c.mk
> -include $(SAGA_ROOT)/make/saga.package.sd.i.mk
>
> -$(GRAMMAR_SRC) $(GRAMMAR_HDR): $(GRAMMAR_TXT)
> -$(GRAMMAR_TXT): $(GRAMMAR_FILE)
> -ifeq "x$(SAGA_HAVE_ANTLR)" "xyes"
> - @$(ECHO) " generating grammar"
> - @$(SH) $(ANTLR) $(GRAMMAR_FILE)
> -else
> - @$(ECHO) " can't regenerate grammar - antlr missing"
> -endif
> -
> -clean::
> -ifeq "x$(SAGA_HAVE_ANTLR)" "xyes"
> - @$(ECHO) " cleaning grammar"
> - @$(RM) $(GRAMMAR_SRC) $(GRAMMAR_HDR) $(GRAMMAR_TXT) $(GRAMMAR_OBJ)
> -endif
> -
>
> File [removed]: sdTokenTypes.hpp
> Delta lines: +0 -56
> ===================================================================
> --- trunk/saga/impl/packages/sd/sdTokenTypes.hpp 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sdTokenTypes.hpp 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,56 +0,0 @@
> -#ifndef INC_sdTokenTypes_hpp_
> -#define INC_sdTokenTypes_hpp_
> -
> -/* $ANTLR 2.7.7 (20081210): "sd_grammar.g" -> "sdTokenTypes.hpp"$ */
> -
> -#ifndef CUSTOM_API
> -# define CUSTOM_API
> -#endif
> -
> -#ifdef __cplusplus
> -struct CUSTOM_API sdTokenTypes {
> -#endif
> - enum {
> - EOF_ = 1,
> - K_IN = 4,
> - K_LIKE = 5,
> - K_ESCAPE = 6,
> - K_NOT = 7,
> - K_AND = 8,
> - K_OR = 9,
> - K_VO = 10,
> - K_TYPE = 11,
> - K_NAME = 12,
> - K_UID = 13,
> - K_URI = 14,
> - K_ENDPOINT = 15,
> - K_SITE = 16,
> - K_SERVICE = 17,
> - K_ALL = 18,
> - K_ANY = 19,
> - K_STRING_LIST = 20,
> - SVC_CMP = 21,
> - DATA_CMP = 22,
> - S_CHAR_LITERAL = 23,
> - LPAREN = 24,
> - RPAREN = 25,
> - S_NUMBER = 26,
> - COMMA = 27,
> - NE = 28,
> - EQ = 29,
> - LESS = 30,
> - GT = 31,
> - LE = 32,
> - GE = 33,
> - S_IDENTIFIER = 34,
> - WS_ = 35,
> - DIGIT = 36,
> - INTEGER = 37,
> - FLOAT = 38,
> - LETTER = 39,
> - NULL_TREE_LOOKAHEAD = 3
> - };
> -#ifdef __cplusplus
> -};
> -#endif
> -#endif /*INC_sdTokenTypes_hpp_*/
>
> File [removed]: sdTokenTypes.txt
> Delta lines: +0 -38
> ===================================================================
> --- trunk/saga/impl/packages/sd/sdTokenTypes.txt 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sdTokenTypes.txt 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,38 +0,0 @@
> -// $ANTLR 2.7.7 (20081210): sd_grammar.g -> sdTokenTypes.txt$
> -sd // output token vocab name
> -K_IN="in"=4
> -K_LIKE="like"=5
> -K_ESCAPE="escape"=6
> -K_NOT="not"=7
> -K_AND="and"=8
> -K_OR="or"=9
> -K_VO="vo"=10
> -K_TYPE="type"=11
> -K_NAME="name"=12
> -K_UID="uid"=13
> -K_URI="uri"=14
> -K_ENDPOINT="endpoint"=15
> -K_SITE="site"=16
> -K_SERVICE="related_services"=17
> -K_ALL="all"=18
> -K_ANY="any"=19
> -K_STRING_LIST=20
> -SVC_CMP=21
> -DATA_CMP=22
> -S_CHAR_LITERAL("char literal")=23
> -LPAREN("left parenthesis")=24
> -RPAREN("right parenthesis")=25
> -S_NUMBER("number")=26
> -COMMA("comma")=27
> -NE("not equals")=28
> -EQ("equals")=29
> -LESS=30
> -GT("greater than")=31
> -LE=32
> -GE=33
> -S_IDENTIFIER("identifier")=34
> -WS_("white space")=35
> -DIGIT("digit")=36
> -INTEGER("integer")=37
> -FLOAT("float")=38
> -LETTER("letter")=39
>
> File [removed]: sd_grammar.g
> Delta lines: +0 -514
> ===================================================================
> --- trunk/saga/impl/packages/sd/sd_grammar.g 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sd_grammar.g 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,514 +0,0 @@
> -header
> -{
> - #include "sd_leafnode.hpp"
> - #include "sd_internalnode.hpp"
> - #include <iostream>
> - #include <string>
> - #include <list>
> - #include <math.h>
> - #include <utility>
> - using namespace std;
> -}
> -
> -options
> -{
> - language=Cpp;
> -}
> -
> -class sd_parser extends Parser;
> -
> -options
> -{
> - k = 3;
> - exportVocab = sd;
> - buildAST = true;
> -}
> -
> -tokens {
> -K_IN = "in";
> -K_LIKE = "like";
> -K_ESCAPE = "escape";
> -K_NOT = "not";
> -K_AND = "and" <AST=sd_internalnode>;
> -K_OR = "or" <AST=sd_internalnode>;
> -K_VO = "vo";
> -K_TYPE = "type";
> -K_NAME = "name";
> -K_UID = "uid";
> -K_URI = "uri";
> -K_ENDPOINT = "endpoint";
> -K_SITE = "site";
> -K_SERVICE = "related_services";
> -K_ALL ="all";
> -K_ANY ="any";
> -K_STRING_LIST;
> -SVC_CMP<AST=sd_leafnode>;
> -DATA_CMP<AST=sd_leafnode>;
> -}
> -
> -service_keyword! returns [int tok_type = 0] :
> - k1:K_TYPE! { tok_type = k1->getType(); } |
> - k2:K_NAME! { tok_type = k2->getType(); } |
> - k3:K_SITE! { tok_type = k3->getType(); } |
> - k4:K_ENDPOINT! { tok_type = k4->getType(); } |
> - k5:K_SERVICE! { tok_type = k5->getType(); } |
> - k6:K_UID! { tok_type = k6->getType(); } |
> - k7:K_URI! { tok_type = k7->getType(); }
> - ;
> -
> -service_filter : service_filter_expression ;
> -
> -service_filter_expression : service_and_expression ( K_OR^ service_and_expression )* ;
> -
> -service_and_expression : service_expression ( K_AND^ service_expression)* ;
> -
> -service_expression
> -{ int knot = 0; int lhs; int op;
> - std::pair<std::string, char> rhs;
> - std::list<std::string> slist;
> - std::string s;
> - Refsd_leafnode myRef;
> -} :
> -(
> - lhs=service_keyword (K_NOT! {knot=1;})? K_IN! slist=in_clause
> - {
> - #service_expression = #([SVC_CMP]);
> - myRef = (Refsd_leafnode)#service_expression;
> - myRef->setLValue(lhs);
> - myRef->setOpType(K_IN);
> - myRef->setRValType(K_STRING_LIST);
> -
> - while (slist.size() > 0)
> - {
> - s = slist.front();
> - myRef->addListElement(s);
> - slist.pop_front();
> - }
> -
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> - //std::cout << "front list element : "
> - // << myRef->frontListElement() << endl;
> - //std::cout << "list size : "
> - // << myRef->getListSize() << endl;
> - //std::cout << "in clause parsed" << endl;
> - } |
> -
> - lhs=service_keyword (K_NOT! {knot = 1;})? K_LIKE! rhs=like_clause
> - {
> - #service_expression = #([SVC_CMP]);
> - myRef = (Refsd_leafnode)#service_expression;
> - myRef->setLValue(lhs);
> - myRef->setOpType(K_LIKE);
> - myRef->setRValue(rhs.first);
> -
> - //Set the escape character
> - //for the 'LIKE' clause
> - myRef->setEscapeChar(rhs.second);
> -
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> - } |
> -
> - lhs=service_keyword op=eqop rval:S_CHAR_LITERAL!
> - {
> - #service_expression = #([SVC_CMP]);
> - myRef = (Refsd_leafnode)#service_expression;
> - myRef->setLValue(lhs);
> - //std::cout << "keyword type " << lhs << endl;
> - myRef->setOpType(op);
> - //std::cout << "op type " << op << endl;
> - myRef->setRValue(rval->getText());
> - //std::cout << "literal " << rval->getText() << endl;
> - } |
> -
> - LPAREN! service_filter_expression RPAREN!
> -)
> - ;
> -
> -like_clause returns [pair<string, char> s] :
> - rhs:S_CHAR_LITERAL!
> - {
> - s.first = rhs->getText();
> - s.second = '\0';
> - }
> - (K_ESCAPE esc:S_CHAR_LITERAL!
> - {
> - //Check there are at least three characters
> - //to allow for the quotes
> - if ( esc->getText().size() > 2 )
> - {
> - //Character [1] to allow for the quote
> - s.second = esc->getText()[1];
> - }
> -
> - else
> - {
> - s.second = '\0';
> - }
> - })?
> - ;
> -
> -//You don't need to quote numbers
> -in_clause returns [std::list<std::string> slist] :
> - slist=bracketed_list
> - ;
> -
> -//This should match a bracketed list
> -//('string', num, num, 'string', etc.)
> -bracketed_list returns [std::list<std::string> slist] :
> - LPAREN
> -
> - (lit:S_CHAR_LITERAL! {slist.push_back(lit->getText());} |
> - num:S_NUMBER! {slist.push_back(num->getText());} )
> -
> - (COMMA! (lit2:S_CHAR_LITERAL! {slist.push_back(lit2->getText());} |
> - num2:S_NUMBER! {slist.push_back(num2->getText());}) )*
> - RPAREN
> - ;
> -
> -string_literal_list! : lit:S_CHAR_LITERAL!
> -//{
> -//s = lit->getText();
> -//myRef->addListElement(lit->getText());
> -//std::cout << lit->getText() << " " << myRef->getListSize() <<endl;
> -//}
> - ( COMMA! lit2:S_CHAR_LITERAL!
> - {
> - //s = s + "," + lit2->getText();
> - //std::cout << myRef->getListSize() <<endl;
> - //myRef->addListElement(lit2->getText());
> - //std::cout << lit2->getText() <<endl;
> - } )*
> -;
> -
> -vo_filter : vo_filter_expression
> -;
> -
> -vo_filter_expression : vo_and_expression (K_OR^ vo_and_expression )*
> -;
> -
> -vo_and_expression : vo_expression ( K_AND^ vo_expression )*
> -;
> -
> -vo_expression
> -{
> - bool allVal = false;
> - bool anyVal = false;
> - int knot = 0;
> - int op;
> - string rhs;
> - string comp;
> - string s;
> - Refsd_leafnode myRef;
> - list<string> slist;
> - std::pair<std::string, char> rhsLike;
> -} :
> - //Check for ANY/ALL clause
> - (K_ANY! {anyVal = true;} |
> - K_ALL! {allVal = true;})?
> -
> - K_VO! (K_NOT! {knot=1;})? K_IN! slist=in_clause
> - {
> - #vo_expression = #([SVC_CMP]);
> - myRef = (Refsd_leafnode)#vo_expression;
> - myRef->setLValue(K_VO);
> - myRef->setOpType(K_IN);
> - myRef->setRValType(K_STRING_LIST);
> -
> - while ( slist.size() > 0 )
> - {
> - s = slist.front();
> - myRef->addListElement(s);
> - slist.pop_front();
> - }
> -
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> - } |
> -
> - K_VO! (K_NOT! {knot = 1;})? K_LIKE rhsLike=like_clause
> - {
> - #vo_expression = #([SVC_CMP]);
> - myRef = (Refsd_leafnode)#vo_expression;
> - myRef->setLValue(K_VO);
> - myRef->setOpType(K_LIKE);
> - myRef->setRValue(rhsLike.first);
> -
> - //Set the escape character
> - //for the 'LIKE' clause
> - myRef->setEscapeChar(rhsLike.second);
> -
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> - } |
> -
> - K_VO! op=eqop rval:S_CHAR_LITERAL!
> - {
> - #vo_expression = #([SVC_CMP]);
> - myRef = (Refsd_leafnode)#vo_expression;
> - myRef->setLValue(K_VO);
> - myRef->setOpType(op);
> - myRef->setRValue(rval->getText());
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> - } |
> -
> - LPAREN! vo_filter_expression RPAREN!
> - ;
> -
> -data_filter : data_filter_expression
> -;
> -
> -data_filter_expression : data_and_expression ( K_OR^ data_and_expression )*
> -;
> -
> -data_and_expression : data_expression ( K_AND^ data_expression )*
> -;
> -
> -data_expression : data_comparison | LPAREN! data_filter_expression RPAREN!
> -;
> -
> -eqop returns [int tok_type = 0] :
> - o1:NE! { tok_type = o1->getType(); } |
> - o2:EQ! { tok_type = o2->getType(); }
> -;
> -
> -relop! returns [int tok_type = 0] :
> - o1:EQ { tok_type = o1->getType(); } |
> - o2:LESS { tok_type = o2->getType(); } |
> - o3:GT { tok_type = o3->getType(); } |
> - o4:NE { tok_type = o4->getType(); } |
> - o5:LE { tok_type = o5->getType(); } |
> - o6:GE { tok_type = o6->getType(); }
> -;
> -
> -data_comparison
> -{
> - bool allVal = false;
> - bool anyVal = false;
> - int op; int rhs1 = 0; int knot = 0;
> - double dval;
> - Refsd_leafnode myRef;
> - std::list<std::string> slist;
> - std::string s;
> - std::pair<std::string, char> likePair;
> - std::string likeString;
> -} :
> - //Check for ANY/ALL clause
> - (K_ANY! {anyVal = true;} |
> - K_ALL! {allVal = true;})?
> -
> - lhs:S_IDENTIFIER! (K_NOT! {knot=1;})? K_IN! slist=in_clause
> - {
> - //Deal with the 'IN' oerator
> - #data_comparison = #([DATA_CMP]);
> - myRef = (Refsd_leafnode)#data_comparison;
> - myRef->setLKey(lhs->getText());
> - myRef->setOpType(K_IN);
> - myRef->setRValType(K_STRING_LIST);
> -
> - //Add everything in the 'IN' list to this element
> - while ( slist.size() > 0 )
> - {
> - s = slist.front();
> - myRef->addListElement(s);
> - slist.pop_front();
> - }
> -
> - //Deal with the NOT condition
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> - } |
> -
> - lhs0:S_IDENTIFIER (K_NOT! {knot = 1;})? K_LIKE likePair=like_clause
> - {
> - //Deal with the 'LIKE' oerator
> - likeString = likePair.first;
> - #data_comparison = #([DATA_CMP]);
> - myRef = (Refsd_leafnode)#data_comparison;
> - myRef->setLKey(lhs0->getText());
> - myRef->setOpType(K_LIKE);
> - myRef->setRValue(likeString);
> -
> - //Set the escape character
> - //for the 'LIKE' clause
> - myRef->setEscapeChar(likePair.second);
> -
> - //Deal with the NOT condition
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> - } |
> -
> - lhs1:S_IDENTIFIER! op=relop (lit:S_CHAR_LITERAL! { rhs1 = 1; } | num:S_NUMBER!)
> - {
> - //Deal with the remaining operators
> - #data_comparison = #([DATA_CMP]);
> - myRef = (Refsd_leafnode)#data_comparison;
> - myRef->setLKey(lhs1->getText());
> - myRef->setOpType(op);
> -
> - if ( rhs1 )
> - {
> - myRef->setRValType(S_CHAR_LITERAL);
> - myRef->setRValue(lit->getText());
> - }
> -
> - else
> - {
> - myRef->setRValType(S_NUMBER);
> - dval = atof(num->getText().c_str());
> - myRef->setRValNum(dval);
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> - } |
> -
> - lhs2:S_IDENTIFIER! op=eqop slist=bracketed_list
> - {
> - //Deal with the remaining operators
> - #data_comparison = #([DATA_CMP]);
> - myRef = (Refsd_leafnode)#data_comparison;
> - myRef->setLKey(lhs2->getText());
> - myRef->setOpType(op);
> - myRef->setRValType(K_STRING_LIST);
> -
> - //Add everything in the 'IN' list to this element
> - while ( slist.size() > 0 )
> - {
> - s = slist.front();
> - myRef->addListElement(s);
> - slist.pop_front();
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> - }
> -;
> -
> -class sd_lexer extends Lexer;
> -
> -options
> -{
> - k = 2;
> - caseSensitive = false;
> - exportVocab = sd;
> - testLiterals = false;
> - caseSensitiveLiterals = false;
> -}
> -
> -WS_ options { paraphrase = "white space"; } : (' ' | '\t' | '\n' | '\r') { _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; } ;
> -
> -LPAREN options { paraphrase = "left parenthesis"; } : '(' ;
> -
> -RPAREN options { paraphrase = "right parenthesis"; } : ')' ;
> -
> -COMMA options { paraphrase = "comma"; } : ',' ;
> -
> -protected
> -DIGIT options { paraphrase = "digit"; } : '0' .. '9';
> -
> -protected
> -INTEGER options { paraphrase = "integer"; } : (DIGIT)+ ;
> -
> -protected
> -FLOAT options { paraphrase = "float"; } : INTEGER ('.' INTEGER)? | '.' INTEGER ;
> -
> -S_NUMBER options { paraphrase = "number"; } : FLOAT (('e') ('+' | '-')? FLOAT)? ;
> -
> -S_CHAR_LITERAL options { paraphrase = "char literal"; } : '\'' ( ~'\'' )* '\'' ;
> -
> -EQ options { paraphrase = "equals"; } : '=' ;
> -
> -NE options { paraphrase = "not equals"; } : '<' { _ttype = LESS; }
> - ( ( '>' { _ttype = NE; } )
> - | ( '=' { _ttype = LE; } ) )?
> - | "!=" ;
> -GT options { paraphrase = "greater than"; } : '>' ( '=' { _ttype = GE; } )? ;
> -
> -protected
> -LETTER options { paraphrase = "letter"; } : 'a' .. 'z';
> -
> -S_IDENTIFIER options { testLiterals = true; paraphrase = "identifier"; } : LETTER (DIGIT | LETTER | '_')* ;
>
> File [removed]: sd_internalnode.hpp
> Delta lines: +0 -44
> ===================================================================
> --- trunk/saga/impl/packages/sd/sd_internalnode.hpp 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sd_internalnode.hpp 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,44 +0,0 @@
> -#ifndef INC_SDINTERNALNODE_HPP__
> -
> -#define INC_SDINTERNALNODE_HPP__
> -
> -#include "antlr/CommonAST.hpp"
> -#include "sd_node.hpp"
> -#include <string>
> -
> -using namespace std;
> -
> -/** An internal node to represent OR / AND operator */
> -class sd_internalnode : public sd_node {
> -
> -public:
> -
> - sd_internalnode()
> - {
> - }
> -
> - static ANTLR_USE_NAMESPACE(antlr)RefAST factory( void )
> - {
> - ANTLR_USE_NAMESPACE(antlr)RefAST ret(new sd_internalnode());
> - return ret;
> - }
> -
> - void initialize(int t, const ANTLR_USE_NAMESPACE(std)string& txt)
> - {
> - CommonAST::initialize(t, txt);
> - }
> -
> - void initialize(ANTLR_USE_NAMESPACE(antlr)RefAST t)
> - {
> - CommonAST::initialize(t);
> - }
> - void initialize(ANTLR_USE_NAMESPACE(antlr)RefToken tok)
> - {
> - CommonAST::initialize(tok);
> - }
> -
> -};
> -
> -typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount<sd_internalnode> Refsd_internalnode;
> -
> -#endif
>
> File [removed]: sd_leafnode.hpp
> Delta lines: +0 -188
> ===================================================================
> --- trunk/saga/impl/packages/sd/sd_leafnode.hpp 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sd_leafnode.hpp 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,188 +0,0 @@
> -#ifndef INC_SDLEAFNODE_HPP__
> -#define INC_SDLEAFNODE_HPP__
> -
> -#include "antlr/CommonAST.hpp"
> -#include "sd_node.hpp"
> -#include <string>
> -#include <list>
> -
> -using namespace std;
> -
> -/** A leaf node to represent service comparison */
> -class sd_leafnode : public sd_node {
> -
> -public:
> - typedef enum
> - {
> - ANY_VALUE = 0,
> - ALL_VALUE
> - } ANYALLTYPE;
> -
> - sd_leafnode()
> - {
> - not_prefix = 0;
> - //Default to Any value for vector operations
> - setAnyAllValue(ANY_VALUE);
> -
> - //Default 'LIKE' escape char to '\0'
> - setEscapeChar('\0');
> - }
> -
> - void setRValue(const ANTLR_USE_NAMESPACE(std)string& rval)
> - {
> - rvalue = rval;
> - }
> -
> - void setLValue(int lval)
> - {
> - lvalue = lval;
> - }
> -
> - void setLKey(const ANTLR_USE_NAMESPACE(std)string& lk)
> - {
> - lkey = lk;
> - }
> -
> - void setRValNum(double rval)
> - {
> - rvalnum = rval;
> - }
> -
> - void setRValType(int rvtype)
> - {
> - rval_type = rvtype;
> - }
> -
> - void setOpType(int op)
> - {
> - op_type = op;
> - }
> -
> - void setNotPrefix()
> - {
> - not_prefix = 1;
> - }
> -
> - int getNotPrefix()
> - {
> - return not_prefix;
> - }
> -
> - ANTLR_USE_NAMESPACE(std)string getRValue()
> - {
> - return rvalue;
> - }
> -
> - ANTLR_USE_NAMESPACE(std)string getLKey()
> - {
> - return lkey;
> - }
> -
> - double getRValNum()
> - {
> - return rvalnum;
> - }
> -
> - int getLValue()
> - {
> - return lvalue;
> - }
> -
> - int getOpType()
> - {
> - return op_type;
> - }
> -
> - int getRValType()
> - {
> - return rval_type;
> - }
> -
> - std::size_t getListSize()
> - {
> - return in_list.size();
> - }
> -
> - void addListElement(const ANTLR_USE_NAMESPACE(std)string& val)
> - {
> - in_list.push_back(val);
> - }
> -
> - ANTLR_USE_NAMESPACE(std)string frontListElement()
> - {
> - ANTLR_USE_NAMESPACE(std)string s = "";
> -
> - if (in_list.size() > 0 )
> - { s = in_list.front();
> - }
> - return s;
> - }
> -
> - ANTLR_USE_NAMESPACE(std)string removeListElement()
> - {
> - ANTLR_USE_NAMESPACE(std)string s = "";
> -
> - if (in_list.size() > 0 )
> - { s = in_list.front();
> - in_list.pop_front();
> - }
> - return s;
> - }
> -
> - static ANTLR_USE_NAMESPACE(antlr)RefAST factory( void )
> - {
> - ANTLR_USE_NAMESPACE(antlr)RefAST ret(new sd_leafnode());
> - return ret;
> - }
> -
> -
> - void initialize(int t, const ANTLR_USE_NAMESPACE(std)string& txt)
> - {
> - CommonAST::initialize(t, txt);
> - }
> -
> - void initialize(ANTLR_USE_NAMESPACE(antlr)RefAST t)
> - {
> - CommonAST::initialize(t);
> - }
> - void initialize(ANTLR_USE_NAMESPACE(antlr)RefToken tok)
> - {
> - CommonAST::initialize(tok);
> - }
> -
> - ANYALLTYPE getAnyValue()
> - {
> - return AAValue;
> - }
> -
> - void setAnyAllValue(ANYALLTYPE AAVal)
> - {
> - AAValue = AAVal;
> - }
> -
> - char getEscapeChar()
> - {
> - return escapeChar;
> - }
> -
> - void setEscapeChar(char escChar)
> - {
> - escapeChar = escChar;
> - }
> -
> -private:
> - string rvalue; // Literal
> - int lvalue; // Service keyword token type
> - int op_type; // Operator token type
> - int rval_type; // GlueDataValue Type LITERAL or NUMBER?
> - double rvalnum; // GlueDataValue (Number)
> - string lkey; // GlueDataKey
> - list<string> in_list;// List of literals for IN operator
> - int not_prefix; // NOT prefix for IN and LIKE operator
> - ANYALLTYPE AAValue; // Is this working on any vector value
> - char escapeChar;
> -};
> -
> -typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount<sd_leafnode> Refsd_leafnode;
> -
> -#endif //INC_SD_LEAFNODE
>
> File [removed]: sd_lexer.cpp
> Delta lines: +0 -641
> ===================================================================
> --- trunk/saga/impl/packages/sd/sd_lexer.cpp 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sd_lexer.cpp 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,641 +0,0 @@
> -/* $ANTLR 2.7.7 (20081210): "sd_grammar.g" -> "sd_lexer.cpp"$ */
> -#include "sd_lexer.hpp"
> -#include <antlr/CharBuffer.hpp>
> -#include <antlr/TokenStreamException.hpp>
> -#include <antlr/TokenStreamIOException.hpp>
> -#include <antlr/TokenStreamRecognitionException.hpp>
> -#include <antlr/CharStreamException.hpp>
> -#include <antlr/CharStreamIOException.hpp>
> -#include <antlr/NoViableAltForCharException.hpp>
> -
> -#line 1 "sd_grammar.g"
> -#line 13 "sd_lexer.cpp"
> -sd_lexer::sd_lexer(ANTLR_USE_NAMESPACE(std)istream& in)
> - : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),false)
> -{
> - initLiterals();
> -}
> -
> -sd_lexer::sd_lexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
> - : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,false)
> -{
> - initLiterals();
> -}
> -
> -sd_lexer::sd_lexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
> - : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,false)
> -{
> - initLiterals();
> -}
> -
> -void sd_lexer::initLiterals()
> -{
> - literals["related_services"] = 17;
> - literals["type"] = 11;
> - literals["name"] = 12;
> - literals["like"] = 5;
> - literals["all"] = 18;
> - literals["site"] = 16;
> - literals["in"] = 4;
> - literals["or"] = 9;
> - literals["endpoint"] = 15;
> - literals["uid"] = 13;
> - literals["escape"] = 6;
> - literals["vo"] = 10;
> - literals["and"] = 8;
> - literals["not"] = 7;
> - literals["uri"] = 14;
> - literals["any"] = 19;
> -}
> -
> -ANTLR_USE_NAMESPACE(antlr)RefToken sd_lexer::nextToken()
> -{
> - ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
> - for (;;) {
> - ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
> - int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
> - resetText();
> - try { // for lexical and char stream error handling
> - switch ( LA(1)) {
> - case 0x9 /* '\t' */ :
> - case 0xa /* '\n' */ :
> - case 0xd /* '\r' */ :
> - case 0x20 /* ' ' */ :
> - {
> - mWS_(true);
> - theRetToken=_returnToken;
> - break;
> - }
> - case 0x28 /* '(' */ :
> - {
> - mLPAREN(true);
> - theRetToken=_returnToken;
> - break;
> - }
> - case 0x29 /* ')' */ :
> - {
> - mRPAREN(true);
> - theRetToken=_returnToken;
> - break;
> - }
> - case 0x2c /* ',' */ :
> - {
> - mCOMMA(true);
> - theRetToken=_returnToken;
> - break;
> - }
> - case 0x2e /* '.' */ :
> - case 0x30 /* '0' */ :
> - case 0x31 /* '1' */ :
> - case 0x32 /* '2' */ :
> - case 0x33 /* '3' */ :
> - case 0x34 /* '4' */ :
> - case 0x35 /* '5' */ :
> - case 0x36 /* '6' */ :
> - case 0x37 /* '7' */ :
> - case 0x38 /* '8' */ :
> - case 0x39 /* '9' */ :
> - {
> - mS_NUMBER(true);
> - theRetToken=_returnToken;
> - break;
> - }
> - case 0x27 /* '\'' */ :
> - {
> - mS_CHAR_LITERAL(true);
> - theRetToken=_returnToken;
> - break;
> - }
> - case 0x3d /* '=' */ :
> - {
> - mEQ(true);
> - theRetToken=_returnToken;
> - break;
> - }
> - case 0x21 /* '!' */ :
> - case 0x3c /* '<' */ :
> - {
> - mNE(true);
> - theRetToken=_returnToken;
> - break;
> - }
> - case 0x3e /* '>' */ :
> - {
> - mGT(true);
> - theRetToken=_returnToken;
> - break;
> - }
> - case 0x61 /* 'a' */ :
> - case 0x62 /* 'b' */ :
> - case 0x63 /* 'c' */ :
> - case 0x64 /* 'd' */ :
> - case 0x65 /* 'e' */ :
> - case 0x66 /* 'f' */ :
> - case 0x67 /* 'g' */ :
> - case 0x68 /* 'h' */ :
> - case 0x69 /* 'i' */ :
> - case 0x6a /* 'j' */ :
> - case 0x6b /* 'k' */ :
> - case 0x6c /* 'l' */ :
> - case 0x6d /* 'm' */ :
> - case 0x6e /* 'n' */ :
> - case 0x6f /* 'o' */ :
> - case 0x70 /* 'p' */ :
> - case 0x71 /* 'q' */ :
> - case 0x72 /* 'r' */ :
> - case 0x73 /* 's' */ :
> - case 0x74 /* 't' */ :
> - case 0x75 /* 'u' */ :
> - case 0x76 /* 'v' */ :
> - case 0x77 /* 'w' */ :
> - case 0x78 /* 'x' */ :
> - case 0x79 /* 'y' */ :
> - case 0x7a /* 'z' */ :
> - {
> - mS_IDENTIFIER(true);
> - theRetToken=_returnToken;
> - break;
> - }
> - default:
> - {
> - if (LA(1)==EOF_CHAR)
> - {
> - uponEOF();
> - _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
> - }
> - else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
> - }
> - }
> - if ( !_returnToken )
> - goto tryAgain; // found SKIP token
> -
> - _ttype = _returnToken->getType();
> - _returnToken->setType(_ttype);
> - return _returnToken;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) {
> - throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e);
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) {
> - throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io);
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) {
> - throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage());
> - }
> -tryAgain:;
> - }
> -}
> -
> -void sd_lexer::mWS_(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = WS_;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - {
> - switch ( LA(1)) {
> - case 0x20 /* ' ' */ :
> - {
> - match(' ' /* charlit */ );
> - break;
> - }
> - case 0x9 /* '\t' */ :
> - {
> - match('\t' /* charlit */ );
> - break;
> - }
> - case 0xa /* '\n' */ :
> - {
> - match('\n' /* charlit */ );
> - break;
> - }
> - case 0xd /* '\r' */ :
> - {
> - match('\r' /* charlit */ );
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
> - }
> - }
> - }
> -#line 482 "sd_grammar.g"
> - _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
> -#line 225 "sd_lexer.cpp"
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mLPAREN(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = LPAREN;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - match('(' /* charlit */ );
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mRPAREN(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = RPAREN;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - match(')' /* charlit */ );
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mCOMMA(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = COMMA;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - match(',' /* charlit */ );
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mDIGIT(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = DIGIT;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - matchRange('0','9');
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mINTEGER(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = INTEGER;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - { // ( ... )+
> - int _cnt58=0;
> - for (;;) {
> - if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
> - mDIGIT(false);
> - }
> - else {
> - if ( _cnt58>=1 ) { goto _loop58; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
> - }
> -
> - _cnt58++;
> - }
> - _loop58:;
> - } // ( ... )+
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mFLOAT(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = FLOAT;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - switch ( LA(1)) {
> - case 0x30 /* '0' */ :
> - case 0x31 /* '1' */ :
> - case 0x32 /* '2' */ :
> - case 0x33 /* '3' */ :
> - case 0x34 /* '4' */ :
> - case 0x35 /* '5' */ :
> - case 0x36 /* '6' */ :
> - case 0x37 /* '7' */ :
> - case 0x38 /* '8' */ :
> - case 0x39 /* '9' */ :
> - {
> - mINTEGER(false);
> - {
> - if ((LA(1) == 0x2e /* '.' */ )) {
> - match('.' /* charlit */ );
> - mINTEGER(false);
> - }
> - else {
> - }
> -
> - }
> - break;
> - }
> - case 0x2e /* '.' */ :
> - {
> - match('.' /* charlit */ );
> - mINTEGER(false);
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
> - }
> - }
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mS_NUMBER(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = S_NUMBER;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - mFLOAT(false);
> - {
> - if ((LA(1) == 0x65 /* 'e' */ )) {
> - {
> - match('e' /* charlit */ );
> - }
> - {
> - switch ( LA(1)) {
> - case 0x2b /* '+' */ :
> - {
> - match('+' /* charlit */ );
> - break;
> - }
> - case 0x2d /* '-' */ :
> - {
> - match('-' /* charlit */ );
> - break;
> - }
> - case 0x2e /* '.' */ :
> - case 0x30 /* '0' */ :
> - case 0x31 /* '1' */ :
> - case 0x32 /* '2' */ :
> - case 0x33 /* '3' */ :
> - case 0x34 /* '4' */ :
> - case 0x35 /* '5' */ :
> - case 0x36 /* '6' */ :
> - case 0x37 /* '7' */ :
> - case 0x38 /* '8' */ :
> - case 0x39 /* '9' */ :
> - {
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
> - }
> - }
> - }
> - mFLOAT(false);
> - }
> - else {
> - }
> -
> - }
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mS_CHAR_LITERAL(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = S_CHAR_LITERAL;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - match('\'' /* charlit */ );
> - { // ( ... )*
> - for (;;) {
> - if ((_tokenSet_0.member(LA(1)))) {
> - matchNot('\'' /* charlit */ );
> - }
> - else {
> - goto _loop67;
> - }
> -
> - }
> - _loop67:;
> - } // ( ... )*
> - match('\'' /* charlit */ );
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mEQ(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = EQ;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - match('=' /* charlit */ );
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mNE(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = NE;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - switch ( LA(1)) {
> - case 0x3c /* '<' */ :
> - {
> - match('<' /* charlit */ );
> -#line 505 "sd_grammar.g"
> - _ttype = LESS;
> -#line 474 "sd_lexer.cpp"
> - {
> - switch ( LA(1)) {
> - case 0x3e /* '>' */ :
> - {
> - {
> - match('>' /* charlit */ );
> -#line 506 "sd_grammar.g"
> - _ttype = NE;
> -#line 483 "sd_lexer.cpp"
> - }
> - break;
> - }
> - case 0x3d /* '=' */ :
> - {
> - {
> - match('=' /* charlit */ );
> -#line 507 "sd_grammar.g"
> - _ttype = LE;
> -#line 493 "sd_lexer.cpp"
> - }
> - break;
> - }
> - default:
> - {
> - }
> - }
> - }
> - break;
> - }
> - case 0x21 /* '!' */ :
> - {
> - match("!=");
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
> - }
> - }
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mGT(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = GT;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - match('>' /* charlit */ );
> - {
> - if ((LA(1) == 0x3d /* '=' */ )) {
> - match('=' /* charlit */ );
> -#line 509 "sd_grammar.g"
> - _ttype = GE;
> -#line 533 "sd_lexer.cpp"
> - }
> - else {
> - }
> -
> - }
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mLETTER(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = LETTER;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - matchRange('a','z');
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -void sd_lexer::mS_IDENTIFIER(bool _createToken) {
> - int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
> - _ttype = S_IDENTIFIER;
> - ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
> -
> - mLETTER(false);
> - { // ( ... )*
> - for (;;) {
> - switch ( LA(1)) {
> - case 0x30 /* '0' */ :
> - case 0x31 /* '1' */ :
> - case 0x32 /* '2' */ :
> - case 0x33 /* '3' */ :
> - case 0x34 /* '4' */ :
> - case 0x35 /* '5' */ :
> - case 0x36 /* '6' */ :
> - case 0x37 /* '7' */ :
> - case 0x38 /* '8' */ :
> - case 0x39 /* '9' */ :
> - {
> - mDIGIT(false);
> - break;
> - }
> - case 0x61 /* 'a' */ :
> - case 0x62 /* 'b' */ :
> - case 0x63 /* 'c' */ :
> - case 0x64 /* 'd' */ :
> - case 0x65 /* 'e' */ :
> - case 0x66 /* 'f' */ :
> - case 0x67 /* 'g' */ :
> - case 0x68 /* 'h' */ :
> - case 0x69 /* 'i' */ :
> - case 0x6a /* 'j' */ :
> - case 0x6b /* 'k' */ :
> - case 0x6c /* 'l' */ :
> - case 0x6d /* 'm' */ :
> - case 0x6e /* 'n' */ :
> - case 0x6f /* 'o' */ :
> - case 0x70 /* 'p' */ :
> - case 0x71 /* 'q' */ :
> - case 0x72 /* 'r' */ :
> - case 0x73 /* 's' */ :
> - case 0x74 /* 't' */ :
> - case 0x75 /* 'u' */ :
> - case 0x76 /* 'v' */ :
> - case 0x77 /* 'w' */ :
> - case 0x78 /* 'x' */ :
> - case 0x79 /* 'y' */ :
> - case 0x7a /* 'z' */ :
> - {
> - mLETTER(false);
> - break;
> - }
> - case 0x5f /* '_' */ :
> - {
> - match('_' /* charlit */ );
> - break;
> - }
> - default:
> - {
> - goto _loop78;
> - }
> - }
> - }
> - _loop78:;
> - } // ( ... )*
> - _ttype = testLiteralsTable(_ttype);
> - if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
> - _token = makeToken(_ttype);
> - _token->setText(text.substr(_begin, text.length()-_begin));
> - }
> - _returnToken = _token;
> - _saveIndex=0;
> -}
> -
> -
> -const unsigned long sd_lexer::_tokenSet_0_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
> -// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
> -// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
> -// 0x1f ! \" # $ % &
> -const ANTLR_USE_NAMESPACE(antlr)BitSet sd_lexer::_tokenSet_0(_tokenSet_0_data_,8);
> -
>
> File [removed]: sd_lexer.hpp
> Delta lines: +0 -59
> ===================================================================
> --- trunk/saga/impl/packages/sd/sd_lexer.hpp 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sd_lexer.hpp 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,59 +0,0 @@
> -#ifndef INC_sd_lexer_hpp_
> -#define INC_sd_lexer_hpp_
> -
> -#include <antlr/config.hpp>
> -/* $ANTLR 2.7.7 (20081210): "sd_grammar.g" -> "sd_lexer.hpp"$ */
> -#include <antlr/CommonToken.hpp>
> -#include <antlr/InputBuffer.hpp>
> -#include <antlr/BitSet.hpp>
> -#include "sdTokenTypes.hpp"
> -#include <antlr/CharScanner.hpp>
> -#line 2 "sd_grammar.g"
> -
> - #include "sd_leafnode.hpp"
> - #include "sd_internalnode.hpp"
> - #include <iostream>
> - #include <string>
> - #include <list>
> - #include <math.h>
> - #include <utility>
> - using namespace std;
> -
> -#line 23 "sd_lexer.hpp"
> -class CUSTOM_API sd_lexer : public ANTLR_USE_NAMESPACE(antlr)CharScanner, public sdTokenTypes
> -{
> -#line 1 "sd_grammar.g"
> -#line 27 "sd_lexer.hpp"
> -private:
> - void initLiterals();
> -public:
> - bool getCaseSensitiveLiterals() const
> - {
> - return false;
> - }
> -public:
> - sd_lexer(ANTLR_USE_NAMESPACE(std)istream& in);
> - sd_lexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib);
> - sd_lexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state);
> - ANTLR_USE_NAMESPACE(antlr)RefToken nextToken();
> - public: void mWS_(bool _createToken);
> - public: void mLPAREN(bool _createToken);
> - public: void mRPAREN(bool _createToken);
> - public: void mCOMMA(bool _createToken);
> - protected: void mDIGIT(bool _createToken);
> - protected: void mINTEGER(bool _createToken);
> - protected: void mFLOAT(bool _createToken);
> - public: void mS_NUMBER(bool _createToken);
> - public: void mS_CHAR_LITERAL(bool _createToken);
> - public: void mEQ(bool _createToken);
> - public: void mNE(bool _createToken);
> - public: void mGT(bool _createToken);
> - protected: void mLETTER(bool _createToken);
> - public: void mS_IDENTIFIER(bool _createToken);
> -private:
> -
> - static const unsigned long _tokenSet_0_data_[];
> - static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0;
> -};
> -
> -#endif /*INC_sd_lexer_hpp_*/
>
> File [removed]: sd_node.hpp
> Delta lines: +0 -34
> ===================================================================
> --- trunk/saga/impl/packages/sd/sd_node.hpp 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sd_node.hpp 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,34 +0,0 @@
> -#ifndef INC_SDNODE_HPP__
> -
> -#define INC_SDNODE_HPP__
> -
> -#include "antlr/CommonAST.hpp"
> -
> -using namespace std;
> -
> -/** Base class for ANTLR Tree nodes */
> -class sd_node : public ANTLR_USE_NAMESPACE(antlr)CommonAST {
> -
> -public:
> -
> - sd_node()
> - {
> - }
> -
> - void setEvalResult(bool res)
> - {
> - eval_result = res;
> - }
> -
> - bool getEvalResult()
> - {
> - return eval_result;
> - }
> -
> -protected:
> - bool eval_result;
> -};
> -
> -typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount<sd_node> Refsd_node;
> -
> -#endif
>
> File [removed]: sd_parser.cpp
> Delta lines: +0 -1653
> ===================================================================
> --- trunk/saga/impl/packages/sd/sd_parser.cpp 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sd_parser.cpp 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,1653 +0,0 @@
> -/* $ANTLR 2.7.7 (20081210): "sd_grammar.g" -> "sd_parser.cpp"$ */
> -#include "sd_parser.hpp"
> -#include <antlr/NoViableAltException.hpp>
> -#include <antlr/SemanticException.hpp>
> -#include <antlr/ASTFactory.hpp>
> -#line 1 "sd_grammar.g"
> -#line 8 "sd_parser.cpp"
> -sd_parser::sd_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
> -: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
> -{
> -}
> -
> -sd_parser::sd_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
> -: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,3)
> -{
> -}
> -
> -sd_parser::sd_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
> -: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
> -{
> -}
> -
> -sd_parser::sd_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
> -: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,3)
> -{
> -}
> -
> -sd_parser::sd_parser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
> -: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,3)
> -{
> -}
> -
> -int sd_parser::service_keyword() {
> -#line 49 "sd_grammar.g"
> - int tok_type = 0;
> -#line 37 "sd_parser.cpp"
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST service_keyword_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken k1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST k1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken k2 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST k2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken k3 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST k3_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken k4 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST k4_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken k5 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST k5_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken k6 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST k6_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken k7 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST k7_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - switch ( LA(1)) {
> - case K_TYPE:
> - {
> - k1 = LT(1);
> - k1_AST = astFactory->create(k1);
> - match(K_TYPE);
> -#line 50 "sd_grammar.g"
> - tok_type = k1->getType();
> -#line 65 "sd_parser.cpp"
> - break;
> - }
> - case K_NAME:
> - {
> - k2 = LT(1);
> - k2_AST = astFactory->create(k2);
> - match(K_NAME);
> -#line 51 "sd_grammar.g"
> - tok_type = k2->getType();
> -#line 75 "sd_parser.cpp"
> - break;
> - }
> - case K_SITE:
> - {
> - k3 = LT(1);
> - k3_AST = astFactory->create(k3);
> - match(K_SITE);
> -#line 52 "sd_grammar.g"
> - tok_type = k3->getType();
> -#line 85 "sd_parser.cpp"
> - break;
> - }
> - case K_ENDPOINT:
> - {
> - k4 = LT(1);
> - k4_AST = astFactory->create(k4);
> - match(K_ENDPOINT);
> -#line 53 "sd_grammar.g"
> - tok_type = k4->getType();
> -#line 95 "sd_parser.cpp"
> - break;
> - }
> - case K_SERVICE:
> - {
> - k5 = LT(1);
> - k5_AST = astFactory->create(k5);
> - match(K_SERVICE);
> -#line 54 "sd_grammar.g"
> - tok_type = k5->getType();
> -#line 105 "sd_parser.cpp"
> - break;
> - }
> - case K_UID:
> - {
> - k6 = LT(1);
> - k6_AST = astFactory->create(k6);
> - match(K_UID);
> -#line 55 "sd_grammar.g"
> - tok_type = k6->getType();
> -#line 115 "sd_parser.cpp"
> - break;
> - }
> - case K_URI:
> - {
> - k7 = LT(1);
> - k7_AST = astFactory->create(k7);
> - match(K_URI);
> -#line 56 "sd_grammar.g"
> - tok_type = k7->getType();
> -#line 125 "sd_parser.cpp"
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_0);
> - }
> - returnAST = service_keyword_AST;
> - return tok_type;
> -}
> -
> -void sd_parser::service_filter() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST service_filter_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - service_filter_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - service_filter_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_1);
> - }
> - returnAST = service_filter_AST;
> -}
> -
> -void sd_parser::service_filter_expression() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST service_filter_expression_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - service_and_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - { // ( ... )*
> - for (;;) {
> - if ((LA(1) == K_OR)) {
> - Refsd_internalnode tmp1_AST = Refsd_internalnode(ANTLR_USE_NAMESPACE(antlr)nullAST);
> - tmp1_AST = astFactory->create(LT(1));
> - astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp1_AST));
> - match(K_OR);
> - service_and_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - }
> - else {
> - goto _loop5;
> - }
> -
> - }
> - _loop5:;
> - } // ( ... )*
> - service_filter_expression_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_2);
> - }
> - returnAST = service_filter_expression_AST;
> -}
> -
> -void sd_parser::service_and_expression() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST service_and_expression_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - service_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - { // ( ... )*
> - for (;;) {
> - if ((LA(1) == K_AND)) {
> - Refsd_internalnode tmp2_AST = Refsd_internalnode(ANTLR_USE_NAMESPACE(antlr)nullAST);
> - tmp2_AST = astFactory->create(LT(1));
> - astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp2_AST));
> - match(K_AND);
> - service_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - }
> - else {
> - goto _loop8;
> - }
> -
> - }
> - _loop8:;
> - } // ( ... )*
> - service_and_expression_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_3);
> - }
> - returnAST = service_and_expression_AST;
> -}
> -
> -void sd_parser::service_expression() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST service_expression_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken rval = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST rval_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -#line 65 "sd_grammar.g"
> - int knot = 0; int lhs; int op;
> - std::pair<std::string, char> rhs;
> - std::list<std::string> slist;
> - std::string s;
> - Refsd_leafnode myRef;
> -
> -#line 240 "sd_parser.cpp"
> -
> - try { // for error handling
> - {
> - if (((LA(1) >= K_TYPE && LA(1) <= K_SERVICE)) && (LA(2) == K_IN || LA(2) == K_NOT) && (LA(3) == K_IN || LA(3) == LPAREN)) {
> - lhs=service_keyword();
> - astFactory->addASTChild( currentAST, returnAST );
> - {
> - switch ( LA(1)) {
> - case K_NOT:
> - {
> - match(K_NOT);
> -#line 73 "sd_grammar.g"
> - knot=1;
> -#line 254 "sd_parser.cpp"
> - break;
> - }
> - case K_IN:
> - {
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - match(K_IN);
> - slist=in_clause();
> - astFactory->addASTChild( currentAST, returnAST );
> - service_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
> -#line 74 "sd_grammar.g"
> -
> - service_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(1))->add(astFactory->create(SVC_CMP))));
> - myRef = (Refsd_leafnode)service_expression_AST;
> - myRef->setLValue(lhs);
> - myRef->setOpType(K_IN);
> - myRef->setRValType(K_STRING_LIST);
> -
> - while (slist.size() > 0)
> - {
> - s = slist.front();
> - myRef->addListElement(s);
> - slist.pop_front();
> - }
> -
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> - //std::cout << "front list element : "
> - // << myRef->frontListElement() << endl;
> - //std::cout << "list size : "
> - // << myRef->getListSize() << endl;
> - //std::cout << "in clause parsed" << endl;
> -
> -#line 296 "sd_parser.cpp"
> - currentAST.root = service_expression_AST;
> - if ( service_expression_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&
> - service_expression_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST )
> - currentAST.child = service_expression_AST->getFirstChild();
> - else
> - currentAST.child = service_expression_AST;
> - currentAST.advanceChildToEnd();
> - }
> - else if (((LA(1) >= K_TYPE && LA(1) <= K_SERVICE)) && (LA(2) == K_LIKE || LA(2) == K_NOT) && (LA(3) == K_LIKE || LA(3) == S_CHAR_LITERAL)) {
> - lhs=service_keyword();
> - astFactory->addASTChild( currentAST, returnAST );
> - {
> - switch ( LA(1)) {
> - case K_NOT:
> - {
> - match(K_NOT);
> -#line 99 "sd_grammar.g"
> - knot = 1;
> -#line 315 "sd_parser.cpp"
> - break;
> - }
> - case K_LIKE:
> - {
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - match(K_LIKE);
> - rhs=like_clause();
> - astFactory->addASTChild( currentAST, returnAST );
> - service_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
> -#line 100 "sd_grammar.g"
> -
> - service_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(1))->add(astFactory->create(SVC_CMP))));
> - myRef = (Refsd_leafnode)service_expression_AST;
> - myRef->setLValue(lhs);
> - myRef->setOpType(K_LIKE);
> - myRef->setRValue(rhs.first);
> -
> - //Set the escape character
> - //for the 'LIKE' clause
> - myRef->setEscapeChar(rhs.second);
> -
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> -
> -#line 349 "sd_parser.cpp"
> - currentAST.root = service_expression_AST;
> - if ( service_expression_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&
> - service_expression_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST )
> - currentAST.child = service_expression_AST->getFirstChild();
> - else
> - currentAST.child = service_expression_AST;
> - currentAST.advanceChildToEnd();
> - }
> - else if (((LA(1) >= K_TYPE && LA(1) <= K_SERVICE)) && (LA(2) == NE || LA(2) == EQ)) {
> - lhs=service_keyword();
> - astFactory->addASTChild( currentAST, returnAST );
> - op=eqop();
> - astFactory->addASTChild( currentAST, returnAST );
> - rval = LT(1);
> - rval_AST = astFactory->create(rval);
> - match(S_CHAR_LITERAL);
> - service_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
> -#line 118 "sd_grammar.g"
> -
> - service_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(1))->add(astFactory->create(SVC_CMP))));
> - myRef = (Refsd_leafnode)service_expression_AST;
> - myRef->setLValue(lhs);
> - //std::cout << "keyword type " << lhs << endl;
> - myRef->setOpType(op);
> - //std::cout << "op type " << op << endl;
> - myRef->setRValue(rval->getText());
> - //std::cout << "literal " << rval->getText() << endl;
> -
> -#line 378 "sd_parser.cpp"
> - currentAST.root = service_expression_AST;
> - if ( service_expression_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&
> - service_expression_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST )
> - currentAST.child = service_expression_AST->getFirstChild();
> - else
> - currentAST.child = service_expression_AST;
> - currentAST.advanceChildToEnd();
> - }
> - else if ((LA(1) == LPAREN)) {
> - match(LPAREN);
> - service_filter_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - match(RPAREN);
> - }
> - else {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> -
> - }
> - service_expression_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_4);
> - }
> - returnAST = service_expression_AST;
> -}
> -
> -std::list<std::string> sd_parser::in_clause() {
> -#line 157 "sd_grammar.g"
> - std::list<std::string> slist;
> -#line 410 "sd_parser.cpp"
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST in_clause_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - slist=bracketed_list();
> - astFactory->addASTChild( currentAST, returnAST );
> - in_clause_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_4);
> - }
> - returnAST = in_clause_AST;
> - return slist;
> -}
> -
> -pair<string, char> sd_parser::like_clause() {
> -#line 133 "sd_grammar.g"
> - pair<string, char> s;
> -#line 431 "sd_parser.cpp"
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST like_clause_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken rhs = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST rhs_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken esc = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST esc_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - rhs = LT(1);
> - rhs_AST = astFactory->create(rhs);
> - match(S_CHAR_LITERAL);
> -#line 135 "sd_grammar.g"
> -
> - s.first = rhs->getText();
> - s.second = '\0';
> -
> -#line 449 "sd_parser.cpp"
> - {
> - switch ( LA(1)) {
> - case K_ESCAPE:
> - {
> - ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - tmp9_AST = astFactory->create(LT(1));
> - astFactory->addASTChild(currentAST, tmp9_AST);
> - match(K_ESCAPE);
> - esc = LT(1);
> - esc_AST = astFactory->create(esc);
> - match(S_CHAR_LITERAL);
> -#line 140 "sd_grammar.g"
> -
> - //Check there are at least three characters
> - //to allow for the quotes
> - if ( esc->getText().size() > 2 )
> - {
> - //Character [1] to allow for the quote
> - s.second = esc->getText()[1];
> - }
> -
> - else
> - {
> - s.second = '\0';
> - }
> -
> -#line 476 "sd_parser.cpp"
> - break;
> - }
> - case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE:
> - case K_AND:
> - case K_OR:
> - case RPAREN:
> - {
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - like_clause_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_4);
> - }
> - returnAST = like_clause_AST;
> - return s;
> -}
> -
> -int sd_parser::eqop() {
> -#line 311 "sd_grammar.g"
> - int tok_type = 0;
> -#line 505 "sd_parser.cpp"
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST eqop_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken o1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST o1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken o2 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST o2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - switch ( LA(1)) {
> - case NE:
> - {
> - o1 = LT(1);
> - o1_AST = astFactory->create(o1);
> - match(NE);
> -#line 312 "sd_grammar.g"
> - tok_type = o1->getType();
> -#line 523 "sd_parser.cpp"
> - eqop_AST = currentAST.root;
> - break;
> - }
> - case EQ:
> - {
> - o2 = LT(1);
> - o2_AST = astFactory->create(o2);
> - match(EQ);
> -#line 313 "sd_grammar.g"
> - tok_type = o2->getType();
> -#line 534 "sd_parser.cpp"
> - eqop_AST = currentAST.root;
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_5);
> - }
> - returnAST = eqop_AST;
> - return tok_type;
> -}
> -
> -std::list<std::string> sd_parser::bracketed_list() {
> -#line 163 "sd_grammar.g"
> - std::list<std::string> slist;
> -#line 555 "sd_parser.cpp"
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST bracketed_list_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken lit = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST lit_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken num = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST num_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken lit2 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST lit2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken num2 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST num2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - tmp10_AST = astFactory->create(LT(1));
> - astFactory->addASTChild(currentAST, tmp10_AST);
> - match(LPAREN);
> - {
> - switch ( LA(1)) {
> - case S_CHAR_LITERAL:
> - {
> - lit = LT(1);
> - lit_AST = astFactory->create(lit);
> - match(S_CHAR_LITERAL);
> -#line 166 "sd_grammar.g"
> - slist.push_back(lit->getText());
> -#line 582 "sd_parser.cpp"
> - break;
> - }
> - case S_NUMBER:
> - {
> - num = LT(1);
> - num_AST = astFactory->create(num);
> - match(S_NUMBER);
> -#line 167 "sd_grammar.g"
> - slist.push_back(num->getText());
> -#line 592 "sd_parser.cpp"
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - { // ( ... )*
> - for (;;) {
> - if ((LA(1) == COMMA)) {
> - match(COMMA);
> - {
> - switch ( LA(1)) {
> - case S_CHAR_LITERAL:
> - {
> - lit2 = LT(1);
> - lit2_AST = astFactory->create(lit2);
> - match(S_CHAR_LITERAL);
> -#line 169 "sd_grammar.g"
> - slist.push_back(lit2->getText());
> -#line 614 "sd_parser.cpp"
> - break;
> - }
> - case S_NUMBER:
> - {
> - num2 = LT(1);
> - num2_AST = astFactory->create(num2);
> - match(S_NUMBER);
> -#line 170 "sd_grammar.g"
> - slist.push_back(num2->getText());
> -#line 624 "sd_parser.cpp"
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - }
> - else {
> - goto _loop20;
> - }
> -
> - }
> - _loop20:;
> - } // ( ... )*
> - ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - tmp12_AST = astFactory->create(LT(1));
> - astFactory->addASTChild(currentAST, tmp12_AST);
> - match(RPAREN);
> - bracketed_list_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_4);
> - }
> - returnAST = bracketed_list_AST;
> - return slist;
> -}
> -
> -void sd_parser::string_literal_list() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST string_literal_list_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken lit = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST lit_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken lit2 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST lit2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - lit = LT(1);
> - lit_AST = astFactory->create(lit);
> - match(S_CHAR_LITERAL);
> - { // ( ... )*
> - for (;;) {
> - if ((LA(1) == COMMA)) {
> - match(COMMA);
> - lit2 = LT(1);
> - lit2_AST = astFactory->create(lit2);
> - match(S_CHAR_LITERAL);
> -#line 181 "sd_grammar.g"
> -
> - //s = s + "," + lit2->getText();
> - //std::cout << myRef->getListSize() <<endl;
> - //myRef->addListElement(lit2->getText());
> - //std::cout << lit2->getText() <<endl;
> -
> -#line 682 "sd_parser.cpp"
> - }
> - else {
> - goto _loop23;
> - }
> -
> - }
> - _loop23:;
> - } // ( ... )*
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_1);
> - }
> - returnAST = string_literal_list_AST;
> -}
> -
> -void sd_parser::vo_filter() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST vo_filter_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - vo_filter_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - vo_filter_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_1);
> - }
> - returnAST = vo_filter_AST;
> -}
> -
> -void sd_parser::vo_filter_expression() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST vo_filter_expression_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - vo_and_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - { // ( ... )*
> - for (;;) {
> - if ((LA(1) == K_OR)) {
> - Refsd_internalnode tmp14_AST = Refsd_internalnode(ANTLR_USE_NAMESPACE(antlr)nullAST);
> - tmp14_AST = astFactory->create(LT(1));
> - astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp14_AST));
> - match(K_OR);
> - vo_and_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - }
> - else {
> - goto _loop27;
> - }
> -
> - }
> - _loop27:;
> - } // ( ... )*
> - vo_filter_expression_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_2);
> - }
> - returnAST = vo_filter_expression_AST;
> -}
> -
> -void sd_parser::vo_and_expression() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST vo_and_expression_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - vo_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - { // ( ... )*
> - for (;;) {
> - if ((LA(1) == K_AND)) {
> - Refsd_internalnode tmp15_AST = Refsd_internalnode(ANTLR_USE_NAMESPACE(antlr)nullAST);
> - tmp15_AST = astFactory->create(LT(1));
> - astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp15_AST));
> - match(K_AND);
> - vo_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - }
> - else {
> - goto _loop30;
> - }
> -
> - }
> - _loop30:;
> - } // ( ... )*
> - vo_and_expression_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_3);
> - }
> - returnAST = vo_and_expression_AST;
> -}
> -
> -void sd_parser::vo_expression() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST vo_expression_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken rval = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST rval_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -#line 198 "sd_grammar.g"
> -
> - bool allVal = false;
> - bool anyVal = false;
> - int knot = 0;
> - int op;
> - string rhs;
> - string comp;
> - string s;
> - Refsd_leafnode myRef;
> - list<string> slist;
> - std::pair<std::string, char> rhsLike;
> -
> -#line 803 "sd_parser.cpp"
> -
> - try { // for error handling
> - if ((LA(1) == K_VO || LA(1) == K_ALL || LA(1) == K_ANY) && (LA(2) == K_IN || LA(2) == K_NOT || LA(2) == K_VO) && (LA(3) == K_IN || LA(3) == K_NOT || LA(3) == LPAREN)) {
> - {
> - switch ( LA(1)) {
> - case K_ANY:
> - {
> - match(K_ANY);
> -#line 212 "sd_grammar.g"
> - anyVal = true;
> -#line 814 "sd_parser.cpp"
> - break;
> - }
> - case K_ALL:
> - {
> - match(K_ALL);
> -#line 213 "sd_grammar.g"
> - allVal = true;
> -#line 822 "sd_parser.cpp"
> - break;
> - }
> - case K_VO:
> - {
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - match(K_VO);
> - {
> - switch ( LA(1)) {
> - case K_NOT:
> - {
> - match(K_NOT);
> -#line 215 "sd_grammar.g"
> - knot=1;
> -#line 843 "sd_parser.cpp"
> - break;
> - }
> - case K_IN:
> - {
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - match(K_IN);
> - slist=in_clause();
> - astFactory->addASTChild( currentAST, returnAST );
> - vo_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
> -#line 216 "sd_grammar.g"
> -
> - vo_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(1))->add(astFactory->create(SVC_CMP))));
> - myRef = (Refsd_leafnode)vo_expression_AST;
> - myRef->setLValue(K_VO);
> - myRef->setOpType(K_IN);
> - myRef->setRValType(K_STRING_LIST);
> -
> - while ( slist.size() > 0 )
> - {
> - s = slist.front();
> - myRef->addListElement(s);
> - slist.pop_front();
> - }
> -
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> -
> -#line 891 "sd_parser.cpp"
> - currentAST.root = vo_expression_AST;
> - if ( vo_expression_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&
> - vo_expression_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST )
> - currentAST.child = vo_expression_AST->getFirstChild();
> - else
> - currentAST.child = vo_expression_AST;
> - currentAST.advanceChildToEnd();
> - vo_expression_AST = currentAST.root;
> - }
> - else if ((LA(1) == K_VO) && (LA(2) == K_LIKE || LA(2) == K_NOT) && (LA(3) == K_LIKE || LA(3) == S_CHAR_LITERAL)) {
> - match(K_VO);
> - {
> - switch ( LA(1)) {
> - case K_NOT:
> - {
> - match(K_NOT);
> -#line 247 "sd_grammar.g"
> - knot = 1;
> -#line 910 "sd_parser.cpp"
> - break;
> - }
> - case K_LIKE:
> - {
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - tmp23_AST = astFactory->create(LT(1));
> - astFactory->addASTChild(currentAST, tmp23_AST);
> - match(K_LIKE);
> - rhsLike=like_clause();
> - astFactory->addASTChild( currentAST, returnAST );
> - vo_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
> -#line 248 "sd_grammar.g"
> -
> - vo_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(1))->add(astFactory->create(SVC_CMP))));
> - myRef = (Refsd_leafnode)vo_expression_AST;
> - myRef->setLValue(K_VO);
> - myRef->setOpType(K_LIKE);
> - myRef->setRValue(rhsLike.first);
> -
> - //Set the escape character
> - //for the 'LIKE' clause
> - myRef->setEscapeChar(rhsLike.second);
> -
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> -
> -#line 958 "sd_parser.cpp"
> - currentAST.root = vo_expression_AST;
> - if ( vo_expression_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&
> - vo_expression_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST )
> - currentAST.child = vo_expression_AST->getFirstChild();
> - else
> - currentAST.child = vo_expression_AST;
> - currentAST.advanceChildToEnd();
> - vo_expression_AST = currentAST.root;
> - }
> - else if ((LA(1) == K_VO) && (LA(2) == NE || LA(2) == EQ)) {
> - match(K_VO);
> - op=eqop();
> - astFactory->addASTChild( currentAST, returnAST );
> - rval = LT(1);
> - rval_AST = astFactory->create(rval);
> - match(S_CHAR_LITERAL);
> - vo_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
> -#line 277 "sd_grammar.g"
> -
> - vo_expression_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(1))->add(astFactory->create(SVC_CMP))));
> - myRef = (Refsd_leafnode)vo_expression_AST;
> - myRef->setLValue(K_VO);
> - myRef->setOpType(op);
> - myRef->setRValue(rval->getText());
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> -
> -#line 995 "sd_parser.cpp"
> - currentAST.root = vo_expression_AST;
> - if ( vo_expression_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&
> - vo_expression_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST )
> - currentAST.child = vo_expression_AST->getFirstChild();
> - else
> - currentAST.child = vo_expression_AST;
> - currentAST.advanceChildToEnd();
> - vo_expression_AST = currentAST.root;
> - }
> - else if ((LA(1) == LPAREN)) {
> - match(LPAREN);
> - vo_filter_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - match(RPAREN);
> - vo_expression_AST = currentAST.root;
> - }
> - else {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> -
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_4);
> - }
> - returnAST = vo_expression_AST;
> -}
> -
> -void sd_parser::data_filter() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST data_filter_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - data_filter_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - data_filter_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_1);
> - }
> - returnAST = data_filter_AST;
> -}
> -
> -void sd_parser::data_filter_expression() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST data_filter_expression_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - data_and_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - { // ( ... )*
> - for (;;) {
> - if ((LA(1) == K_OR)) {
> - Refsd_internalnode tmp27_AST = Refsd_internalnode(ANTLR_USE_NAMESPACE(antlr)nullAST);
> - tmp27_AST = astFactory->create(LT(1));
> - astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp27_AST));
> - match(K_OR);
> - data_and_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - }
> - else {
> - goto _loop38;
> - }
> -
> - }
> - _loop38:;
> - } // ( ... )*
> - data_filter_expression_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_2);
> - }
> - returnAST = data_filter_expression_AST;
> -}
> -
> -void sd_parser::data_and_expression() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST data_and_expression_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - data_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - { // ( ... )*
> - for (;;) {
> - if ((LA(1) == K_AND)) {
> - Refsd_internalnode tmp28_AST = Refsd_internalnode(ANTLR_USE_NAMESPACE(antlr)nullAST);
> - tmp28_AST = astFactory->create(LT(1));
> - astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp28_AST));
> - match(K_AND);
> - data_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - }
> - else {
> - goto _loop41;
> - }
> -
> - }
> - _loop41:;
> - } // ( ... )*
> - data_and_expression_AST = currentAST.root;
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_3);
> - }
> - returnAST = data_and_expression_AST;
> -}
> -
> -void sd_parser::data_expression() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST data_expression_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - switch ( LA(1)) {
> - case K_ALL:
> - case K_ANY:
> - case S_IDENTIFIER:
> - {
> - data_comparison();
> - astFactory->addASTChild( currentAST, returnAST );
> - data_expression_AST = currentAST.root;
> - break;
> - }
> - case LPAREN:
> - {
> - match(LPAREN);
> - data_filter_expression();
> - astFactory->addASTChild( currentAST, returnAST );
> - match(RPAREN);
> - data_expression_AST = currentAST.root;
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_4);
> - }
> - returnAST = data_expression_AST;
> -}
> -
> -void sd_parser::data_comparison() {
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST data_comparison_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken lhs = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST lhs_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken lhs0 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST lhs0_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken lhs1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST lhs1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken lit = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST lit_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken num = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST num_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken lhs2 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST lhs2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -#line 325 "sd_grammar.g"
> -
> - bool allVal = false;
> - bool anyVal = false;
> - int op; int rhs1 = 0; int knot = 0;
> - double dval;
> - Refsd_leafnode myRef;
> - std::list<std::string> slist;
> - std::string s;
> - std::pair<std::string, char> likePair;
> - std::string likeString;
> -
> -#line 1175 "sd_parser.cpp"
> -
> - try { // for error handling
> - if ((LA(1) == K_ALL || LA(1) == K_ANY || LA(1) == S_IDENTIFIER) && (LA(2) == K_IN || LA(2) == K_NOT || LA(2) == S_IDENTIFIER) && (LA(3) == K_IN || LA(3) == K_NOT || LA(3) == LPAREN)) {
> - {
> - switch ( LA(1)) {
> - case K_ANY:
> - {
> - match(K_ANY);
> -#line 338 "sd_grammar.g"
> - anyVal = true;
> -#line 1186 "sd_parser.cpp"
> - break;
> - }
> - case K_ALL:
> - {
> - match(K_ALL);
> -#line 339 "sd_grammar.g"
> - allVal = true;
> -#line 1194 "sd_parser.cpp"
> - break;
> - }
> - case S_IDENTIFIER:
> - {
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - lhs = LT(1);
> - lhs_AST = astFactory->create(lhs);
> - match(S_IDENTIFIER);
> - {
> - switch ( LA(1)) {
> - case K_NOT:
> - {
> - match(K_NOT);
> -#line 341 "sd_grammar.g"
> - knot=1;
> -#line 1217 "sd_parser.cpp"
> - break;
> - }
> - case K_IN:
> - {
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - match(K_IN);
> - slist=in_clause();
> - astFactory->addASTChild( currentAST, returnAST );
> - data_comparison_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
> -#line 342 "sd_grammar.g"
> -
> - //Deal with the 'IN' oerator
> - data_comparison_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(1))->add(astFactory->create(DATA_CMP))));
> - myRef = (Refsd_leafnode)data_comparison_AST;
> - myRef->setLKey(lhs->getText());
> - myRef->setOpType(K_IN);
> - myRef->setRValType(K_STRING_LIST);
> -
> - //Add everything in the 'IN' list to this element
> - while ( slist.size() > 0 )
> - {
> - s = slist.front();
> - myRef->addListElement(s);
> - slist.pop_front();
> - }
> -
> - //Deal with the NOT condition
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> -
> -#line 1268 "sd_parser.cpp"
> - currentAST.root = data_comparison_AST;
> - if ( data_comparison_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&
> - data_comparison_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST )
> - currentAST.child = data_comparison_AST->getFirstChild();
> - else
> - currentAST.child = data_comparison_AST;
> - currentAST.advanceChildToEnd();
> - data_comparison_AST = currentAST.root;
> - }
> - else if ((LA(1) == S_IDENTIFIER) && (LA(2) == K_LIKE || LA(2) == K_NOT) && (LA(3) == K_LIKE || LA(3) == S_CHAR_LITERAL)) {
> - lhs0 = LT(1);
> - lhs0_AST = astFactory->create(lhs0);
> - astFactory->addASTChild(currentAST, lhs0_AST);
> - match(S_IDENTIFIER);
> - {
> - switch ( LA(1)) {
> - case K_NOT:
> - {
> - match(K_NOT);
> -#line 376 "sd_grammar.g"
> - knot = 1;
> -#line 1290 "sd_parser.cpp"
> - break;
> - }
> - case K_LIKE:
> - {
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - tmp36_AST = astFactory->create(LT(1));
> - astFactory->addASTChild(currentAST, tmp36_AST);
> - match(K_LIKE);
> - likePair=like_clause();
> - astFactory->addASTChild( currentAST, returnAST );
> - data_comparison_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
> -#line 377 "sd_grammar.g"
> -
> - //Deal with the 'LIKE' oerator
> - likeString = likePair.first;
> - data_comparison_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(1))->add(astFactory->create(DATA_CMP))));
> - myRef = (Refsd_leafnode)data_comparison_AST;
> - myRef->setLKey(lhs0->getText());
> - myRef->setOpType(K_LIKE);
> - myRef->setRValue(likeString);
> -
> - //Set the escape character
> - //for the 'LIKE' clause
> - myRef->setEscapeChar(likePair.second);
> -
> - //Deal with the NOT condition
> - if ( knot )
> - {
> - myRef->setNotPrefix();
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> -
> -#line 1341 "sd_parser.cpp"
> - currentAST.root = data_comparison_AST;
> - if ( data_comparison_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&
> - data_comparison_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST )
> - currentAST.child = data_comparison_AST->getFirstChild();
> - else
> - currentAST.child = data_comparison_AST;
> - currentAST.advanceChildToEnd();
> - data_comparison_AST = currentAST.root;
> - }
> - else if ((LA(1) == S_IDENTIFIER) && ((LA(2) >= NE && LA(2) <= GE)) && (LA(3) == S_CHAR_LITERAL || LA(3) == S_NUMBER)) {
> - lhs1 = LT(1);
> - lhs1_AST = astFactory->create(lhs1);
> - match(S_IDENTIFIER);
> - op=relop();
> - astFactory->addASTChild( currentAST, returnAST );
> - {
> - switch ( LA(1)) {
> - case S_CHAR_LITERAL:
> - {
> - lit = LT(1);
> - lit_AST = astFactory->create(lit);
> - match(S_CHAR_LITERAL);
> -#line 408 "sd_grammar.g"
> - rhs1 = 1;
> -#line 1366 "sd_parser.cpp"
> - break;
> - }
> - case S_NUMBER:
> - {
> - num = LT(1);
> - num_AST = astFactory->create(num);
> - match(S_NUMBER);
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - data_comparison_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
> -#line 409 "sd_grammar.g"
> -
> - //Deal with the remaining operators
> - data_comparison_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(1))->add(astFactory->create(DATA_CMP))));
> - myRef = (Refsd_leafnode)data_comparison_AST;
> - myRef->setLKey(lhs1->getText());
> - myRef->setOpType(op);
> -
> - if ( rhs1 )
> - {
> - myRef->setRValType(S_CHAR_LITERAL);
> - myRef->setRValue(lit->getText());
> - }
> -
> - else
> - {
> - myRef->setRValType(S_NUMBER);
> - dval = atof(num->getText().c_str());
> - myRef->setRValNum(dval);
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> -
> -#line 1415 "sd_parser.cpp"
> - currentAST.root = data_comparison_AST;
> - if ( data_comparison_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&
> - data_comparison_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST )
> - currentAST.child = data_comparison_AST->getFirstChild();
> - else
> - currentAST.child = data_comparison_AST;
> - currentAST.advanceChildToEnd();
> - data_comparison_AST = currentAST.root;
> - }
> - else if ((LA(1) == S_IDENTIFIER) && (LA(2) == NE || LA(2) == EQ) && (LA(3) == LPAREN)) {
> - lhs2 = LT(1);
> - lhs2_AST = astFactory->create(lhs2);
> - match(S_IDENTIFIER);
> - op=eqop();
> - astFactory->addASTChild( currentAST, returnAST );
> - slist=bracketed_list();
> - astFactory->addASTChild( currentAST, returnAST );
> - data_comparison_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
> -#line 442 "sd_grammar.g"
> -
> - //Deal with the remaining operators
> - data_comparison_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(1))->add(astFactory->create(DATA_CMP))));
> - myRef = (Refsd_leafnode)data_comparison_AST;
> - myRef->setLKey(lhs2->getText());
> - myRef->setOpType(op);
> - myRef->setRValType(K_STRING_LIST);
> -
> - //Add everything in the 'IN' list to this element
> - while ( slist.size() > 0 )
> - {
> - s = slist.front();
> - myRef->addListElement(s);
> - slist.pop_front();
> - }
> -
> - //Deal with ANY/ALL
> - if ( anyVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ANY_VALUE);
> - }
> -
> - if ( allVal )
> - {
> - myRef->setAnyAllValue(sd_leafnode::ALL_VALUE);
> - }
> -
> -#line 1462 "sd_parser.cpp"
> - currentAST.root = data_comparison_AST;
> - if ( data_comparison_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&
> - data_comparison_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST )
> - currentAST.child = data_comparison_AST->getFirstChild();
> - else
> - currentAST.child = data_comparison_AST;
> - currentAST.advanceChildToEnd();
> - data_comparison_AST = currentAST.root;
> - }
> - else {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> -
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_4);
> - }
> - returnAST = data_comparison_AST;
> -}
> -
> -int sd_parser::relop() {
> -#line 316 "sd_grammar.g"
> - int tok_type = 0;
> -#line 1487 "sd_parser.cpp"
> - returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
> - ANTLR_USE_NAMESPACE(antlr)RefAST relop_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken o1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST o1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken o2 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST o2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken o3 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST o3_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken o4 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST o4_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken o5 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST o5_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> - ANTLR_USE_NAMESPACE(antlr)RefToken o6 = ANTLR_USE_NAMESPACE(antlr)nullToken;
> - ANTLR_USE_NAMESPACE(antlr)RefAST o6_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
> -
> - try { // for error handling
> - switch ( LA(1)) {
> - case EQ:
> - {
> - o1 = LT(1);
> - o1_AST = astFactory->create(o1);
> - match(EQ);
> -#line 317 "sd_grammar.g"
> - tok_type = o1->getType();
> -#line 1513 "sd_parser.cpp"
> - break;
> - }
> - case LESS:
> - {
> - o2 = LT(1);
> - o2_AST = astFactory->create(o2);
> - match(LESS);
> -#line 318 "sd_grammar.g"
> - tok_type = o2->getType();
> -#line 1523 "sd_parser.cpp"
> - break;
> - }
> - case GT:
> - {
> - o3 = LT(1);
> - o3_AST = astFactory->create(o3);
> - match(GT);
> -#line 319 "sd_grammar.g"
> - tok_type = o3->getType();
> -#line 1533 "sd_parser.cpp"
> - break;
> - }
> - case NE:
> - {
> - o4 = LT(1);
> - o4_AST = astFactory->create(o4);
> - match(NE);
> -#line 320 "sd_grammar.g"
> - tok_type = o4->getType();
> -#line 1543 "sd_parser.cpp"
> - break;
> - }
> - case LE:
> - {
> - o5 = LT(1);
> - o5_AST = astFactory->create(o5);
> - match(LE);
> -#line 321 "sd_grammar.g"
> - tok_type = o5->getType();
> -#line 1553 "sd_parser.cpp"
> - break;
> - }
> - case GE:
> - {
> - o6 = LT(1);
> - o6_AST = astFactory->create(o6);
> - match(GE);
> -#line 322 "sd_grammar.g"
> - tok_type = o6->getType();
> -#line 1563 "sd_parser.cpp"
> - break;
> - }
> - default:
> - {
> - throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
> - }
> - }
> - }
> - catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
> - reportError(ex);
> - recover(ex,_tokenSet_6);
> - }
> - returnAST = relop_AST;
> - return tok_type;
> -}
> -
> -void sd_parser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
> -{
> - factory.registerFactory(8, "sd_internalnode", sd_internalnode::factory);
> - factory.registerFactory(9, "sd_internalnode", sd_internalnode::factory);
> - factory.registerFactory(21, "sd_leafnode", sd_leafnode::factory);
> - factory.registerFactory(22, "sd_leafnode", sd_leafnode::factory);
> - factory.setMaxNodeType(39);
> -}
> -const char* sd_parser::tokenNames[] = {
> - "<0>",
> - "EOF",
> - "<2>",
> - "NULL_TREE_LOOKAHEAD",
> - "\"in\"",
> - "\"like\"",
> - "\"escape\"",
> - "\"not\"",
> - "\"and\"",
> - "\"or\"",
> - "\"vo\"",
> - "\"type\"",
> - "\"name\"",
> - "\"uid\"",
> - "\"uri\"",
> - "\"endpoint\"",
> - "\"site\"",
> - "\"related_services\"",
> - "\"all\"",
> - "\"any\"",
> - "K_STRING_LIST",
> - "SVC_CMP",
> - "DATA_CMP",
> - "char literal",
> - "left parenthesis",
> - "right parenthesis",
> - "number",
> - "comma",
> - "not equals",
> - "equals",
> - "LESS",
> - "greater than",
> - "LE",
> - "GE",
> - "identifier",
> - "white space",
> - "digit",
> - "integer",
> - "float",
> - "letter",
> - 0
> -};
> -
> -const unsigned long sd_parser::_tokenSet_0_data_[] = { 805306544UL, 0UL, 0UL, 0UL };
> -// "in" "like" "not" NE EQ
> -const ANTLR_USE_NAMESPACE(antlr)BitSet sd_parser::_tokenSet_0(_tokenSet_0_data_,4);
> -const unsigned long sd_parser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
> -// EOF
> -const ANTLR_USE_NAMESPACE(antlr)BitSet sd_parser::_tokenSet_1(_tokenSet_1_data_,4);
> -const unsigned long sd_parser::_tokenSet_2_data_[] = { 33554434UL, 0UL, 0UL, 0UL };
> -// EOF RPAREN
> -const ANTLR_USE_NAMESPACE(antlr)BitSet sd_parser::_tokenSet_2(_tokenSet_2_data_,4);
> -const unsigned long sd_parser::_tokenSet_3_data_[] = { 33554946UL, 0UL, 0UL, 0UL };
> -// EOF "or" RPAREN
> -const ANTLR_USE_NAMESPACE(antlr)BitSet sd_parser::_tokenSet_3(_tokenSet_3_data_,4);
> -const unsigned long sd_parser::_tokenSet_4_data_[] = { 33555202UL, 0UL, 0UL, 0UL };
> -// EOF "and" "or" RPAREN
> -const ANTLR_USE_NAMESPACE(antlr)BitSet sd_parser::_tokenSet_4(_tokenSet_4_data_,4);
> -const unsigned long sd_parser::_tokenSet_5_data_[] = { 25165824UL, 0UL, 0UL, 0UL };
> -// S_CHAR_LITERAL LPAREN
> -const ANTLR_USE_NAMESPACE(antlr)BitSet sd_parser::_tokenSet_5(_tokenSet_5_data_,4);
> -const unsigned long sd_parser::_tokenSet_6_data_[] = { 75497472UL, 0UL, 0UL, 0UL };
> -// S_CHAR_LITERAL S_NUMBER
> -const ANTLR_USE_NAMESPACE(antlr)BitSet sd_parser::_tokenSet_6(_tokenSet_6_data_,4);
> -
> -
>
> File [removed]: sd_parser.hpp
> Delta lines: +0 -105
> ===================================================================
> --- trunk/saga/impl/packages/sd/sd_parser.hpp 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sd_parser.hpp 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,105 +0,0 @@
> -#ifndef INC_sd_parser_hpp_
> -#define INC_sd_parser_hpp_
> -
> -#include <antlr/config.hpp>
> -/* $ANTLR 2.7.7 (20081210): "sd_grammar.g" -> "sd_parser.hpp"$ */
> -#include <antlr/TokenStream.hpp>
> -#include <antlr/TokenBuffer.hpp>
> -#include "sdTokenTypes.hpp"
> -#include <antlr/LLkParser.hpp>
> -
> -#line 2 "sd_grammar.g"
> -
> - #include "sd_leafnode.hpp"
> - #include "sd_internalnode.hpp"
> - #include <iostream>
> - #include <string>
> - #include <list>
> - #include <math.h>
> - #include <utility>
> - using namespace std;
> -
> -#line 23 "sd_parser.hpp"
> -class CUSTOM_API sd_parser : public ANTLR_USE_NAMESPACE(antlr)LLkParser, public sdTokenTypes
> -{
> -#line 1 "sd_grammar.g"
> -#line 27 "sd_parser.hpp"
> -public:
> - void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory );
> -protected:
> - sd_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k);
> -public:
> - sd_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf);
> -protected:
> - sd_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k);
> -public:
> - sd_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer);
> - sd_parser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state);
> - int getNumTokens() const
> - {
> - return sd_parser::NUM_TOKENS;
> - }
> - const char* getTokenName( int type ) const
> - {
> - if( type > getNumTokens() ) return 0;
> - return sd_parser::tokenNames[type];
> - }
> - const char* const* getTokenNames() const
> - {
> - return sd_parser::tokenNames;
> - }
> - public: int service_keyword();
> - public: void service_filter();
> - public: void service_filter_expression();
> - public: void service_and_expression();
> - public: void service_expression();
> - public: std::list<std::string> in_clause();
> - public: pair<string, char> like_clause();
> - public: int eqop();
> - public: std::list<std::string> bracketed_list();
> - public: void string_literal_list();
> - public: void vo_filter();
> - public: void vo_filter_expression();
> - public: void vo_and_expression();
> - public: void vo_expression();
> - public: void data_filter();
> - public: void data_filter_expression();
> - public: void data_and_expression();
> - public: void data_expression();
> - public: void data_comparison();
> - public: int relop();
> -public:
> - ANTLR_USE_NAMESPACE(antlr)RefAST getAST()
> - {
> - return returnAST;
> - }
> -
> -protected:
> - ANTLR_USE_NAMESPACE(antlr)RefAST returnAST;
> -private:
> - static const char* tokenNames[];
> -#ifndef NO_STATIC_CONSTS
> - static const int NUM_TOKENS = 40;
> -#else
> - enum {
> - NUM_TOKENS = 40
> - };
> -#endif
> -
> - static const unsigned long _tokenSet_0_data_[];
> - static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0;
> - static const unsigned long _tokenSet_1_data_[];
> - static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1;
> - static const unsigned long _tokenSet_2_data_[];
> - static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2;
> - static const unsigned long _tokenSet_3_data_[];
> - static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_3;
> - static const unsigned long _tokenSet_4_data_[];
> - static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_4;
> - static const unsigned long _tokenSet_5_data_[];
> - static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_5;
> - static const unsigned long _tokenSet_6_data_[];
> - static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_6;
> -};
> -
> -#endif /*INC_sd_parser_hpp_*/
>
> File [removed]: sd_parser_ext.hpp
> Delta lines: +0 -97
> ===================================================================
> --- trunk/saga/impl/packages/sd/sd_parser_ext.hpp 2009-01-19 15:01:34 UTC (rev 3334)
> +++ trunk/saga/impl/packages/sd/sd_parser_ext.hpp 2009-01-20 09:39:56 UTC (rev 3335)
> @@ -1,97 +0,0 @@
> -#ifndef SD_PARSER_EXT_HPP
> -#define SD_PARSER_EXT_HPP
> -
> -#include "sd_parser.hpp"
> -#include <string>
> -#include <sstream>
> -#include "saga/exception.hpp"
> -class sd_parser_ext : public sd_parser
> -{
> - public:
> -
> - sd_parser_ext(antlr::TokenStream& lexer) : sd_parser(lexer)
> - {
> - setErrorFlag(false);
> - setErrorString("");
> - }
> -
> - //Get the error flag
> - bool getErrorFlag() const
> - {
> - return _errorFlag;
> - }
> -
> - //Set the error flag
> - void setErrorFlag(bool errorFlag)
> - {
> - _errorFlag = errorFlag;
> - }
> -
> - //Get the error string
> - std::string getErrorString() const
> - {
> - return _errorString;
> - }
> -
> - //Set the error string
> - void setErrorString(const std::string& errorString)
> - {
> - _errorString = errorString;
> - }
> -
> - // Override the reportError function defined in the Parser base
> - // class.
> - void reportError(const std::string& s)
> - {
> - if ( getErrorFlag() == false )
> - {
> - setErrorFlag(true);
> -
> - std::ostringstream os;
> -
> - if ( getFilename()=="" )
> - {
> - os << "Error: " << s << std::endl;
> - }
> -
> - else
> - {
> - os << "Error in " << getFilename()
> - << ": " << s << std::endl;
> - }
> - setErrorString(os.str());
> - }
> - }
> -
> - // Override the reportError function defined in the Parser base
> - // class.
> - void reportError(const antlr::RecognitionException& ex)
> - {
> - if ( getErrorFlag() == false )
> - {
> - setErrorFlag(true);
> -
> - std::ostringstream os;
> -
> - if ( getFilename()=="" )
> - {
> - os << "Error: " << ex.toString() << std::endl;
> - }
> -
> - else
> - {
> - os << "Error in " << getFilename()
> - << ": " << ex.toString() << std::endl;
> - }
> - setErrorString(os.str());
> - }
> - }
> -
> - private:
> -
> - bool _errorFlag;
> - std::string _errorString;
> -};
> -
> -#endif
> -
>
> _______________________________________________
> saga-devel mailing list
> saga-devel at cct.lsu.edu
> https://mail.cct.lsu.edu/mailman/listinfo/saga-devel
--
Nothing is ever easy.
More information about the saga-devel
mailing list