Recursive decent parser for Django style template expressions. 更多...

ExpressionParser 的协作图:

类
class	ExprToken
	Class representing a token within an expression. 更多...

Public 成员函数
	ExpressionParser (const TemplateParser *parser, int line)

virtual	~ExpressionParser ()

ExprAstPtr	parse (const QCString &expr)

Private 成员函数
ExprAstPtr	parseExpression ()

ExprAstPtr	parseOrExpression ()

ExprAstPtr	parseAndExpression ()

ExprAstPtr	parseNotExpression ()

ExprAstPtr	parseCompareExpression ()

ExprAstPtr	parseAdditiveExpression ()

ExprAstPtr	parseMultiplicativeExpression ()

ExprAstPtr	parseUnaryExpression ()

ExprAstPtr	parsePrimaryExpression ()

ExprAstPtr	parseNumber ()

ExprAstPtr	parseIdentifier ()

ExprAstPtr	parseLiteral ()

ExprAstPtr	parseIdentifierOptionalArgs ()

ExprAstPtr	parseFilteredVariable ()

ExprAstFilterPtr	parseFilter ()

bool	getNextToken ()

Private 属性
const TemplateParser *	m_parser = 0

ExprToken	m_curToken

int	m_line = 0

const char *	m_tokenStream

详细描述

Recursive decent parser for Django style template expressions.

在文件 template.cpp 第 2010 行定义.

构造及析构函数说明

◆ ExpressionParser()

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

inline

在文件 template.cpp 第 2013 行定义.

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

◆ ~ExpressionParser()

virtual ExpressionParser::~ExpressionParser ( )

inlinevirtual

在文件 template.cpp 第 2017 行定义.

2018 {

2019 }

成员函数说明

◆ getNextToken()

bool ExpressionParser::getNextToken ( )

inlineprivate

在文件 template.cpp 第 2344 行定义.

     {
       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;
         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,qPrint(m_curToken.id)));
  
       m_tokenStream = p;
       return TRUE;
     }

被这些函数引用 parse(), parseAdditiveExpression(), parseAndExpression(), parseCompareExpression(), parseFilter(), parseFilteredVariable(), parseIdentifier(), parseIdentifierOptionalArgs(), parseLiteral(), parseMultiplicativeExpression(), parseNotExpression(), parseNumber(), parseOrExpression(), parsePrimaryExpression() , 以及 parseUnaryExpression().

◆ parse()

ExprAstPtr ExpressionParser::parse ( const QCString & expr )

inline

在文件 template.cpp 第 2021 行定义.

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

引用了 QCString::data(), getNextToken(), QCString::isEmpty(), m_tokenStream , 以及 parseExpression().

被这些函数引用 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() , 以及 TemplateNodeWith::TemplateNodeWith().

◆ parseAdditiveExpression()

ExprAstPtr ExpressionParser::parseAdditiveExpression ( )

inlineprivate

在文件 template.cpp 第 2143 行定义.

     {
       TRACE(("{parseAdditiveExpression(%s)\n",m_tokenStream));
       ExprAstPtr 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();
           ExprAstPtr rhs { parseMultiplicativeExpression() };
           lhs = std::make_unique<ExprAstBinary>(op,std::move(lhs),std::move(rhs));
         }
       }
       TRACE(("}parseAdditiveExpression(%s)\n",m_tokenStream));
       return lhs;
     }

引用了 getNextToken(), m_curToken, m_tokenStream, Operator::Minus, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseMultiplicativeExpression(), Operator::Plus, TRACE , 以及 ExpressionParser::ExprToken::type.

被这些函数引用 parseCompareExpression().

◆ parseAndExpression()

ExprAstPtr ExpressionParser::parseAndExpression ( )

inlineprivate

在文件 template.cpp 第 2075 行定义.

     {
       TRACE(("{parseAndExpression(%s)\n",m_tokenStream));
       ExprAstPtr lhs { parseNotExpression() };
       if (lhs)
       {
         while (m_curToken.type==ExprToken::Operator &&
                m_curToken.op==Operator::And)
         {
           getNextToken();
           ExprAstPtr rhs { parseNotExpression() };
           lhs = std::make_unique<ExprAstBinary>(Operator::And,std::move(lhs),std::move(rhs));
         }
       }
       TRACE(("}parseAndExpression(%s)\n",m_tokenStream));
       return lhs;
     }

