Some performance tweaks + remove setting of global locale

17 files changed, 63 insertions, 67 deletions

diff --git a/src/configimpl.l b/src/configimpl.l
index 2938eb8..b99ddf8 100644
--- a/src/configimpl.l
+++ b/src/configimpl.l
@@ -1136,7 +1136,7 @@ static void substEnvVarsInString(QCString &str)
 {
   if (str.isEmpty()) return;
   // match e.g. $(HOME) but also $(PROGRAMFILES(X86))
-  static std::regex re("\\$\\(([[:alpha:]_][[:alnum:].-]*(\\([[:alpha:]_][[:alnum:].-]*\\))?)\\)");
+  static const std::regex re("\\$\\(([[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF.-]*(\\([[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF.-]*\\))?)\\)", std::regex::optimize);
   std::string s = str.str();
   std::sregex_iterator it(s.begin(),s.end(),re);
   std::sregex_iterator end;
@@ -1649,7 +1649,7 @@ void Config::checkAndCorrect()
   for (const auto &alias : aliasList)
   {
     // match aliases of the form 'name=' and 'name{2} ='
-    static std::regex re("[[:alpha:]_][[:alnum:]_]*(\\{[[:digit:]]+\\})?[[:space:]]*=");
+    static const std::regex re("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_]*(\\{[[:digit:]]+\\})?[[:space:]]*=", std::regex::optimize);
     std::sregex_iterator it(alias.begin(),alias.end(),re);
     std::sregex_iterator end;
     if (it==end)
diff --git a/src/definition.cpp b/src/definition.cpp
index 6a5b6e3..1140a7f 100644
--- a/src/definition.cpp
+++ b/src/definition.cpp
@@ -176,7 +176,7 @@ static bool matchExcludedSymbols(const char *name)
       pattern=pattern.left(pattern.length()-1),forceEnd=TRUE;
     if (pattern.find('*')!=-1) // wildcard mode
     {
-      std::regex re(substitute(pattern,"*",".*").str());
+      const std::regex re(substitute(pattern,"*",".*").str());
       std::sregex_iterator it(symName.begin(),symName.end(),re);
       std::sregex_iterator end;
       if (it!=end) // wildcard match
diff --git a/src/docparser.cpp b/src/docparser.cpp
index 9fbfef1..e801133 100644
--- a/src/docparser.cpp
+++ b/src/docparser.cpp
@@ -436,7 +436,7 @@ static void checkArgumentName(const std::string &name)
   //printf("isDocsForDefinition()=%d\n",g_memberDef->isDocsForDefinition());
   if (al.empty()) return; // no argument list
 
-  static std::regex re("(\\$[[:alnum:]_]|[[:alpha:]_])[[:alnum:]_]*\\.*");
+  static const std::regex re("(\\$[[:alnum:]\\x80-\\xFF_]|[[:alpha:]\\x80-\\xFF_])[[:alnum:]\\x80-\\xFF_]*\\.*", std::regex::optimize);
   std::sregex_iterator it(name.begin(),name.end(),re);
   std::sregex_iterator end;
   for (; it!=end ; ++it)
@@ -873,7 +873,7 @@ static int handleStyleArgument(DocNode *parent,DocNodeList &children,
           tok!=TK_ENDLIST
         )
   {
-    static std::regex specialChar("[.,|()\\[\\]:;\\?]");
+    static const std::regex specialChar("[.,|()\\[\\]:;\\?]", std::regex::optimize);
     if (tok==TK_WORD && g_token->name.length()==1 &&
         std::regex_search(g_token->name.str(),specialChar))
     {
diff --git a/src/doctokenizer.l b/src/doctokenizer.l
index ad6ac11..f30dba7 100644
--- a/src/doctokenizer.l
+++ b/src/doctokenizer.l
@@ -515,7 +515,7 @@ RCSID "$"("Author"|"Date"|"Header"|"Id"|"Locker"|"Log"|"Name"|"RCSfile"|"Revisio
                          {
                            lineCount(yytext,yyleng);
                            std::string text=yytext;
-                           static std::regex re("[*+][^*+]*$"); // find last + or *
+                           static const std::regex re("[*+][^*+]*$", std::regex::optimize); // find last + or *
                            std::smatch match;
                            std::regex_search(text,match,re);
                            size_t listPos = match.position();
@@ -533,7 +533,7 @@ RCSID "$"("Author"|"Date"|"Header"|"Id"|"Locker"|"Log"|"Name"|"RCSfile"|"Revisio
                          else
                          {
                            std::string text=yytext;
-                           static std::regex re("[1-9]+");
+                           static const std::regex re("[1-9]+", std::regex::optimize);
                            std::smatch match;
                            std::regex_search(text,match,re);
                            g_token->isEnumList = true;
@@ -560,7 +560,7 @@ RCSID "$"("Author"|"Date"|"Header"|"Id"|"Locker"|"Log"|"Name"|"RCSfile"|"Revisio
                          {
                            lineCount(yytext,yyleng);
                            std::string text=extractPartAfterNewLine(yytext).str();
-                           static std::regex re("[*+][^*+]*$"); // find last + or *
+                           static const std::regex re("[*+][^*+]*$", std::regex::optimize); // find last + or *
                            std::smatch match;
                            std::regex_search(text,match,re);
                            size_t markPos = match.position();
@@ -579,7 +579,7 @@ RCSID "$"("Author"|"Date"|"Header"|"Id"|"Locker"|"Log"|"Name"|"RCSfile"|"Revisio
                          {
                            lineCount(yytext,yyleng);
                            std::string text=extractPartAfterNewLine(yytext).str();
-                           static std::regex re("[1-9]+");
+                           static const std::regex re("[1-9]+", std::regex::optimize);
                            std::smatch match;
                            std::regex_search(text,match,re);
                            g_token->isEnumList = true;
diff --git a/src/doxygen.cpp b/src/doxygen.cpp
index 3fd1069..d4127a7 100644
--- a/src/doxygen.cpp
+++ b/src/doxygen.cpp
@@ -2220,7 +2220,7 @@ static MemberDef *addVariableToFile(
     {
       ttype.stripPrefix("struct ");
       ttype.stripPrefix("union ");
-      static std::regex re("[[:alpha:]_][[:alnum:]_]*");
+      static const std::regex re("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_]*", std::regex::optimize);
       std::smatch match;
       std::string typ = ttype.str();
       if (std::regex_search(typ,match,re))
@@ -2439,7 +2439,7 @@ static int findFunctionPtr(const std::string &type,SrcLangExt lang, int *pLength
     return -1; // Fortran and VHDL do not have function pointers
   }
 
-  static std::regex re("\\([^)]*[*\\^][^)]*\\)");
+  static const std::regex re("\\([^)]*[*\\^][^)]*\\)", std::regex::optimize);
   std::smatch match;
   size_t i=std::string::npos;
   size_t l=0;
@@ -2532,7 +2532,7 @@ static bool isVarWithConstructor(const Entry *root)
     }
     for (const Argument &a : root->argList)
     {
-      static std::regex initChars("[0-9\"'&*!^]+");
+      static const std::regex initChars("[0-9\"'&*!^]+", std::regex::optimize);
       std::smatch match;
       if (!a.name.isEmpty() || !a.defval.isEmpty())
       {
@@ -2574,7 +2574,7 @@ static bool isVarWithConstructor(const Entry *root)
       }
       std::string resType=resolveTypeDef(ctx,a.type).str();
       if (resType.empty()) resType=atype;
-      static std::regex idChars("[[:alpha:]_][[:alnum:]_]*");
+      static const std::regex idChars("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_]*", std::regex::optimize);
       if (std::regex_search(resType,match,idChars) && match.position()==0) // resType starts with identifier
       {
         resType=match.str();
@@ -2625,7 +2625,7 @@ static void addVariable(const Entry *root,int isFuncPtr=-1)
 
       type=name;
       std::string sargs = args.str();
-      static const std::regex reName("[[:alpha:]_][[:alnum:]_]*");
+      static const std::regex reName("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_]*", std::regex::optimize);
       std::smatch match;
       if (std::regex_search(sargs,match,reName))
       {
@@ -3816,7 +3816,7 @@ static TemplateNameMap getTemplateArgumentsInName(const ArgumentList &templateAr
   int count=0;
   for (const Argument &arg : templateArguments)
   {
-    static std::regex re("[[:alpha:]_][[:alnum:]_:]*");
+    static const std::regex re("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_:]*", std::regex::optimize);
     std::sregex_iterator it(name.begin(),name.end(),re);
     std::sregex_iterator end;
     for (; it!=end ; ++it)
@@ -5325,7 +5325,7 @@ static QCString substituteTemplatesInString(
     )
 {
   std::string dst;
-  static const std::regex re("[[:alpha:]_][[:alnum:]_]*");
+  static const std::regex re("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_]*", std::regex::optimize);
   std::sregex_iterator it(src.begin(),src.end(),re);
   std::sregex_iterator end;
   //printf("type=%s\n",sa->type.data());
@@ -10066,7 +10066,6 @@ void initDoxygen()
   std::setlocale(LC_ALL,"");
   std::setlocale(LC_CTYPE,"C"); // to get isspace(0xA0)==0, needed for UTF-8
   std::setlocale(LC_NUMERIC,"C");
-  std::locale::global(std::locale("en_US.UTF-8"));
 
   Portable::correct_path();
 
@@ -10454,7 +10453,7 @@ void readConfiguration(int argc, char **argv)
           cleanUpDoxygen();
           exit(0);
         }
-        else if ((qstrcmp(&argv[optind][2],"Version")==0) || 
+        else if ((qstrcmp(&argv[optind][2],"Version")==0) ||
                  (qstrcmp(&argv[optind][2],"VERSION")==0))
         {
           version(true);
diff --git a/src/groupdef.cpp b/src/groupdef.cpp
index 3fdb9fb..5a89a4a 100644
--- a/src/groupdef.cpp
+++ b/src/groupdef.cpp
@@ -1090,7 +1090,7 @@ void GroupDefImpl::writeDocumentation(OutputList &ol)
   if (Doxygen::searchIndex)
   {
     Doxygen::searchIndex->setCurrentDoc(this,anchor(),FALSE);
-    static std::regex we("[[:alpha:]_][[:alnum:]_\\-]*");
+    static const std::regex we("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_\\-]*", std::regex::optimize);
     std::string title = m_title.str();
     std::sregex_iterator it(title.begin(),title.end(),we);
     std::sregex_iterator end;
diff --git a/src/htmlhelp.cpp b/src/htmlhelp.cpp
index b020bb0..e3a007a 100644
--- a/src/htmlhelp.cpp
+++ b/src/htmlhelp.cpp
@@ -154,7 +154,7 @@ void HtmlHelpIndex::addItem(const char *level1,const char *level2,
                        const char *url,const char *anchor,bool hasLink,
                        bool reversed)
 {
-  static std::regex re("@[[:digit:]]+");
+  static const std::regex re("@[[:digit:]]+", std::regex::optimize);
   std::string key = level1;
   if (level2) key+= std::string("?") + level2;
   if (std::regex_search(key,re)) // skip anonymous stuff
diff --git a/src/markdown.cpp b/src/markdown.cpp
index df632d7..8ac2e5f 100644
--- a/src/markdown.cpp
+++ b/src/markdown.cpp
@@ -1472,7 +1472,7 @@ static QCString extractTitleId(QCString &title, int level)
 {
   TRACE(title.data());
   // match e.g. '{#id-b11} ' and capture 'id-b11'
-  static std::regex r2("\\{#([a-z_A-Z][a-z_A-Z0-9\\-]*)\\}[[:space:]]*$");
+  static const std::regex r2("\\{#([a-z_A-Z][a-z_A-Z0-9\\-]*)\\}[[:space:]]*$", std::regex::optimize);
   std::smatch match;
   std::string ti = title.str();
   if (std::regex_search(ti,match,r2))
diff --git a/src/memberdef.cpp b/src/memberdef.cpp
index b3415ff..5d2a0da 100644
--- a/src/memberdef.cpp
+++ b/src/memberdef.cpp
@@ -1852,7 +1852,7 @@ ClassDef *MemberDefImpl::getClassDefOfAnonymousType() const
 
   // match expression if it contains at least one @1 marker, e.g.
   // 'struct A::@1::@2::B' matches 'A::@1::@2::B' but 'struct A::B' does not match.
-  static const std::regex r("[[:alnum:]_@:]*@[[:digit:]]+[[:alnum:]_@:]*");
+  static const std::regex r("[[:alnum:]\\x80-\\xFF_@:]*@[[:digit:]]+[[:alnum:]\\x80-\\xFF_@:]*", std::regex::optimize);
   std::string stype = ltype.str();
   std::smatch match;
   if (std::regex_search(stype,match,r)) // found anonymous scope in type
@@ -2103,7 +2103,7 @@ void MemberDefImpl::writeDeclaration(OutputList &ol,
   }
   // strip 'friend' keyword from ltype
   ltype.stripPrefix("friend ");
-  static const std::regex r("@[[:digit:]]+");
+  static const std::regex r("@[[:digit:]]+", std::regex::optimize);
   std::smatch match;
   std::string stype = ltype.str();
   bool endAnonScopeNeeded=FALSE;
@@ -2906,7 +2906,7 @@ void MemberDefImpl::_writeTypeConstraints(OutputList &ol) const
 }
 
 // match from the start of the scope until the last marker
-static const std::regex reAnonymous("[[:alnum:]_:]*@[[:digit:]]+([^@]*@[[:digit:]]+)?");
+static const std::regex reAnonymous("[[:alnum:]\\x80-\\xFF_:]*@[[:digit:]]+([^@]*@[[:digit:]]+)?", std::regex::optimize);
 
 void MemberDefImpl::_writeEnumValues(OutputList &ol,const Definition *container,
                                  const QCString &cfname,const QCString &ciname,
@@ -3203,7 +3203,7 @@ void MemberDefImpl::writeDocumentation(const MemberList *ml,
   QStrList sl;
   getLabels(sl,scopedContainer);
 
-  static std::regex r("@[0-9]+");
+  static const std::regex r("@[0-9]+", std::regex::optimize);
   std::smatch match;
   std::string sdef = ldef.str();
   if ((isVariable() || isTypedef()) && std::regex_search(sdef,match,r))
@@ -3612,7 +3612,7 @@ static QCString simplifyTypeForTable(const QCString &s)
 {
   QCString ts=removeAnonymousScopes(s);
   if (ts.right(2)=="::") ts = ts.left(ts.length()-2);
-  static const std::regex re("[[:alpha:]_][[:alnum:]_]*(<[^>]*>)?::([[:alpha:]_][[:alnum:]_]*)");
+  static const std::regex re("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_]*(<[^>]*>)?::([[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_]*)", std::regex::optimize);
   std::smatch match;
   std::string t = ts.str();
   if (std::regex_search(t,match,re))
diff --git a/src/pre.l b/src/pre.l
index f7aca7f..296295f 100644
--- a/src/pre.l
+++ b/src/pre.l
@@ -1962,7 +1962,7 @@ static void processConcatOperators(QCString &expr)
   if (expr.isEmpty()) return;
   //printf("processConcatOperators: in='%s'\n",expr.data());
   std::string e = expr.str();
-  static std::regex r("[[:space:]]*##[[:space:]]*");
+  static const std::regex r("[[:space:]]*##[[:space:]]*", std::regex::optimize);
   std::sregex_iterator end;
 
   size_t i=0;
@@ -3206,7 +3206,7 @@ static void initPredefined(yyscan_t yyscanner,const char *fileName)
         i_obrace<i_cbrace
        ) // predefined function macro definition
     {
-      std::regex reId("[[:alpha:]_][[:alnum:]_]*");
+      static const std::regex reId("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_]*", std::regex::optimize);
       std::sregex_iterator end;
       bool varArgs = false;
       int count = 0;
diff --git a/src/rtfstyle.cpp b/src/rtfstyle.cpp
index 3b0544e..cbe2468 100644
--- a/src/rtfstyle.cpp
+++ b/src/rtfstyle.cpp
@@ -234,7 +234,7 @@ Rtf_Style_Default rtf_Style_Default[] =
   }
 };
 
-static const std::regex s_clause("\\\\s([[:digit:]]+)[[:space:]]*");
+static const std::regex s_clause("\\\\s([[:digit:]]+)[[:space:]]*", std::regex::optimize);
 
 StyleData::StyleData(const std::string &reference, const std::string &definition)
 {
@@ -261,7 +261,7 @@ bool StyleData::setStyle(const std::string &command, const std::string &styleNam
   }
   m_index = static_cast<int>(std::stoul(match[1].str()));
 
-  static std::regex definition_splitter("^(.*)(\\\\sbasedon[[:digit:]]+.*)$");
+  static const std::regex definition_splitter("^(.*)(\\\\sbasedon[[:digit:]]+.*)$", std::regex::optimize);
   if (std::regex_match(command,match,definition_splitter))
   {
     m_reference  = match[1].str();
@@ -287,7 +287,7 @@ void loadStylesheet(const char *name, StyleDataMap& map)
   for (std::string line ; getline(file,line) ; ) // for each line
   {
     if (line.empty() || line[0]=='#') continue; // skip blanks & comments
-    static std::regex assignment_splitter("[[:space:]]*=[[:space:]]*");
+    static const std::regex assignment_splitter("[[:space:]]*=[[:space:]]*", std::regex::optimize);
     std::smatch match;
     if (std::regex_search(line,match,assignment_splitter))
     {
@@ -330,7 +330,7 @@ void loadExtensions(const char *name)
   {
     if (line.empty() || line[0]=='#') continue; // skip blanks & comments
     std::smatch match;
-    static std::regex assignment_splitter("[[:space:]]*=[[:space:]]*");
+    static const std::regex assignment_splitter("[[:space:]]*=[[:space:]]*", std::regex::optimize);
     if (std::regex_search(line,match,assignment_splitter))
     {
       std::string key   = match.prefix();
diff --git a/src/scanner.l b/src/scanner.l
index ebb37c7..4a1e720 100644
--- a/src/scanner.l
+++ b/src/scanner.l
@@ -3739,7 +3739,7 @@ OPERATOR  "operator"{B}*({ARITHOP}|{ASSIGNOP}|{LOGICOP}|{BITOP})
                                                 }
                                                 else
                                                 {
-                                                  static std::regex re("@[0-9]+$");
+                                                  static const std::regex re("@[0-9]+$", std::regex::optimize);
                                                   if (!yyextra->isTypedef && yyextra->memspecEntry &&
                                                       !std::regex_search(yyextra->memspecEntry->name.str(),re)) // not typedef or anonymous type (see bug691071)
                                                   {
@@ -4831,7 +4831,7 @@ OPERATOR  "operator"{B}*({ARITHOP}|{ASSIGNOP}|{LOGICOP}|{BITOP})
                                           yyextra->current->fileName = yyextra->yyFileName;
                                           yyextra->current->startLine = yyextra->yyBegLineNr;
                                           yyextra->current->startColumn = yyextra->yyBegColNr;
-                                          static std::regex re("\\([^)]*[*&][^]*\\)");
+                                          static const std::regex re("\\([^)]*[*&][^]*\\)", std::regex::optimize);
                                           std::smatch match;
                                           std::string type = yyextra->current->type.str();
                                           int ti=-1;
@@ -6895,7 +6895,7 @@ static void splitKnRArg(yyscan_t yyscanner,QCString &oldStyleArgPtr,QCString &ol
   int si = yyextra->current->args.length();
   if (yyextra->oldStyleArgType.isEmpty()) // new argument
   {
-    static std::regex re("(\\([^)]*\\))[[:space:]]*(\\([^)]*\\))?");
+    static const std::regex re("(\\([^)]*\\))[[:space:]]*(\\([^)]*\\))?", std::regex::optimize);
     std::string args = yyextra->current->args.str();
     std::smatch matches;
     std::regex_search(args,matches,re);
diff --git a/src/template.cpp b/src/template.cpp
index 61411be..4c296aa 100644
--- a/src/template.cpp
+++ b/src/template.cpp
@@ -4186,7 +4186,7 @@ class TemplateNodeMarkers : public TemplateNodeCreator<TemplateNodeMarkers>
             c->push();
             std::string str = patternStr.toString().str();
 
-            static std::regex marker("@([[:digit:]]+)");
+            static const std::regex marker("@([[:digit:]]+)", std::regex::optimize);
             std::sregex_iterator re_it(str.begin(),str.end(),marker);
             std::sregex_iterator end;
             size_t index=0;
diff --git a/src/util.cpp b/src/util.cpp
index 05a90cb..9b76714 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -188,7 +188,7 @@ QCString removeAnonymousScopes(const char *str)
     return false;
   };
 
-  static std::regex re("[ :]*@[[:digit:]]+[: ]*");
+  static const std::regex re("[ :]*@[[:digit:]]+[: ]*", std::regex::optimize);
   std::string s = str;
   std::sregex_iterator iter( s.begin(), s.end(), re);
   std::sregex_iterator end;
@@ -221,7 +221,7 @@ QCString removeAnonymousScopes(const char *str)
 QCString replaceAnonymousScopes(const char *s,const char *replacement)
 {
   if (s==0) return QCString();
-  static std::regex marker("@[[:digit:]]+");
+  static const std::regex marker("@[[:digit:]]+", std::regex::optimize);
   std::string result = std::regex_replace(s,marker,replacement?replacement:"__anonymous__");
   //printf("replaceAnonymousScopes('%s')='%s'\n",s.data(),result.data());
   return result;
@@ -895,7 +895,7 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
   size_t strLen = txtStr.length();
   if (strLen==0) return;
 
-  static std::regex regExp("[[:alpha:]_][[:alnum:]_~!\\\\.:$]*");
+  static const std::regex regExp("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_~!\\\\.:$]*", std::regex::optimize);
   std::sregex_iterator it( txtStr.begin(), txtStr.end(), regExp);
   std::sregex_iterator end;
 
@@ -1096,7 +1096,7 @@ void linkifyText(const TextGeneratorIntf &out, const Definition *scope,
 void writeMarkerList(OutputList &ol,const std::string &markerText,size_t numMarkers,
                      std::function<void(size_t)> replaceFunc)
 {
-  static std::regex marker("@([[:digit:]]+)");
+  static const std::regex marker("@([[:digit:]]+)", std::regex::optimize);
   std::sregex_iterator it(markerText.begin(),markerText.end(),marker);
   std::sregex_iterator end;
   size_t index=0;
@@ -1906,7 +1906,7 @@ static QCString extractCanonicalType(const Definition *d,const FileDef *fs,QCStr
                               // (i.e. type is not a template specialization)
                               // then resolve any identifiers inside.
     {
-      static std::regex re("[[:alpha:]_][[:alnum:]_]*");
+      static const std::regex re("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_]*", std::regex::optimize);
       std::string ts = templSpec.str();
       std::sregex_iterator it(ts.begin(),ts.end(),re);
       std::sregex_iterator end;
@@ -4282,7 +4282,7 @@ QCString convertCharEntitiesToUTF8(const char *str)
 {
   if (str==0) return QCString();
 
-  static std::regex re("&[[:alpha:]][[:alnum:]]*;");
+  static const std::regex re("&[[:alpha:]\\x80-\\xFF][[:alnum:]\\x80-\\xFF]*;", std::regex::optimize);
   std::string s = str;
   std::sregex_iterator it(s.begin(),s.end(),re);
   std::sregex_iterator end;
@@ -4447,8 +4447,8 @@ void addMembersToMemberGroup(MemberList *ml,
  */
 int extractClassNameFromType(const char *type,int &pos,QCString &name,QCString &templSpec,SrcLangExt lang)
 {
-  static std::regex re_norm("[[:alpha:]_][[:alnum:]_:]*");
-  static std::regex re_fortran("[[:alpha:]_][[:alnum:]_:()=]*");
+  static std::regex re_norm("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_:]*");
+  static std::regex re_fortran("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_:()=]*");
   static std::regex &re = re_norm;
 
   name.resize(0);
@@ -4530,7 +4530,7 @@ QCString normalizeNonTemplateArgumentsInString(
   p++;
   QCString result = name.left(p);
 
-  static std::regex re("[[:alpha:]_:][[:alnum:]_:]*");
+  static const std::regex re("[[:alpha:]\\x80-\\xFF_:][[:alnum:]\\x80-\\xFF_:]*", std::regex::optimize);
   std::string s = result.mid(p).str();
   std::sregex_iterator it(s.begin(),s.end(),re);
   std::sregex_iterator end;
@@ -4594,7 +4594,7 @@ QCString substituteTemplateArgumentsInString(
   if (formalArgs.empty()) return name;
   std::string result;
 
-  static std::regex re("[[:alpha:]_][[:alnum:]_:]*");
+  static const std::regex re("[[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_:]*", std::regex::optimize);
   std::sregex_iterator it(name.begin(),name.end(),re);
   std::sregex_iterator end;
   size_t p=0;
@@ -5414,7 +5414,7 @@ QCString stripPath(const char *s)
 bool containsWord(const char *str,const char *word)
 {
   if (str==0 || word==0) return false;
-  static std::regex re("[[:alpha:]_]+");
+  static const std::regex re("[[:alpha:]\\x80-\\xFF_]+", std::regex::optimize);
   std::string s = str;
   for (std::sregex_iterator it(s.begin(),s.end(),re) ; it!=std::sregex_iterator() ; ++it)
   {
@@ -5429,7 +5429,7 @@ bool containsWord(const char *str,const char *word)
  */
 bool findAndRemoveWord(QCString &sentence,const char *word)
 {
-  static std::regex re("[^[:alpha:]_]+");
+  static const std::regex re("[^[:alpha:]\\x80-\\xFF_]+", std::regex::optimize);
   std::string s = sentence.str();
   std::sregex_token_iterator it(s.begin(),s.end(),re,{-1,0});
   std::sregex_token_iterator end;
@@ -6031,13 +6031,10 @@ static QCString expandAliasRec(StringUnorderedSet &aliasesProcessed,const std::s
 {
   //QCString result;
   std::string result;
-  std::regex re("[\\\\@]([[:alpha:]_][[:alnum:]_]*)");
+  std::regex re("[\\\\@]([[:alpha:]\\x80-\\xFF_][[:alnum:]\\x80-\\xFF_]*)");
   std::sregex_iterator re_it(s.begin(),s.end(),re);
   std::sregex_iterator end;
   int p = 0;
-  //QCString value=s;
-  //int i,p=0,l;
-  //while ((i=cmdPat.match(value,p,&l))!=-1)
   for ( ; re_it!=end ; ++re_it)
   {
     const auto &match = *re_it;
@@ -6489,7 +6486,7 @@ QCString replaceColorMarkers(const char *str)
   if (str==0) return QCString();
   std::string result;
   std::string s=str;
-  static std::regex re("##([0-9A-Fa-f][0-9A-Fa-f])");
+  static const std::regex re("##([0-9A-Fa-f][0-9A-Fa-f])", std::regex::optimize);
   std::sregex_iterator it(s.begin(),s.end(),re);
   std::sregex_iterator end;
   static int hue   = Config_getInt(HTML_COLORSTYLE_HUE);
diff --git a/src/vhdlcode.l b/src/vhdlcode.l
index 7c4b70b..3e754c7 100644
--- a/src/vhdlcode.l
+++ b/src/vhdlcode.l
@@ -359,7 +359,7 @@ XILINX      "INST"|"NET"|"PIN"|"BLKNM"|"BUFG"|"COLLAPSE"|"CPLD"|"COMPGRP"|"CONFI
                                       tt=tt.lower();
                                       VhdlDocGen::deleteAllChars(tt,';');
                                       tt.stripWhiteSpace();
-                                      static std::regex regg("[[:space:]]+");
+                                      static const std::regex regg("[[:space:]]+", std::regex::optimize);
                                       auto ql = split(tt.str(),regg);
                                       int index=findIndex(ql,"if")+1;
                                       index+=findIndex(ql,"case")+1;
@@ -959,7 +959,7 @@ static bool checkVhdlString(yyscan_t yyscanner,QCString &name)
   if (name.at(0)=='"' && name.at(len-1)=='"' && len > 2)
   {
     std::string inside = name.str().substr(1,len-2);
-    static std::regex regg("[[:space:]]+");
+    static const std::regex regg("[[:space:]]+", std::regex::optimize);
     auto qrl=split(inside,regg);
     if (VhdlDocGen::isNumber(qrl[0]))
     {
diff --git a/src/vhdldocgen.cpp b/src/vhdldocgen.cpp
index cc12006..3bd510f 100644
--- a/src/vhdldocgen.cpp
+++ b/src/vhdldocgen.cpp
@@ -1034,7 +1034,7 @@ void VhdlDocGen::parseFuncProto(const char* text,QCString& name,QCString& ret,bo
 
 QCString VhdlDocGen::getIndexWord(const char* c,int index)
 {
-  static std::regex reg("[[:space:]:|]");
+  static const std::regex reg("[[:space:]:|]",std::regex::optimize);
   auto ql=split(c,reg);
 
   if ((size_t)index < ql.size())
@@ -1122,7 +1122,7 @@ QCString VhdlDocGen::getProcessNumber()
 
 void VhdlDocGen::writeFormatString(const QCString& s,OutputList&ol,const MemberDef* mdef)
 {
-  static std::regex reg("[\\[\\]\\.\\/\\<\\>\\:\\s\\,\\;\\'\\+\\-\\*\\|\\&\\=\\(\\)\"]");
+  static const std::regex reg("[\\[\\]\\.\\/\\<\\>\\:\\s\\,\\;\\'\\+\\-\\*\\|\\&\\=\\(\\)\"]",std::regex::optimize);
   QCString qcs = s;
   qcs+=QCString(" ");// parsing the last sign
   QCString find=qcs;
@@ -1191,7 +1191,7 @@ void VhdlDocGen::writeFormatString(const QCString& s,OutputList&ol,const MemberD
  */
 bool VhdlDocGen::isNumber(const std::string& s)
 {
-  static std::regex regg("[0-9][0-9eEfFbBcCdDaA_.#-+?xXzZ]*");
+  static const std::regex regg("[0-9][0-9eEfFbBcCdDaA_.#-+?xXzZ]*",std::regex::optimize);
   return std::regex_match(s,regg);
 }// isNumber
 
@@ -2298,7 +2298,7 @@ void VhdlDocGen::parseUCF(const char*  input,  Entry* entity,QCString fileName,b
         }
         else
         {
-          static std::regex ee("[[:space:]=]");
+          static const std::regex ee("[[:space:]=]",std::regex::optimize);
           int in=findIndex(temp.str(),ee);
           QCString ff=temp.left(in);
           temp.stripPrefix(ff.data());
@@ -2324,7 +2324,7 @@ static void initUCF(Entry* root,const char*  type,QCString &  qcs,int line,QCStr
   VhdlDocGen::deleteAllChars(qcs,';');
   qcs=qcs.stripWhiteSpace();
 
-  static std::regex reg("[[:space:]=]");
+  static const std::regex reg("[[:space:]=]",std::regex::optimize);
   int i = findIndex(qcs.str(),reg);
   if (i<0) return;
   if (i==0)
@@ -2406,7 +2406,7 @@ QCString VhdlDocGen::parseForConfig(QCString & entity,QCString & arch)
   QCString label;
   if (!entity.contains(":")) return "";
 
-  static std::regex exp("[:()[[:space:]]");
+  static const std::regex exp("[:()[[:space:]]",std::regex::optimize);
   auto ql=split(entity.str(),exp);
   if (ql.size()<2)
   {
@@ -2436,7 +2436,7 @@ QCString VhdlDocGen::parseForConfig(QCString & entity,QCString & arch)
 
 QCString  VhdlDocGen::parseForBinding(QCString & entity,QCString & arch)
 {
-  static std::regex exp("[()[[:space:]]");
+  static const std::regex exp("[()[[:space:]]",std::regex::optimize);
 
   auto ql = split(entity.str(),exp);
 
@@ -2704,7 +2704,7 @@ void VhdlDocGen::addBaseClass(ClassDef* cd,ClassDef *ent)
         bcd.usedName.append("(2)");
         return;
       }
-      static std::regex reg("[[:digit:]]+");
+      static const std::regex reg("[[:digit:]]+",std::regex::optimize);
       QCString s=n.left(i);
       QCString r=n.right(n.length()-i);
       std::string t=r.str();
@@ -2952,7 +2952,7 @@ void FlowChart::printNode(const FlowChart& flo)
     {
       t=flo.text.str();
     }
-    static std::regex ep("[[:space:]]");
+    static const std::regex ep("[[:space:]]",std::regex::optimize);
     t = std::regex_replace(t,ep,std::string(""));
     if (t.empty())
     {
diff --git a/src/vhdljjparser.cpp b/src/vhdljjparser.cpp
index 845602d..3852045 100644
--- a/src/vhdljjparser.cpp
+++ b/src/vhdljjparser.cpp
@@ -272,9 +272,9 @@ void VHDLOutlineParser::handleFlowComment(const char* doc)
 
 int VHDLOutlineParser::checkInlineCode(QCString &doc)
 {
-  static std::regex csRe("[\\\\@]code");
-  static std::regex cendRe("[[:space:]]*[\\\\@]endcode");
-  static std::regex cbriefRe("[\\\\@]brief");
+  static const std::regex csRe("[\\\\@]code", std::regex::optimize);
+  static const std::regex cendRe("[[:space:]]*[\\\\@]endcode", std::regex::optimize);
+  static const std::regex cbriefRe("[\\\\@]brief", std::regex::optimize);
 
   // helper to simulate behavior of QString.find(const QRegExp &re,int pos)
   auto findRe = [](const QCString &str,const std::regex &re,int pos=0) -> int