// $ANTLR : "datalog.g" -> "AntlrDatalogParser.java"$

package net.jxta.edutella.provider.datalog;

import net.jxta.edutella.eqm.*;
import net.jxta.edutella.vocabulary.QEL;
import com.hp.hpl.jena.rdf.model.*;
import java.util.*;

import antlr.TokenBuffer;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.ANTLRException;
import antlr.LLkParser;
import antlr.Token;
import antlr.TokenStream;
import antlr.RecognitionException;
import antlr.NoViableAltException;
import antlr.MismatchedTokenException;
import antlr.SemanticException;
import antlr.ParserSharedInputState;
import antlr.collections.impl.BitSet;

public class AntlrDatalogParser extends antlr.LLkParser       implements AntlrDatalogParserTokenTypes
 {


	AntlrDatalogLexer lexer = null ;
	
	void setLexer(AntlrDatalogLexer l) {
		this.lexer = l ;
	}

	/*
	 * helper method to create Resources from the Query model.
	 */
	private Resource createResource(Query eduquery, String s) {
		try{
			return eduquery.getResource().getModel().createResource(s);
		} catch( RDFException e ) {
			throw new EQMException(e);
		}
	}
	
	private class ParsedQueryLiteral {
		public QueryLiteral queryLiteral;
		public boolean isOuterJoin = false;
	}

protected AntlrDatalogParser(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
}

public AntlrDatalogParser(TokenBuffer tokenBuf) {
  this(tokenBuf,4);
}

protected AntlrDatalogParser(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
}

public AntlrDatalogParser(TokenStream lexer) {
  this(lexer,4);
}

public AntlrDatalogParser(ParserSharedInputState state) {
  super(state,4);
  tokenNames = _tokenNames;
}

	public final Query  query(
		String base
	) throws RecognitionException, TokenStreamException {
		Query eduquery;
		
		
				Map prefixes = new HashMap();
				prefixes.put("qel", QEL.getURI());
			Model m = ModelFactory.createDefaultModel();
			Resource queryRes = null;
			String declaredBase = null;
			eduquery = null;
			
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case AT_BASE:
			{
				declaredBase=baseDeclaration();
				break;
			}
			case NAME:
			case QNAME:
			case AT_PREFIX:
			case QUERYSEP:
			case MINUS:
			case URIREF:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			_loop602:
			do {
				if ((LA(1)==AT_PREFIX)) {
					prefixDeclaration(m, prefixes);
				}
				else {
					break _loop602;
				}
				
			} while (true);
			}
			
				try {
					if(declaredBase != null ) {
						base = declaredBase;
					}
					
				    	queryRes = m.createResource(base+"#query");
				} catch (RDFException e) {
					throw new EQMException(e);
				}
					eduquery = new Query(queryRes);
				
			{
			_loop604:
			do {
				if ((_tokenSet_0.member(LA(1)))) {
					
						    	Rule edurule;
							
					edurule=rule(eduquery, prefixes);
					
								eduquery.addRule(edurule);
							
				}
				else {
					break _loop604;
				}
				
			} while (true);
			}
			queryExpression(eduquery, prefixes);
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_1);
		}
		return eduquery;
	}
	
	public final String  baseDeclaration() throws RecognitionException, TokenStreamException {
		String base;
		
		Token  r = null;
		
				base = null;
			
		
		try {      // for error handling
			match(AT_BASE);
			r = LT(1);
			match(URIREF);
			
					base=r.getText();
				
			{
			switch ( LA(1)) {
			case SEP:
			{
				match(SEP);
				break;
			}
			case NAME:
			case QNAME:
			case AT_PREFIX:
			case QUERYSEP:
			case MINUS:
			case URIREF:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_2);
		}
		return base;
	}
	
	public final void prefixDeclaration(
		Model m, Map prefixes
	) throws RecognitionException, TokenStreamException {
		
		Token  p = null;
		Token  r = null;
		
				String prefix = null;
				Resource ns = null;
			
		
		try {      // for error handling
			match(AT_PREFIX);
			p = LT(1);
			match(PREFIXNAME);
			
					prefix = p.getText();
				
			r = LT(1);
			match(URIREF);
			
					prefixes.put(prefix, r.getText());
				
			{
			switch ( LA(1)) {
			case SEP:
			{
				match(SEP);
				break;
			}
			case NAME:
			case QNAME:
			case AT_PREFIX:
			case QUERYSEP:
			case MINUS:
			case URIREF:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_2);
		}
	}
	
	public final Rule  rule(
		Query eduquery, Map prefixes
	) throws RecognitionException, TokenStreamException {
		Rule edurule;
		
		
				ParsedQueryLiteral pql;
				edurule=null;
			
		
		try {      // for error handling
			pql=queryLiteral(eduquery, prefixes);
			
					edurule = eduquery.createRule(pql.queryLiteral);	
				
			match(RULESEP);
			{
			pql=queryLiteral(eduquery, prefixes);
			
						if ( pql.isOuterJoin ) {
							edurule.addOuterJoinLiteral(pql.queryLiteral);
						} else {
							edurule.addLiteral(pql.queryLiteral);
						}
					
			}
			{
			_loop617:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					pql=queryLiteral(eduquery, prefixes);
					
									if ( pql.isOuterJoin ) {
										edurule.addOuterJoinLiteral(pql.queryLiteral);
									} else {
										edurule.addLiteral(pql.queryLiteral);
									}
								
					}
				}
				else {
					break _loop617;
				}
				
			} while (true);
			}
			match(SEP);
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_3);
		}
		return edurule;
	}
	
	public final void queryExpression(
		Query eduquery, Map prefixes
	) throws RecognitionException, TokenStreamException {
		
		
				QueryLiteral queryLit;
				List resultVariables;
				ParsedQueryLiteral pql;
			
		
		try {      // for error handling
			match(QUERYSEP);
			{
			switch ( LA(1)) {
			case MINUS:
			{
				match(MINUS);
				break;
			}
			case LPAREN:
			{
				{
				resultVariables=arglist(eduquery, prefixes);
				
								eduquery.setResultVariables(resultVariables);
							
				match(MINUS);
				}
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			pql=queryLiteral(eduquery, prefixes);
			
						if ( pql.isOuterJoin ) {
							eduquery.addOuterJoinLiteral(pql.queryLiteral);
						} else {
							eduquery.addLiteral(pql.queryLiteral);
						}
					
			}
			{
			_loop611:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					{
					pql=queryLiteral(eduquery, prefixes);
					
									if ( pql.isOuterJoin ) {
										eduquery.addOuterJoinLiteral(pql.queryLiteral);
									} else {
										eduquery.addLiteral(pql.queryLiteral);
									}
								
					}
				}
				else {
					break _loop611;
				}
				
			} while (true);
			}
			{
			switch ( LA(1)) {
			case SEP:
			{
				match(SEP);
				break;
			}
			case EOF:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_1);
		}
	}
	
	public final List  arglist(
		Query eduquery, Map prefixes
	) throws RecognitionException, TokenStreamException {
		List args;
		
		
				args = new ArrayList();
				RDFNode arg;
			
		
		try {      // for error handling
			match(LPAREN);
			arg=argument(eduquery, prefixes);
			
					args.add(arg);
				
			{
			_loop624:
			do {
				if ((LA(1)==COMMA)) {
					match(COMMA);
					arg=argument(eduquery, prefixes);
					
								args.add(arg);
							
				}
				else {
					break _loop624;
				}
				
			} while (true);
			}
			match(RPAREN);
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_4);
		}
		return args;
	}
	
	public final ParsedQueryLiteral  queryLiteral(
		Query eduquery, Map prefixes
	) throws RecognitionException, TokenStreamException {
		ParsedQueryLiteral pql;
		
		Token  p = null;
		
				pql = new ParsedQueryLiteral();
				List litArgs;
				Resource pSym = null;
				boolean negated = false;
				boolean isPrefixStatement = false;
			
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case MINUS:
			{
				match(MINUS);
				negated=true;
				break;
			}
			case NAME:
			case QNAME:
			case URIREF:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			switch ( LA(1)) {
			case NAME:
			{
				p = LT(1);
				match(NAME);
				
						// allow usage of statement literal without namespace declaration
						if ("s".equals(p.getText())) {
							pSym = QEL.s;
						} else {
							pSym = createResource(eduquery, eduquery.getResource().getNameSpace()+p.getText());
						}
					
				break;
			}
			case QNAME:
			{
				pSym=qname(eduquery, prefixes);
				isPrefixStatement=true;
				break;
			}
			case URIREF:
			{
				pSym=uriref(eduquery);
				isPrefixStatement=true;
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			switch ( LA(1)) {
			case OJMARKER:
			{
				match(OJMARKER);
				
						pql.isOuterJoin = true;
					
				break;
			}
			case LPAREN:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			litArgs=arglist(eduquery, prefixes);
			
					if(pSym.equals(QEL.s)){
						//create StatementLiteral
						Resource subject = (Resource)litArgs.get(0);
						Resource predicate = (Resource)litArgs.get(1);
						RDFNode object = (RDFNode)litArgs.get(2);
						pql.queryLiteral = eduquery.createStatementLiteral(subject, predicate, object);
					} else if (QEL.isBuiltinPredicate(pSym)) {
						pql.queryLiteral = eduquery.createBuiltinLiteral(pSym,litArgs,negated);
					} else {
						if (isPrefixStatement) {
							//create StatementLiteral
							Resource subject = (Resource)litArgs.get(0);
							Resource predicate = pSym;
							RDFNode object = (RDFNode)litArgs.get(1);
							pql.queryLiteral = eduquery.createStatementLiteral(subject, predicate, object);
						} else {			
							pql.queryLiteral = eduquery.createQueryLiteral(pSym,litArgs);
						}
					}
				
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_5);
		}
		return pql;
	}
	
	public final Resource  qname(
		Query eduquery, Map prefixes
	) throws RecognitionException, TokenStreamException {
		Resource res;
		
		Token  qn = null;
		
				res = null;
			
		
		try {      // for error handling
			qn = LT(1);
			match(QNAME);
			
					String qname = qn.getText();
					int colonIndex = qname.indexOf(':');
					String prefix = qname.substring(0,  colonIndex);
					String lname = qname.substring(colonIndex+1, qname.length());
					String ns = (String)prefixes.get(prefix);
					if ( ns == null ) {
						throw new SemanticException("namespace '" + prefix + "' has not been declared");
					}
					res=createResource(eduquery, ns+lname);
				
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_6);
		}
		return res;
	}
	
	public final Resource  uriref(
		Query eduquery
	) throws RecognitionException, TokenStreamException {
		Resource res;
		
		Token  r = null;
		
				res = null;
			
		
		try {      // for error handling
			r = LT(1);
			match(URIREF);
			
					res=createResource(eduquery, r.getText());
				
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_6);
		}
		return res;
	}
	
	public final RDFNode  argument(
		Query eduquery, Map prefixes
	) throws RecognitionException, TokenStreamException {
		RDFNode arg;
		
		Token  v = null;
		
				arg=null;
				RDFNode a = null;		
			
		
		try {      // for error handling
			switch ( LA(1)) {
			case STRING:
			{
				arg=literal(eduquery, prefixes);
				break;
			}
			case QNAME:
			{
				arg=qname(eduquery, prefixes);
				break;
			}
			case URIREF:
			{
				arg=uriref(eduquery);
				break;
			}
			case NAME:
			{
				v = LT(1);
				match(NAME);
				
						String varName=v.getText();
						arg = eduquery.getVarForLocalName(varName);
						if ( arg == null ) {
							eduquery.addVarWithLocalName(varName);
							arg = eduquery.getVarForLocalName(varName);
						}
					
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_7);
		}
		return arg;
	}
	
	public final Literal  literal(
		Query eduquery, Map prefixes
	) throws RecognitionException, TokenStreamException {
		Literal lit;
		
		Token  s = null;
		
				lit=null;
				String lang = null;
				Resource dt = null;
			
		
		try {      // for error handling
			s = LT(1);
			match(STRING);
			{
			switch ( LA(1)) {
			case AT_LANG:
			{
				lang=langModifier();
				break;
			}
			case COMMA:
			case RPAREN:
			case DATATYPE:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			switch ( LA(1)) {
			case DATATYPE:
			{
				dt=datatypeModifier(eduquery, prefixes);
				break;
			}
			case COMMA:
			case RPAREN:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			
					try{
						lit=eduquery.getResource().getModel().createLiteral(s.getText());  
					} catch( RDFException e ) {
						throw new EQMException(e);
					}
				
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_7);
		}
		return lit;
	}
	
	public final String  nsprefix() throws RecognitionException, TokenStreamException {
		String prefix;
		
		Token  ns = null;
		
				prefix="_default";
			
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case NAME:
			{
				ns = LT(1);
				match(NAME);
				prefix = ns.getText();
				break;
			}
			case COLON:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			match(COLON);
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_1);
		}
		return prefix;
	}
	
	public final String  langModifier() throws RecognitionException, TokenStreamException {
		String lang;
		
		Token  l = null;
		
				lang = null;
			
		
		try {      // for error handling
			l = LT(1);
			match(AT_LANG);
			lang=l.getText();
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_8);
		}
		return lang;
	}
	
	public final Resource  datatypeModifier(
		Query eduquery, Map prefixes
	) throws RecognitionException, TokenStreamException {
		Resource res;
		
		
				res = null;
			
		
		try {      // for error handling
			match(DATATYPE);
			res=datatype(eduquery, prefixes);
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_7);
		}
		return res;
	}
	
	public final Resource  datatype(
		Query eduquery, Map prefixes
	) throws RecognitionException, TokenStreamException {
		Resource res;
		
		
				res = null;
			
		
		try {      // for error handling
			switch ( LA(1)) {
			case QNAME:
			{
				res=qname(eduquery, prefixes);
				break;
			}
			case URIREF:
			{
				res=uriref(eduquery);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			consume();
			consumeUntil(_tokenSet_7);
		}
		return res;
	}
	
	
	public static final String[] _tokenNames = {
		"<0>",
		"EOF",
		"<2>",
		"NULL_TREE_LOOKAHEAD",
		"NAME",
		"QNAME",
		"PREFIXNAME",
		"RULESEP",
		"AT_PREFIX",
		"AT_BASE",
		"AT_LANG",
		"QUERYSEP",
		"MINUS",
		"COMMA",
		"SEP",
		"OJMARKER",
		"LPAREN",
		"RPAREN",
		"URIREF",
		"COLON",
		"STRING",
		"DATATYPE",
		"THING",
		"NSNAME",
		"LNAME",
		"LOCALCHAR",
		"URICHAR",
		"MOST_URI_CHARS",
		"AT_WORD",
		"AT",
		"SL_COMMENT",
		"NL1",
		"NL2",
		"NL3",
		"NL",
		"WS",
		"ALPHASMALL",
		"ALPHACAPS",
		"ALPHA",
		"ALPHANUMERIC",
		"STRING1",
		"STRING2",
		"QUOTE3S",
		"QUOTE3D",
		"ESCAPE",
		"ESC_CHAR"
	};
	
	private static final long[] mk_tokenSet_0() {
		long[] data = { 266288L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
	private static final long[] mk_tokenSet_1() {
		long[] data = { 2L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
	private static final long[] mk_tokenSet_2() {
		long[] data = { 268592L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
	private static final long[] mk_tokenSet_3() {
		long[] data = { 268336L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
	private static final long[] mk_tokenSet_4() {
		long[] data = { 28802L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
	private static final long[] mk_tokenSet_5() {
		long[] data = { 24706L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
	private static final long[] mk_tokenSet_6() {
		long[] data = { 237568L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
	private static final long[] mk_tokenSet_7() {
		long[] data = { 139264L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
	private static final long[] mk_tokenSet_8() {
		long[] data = { 2236416L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
	
	}