引用了 Operator::And, getNextToken(), m_curToken, m_tokenStream, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseNotExpression(), TRACE , 以及 ExpressionParser::ExprToken::type.

被这些函数引用 parseOrExpression().

◆ parseCompareExpression()

ExprAstPtr ExpressionParser::parseCompareExpression ( )

inlineprivate

在文件 template.cpp 第 2117 行定义.

     {
       TRACE(("{parseCompareExpression(%s)\n",m_tokenStream));
       ExprAstPtr 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();
           ExprAstPtr rhs { parseNotExpression() };
           lhs = std::make_unique<ExprAstBinary>(op,std::move(lhs),std::move(rhs));
         }
       }
       TRACE(("}parseCompareExpression(%s)\n",m_tokenStream));
       return lhs;
     }

引用了 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 , 以及 ExpressionParser::ExprToken::type.

被这些函数引用 parseNotExpression().

◆ parseExpression()

ExprAstPtr ExpressionParser::parseExpression ( )

inlineprivate

在文件 template.cpp 第 2049 行定义.

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

引用了 m_tokenStream, parseOrExpression() , 以及 TRACE.

被这些函数引用 parse() , 以及 parsePrimaryExpression().

◆ parseFilter()

ExprAstFilterPtr ExpressionParser::parseFilter ( )

inlineprivate

在文件 template.cpp 第 2326 行定义.

     {
       TRACE(("{parseFilter(%s)\n",qPrint(m_curToken.id)));
       QCString filterName = m_curToken.id;
       getNextToken();
       ExprAstPtr argExpr;
       if (m_curToken.type==ExprToken::Operator &&
           m_curToken.op==Operator::Colon)
       {
         getNextToken();
         argExpr = parsePrimaryExpression();
       }
       ExprAstFilterPtr filter = std::make_unique<ExprAstFilter>(filterName,std::move(argExpr));
       TRACE(("}parseFilter()\n"));
       return filter;
     }

引用了 Operator::Colon, getNextToken(), ExpressionParser::ExprToken::id, m_curToken, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parsePrimaryExpression(), qPrint(), TRACE , 以及 ExpressionParser::ExprToken::type.

被这些函数引用 parseFilteredVariable().

◆ parseFilteredVariable()

ExprAstPtr ExpressionParser::parseFilteredVariable ( )

inlineprivate

在文件 template.cpp 第 2307 行定义.

     {
       TRACE(("{parseFilteredVariable()\n"));
       ExprAstPtr expr = parseIdentifierOptionalArgs();
       if (expr)
       {
         while (m_curToken.type==ExprToken::Operator &&
                m_curToken.op==Operator::Filter)
         {
           getNextToken();
           ExprAstFilterPtr filter = parseFilter();
           if (!filter) break;
           expr = std::make_unique<ExprAstFilterAppl>(std::move(expr),std::move(filter));
         }
       }
       TRACE(("}parseFilteredVariable()\n"));
       return expr;
     }

引用了 Operator::Filter, getNextToken(), m_curToken, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseFilter(), parseIdentifierOptionalArgs(), TRACE , 以及 ExpressionParser::ExprToken::type.

被这些函数引用 parsePrimaryExpression().

◆ parseIdentifier()

ExprAstPtr ExpressionParser::parseIdentifier ( )

inlineprivate

在文件 template.cpp 第 2264 行定义.

     {
       TRACE(("{parseIdentifier(%s)\n",qPrint(m_curToken.id)));
       ExprAstPtr id = std::make_unique<ExprAstVariable>(m_curToken.id);
       getNextToken();
       TRACE(("}parseIdentifier()\n"));
       return id;
     }

引用了 getNextToken(), ExpressionParser::ExprToken::id, m_curToken, qPrint() , 以及 TRACE.

被这些函数引用 parseIdentifierOptionalArgs().

◆ parseIdentifierOptionalArgs()

ExprAstPtr ExpressionParser::parseIdentifierOptionalArgs ( )

inlineprivate

