recoll / Code / Diff of /src/query/wasaparseaux.cpp

Diff of /src/query/wasaparseaux.cpp [3cda80] .. [c28908]

Switch to unified view


...
    if (!sd) 
        reason = d.getreason();
    return sd;
}

WasaParserDriver::WasaParserDriver(const RclConfig *c, const std::string sl, 
                                   const std::string& as)
    : m_stemlang(sl), m_autosuffs(as), m_config(c),
      m_index(0), m_result(0), m_haveDates(false), 
      m_maxSize((size_t)-1), m_minSize((size_t)-1)
{

}

WasaParserDriver::~WasaParserDriver()
{
}

SearchData *WasaParserDriver::parse(const std::string& in)
{
    m_input = in;
    m_index = 0;
    delete m_result;
...
    if (parser.parse() != 0) {
        delete m_result;
        m_result = 0;
    }

    if (m_result == 0)
        return m_result;

    // Set the top level filters (types, dates, size)
    for (vector<string>::const_iterator it = m_filetypes.begin();
         it != m_filetypes.end(); it++) {
        m_result->addFiletype(*it);
    }
    for (vector<string>::const_iterator it = m_nfiletypes.begin();
         it != m_nfiletypes.end(); it++) {
        m_result->remFiletype(*it);
    }
    if (m_haveDates) {
        m_result->setDateSpan(&m_dates);
    }
    if (m_minSize != (size_t)-1) {
        m_result->setMinSize(m_minSize);
    }
    if (m_maxSize != (size_t)-1) {
        m_result->setMaxSize(m_maxSize);
    }
    //if (m_result)  m_result->dump(cout);
    return m_result;
}

int WasaParserDriver::GETCHAR()
{
...
    string fld = stringtolower(ofld);

    // MIME types and categories
    if (!fld.compare("mime") || !fld.compare("format")) {
        if (cl->getexclude()) {
            m_nfiletypes.push_back(cl->gettext());
        } else {
            m_filetypes.push_back(cl->gettext());
        }
        delete cl;
        return false;
    } 

    if (!fld.compare("rclcat") || !fld.compare("type")) {
        vector<string> mtypes;
        if (m_config && m_config->getMimeCatTypes(cl->gettext(), mtypes)) {
            for (vector<string>::iterator mit = mtypes.begin();
                 mit != mtypes.end(); mit++) {
                if (cl->getexclude()) {
                    m_nfiletypes.push_back(*mit);
                } else {
                    m_filetypes.push_back(*mit);
                }
            }
        }
        delete cl;
        return false;
    }

    // Handle "date" spec
    if (!fld.compare("date")) {
        DateInterval di;
...
            delete cl;
            return false;
        }
        LOGDEB(("addClause:: date span:  %d-%d-%d/%d-%d-%d\n",
                di.y1,di.m1,di.d1, di.y2,di.m2,di.d2));
        m_haveDates = true;
        m_dates = di;
        delete cl;
        return false;
    } 

    // Handle "size" spec
    if (!fld.compare("size")) {
        char *cp;
...

        delete cl;

        switch (rel) {
        case SearchDataClause::REL_EQUALS:
            m_maxSize = m_minSize = size;

            break;
        case SearchDataClause::REL_LT:
        case SearchDataClause::REL_LTE:
            m_maxSize = size;
            break;
        case SearchDataClause::REL_GT: 
        case SearchDataClause::REL_GTE:
            m_minSize = size;
            break;
        default:
            m_reason = "Bad relation operator with size query. Use > < or =";
            return false;
        }
        return false;
    }

    if (!fld.compare("dir")) {
        // dir filtering special case
        SearchDataClausePath *nclause = 

	a/src/query/wasaparseaux.cpp		b/src/query/wasaparseaux.cpp
	...		...
49	if (!sd)	49	if (!sd)
50	reason = d.getreason();	50	reason = d.getreason();
51	return sd;	51	return sd;
52	}	52	}
53		53
		54	WasaParserDriver::WasaParserDriver(const RclConfig *c, const std::string sl,
		55	const std::string& as)
		56	: m_stemlang(sl), m_autosuffs(as), m_config(c),
		57	m_index(0), m_result(0), m_haveDates(false),
		58	m_maxSize((size_t)-1), m_minSize((size_t)-1)
		59	{
		60
		61	}
		62
		63	WasaParserDriver::~WasaParserDriver()
		64	{
		65	}
		66
