ExpressionParser Class Reference

Recursive decent parser for Django style template expressions. More...

Classes
class	ExprToken
	Class representing a token within an expression. More...

Public Member Functions
	ExpressionParser (const TemplateParser *parser, int line)
virtual	~ExpressionParser ()
ExprAst *	parse (const char *expr)

Private Member Functions
ExprAst *	parseExpression ()
ExprAst *	parseOrExpression ()
ExprAst *	parseAndExpression ()
ExprAst *	parseNotExpression ()
ExprAst *	parseCompareExpression ()
ExprAst *	parseAdditiveExpression ()
ExprAst *	parseMultiplicativeExpression ()
ExprAst *	parseUnaryExpression ()
ExprAst *	parsePrimaryExpression ()
ExprAst *	parseNumber ()
ExprAst *	parseIdentifier ()
ExprAst *	parseLiteral ()
ExprAst *	parseIdentifierOptionalArgs ()
ExprAst *	parseFilteredVariable ()
ExprAstFilter *	parseFilter ()
bool	getNextToken ()

Private Attributes
const TemplateParser *	m_parser
ExprToken	m_curToken
int	m_line
const char *	m_tokenStream

Detailed Description

Recursive decent parser for Django style template expressions.

Definition at line 1748 of file template.cpp.

Constructor & Destructor Documentation

ExpressionParser::ExpressionParser ( const TemplateParser *  parser, int  line  )

inline

Definition at line 1751 of file template.cpp.

      : m_parser(parser), m_line(line), m_tokenStream(0)
    {
    }

virtual ExpressionParser::~ExpressionParser ( )

inlinevirtual

Definition at line 1755 of file template.cpp.

    {
    }

Member Function Documentation

bool ExpressionParser::getNextToken ( )

inlineprivate

Definition at line 2083 of file template.cpp.

References Operator::And, Operator::Colon, Operator::Comma, Operator::Divide, Operator::Equal, Operator::Filter, Operator::Greater, Operator::GreaterEqual, ExpressionParser::ExprToken::id, ExpressionParser::ExprToken::Identifier, Operator::LeftParen, Operator::Less, Operator::LessEqual, ExpressionParser::ExprToken::Literal, m_curToken, m_line, m_parser, m_tokenStream, Operator::Minus, Operator::Modulo, Operator::Multiply, Operator::Not, Operator::NotEqual, ExpressionParser::ExprToken::num, ExpressionParser::ExprToken::Number, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, Operator::Or, Operator::Plus, Operator::RightParen, TemplateParser::templateName(), ExpressionParser::ExprToken::type, ExpressionParser::ExprToken::Unknown, and warn().

