recoll / Code / Diff of /src/query/wasaparse.ypp

Diff of /src/query/wasaparse.ypp [26d15d] .. [595e41]

Switch to unified view


...
#include "wasaparserdriver.h"
#include "wasaparse.hpp"

using namespace std;

//#define LOG_PARSER
#ifdef LOG_PARSER
#define LOGP(X) {cerr << X;}
#else
#define LOGP(X)
#endif
...
%parse-param {WasaParserDriver* d}
%lex-param {WasaParserDriver* d}

%union {
    std::string *str;
    Rcl::SearchDataClauseRange *rg;
    Rcl::SearchDataClauseSimple *cl;
    Rcl::SearchData *sd;
}
%destructor {delete $$;} <str>

%type <cl> qualquote
%type <cl> fieldexpr
%type <rg> range
%type <cl> term
%type <sd> query
%type <str> complexfieldname

/* Non operator tokens need precedence because of the possibility of
...
%left <str> QUOTED
%left <str> QUALIFIERS
%left AND UCONCAT '(' '-'
%left OR

%token EQUALS CONTAINS SMALLEREQ SMALLER GREATEREQ GREATER RANGE

%%

topquery: query
{
...
    $3->setfield(*$1);
    $3->setrel(Rcl::SearchDataClause::REL_CONTAINS);
    $$ = $3;
    delete $1;
}
| complexfieldname CONTAINS range
{
    LOGP("fe: " << *$1 << " : " << $3->gettext() << endl);
    $3->setfield(*$1);
    $3->setrel(Rcl::SearchDataClause::REL_CONTAINS);
    $$ = $3;
    delete $1;
}
| complexfieldname SMALLER term 
{
    LOGP("fe: " << *$1 << " < " << $3->gettext() << endl);
    $3->setfield(*$1);
    $3->setrel(Rcl::SearchDataClause::REL_LT);
    $$ = $3;
    delete $1;
}
...
    LOGP("cfn: complexfieldname ':' WORD" << endl);
    $$ = new string(*$1 + string(":") + *$3);
    delete $1;
    delete $3;
}

range:
WORD RANGE WORD
{
    LOGP("Range: " << *$1 << string(" .. ") << *$3 << endl);
    $$ = new Rcl::SearchDataClauseRange(*$1, *$3);
    delete $1;
    delete $3;
}
|
RANGE WORD
{
    LOGP("Range: " << "" << string(" .. ") << *$2 << endl);
    $$ = new Rcl::SearchDataClauseRange("", *$2);
    delete $2;
}
|
WORD RANGE
{
    LOGP("Range: " << *$1 << string(" .. ") << "" << endl);
    $$ = new Rcl::SearchDataClauseRange(*$1, "");
    delete $1;
}
;

term: 
WORD
{
    LOGP("term[" << *$1 << "]" << endl);
...
    if (specialstartchars.find_first_of(c) != string::npos) {
        //cerr << "yylex: return " << c << endl;
        return c;
    }

    // field-term relations, and ranges
    switch (c) {
    case '=': return yy::parser::token::EQUALS;
    case ':': return yy::parser::token::CONTAINS;
    case '<': {
        int c1 = d->GETCHAR();
...
        } else {
            d->UNGETCHAR(c1);
            return yy::parser::token::SMALLER;
        }
    }
    case '.': {
        int c1 = d->GETCHAR();
        if (c1 == '.') {
            return yy::parser::token::RANGE;
        } else {
            d->UNGETCHAR(c1);
            break;
        }
    }
    case '>': {
        int c1 = d->GETCHAR();
        if (c1 == '=') {
            return yy::parser::token::GREATEREQ;
        } else {
...
            break;
        } else if (specialinchars.find_first_of(c) != string::npos) {
            //cerr << "Word broken by special char" << endl;
            d->UNGETCHAR(c);
            break;
        } else if (c == '.') {
            int c1 = d->GETCHAR();
            if (c1 == '.') {
                d->UNGETCHAR(c1);
                d->UNGETCHAR(c);
                break;
            } else {
                d->UNGETCHAR(c1);
                word->push_back(c);
            }
        } else if (c == 0) {
            //cerr << "Word broken by EOF" << endl;
            break;
        } else {
            word->push_back(c);

	a/src/query/wasaparse.ypp		b/src/query/wasaparse.ypp
	...		...
11	#include "wasaparserdriver.h"	11	#include "wasaparserdriver.h"
12	#include "wasaparse.hpp"	12	#include "wasaparse.hpp"
13		13
14	using namespace std;	14	using namespace std;
15		15
16	// #define LOG_PARSER	16	//#define LOG_PARSER
17	#ifdef LOG_PARSER	17	#ifdef LOG_PARSER
18	#define LOGP(X) {cerr << X;}	18	#define LOGP(X) {cerr << X;}
19	#else	19	#else
20	#define LOGP(X)	20	#define LOGP(X)
21	#endif	21	#endif
	...		...
43	%parse-param {WasaParserDriver* d}	43	%parse-param {WasaParserDriver* d}
44	%lex-param {WasaParserDriver* d}	44	%lex-param {WasaParserDriver* d}
45		45
46	%union {	46	%union {
47	std::string *str;	47	std::string *str;
		48	Rcl::SearchDataClauseRange *rg;
48	Rcl::SearchDataClauseSimple *cl;	49	Rcl::SearchDataClauseSimple *cl;
49	Rcl::SearchData *sd;	50	Rcl::SearchData *sd;
50	}	51	}
51	%destructor {delete $$;} <str>	52	%destructor {delete $$;} <str>
52		53
53	%type <cl> qualquote	54	%type <cl> qualquote
54	%type <cl> fieldexpr	55	%type <cl> fieldexpr
		56	%type <rg> range
55	%type <cl> term	57	%type <cl> term
56	%type <sd> query	58	%type <sd> query
57	%type <str> complexfieldname	59	%type <str> complexfieldname
58		60
59	/* Non operator tokens need precedence because of the possibility of	61	/* Non operator tokens need precedence because of the possibility of
	...		...
62	%left <str> QUOTED	64	%left <str> QUOTED
63	%left <str> QUALIFIERS	65	%left <str> QUALIFIERS
64	%left AND UCONCAT '(' '-'	66	%left AND UCONCAT '(' '-'
65	%left OR	67	%left OR
66		68
67	%token EQUALS CONTAINS SMALLEREQ SMALLER GREATEREQ GREATER	69	%token EQUALS CONTAINS SMALLEREQ SMALLER GREATEREQ GREATER RANGE
68		70
69	%%	71	%%
70		72
71	topquery: query	73	topquery: query
72	{	74	{
	...		...
152	$3->setfield(*$1);	154	$3->setfield(*$1);
153	$3->setrel(Rcl::SearchDataClause::REL_CONTAINS);	155	$3->setrel(Rcl::SearchDataClause::REL_CONTAINS);
154	$$ = $3;	156	$$ = $3;
155	delete $1;	157	delete $1;
156	}	158	}
		159	\| complexfieldname CONTAINS range
		160	{
		161	LOGP("fe: " << *$1 << " : " << $3->gettext() << endl);
		162	$3->setfield(*$1);
		163	$3->setrel(Rcl::SearchDataClause::REL_CONTAINS);
		164	$$ = $3;
		165	delete $1;
		166	}
157	\| complexfieldname SMALLER term	167	\| complexfieldname SMALLER term
158	{	168	{
159	LOGP(cerr << "fe: " << *$1 << " < " << $3->gettext() << endl);	169	LOGP("fe: " << *$1 << " < " << $3->gettext() << endl);
160	$3->setfield(*$1);	170	$3->setfield(*$1);
161	$3->setrel(Rcl::SearchDataClause::REL_LT);	171	$3->setrel(Rcl::SearchDataClause::REL_LT);
162	$$ = $3;	172	$$ = $3;
163	delete $1;	173	delete $1;
164	}	174	}
	...		...
207	LOGP("cfn: complexfieldname ':' WORD" << endl);	217	LOGP("cfn: complexfieldname ':' WORD" << endl);
208	$$ = new string($1 + string(":") + $3);	218	$$ = new string($1 + string(":") + $3);
209	delete $1;	219	delete $1;
210	delete $3;	220	delete $3;
211	}	221	}
		222
		223	range:
		224	WORD RANGE WORD
		225	{
		226	LOGP("Range: " << $1 << string(" .. ") << $3 << endl);
		227	$$ = new Rcl::SearchDataClauseRange($1, $3);
		228	delete $1;
		229	delete $3;
		230	}
		231	\|
		232	RANGE WORD
		233	{
		234	LOGP("Range: " << "" << string(" .. ") << *$2 << endl);
		235	$$ = new Rcl::SearchDataClauseRange("", *$2);
		236	delete $2;
		237	}
		238	\|
		239	WORD RANGE
		240	{
		241	LOGP("Range: " << *$1 << string(" .. ") << "" << endl);
		242	$$ = new Rcl::SearchDataClauseRange(*$1, "");
		243	delete $1;
		244	}
		245	;
212		246
213	term:	247	term:
214	WORD	248	WORD
215	{	249	{
216	LOGP("term[" << *$1 << "]" << endl);	250	LOGP("term[" << *$1 << "]" << endl);
	...		...
387	if (specialstartchars.find_first_of(c) != string::npos) {	421	if (specialstartchars.find_first_of(c) != string::npos) {
388	//cerr << "yylex: return " << c << endl;	422	//cerr << "yylex: return " << c << endl;
389	return c;	423	return c;
390	}	424	}
391		425
392	// field-term relations	426	// field-term relations, and ranges
393	switch (c) {	427	switch (c) {
394	case '=': return yy::parser::token::EQUALS;	428	case '=': return yy::parser::token::EQUALS;
395	case ':': return yy::parser::token::CONTAINS;	429	case ':': return yy::parser::token::CONTAINS;
396	case '<': {	430	case '<': {
397	int c1 = d->GETCHAR();	431	int c1 = d->GETCHAR();
	...		...
400	} else {	434	} else {
401	d->UNGETCHAR(c1);	435	d->UNGETCHAR(c1);
402	return yy::parser::token::SMALLER;	436	return yy::parser::token::SMALLER;
403	}	437	}
404	}	438	}
		439	case '.': {
		440	int c1 = d->GETCHAR();
		441	if (c1 == '.') {
		442	return yy::parser::token::RANGE;
		443	} else {
		444	d->UNGETCHAR(c1);
		445	break;
		446	}
		447	}
405	case '>': {	448	case '>': {
406	int c1 = d->GETCHAR();	449	int c1 = d->GETCHAR();
407	if (c1 == '=') {	450	if (c1 == '=') {
408	return yy::parser::token::GREATEREQ;	451	return yy::parser::token::GREATEREQ;
409	} else {	452	} else {
	...		...
428	break;	471	break;
429	} else if (specialinchars.find_first_of(c) != string::npos) {	472	} else if (specialinchars.find_first_of(c) != string::npos) {
430	//cerr << "Word broken by special char" << endl;	473	//cerr << "Word broken by special char" << endl;
431	d->UNGETCHAR(c);	474	d->UNGETCHAR(c);
432	break;	475	break;
		476	} else if (c == '.') {
		477	int c1 = d->GETCHAR();
		478	if (c1 == '.') {
		479	d->UNGETCHAR(c1);
		480	d->UNGETCHAR(c);
		481	break;
		482	} else {
		483	d->UNGETCHAR(c1);
		484	word->push_back(c);
		485	}
433	} else if (c == 0) {	486	} else if (c == 0) {
434	//cerr << "Word broken by EOF" << endl;	487	//cerr << "Word broken by EOF" << endl;
435	break;	488	break;
436	} else {	489	} else {
437	word->push_back(c);	490	word->push_back(c);