Changeset 7389

Timestamp:

2004-05-24T16:45:38+12:00 (20 years ago)

Author:

davidb

Message:

Format statment 'if' syntax extended to support operators such as
'eq' and 'ne'. Can now say things like: {If}{[format] eq 'ab cd',X,Y}
Two main changes in code. The first is where the text of the text-condition
of the if statement is handled. This now needs to be parsed, to ensure
any metadata present it recorded, so when 'docinfo' is setup the necessary
metadata is there. The second change is that, when the test condition
of the if statement is evaluated, it is parsed 'on the fly' to look
for the precence of an operator such as 'eq' or 'ne' (in fact these are
currently the only ones implemented; others, such as 'gt' for greater
than etc would be straightforward to add). If there is an operator
detected, the the left and right hand sides of the expression are
determined (any metadata looked up) and the operator applied.

Location:

trunk/gsdl/src/recpt

Files:

• formattools.cpp (modified) (4 diffs)
• formattools.h (modified) (1 diff)

trunk/gsdl/src/recpt/formattools.cpp

@@ -777 +777 @@
       // Decision is a piece of text (probably a macro like _cgiargmode_).
       else {
+
+        // hunt for any metadata in string, which might be uses in
+        // to test a condition, e.g. [Format] eq 'PDF'
+        format_t* dummyformat = new format_t();
+        // update which metadata fields needed 
+        // (not interested in updatng formatlistptr)
+        parse_string (text, dummyformat, metadata, getParents);
+        delete dummyformat;
+
         formatlistptr->decision.command = dText;
         formatlistptr->decision.text = text;
@@ -976 +985 @@
 }
 
