Changeset 4209 for trunk/gsdl/src/mgpp/text/GSDLQueryParser.cpp

Timestamp:

2003-05-01T10:58:25+12:00 (21 years ago)

Author:

kjdon

Message:

parseQuery (in GSDLQueryParser) now returns NULL if there has been a syntax error. So all the auxiliary functions either return NULl if there is an error, or set an error flag to true. Queryer now tells the user that there has been invalid syntax rather than seg faulting

File:

• trunk/gsdl/src/mgpp/text/GSDLQueryParser.cpp (modified) (11 diffs)

trunk/gsdl/src/mgpp/text/GSDLQueryParser.cpp

@@ -26 +26 @@
 static QueryNode *ParseExpression (UCArray::const_iterator &here,
                    UCArray::const_iterator end, 
-                   int defaultBoolCOmbine,
+                   int defaultBoolCombine,
                    int defaultStemMethod);
 
@@ -95 +95 @@
   UCArray NEARBY; SetCStr(NEARBY, "NEAR");
   if (nearby == NEARBY) { // no modifier
-    termNode.startRange = -21;
-    termNode.endRange = 20;
+    termNode.startRange = (NEAR_DEFAULT+1)*-1;
+    termNode.endRange = NEAR_DEFAULT;
+
   }
   else { // extract number
@@ -215 +216 @@
 
 // expects starting brackets to have been parsed
+// sets error to true if something has gone wrong
 static void ParseSquareBrackets(UCArray::const_iterator &here,
                 UCArray::const_iterator end,
                 ProxMatchQueryNode *proxNode,
-                int defaultStemMethod) {
+                int defaultStemMethod,
+                bool & error) {
 
   LexEl el;
@@ -240 +243 @@
       break;
     }
-    else if (el.lexType == AndOpE) {
-      // ignore, the words are AND'ed anyway
-      cerr << "and inside []\n";
-    }
-    else if (el.lexType == OrOpE) {
-      cerr << "or inside []\n";
-    }
     else if (el.lexType == QuoteE) {
       // phrase inside square brackets
@@ -253 +249 @@
     }
     else {
-      //error
-      // just ignore for now
-      cerr <<"bad syntax inside []\n";
+      //error - we set the proxNode to NULL,
+      cerr <<"GSDLQueryParser: bad syntax inside []\n";
+      error = true;
+      return;
     }
   } // while
@@ -267 +264 @@
              UCArray::const_iterator end,
              ProxMatchQueryNode &proxNode, 
-             int defaultStemMethod) {
+             int defaultStemMethod,
+             bool &error) {
   LexEl el;
   bool first = true;
@@ -289 +287 @@
       
     } else {
-      // error
-      break;
+      // error 
+      error = true;
+      return;
     }
   }