在文件 template.cpp 第 2282 行定义.

     {
       TRACE(("{parseIdentifierOptionalArgs(%s)\n",qPrint(m_curToken.id)));
       ExprAstPtr expr { parseIdentifier() };
       if (expr)
       {
         if (m_curToken.type==ExprToken::Operator &&
             m_curToken.op==Operator::Colon)
         {
           getNextToken();
           ExprAstList args;
           args.push_back(std::unique_ptr<ExprAst>(parsePrimaryExpression()));
           while (m_curToken.type==ExprToken::Operator &&
                  m_curToken.op==Operator::Comma)
           {
             getNextToken();
             args.push_back(std::unique_ptr<ExprAst>(parsePrimaryExpression()));
           }
           expr = std::make_unique<ExprAstFunctionVariable>(std::move(expr),std::move(args));
         }
       }
       TRACE(("}parseIdentifierOptionalArgs()\n"));
       return expr;
     }

引用了 Operator::Colon, Operator::Comma, getNextToken(), ExpressionParser::ExprToken::id, m_curToken, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseIdentifier(), parsePrimaryExpression(), qPrint(), TRACE , 以及 ExpressionParser::ExprToken::type.

被这些函数引用 parseFilteredVariable().

◆ parseLiteral()

ExprAstPtr ExpressionParser::parseLiteral ( )

inlineprivate

在文件 template.cpp 第 2273 行定义.

     {
       TRACE(("{parseLiteral(%s)\n",qPrint(m_curToken.id)));
       ExprAstPtr expr = std::make_unique<ExprAstLiteral>(m_curToken.id);
       getNextToken();
       TRACE(("}parseLiteral()\n"));
       return expr;
     }

引用了 getNextToken(), ExpressionParser::ExprToken::id, m_curToken, qPrint() , 以及 TRACE.

被这些函数引用 parsePrimaryExpression().

◆ parseMultiplicativeExpression()

ExprAstPtr ExpressionParser::parseMultiplicativeExpression ( )

inlineprivate

在文件 template.cpp 第 2162 行定义.

     {
       TRACE(("{parseMultiplicativeExpression(%s)\n",m_tokenStream));
       ExprAstPtr 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();
           ExprAstPtr rhs = parseUnaryExpression();
           lhs = std::make_unique<ExprAstBinary>(op,std::move(lhs),std::move(rhs));
         }
       }
       TRACE(("}parseMultiplicativeExpression(%s)\n",m_tokenStream));
       return lhs;
     }

引用了 Operator::Divide, getNextToken(), m_curToken, m_tokenStream, Operator::Modulo, Operator::Multiply, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseUnaryExpression(), TRACE , 以及 ExpressionParser::ExprToken::type.

被这些函数引用 parseAdditiveExpression().

◆ parseNotExpression()

ExprAstPtr ExpressionParser::parseNotExpression ( )

inlineprivate

在文件 template.cpp 第 2093 行定义.

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

引用了 getNextToken(), m_curToken, m_line, m_parser, m_tokenStream, Operator::Not, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parseCompareExpression(), TemplateParser::templateName(), TRACE, ExpressionParser::ExprToken::type , 以及 warn().

被这些函数引用 parseAndExpression() , 以及 parseCompareExpression().

◆ parseNumber()

ExprAstPtr ExpressionParser::parseNumber ( )

inlineprivate

在文件 template.cpp 第 2255 行定义.

     {
       TRACE(("{parseNumber(%d)\n",m_curToken.num));
       ExprAstPtr num = std::make_unique<ExprAstNumber>(m_curToken.num);
       getNextToken();
       TRACE(("}parseNumber()\n"));
       return num;
     }

引用了 getNextToken(), m_curToken, ExpressionParser::ExprToken::num , 以及 TRACE.

被这些函数引用 parsePrimaryExpression().

◆ parseOrExpression()

ExprAstPtr ExpressionParser::parseOrExpression ( )

inlineprivate

在文件 template.cpp 第 2057 行定义.

     {
       TRACE(("{parseOrExpression(%s)\n",m_tokenStream));
       ExprAstPtr lhs { parseAndExpression() };
       if (lhs)
       {
         while (m_curToken.type==ExprToken::Operator &&
             m_curToken.op==Operator::Or)
         {
           getNextToken();
           ExprAstPtr rhs { parseAndExpression() };
           lhs = std::make_unique<ExprAstBinary>(Operator::Or,std::move(lhs),std::move(rhs));
         }
       }
       TRACE(("}parseOrExpression(%s)\n",m_tokenStream));
       return lhs;
     }

引用了 getNextToken(), m_curToken, m_tokenStream, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, Operator::Or, parseAndExpression(), TRACE , 以及 ExpressionParser::ExprToken::type.