+static bool char_is_whitespace(const char c) 
+{
+  return ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r'));
+
+}
+
+static int scan_over_whitespace(const text_t& outstring, const int start_pos)
+{
+  int pos = start_pos;
+  while (pos<outstring.size()) {
+    if (!char_is_whitespace(outstring[pos])) {
+      break;
+    }
+    pos++;
+  }
+
+  return pos;
+}
+
+static int rscan_over_whitespace(const text_t& outstring, const int start_pos)
+{
+  int pos = start_pos;
+  while (pos>=0) {
+    if (!char_is_whitespace(outstring[pos])) {
+      break;
+    }
+    pos--;
+  }
+
+  return pos;
+}
+
+static int rscan_for_whitespace(const text_t& outstring, const int start_pos)
+{
+  int pos = start_pos;
+  while (pos>=0) {
+    if (char_is_whitespace(outstring[pos])) {
+      break;
+    }
+    pos--;
+  }
+
+  return pos;
+}
+
+
+static int rscan_for(const text_t& outstring, const int start_pos, 
+             const char find_c)
+{
+  int pos = start_pos;
+  while (pos>=0) {
+    char c = outstring[pos];
+    if (outstring[pos] == find_c) {
+      break;
+    }
+    pos--;
+  }
+
+  return pos;
+}
+
+text_t extract_substr(const text_t& outstring, const int start_pos,
+              const int end_pos)
+{
+  text_t extracted_str;
+  extracted_str.clear();
+
+  for (int pos=start_pos; pos<=end_pos; pos++) {
+    extracted_str.push_back(outstring[pos]);
+  }
+
+  return extracted_str;
+}
+
+
+static text_t expand_potential_metadata(ResultDocInfo_t &docinfo, 
+                    const text_t& intext)
+{
+  text_t outtext;
+
+  // decide if dealing with metadata or text
+
+  text_t::const_iterator beginbracket = intext.begin();
+  text_t::const_iterator endbracket = (intext.end() - 1);
+
+  // Decision is based on a metadata element
+  if ((*beginbracket == '[') && (*endbracket == ']')) {
+    // Ignore the surrounding square brackets
+    text_t meta_text = substr (beginbracket+1, endbracket);
+
+    metadata_t meta;
+    meta.metaname = meta_text;
+    meta.parentcommand = pNone;
+    meta.metacommand = mSibling;
+
+    bool getParents =false;
+    outtext = get_meta (docinfo,meta);
+  }
+  else {
+    outtext = intext;
+  }
+
+  return outtext;
+}
+
+
+
+
+static bool uses_expression(ResultDocInfo_t &docinfo,
+                const text_t& outstring, text_t& lhs_expr,
+                text_t& op_expr, text_t& rhs_expr)
+{
+  // Note: the string may not be of the form: str1 op str2, however
+  // to deterine this we have to process it on the assumption it is,
+  // and if at any point an 'erroneous' value is encountered, return
+  // false and let something else have a go at evaluating it
+
+  // Starting at the end of the string and working backwards ..
+
+  const int outstring_len = outstring.size();
+
+  // skip over white space
+  int rhs_end = rscan_over_whitespace(outstring,outstring_len-1);
+
+  if (rhs_end<=0) { 
+    // no meaningful text or (rhs_end==0) no room for operator
+    return false;
+  }
+
+  // check for ' or " and then scan over token
+  const char potential_quote = outstring[rhs_end];
+  int rhs_start=rhs_end;
+  bool quoted = false;
+
+  if ((potential_quote == '\'') || (potential_quote == '\"')) {
+    rhs_end--;
+    rhs_start = rscan_for(outstring,rhs_end-1,potential_quote) +1;
+    quoted = true;
+  }
+  else {
+    rhs_start = rscan_for_whitespace(outstring,rhs_end-1) +1;
+  }
+
+  if ((rhs_end-rhs_start)<=0) {
+    // no meaningful rhs expression
+    return false;
+  }
+
+  // form rhs_expr
+  rhs_expr = extract_substr(outstring,rhs_start,rhs_end);
+
+  // skip over white space
+
+  const int to_whitespace = (quoted) ? 2 : 1;
+
+  int op_end = rscan_over_whitespace(outstring,rhs_start-to_whitespace);
+  int op_start = rscan_for_whitespace(outstring,op_end-1)+1;
+
+
+  if (op_end-op_start<=0) {
+    // no meaningful expression operator
+    return false;
+  }
+
+  op_expr = extract_substr(outstring,op_start,op_end);
+
+
+  // check for operator
+  if ((op_expr != "eq") && (op_expr != "ne")) {
+    // not a valid operator
+    return false;
+  }
+
+  int lhs_end = rscan_over_whitespace(outstring,op_start-1);
+  if (lhs_end<=0) {
+    // no meaningful lhs expression
+    return false;
+  }
+
+  int lhs_start = scan_over_whitespace(outstring,0);
+
+  // form lhs_expr from remainder of string
+  lhs_expr = extract_substr(outstring,lhs_start,lhs_end);
+
+  // Now we know we have a valid expression, look up any 
+  // metadata terms
+
+  rhs_expr = expand_potential_metadata(docinfo,rhs_expr);
+  lhs_expr = expand_potential_metadata(docinfo,lhs_expr);
+
+  return true;
+}
+
+static bool eval_expression_true(const text_t& lhs_expr,const text_t& op_expr,
+                 const text_t& rhs_expr, ostream& logout)
+{
+  if (op_expr == "eq") {
+    return (lhs_expr == rhs_expr);
+  }
+  else if (op_expr == "ne" ) {
+    return (lhs_expr != rhs_expr);
+  }
+  else {
+    logout << "Error: '" << op_expr << "' is not a recognised operator." << endl;
+  }
+
+  return false;
+}
+
+
 static text_t get_if (const text_t& collection, recptproto* collectproto,
               ResultDocInfo_t &docinfo, displayclass &disp, 
@@ -982 +1201 @@
               text_tmap &options, ostream& logout) 
 {
-
   // If the decision component is a metadata element, then evaluate it
   // to see whether we output the "then" or the "else" clause
@@ -1005 +1223 @@
     disp.expandstring (decision.text, outstring);
 
+    // Check for if expression in form: str1 op str2 
+    // (such as [x] eq "y")
+    text_t lhs_expr, op_expr, rhs_expr;
+    if (uses_expression(docinfo, outstring,lhs_expr,op_expr,rhs_expr)) {
+      if (eval_expression_true(lhs_expr,op_expr,rhs_expr,logout)) {
+    if (ifptr != NULL) {
+      return get_formatted_string (collection, collectproto, docinfo, disp, ifptr, 
+                       options, logout);
+    }
+    else {
+      return "";
+    }
+      } else {
+    if (elseptr != NULL) {
+      return get_formatted_string (collection, collectproto, docinfo, disp, elseptr,
+                       options, logout);
+    }
+    else {
+      return "";
+    }
+      }
+    }
+
+
     // This is a tad tricky.  When we expand a string like _cgiargmode_, that is
     // a cgi argument macro that has not been set, it evaluates to itself.
     // Therefore, were have to say that a piece of text evalautes true if
     // it is non-empty and if it is a cgi argument evaulating to itself.
+
     if ((outstring != "") && !((outstring == decision.text) && (outstring[0] == '_'))) {
       if (ifptr != NULL)

trunk/gsdl/src/recpt/formattools.h

@@ -53 +53 @@
 
 // The decision component of an {If}{decision,true-text,false-text}
-// formatstring.  Te decision can be based on metadata or on text;
+// formatstring.  The decision can be based on metadata or on text;
 // normally that text would be a macro like _cgiargmode_.  --gordon
 struct decision_t {