54	SearchData *WasaParserDriver::parse(const std::string& in)	67	SearchData *WasaParserDriver::parse(const std::string& in)
55	{	68	{
56	m_input = in;	69	m_input = in;
57	m_index = 0;	70	m_index = 0;
58	delete m_result;	71	delete m_result;
	...		...
65	if (parser.parse() != 0) {	78	if (parser.parse() != 0) {
66	delete m_result;	79	delete m_result;
67	m_result = 0;	80	m_result = 0;
68	}	81	}
69		82
		83	if (m_result == 0)
		84	return m_result;
		85
		86	// Set the top level filters (types, dates, size)
		87	for (vector<string>::const_iterator it = m_filetypes.begin();
		88	it != m_filetypes.end(); it++) {
		89	m_result->addFiletype(*it);
		90	}
		91	for (vector<string>::const_iterator it = m_nfiletypes.begin();
		92	it != m_nfiletypes.end(); it++) {
		93	m_result->remFiletype(*it);
		94	}
		95	if (m_haveDates) {
		96	m_result->setDateSpan(&m_dates);
		97	}
		98	if (m_minSize != (size_t)-1) {
		99	m_result->setMinSize(m_minSize);
		100	}
		101	if (m_maxSize != (size_t)-1) {
		102	m_result->setMaxSize(m_maxSize);
		103	}
		104	//if (m_result) m_result->dump(cout);
70	return m_result;	105	return m_result;
71	}	106	}
72		107
73	int WasaParserDriver::GETCHAR()	108	int WasaParserDriver::GETCHAR()
74	{	109	{
	...		...
112	string fld = stringtolower(ofld);	147	string fld = stringtolower(ofld);
113		148
114	// MIME types and categories	149	// MIME types and categories
115	if (!fld.compare("mime") \|\| !fld.compare("format")) {	150	if (!fld.compare("mime") \|\| !fld.compare("format")) {
116	if (cl->getexclude()) {	151	if (cl->getexclude()) {
117	sd->remFiletype(cl->gettext());	152	m_nfiletypes.push_back(cl->gettext());
118	} else {	153	} else {
119	sd->addFiletype(cl->gettext());	154	m_filetypes.push_back(cl->gettext());
120	}	155	}
121	delete cl;	156	delete cl;
122	return true;	157	return false;
123	}	158	}
124		159
125	if (!fld.compare("rclcat") \|\| !fld.compare("type")) {	160	if (!fld.compare("rclcat") \|\| !fld.compare("type")) {
126	vector<string> mtypes;	161	vector<string> mtypes;
127	if (m_config && m_config->getMimeCatTypes(cl->gettext(), mtypes)) {	162	if (m_config && m_config->getMimeCatTypes(cl->gettext(), mtypes)) {
128	for (vector<string>::iterator mit = mtypes.begin();	163	for (vector<string>::iterator mit = mtypes.begin();
129	mit != mtypes.end(); mit++) {	164	mit != mtypes.end(); mit++) {
130	if (cl->getexclude()) {	165	if (cl->getexclude()) {
131	sd->remFiletype(*mit);	166	m_nfiletypes.push_back(*mit);
132	} else {	167	} else {
133	sd->addFiletype(*mit);	168	m_filetypes.push_back(*mit);
134	}	169	}
135	}	170	}
136	}	171	}
137	delete cl;	172	delete cl;
138	return true;	173	return false;
139	}	174	}
140		175
141	// Handle "date" spec	176	// Handle "date" spec
142	if (!fld.compare("date")) {	177	if (!fld.compare("date")) {
143	DateInterval di;	178	DateInterval di;
	...		...
148	delete cl;	183	delete cl;
149	return false;	184	return false;
150	}	185	}
151	LOGDEB(("addClause:: date span: %d-%d-%d/%d-%d-%d\n",	186	LOGDEB(("addClause:: date span: %d-%d-%d/%d-%d-%d\n",
152	di.y1,di.m1,di.d1, di.y2,di.m2,di.d2));	187	di.y1,di.m1,di.d1, di.y2,di.m2,di.d2));
153	sd->setDateSpan(&di);	188	m_haveDates = true;
		189	m_dates = di;
154	delete cl;	190	delete cl;
155	return true;	191	return false;
156	}	192	}
157		193
158	// Handle "size" spec	194	// Handle "size" spec
159	if (!fld.compare("size")) {	195	if (!fld.compare("size")) {
160	char *cp;	196	char *cp;
	...		...
176		212
177	delete cl;	213	delete cl;
178		214
179	switch (rel) {	215	switch (rel) {
180	case SearchDataClause::REL_EQUALS:	216	case SearchDataClause::REL_EQUALS:
181	sd->setMaxSize(size);	217	m_maxSize = m_minSize = size;
182	sd->setMinSize(size);
183	break;	218	break;
184	case SearchDataClause::REL_LT:	219	case SearchDataClause::REL_LT:
185	case SearchDataClause::REL_LTE:	220	case SearchDataClause::REL_LTE:
186	sd->setMaxSize(size);	221	m_maxSize = size;
187	break;	222	break;
188	case SearchDataClause::REL_GT:	223	case SearchDataClause::REL_GT:
189	case SearchDataClause::REL_GTE:	224	case SearchDataClause::REL_GTE:
190	sd->setMinSize(size);	225	m_minSize = size;
191	break;	226	break;
192	default:	227	default:
193	m_reason = "Bad relation operator with size query. Use > < or =";	228	m_reason = "Bad relation operator with size query. Use > < or =";
194	return false;	229	return false;
195	}	230	}
196	return true;	231	return false;
197	}	232	}
198		233
199	if (!fld.compare("dir")) {	234	if (!fld.compare("dir")) {
200	// dir filtering special case	235	// dir filtering special case
201	SearchDataClausePath *nclause =	236	SearchDataClausePath *nclause =