/* $Id: SPARQLfedScanner.lpp,v 1.4 2008/10/03 07:06:03 eric Exp $ -*- mode: c++ -*- */
/** \file SPARQLfedScanner.ll Define the Flex lexical scanner */

%{ /*** C/C++ Declarations ***/

#include "SPARQLfedParser.hpp"
#include "SPARQLfedScanner.hpp"

/* import the parser's token type into a local typedef */
typedef w3c_sw::SPARQLfedParser::token token;
typedef w3c_sw::SPARQLfedParser::token_type token_type;

/* Work around an incompatibility in flex (at least versions 2.5.31 through
 * 2.5.33): it generates code that does not conform to C89.  See Debian bug
 * 333231 <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=333231>.  */
#undef yywrap
#define yywrap()	1

/* By default yylex returns int, we use token_type. Unfortunately yyterminate
 * by default returns 0, which is not of token_type. */
#define yyterminate() return token::__EOF__

/* This disables inclusion of unistd.h, which is not available under Visual C++
 * on Win32. The C++ scanner uses STL streams instead. */
#define YY_NO_UNISTD_H

%}

/*** Flex Declarations and Options ***/

/* enable c++ scanner class generation */
%option c++

/* change the name of the scanner class. results in "SPARQLfedFlexLexer" */
%option prefix="SPARQLfed"

/* the manual says "somewhat more optimized" */
%option batch

/* enable scanner to generate debug output. disable this for release
 * versions. */
%option debug

/* no support for include files is planned */
%option noyywrap nounput

/* enables the use of start condition stacks */
%option stack

/* The following paragraph suffices to track locations accurately. Each time
 * yylex is invoked, the begin position is moved onto the end position. */
%{
#define YY_USER_ACTION  yylloc->columns(yyleng);
%}