Referenced by parse(), parseAdditiveExpression(), parseAndExpression(), parseCompareExpression(), parseFilter(), parseFilteredVariable(), parseIdentifier(), parseIdentifierOptionalArgs(), parseLiteral(), parseMultiplicativeExpression(), parseNotExpression(), parseNumber(), parseOrExpression(), parsePrimaryExpression(), and parseUnaryExpression().

    {
      const char *p = m_tokenStream;
      char s[2];
      s[1]=0;
      if (p==0 || *p=='\0') return FALSE;
      while (*p==' ') p++; // skip over spaces
      char c=*p;
      if (*p=='\0') // only spaces...
      {
        m_tokenStream = p;
        return FALSE;
      }
      const char *q = p;
      switch (c)
      {
        case '=':
          if (c=='=' && *(p+1)=='=') // equal
          {
            m_curToken.op = Operator::Equal;
            p+=2;
          }
          break;
        case '!':
          if (c=='!' && *(p+1)=='=') // not equal
          {
            m_curToken.op = Operator::NotEqual;
            p+=2;
          }
          break;
        case '<':
          if (c=='<' && *(p+1)=='=') // less or equal
          {
            m_curToken.op = Operator::LessEqual;
            p+=2;
          }
          else // less
          {
            m_curToken.op = Operator::Less;
            p++;
          }
          break;
        case '>':
          if (c=='>' && *(p+1)=='=') // greater or equal
          {
            m_curToken.op = Operator::GreaterEqual;
            p+=2;
          }
          else // greater
          {
            m_curToken.op = Operator::Greater;
            p++;
          }
          break;
        case '(':
          m_curToken.op = Operator::LeftParen;
          p++;
          break;
        case ')':
          m_curToken.op = Operator::RightParen;
          p++;
          break;
        case '|':
          m_curToken.op = Operator::Filter;
          p++;
          break;
        case '+':
          m_curToken.op = Operator::Plus;
          p++;
          break;
        case '-':
          m_curToken.op = Operator::Minus;
          p++;
          break;
        case '*':
          m_curToken.op = Operator::Multiply;
          p++;
          break;
        case '/':
          m_curToken.op = Operator::Divide;
          p++;
          break;
        case '%':
          m_curToken.op = Operator::Modulo;
          p++;
          break;
        case ':':
          m_curToken.op = Operator::Colon;
          p++;
          break;
        case ',':
          m_curToken.op = Operator::Comma;
          p++;
          break;
        case 'n':
          if (strncmp(p,"not ",4)==0)
          {
            m_curToken.op = Operator::Not;
            p+=4;
          }
          break;
        case 'a':
          if (strncmp(p,"and ",4)==0)
          {
            m_curToken.op = Operator::And;
            p+=4;
          }
          break;
        case 'o':
          if (strncmp(p,"or ",3)==0)
          {
            m_curToken.op = Operator::Or;
            p+=3;
          }
          break;
        default:
          break;
      }
      if (p!=q) // found an operator
      {
        m_curToken.type = ExprToken::Operator;
      }
      else // no token found yet
      {
        if (c>='0' && c<='9') // number?
        {
          m_curToken.type = ExprToken::Number;
          const char *np = p;
          m_curToken.num = 0;
          while (*np>='0' && *np<='9')
          {
            m_curToken.num*=10;
            m_curToken.num+=*np-'0';
            np++;
          }
          p=np;
        }
        else if (c=='_' || (c>='a' && c<='z') || (c>='A' && c<='Z')) // identifier?
        {
          m_curToken.type = ExprToken::Identifier;
          s[0]=c;
          m_curToken.id = s;
          p++;
          while ((c=*p) &&
              (c=='_' || c=='.' ||
               (c>='a' && c<='z') ||
               (c>='A' && c<='Z') ||
               (c>='0' && c<='9'))
              )
          {
            s[0]=c;
            m_curToken.id+=s;
            p++;
          }
          if (m_curToken.id=="True") // treat true literal as numerical 1
          {
            m_curToken.type = ExprToken::Number;
            m_curToken.num = 1;
          }
          else if (m_curToken.id=="False") // treat false literal as numerical 0
          {
            m_curToken.type = ExprToken::Number;
            m_curToken.num = 0;
          }
        }
        else if (c=='"' || c=='\'') // string literal
        {
          m_curToken.type = ExprToken::Literal;
          m_curToken.id.resize(0);
          p++;
          char tokenChar = c;
          char cp=0;
          while ((c=*p) && (c!=tokenChar || (c==tokenChar && cp=='\\')))
          {
            s[0]=c;
            if (c!='\\' || cp=='\\') // don't add escapes
            {
              m_curToken.id+=s;
            }
            cp=c;
            p++;
          }
          if (*p==tokenChar) p++;
        }
      }
      if (p==q) // still no valid token found -> error
      {
        m_curToken.type = ExprToken::Unknown;
        char s[2];
        s[0]=c;
        s[1]=0;
        warn(m_parser->templateName(),m_line,"Found unknown token '%s' (%d) while parsing %s",s,c,m_tokenStream);
        m_curToken.id = s;
        p++;
      }
      //TRACE(("token type=%d op=%d num=%d id=%s\n",
      //    m_curToken.type,m_curToken.op,m_curToken.num,m_curToken.id.data()));

      m_tokenStream = p;
      return TRUE;
    }

ExprAst* ExpressionParser::parse ( const char *  expr )

inline

Definition at line 1759 of file template.cpp.

References getNextToken(), m_tokenStream, and parseExpression().