被这些函数引用 parseExpression().

◆ parsePrimaryExpression()

ExprAstPtr ExpressionParser::parsePrimaryExpression ( )

inlineprivate

在文件 template.cpp 第 2211 行定义.

     {
       TRACE(("{parsePrimary(%s)\n",m_tokenStream));
       ExprAstPtr result;
       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));
             abort();
           }
           break;
         default:
           warn(m_parser->templateName(),m_line,"unexpected token in expression");
       }
       TRACE(("}parsePrimary(%s)\n",m_tokenStream));
       return result;
     }

引用了 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 , 以及 warn().

被这些函数引用 parseFilter(), parseIdentifierOptionalArgs() , 以及 parseUnaryExpression().

◆ parseUnaryExpression()

ExprAstPtr ExpressionParser::parseUnaryExpression ( )

inlineprivate

在文件 template.cpp 第 2181 行定义.

     {
       TRACE(("{parseUnaryExpression(%s)\n",m_tokenStream));
       ExprAstPtr result;
       if (m_curToken.type==ExprToken::Operator)
       {
         if (m_curToken.op==Operator::Plus)
         {
           getNextToken();
           result = parsePrimaryExpression();
         }
         else if (m_curToken.op==Operator::Minus)
         {
           getNextToken();
           ExprAstPtr rhs { parsePrimaryExpression() };
           result = std::make_unique<ExprAstUnary>(m_curToken.op,std::move(rhs));
         }
         else
         {
           result = parsePrimaryExpression();
         }
       }
       else
       {
         result = parsePrimaryExpression();
       }
       TRACE(("}parseUnaryExpression(%s)\n",m_tokenStream));
       return result;
     }

引用了 getNextToken(), m_curToken, m_tokenStream, Operator::Minus, ExpressionParser::ExprToken::op, ExpressionParser::ExprToken::Operator, parsePrimaryExpression(), Operator::Plus, TRACE , 以及 ExpressionParser::ExprToken::type.

被这些函数引用 parseMultiplicativeExpression().

类成员变量说明

◆ m_curToken

ExprToken ExpressionParser::m_curToken

private

在文件 template.cpp 第 2546 行定义.

被这些函数引用 getNextToken(), parseAdditiveExpression(), parseAndExpression(), parseCompareExpression(), parseFilter(), parseFilteredVariable(), parseIdentifier(), parseIdentifierOptionalArgs(), parseLiteral(), parseMultiplicativeExpression(), parseNotExpression(), parseNumber(), parseOrExpression(), parsePrimaryExpression() , 以及 parseUnaryExpression().

◆ m_line

int ExpressionParser::m_line = 0

private

在文件 template.cpp 第 2547 行定义.

被这些函数引用 getNextToken(), parseNotExpression() , 以及 parsePrimaryExpression().

◆ m_parser

const TemplateParser* ExpressionParser::m_parser = 0

private

在文件 template.cpp 第 2545 行定义.

被这些函数引用 getNextToken(), parseNotExpression() , 以及 parsePrimaryExpression().

◆ m_tokenStream

const char* ExpressionParser::m_tokenStream

private

在文件 template.cpp 第 2548 行定义.

被这些函数引用 getNextToken(), parse(), parseAdditiveExpression(), parseAndExpression(), parseCompareExpression(), parseExpression(), parseMultiplicativeExpression(), parseNotExpression(), parseOrExpression(), parsePrimaryExpression() , 以及 parseUnaryExpression().

该类的文档由以下文件生成:

src/template.cpp

类

Public 成员函数

Private 成员函数

Private 属性

详细描述

构造及析构函数说明

◆ ExpressionParser()

◆ ~ExpressionParser()

成员函数说明

◆ getNextToken()

◆ parse()

◆ parseAdditiveExpression()

◆ parseAndExpression()

◆ parseCompareExpression()

◆ parseExpression()

◆ parseFilter()

◆ parseFilteredVariable()

◆ parseIdentifier()

◆ parseIdentifierOptionalArgs()

◆ parseLiteral()

◆ parseMultiplicativeExpression()

◆ parseNotExpression()

◆ parseNumber()

◆ parseOrExpression()

◆ parsePrimaryExpression()

◆ parseUnaryExpression()

类成员变量说明

◆ m_curToken

◆ m_line

◆ m_parser

◆ m_tokenStream