/* START patterns for SPARQLfed terminals */
IT_REPLACE		[Rr][Ee][Pp][Ll][Aa][Cc][Ee]
IT_WITH		[Ww][Ii][Tt][Hh]
IT_DELETE		[Dd][Ee][Ll][Ee][Tt][Ee]
IT_INSERT		[Ii][Nn][Ss][Ee][Rr][Tt]
IT_GRAPH		[Gg][Rr][Aa][Pp][Hh]
IT_LOAD		[Ll][Oo][Aa][Dd]
IT_INTO		[Ii][Nn][Tt][Oo]
IT_CLEAR		[Cc][Ll][Ee][Aa][Rr]
IT_CREATE		[Cc][Rr][Ee][Aa][Tt][Ee]
IT_SILENT		[Ss][Ii][Ll][Ee][Nn][Tt]
IT_DROP		[Dd][Rr][Oo][Pp]
IT_BASE		[Bb][Aa][Ss][Ee]
IT_PREFIX		[Pp][Rr][Ee][Ff][Ii][Xx]
IT_SELECT		[Ss][Ee][Ll][Ee][Cc][Tt]
IT_DISTINCT		[Dd][Ii][Ss][Tt][Ii][Nn][Cc][Tt]
IT_REDUCED		[Rr][Ee][Dd][Uu][Cc][Ee][Dd]
GT_TIMES		"*"
IT_CONSTRUCT		[Cc][Oo][Nn][Ss][Tt][Rr][Uu][Cc][Tt]
IT_DESCRIBE		[Dd][Ee][Ss][Cc][Rr][Ii][Bb][Ee]
IT_ASK		[Aa][Ss][Kk]
IT_FROM		[Ff][Rr][Oo][Mm]
IT_NAMED		[Nn][Aa][Mm][Ee][Dd]
IT_WHERE		[Ww][Hh][Ee][Rr][Ee]
IT_ORDER		[Oo][Rr][Dd][Ee][Rr]
IT_BY		[Bb][Yy]
IT_ASC		[Aa][Ss][Cc]
IT_DESC		[Dd][Ee][Ss][Cc]
IT_LIMIT		[Ll][Ii][Mm][Ii][Tt]
IT_OFFSET		[Oo][Ff][Ff][Ss][Ee][Tt]
IT_BINDINGS		[Bb][Ii][Nn][Dd][Ii][Nn][Gg][Ss]
GT_LCURLEY		"{"
GT_RCURLEY		"}"
GT_LPAREN		"("
GT_RPAREN		")"
IT_NULL		[Nn][Uu][Ll][Ll]
GT_DOT		"."
IT_OPTIONAL		[Oo][Pp][Tt][Ii][Oo][Nn][Aa][Ll]
IT_UNION		[Uu][Nn][Ii][Oo][Nn]
IT_FILTER		[Ff][Ii][Ll][Tt][Ee][Rr]
GT_COMMA		","
GT_SEMI		";"
IT_a		"a"
GT_LBRACKET		"\["
GT_RBRACKET		"\]"
GT_OR		"||"
GT_AND		"&&"
GT_EQUAL		"="
GT_NEQUAL		"!="
GT_LT		"<"
GT_GT		">"
GT_LE		"<="
GT_GE		">="
GT_PLUS		"+"
GT_MINUS		"-"
GT_DIVIDE		"/"
GT_NOT		"!"
IT_STR		[Ss][Tt][Rr]
IT_LANG		[Ll][Aa][Nn][Gg]
IT_LANGMATCHES		[Ll][Aa][Nn][Gg][Mm][Aa][Tt][Cc][Hh][Ee][Ss]
IT_DATATYPE		[Dd][Aa][Tt][Aa][Tt][Yy][Pp][Ee]
IT_BOUND		[Bb][Oo][Uu][Nn][Dd]
IT_sameTerm		[Ss][Aa][Mm][Ee][Tt][Ee][Rr][Mm]
IT_isIRI		[Ii][Ss][Ii][Rr][Ii]
IT_isURI		[Ii][Ss][Uu][Rr][Ii]
IT_isBLANK		[Ii][Ss][Bb][Ll][Aa][Nn][Kk]
IT_isLITERAL		[Ii][Ss][Ll][Ii][Tt][Ee][Rr][Aa][Ll]
IT_REGEX		[Rr][Ee][Gg][Ee][Xx]
GT_DTYPE		"^^"
IT_true		[Tt][Rr][Uu][Ee]
IT_false		[Ff][Aa][Ll][Ss][Ee]

