---

expressionparser.h

Go to the documentation of this file.

#ifndef ___EXPRESSIONPARSER_H___
#define ___EXPRESSIONPARSER_H___

#include "../src/exprparser.h"
#include "../src/pointerlookup.h"

#ifdef ANSI_COMPATIBLE
/* Optional: provides definition of snprintf on systems lacking them */
#include "../src/ind_types.h"
#endif


template <class MapT=PointerLookup<Typeless> >
class ExpressionParser : public ExprParser<> {
public:
  typedef MapT MapType;
  
  ExpressionParser(MapType& p,const char* expr)
    : ExprParser<>(expr), params(p) {  };

  virtual ~ExpressionParser() { }

  template <class DT> DT* lookup_pointer(DT*& x);

private:

  virtual const char*   getstringval();
  virtual const Typeless& getval();
  
  MapType& params;
};



template <class MapT>
template <class DT>
DT* ExpressionParser<MapT>::lookup_pointer(DT*& x)
{
  Typeless*     p  = params.getptr(remaining);
  Polymorph<DT>* pp = dynamic_cast<Polymorph<DT>*>(p);
  return x = (pp ? pp->valueptr() : 0);
}



template <class MapT>
const Typeless& ExpressionParser<MapT>::getval()
{
  const char* str      = remaining;
  int identlen         = String::C_identifier_length(str,':');
  size_t checklen      = identlen;

  if (!identlen)  /* Must be a numeric literal, then */
    return ExprParser<>::getval();

  /* Look up parameter value */
  const Typeless* p=0;
  p = params.getptr(string(str,checklen));
  remaining=str+identlen;
  if (p) return *p;
  else { /* Nothing found */
    static Polymorph<int> dummy(Uninitialized);
    return dummy;
  }
}



template <class MapT>
const char *ExpressionParser<MapT>::getstringval()
{
  const size_t bufsize=16384; // Arbitrary limit
  static char buf[bufsize];
  const char* maxbufptr=buf+bufsize;

  char* bufptr=buf;
  int identlen;

  const char* str = remaining;
  while (remaining && *remaining && bufptr<maxbufptr) {
    /* Copy any bare characters without substitution */
    while (*remaining && *remaining != '$' && bufptr<maxbufptr)
      *(bufptr++) = *(remaining)++;
    
    /* Substitute strings starting with a dollar sign ($) */
    if (*remaining == '$') { /* Swallow first $ */
      (remaining)++;
      if (*remaining == '$') /* Copy literal $, if present */
        *(bufptr++) = *(remaining)++;
      else {
        int bracefound=false;
        string formatflags="";
        if (*remaining == '{') {
          bracefound=true;
          (remaining)++;
        }

        /* Support conditional text, where e.g. ${?param,text} will print text if param
           is non-zero and not the empty string */
        bool conditional=false;
        if (*remaining=='?') {
          (remaining)++;
          conditional=true;
        }

        /* Anything non-alphabetic other than : must be a printing format specification */
        if (!isalpha(*remaining) && (*remaining)!=':') {
          const char *start=remaining;
          while (*remaining && !isalpha(*remaining))
            (remaining)++;
          formatflags=string(start,remaining);
        }

        /* Figure out what part of the remaining string is the identifier */
        identlen = String::C_identifier_length(remaining,':');
      
        /* Look up parameter value */
        const Typeless* p = params.getptr(string(remaining,identlen));
        remaining +=identlen;
        const string representation=p->stringrep(String::StreamFormat(formatflags));
        
        /* Insert either the string representation of the parameter, or replacement text (if conditional) */
        if (p) {
          if (!conditional)
            bufptr += SNPRINTF(bufptr,maxbufptr-bufptr,"%s",representation.c_str());
          else {
            if (*remaining==',' && bracefound) {
              (remaining)++;
              /* Grab text between ',' and '}' */
              const char *start=remaining;
              while (*remaining && !(*remaining=='}'))
                (remaining)++;
              const string replacetext=string(start,remaining);

              /* Insert replacement text if parameter expanded to something non-empty */
              if (p->isnumeric()? p->numericvalue()!=0 : representation!="")
                bufptr += SNPRINTF(bufptr,maxbufptr-bufptr,"%s",replacetext.c_str());
            }
            /* Insert parameter value if it expanded to something non-empty */
            else if (p->isnumeric()? p->numericvalue()!=0 : representation!="")
              bufptr += SNPRINTF(bufptr,maxbufptr-bufptr,"%s",representation.c_str());
          }
        }
        
        if (bracefound) {
          if (*remaining == '}')
            (remaining)++;
          else
            message(Msg::Warning,"Missing right brace in "+string(str));
        }
      }
    }
  }
  *bufptr='\0';
    
  return buf;
}