Referenced by TemplateNodeCreate::TemplateNodeCreate(), TemplateNodeCycle::TemplateNodeCycle(), TemplateNodeEncoding::TemplateNodeEncoding(), TemplateNodeExtend::TemplateNodeExtend(), TemplateNodeFor::TemplateNodeFor(), TemplateNodeIf::TemplateNodeIf(), TemplateNodeInclude::TemplateNodeInclude(), TemplateNodeIndexEntry::TemplateNodeIndexEntry(), TemplateNodeMarkers::TemplateNodeMarkers(), TemplateNodeRange::TemplateNodeRange(), TemplateNodeRepeat::TemplateNodeRepeat(), TemplateNodeResource::TemplateNodeResource(), TemplateNodeSet::TemplateNodeSet(), TemplateNodeTree::TemplateNodeTree(), TemplateNodeVariable::TemplateNodeVariable(), and TemplateNodeWith::TemplateNodeWith().

    {
      if (expr==0) return 0;
      m_tokenStream = expr;
      getNextToken();
      return parseExpression();
    }

ExprAst* ExpressionParser::parseAdditiveExpression ( )

inlineprivate

Definition at line 1881 of file template.cpp.

References getNextToken(), m_curToken, m_tokenStream, Operator::Minus, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseMultiplicativeExpression(), Operator::Plus, TRACE, and ExpressionParser::ExprToken::type.

Referenced by parseCompareExpression().

    {
      TRACE(("{parseAdditiveExpression(%s)\n",m_tokenStream));
      ExprAst *lhs = parseMultiplicativeExpression();
      if (lhs)
      {
        while (m_curToken.type==ExprToken::Operator &&
               (m_curToken.op==Operator::Plus || m_curToken.op==Operator::Minus))
        {
          Operator::Type op = m_curToken.op;
          getNextToken();
          ExprAst *rhs = parseMultiplicativeExpression();
          lhs = new ExprAstBinary(op,lhs,rhs);
        }
      }
      TRACE(("}parseAdditiveExpression(%s)\n",m_tokenStream));
      return lhs;
    }

ExprAst* ExpressionParser::parseAndExpression ( )

inlineprivate

Definition at line 1813 of file template.cpp.

References Operator::And, getNextToken(), m_curToken, m_tokenStream, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseNotExpression(), TRACE, and ExpressionParser::ExprToken::type.

Referenced by parseOrExpression().

    {
      TRACE(("{parseAndExpression(%s)\n",m_tokenStream));
      ExprAst *lhs = parseNotExpression();
      if (lhs)
      {
        while (m_curToken.type==ExprToken::Operator &&
               m_curToken.op==Operator::And)
        {
          getNextToken();
          ExprAst *rhs = parseNotExpression();
          lhs = new ExprAstBinary(Operator::And,lhs,rhs);
        }
      }
      TRACE(("}parseAndExpression(%s)\n",m_tokenStream));
      return lhs;
    }

ExprAst* ExpressionParser::parseCompareExpression ( )

inlineprivate

Definition at line 1855 of file template.cpp.

References Operator::Equal, getNextToken(), Operator::Greater, Operator::GreaterEqual, Operator::Less, Operator::LessEqual, m_curToken, m_tokenStream, Operator::NotEqual, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseAdditiveExpression(), parseNotExpression(), TRACE, and ExpressionParser::ExprToken::type.

Referenced by parseNotExpression().

    {
      TRACE(("{parseCompareExpression(%s)\n",m_tokenStream));
      ExprAst *lhs = parseAdditiveExpression();
      if (lhs)
      {
        Operator::Type op = m_curToken.op;
        if (m_curToken.type==ExprToken::Operator &&
            (op==Operator::Less      ||
             op==Operator::Greater   ||
             op==Operator::Equal     ||
             op==Operator::NotEqual  ||
             op==Operator::LessEqual ||
             op==Operator::GreaterEqual
            )
           )
        {
          getNextToken();
          ExprAst *rhs = parseNotExpression();
          lhs = new ExprAstBinary(op,lhs,rhs);
        }
      }
      TRACE(("}parseCompareExpression(%s)\n",m_tokenStream));
      return lhs;
    }