/* <IRI_REF> ::= "<" (( [^<>\"{}|^`\\] - [#0000- ] ))* ">" */
IRI_REF		"<"(([#-;=?-\[\]_a-z~-\x7F]|([\xC2-\xDF][\x80-\xBF])|(\xE0([\xA0-\xBF][\x80-\xBF]))|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|(\xED([\x80-\x9F][\x80-\xBF]))|([\xEE-\xEF][\x80-\xBF][\x80-\xBF])|(\xF0([\x90-\xBF][\x80-\xBF][\x80-\xBF]))|([\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF])|(\xF4([\x80-\x8E][\x80-\xBF][\x80-\xBF])|(\x8F([\x80-\xBE][\x80-\xBF])|(\xBF[\x80-\xBD])))]))*">"
LANGTAG		"@"([A-Za-z])+(("-"([0-9A-Za-z])+))*
INTEGER		([0-9])+
DECIMAL		(([0-9])+"."([0-9])*)|("."([0-9])+)
INTEGER_POSITIVE		"+"({INTEGER})
DECIMAL_POSITIVE		"+"({DECIMAL})
INTEGER_NEGATIVE		"-"({INTEGER})
DECIMAL_NEGATIVE		"-"({DECIMAL})
EXPONENT		[Ee]([+-])?([0-9])+
DOUBLE		(([0-9])+"."([0-9])*({EXPONENT}))|(("."(([0-9]))+({EXPONENT}))|((([0-9]))+({EXPONENT})))
DOUBLE_NEGATIVE		"-"({DOUBLE})
DOUBLE_POSITIVE		"+"({DOUBLE})
ECHAR		"\\"[\"\'\\bfnrt]

/* <STRING_LITERAL_LONG2> ::= "'''" (( (( "'" | "''" ))? ( [^'\\] | ECHAR ) ))* "'''" */
STRING_LITERAL_LONG2		"\"\"\""((((("\"")|("\"\"")))?(([\x00-!#-\[\]-\x7F]|([\xC2-\xDF][\x80-\xBF])|(\xE0([\xA0-\xBF][\x80-\xBF]))|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|(\xED([\x80-\x9F][\x80-\xBF]))|([\xEE-\xEF][\x80-\xBF][\x80-\xBF])|(\xF0([\x90-\xBF][\x80-\xBF][\x80-\xBF]))|([\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF])|(\xF4([\x80-\x8E][\x80-\xBF][\x80-\xBF])|(\x8F([\x80-\xBE][\x80-\xBF])|(\xBF[\x80-\xBD])))])|(({ECHAR})))))*"\"\"\""
STRING_LITERAL_LONG1		"\'\'\'"((((("\'")|("\'\'")))?(([\x00-&(-\[\]-\x7F]|([\xC2-\xDF][\x80-\xBF])|(\xE0([\xA0-\xBF][\x80-\xBF]))|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|(\xED([\x80-\x9F][\x80-\xBF]))|([\xEE-\xEF][\x80-\xBF][\x80-\xBF])|(\xF0([\x90-\xBF][\x80-\xBF][\x80-\xBF]))|([\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF])|(\xF4([\x80-\x8E][\x80-\xBF][\x80-\xBF])|(\x8F([\x80-\xBE][\x80-\xBF])|(\xBF[\x80-\xBD])))])|(({ECHAR})))))*"\'\'\'"
STRING_LITERAL2		"\""(((([\x00-\t\x0B-\x0C\x0E-!#-\[\]-\x7F]|([\xC2-\xDF][\x80-\xBF])|(\xE0([\xA0-\xBF][\x80-\xBF]))|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|(\xED([\x80-\x9F][\x80-\xBF]))|([\xEE-\xEF][\x80-\xBF][\x80-\xBF])|(\xF0([\x90-\xBF][\x80-\xBF][\x80-\xBF]))|([\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF])|(\xF4([\x80-\x8E][\x80-\xBF][\x80-\xBF])|(\x8F([\x80-\xBE][\x80-\xBF])|(\xBF[\x80-\xBD])))]))|(({ECHAR}))))*"\""
STRING_LITERAL1		"\'"(((([\x00-\t\x0B-\x0C\x0E-&(-\[\]-\x7F]|([\xC2-\xDF][\x80-\xBF])|(\xE0([\xA0-\xBF][\x80-\xBF]))|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|(\xED([\x80-\x9F][\x80-\xBF]))|([\xEE-\xEF][\x80-\xBF][\x80-\xBF])|(\xF0([\x90-\xBF][\x80-\xBF][\x80-\xBF]))|([\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF])|(\xF4([\x80-\x8E][\x80-\xBF][\x80-\xBF])|(\x8F([\x80-\xBE][\x80-\xBF])|(\xBF[\x80-\xBD])))]))|(({ECHAR}))))*"\'"
WS		(" ")|(("\t")|(("\r")|("\n")))
NIL		"("(({WS}))*")"
ANON		"\["(({WS}))*"\]"
PN_CHARS_BASE		([A-Z])|(([a-z])|(((\xC3[\x80-\x96]))|(((\xC3[\x98-\xB6]))|(((\xC3[\xB8-\xBF])|([\xC4-\xCB][\x80-\xBF]))|(((\xCD[\xB0-\xBD]))|(((\xCD\xBF)|([\xCE-\xDF][\x80-\xBF])|(\xE0([\xA0-\xBF][\x80-\xBF]))|(\xE1([\x80-\xBF][\x80-\xBF])))|(((\xE2(\x80[\x8C-\x8D])))|(((\xE2(\x81[\xB0-\xBF])|([\x82-\x85][\x80-\xBF])|(\x86[\x80-\x8F])))|(((\xE2([\xB0-\xBE][\x80-\xBF])|(\xBF[\x80-\xAF])))|(((\xE3(\x80[\x81-\xBF])|([\x81-\xBF][\x80-\xBF]))|([\xE4-\xEC][\x80-\xBF][\x80-\xBF])|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|(\xED([\x80-\x9F][\x80-\xBF])))|(((\xEF([\xA4-\xB6][\x80-\xBF])|(\xB7[\x80-\x8F])))|(((\xEF(\xB7[\xB0-\xBF])|([\xB8-\xBE][\x80-\xBF])|(\xBF[\x80-\xBD])))|((\xF0([\x90-\xBF][\x80-\xBF][\x80-\xBF]))|([\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]))))))))))))))
PN_CHARS_U		(({PN_CHARS_BASE}))|("_")
VARNAME		((({PN_CHARS_U}))|([0-9]))(((({PN_CHARS_U}))|(([0-9])|((\xC2\xB7)|(((\xCD[\x80-\xAF]))|((\xE2(\x80\xBF)|(\x81\x80))))))))*
VAR2		"$"({VARNAME})
VAR1		"?"({VARNAME})
PN_CHARS		(({PN_CHARS_U}))|(("-")|(([0-9])|((\xC2\xB7)|(((\xCD[\x80-\xAF]))|((\xE2(\x80\xBF)|(\x81\x80)))))))
PN_PREFIX		({PN_CHARS_BASE})(((((({PN_CHARS}))|(".")))*({PN_CHARS})))?
PNAME_NS		(({PN_PREFIX}))?":"
PN_LOCAL		((({PN_CHARS_U}))|([0-9]))(((((({PN_CHARS}))|(".")))*({PN_CHARS})))?
BLANK_NODE_LABEL		"_:"({PN_LOCAL})
PNAME_LN		({PNAME_NS})({PN_LOCAL})
PASSED_TOKENS		(([\t\n\r ])+)|("#"([\x00-\t\x0B-\x0C\x0E-\x7F]|([\xC2-\xDF][\x80-\xBF])|(\xE0([\xA0-\xBF][\x80-\xBF]))|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|([\xE1-\xEC][\x80-\xBF][\x80-\xBF])|(\xED([\x80-\x9F][\x80-\xBF]))|([\xEE-\xEF][\x80-\xBF][\x80-\xBF])|(\xF0([\x90-\xBF][\x80-\xBF][\x80-\xBF]))|([\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF])|(\xF4([\x80-\x8E][\x80-\xBF][\x80-\xBF])|(\x8F([\x80-\xBE][\x80-\xBF])|(\xBF[\x80-\xBD])))])*)

/* END patterns for SPARQLfed terminals */

/* START semantic actions for SPARQLfed terminals */
%%
{PASSED_TOKENS}		{ /* yylloc->step(); @@ needed? useful? */ }
{IT_REPLACE}		{return token::IT_REPLACE;}
{IT_WITH}		{return token::IT_WITH;}
{IT_DELETE}		{return token::IT_DELETE;}
{IT_INSERT}		{return token::IT_INSERT;}
{IT_GRAPH}		{return token::IT_GRAPH;}
{IT_LOAD}		{return token::IT_LOAD;}
{IT_INTO}		{return token::IT_INTO;}
{IT_CLEAR}		{return token::IT_CLEAR;}
{IT_CREATE}		{return token::IT_CREATE;}
{IT_SILENT}		{return token::IT_SILENT;}
{IT_DROP}		{return token::IT_DROP;}
{IT_BASE}		{return token::IT_BASE;}
{IT_PREFIX}		{return token::IT_PREFIX;}
{IT_SELECT}		{return token::IT_SELECT;}
{IT_DISTINCT}		{return token::IT_DISTINCT;}
{IT_REDUCED}		{return token::IT_REDUCED;}
{GT_TIMES}		{return token::GT_TIMES;}
{IT_CONSTRUCT}		{return token::IT_CONSTRUCT;}
{IT_DESCRIBE}		{return token::IT_DESCRIBE;}
{IT_ASK}		{return token::IT_ASK;}
{IT_FROM}		{return token::IT_FROM;}
{IT_NAMED}		{return token::IT_NAMED;}
{IT_WHERE}		{return token::IT_WHERE;}
{IT_ORDER}		{return token::IT_ORDER;}
{IT_BY}		{return token::IT_BY;}
{IT_ASC}		{return token::IT_ASC;}
{IT_DESC}		{return token::IT_DESC;}
{IT_LIMIT}		{return token::IT_LIMIT;}
{IT_OFFSET}		{return token::IT_OFFSET;}
{IT_BINDINGS}		{return token::IT_BINDINGS;}
{GT_LCURLEY}		{return token::GT_LCURLEY;}
{GT_RCURLEY}		{return token::GT_RCURLEY;}
{GT_LPAREN}		{return token::GT_LPAREN;}
{GT_RPAREN}		{return token::GT_RPAREN;}
{IT_NULL}		{return token::IT_NULL;}
{GT_DOT}		{return token::GT_DOT;}
{IT_OPTIONAL}		{return token::IT_OPTIONAL;}
{IT_UNION}		{return token::IT_UNION;}
{IT_FILTER}		{return token::IT_FILTER;}
{GT_COMMA}		{return token::GT_COMMA;}
{GT_SEMI}		{return token::GT_SEMI;}
{IT_a}		{return token::IT_a;}
{GT_LBRACKET}		{return token::GT_LBRACKET;}
{GT_RBRACKET}		{return token::GT_RBRACKET;}
{GT_OR}		{return token::GT_OR;}
{GT_AND}		{return token::GT_AND;}
{GT_EQUAL}		{return token::GT_EQUAL;}
{GT_NEQUAL}		{return token::GT_NEQUAL;}
{GT_LT}		{return token::GT_LT;}
{GT_GT}		{return token::GT_GT;}
{GT_LE}		{return token::GT_LE;}
{GT_GE}		{return token::GT_GE;}
{GT_PLUS}		{return token::GT_PLUS;}
{GT_MINUS}		{return token::GT_MINUS;}
{GT_DIVIDE}		{return token::GT_DIVIDE;}
{GT_NOT}		{return token::GT_NOT;}
{IT_STR}		{return token::IT_STR;}
{IT_LANG}		{return token::IT_LANG;}
{IT_LANGMATCHES}		{return token::IT_LANGMATCHES;}
{IT_DATATYPE}		{return token::IT_DATATYPE;}
{IT_BOUND}		{return token::IT_BOUND;}
{IT_sameTerm}		{return token::IT_sameTerm;}
{IT_isIRI}		{return token::IT_isIRI;}
{IT_isURI}		{return token::IT_isURI;}
{IT_isBLANK}		{return token::IT_isBLANK;}
{IT_isLITERAL}		{return token::IT_isLITERAL;}
{IT_REGEX}		{return token::IT_REGEX;}
{GT_DTYPE}		{return token::GT_DTYPE;}
{IT_true}		{yylval->p_BooleanRDFLiteral = driver->getBooleanRDFLiteral("TRUE", yytext); return token::IT_true;}
{IT_false}		{yylval->p_BooleanRDFLiteral = driver->getBooleanRDFLiteral("FALSE", yytext); return token::IT_false;}
{IRI_REF}		{yylval->p_URI = resolveBase(yytext, true); return token::IRI_REF;}
{LANGTAG}		{yylval->p_LANGTAG = new LANGTAG(yytext+1); return token::LANGTAG;}
{INTEGER}		{return typedLiteral(yylval, token::INTEGER);}
{DECIMAL}		{return typedLiteral(yylval, token::DECIMAL);}
{INTEGER_POSITIVE}		{return typedLiteral(yylval, token::INTEGER_POSITIVE);}
{DECIMAL_POSITIVE}		{return typedLiteral(yylval, token::DECIMAL_POSITIVE);}
{INTEGER_NEGATIVE}		{return typedLiteral(yylval, token::INTEGER_NEGATIVE);}
{DECIMAL_NEGATIVE}		{return typedLiteral(yylval, token::DECIMAL_NEGATIVE);}
{DOUBLE}		{return typedLiteral(yylval, token::DOUBLE);}
{DOUBLE_NEGATIVE}		{return typedLiteral(yylval, token::DOUBLE_NEGATIVE);}
{DOUBLE_POSITIVE}		{return typedLiteral(yylval, token::DOUBLE_POSITIVE);}
{STRING_LITERAL_LONG1}		{return unescape(yylval, 3, token::STRING_LITERAL_LONG1);}
{STRING_LITERAL_LONG2}		{return unescape(yylval, 3, token::STRING_LITERAL_LONG2);}
{STRING_LITERAL1}		{return unescape(yylval, 1, token::STRING_LITERAL1);}
{STRING_LITERAL2}		{return unescape(yylval, 1, token::STRING_LITERAL2);}
{NIL}		{return token::NIL;}
{ANON}		{yylval->p_POS = driver->createBNode(); return token::ANON;}
{PNAME_NS}		{yylval->p_URI = driver->ignorePrefix() ? driver->getURI(yytext) : resolvePrefix(yytext); return token::PNAME_NS;}
{PNAME_LN}		{yylval->p_URI = resolvePrefix(yytext); return token::PNAME_LN;}
{BLANK_NODE_LABEL}		{yylval->p_POS = driver->getBNode(yytext+2); return token::BLANK_NODE_LABEL;}
{VAR1}		{yylval->p_Variable = driver->getVariable(yytext+1); return token::VAR1;}
{VAR2}		{yylval->p_Variable = driver->getVariable(yytext+1); return token::VAR2;}

<<EOF>>			{ yyterminate();}
%%
/* END semantic actions for SPARQLfed terminals */

/* START SPARQLfedScanner */
namespace w3c_sw {

SPARQLfedScanner::SPARQLfedScanner (SPARQLfedDriver* driver, std::istream* in, std::ostream* out) : SPARQLfedFlexLexer(in, out), driver(driver) {  }
SPARQLfedScanner::~SPARQLfedScanner () {  }

SPARQLfedParser::token_type SPARQLfedScanner::typedLiteral (SPARQLfedParser::semantic_type*& yylval, SPARQLfedParser::token_type tok) {
    std::istringstream is(yytext);
    std::ostringstream normalized;

    switch (tok) {
    case token::INTEGER:
    case token::INTEGER_POSITIVE:
    case token::INTEGER_NEGATIVE:
	int i;
	is >> i;
	normalized << i;
	yylval->p_NumericRDFLiteral = driver->getNumericRDFLiteral(normalized.str().c_str(), i);
	return tok;
    case token::DECIMAL:
    case token::DECIMAL_POSITIVE:
    case token::DECIMAL_NEGATIVE:
	float f;
	is >> f;
	normalized << f;
	yylval->p_NumericRDFLiteral = driver->getNumericRDFLiteral(normalized.str().c_str(), f);
	return tok;
    case token::DOUBLE:
    case token::DOUBLE_POSITIVE:
    case token::DOUBLE_NEGATIVE:
	double d;
	is >> d;
	normalized << d;
	yylval->p_NumericRDFLiteral = driver->getNumericRDFLiteral(normalized.str().c_str(), d);
	return tok;
    default: throw(new std::exception());
    }
}

SPARQLfedParser::token_type SPARQLfedScanner::unescape (SPARQLfedParser::semantic_type*& yylval, size_t skip, SPARQLfedParser::token_type tok){
    std::string* space = new std::string;
    for (size_t i = skip; i < yyleng-skip; i++) {
	if (yytext[i] == '\\') {
	    switch (yytext[++i]) {
	    case 't': (*space) += '\t'; break;
	    case 'n': (*space) += '\n'; break;
	    case 'r': (*space) += '\r'; break;
	    case 'b': (*space) += '\b'; break;
	    case 'f': (*space) += '\f'; break;
	    case '"': (*space) += '\"'; break;
	    case '\'': (*space) += '\''; break;
	    case '\\': (*space) += '\\'; break;
	    default: throw(new std::exception());
	    }
	} else {
	    (*space) += yytext[i];
	}
    }
    yylval->p_string = space;
    return tok;
}


URI* SPARQLfedScanner::resolvePrefix (const char* yytext){
    std::string ret(yytext);
    size_t index = ret.find(':');
    if (index == std::string::npos)
	throw(std::runtime_error("Inexplicable lack of ':' in prefix"));
    URI* nspace = driver->getNamespace(ret.substr(0, index));
    if (nspace == NULL) {
	std::stringstream err;
	err << "Unknown prefix: \"" << ret.substr(0, index) << " asdf";
	throw(std::runtime_error(err.str()));
    }
    ret.replace(0, index+1, nspace->getTerminal());
    return resolveBase(ret.c_str(), false);
}

void SPARQLfedScanner::set_debug(bool b)
{
    yy_flex_debug = b;
}

} // END namespace w3c_sw
/* END SPARQLfedScanner */

w3c_sw::URI* w3c_sw::SPARQLfedScanner::resolveBase (const char* p_rel, bool stripDelims) {
    std::string stripped(p_rel);
    if (stripDelims) {
	stripped.replace(0, 1, "");
	stripped.replace(stripped.size()-1, 1, "");
    }
    return driver->getAbsoluteURI(stripped.c_str());

#if 0
    // was a transliteration of _generic.pm
    static const boost::regex re_scheme("^([a-zA-Z][a-zA-Z0-9.+-]*):");
    static const boost::regex re_authority("^((?:[a-zA-Z][a-zA-Z0-9.+-]*)?)(?://([^/?\\#]*))?(.*)$");
    static const boost::regex re_path("^((?:[^:/?\\#]+:)?(?://[^/?\\#]*)?)([^?\\#]*)(.*)$");

    boost::smatch what;
    w3c_sw::URI* baseURI = driver->getBase();
    std::string base;
    if (baseURI != NULL)
	std::string base = baseURI->getTerminal();
    std::string base_scheme;
    if (base.size() > 0 && boost::regex_search(base, what, re_scheme))
	base_scheme = what[1];
    if (boost::regex_search(self, what, re_scheme) &&
	what[1] != base_schema)
	return driver->getURI(self.c_str());
    if (base.size() == 0)
	throw(std::runtime_error(((std::string)"no base declared while resolving relative URI ").append(abs)));

    std::string abs(self);
    if (!boost::regex_search(base, what, re_scheme))
	throw(std::runtime_error(((std::string)"resolving against base URI with no scheme ").append(base)));
    // !!! abs->scheme = base_scheme
    if (false) ; // ...

    if (!boost::regex_search(base, what, re_authority))
	throw(std::runtime_error(((std::string)"resolving against base URI with no authority ").append(base)));
    std::string base_authority(what[2]);

    if (!boost::regex_search(rel, what, re_path))
	throw(std::runtime_error(((std::string)"oddly failed to match re_path on ").append(rel)));
    std::string rel_path(what[2]);
    if (rel_path.find("/") == 0) return driver->getURI(abs.c_str());

#endif
}

/* This implementation of SPARQLfedFlexLexer::yylex() is required to fill the
 * vtable of the class SPARQLfedFlexLexer. We define the scanner's main yylex
 * function via YY_DECL to reside in the SPARQLfedScanner class instead. */

#ifdef yylex
#undef yylex
#endif

int SPARQLfedFlexLexer::yylex()
{
    std::cerr << "in SPARQLfedFlexLexer::yylex() !" << std::endl;
    return 0;
}