/*******************************************************************************/
template <class MapT=PointerLookup<Typeless>, class ParserT=ExpressionParser<MapT> >
class ParamStringParser : public StringParser {
public:
  typedef ParserT ParserType;
  typedef MapT    MapType;

  ParamStringParser(MapType& m) : params(m) {  };
  
  virtual ~ParamStringParser() {  }
  virtual StringParser* clone() const {  return new ParamStringParser(*this);  };

  virtual double&   parse(const string& s, double&   x) const {  return x = parserfactory(s.c_str()).cmdf();  }
  virtual int&      parse(const string& s, int&      x) const {  return x = parserfactory(s.c_str()).cmdi();  }
  virtual Tristate& parse(const string& s, Tristate& x) const {  return x = Tristate(parserfactory(s.c_str()).cmdi());  }
  virtual string&   parse(const string& s, string&   x) const {  return x = parserfactory(s.c_str()).cmds();  }
  
  virtual double*&   parse(const string& s, double*&   x) const {  return x = parse_pointer(s,x); }
  virtual int*&      parse(const string& s, int*&      x) const {  return x = parse_pointer(s,x); }
  virtual Tristate*& parse(const string& s, Tristate*& x) const {  return x = parse_pointer(s,x); }
  virtual string*&   parse(const string& s, string*&   x) const {  return x = parse_pointer(s,x); }

  /* Unchanged templated routines from the base class have to be
     duplicated explicitly here due to limitations in C++'s overload
     resolution rules and in the using directive. */
  virtual string   parse(const string& s) const 
    {  return StringParser::parse(s);  }

  /* Compared to the base class, adds support for single and double quotes,
     so that word breaking will group quoted items together and suppress
     the quotes. */
  virtual arglist&  parse(const string& s, arglist&  x) const {
    x.resize(0);
    const char* remaining = s.c_str();
    while (*remaining) 
      x.push_back(parse_token(remaining));
    return x;
  }
  
  virtual void error(const string& s) const {
    Msg::LevelHandler<>* mh = Msg::LevelHandler<>::default_instance();
    if (mh) (*mh)(Msg::Error,s);
  }

private:
  MapType& params;

  string      parse_token(  const char*& remaining) const;
  const char* consume_quote(const char*& remaining) const;
  
  ParserType parserfactory(const char* expr) const
    {  return ParserType(params,expr);  }
  
//template <class T>  
#define PARSE_POINTER_DEF(T)\
  T*&  parse_pointer(const string& s, T*&  x) const {   \
    if (!ispointer(s))                                  \
      parse(s,*x);                                      \
    else {                                              \
      T* ptr;                                           \
      parserfactory(s.c_str()+1).lookup_pointer(ptr);   \
      if (ptr) x=ptr;                                   \
      else error("StringParser: Could not get a "       \
                 "pointer of required type from "+s);   \
    }                                                   \
    return x;                                           \
  }
  
  PARSE_POINTER_DEF(double);
  PARSE_POINTER_DEF(int);
  PARSE_POINTER_DEF(Tristate);
  PARSE_POINTER_DEF(string);
  
  
  virtual bool ispointer(const string& s) const {
    std::istrstream ist(s.c_str(),s.length());
    unsigned char w;
    ist >> w;
    return (w == '&');
  }
};


template <class MapT, class ParserT>
const char* ParamStringParser<MapT,ParserT>::consume_quote(const char*& remaining) const  {
  const char* quotepos=remaining;
  while (*(++(remaining)) && (*remaining!=*quotepos));
  const char* end=remaining;
  if (!*remaining) {
    string q;
    q=*quotepos;
    error("Unmatched " + q);
  }
  else (remaining)++;
  return end;
}

template <class MapT, class ParserT>
string ParamStringParser<MapT,ParserT>::parse_token(const char*& remaining) const {
  while (isspace(*remaining)) (remaining)++;
  const char* start=remaining;
  const char* end=remaining;
  
  switch (*remaining) {
  case '\0': break;
  case  '#': while (*(++(remaining))); start=end=(remaining); break;
  case '\"': start++; end=consume_quote(remaining); break;
  case '\'': start++; end=consume_quote(remaining); break;
  default:
    while (*(++(remaining))  && !isspace(*remaining) &&
             (*remaining!='"') && (*remaining!='\''));
    if (*remaining=='"' || *remaining=='\'') consume_quote(remaining);
    end=remaining;
    break;
  }
  
  /* Swallow trailing garbage until we're sure there's something interesting left,
     and return a new string. */
  while (isspace(*remaining)) (remaining)++;
  return string(start,end);
}


#endif /* ___EXPRESSIONPARSER_H___ */

---