summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/context.cpp86
-rw-r--r--src/template.cpp119
-rw-r--r--src/template.h14
-rw-r--r--src/util.cpp3
4 files changed, 111 insertions, 111 deletions
diff --git a/src/context.cpp b/src/context.cpp
index 83e8e7a..3bdead3 100644
--- a/src/context.cpp
+++ b/src/context.cpp
@@ -443,147 +443,147 @@ class TranslateContext::Private
{
public:
- TemplateVariant handleGeneratedAt(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleGeneratedAt(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==2)
+ if (args.size()==2)
{
return theTranslator->trGeneratedAt(args[0].toString(),args[1].toString());
}
else
{
- err("tr.generateAt should take two arguments, got %d!\n",args.count());
+ err("tr.generateAt should take two arguments, got %zu!\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleInheritanceDiagramFor(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleInheritanceDiagramFor(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trClassDiagram(args[0].toString());
}
else
{
- err("tr.inheritanceDiagramFor should take one argument, got %d!\n",args.count());
+ err("tr.inheritanceDiagramFor should take one argument, got %zu!\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleCollaborationDiagramFor(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleCollaborationDiagramFor(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trCollaborationDiagram(args[0].toString());
}
else
{
- err("tr.collaborationDiagramFor should take one argument, got %d!\n",args.count());
+ err("tr.collaborationDiagramFor should take one argument, got %zu!\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleDirDependencyGraphFor(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleDirDependencyGraphFor(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trDirDepGraph(args[0].toString());
}
else
{
- err("tr.dirDependencyGraphFor should take one argument, got %d!\n",args.count());
+ err("tr.dirDependencyGraphFor should take one argument, got %zu!\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleInheritsList(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleInheritsList(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trInheritsList(args[0].toInt());
}
else
{
- err("tr.inheritsList should take one integer argument, got %d!\n",args.count());
+ err("tr.inheritsList should take one integer argument, got %zu!\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleInheritedByList(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleInheritedByList(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trInheritedByList(args[0].toInt());
}
else
{
- err("tr.inheritedByList should take one integer argument, got %d!\n",args.count());
+ err("tr.inheritedByList should take one integer argument, got %zu!\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleWriteList(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleWriteList(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trWriteList(args[0].toInt());
}
else
{
- err("tr.*List should take one integer argument, got %d!\n",args.count());
+ err("tr.*List should take one integer argument, got %zu!\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleImplementedBy(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleImplementedBy(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trImplementedInList(args[0].toInt());
}
else
{
- err("tr.implementedBy should take one integer argument, got %d!\n",args.count());
+ err("tr.implementedBy should take one integer argument, got %zu!\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleReimplementedBy(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleReimplementedBy(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trReimplementedInList(args[0].toInt());
}
else
{
- err("tr.reimplementedBy should take one integer argument, got %d!\n",args.count());
+ err("tr.reimplementedBy should take one integer argument, got %zu!\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleSourceRefs(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleSourceRefs(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trReferences()+" "+theTranslator->trWriteList(args[0].toInt())+".";
}
else
{
- err("tr.sourceRefs should take one integer argument, got %d\n",args.count());
+ err("tr.sourceRefs should take one integer argument, got %zu\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleSourceRefBys(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleSourceRefBys(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trReferencedBy()+" "+theTranslator->trWriteList(args[0].toInt())+".";
}
else
{
- err("tr.sourceRefBys should take one integer argument, got %d\n",args.count());
+ err("tr.sourceRefBys should take one integer argument, got %zu\n",args.size());
}
return TemplateVariant();
}
- TemplateVariant handleIncludeDependencyGraph(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleIncludeDependencyGraph(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return theTranslator->trInclDepGraph(args[0].toString());
}
else
{
- err("tr.includeDependencyGraph should take one string argument, got %d\n",args.count());
+ err("tr.includeDependencyGraph should take one string argument, got %zu\n",args.size());
}
return TemplateVariant();
}
@@ -5126,15 +5126,15 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private>
{
return m_memberDef->typeString();
}
- TemplateVariant handleDetailsVisibleFor(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleDetailsVisibleFor(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
return m_memberDef->isDetailedSectionVisible(args[0].toString()=="module",args[0].toString()=="file");
}
else
{
- err(".detailsVisibleFor should take one string argument, got %d\n",args.count());
+ err(".detailsVisibleFor should take one string argument, got %zu\n",args.size());
}
return TemplateVariant();
}
@@ -5142,9 +5142,9 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private>
{
return TemplateVariant::Delegate::fromMethod<Private,&Private::handleDetailsVisibleFor>(this);
}
- TemplateVariant handleNameWithContextFor(const QValueList<TemplateVariant> &args) const
+ TemplateVariant handleNameWithContextFor(const std::vector<TemplateVariant> &args) const
{
- if (args.count()==1)
+ if (args.size()==1)
{
SrcLangExt lang = m_memberDef->getLanguage();
QCString n = m_memberDef->name();
@@ -5166,7 +5166,7 @@ class MemberContext::Private : public DefinitionContext<MemberContext::Private>
}
else
{
- err(".nameWithContextFor should take one string argument, got %d\n",args.count());
+ err(".nameWithContextFor should take one string argument, got %zu\n",args.size());
}
return TemplateVariant();
}
@@ -9418,7 +9418,7 @@ class ArgumentContext::Private
return result;
}
private:
- const Argument &m_argument;
+ Argument m_argument;
const Definition *m_def;
QCString m_relPath;
struct Cachable
diff --git a/src/template.cpp b/src/template.cpp
index c836c6b..80962e8 100644
--- a/src/template.cpp
+++ b/src/template.cpp
@@ -48,10 +48,10 @@ class TemplateToken;
//-------------------------------------------------------------------
-static QValueList<QCString> split(const QCString &str,const QCString &sep,
+static std::vector<QCString> split(const QCString &str,const QCString &sep,
bool allowEmptyEntries=FALSE,bool cleanup=TRUE)
{
- QValueList<QCString> lst;
+ std::vector<QCString> lst;
int j = 0;
int i = str.find( sep, j );
@@ -62,16 +62,16 @@ static QValueList<QCString> split(const QCString &str,const QCString &sep,
{
if (cleanup)
{
- lst.append(str.mid(j,i-j).stripWhiteSpace());
+ lst.push_back(str.mid(j,i-j).stripWhiteSpace());
}
else
{
- lst.append(str.mid(j,i-j));
+ lst.push_back(str.mid(j,i-j));
}
}
else if (allowEmptyEntries)
{
- lst.append("");
+ lst.push_back("");
}
j = i + sep.length();
i = str.find(sep,j);
@@ -82,16 +82,16 @@ static QValueList<QCString> split(const QCString &str,const QCString &sep,
{
if (cleanup)
{
- lst.append(str.mid(j,l-j+1).stripWhiteSpace());
+ lst.push_back(str.mid(j,l-j+1).stripWhiteSpace());
}
else
{
- lst.append(str.mid(j,l-j+1));
+ lst.push_back(str.mid(j,l-j+1));
}
}
else if (allowEmptyEntries)
{
- lst.append("");
+ lst.push_back("");
}
return lst;
@@ -305,7 +305,7 @@ class TemplateList::Private
{
public:
Private() : index(-1), refCount(0) {}
- QValueList<TemplateVariant> elems;
+ std::vector<TemplateVariant> elems;
int index = -1;
int refCount = 0;
};
@@ -338,67 +338,65 @@ int TemplateList::release()
uint TemplateList::count() const
{
- return p->elems.count();
+ return p->elems.size();
}
void TemplateList::append(const TemplateVariant &v)
{
- p->elems.append(v);
+ p->elems.push_back(v);
}
// iterator support
class TemplateListConstIterator : public TemplateListIntf::ConstIterator
{
public:
- TemplateListConstIterator(const TemplateList &l) : m_list(l) { m_index=-1; }
+ TemplateListConstIterator(const TemplateList &l) : m_list(l) { m_index=0; }
virtual ~TemplateListConstIterator() {}
virtual void toFirst()
{
- m_it = m_list.p->elems.begin();
m_index=0;
}
virtual void toLast()
{
- m_it = m_list.p->elems.fromLast();
- m_index=m_list.count()-1;
+ if (m_list.p->elems.size()>0)
+ {
+ m_index=m_list.p->elems.size()-1;
+ }
+ else
+ {
+ m_index=0;
+ }
}
virtual void toNext()
{
- if (m_it!=m_list.p->elems.end())
+ if (m_index<m_list.p->elems.size())
{
- ++m_it;
- ++m_index;
+ m_index++;
}
}
virtual void toPrev()
{
if (m_index>0)
{
- --m_it;
--m_index;
}
- else
- {
- m_index=-1;
- }
}
virtual bool current(TemplateVariant &v) const
{
- if (m_index<0 || m_it==m_list.p->elems.end())
+ if (m_index>=0 && m_index<m_list.p->elems.size())
{
- v = TemplateVariant();
- return FALSE;
+ v = m_list.p->elems[m_index];
+ return TRUE;
}
else
{
- v = *m_it;
- return TRUE;
+ v = TemplateVariant();
+ return FALSE;
}
}
private:
const TemplateList &m_list;
- QValueList<TemplateVariant>::ConstIterator m_it;
- int m_index = 0;
+ size_t m_index = 0;
};
TemplateListIntf::ConstIterator *TemplateList::createIterator() const
@@ -408,7 +406,7 @@ TemplateListIntf::ConstIterator *TemplateList::createIterator() const
TemplateVariant TemplateList::at(uint index) const
{
- if (index<p->elems.count())
+ if (index<p->elems.size())
{
return p->elems[index];
}
@@ -545,7 +543,7 @@ class TemplateContextImpl : public TemplateContext
QCString outputDirectory() const { return m_outputDir; }
TemplateEscapeIntf *escapeIntf() const { return m_activeEscapeIntf; }
TemplateSpacelessIntf *spacelessIntf() const { return m_spacelessIntf; }
- void enableSpaceless(bool b) { if (b && !m_spacelessEnabled) m_spacelessIntf->reset();
+ void enableSpaceless(bool b) { if (b && !m_spacelessEnabled) m_spacelessIntf->reset();
m_spacelessEnabled=b;
}
bool spacelessEnabled() const { return m_spacelessEnabled && m_spacelessIntf; }
@@ -562,7 +560,7 @@ class TemplateContextImpl : public TemplateContext
// index related functions
void openSubIndex(const QCString &indexName);
void closeSubIndex(const QCString &indexName);
- void addIndexEntry(const QCString &indexName,const QValueList<TemplateKeyValue> &arguments);
+ void addIndexEntry(const QCString &indexName,const std::vector<TemplateKeyValue> &arguments);
private:
const TemplateEngine *m_engine = 0;
@@ -1483,11 +1481,11 @@ class ExprAstFunctionVariable : public ExprAst
}
virtual TemplateVariant resolve(TemplateContext *c)
{
- QValueList<TemplateVariant> args;
+ std::vector<TemplateVariant> args;
for (uint i=0;i<m_args.count();i++)
{
TemplateVariant v = m_args.at(i)->resolve(c);
- args.append(v);
+ args.push_back(v);
}
TemplateVariant v = m_var->resolve(c);
if (v.type()==TemplateVariant::Function)
@@ -2607,7 +2605,7 @@ static void getPathListFunc(TemplateStructIntf *entry,TemplateList *list)
list->append(entry);
}
-static TemplateVariant getPathFunc(const void *ctx, const QValueList<TemplateVariant> &)
+static TemplateVariant getPathFunc(const void *ctx, const std::vector<TemplateVariant> &)
{
TemplateStruct *entry = (TemplateStruct*)ctx;
TemplateList *result = TemplateList::alloc();
@@ -2615,9 +2613,9 @@ static TemplateVariant getPathFunc(const void *ctx, const QValueList<TemplateVar
return result;
}
-void TemplateContextImpl::addIndexEntry(const QCString &indexName,const QValueList<TemplateKeyValue> &arguments)
+void TemplateContextImpl::addIndexEntry(const QCString &indexName,const std::vector<TemplateKeyValue> &arguments)
{
- QValueListConstIterator<TemplateKeyValue> it = arguments.begin();
+ auto it = arguments.begin();
//printf("TemplateContextImpl::addIndexEntry(%s)\n",indexName.data());
//while (it!=arguments.end())
//{
@@ -2759,7 +2757,7 @@ class TemplateNodeVariable : public TemplateNode
TemplateVariant v = m_var->resolve(c);
if (v.type()==TemplateVariant::Function)
{
- v = v.call(QValueList<TemplateVariant>());
+ v = v.call(std::vector<TemplateVariant>());
}
if (ci->escapeIntf() && !v.raw())
{
@@ -2843,7 +2841,7 @@ template<class T> class TemplateNodeCreator : public TemplateNode
if (d.exists())
{
bool ok = d.mkdir(fileName.mid(j,i-j));
- if (!ok)
+ if (!ok)
{
err("Failed to create directory '%s'\n",(fileName.mid(j,i-j)).data());
break;
@@ -3217,7 +3215,7 @@ class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
else
{
m_vars = split(data.left(i),",");
- if (m_vars.count()==0)
+ if (m_vars.size()==0)
{
parser->warn(m_templateName,line,"for needs at least one iterator variable");
}
@@ -3270,7 +3268,7 @@ class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
TemplateVariant v = m_expr->resolve(c);
if (v.type()==TemplateVariant::Function)
{
- v = v.call(QValueList<TemplateVariant>());
+ v = v.call(std::vector<TemplateVariant>());
}
const TemplateListIntf *list = v.toList();
if (list)
@@ -3287,8 +3285,9 @@ class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
const TemplateVariant *parentLoop = c->getRef("forloop");
uint index = m_reversed ? listSize-1 : 0;
TemplateListIntf::ConstIterator *it = list->createIterator();
+ TemplateVariant ve;
for (m_reversed ? it->toLast() : it->toFirst();
- (it->current(v));
+ (it->current(ve));
m_reversed ? it->toPrev() : it->toNext())
{
TemplateAutoRef<TemplateStruct> s(TemplateStruct::alloc());
@@ -3304,19 +3303,19 @@ class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
// add variables for this loop to the context
//obj->addVariableToContext(index,m_vars,c);
uint vi=0;
- if (m_vars.count()==1) // loop variable represents an item
+ if (m_vars.size()==1) // loop variable represents an item
{
- c->set(m_vars[vi++],v);
+ c->set(m_vars[vi++],ve);
}
- else if (m_vars.count()>1 && v.type()==TemplateVariant::Struct)
+ else if (m_vars.size()>1 && ve.type()==TemplateVariant::Struct)
// loop variables represent elements in a list item
{
- for (uint i=0;i<m_vars.count();i++,vi++)
+ for (uint i=0;i<m_vars.size();i++,vi++)
{
- c->set(m_vars[vi],v.toStruct()->get(m_vars[vi]));
+ c->set(m_vars[vi],ve.toStruct()->get(m_vars[vi]));
}
}
- for (;vi<m_vars.count();vi++)
+ for (;vi<m_vars.size();vi++)
{
c->set(m_vars[vi],TemplateVariant());
}
@@ -3339,7 +3338,7 @@ class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
private:
bool m_reversed = false;
ExprAst *m_expr = 0;
- QValueList<QCString> m_vars;
+ std::vector<QCString> m_vars;
TemplateNodeList m_loopNodes;
TemplateNodeList m_emptyNodes;
};
@@ -3766,7 +3765,7 @@ class TemplateNodeTree : public TemplateNodeCreator<TemplateNodeTree>
{
delete m_treeExpr;
}
- static TemplateVariant renderChildrenStub(const void *ctx, const QValueList<TemplateVariant> &)
+ static TemplateVariant renderChildrenStub(const void *ctx, const std::vector<TemplateVariant> &)
{
return TemplateVariant(((TreeContext*)ctx)->object->
renderChildren((const TreeContext*)ctx),TRUE);
@@ -3866,8 +3865,8 @@ class TemplateNodeIndexEntry : public TemplateNodeCreator<TemplateNodeIndexEntry
TRACE(("{TemplateNodeIndexEntry(%s)\n",data.data()));
m_args.setAutoDelete(TRUE);
ExpressionParser expParser(parser,line);
- QValueList<QCString> args = split(data," ");
- QValueListIterator<QCString> it = args.begin();
+ std::vector<QCString> args = split(data," ");
+ auto it = args.begin();
if (it==args.end() || (*it).find('=')!=-1)
{
parser->warn(parser->templateName(),line,"Missing name for indexentry tag");
@@ -3906,10 +3905,10 @@ class TemplateNodeIndexEntry : public TemplateNodeCreator<TemplateNodeIndexEntry
ci->setLocation(m_templateName,m_line);
QListIterator<Mapping> it(m_args);
Mapping *mapping;
- QValueList<TemplateKeyValue> list;
+ std::vector<TemplateKeyValue> list;
for (it.toFirst();(mapping=it.current());++it)
{
- list.append(TemplateKeyValue(mapping->name,mapping->value->resolve(c)));
+ list.push_back(TemplateKeyValue(mapping->name,mapping->value->resolve(c)));
}
ci->addIndexEntry(m_name,list);
}
@@ -4012,8 +4011,8 @@ class TemplateNodeWith : public TemplateNodeCreator<TemplateNodeWith>
m_args.setAutoDelete(TRUE);
ExpressionParser expParser(parser,line);
QCString filteredData = removeSpacesAroundEquals(data);
- QValueList<QCString> args = split(filteredData," ");
- QValueListIterator<QCString> it = args.begin();
+ std::vector<QCString> args = split(filteredData," ");
+ auto it = args.begin();
while (it!=args.end())
{
QCString arg = *it;
@@ -4075,8 +4074,8 @@ class TemplateNodeCycle : public TemplateNodeCreator<TemplateNodeCycle>
m_args.setAutoDelete(TRUE);
m_index=0;
ExpressionParser expParser(parser,line);
- QValueList<QCString> args = split(data," ");
- QValueListIterator<QCString> it = args.begin();
+ std::vector<QCString> args = split(data," ");
+ auto it = args.begin();
while (it!=args.end())
{
ExprAst *expr = expParser.parse(*it);
@@ -4101,7 +4100,7 @@ class TemplateNodeCycle : public TemplateNodeCreator<TemplateNodeCycle>
TemplateVariant v = m_args.at(m_index)->resolve(c);
if (v.type()==TemplateVariant::Function)
{
- v = v.call(QValueList<TemplateVariant>());
+ v = v.call(std::vector<TemplateVariant>());
}
if (ci->escapeIntf() && !v.raw())
{
diff --git a/src/template.h b/src/template.h
index 40bd43f..c9e9041 100644
--- a/src/template.h
+++ b/src/template.h
@@ -17,7 +17,7 @@
#define TEMPLATE_H
#include <qcstring.h>
-#include <qvaluelist.h>
+#include <vector>
class FTextStream;
@@ -95,12 +95,12 @@ class TemplateVariant
{
public:
/** Callback type to use when creating a delegate from a function. */
- typedef TemplateVariant (*StubType)(const void *obj, const QValueList<TemplateVariant> &args);
+ typedef TemplateVariant (*StubType)(const void *obj, const std::vector<TemplateVariant> &args);
Delegate() : m_objectPtr(0) , m_stubPtr(0) {}
/** Creates a delegate given an object. The method to call is passed as a template parameter */
- template <class T, TemplateVariant (T::*TMethod)(const QValueList<TemplateVariant> &) const>
+ template <class T, TemplateVariant (T::*TMethod)(const std::vector<TemplateVariant> &) const>
static Delegate fromMethod(const T* objectPtr)
{
Delegate d;
@@ -118,7 +118,7 @@ class TemplateVariant
}
/** Invokes the function/method stored in the delegate */
- TemplateVariant operator()(const QValueList<TemplateVariant> &args) const
+ TemplateVariant operator()(const std::vector<TemplateVariant> &args) const
{
return (*m_stubPtr)(m_objectPtr, args);
}
@@ -127,8 +127,8 @@ class TemplateVariant
const void* m_objectPtr;
StubType m_stubPtr;
- template <class T, TemplateVariant (T::*TMethod)(const QValueList<TemplateVariant> &) const>
- static TemplateVariant methodStub(const void* objectPtr, const QValueList<TemplateVariant> &args)
+ template <class T, TemplateVariant (T::*TMethod)(const std::vector<TemplateVariant> &) const>
+ static TemplateVariant methodStub(const void* objectPtr, const std::vector<TemplateVariant> &args)
{
T* p = (T*)(objectPtr);
return (p->*TMethod)(args);
@@ -269,7 +269,7 @@ class TemplateVariant
/** Return the result of apply this function with \a args.
* Returns an empty string if the variant type is not a function.
*/
- TemplateVariant call(const QValueList<TemplateVariant> &args)
+ TemplateVariant call(const std::vector<TemplateVariant> &args)
{
if (m_type==Function) return m_delegate(args);
return TemplateVariant();
diff --git a/src/util.cpp b/src/util.cpp
index 90b4af1..3075d1b 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -1982,8 +1982,10 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
//printf("linkify='%s'\n",text);
static QRegExp regExp("[a-z_A-Z\\x80-\\xFF][~!a-z_A-Z0-9$\\\\.:\\x80-\\xFF]*");
static QRegExp regExpSplit("(?!:),");
+ if (text==0) return;
QCString txtStr=text;
int strLen = txtStr.length();
+ if (strLen==0) return;
//printf("linkifyText scope=%s fileScope=%s strtxt=%s strlen=%d external=%d\n",
// scope?scope->name().data():"<none>",
// fileScope?fileScope->name().data():"<none>",
@@ -1993,7 +1995,6 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
int newIndex;
int skipIndex=0;
int floatingIndex=0;
- if (strLen==0) return;
// read a word from the text string
while ((newIndex=regExp.match(txtStr,index,&matchLen))!=-1)
{
generated by cgit v0.12 at 2024-09-30 00:11:48 (GMT)