@@ -316 +315 @@
     oldHere = here;  // dont backtrack past here
     if (ParseLexEl(here, end, el) && el.lexType == NearOpE) {
-      delete proxNode;
+    delete proxNode;
+    oldHere = here;
+      // this is calling ParseTerm again, but only a subset of the things accepted by ParseTerm are appropriate here. add in some hacks to avoid segmentation faults - kjdon, 04/2003
+      
+      // if the next element is a '(' have a syntax error, return NULL 
+      LexEl temp_el;
+      if (ParseLexEl(here, end, temp_el) && temp_el.lexType == OpenBracketE) {
+    cerr << "GSDLQueryParser: NEAR cannot be followed by a '('\n";
+    return NULL;
+      }
+      here = oldHere; // else backtrack
+    
       proxNode = (ProxMatchQueryNode *)ParseTerm(here, end, defaultBoolCombine,
                          defaultStemMethod);
@@ -322 +332 @@
       proxNode->terms.push_back (termNode);
       return proxNode;
-    }
-    else {
+      
+    } else {
       here = oldHere; // backtrack
       proxNode->terms.push_back (termNode);
@@ -330 +340 @@
     }
   } else if (el.lexType == QuoteE) {
-    ParsePhrase (here, end, *proxNode, defaultStemMethod);
+    bool error = false;
+    ParsePhrase (here, end, *proxNode, defaultStemMethod, error);
+    if (error) {
+      delete proxNode;
+      return NULL;
+    }
     return proxNode;
   }
   else if (el.lexType == OpenSquareBracketE) {
-    ParseSquareBrackets (here, end, proxNode, defaultStemMethod);
+    bool error = false;
+    ParseSquareBrackets (here, end, proxNode, defaultStemMethod, error);
+    if (error) {
+      delete proxNode;
+      return NULL;
+    }
     ParseProxModifiers (here, end, proxNode);
     return proxNode;
@@ -352 +372 @@
   LexEl el;
   QueryNode *curTree = NULL;
-
   UCArray::const_iterator oldHere = here;
   while (ParseLexEl (here, end, el)) {
-    if (el.lexType == OpenSquareBracketE ||
-    el.lexType == OpenBracketE ||
-    el.lexType == TermE ||
-    el.lexType == QuoteE ||
-    el.lexType == IntegerE ) {
-    //  el.lexType == TagE) { //tag at end of term now
-      // some type of term, back track and parse it
-      here = oldHere;
-      // if default==1, AND, else if==0, OR
-      if (defaultBoolCombine) {
-    curTree = AndAdd (curTree, ParseTerm (here, end, defaultBoolCombine, 
-                          defaultStemMethod));
-      }
-      else {
-    curTree = OrAdd (curTree, ParseTerm (here, end, defaultBoolCombine,
-                         defaultStemMethod));
-      }
-
-    } else if (el.lexType == AndOpE) {
-      curTree = AndAdd (curTree, ParseTerm (here, end, defaultBoolCombine,
-                        defaultStemMethod));
-      
-    } else if (el.lexType == OrOpE) {
-      curTree = OrAdd (curTree, ParseTerm (here, end, defaultBoolCombine,
-                       defaultStemMethod));
-      
-    } else if (el.lexType == NotOpE) {
-      curTree = NotAdd (curTree, ParseTerm (here, end, defaultBoolCombine,
-                        defaultStemMethod));
-      
-    } else if (el.lexType == CloseBracketE) {
+    if (el.lexType == CloseBracketE) {
       // parsebracketexpression is waiting for the last bracket, so put it back
       here = oldHere;
       break;
-    
-    } else break;
-    
+      
+    } else if (el.lexType == OpenSquareBracketE ||
+           el.lexType == OpenBracketE ||
+           el.lexType == TermE ||
+           el.lexType == QuoteE ||
+           el.lexType == IntegerE ) { 
+      
+      // some type of term, back track and parse it
+      here = oldHere;
+
+      //  parse the term
+      QueryNode * newTerm = ParseTerm (here, end, defaultBoolCombine, 
+                       defaultStemMethod);
+      if (newTerm == NULL) {
+    delete curTree;
+    return NULL;
+      }
+
+      // if default==1, AND, else if==0, OR
+      if (defaultBoolCombine) {
+    curTree = AndAdd (curTree, newTerm);
+      }
+      else {
+    curTree = OrAdd (curTree, newTerm); 
+      }
+      
+    } else if (el.lexType == AndOpE) {
+      QueryNode * newTerm = ParseTerm (here, end, defaultBoolCombine,
+                       defaultStemMethod);
+      if (newTerm == NULL) {
+    delete curTree;
+    return NULL;
+      }
+      curTree = AndAdd (curTree, newTerm);
+      
+    } else if (el.lexType == OrOpE) {
+      QueryNode * newTerm = ParseTerm (here, end, defaultBoolCombine,
+                       defaultStemMethod);
+      if (newTerm == NULL) {
+    delete curTree;
+    return NULL;
+      }
+      curTree = OrAdd (curTree, newTerm);
+      
+    } else if (el.lexType == NotOpE) {
+      QueryNode * newTerm = ParseTerm (here, end, defaultBoolCombine,
+                       defaultStemMethod);
+      if (newTerm == NULL) {
+    delete curTree;
+    return NULL;
+      }
+      curTree = NotAdd (curTree, newTerm); 
+      
+    } else {
+
+      // syntax error, return NUll
+      delete curTree;
+      return NULL;
+    }
+
     oldHere = here;
   }