summaryrefslogtreecommitdiffstats
path: root/src/template.cpp
diff options
context:
space:
mode:
authorDimitri van Heesch <dimitri@stack.nl>2013-10-27 08:23:08 (GMT)
committerDimitri van Heesch <dimitri@stack.nl>2013-11-11 19:20:39 (GMT)
commit31198c214de4f4a8f8935426574e9fa0eb0cf27e (patch)
tree67e39ea38a050f0a14b6d135874cf5813c3da51b /src/template.cpp
parent7cda115a6830bf816a094e37c498e5a50ce1b29c (diff)
downloadDoxygen-31198c214de4f4a8f8935426574e9fa0eb0cf27e.zip
Doxygen-31198c214de4f4a8f8935426574e9fa0eb0cf27e.tar.gz
Doxygen-31198c214de4f4a8f8935426574e9fa0eb0cf27e.tar.bz2
More template and context updates
Diffstat (limited to 'src/template.cpp')
-rw-r--r--src/template.cpp534
1 files changed, 376 insertions, 158 deletions
diff --git a/src/template.cpp b/src/template.cpp
index 3c60304..bc564cc 100644
--- a/src/template.cpp
+++ b/src/template.cpp
@@ -36,7 +36,7 @@ static QValueList<QCString> split(const QCString &str,const QCString &sep,bool a
int j = 0;
int i = str.find( sep, j );
- while (i!=-1)
+ while (i!=-1)
{
if ( str.mid(j,i-j).length() > 0 )
{
@@ -109,58 +109,60 @@ class TemplateVariant::Private
bool raw;
};
-TemplateVariant::TemplateVariant()
-{
+TemplateVariant::TemplateVariant()
+{
p = new Private;
p->type=None;
}
TemplateVariant::TemplateVariant(bool b)
-{
+{
p = new Private;
- p->type = Bool;
- p->boolVal = b;
+ p->type = Bool;
+ p->boolVal = b;
}
-TemplateVariant::TemplateVariant(int v)
-{
+TemplateVariant::TemplateVariant(int v)
+{
p = new Private;
- p->type = Integer;
- p->intVal = v;
+ p->type = Integer;
+ p->intVal = v;
}
-TemplateVariant::TemplateVariant(const char *s)
-{
+TemplateVariant::TemplateVariant(const char *s,bool raw)
+{
p = new Private;
- p->type = String;
- p->strVal = s;
+ p->type = String;
+ p->strVal = s;
+ p->raw = raw;
}
-TemplateVariant::TemplateVariant(const QCString &s)
-{
+TemplateVariant::TemplateVariant(const QCString &s,bool raw)
+{
p = new Private;
- p->type = String;
- p->strVal = s;
+ p->type = String;
+ p->strVal = s;
+ p->raw = raw;
}
TemplateVariant::TemplateVariant(const TemplateStructIntf *s)
-{
+{
p = new Private;
- p->type = Struct;
+ p->type = Struct;
p->strukt = s; }
TemplateVariant::TemplateVariant(const TemplateListIntf *l)
-{
+{
p = new Private;
- p->type = List;
- p->list = l;
+ p->type = List;
+ p->list = l;
}
TemplateVariant::TemplateVariant(const void *obj,FuncType f)
-{
+{
p = new Private;
- p->type = Function;
- p->func = f;
+ p->type = Function;
+ p->func = f;
p->obj = obj;
}
@@ -169,7 +171,7 @@ TemplateVariant::~TemplateVariant()
delete p;
}
-TemplateVariant::TemplateVariant(const TemplateVariant &v)
+TemplateVariant::TemplateVariant(const TemplateVariant &v)
{
p = new Private;
p->type = v.p->type;
@@ -182,13 +184,13 @@ TemplateVariant::TemplateVariant(const TemplateVariant &v)
case String: p->strVal = v.p->strVal; break;
case Struct: p->strukt = v.p->strukt; break;
case List: p->list = v.p->list; break;
- case Function: p->func = v.p->func;
+ case Function: p->func = v.p->func;
p->obj = v.p->obj; break;
}
}
-TemplateVariant &TemplateVariant::operator=(const TemplateVariant &v)
-{
+TemplateVariant &TemplateVariant::operator=(const TemplateVariant &v)
+{
p->type = v.p->type;
p->raw = v.p->raw;
switch (p->type)
@@ -199,10 +201,10 @@ TemplateVariant &TemplateVariant::operator=(const TemplateVariant &v)
case String: p->strVal = v.p->strVal; break;
case Struct: p->strukt = v.p->strukt; break;
case List: p->list = v.p->list; break;
- case Function: p->func = v.p->func;
+ case Function: p->func = v.p->func;
p->obj = v.p->obj; break;
}
- return *this;
+ return *this;
}
QCString TemplateVariant::toString() const
@@ -301,17 +303,17 @@ const TemplateListIntf *TemplateVariant::toList() const
return p->type==List ? p->list : 0;
}
-QCString TemplateVariant::call(const QValueList<TemplateVariant> &args)
+TemplateVariant TemplateVariant::call(const QValueList<TemplateVariant> &args)
{
if (p->type==Function) return p->func(p->obj,args);
- return QCString();
+ return TemplateVariant();
}
bool TemplateVariant::operator==(TemplateVariant &other)
{
- if (p->type==None)
+ if (p->type==None)
{
- return FALSE;
+ return FALSE;
}
if (p->type==TemplateVariant::List && other.p->type==TemplateVariant::List)
{
@@ -327,14 +329,14 @@ bool TemplateVariant::operator==(TemplateVariant &other)
}
}
-TemplateVariant::Type TemplateVariant::type() const
-{
- return p->type;
+TemplateVariant::Type TemplateVariant::type() const
+{
+ return p->type;
}
-bool TemplateVariant::isValid() const
-{
- return p->type!=None;
+bool TemplateVariant::isValid() const
+{
+ return p->type!=None;
}
void TemplateVariant::setRaw(bool b)
@@ -427,7 +429,7 @@ class TemplateListConstIterator : public TemplateListIntf::ConstIterator
public:
TemplateListConstIterator(const TemplateList &l) : m_list(l) { m_index=-1; }
virtual ~TemplateListConstIterator() {}
- virtual void toFirst()
+ virtual void toFirst()
{
m_it = m_list.p->elems.begin();
m_index=0;
@@ -507,11 +509,12 @@ class Operator
==, !=, <, >, <=, >=
|
:
+ ,
*/
enum Type
{
- Or, And, Not, In, Equal, NotEqual, Less, Greater, LessEqual,
- GreaterEqual, Filter, Colon, Last
+ Or, And, Not, In, Equal, NotEqual, Less, Greater, LessEqual,
+ GreaterEqual, Filter, Colon, Comma, Last
};
static const char *toString(Type op)
@@ -530,6 +533,7 @@ class Operator
case GreaterEqual: return ">=";
case Filter: return "|";
case Colon: return ":";
+ case Comma: return ",";
case Last: return "?";
}
return "?";
@@ -556,24 +560,26 @@ class TemplateBlockContext
};
-/** @brief Internal class representing the implementation of a template
+/** @brief Internal class representing the implementation of a template
* context */
class TemplateContextImpl : public TemplateContext
{
public:
TemplateContextImpl();
virtual ~TemplateContextImpl();
-
+
// TemplateContext methods
void push();
void pop();
void set(const char *name,const TemplateVariant &v);
TemplateVariant get(const QCString &name) const;
const TemplateVariant *getRef(const QCString &name) const;
- void setOutputDirectory(const QCString &dir)
+ void setOutputDirectory(const QCString &dir)
{ m_outputDir = dir; }
void setEscapeIntf(TemplateEscapeIntf *intf)
{ m_escapeIntf = intf; }
+ void setSpacelessIntf(TemplateSpacelessIntf *intf)
+ { m_spacelessIntf = intf; }
// internal methods
TemplateBlockContext *blockContext();
@@ -584,6 +590,9 @@ class TemplateContextImpl : public TemplateContext
int line() const { return m_line; }
QCString outputDirectory() const { return m_outputDir; }
TemplateEscapeIntf *escapeIntf() const { return m_escapeIntf; }
+ TemplateSpacelessIntf *spacelessIntf() const { return m_spacelessIntf; }
+ void enableSpaceless(bool b) { m_spacelessEnabled=b; }
+ bool spacelessEnabled() const { return m_spacelessEnabled && m_spacelessIntf; }
private:
QCString m_templateName;
@@ -592,6 +601,8 @@ class TemplateContextImpl : public TemplateContext
QList< QDict<TemplateVariant> > m_contextStack;
TemplateBlockContext m_blockContext;
TemplateEscapeIntf *m_escapeIntf;
+ TemplateSpacelessIntf *m_spacelessIntf;
+ bool m_spacelessEnabled;
};
//-----------------------------------------------------------------------------
@@ -802,15 +813,15 @@ static TemplateFilterFactory::AutoRegister<FilterAdd> fAdd("add");
static TemplateFilterFactory::AutoRegister<FilterPrepend> fPrepend("prepend");
static TemplateFilterFactory::AutoRegister<FilterLength> fLength("length");
static TemplateFilterFactory::AutoRegister<FilterDefault> fDefault("default");
-static TemplateFilterFactory::AutoRegister<FilterStripPath> fStripPath("strippath");
+static TemplateFilterFactory::AutoRegister<FilterStripPath> fStripPath("stripPath");
static TemplateFilterFactory::AutoRegister<FilterNoWrap> fNoWrap("nowrap");
//--------------------------------------------------------------------
-/** @brief Base class for all nodes in the abstract syntax tree of an
- * expression.
+/** @brief Base class for all nodes in the abstract syntax tree of an
+ * expression.
*/
-class ExprAst
+class ExprAst
{
public:
virtual ~ExprAst() {}
@@ -821,7 +832,7 @@ class ExprAst
class ExprAstNumber : public ExprAst
{
public:
- ExprAstNumber(int num) : m_number(num)
+ ExprAstNumber(int num) : m_number(num)
{ TRACE(("ExprAstNumber(%d)\n",num)); }
int number() const { return m_number; }
virtual TemplateVariant resolve(TemplateContext *) { return TemplateVariant(m_number); }
@@ -833,13 +844,13 @@ class ExprAstNumber : public ExprAst
class ExprAstVariable : public ExprAst
{
public:
- ExprAstVariable(const char *name) : m_name(name)
+ ExprAstVariable(const char *name) : m_name(name)
{ TRACE(("ExprAstVariable(%s)\n",name)); }
const QCString &name() const { return m_name; }
- virtual TemplateVariant resolve(TemplateContext *c)
- {
+ virtual TemplateVariant resolve(TemplateContext *c)
+ {
TemplateContextImpl *ci = dynamic_cast<TemplateContextImpl*>(c);
- TemplateVariant v = c->get(m_name);
+ TemplateVariant v = c->get(m_name);
if (!v.isValid())
{
warn(ci->templateName(),ci->line(),"undefined variable '%s' in expression",m_name.data());
@@ -850,6 +861,34 @@ class ExprAstVariable : public ExprAst
QCString m_name;
};
+class ExprAstFunctionVariable : public ExprAst
+{
+ public:
+ ExprAstFunctionVariable(ExprAst *var,const QList<ExprAst> &args)
+ : m_var(var), m_args(args)
+ { TRACE(("ExprAstFunctionVariable(%s)\n",var->name().data()));
+ m_args.setAutoDelete(TRUE);
+ }
+ virtual TemplateVariant resolve(TemplateContext *c)
+ {
+ QValueList<TemplateVariant> args;
+ for (uint i=0;i<m_args.count();i++)
+ {
+ TemplateVariant v = m_args.at(i)->resolve(c);
+ args.append(v);
+ }
+ TemplateVariant v = m_var->resolve(c);
+ if (v.type()==TemplateVariant::Function)
+ {
+ v = v.call(args);
+ }
+ return v;
+ }
+ private:
+ ExprAst *m_var;
+ QList<ExprAst> m_args;
+};
+
/** @brief Class representing a filter in the AST */
class ExprAstFilter : public ExprAst
{
@@ -882,11 +921,11 @@ class ExprAstFilterAppl : public ExprAst
{
public:
ExprAstFilterAppl(ExprAst *expr,ExprAstFilter *filter)
- : m_expr(expr), m_filter(filter)
+ : m_expr(expr), m_filter(filter)
{ TRACE(("ExprAstFilterAppl\n")); }
~ExprAstFilterAppl() { delete m_expr; delete m_filter; }
- virtual TemplateVariant resolve(TemplateContext *c)
- {
+ virtual TemplateVariant resolve(TemplateContext *c)
+ {
return m_filter->apply(m_expr->resolve(c),c);
}
private:
@@ -898,7 +937,7 @@ class ExprAstFilterAppl : public ExprAst
class ExprAstLiteral : public ExprAst
{
public:
- ExprAstLiteral(const char *lit) : m_literal(lit)
+ ExprAstLiteral(const char *lit) : m_literal(lit)
{ TRACE(("ExprAstLiteral(%s)\n",lit)); }
const QCString &literal() const { return m_literal; }
virtual TemplateVariant resolve(TemplateContext *) { return TemplateVariant(m_literal); }
@@ -910,10 +949,10 @@ class ExprAstLiteral : public ExprAst
class ExprAstNegate : public ExprAst
{
public:
- ExprAstNegate(ExprAst *expr) : m_expr(expr)
+ ExprAstNegate(ExprAst *expr) : m_expr(expr)
{ TRACE(("ExprAstNegate\n")); }
~ExprAstNegate() { delete m_expr; }
- virtual TemplateVariant resolve(TemplateContext *c)
+ virtual TemplateVariant resolve(TemplateContext *c)
{ return TemplateVariant(!m_expr->resolve(c).toBool()); }
private:
ExprAst *m_expr;
@@ -924,10 +963,10 @@ class ExprAstBinary : public ExprAst
{
public:
ExprAstBinary(Operator::Type op,ExprAst *lhs,ExprAst *rhs)
- : m_operator(op), m_lhs(lhs), m_rhs(rhs)
+ : m_operator(op), m_lhs(lhs), m_rhs(rhs)
{ TRACE(("ExprAstBinary %s\n",Operator::toString(op))); }
~ExprAstBinary() { delete m_lhs; delete m_rhs; }
- virtual TemplateVariant resolve(TemplateContext *c)
+ virtual TemplateVariant resolve(TemplateContext *c)
{
TemplateVariant lhs = m_lhs->resolve(c);
TemplateVariant rhs = m_rhs ? m_rhs->resolve(c) : TemplateVariant();
@@ -994,11 +1033,11 @@ class ExprAstBinary : public ExprAst
class ExpressionParser
{
public:
- ExpressionParser(const QCString &templateName,int line)
- : m_templateName(templateName), m_line(line), m_tokenStream(0)
+ ExpressionParser(const QCString &templateName,int line)
+ : m_templateName(templateName), m_line(line), m_tokenStream(0)
{
}
- virtual ~ExpressionParser()
+ virtual ~ExpressionParser()
{
}
@@ -1050,7 +1089,7 @@ class ExpressionParser
{
TRACE(("{parseOrExpression(%s)\n",m_tokenStream));
ExprAst *lhs = parseAndExpression();
- if (lhs)
+ if (lhs)
{
while (m_curToken.type==ExprToken::Operator &&
m_curToken.op==Operator::Or)
@@ -1068,7 +1107,7 @@ class ExpressionParser
{
TRACE(("{parseAndExpression(%s)\n",m_tokenStream));
ExprAst *lhs = parseNotExpression();
- if (lhs)
+ if (lhs)
{
while (m_curToken.type==ExprToken::Operator &&
m_curToken.op==Operator::And)
@@ -1189,11 +1228,38 @@ class ExpressionParser
return lit;
}
+ ExprAst *parseIdentifierOptionalArgs()
+ {
+ 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 *parseFilteredVariable()
{
TRACE(("{parseFilteredVariable()\n"));
- ExprAst *expr = parseIdentifier();
- if (expr)
+ ExprAst *expr = parseIdentifierOptionalArgs();
+ if (expr)
{
while (m_curToken.type==ExprToken::Operator &&
m_curToken.op==Operator::Filter)
@@ -1300,6 +1366,12 @@ class ExpressionParser
m_curToken.op = Operator::Colon;
p++;
}
+ else if (c==',')
+ {
+ m_curToken.type = ExprToken::Operator;
+ m_curToken.op = Operator::Comma;
+ p++;
+ }
else if ((c=='-' && *(p+1)>='0' && *(p+1)<='9') || (c>='0' && c<='9'))
{
m_curToken.type = ExprToken::Number;
@@ -1321,17 +1393,17 @@ class ExpressionParser
s[0]=c;
m_curToken.id = s;
p++;
- while ((c=*p) &&
+ while ((c=*p) &&
(c=='_' || c=='.' ||
- (c>='a' && c<='z') ||
- (c>='A' && c<='Z') ||
+ (c>='a' && c<='z') ||
+ (c>='A' && c<='Z') ||
(c>='0' && c<='9'))
)
{
s[0]=c;
m_curToken.id+=s;
p++;
- }
+ }
}
else if (c=='"' || c=='\'')
{
@@ -1470,9 +1542,10 @@ class TemplateImpl : public TemplateNode, public Template
//----------------------------------------------------------
-TemplateContextImpl::TemplateContextImpl()
- : m_templateName("<unknown>"), m_line(1), m_escapeIntf(0)
-{
+TemplateContextImpl::TemplateContextImpl()
+ : m_templateName("<unknown>"), m_line(1), m_escapeIntf(0),
+ m_spacelessIntf(0), m_spacelessEnabled(FALSE)
+{
m_contextStack.setAutoDelete(TRUE);
push();
}
@@ -1497,7 +1570,7 @@ TemplateVariant TemplateContextImpl::get(const QCString &name) const
int i=name.find('.');
if (i==-1) // simple name
{
- return getPrimary(name);
+ return getPrimary(name);
}
else // obj.prop
{
@@ -1576,7 +1649,7 @@ const TemplateVariant *TemplateContextImpl::getRef(const QCString &name) const
TemplateVariant TemplateContextImpl::getPrimary(const QCString &name) const
{
const TemplateVariant *v = getRef(name);
- return v ? *v : TemplateVariant();
+ return v ? *v : TemplateVariant();
}
void TemplateContextImpl::push()
@@ -1605,16 +1678,24 @@ TemplateBlockContext *TemplateContextImpl::blockContext()
class TemplateNodeText : public TemplateNode
{
public:
- TemplateNodeText(TemplateParser *,TemplateNode *parent,int,const QCString &data)
- : TemplateNode(parent), m_data(data)
+ TemplateNodeText(TemplateParser *,TemplateNode *parent,int,const QCString &data)
+ : TemplateNode(parent), m_data(data)
{
TRACE(("TemplateNodeText('%s')\n",replace(data,'\n',' ').data()));
}
- void render(FTextStream &ts, TemplateContext *)
+ void render(FTextStream &ts, TemplateContext *c)
{
//printf("TemplateNodeText::render(%s)\n",m_data.data());
- ts << m_data;
+ TemplateContextImpl* ci = dynamic_cast<TemplateContextImpl*>(c);
+ if (ci->spacelessEnabled())
+ {
+ ts << ci->spacelessIntf()->remove(m_data);
+ }
+ else
+ {
+ ts << m_data;
+ }
}
private:
QCString m_data;
@@ -1626,30 +1707,12 @@ class TemplateNodeText : public TemplateNode
class TemplateNodeVariable : public TemplateNode
{
public:
- TemplateNodeVariable(TemplateParser *parser,TemplateNode *parent,int line,const QCString &var)
+ TemplateNodeVariable(TemplateParser *parser,TemplateNode *parent,int line,const QCString &var)
: TemplateNode(parent), m_templateName(parser->templateName()), m_line(line)
{
TRACE(("TemplateNodeVariable(%s)\n",var.data()));
ExpressionParser expParser(m_templateName,line);
- int i=var.find(':');
- int j=var.find('|');
- if (i==-1 || (j!=-1 && j<i)) // no arguments or arg belongs to filter
- {
- m_var = expParser.parseVariable(var);
- }
- else
- {
- QValueList<QCString> args = split(var.mid(i+1),",");
- for (uint j=0;j<args.count();j++)
- {
- ExprAst *expr = expParser.parsePrimary(args[j]);
- if (expr)
- {
- m_args.append(expr);
- }
- }
- m_var = expParser.parseVariable(var.left(i));
- }
+ m_var = expParser.parseVariable(var);
}
~TemplateNodeVariable()
{
@@ -1660,30 +1723,19 @@ class TemplateNodeVariable : public TemplateNode
{
TemplateContextImpl* ci = dynamic_cast<TemplateContextImpl*>(c);
ci->setLocation(m_templateName,m_line);
- QValueList<TemplateVariant> args;
- for (uint i=0;i<m_args.count();i++)
- {
- TemplateVariant v = m_args.at(i)->resolve(c);
- args.append(v);
- }
TemplateVariant v = m_var->resolve(c);
- QCString value;
if (v.type()==TemplateVariant::Function)
{
- value = v.call(args);
- }
- else
- {
- value = v.toString();
+ v = v.call(QValueList<TemplateVariant>());
}
//printf("TemplateNodeVariable::render(%s) raw=%d\n",value.data(),v.raw());
if (ci->escapeIntf() && !v.raw())
{
- ts << ci->escapeIntf()->escape(value);
+ ts << ci->escapeIntf()->escape(v.toString());
}
else
{
- ts << value;
+ ts << v.toString();
}
}
@@ -1696,13 +1748,13 @@ class TemplateNodeVariable : public TemplateNode
//----------------------------------------------------------
-/** @brief Helper class for creating template AST tag nodes and returning
+/** @brief Helper class for creating template AST tag nodes and returning
* the template for a given node.
*/
template<class T> class TemplateNodeCreator : public TemplateNode
{
public:
- TemplateNodeCreator(TemplateParser *parser,TemplateNode *parent,int line)
+ TemplateNodeCreator(TemplateParser *parser,TemplateNode *parent,int line)
: TemplateNode(parent), m_templateName(parser->templateName()), m_line(line) {}
static TemplateNode *createInstance(TemplateParser *parser,
TemplateNode *parent,
@@ -1790,7 +1842,7 @@ class TemplateNodeIf : public TemplateNodeCreator<TemplateNodeIf>
class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
{
public:
- TemplateNodeFor(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
+ TemplateNodeFor(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
: TemplateNodeCreator<TemplateNodeFor>(parser,parent,line)
{
TRACE(("{TemplateNodeFor(%s)\n",data.data()));
@@ -1899,7 +1951,7 @@ class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
{
c->set(m_vars[vi++],v);
}
- else if (m_vars.count()>1 && v.type()==TemplateVariant::Struct)
+ else if (m_vars.count()>1 && v.type()==TemplateVariant::Struct)
// loop variables represent elements in a list item
{
for (uint i=0;i<m_vars.count();i++,vi++)
@@ -1937,11 +1989,42 @@ class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
//----------------------------------------------------------
+/** @brief Class representing an 'markers' tag in a template */
+class TemplateNodeMsg : public TemplateNodeCreator<TemplateNodeMsg>
+{
+ public:
+ TemplateNodeMsg(TemplateParser *parser,TemplateNode *parent,int line,const QCString &)
+ : TemplateNodeCreator<TemplateNodeMsg>(parser,parent,line)
+ {
+ TRACE(("{TemplateNodeMsg()\n"));
+ QStrList stopAt;
+ stopAt.append("endmsg");
+ parser->parse(this,line,stopAt,m_nodes);
+ parser->removeNextToken(); // skip over endmarkers
+ TRACE(("}TemplateNodeMsg()\n"));
+ }
+ void render(FTextStream &, TemplateContext *c)
+ {
+ TemplateContextImpl* ci = dynamic_cast<TemplateContextImpl*>(c);
+ TemplateEscapeIntf *escIntf = ci->escapeIntf();
+ ci->setEscapeIntf(0); // avoid escaping things we send to standard out
+ FTextStream ts(stdout);
+ m_nodes.render(ts,c);
+ ts << endl;
+ ci->setEscapeIntf(escIntf);
+ }
+ private:
+ TemplateNodeList m_nodes;
+};
+
+
+//----------------------------------------------------------
+
/** @brief Class representing a 'block' tag in a template */
class TemplateNodeBlock : public TemplateNodeCreator<TemplateNodeBlock>
{
public:
- TemplateNodeBlock(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
+ TemplateNodeBlock(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
: TemplateNodeCreator<TemplateNodeBlock>(parser,parent,line)
{
TRACE(("{TemplateNodeBlock(%s)\n",data.data()));
@@ -2014,7 +2097,7 @@ class TemplateNodeBlock : public TemplateNodeCreator<TemplateNodeBlock>
class TemplateNodeExtend : public TemplateNodeCreator<TemplateNodeExtend>
{
public:
- TemplateNodeExtend(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
+ TemplateNodeExtend(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
: TemplateNodeCreator<TemplateNodeExtend>(parser,parent,line)
{
TRACE(("{TemplateNodeExtend(%s)\n",data.data()));
@@ -2065,6 +2148,11 @@ class TemplateNodeExtend : public TemplateNodeCreator<TemplateNodeExtend>
{
bc->add(nb);
}
+ TemplateNodeMsg *msg = dynamic_cast<TemplateNodeMsg*>(n);
+ if (msg)
+ {
+ msg->render(ts,c);
+ }
}
// render the base template with the given context
@@ -2090,7 +2178,7 @@ class TemplateNodeExtend : public TemplateNodeCreator<TemplateNodeExtend>
class TemplateNodeInclude : public TemplateNodeCreator<TemplateNodeInclude>
{
public:
- TemplateNodeInclude(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
+ TemplateNodeInclude(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
: TemplateNodeCreator<TemplateNodeInclude>(parser,parent,line)
{
TRACE(("TemplateNodeInclude(%s)\n",data.data()));
@@ -2140,11 +2228,11 @@ class TemplateNodeInclude : public TemplateNodeCreator<TemplateNodeInclude>
//----------------------------------------------------------
-/** @brief Class representing an 'instantiate' tag in a template */
+/** @brief Class representing an 'create' tag in a template */
class TemplateNodeCreate : public TemplateNodeCreator<TemplateNodeCreate>
{
public:
- TemplateNodeCreate(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
+ TemplateNodeCreate(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
: TemplateNodeCreator<TemplateNodeCreate>(parser,parent,line)
{
TRACE(("TemplateNodeCreate(%s)\n",data.data()));
@@ -2237,19 +2325,19 @@ class TemplateNodeCreate : public TemplateNodeCreator<TemplateNodeCreate>
//----------------------------------------------------------
-/** @brief Class representing an 'instantiate' tag in a template */
+/** @brief Class representing an 'tree' tag in a template */
class TemplateNodeTree : public TemplateNodeCreator<TemplateNodeTree>
{
struct TreeContext
{
- TreeContext(TemplateNodeTree *o,const TemplateListIntf *l,TemplateContext *c)
+ TreeContext(TemplateNodeTree *o,const TemplateListIntf *l,TemplateContext *c)
: object(o), list(l), templateCtx(c) {}
TemplateNodeTree *object;
const TemplateListIntf *list;
TemplateContext *templateCtx;
};
public:
- TemplateNodeTree(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
+ TemplateNodeTree(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
: TemplateNodeCreator<TemplateNodeTree>(parser,parent,line)
{
TRACE(("{TemplateNodeTree(%s)\n",data.data()));
@@ -2269,9 +2357,10 @@ class TemplateNodeTree : public TemplateNodeCreator<TemplateNodeTree>
{
delete m_treeExpr;
}
- static QCString renderChildrenStub(const void *ctx, const QValueList<TemplateVariant> &)
+ static TemplateVariant renderChildrenStub(const void *ctx, const QValueList<TemplateVariant> &)
{
- return ((TreeContext*)ctx)->object->renderChildren((const TreeContext*)ctx);
+ return TemplateVariant(((TreeContext*)ctx)->object->
+ renderChildren((const TreeContext*)ctx),TRUE);
}
QCString renderChildren(const TreeContext *ctx)
{
@@ -2305,7 +2394,7 @@ class TemplateNodeTree : public TemplateNodeCreator<TemplateNodeTree>
}
}
}
- if (!hasChildren)
+ if (!hasChildren)
{
c->set("children",TemplateVariant("")); // provide default
m_treeNodes.render(ss,c);
@@ -2339,7 +2428,7 @@ class TemplateNodeTree : public TemplateNodeCreator<TemplateNodeTree>
//----------------------------------------------------------
-/** @brief Class representing an 'instantiate' tag in a template */
+/** @brief Class representing an 'with' tag in a template */
class TemplateNodeWith : public TemplateNodeCreator<TemplateNodeWith>
{
struct Mapping
@@ -2350,9 +2439,10 @@ class TemplateNodeWith : public TemplateNodeCreator<TemplateNodeWith>
ExprAst *value;
};
public:
- TemplateNodeWith(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
+ TemplateNodeWith(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
: TemplateNodeCreator<TemplateNodeWith>(parser,parent,line)
{
+ TRACE(("{TemplateNodeWith(%s)\n",data.data()));
m_args.setAutoDelete(TRUE);
ExpressionParser expParser(parser->templateName(),line);
QValueList<QCString> args = split(data," ");
@@ -2379,6 +2469,7 @@ class TemplateNodeWith : public TemplateNodeCreator<TemplateNodeWith>
stopAt.append("endwith");
parser->parse(this,line,stopAt,m_nodes);
parser->removeNextToken(); // skip over endwith
+ TRACE(("}TemplateNodeWith(%s)\n",data.data()));
}
~TemplateNodeWith()
{
@@ -2404,7 +2495,130 @@ class TemplateNodeWith : public TemplateNodeCreator<TemplateNodeWith>
//----------------------------------------------------------
-/** @brief Factory class for creating tag AST nodes found in a template */
+/** @brief Class representing an 'spaceless' tag in a template */
+class TemplateNodeSpaceless : public TemplateNodeCreator<TemplateNodeSpaceless>
+{
+ public:
+ TemplateNodeSpaceless(TemplateParser *parser,TemplateNode *parent,int line,const QCString &)
+ : TemplateNodeCreator<TemplateNodeSpaceless>(parser,parent,line)
+ {
+ TRACE(("{TemplateNodeSpaceless()\n"));
+ QStrList stopAt;
+ stopAt.append("endspaceless");
+ parser->parse(this,line,stopAt,m_nodes);
+ parser->removeNextToken(); // skip over endwith
+ TRACE(("}TemplateNodeSpaceless()\n"));
+ }
+ void render(FTextStream &ts, TemplateContext *c)
+ {
+ TemplateContextImpl *ci = dynamic_cast<TemplateContextImpl*>(c);
+ bool wasSpaceless = ci->spacelessEnabled();
+ ci->enableSpaceless(TRUE);
+ m_nodes.render(ts,c);
+ ci->enableSpaceless(wasSpaceless);
+ }
+ private:
+ TemplateNodeList m_nodes;
+};
+
+//----------------------------------------------------------
+
+/** @brief Class representing an 'markers' tag in a template */
+class TemplateNodeMarkers : public TemplateNodeCreator<TemplateNodeMarkers>
+{
+ public:
+ TemplateNodeMarkers(TemplateParser *parser,TemplateNode *parent,int line,const QCString &data)
+ : TemplateNodeCreator<TemplateNodeMarkers>(parser,parent,line)
+ {
+ TRACE(("{TemplateNodeMarkers(%s)\n",data.data()));
+ int i = data.find(" in ");
+ int w = data.find(" with ");
+ if (i==-1 || w==-1 || w<i)
+ {
+ warn(m_templateName,line,"markers tag as wrong format. Expected: markers <var> in <list> with <string_with_markers>");
+ }
+ else
+ {
+ ExpressionParser expParser(parser->templateName(),line);
+ m_var = data.left(i);
+ m_listExpr = expParser.parseVariable(data.mid(i+4,w-i-4));
+ m_patternExpr = expParser.parseVariable(data.right(data.length()-w-6));
+ }
+ QStrList stopAt;
+ stopAt.append("endmarkers");
+ parser->parse(this,line,stopAt,m_nodes);
+ parser->removeNextToken(); // skip over endmarkers
+ TRACE(("}TemplateNodeMarkers(%s)\n",data.data()));
+ }
+ void render(FTextStream &ts, TemplateContext *c)
+ {
+ TemplateContextImpl *ci = dynamic_cast<TemplateContextImpl*>(c);
+ ci->setLocation(m_templateName,m_line);
+ if (!m_var.isEmpty() && m_listExpr && m_patternExpr)
+ {
+ TemplateVariant v = m_listExpr->resolve(c);
+ const TemplateListIntf *list = v.toList();
+ TemplateVariant patternStr = m_patternExpr->resolve(c);
+ if (list)
+ {
+ if (patternStr.type()==TemplateVariant::String)
+ {
+ TemplateListIntf::ConstIterator *it = list->createIterator();
+ c->push();
+ QCString str = patternStr.toString();
+ QRegExp marker("@[0-9]+"); // pattern for a marker, i.e. @0, @1 ... @12, etc
+ int index=0,newIndex,matchLen;
+ while ((newIndex=marker.match(str,index,&matchLen))!=-1)
+ {
+ ts << str.mid(index,newIndex-index); // write text before marker
+ bool ok;
+ uint entryIndex = str.mid(newIndex+1,matchLen-1).toUInt(&ok); // get marker id
+ TemplateVariant var;
+ uint i=0;
+ // search for list element at position id
+ for (it->toFirst(); (it->current(var)) && i<entryIndex; it->toNext(),i++) {}
+ if (ok && i==entryIndex) // found element
+ {
+ c->set(m_var,var); // define local variable to hold element of list type
+ bool wasSpaceless = ci->spacelessEnabled();
+ ci->enableSpaceless(TRUE);
+ m_nodes.render(ts,c);
+ ci->enableSpaceless(wasSpaceless);
+ }
+ else if (!ok)
+ {
+ warn(m_templateName,m_line,"markers pattern string has invalid markers '%s'",str.data());
+ }
+ else if (i<entryIndex)
+ {
+ warn(m_templateName,m_line,"markers list does not an element for marker position %d",i);
+ }
+ index=newIndex+matchLen; // set index just after marker
+ }
+ ts << str.right(str.length()-index); // write text after last marker
+ c->pop();
+ }
+ else
+ {
+ warn(m_templateName,m_line,"markers requires a parameter of string type after 'with'!");
+ }
+ }
+ else
+ {
+ warn(m_templateName,m_line,"markers requires a parameter of list type after 'in'!");
+ }
+ }
+ }
+ private:
+ TemplateNodeList m_nodes;
+ QCString m_var;
+ ExprAst *m_listExpr;
+ ExprAst *m_patternExpr;
+};
+
+//----------------------------------------------------------
+
+/** @brief Factory class for creating tag AST nodes found in a template */
class TemplateNodeFactory
{
public:
@@ -2450,20 +2664,23 @@ class TemplateNodeFactory
};
// register a handler for each start tag we support
-static TemplateNodeFactory::AutoRegister<TemplateNodeIf> autoRefIf("if");
-static TemplateNodeFactory::AutoRegister<TemplateNodeFor> autoRefFor("for");
-static TemplateNodeFactory::AutoRegister<TemplateNodeTree> autoRefTree("recursetree");
-static TemplateNodeFactory::AutoRegister<TemplateNodeWith> autoRefWith("with");
-static TemplateNodeFactory::AutoRegister<TemplateNodeBlock> autoRefBlock("block");
-static TemplateNodeFactory::AutoRegister<TemplateNodeExtend> autoRefExtend("extend");
-static TemplateNodeFactory::AutoRegister<TemplateNodeCreate> autoRefCreate("create");
-static TemplateNodeFactory::AutoRegister<TemplateNodeInclude> autoRefInclude("include");
+static TemplateNodeFactory::AutoRegister<TemplateNodeIf> autoRefIf("if");
+static TemplateNodeFactory::AutoRegister<TemplateNodeFor> autoRefFor("for");
+static TemplateNodeFactory::AutoRegister<TemplateNodeMsg> autoRefMsg("msg");
+static TemplateNodeFactory::AutoRegister<TemplateNodeTree> autoRefTree("recursetree");
+static TemplateNodeFactory::AutoRegister<TemplateNodeWith> autoRefWith("with");
+static TemplateNodeFactory::AutoRegister<TemplateNodeBlock> autoRefBlock("block");
+static TemplateNodeFactory::AutoRegister<TemplateNodeExtend> autoRefExtend("extend");
+static TemplateNodeFactory::AutoRegister<TemplateNodeCreate> autoRefCreate("create");
+static TemplateNodeFactory::AutoRegister<TemplateNodeInclude> autoRefInclude("include");
+static TemplateNodeFactory::AutoRegister<TemplateNodeMarkers> autoRefMarkers("markers");
+static TemplateNodeFactory::AutoRegister<TemplateNodeSpaceless> autoRefSpaceless("spaceless");
//----------------------------------------------------------
-TemplateBlockContext::TemplateBlockContext() : m_blocks(257)
-{
- m_blocks.setAutoDelete(TRUE);
+TemplateBlockContext::TemplateBlockContext() : m_blocks(257)
+{
+ m_blocks.setAutoDelete(TRUE);
}
TemplateNodeBlock *TemplateBlockContext::get(const QCString &name) const
@@ -2552,7 +2769,7 @@ class TemplateLexer
QCString m_data;
};
-TemplateLexer::TemplateLexer(const QCString &fileName,const QCString &data) :
+TemplateLexer::TemplateLexer(const QCString &fileName,const QCString &data) :
m_fileName(fileName), m_data(data)
{
}
@@ -2585,7 +2802,7 @@ void TemplateLexer::tokenize(QList<TemplateToken> &tokens)
{
switch (state)
{
- case StateText:
+ case StateText:
if (c=='{') // {{ or {% or {# or something else
{
state=StateBeginTemplate;
@@ -2728,7 +2945,7 @@ void TemplateLexer::tokenize(QList<TemplateToken> &tokens)
{
state=StateText;
startLinePos=pos+1;
- // if the current line only contain commands and whitespace,
+ // if the current line only contain commands and whitespace,
// then skip it in the output by moving lastTokenPos
if (markStartPos!=-1 && emptyOutputLine) lastTokenPos = startLinePos;
// reset markers
@@ -2813,10 +3030,11 @@ void TemplateParser::parse(
{
nodes.append(node);
}
- else if (command=="empty" || command=="else" ||
- command=="endif" || command=="endfor" ||
- command=="endblock" || command=="endwith" ||
- command=="endrecursetree")
+ else if (command=="empty" || command=="else" ||
+ command=="endif" || command=="endfor" ||
+ command=="endblock" || command=="endwith" ||
+ command=="endrecursetree" || command=="endspaceless" ||
+ command=="endmarkers" || command=="endmsg")
{
warn(m_templateName,tok->line,"Found tag '%s' without matching start tag",command.data());
}
@@ -2888,8 +3106,8 @@ TemplateImpl::TemplateImpl(TemplateEngine *engine,const QCString &name,const QCS
parser.parse(this,1,QStrList(),m_nodes);
}
-void TemplateImpl::render(FTextStream &ts, TemplateContext *c)
-{
+void TemplateImpl::render(FTextStream &ts, TemplateContext *c)
+{
if (!m_nodes.isEmpty())
{
TemplateNodeExtend *ne = dynamic_cast<TemplateNodeExtend*>(m_nodes.getFirst());
@@ -2908,7 +3126,7 @@ void TemplateImpl::render(FTextStream &ts, TemplateContext *c)
}
}
}
- m_nodes.render(ts,c);
+ m_nodes.render(ts,c);
}
}