ExprAst* ExpressionParser::parseExpression ( )

inlineprivate

Definition at line 1787 of file template.cpp.

References m_tokenStream, parseOrExpression(), and TRACE.

Referenced by parse(), and parsePrimaryExpression().

    {
      TRACE(("{parseExpression(%s)\n",m_tokenStream));
      ExprAst *result = parseOrExpression();
      TRACE(("}parseExpression(%s)\n",m_tokenStream));
      return result;
    }

ExprAstFilter* ExpressionParser::parseFilter ( )

inlineprivate

Definition at line 2065 of file template.cpp.

References Operator::Colon, filter(), getNextToken(), ExpressionParser::ExprToken::id, m_curToken, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parsePrimaryExpression(), TRACE, and ExpressionParser::ExprToken::type.

Referenced by parseFilteredVariable().

    {
      TRACE(("{parseFilter(%s)\n",m_curToken.id.data()));
      QCString filterName = m_curToken.id;
      getNextToken();
      ExprAst *argExpr=0;
      if (m_curToken.type==ExprToken::Operator &&
          m_curToken.op==Operator::Colon)
      {
        getNextToken();
        argExpr = parsePrimaryExpression();
      }
      ExprAstFilter *filter = new ExprAstFilter(filterName,argExpr);
      TRACE(("}parseFilter()\n"));
      return filter;
    }

ExprAst* ExpressionParser::parseFilteredVariable ( )

inlineprivate

Definition at line 2046 of file template.cpp.

References Operator::Filter, filter(), getNextToken(), m_curToken, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseFilter(), parseIdentifierOptionalArgs(), TRACE, and ExpressionParser::ExprToken::type.

Referenced by parsePrimaryExpression().

    {
      TRACE(("{parseFilteredVariable()\n"));
      ExprAst *expr = parseIdentifierOptionalArgs();
      if (expr)
      {
        while (m_curToken.type==ExprToken::Operator &&
               m_curToken.op==Operator::Filter)
        {
          getNextToken();
          ExprAstFilter *filter = parseFilter();
          if (!filter) break;
          expr = new ExprAstFilterAppl(expr,filter);
        }
      }
      TRACE(("}parseFilteredVariable()\n"));
      return expr;
    }

ExprAst* ExpressionParser::parseIdentifier ( )

inlineprivate

Definition at line 2001 of file template.cpp.

References getNextToken(), ExpressionParser::ExprToken::id, m_curToken, and TRACE.

Referenced by parseIdentifierOptionalArgs().

    {
      TRACE(("{parseIdentifier(%s)\n",m_curToken.id.data()));
      ExprAst *id = new ExprAstVariable(m_curToken.id);
      getNextToken();
      TRACE(("}parseIdentifier()\n"));
      return id;
    }

ExprAst* ExpressionParser::parseIdentifierOptionalArgs ( )

inlineprivate

Definition at line 2019 of file template.cpp.

References Operator::Colon, Operator::Comma, getNextToken(), ExpressionParser::ExprToken::id, m_curToken, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseIdentifier(), parsePrimaryExpression(), TRACE, and ExpressionParser::ExprToken::type.

Referenced by parseFilteredVariable().

    {
      TRACE(("{parseIdentifierOptionalArgs(%s)\n",m_curToken.id.data()));
      ExprAst *expr = parseIdentifier();
      if (expr)
      {
        if (m_curToken.type==ExprToken::Operator &&
            m_curToken.op==Operator::Colon)
        {
          getNextToken();
          ExprAst *argExpr = parsePrimaryExpression();
          QList<ExprAst> args;
          args.append(argExpr);
          while (m_curToken.type==ExprToken::Operator &&
                 m_curToken.op==Operator::Comma)
          {
            getNextToken();
            argExpr = parsePrimaryExpression();
            args.append(argExpr);
          }
          expr = new ExprAstFunctionVariable(expr,args);
        }
      }
      TRACE(("}parseIdentifierOptionalArgs()\n"));
      return expr;
    }

ExprAst* ExpressionParser::parseLiteral ( )

inlineprivate

Definition at line 2010 of file template.cpp.

References getNextToken(), ExpressionParser::ExprToken::id, m_curToken, and TRACE.

Referenced by parsePrimaryExpression().

    {
      TRACE(("{parseLiteral(%s)\n",m_curToken.id.data()));
      ExprAst *expr = new ExprAstLiteral(m_curToken.id);
      getNextToken();
      TRACE(("}parseLiteral()\n"));
      return expr;
    }

ExprAst* ExpressionParser::parseMultiplicativeExpression ( )

inlineprivate

Definition at line 1900 of file template.cpp.

References Operator::Divide, getNextToken(), m_curToken, m_tokenStream, Operator::Modulo, Operator::Multiply, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseUnaryExpression(), TRACE, and ExpressionParser::ExprToken::type.

Referenced by parseAdditiveExpression().

    {
      TRACE(("{parseMultiplicativeExpression(%s)\n",m_tokenStream));
      ExprAst *lhs = parseUnaryExpression();
      if (lhs)
      {
        while (m_curToken.type==ExprToken::Operator &&
               (m_curToken.op==Operator::Multiply || m_curToken.op==Operator::Divide || m_curToken.op==Operator::Modulo))
        {
          Operator::Type op = m_curToken.op;
          getNextToken();
          ExprAst *rhs = parseUnaryExpression();
          lhs = new ExprAstBinary(op,lhs,rhs);
        }
      }
      TRACE(("}parseMultiplicativeExpression(%s)\n",m_tokenStream));
      return lhs;
    }

ExprAst* ExpressionParser::parseNotExpression ( )

inlineprivate

Definition at line 1831 of file template.cpp.

References getNextToken(), m_curToken, m_line, m_parser, m_tokenStream, Operator::Not, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseCompareExpression(), TemplateParser::templateName(), TRACE, ExpressionParser::ExprToken::type, and warn().

Referenced by parseAndExpression(), and parseCompareExpression().

    {
      TRACE(("{parseNotExpression(%s)\n",m_tokenStream));
      ExprAst *result=0;
      if (m_curToken.type==ExprToken::Operator &&
          m_curToken.op==Operator::Not)
      {
        getNextToken();
        ExprAst *expr = parseCompareExpression();
        if (expr==0)
        {
          warn(m_parser->templateName(),m_line,"argument missing for not operator");
          return 0;
        }
        result = new ExprAstNegate(expr);
      }
      else
      {
        result = parseCompareExpression();
      }
      TRACE(("}parseNotExpression(%s)\n",m_tokenStream));
      return result;
    }

ExprAst* ExpressionParser::parseNumber ( )

inlineprivate

Definition at line 1992 of file template.cpp.

References getNextToken(), m_curToken, ExpressionParser::ExprToken::num, and TRACE.

Referenced by parsePrimaryExpression().

    {
      TRACE(("{parseNumber(%d)\n",m_curToken.num));
      ExprAst *num = new ExprAstNumber(m_curToken.num);
      getNextToken();
      TRACE(("}parseNumber()\n"));
      return num;
    }

ExprAst* ExpressionParser::parseOrExpression ( )

inlineprivate

Definition at line 1795 of file template.cpp.

References getNextToken(), m_curToken, m_tokenStream, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, Operator::Or, parseAndExpression(), TRACE, and ExpressionParser::ExprToken::type.

Referenced by parseExpression().

    {
      TRACE(("{parseOrExpression(%s)\n",m_tokenStream));
      ExprAst *lhs = parseAndExpression();
      if (lhs)
      {
        while (m_curToken.type==ExprToken::Operator &&
            m_curToken.op==Operator::Or)
        {
          getNextToken();
          ExprAst *rhs = parseAndExpression();
          lhs = new ExprAstBinary(Operator::Or,lhs,rhs);
        }
      }
      TRACE(("}parseOrExpression(%s)\n",m_tokenStream));
      return lhs;
    }

ExprAst* ExpressionParser::parsePrimaryExpression ( )

inlineprivate

Definition at line 1949 of file template.cpp.

References getNextToken(), ExpressionParser::ExprToken::Identifier, Operator::LeftParen, ExpressionParser::ExprToken::Literal, m_curToken, m_line, m_parser, m_tokenStream, ExpressionParser::ExprToken::Number, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseExpression(), parseFilteredVariable(), parseLiteral(), parseNumber(), Operator::RightParen, TemplateParser::templateName(), Operator::toString(), TRACE, ExpressionParser::ExprToken::type, and warn().

Referenced by parseFilter(), parseIdentifierOptionalArgs(), and parseUnaryExpression().

    {
      TRACE(("{parsePrimary(%s)\n",m_tokenStream));
      ExprAst *result=0;
      switch (m_curToken.type)
      {
        case ExprToken::Number:
          result = parseNumber();
          break;
        case ExprToken::Identifier:
          result = parseFilteredVariable();
          break;
        case ExprToken::Literal:
          result = parseLiteral();
          break;
        case ExprToken::Operator:
          if (m_curToken.op==Operator::LeftParen)
          {
            getNextToken(); // skip over opening bracket
            result = parseExpression();
            if (m_curToken.type!=ExprToken::Operator ||
                m_curToken.op!=Operator::RightParen)
            {
              warn(m_parser->templateName(),m_line,"missing closing parenthesis");
            }
            else
            {
              getNextToken(); // skip over closing bracket
            }
          }
          else
          {
            warn(m_parser->templateName(),m_line,"unexpected operator '%s' in expression",
                Operator::toString(m_curToken.op));
          }
          break;
        default:
          warn(m_parser->templateName(),m_line,"unexpected token in expression");
      }
      TRACE(("}parsePrimary(%s)\n",m_tokenStream));
      return result;
    }

ExprAst* ExpressionParser::parseUnaryExpression ( )

inlineprivate

Definition at line 1919 of file template.cpp.

References getNextToken(), m_curToken, m_tokenStream, Operator::Minus, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parsePrimaryExpression(), Operator::Plus, TRACE, and ExpressionParser::ExprToken::type.

Referenced by parseMultiplicativeExpression().

    {
      TRACE(("{parseUnaryExpression(%s)\n",m_tokenStream));
      ExprAst *result=0;
      if (m_curToken.type==ExprToken::Operator)
      {
        if (m_curToken.op==Operator::Plus)
        {
          getNextToken();
          result = parsePrimaryExpression();
        }
        else if (m_curToken.op==Operator::Minus)
        {
          getNextToken();
          ExprAst *rhs = parsePrimaryExpression();
          result = new ExprAstUnary(m_curToken.op,rhs);
        }
        else
        {
          result = parsePrimaryExpression();
        }
      }
      else
      {
        result = parsePrimaryExpression();
      }
      TRACE(("}parseUnaryExpression(%s)\n",m_tokenStream));
      return result;
    }

Member Data Documentation

ExprToken ExpressionParser::m_curToken

private

Definition at line 2286 of file template.cpp.

Referenced by getNextToken(), parseAdditiveExpression(), parseAndExpression(), parseCompareExpression(), parseFilter(), parseFilteredVariable(), parseIdentifier(), parseIdentifierOptionalArgs(), parseLiteral(), parseMultiplicativeExpression(), parseNotExpression(), parseNumber(), parseOrExpression(), parsePrimaryExpression(), and parseUnaryExpression().

int ExpressionParser::m_line

private

Definition at line 2287 of file template.cpp.

Referenced by getNextToken(), parseNotExpression(), and parsePrimaryExpression().

const TemplateParser* ExpressionParser::m_parser

private

Definition at line 2285 of file template.cpp.

Referenced by getNextToken(), parseNotExpression(), and parsePrimaryExpression().

const char* ExpressionParser::m_tokenStream

private

Definition at line 2288 of file template.cpp.

Referenced by getNextToken(), parse(), parseAdditiveExpression(), parseAndExpression(), parseCompareExpression(), parseExpression(), parseMultiplicativeExpression(), parseNotExpression(), parseOrExpression(), parsePrimaryExpression(), and parseUnaryExpression().

---

The documentation for this class was generated from the following file:

• template.cpp