diff --git a/Doxyfile b/Doxyfile
index 44eb5b524be..100347becb7 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -106,10 +106,12 @@ WARN_LOGFILE           = warnings.log
 # Configuration options related to the input files
 #---------------------------------------------------------------------------
 INPUT                  = src \
-                         vhdlparser
+                         vhdlparser \
+                         xml
 INPUT_ENCODING         = UTF-8
 FILE_PATTERNS          = *.h \
                          *.cpp \
+                         *.l \
                          *.md
 RECURSIVE              = NO
 EXCLUDE                =
diff --git a/doc/features.doc b/doc/features.doc
index e746ac39f17..9c42d5bc4f0 100644
--- a/doc/features.doc
+++ b/doc/features.doc
@@ -28,7 +28,7 @@
     output even from undocumented code.
 <li>Generates structured XML output for parsed sources, which can be 
     used by external tools.
-<li>Supports C/C++, Java, (Corba and Microsoft) Java, Python, VHDL, PHP
+<li>Supports C/C++, Lex, Java, (Corba and Microsoft) Java, Python, VHDL, PHP
     IDL, C#, Fortran, Objective-C 2.0, and to some extent D sources.
 <li>Supports documentation of files, namespaces, packages, classes, 
     structs, unions, templates, variables, functions, typedefs, enums and 
diff --git a/doc/starting.doc b/doc/starting.doc
index ad34af3aa1b..44f2a92a925 100644
--- a/doc/starting.doc
+++ b/doc/starting.doc
@@ -37,7 +37,7 @@ tries to be complete):
 \section step0 Step 0: Check if doxygen supports your programming language
 
 First, assure that your programming language has a reasonable chance of being
-recognized by doxygen. These languages are supported by default: C, C++, C#,
+recognized by doxygen. These languages are supported by default: C, C++, Lex, C#,
 Objective-C, IDL, Java, VHDL, PHP, Python, Fortran and D. It
 is possible to configure certain file type extensions to use certain parsers:
 see the \ref cfg_extension_mapping "Configuration/ExtensionMappings" for details.
@@ -120,7 +120,7 @@ Extension | Language | Extension | Language     | Extension | Language
 .ixx      |C / C++   | .php5     |PHP           | .vhdl     |VHDL
 .ipp      |C / C++   | .inc      |PHP           | .ucf      |VHDL
 .i++      |C / C++   | .phtml    |PHP           | .qsf      |VHDL
-.inl      |C / C++   | .m        |Objective-C   | &nbsp;    |&nbsp;
+.inl      |C / C++   | .m        |Objective-C   | .l        |Lex
 .h        |C / C++   | .M        |Objective-C   | .md       |Markdown
 .H        |C / C++   | .py       |Python        | .markdown |Markdown
 .hh       |C / C++   | .pyw      |Python        | .ice      |Slice
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index c6af8131196..e85d8f2ef6b 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -117,6 +117,8 @@ set(LEX_FILES scanner
     constexp
     xmlcode
     sqlcode
+    lexcode
+    lexscanner
     configimpl)
 
 # unfortunately ${LEX_FILES_H} and ${LEX_FILES_CPP} don't work in older versions of CMake (like 3.6.2) for add_library
@@ -184,6 +186,8 @@ add_library(doxymain STATIC
     ${GENERATED_SRC}/doctokenizer.l.h
     ${GENERATED_SRC}/fortrancode.l.h
     ${GENERATED_SRC}/fortranscanner.l.h
+    ${GENERATED_SRC}/lexcode.l.h
+    ${GENERATED_SRC}/lexscanner.l.h
     ${GENERATED_SRC}/pre.l.h
     ${GENERATED_SRC}/pycode.l.h
     ${GENERATED_SRC}/pyscanner.l.h
@@ -199,6 +203,8 @@ add_library(doxymain STATIC
     ${GENERATED_SRC}/doctokenizer.cpp
     ${GENERATED_SRC}/fortrancode.cpp
     ${GENERATED_SRC}/fortranscanner.cpp
+    ${GENERATED_SRC}/lexcode.cpp
+    ${GENERATED_SRC}/lexscanner.cpp
     ${GENERATED_SRC}/pre.cpp
     ${GENERATED_SRC}/pycode.cpp
     ${GENERATED_SRC}/pyscanner.cpp
diff --git a/src/code.h b/src/code.h
index 42265ad506c..ba242423808 100644
--- a/src/code.h
+++ b/src/code.h
@@ -46,6 +46,7 @@ class CCodeParser : public CodeParserInterface
                    bool collectXRefs=TRUE
                   );
     void resetCodeParserState();
+    void setStartCodeLine(const bool inp);
   private:
     struct Private;
     std::unique_ptr<Private> p;
diff --git a/src/code.l b/src/code.l
index 233a4f0741c..083660b8cc4 100644
--- a/src/code.l
+++ b/src/code.l
@@ -98,6 +98,11 @@ struct codeYY_state
   QCString      parmType;
   QCString      parmName;
 
+  bool          beginCodeLine = true; //!< signals whether or not we should with the first line
+                                      //!< write a start line code or not. Essential
+                                      //!< when this code parser is called from another 
+                                      //!< code parser.
+
   const char *  inputString = 0;     //!< the code fragment as text
   yy_size_t     inputPosition = 0;   //!< read offset during parsing
   int           inputLines = 0;      //!< number of line in the code fragment
@@ -3788,6 +3793,12 @@ void CCodeParser::resetCodeParserState()
   yyextra->anchorCount = 0;
 }
 
+void CCodeParser::setStartCodeLine(const bool inp)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)p->yyscanner;
+  yyextra->beginCodeLine = inp;
+}
+
 void CCodeParser::parseCode(CodeOutputInterface &od,const char *className,const QCString &s,
                 SrcLangExt lang,bool exBlock, const char *exName,FileDef *fd,
                 int startLine,int endLine,bool inlineFragment,
@@ -3862,7 +3873,8 @@ void CCodeParser::parseCode(CodeOutputInterface &od,const char *className,const
   }
   yyextra->includeCodeFragment = inlineFragment;
   //printf("** exBlock=%d exName=%s include=%d\n",exBlock,exName,inlineFragment);
-  startCodeLine(yyscanner);
+
+  if (yyextra->beginCodeLine) startCodeLine(yyscanner);
   yyextra->type.resize(0);
   yyextra->name.resize(0);
   yyextra->args.resize(0);
diff --git a/src/config.xml b/src/config.xml
index d9b29aa23ae..8526a2bb090 100644
--- a/src/config.xml
+++ b/src/config.xml
@@ -647,7 +647,7 @@ Go to the <a href="commands.html">next</a> section or return to the
  With this tag you can assign which parser to use for a given extension.
  Doxygen has a built-in mapping, but you can override or extend it using this tag.
  The format is <code>ext=language</code>, where \c ext is a file extension, and language is one of
- the parsers supported by doxygen: IDL, Java, JavaScript, Csharp (C#), C, C++, D, PHP,
+ the parsers supported by doxygen: IDL, Java, JavaScript, Csharp (C#), C, C++, Lex, D, PHP,
  md (Markdown), Objective-C, Python, Slice, VHDL, Fortran (fixed format Fortran: FortranFixed,
  free formatted Fortran: FortranFree, unknown formatted Fortran: Fortran. In
  the later case the parser tries to guess whether the code is fixed or free
@@ -1434,6 +1434,7 @@ FILE_VERSION_FILTER = "cleartool desc -fmt \%Vn"
       <value name='*.hxx'/>
       <value name='*.hpp'/>
       <value name='*.h++'/>
+      <value name='*.l'/>
       <value name='*.cs'/>
       <value name='*.d'/>
       <value name='*.php'/>
diff --git a/src/context.cpp b/src/context.cpp
index d2cfa9ee7b6..e0017fbab5a 100644
--- a/src/context.cpp
+++ b/src/context.cpp
@@ -1540,6 +1540,7 @@ class DefinitionContext
         case SrcLangExt_SQL:      result="sql";      break;
         case SrcLangExt_Markdown: result="markdown"; break;
         case SrcLangExt_Slice:    result="slice";    break;
+        case SrcLangExt_Lex:      result="lex";      break;
       }
       return result;
     }
diff --git a/src/defargs.l b/src/defargs.l
index e25c1fe081b..76d07ec425f 100644
--- a/src/defargs.l
+++ b/src/defargs.l
@@ -27,12 +27,12 @@
  *  The Argument list as a whole can be pure, constant or volatile.
  *
  *  Examples of input strings are:
- *  \code
+ *  \verbatim
  *    "(int a,int b) const"
  *    "(const char *s="hello world",int=5) = 0"
  *    "<class T,class N>"
  *    "(char c,const char)"
- *  \endcode
+ *  \endverbatim
  *
  *  Note: It is not always possible to distinguish between the name and 
  *        type of an argument. In case of doubt the name is added to the
diff --git a/src/docsets.cpp b/src/docsets.cpp
index 4f04623c54e..9c29818f953 100644
--- a/src/docsets.cpp
+++ b/src/docsets.cpp
@@ -328,6 +328,7 @@ void DocSets::addIndexItem(const Definition *context,const MemberDef *md,
     case SrcLangExt_SQL:     lang="sql"; break;        // Sql
     case SrcLangExt_Markdown:lang="markdown"; break;   // Markdown
     case SrcLangExt_Slice:   lang="slice"; break;      // Slice
+    case SrcLangExt_Lex:     lang="lex"; break;        // Lex
     case SrcLangExt_Unknown: lang="unknown"; break;    // should not happen!
   }
 
diff --git a/src/doxygen.cpp b/src/doxygen.cpp
index f5a280be6e7..c268f2667e1 100644
--- a/src/doxygen.cpp
+++ b/src/doxygen.cpp
@@ -77,6 +77,8 @@
 #include "fortranscanner.h"
 #include "xmlcode.h"
 #include "sqlcode.h"
+#include "lexcode.h"
+#include "lexscanner.h"
 #include "code.h"
 #include "portable.h"
 #include "vhdljjparser.h"
@@ -10058,6 +10060,8 @@ void initDoxygen()
                                                          make_parser_factory<SQLCodeParser>());
   Doxygen::parserManager->registerParser("md",           make_parser_factory<MarkdownOutlineParser>(),
                                                          make_parser_factory<FileCodeParser>());
+  Doxygen::parserManager->registerParser("lex",          make_parser_factory<LexOutlineParser>(),
+                                                         make_parser_factory<LexCodeParser>());
 
   // register any additional parsers here...
 
diff --git a/src/lexcode.h b/src/lexcode.h
new file mode 100644
index 00000000000..38aec508e0c
--- /dev/null
+++ b/src/lexcode.h
@@ -0,0 +1,57 @@
+/******************************************************************************
+ *
+ * Copyright (C) 1997-2021 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby
+ * granted. No representations are made about the suitability of this software
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+
+
+#ifndef LEXCODE_H
+#define LEXCODE_H
+
+#include "parserintf.h"
+
+class CodeOutputInterface;
+class FileDef;
+class MemberDef;
+class QCString;
+class Definition;
+
+/** LEX code scanner.
+ */
+class LexCodeParser : public CodeParserInterface
+{
+  public:
+    LexCodeParser();
+    virtual ~LexCodeParser();
+    void parseCode(CodeOutputInterface &codeOutIntf,
+                   const char *scopeName,
+                   const QCString &input,
+                   SrcLangExt,
+                   bool isExampleBlock,
+                   const char *exampleName=0,
+                   FileDef *fileDef=0,
+                   int startLine=-1,
+                   int endLine=-1,
+                   bool inlineFragment=FALSE,
+                   const MemberDef *memberDef=0,
+                   bool showLineNumbers=TRUE,
+                   const Definition *searchCtx=0,
+                   bool collectXRefs=TRUE
+                  );
+    void resetCodeParserState();
+  private:
+    struct Private;
+    std::unique_ptr<Private> p;
+};
+
+
+#endif
diff --git a/src/lexcode.l b/src/lexcode.l
new file mode 100644
index 00000000000..d6b41b02833
--- /dev/null
+++ b/src/lexcode.l
@@ -0,0 +1,1223 @@
+/******************************************************************************
+ *
+ * Copyright (C) 1997-2021 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby
+ * granted. No representations are made about the suitability of this software
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+
+%option never-interactive
+%option prefix="lexcodeYY"
+%option noyywrap
+%option reentrant
+%option extra-type="struct lexcodeYY_state *"
+%top{
+#include <stdint.h>
+}
+
+%{
+
+#include <stdio.h>
+
+#include "config.h"
+#include "doxygen.h"
+#include "outputgen.h"
+#include "code.h"
+#include "lexcode.h"
+#include "filedef.h"
+#include "message.h"
+
+#define YY_NEVER_INTERACTIVE 1
+#define YY_NO_INPUT 1
+#define YY_NO_UNISTD_H 1
+
+#define USE_STATE2STRING 0
+
+struct lexcodeYY_state
+{
+     CodeOutputInterface * code;
+     CCodeParser ccodeParser;
+     const char   *inputString;     //!< the code fragment as text
+     yy_size_t     inputPosition;   //!< read offset during parsing
+     int           inputLines;      //!< number of line in the code fragment
+     int           yyLineNr;        //!< current line number
+     bool          needsTermination;
+
+     bool          lineNumbers = FALSE;
+     const Definition   *searchCtx;
+     bool          collectXRefs = FALSE;
+
+     int           lastContext = 0;
+     int           lastCContext = 0;
+     int           lastStringContext = 0;
+     int           docBlockContext  = 0;
+     int           lastPreLineCtrlContext = 0;
+     int           lastRawStringContext = 0;
+     int           curlyCount = 0;
+
+     QCString      rulesPatternBuffer;
+     QCString      CCodeBuffer;
+     int           startCCodeLine = -1;
+     int           roundCount = 0;
+     int           squareCount = 0;
+     bool          insideCode = FALSE;
+     QCString      delimiter;
+     QCString      docBlockName;
+     uint          fencedSize = 0;
+     bool          nestedComment = false;
+
+     bool          exampleBlock;
+     QCString      exampleName;
+     QCString      classScope;
+
+     FileDef    *sourceFileDef;
+     const Definition *currentDefinition;
+     const MemberDef  *currentMemberDef;
+     bool          includeCodeFragment;
+     const char   *currentFontClass;
+};
+
+#if USE_STATE2STRING
+static const char *stateToString(int state);
+#endif
+
+static void setCurrentDoc(yyscan_t yyscanner,const QCString &anchor);
+static void startCodeLine(yyscan_t yyscanner);
+static void endFontClass(yyscan_t yyscanner);
+static void endCodeLine(yyscan_t yyscanner);
+static void nextCodeLine(yyscan_t yyscanner);
+static void codifyLines(yyscan_t yyscanner,const char *text);
+static void startFontClass(yyscan_t yyscanner,const char *s);
+static int countLines(yyscan_t yyscanner);
+static yy_size_t yyread(yyscan_t yyscanner,char *buf,yy_size_t max_size);
+static void lineCount(yyscan_t yyscanner);
+static void handleCCode(yyscan_t yyscanner);
+
+#undef YY_INPUT
+#define YY_INPUT(buf,result,max_size) result=yyread(yyscanner,buf,max_size);
+
+%}
+
+nl              (\r\n|\r|\n)
+ws              [ \t]
+nws             [^ \t\n]
+TopStart        "%top{"{nl}
+TopEnd          "}"{nl}
+LiteralStart    "%{"{nl}
+LiteralEnd      "%}"{nl}
+RulesStart      "%%"{nl}
+RulesEnd        "%%"{nl}
+RulesSharp      "<"[^>]*">"
+RulesCurly      "{"[^{}\n]*"}"
+StartSquare     "["
+StartDouble     "\""
+StartRound      "("
+EscapeRulesCharOpen  "\\["|"\\<"|"\\{"|"\\("|"\\\""|"\\{"|"\\ "
+EscapeRulesCharClose "\\]"|"\\>"|"\\}"|"\\)"
+EscapeRulesChar      {EscapeRulesCharOpen}|{EscapeRulesCharClose}
+
+CMD       ("\\"|"@")
+BN        [ \t\n\r]
+BL        [ \t\r]*"\n"
+B         [ \t]
+ID        "$"?[a-z_A-Z\x80-\xFF][a-z_A-Z0-9\x80-\xFF]*
+PRE       [pP][rR][eE]
+CODE      [cC][oO][dD][eE]
+RAWBEGIN  (u|U|L|u8)?R\"[^ \t\(\)\\]{0,16}"("
+RAWEND    ")"[^ \t\(\)\\]{0,16}\"
+CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
+
+%x DefSection
+%x DefSectionLine
+%x RulesSectionInit
+%x RulesPattern
+%x RulesDouble
+%x RulesRoundDouble
+%x RulesSquare
+%x RulesRoundSquare
+%x RulesRound
+%x UserSection
+
+%x TopSection
+%x LiteralSection
+
+%x COMMENT
+
+%x SkipCurly
+%x SkipCurlyEndDoc
+%x PreLineCtrl
+%x DocLine
+%x DocBlock
+%x DocCopyBlock
+%x SkipString
+%x RawString
+%x SkipComment
+%x SkipCxxComment
+%x Comment
+
+%%
+
+<*>\x0d
+<DefSection>^{TopStart}  {
+                           handleCCode(yyscanner);
+                           codifyLines(yyscanner,yytext);
+                           yyextra->lastContext = YY_START;
+                           yyextra->startCCodeLine=yyextra->yyLineNr;
+                           BEGIN (TopSection);
+                         }
+<DefSection>^{LiteralStart}   {
+                           handleCCode(yyscanner);
+                           codifyLines(yyscanner,yytext);
+                           yyextra->lastContext = YY_START;
+                           yyextra->startCCodeLine=yyextra->yyLineNr;
+                           BEGIN (LiteralSection);
+                         }
+<TopSection>^{TopEnd}    {
+                           handleCCode(yyscanner);
+                           codifyLines(yyscanner,yytext);
+                           BEGIN( yyextra->lastContext ) ;
+                         }
+<TopSection>.*{nl}       {
+                           yyextra->CCodeBuffer += yytext;
+                           yyextra->yyLineNr++;
+                         }
+<LiteralSection>^{LiteralEnd}     {
+                           handleCCode(yyscanner);
+                           codifyLines(yyscanner,yytext);
+                           BEGIN( yyextra->lastContext ) ;
+                         }
+<LiteralSection>.*{nl}   {
+                           yyextra->CCodeBuffer += yytext;
+                           yyextra->yyLineNr++;
+                         }
+<DefSection>"//".*{nl}   {
+                           yyextra->CCodeBuffer += yytext;
+                           yyextra->yyLineNr++;
+                         }
+<DefSection>^{ws}*"/*"   {
+                           yyextra->CCodeBuffer += yytext;
+                           yyextra->lastContext = YY_START;
+                           BEGIN(COMMENT);
+                         }
+<COMMENT>"*/"{ws}*{nl}   {
+                           yyextra->CCodeBuffer+=yytext;
+                           yyextra->yyLineNr++;
+                           handleCCode(yyscanner);
+                           BEGIN(yyextra->lastContext);
+                         }
+<COMMENT>"*/"            {
+                           yyextra->CCodeBuffer+=yytext;
+                           handleCCode(yyscanner);
+                           BEGIN(yyextra->lastContext);
+                         }
+<COMMENT>[^*\n]+         {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<COMMENT>"//"|"/*"       {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<COMMENT>{nl}            {
+                           yyextra->CCodeBuffer += yytext;
+                           yyextra->yyLineNr++;
+                         }
+<COMMENT>.               {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<DefSection>^{nl}        {
+                           handleCCode(yyscanner);
+                           codifyLines(yyscanner,yytext);
+                           yyextra->startCCodeLine=yyextra->yyLineNr;
+                         }
+<DefSection>^{ws}.*{nl}  {
+                           yyextra->CCodeBuffer += yytext;
+                           yyextra->yyLineNr++;
+                         }
+<DefSection>^{RulesStart} {
+                           handleCCode(yyscanner);
+                           codifyLines(yyscanner,yytext);
+                           yyextra->startCCodeLine=yyextra->yyLineNr;
+                           BEGIN (RulesSectionInit);
+                         }
+<DefSection>^{nws}       {
+                           handleCCode(yyscanner);
+                           codifyLines(yyscanner,yytext);
+                           BEGIN(DefSectionLine);
+                         }
+<DefSectionLine>.*{nl}   {
+                           codifyLines(yyscanner,yytext);
+                           yyextra->startCCodeLine=yyextra->yyLineNr;
+                           BEGIN(DefSection);
+                         }
+<RulesSectionInit,RulesPattern>^{RulesEnd} {
+                           handleCCode(yyscanner);
+                           codifyLines(yyscanner,yytext);
+                           yyextra->startCCodeLine=yyextra->yyLineNr;
+                           BEGIN (UserSection);
+                         }
+<RulesSectionInit>^{nws} {
+                           handleCCode(yyscanner);
+                           unput(*yytext);
+                           BEGIN(RulesPattern);
+                         }
+<RulesSectionInit>{nl}   {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->yyLineNr++;
+                         }
+<RulesSectionInit>^{ws}.*{nl} {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->yyLineNr++;
+                         }
+<RulesPattern>"<<EOF>>"  {
+                           yyextra->rulesPatternBuffer += yytext;
+                         }
+<RulesPattern>{EscapeRulesChar} {
+                           yyextra->rulesPatternBuffer += yytext;
+                         }
+<RulesPattern>{RulesSharp} {
+                           yyextra->rulesPatternBuffer += yytext;
+                         }
+<RulesPattern>{RulesCurly} {
+                           yyextra->rulesPatternBuffer += yytext;
+                         }
+<RulesPattern>{StartDouble} {
+                           yyextra->rulesPatternBuffer += yytext;
+                           yyextra->lastContext = YY_START;
+                           BEGIN(RulesDouble);
+                        }
+<RulesDouble,RulesRoundDouble>"\\\\"      {
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesDouble,RulesRoundDouble>"\\\""     {
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesDouble>"\""       {
+                           yyextra->rulesPatternBuffer += yytext;
+                           BEGIN( yyextra->lastContext ) ;
+                        }
+<RulesRoundDouble>"\""  {
+                           yyextra->rulesPatternBuffer += yytext;
+                           BEGIN(RulesRound) ;
+                        }
+<RulesDouble,RulesRoundDouble>.          {
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesPattern>{StartSquare} {
+                           yyextra->squareCount++;
+                           yyextra->rulesPatternBuffer += yytext;
+                           yyextra->lastContext = YY_START;
+                           BEGIN(RulesSquare);
+                        }
+<RulesSquare,RulesRoundSquare>"\\["      |
+<RulesSquare,RulesRoundSquare>"\\]"      {
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesSquare,RulesRoundSquare>"["        {
+                           yyextra->squareCount++;
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesSquare>"]"        {
+                           yyextra->squareCount--;
+                           yyextra->rulesPatternBuffer += yytext;
+                           if (!yyextra->squareCount) BEGIN(RulesPattern) ;
+                        }
+<RulesRoundSquare>"]"        {
+                           yyextra->squareCount--;
+                           yyextra->rulesPatternBuffer += yytext;
+                           if (!yyextra->squareCount) BEGIN(RulesRound) ;
+                        }
+<RulesSquare,RulesRoundSquare>"\\\\"          {
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesSquare,RulesRoundSquare>.          {
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesPattern>{StartRound} {
+                           yyextra->roundCount++;
+                           yyextra->rulesPatternBuffer += yytext;
+                           yyextra->lastContext = YY_START;
+                           BEGIN(RulesRound);
+                        }
+<RulesRound>{RulesCurly} {
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesRound>{StartSquare} {
+                           yyextra->squareCount++;
+                           yyextra->rulesPatternBuffer += yytext;
+                           BEGIN(RulesRoundSquare);
+                        }
+<RulesRound>{StartDouble} {
+                           yyextra->rulesPatternBuffer += yytext;
+                           BEGIN(RulesRoundDouble);
+                        }
+<RulesRound>"\\("       |
+<RulesRound>"\\)"       {
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesRound>"("         {
+                           yyextra->roundCount++;
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesRound>")"         {
+                           yyextra->roundCount--;
+                           yyextra->rulesPatternBuffer += yytext;
+                           if (!yyextra->roundCount) BEGIN( yyextra->lastContext ) ;
+                        }
+<RulesRound>.           {
+                           yyextra->rulesPatternBuffer += yytext;
+                        }
+<RulesPattern>{ws}+"|"  {
+                           if (!yyextra->rulesPatternBuffer.isEmpty())
+                           {
+                             startFontClass(yyscanner,"stringliteral");
+                             codifyLines(yyscanner,yyextra->rulesPatternBuffer.data());
+                             yyextra->rulesPatternBuffer.resize(0);
+                             endFontClass(yyscanner);
+                           }
+                           codifyLines(yyscanner,yytext);
+                           yyextra->startCCodeLine=yyextra->yyLineNr;
+                           yyextra->curlyCount = 0;
+                           BEGIN(SkipCurly);
+                         }
+<RulesPattern>^{ws}*{nl} {
+                           codifyLines(yyscanner,"\n");
+                         }
+<RulesPattern>^{ws}+     {
+                           codifyLines(yyscanner,yytext);
+                         }
+<RulesPattern>({ws}|{nl}) {
+                           unput(*yytext);
+                           if (!yyextra->rulesPatternBuffer.isEmpty())
+                           {
+                             startFontClass(yyscanner,"stringliteral");
+                             codifyLines(yyscanner,yyextra->rulesPatternBuffer.data());
+                             yyextra->rulesPatternBuffer.resize(0);
+                             endFontClass(yyscanner);
+                           }
+                           yyextra->startCCodeLine=yyextra->yyLineNr;
+                           yyextra->curlyCount = 0;
+                           BEGIN(SkipCurly);
+                         }
+<RulesPattern>"\\\\"     {
+                           yyextra->rulesPatternBuffer += yytext;
+                         }
+<RulesPattern>"/*"       {
+                           if (!yyextra->rulesPatternBuffer.isEmpty())
+                           {
+                             startFontClass(yyscanner,"stringliteral");
+                             codifyLines(yyscanner,yyextra->rulesPatternBuffer.data());
+                             yyextra->rulesPatternBuffer.resize(0);
+                             endFontClass(yyscanner);
+                           }
+                           yyextra->CCodeBuffer += yytext;
+                           yyextra->lastContext = YY_START;
+                           BEGIN(COMMENT);
+                         }
+<RulesPattern>.          {
+                           yyextra->rulesPatternBuffer += yytext;
+                         }
+<SkipCurly>{B}*"#"{B}+[0-9]+{B}+/"\"" { /* line control directive */
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->lastPreLineCtrlContext = YY_START;
+                            BEGIN( PreLineCtrl );
+                          }
+<PreLineCtrl>"\""[^\n\"]*"\"" {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<PreLineCtrl>.            {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<PreLineCtrl>\n           {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->yyLineNr++;
+                            BEGIN( yyextra->lastPreLineCtrlContext );
+                          }
+<SkipCurly>"{"            {
+                            yyextra->CCodeBuffer += yytext;
+                                          ++yyextra->curlyCount ;
+                          }
+<SkipCurly>"}"/{BN}*("/*!"|"/**"|"//!"|"///")"<!--" | /* see bug710917 */
+<SkipCurly>"}"            {
+                            yyextra->CCodeBuffer += yytext;
+                            lineCount(yyscanner);
+                            if( yyextra->curlyCount )
+                            {
+                              --yyextra->curlyCount ;
+                            }
+                          }
+<SkipCurly>"}"{BN}*("/*!"|"/**"|"//!"|"///")"<" {
+                            yyextra->CCodeBuffer += yytext;
+                            lineCount(yyscanner);
+                            if ( yyextra->curlyCount )
+                            {
+                              --yyextra->curlyCount ;
+                            }
+                            else
+                            {
+                              yyextra->docBlockContext   = SkipCurlyEndDoc;
+                              if (yytext[yyleng-3]=='/')
+                              {
+                                BEGIN( DocLine );
+                              }
+                              else
+                              {
+                                BEGIN( DocBlock );
+                              }
+                            }
+                          }
+<SkipCurly>\"             {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->lastStringContext=SkipCurly;
+                            BEGIN( SkipString );
+                          }
+<SkipCurly>^{B}*"#"       {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->lastPreLineCtrlContext = YY_START;
+                            BEGIN( PreLineCtrl );
+                          }
+<SkipCurly>{B}*{RAWBEGIN} {
+                            QCString raw=QCString(yytext).stripWhiteSpace();
+                            yyextra->delimiter = raw.data()+2;
+                            yyextra->delimiter=yyextra->delimiter.left(yyextra->delimiter.length()-1);
+                            yyextra->lastRawStringContext = YY_START;
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN(RawString);
+                          }
+<SkipCurly>[^\n#"'@\\/{}<]+ {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCurly>"/*"           {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->lastCContext = YY_START;
+                            BEGIN(SkipComment);
+                          }
+<SkipCurly>"//"           {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->lastCContext = YY_START;
+                            BEGIN(SkipCxxComment);
+                          }
+<SkipCurly>{CHARLIT}      {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCurly>\'             {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCurly>.              {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCurly>("//"{B}*)?"/*!" {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockContext   = YY_START;
+                            BEGIN( DocBlock );
+                          }
+<SkipCurly>"/**"[*]+{BL}  {
+                            bool javadocBanner = Config_getBool(JAVADOC_BANNER);
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->yyLineNr++;
+                            if( javadocBanner )
+                            {
+                              yyextra->docBlockContext   = YY_START;
+                              BEGIN( DocBlock );
+                            }
+                            else
+                            {
+                              BEGIN( Comment ) ;
+                            }
+                          }
+<SkipCurly>("//"{B}*)?"/**"/[^/*] {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockContext   = YY_START;
+                            BEGIN( DocBlock );
+                          }
+<SkipCurly>"//!"          {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockContext   = YY_START;
+                            BEGIN( DocLine );
+                          }
+<SkipCurly>"///"/[^/]     {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockContext   = YY_START;
+                            BEGIN( DocLine );
+                          }
+
+<SkipCurly>\n             {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->yyLineNr++;
+                            if (yyextra->curlyCount<=0)
+                            {
+                              handleCCode(yyscanner);
+                              BEGIN(RulesPattern);
+                            }
+                          }
+<SkipString>\\.           {
+                             yyextra->CCodeBuffer += yytext;
+                          }
+<SkipString>\"            {
+                             yyextra->CCodeBuffer += yytext;
+                             BEGIN( yyextra->lastStringContext );
+                          }
+<SkipString>"/*"|"*/"|"//" {
+                             yyextra->CCodeBuffer += yytext;
+                           }
+<SkipString>\n            {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->yyLineNr++;
+                          }
+<SkipString>.             {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCxxComment>.*"\\\n"  {  // line continuation
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->yyLineNr++;
+                          }
+<SkipCxxComment>.*/\n     {
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->lastCContext ) ;
+                          }
+<Comment>{BN}+            {
+                            yyextra->CCodeBuffer += yytext ;
+                            lineCount(yyscanner);
+                          }
+<Comment>"/*"             { yyextra->CCodeBuffer += yytext ; }
+<Comment>"//"             { yyextra->CCodeBuffer += yytext ; }
+<Comment>{CMD}("code"|"verbatim")       {
+                            yyextra->insideCode=TRUE;
+                            yyextra->CCodeBuffer += yytext ;
+                          }
+<Comment>{CMD}("endcode"|"endverbatim") {
+                            yyextra->insideCode=FALSE;
+                            yyextra->CCodeBuffer += yytext ;
+                          }
+<Comment>[^ \.\t\r\n\/\*]+ { yyextra->CCodeBuffer += yytext ; }
+<Comment>"*/"             {
+                            yyextra->CCodeBuffer += yytext ;
+                            if (!yyextra->insideCode) BEGIN( yyextra->lastContext ) ;
+                          }
+<Comment>.                { yyextra->CCodeBuffer += *yytext ; }
+
+<SkipComment>"//"|"/*"    {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipComment>[^\*\n]+     {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipComment>\n           {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->yyLineNr++;
+                          }
+<SkipComment>{B}*"*/"     {
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->lastCContext );
+                          }
+<SkipComment>"*"          {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<RawString>{RAWEND}       {
+                            yyextra->CCodeBuffer += yytext;
+                            QCString delimiter = yytext+1;
+                            delimiter=delimiter.left(delimiter.length()-1);
+                            if (delimiter==yyextra->delimiter)
+                            {
+                              BEGIN(yyextra->lastRawStringContext);
+                            }
+                          }
+<RawString>[^)\n]+        {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<RawString>.              {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<RawString>\n             {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->yyLineNr++;
+                          }
+
+
+  /* ---- Single line comments ------ */
+<DocLine>[^\n]*"\n"[ \t]*"//"[/!][<]? { // continuation of multiline C++-style comment
+                            yyextra->CCodeBuffer += yytext;
+                            lineCount(yyscanner);
+                          }
+<DocLine>{B}*"///"[/]+{B}*/"\n" { // ignore marker line (see bug700345)
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->docBlockContext );
+                          }
+<DocLine>[^\n]*/"\n"{B}*"//"[!/]{B}*{CMD}"}" { // next line is an end group marker, see bug 752712
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->docBlockContext );
+                          }
+<DocLine>[^\n]*/"\n"      { // whole line
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->docBlockContext );
+                          }
+
+ /* ---- Comments blocks ------ */
+
+<DocBlock>"*"*"*/"        { // end of comment block
+                            yyextra->CCodeBuffer += yytext;
+                          BEGIN(yyextra->docBlockContext);
+                                        }
+<DocBlock>^{B}*"*"+/[^/]  {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>^{B}*("//")?{B}*"*"+/[^//a-z_A-Z0-9*] { // start of a comment line
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>^{B}*("//"){B}* { // strip embedded C++ comments if at the start of a line
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>"//"            { // slashes in the middle of a comment block
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>"/*"            { // start of a new comment in the
+                            // middle of a comment block
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>({CMD}{CMD}){ID}/[^a-z_A-Z0-9] { // escaped command
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>{CMD}("f$"|"f["|"f{") {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockName=&yytext[1];
+                            if (yyextra->docBlockName.at(1)=='{')
+                            {
+                              yyextra->docBlockName.at(1)='}';
+                            }
+                            yyextra->fencedSize=0;
+                            yyextra->nestedComment=FALSE;
+                            BEGIN(DocCopyBlock);
+                          }
+<DocBlock>{B}*"<"{PRE}">" {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockName="<pre>";
+                            yyextra->fencedSize=0;
+                            yyextra->nestedComment=FALSE;
+                            BEGIN(DocCopyBlock);
+                          }
+<DocBlock>{CMD}("verbatim"|"latexonly"|"htmlonly"|"xmlonly"|"manonly"|"rtfonly"|"docbookonly"|"dot"|"code")/[^a-z_A-Z0-9\-] { // verbatim command (which could contain nested comments!)
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockName=&yytext[1];
+                            yyextra->fencedSize=0;
+                            yyextra->nestedComment=FALSE;
+                            BEGIN(DocCopyBlock);
+                          }
+<DocBlock>^({B}*"*"+)?{B}{0,3}"~~~"[~]* {
+                            yyextra->CCodeBuffer += yytext;
+                            QCString pat = substitute(yytext,"*"," ");
+                            yyextra->docBlockName="~~~";
+                            yyextra->fencedSize=pat.stripWhiteSpace().length();
+                            yyextra->nestedComment=FALSE;
+                            BEGIN(DocCopyBlock);
+                          }
+<DocBlock>^({B}*"*"+)?{B}{0,3}"```"[`]* {
+                            yyextra->CCodeBuffer += yytext;
+                            QCString pat = substitute(yytext,"*"," ");
+                            yyextra->docBlockName="```";
+                            yyextra->fencedSize=pat.stripWhiteSpace().length();
+                            yyextra->nestedComment=FALSE;
+                            BEGIN(DocCopyBlock);
+                          }
+<DocBlock>{B}*"<code>"    {
+                            REJECT;
+                          }
+<DocBlock>[^@*~\/\\\n]+   { // any character that isn't special
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>\n              { // newline
+                            yyextra->CCodeBuffer += yytext;
+                            lineCount(yyscanner);
+                          }
+<DocBlock>.               { // command block
+                            yyextra->CCodeBuffer += yytext;
+                          }
+ /* ---- Copy verbatim sections ------ */
+
+<DocCopyBlock>"</"{PRE}">" { // end of a <pre> block
+                            yyextra->CCodeBuffer += yytext;
+                            if (yyextra->docBlockName=="<pre>")
+                            {
+                              BEGIN(DocBlock);
+                            }
+                          }
+<DocCopyBlock>"</"{CODE}">" { // end of a <code> block
+                            yyextra->CCodeBuffer += yytext;
+                            if (yyextra->docBlockName=="<code>")
+                            {
+                                            BEGIN(DocBlock);
+                            }
+                          }
+<DocCopyBlock>[\\@]("f$"|"f]"|"f}") {
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN(DocBlock);
+                          }
+<DocCopyBlock>[\\@]("endverbatim"|"endlatexonly"|"endhtmlonly"|"endxmlonly"|"enddocbookonly"|"endmanonly"|"endrtfonly"|"enddot"|"endcode")/[^a-z_A-Z0-9] { // end of verbatim block
+                            yyextra->CCodeBuffer += yytext;
+                            if (&yytext[4]==yyextra->docBlockName)
+                            {
+                              BEGIN(DocBlock);
+                            }
+                          }
+<DocCopyBlock>^{B}*"*"+/{BN}+ { // start of a comment line
+                            yyextra->CCodeBuffer += yytext;
+                            if (yyextra->docBlockName=="verbatim")
+                            {
+                              REJECT;
+                            }
+                            else if (yyextra->docBlockName=="code")
+                            {
+                              REJECT;
+                            }
+                            else
+                            {
+                              yyextra->CCodeBuffer += yytext;
+                            }
+                          }
+<DocCopyBlock>^{B}*"*"+/{B}+"*"{BN}* { // start of a comment line with two *'s
+                            if (yyextra->docBlockName=="code")
+                            {
+                              yyextra->CCodeBuffer += yytext;
+                            }
+                            else
+                            {
+                              REJECT;
+                            }
+                          }
+<DocCopyBlock>^{B}*"*"+/({ID}|"(") { // Assume *var or *(... is part of source code (see bug723516)
+                            if (yyextra->docBlockName=="code")
+                            {
+                              yyextra->CCodeBuffer += yytext;
+                            }
+                            else
+                            {
+                              REJECT;
+                            }
+                          }
+<DocCopyBlock>^{B}*"*"+/{BN}* { // start of a comment line with one *
+                            if (yyextra->docBlockName=="code")
+                            {
+                              if (yyextra->nestedComment) // keep * it is part of the code
+                              {
+                                yyextra->CCodeBuffer += yytext;
+                              }
+                              else // remove * it is part of the comment block
+                              {
+                            yyextra->CCodeBuffer += yytext;
+                              }
+                            }
+                            else
+                            {
+                              REJECT;
+                            }
+                          }
+<DocCopyBlock>^({B}*"*"+)?{B}{0,3}"~~~"[~]* {
+                            yyextra->CCodeBuffer += yytext;
+                            QCString pat = substitute(yytext,"*"," ");
+                            if (yyextra->fencedSize==pat.stripWhiteSpace().length())
+                            {
+                              BEGIN(DocBlock);
+                            }
+                          }
+<DocCopyBlock>^({B}*"*"+)?{B}{0,3}"```"[`]* {
+                            yyextra->CCodeBuffer += yytext;
+                            QCString pat = substitute(yytext,"*"," ");
+                            if (yyextra->fencedSize==pat.stripWhiteSpace().length())
+                            {
+                              BEGIN(DocBlock);
+                            }
+                          }
+<DocCopyBlock>[^\<@/*\]~\$\\\n]+ { // any character that is not special
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocCopyBlock>"/*"|"*/"|"//" {
+                            if (yytext[1]=='*')
+                            {
+                              yyextra->nestedComment=TRUE;
+                            }
+                            else if (yytext[0]=='*')
+                            {
+                              yyextra->nestedComment=FALSE;
+                            }
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocCopyBlock>\n          { // newline
+                            yyextra->CCodeBuffer += yytext;
+                            lineCount(yyscanner);
+                          }
+<DocCopyBlock>.           { // any other character
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCurlyEndDoc>"}"{BN}*("/*!"|"/**"|"//!"|"///")"<" { // desc is followed by another one
+                            yyextra->docBlockContext   = SkipCurlyEndDoc;
+                            yyextra->CCodeBuffer += yytext;
+                            if (yytext[yyleng-3]=='/')
+                            {
+                              BEGIN( DocLine );
+                            }
+                            else
+                            {
+                              BEGIN( DocBlock );
+                            }
+                          }
+<SkipCurlyEndDoc>"}"      {
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN(SkipCurly);
+                          }
+
+<UserSection>.*{nl}       {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->yyLineNr++;
+                          }
+  /*
+<*>.  { fprintf(stderr,"Lex code scanner Def rule for %s: #%s#\n",stateToString(YY_START),yytext);}
+  */
+<*><<EOF>>                {
+                            handleCCode(yyscanner);
+                            yyterminate();
+                          }
+%%
+
+static void setCurrentDoc(yyscan_t yyscanner,const QCString &anchor)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  if (Doxygen::searchIndex)
+  {
+    if (yyextra->searchCtx)
+    {
+      yyextra->code->setCurrentDoc(yyextra->searchCtx,yyextra->searchCtx->anchor(),false);
+    }
+    else
+    {
+      yyextra->code->setCurrentDoc(yyextra->sourceFileDef,anchor,true);
+    }
+  }
+}
+
+/*! start a new line of code, inserting a line number if yyextra->sourceFileDef
+ * is true. If a definition starts at the current line, then the line
+ * number is linked to the documentation of that definition.
+ */
+static void startCodeLine(yyscan_t yyscanner)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  if (yyextra->sourceFileDef && yyextra->lineNumbers)
+  {
+    const Definition *d = yyextra->sourceFileDef->getSourceDefinition(yyextra->yyLineNr);
+
+    if (!yyextra->includeCodeFragment && d)
+    {
+      yyextra->currentDefinition = d;
+      yyextra->currentMemberDef = yyextra->sourceFileDef->getSourceMember(yyextra->yyLineNr);
+      yyextra->classScope = d->name().copy();
+      QCString lineAnchor;
+      lineAnchor.sprintf("l%05d",yyextra->yyLineNr);
+      if (yyextra->currentMemberDef)
+      {
+        yyextra->code->writeLineNumber(yyextra->currentMemberDef->getReference(),
+                            yyextra->currentMemberDef->getOutputFileBase(),
+                            yyextra->currentMemberDef->anchor(),yyextra->yyLineNr);
+        setCurrentDoc(yyscanner,lineAnchor);
+      }
+      else
+      {
+        yyextra->code->writeLineNumber(d->getReference(),
+                            d->getOutputFileBase(),
+                            0,yyextra->yyLineNr);
+        setCurrentDoc(yyscanner,lineAnchor);
+      }
+    }
+    else
+    {
+      yyextra->code->writeLineNumber(0,0,0,yyextra->yyLineNr);
+    }
+  }
+
+  yyextra->code->startCodeLine(yyextra->sourceFileDef && yyextra->lineNumbers);
+
+  if (yyextra->currentFontClass)
+  {
+    yyextra->code->startFontClass(yyextra->currentFontClass);
+  }
+}
+
+static void endFontClass(yyscan_t yyscanner)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  if (yyextra->currentFontClass)
+  {
+    yyextra->code->endFontClass();
+    yyextra->currentFontClass=0;
+  }
+}
+
+static void endCodeLine(yyscan_t yyscanner)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  endFontClass(yyscanner);
+  yyextra->code->endCodeLine();
+}
+
+static void nextCodeLine(yyscan_t yyscanner)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  const char *fc = yyextra->currentFontClass;
+  endCodeLine(yyscanner);
+  if (yyextra->yyLineNr<yyextra->inputLines)
+  {
+    yyextra->currentFontClass = fc;
+    startCodeLine(yyscanner);
+  }
+}
+
+static void codifyLines(yyscan_t yyscanner,const char *text)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  const char *p=text,*sp=p;
+  char c;
+  bool done=false;
+  while (!done)
+  {
+    sp=p;
+    while ((c=*p++) && c!='\n') { }
+    if (c=='\n')
+    {
+      yyextra->yyLineNr++;
+      int l = (int)(p-sp-1);
+      char *tmp = (char*)malloc(l+1);
+      memcpy(tmp,sp,l);
+      tmp[l]='\0';
+      yyextra->code->codify(tmp);
+      if (p)
+      {
+        nextCodeLine(yyscanner);
+      }
+      else
+      {
+        endCodeLine(yyscanner);
+        done=true;
+      }
+      free(tmp);
+    }
+    else
+    {
+      yyextra->code->codify(sp);
+      done=true;
+    }
+  }
+  yyextra->startCCodeLine = yyextra->yyLineNr;
+}
+
+static void startFontClass(yyscan_t yyscanner,const char *s)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  endFontClass(yyscanner);
+  if (!yyextra->currentFontClass || !s || strcmp(yyextra->currentFontClass,s))
+  {
+    endFontClass(yyscanner);
+    yyextra->code->startFontClass(s);
+    yyextra->currentFontClass=s;
+  }
+}
+
+/*! counts the number of lines in the input */
+static int countLines(yyscan_t yyscanner)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  const char *p=yyextra->inputString;
+  char c;
+  int count=1;
+  while ((c=*p))
+  {
+    p++ ;
+    if (c=='\n') count++;
+  }
+  if (p>yyextra->inputString && *(p-1)!='\n')
+  { // last line does not end with a \n, so we add an extra
+    // line and explicitly terminate the line after parsing.
+    count++,
+    yyextra->needsTermination=true;
+  }
+  return count;
+}
+
+static yy_size_t yyread(yyscan_t yyscanner,char *buf,yy_size_t max_size)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  yy_size_t inputPosition = yyextra->inputPosition;
+  const char *s = yyextra->inputString + inputPosition;
+  yy_size_t c=0;
+  while( c < max_size && *s )
+  {
+    *buf++ = *s++;
+    c++;
+  }
+  yyextra->inputPosition += c;
+  return c;
+}
+
+static void lineCount(yyscan_t yyscanner)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  const char *p;
+  for (p = yytext ; *p ; ++p )
+  {
+    if (*p=='\n')
+    {
+      yyextra->yyLineNr++;
+    }
+  }
+}
+
+static void handleCCode(yyscan_t yyscanner)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  if (yyextra->CCodeBuffer.isEmpty()) return;
+
+  yyextra->ccodeParser.setStartCodeLine(false);
+  yyextra->ccodeParser.parseCode(*yyextra->code,
+               yyextra->classScope,
+               yyextra->CCodeBuffer,
+               SrcLangExt_Cpp,
+               yyextra->exampleBlock,
+               yyextra->exampleName,
+               yyextra->sourceFileDef,
+               yyextra->startCCodeLine,
+               -1, /* endLine will be calculated in called routine */
+               yyextra->includeCodeFragment,
+               yyextra->currentMemberDef,
+               yyextra->lineNumbers,
+               yyextra->searchCtx,
+               yyextra->collectXRefs
+              );
+  yyextra->CCodeBuffer.resize(0);
+  yyextra->ccodeParser.setStartCodeLine(true);
+  yyextra->yyLineNr--;
+  codifyLines(yyscanner,"\n");
+  return;
+}
+
+// public interface -----------------------------------------------------------
+
+struct LexCodeParser::Private
+{
+  yyscan_t yyscanner;
+  lexcodeYY_state state;
+};
+
+LexCodeParser::LexCodeParser() : p(std::make_unique<Private>())
+{
+  lexcodeYYlex_init_extra(&p->state, &p->yyscanner);
+#ifdef FLEX_DEBUG
+  lexcodeYYset_debug(1,p->yyscanner);
+#endif
+  resetCodeParserState();
+}
+
+LexCodeParser::~LexCodeParser()
+{
+  lexcodeYYlex_destroy(p->yyscanner);
+}
+
+void LexCodeParser::resetCodeParserState()
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)p->yyscanner;
+  yyextra->currentDefinition = 0;
+  yyextra->currentMemberDef = 0;
+}
+
+void LexCodeParser::parseCode(CodeOutputInterface &codeOutIntf,
+               const char *scopeName,
+               const QCString &input,
+               SrcLangExt,
+               bool isExampleBlock,
+               const char *exampleName,
+               FileDef *fileDef,
+               int startLine,
+               int endLine,
+               bool inlineFragment,
+               const MemberDef *memberDef,
+               bool showLineNumbers,
+               const Definition *searchCtx,
+               bool collectXRefs
+              )
+{
+  yyscan_t yyscanner = p->yyscanner;
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+
+  if (input.isEmpty()) return;
+
+  printlex(yy_flex_debug, true, __FILE__, fileDef ? fileDef->fileName().data(): NULL);
+
+  yyextra->code = &codeOutIntf;
+  yyextra->inputString   = input;
+  yyextra->inputPosition = 0;
+  yyextra->currentFontClass = 0;
+  yyextra->needsTermination = false;
+
+  yyextra->classScope=scopeName;
+  yyextra->currentMemberDef=memberDef;
+  yyextra->searchCtx=searchCtx;
+  yyextra->collectXRefs=collectXRefs;
+
+  if (startLine!=-1)
+    yyextra->yyLineNr    = startLine;
+  else
+    yyextra->yyLineNr    = 1;
+
+  if (endLine!=-1)
+    yyextra->inputLines  = endLine+1;
+  else
+    yyextra->inputLines  = yyextra->yyLineNr + countLines(yyscanner) - 1;
+
+  yyextra->startCCodeLine = yyextra->yyLineNr;
+  yyextra->exampleBlock  = isExampleBlock;
+  yyextra->exampleName   = exampleName;
+  yyextra->sourceFileDef = fileDef;
+  yyextra->lineNumbers   = fileDef!=0 && showLineNumbers;
+
+  bool cleanupSourceDef = false;
+
+  if (isExampleBlock && fileDef==0)
+  {
+    // create a dummy filedef for the example
+    yyextra->sourceFileDef = createFileDef("",(exampleName?exampleName:"generated"));
+    cleanupSourceDef = true;
+  }
+
+  if (yyextra->sourceFileDef)
+  {
+    setCurrentDoc(yyscanner,"l00001");
+  }
+
+  yyextra->includeCodeFragment = inlineFragment;
+  // Starts line 1 on the output
+  startCodeLine(yyscanner);
+
+  lexcodeYYrestart( 0, yyscanner );
+  BEGIN( DefSection );
+  lexcodeYYlex(yyscanner);
+
+  if (yyextra->needsTermination)
+  {
+    endCodeLine(yyscanner);
+  }
+  if (cleanupSourceDef)
+  {
+    // delete the temporary file definition used for this example
+    delete yyextra->sourceFileDef;
+    yyextra->sourceFileDef=0;
+  }
+
+  printlex(yy_flex_debug, false, __FILE__, fileDef ? fileDef->fileName().data(): NULL);
+}
+
+//---------------------------------------------------------------------------------
+
+#if USE_STATE2STRING
+#include "lexcode.l.h"
+#endif
diff --git a/src/lexscanner.h b/src/lexscanner.h
new file mode 100644
index 00000000000..11bf25e3822
--- /dev/null
+++ b/src/lexscanner.h
@@ -0,0 +1,43 @@
+/******************************************************************************
+ *
+ *
+ *
+ * Copyright (C) 1997-2021 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby
+ * granted. No representations are made about the suitability of this software
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+
+#ifndef SCANNER_LEL_H
+#define SCANNER_LEX_H
+
+#include "parserintf.h"
+
+/** \brief Lex language parser using state-based lexical scanning.
+ *
+ *  This is the Lex language parser for doxygen.
+ */
+class LexOutlineParser : public OutlineParserInterface
+{
+  public:
+    LexOutlineParser();
+   ~LexOutlineParser();
+    void parseInput(const char *fileName,
+                    const char *fileBuf,
+                    const std::shared_ptr<Entry> &root,
+                    ClangTUParser *clangParser);
+    bool needsPreprocessing(const QCString &extension) const { return TRUE; };
+    void parsePrototype(const char *text){}
+
+  private:
+    struct Private;
+    std::unique_ptr<Private> p;
+};
+#endif
diff --git a/src/lexscanner.l b/src/lexscanner.l
new file mode 100644
index 00000000000..e0f3a928bec
--- /dev/null
+++ b/src/lexscanner.l
@@ -0,0 +1,938 @@
+/*****************************************************************************
+ *
+ *
+ *
+ * Copyright (C) 1997-2021 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby
+ * granted. No representations are made about the suitability of this software
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+%option never-interactive
+%option prefix="lexscannerYY"
+%option reentrant
+%option extra-type="struct lexscannerYY_state *"
+%option noyywrap
+
+%top{
+#include <stdint.h>
+}
+
+%{
+
+/*
+ *      includes
+ */
+
+#include <algorithm>
+#include <vector>
+#include <utility>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "config.h"
+#include "lexscanner.h"
+#include "entry.h"
+#include "message.h"
+#include "util.h"
+#include "scanner.h"
+
+#define YY_NO_INPUT 1
+#define YY_NO_UNISTD_H 1
+
+#define USE_STATE2STRING 0
+
+#define repeatChar(chr, cnt) std::string(cnt, chr).c_str()
+
+struct lexscannerYY_state
+{
+  COutlineParser   cOutlineParser;
+  const char *     inputString = 0;
+  int              inputPosition = 0;
+
+  int              lastContext = 0;
+  int              lastCContext = 0;
+  int              lastStringContext = 0;
+  int              docBlockContext  = 0;
+  int              lastPreLineCtrlContext = 0;
+  int              lastRawStringContext = 0;
+  int              curlyCount = 0;
+
+  bool             insideCode = FALSE;
+  QCString         delimiter;
+  QCString         docBlockName;
+  uint             fencedSize = 0;
+  bool             nestedComment = false;
+
+  QCString         prefix = "yy";
+  QCString         CCodeBuffer;
+  int              roundCount = 0;
+  int              squareCount = 0;
+
+  QCString         yyFileName;
+  ClangTUParser   *clangParser = 0;
+
+  std::shared_ptr<Entry> current;
+  std::shared_ptr<Entry> current_root;
+  SrcLangExt language;
+};
+
+#if USE_STATE2STRING
+static const char *stateToString(int state);
+#endif
+//-----------------------------------------------------------------------------
+
+// forward declarations for statefull functions
+static void handleCCode(yyscan_t yyscanner);
+static yy_size_t yyread(yyscan_t yyscanner,char *buf,yy_size_t max_size);
+
+/* ----------------------------------------------------------------- */
+#undef  YY_INPUT
+#define YY_INPUT(buf,result,max_size) result=yyread(yyscanner,buf,max_size);
+
+%}
+
+nl              (\r\n|\r|\n)
+ws              [ \t]
+nws             [^ \t\n]
+TopStart        "%top{"{nl}
+TopEnd          "}"{nl}
+LiteralStart    "%{"{nl}
+LiteralEnd      "%}"{nl}
+OptPrefix       "%option"{ws}+"prefix"{ws}*"="{ws}*
+RulesStart      "%%"{nl}
+RulesEnd        "%%"{nl}
+RulesSharp      "<"[^>]*">"
+RulesCurly      "{"[^{}\n]*"}"
+StartSquare     "["
+StartDouble     "\""
+StartRound      "("
+EscapeRulesCharOpen  "\\["|"\\<"|"\\{"|"\\("|"\\\""|"\\{"|"\\ "
+EscapeRulesCharClose "\\]"|"\\>"|"\\}"|"\\)"
+EscapeRulesChar      {EscapeRulesCharOpen}|{EscapeRulesCharClose}
+
+CMD       ("\\"|"@")
+BN        [ \t\n\r]
+BL        [ \t\r]*"\n"
+B         [ \t]
+ID        "$"?[a-z_A-Z\x80-\xFF][a-z_A-Z0-9\x80-\xFF]*
+PRE       [pP][rR][eE]
+CODE      [cC][oO][dD][eE]
+RAWBEGIN  (u|U|L|u8)?R\"[^ \t\(\)\\]{0,16}"("
+RAWEND    ")"[^ \t\(\)\\]{0,16}\"
+CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
+
+%x DefSection
+%x OptPrefix
+%x DefSectionLine
+%x RulesSectionInit
+%x RulesPattern
+%x RulesDouble
+%x RulesRoundDouble
+%x RulesSquare
+%x RulesRoundSquare
+%x RulesRound
+%x UserSection
+
+%x TopSection
+%x LiteralSection
+
+%x COMMENT
+
+%x SkipCurly
+%x SkipCurlyEndDoc
+%x PreLineCtrl
+%x DocLine
+%x DocBlock
+%x DocCopyBlock
+%x SkipString
+%x RawString
+%x SkipComment
+%x SkipCxxComment
+%x Comment
+
+%%
+
+<*>\x0d
+<DefSection>{OptPrefix}  {
+                           BEGIN (OptPrefix);
+                         }
+<OptPrefix>"\""[^\"]*"\"" {
+                           yyextra->prefix = yytext;
+                           yyextra->prefix = yyextra->prefix.mid(1,yyleng-2);
+                         }
+<OptPrefix>{nl}          {
+                           yyextra->CCodeBuffer += yytext;
+                           BEGIN (DefSection);
+                         }
+<DefSection>^{RulesStart} {
+                           yyextra->CCodeBuffer += "int " + yyextra->prefix + "lex (yyscan_t yyscanner) {\n";
+                           BEGIN (RulesSectionInit);
+                         }
+<DefSection>^{TopStart}  {
+                           yyextra->CCodeBuffer += "\n";
+                           yyextra->lastContext = YY_START;
+                           BEGIN (TopSection);
+                         }
+<DefSection>^{LiteralStart}   {
+                           yyextra->CCodeBuffer += "\n";
+                           yyextra->lastContext = YY_START;
+                           BEGIN (LiteralSection);
+                         }
+<TopSection>^{TopEnd}    {
+                           yyextra->CCodeBuffer += "\n";
+                           BEGIN( yyextra->lastContext ) ;
+                         }
+<TopSection>.*{nl}       {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<LiteralSection>^{LiteralEnd}     {
+                           yyextra->CCodeBuffer += "\n";
+                           BEGIN( yyextra->lastContext ) ;
+                         }
+<LiteralSection>.*{nl}   {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<DefSection>^{nws}       {
+                           BEGIN(DefSectionLine);
+                         }
+<DefSection>"//".*{nl}   {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<DefSection>^{ws}*"/*"   {
+                           yyextra->CCodeBuffer += yytext;
+                           yyextra->lastContext = YY_START;
+                           BEGIN(COMMENT);
+                         }
+<COMMENT>"*/"{ws}*{nl}   {
+                           yyextra->CCodeBuffer+=yytext;
+                           BEGIN(yyextra->lastContext);
+                         }
+<COMMENT>"*/"            {
+                           yyextra->CCodeBuffer+=yytext;
+                           BEGIN(yyextra->lastContext);
+                         }
+<COMMENT>[^*\n]+         {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<COMMENT>"//"|"/*"       {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<COMMENT>{nl}              {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<COMMENT>.               {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<DefSection>^{nl}        {
+                           yyextra->CCodeBuffer += "\n";
+                         }
+<DefSection>^{ws}.*{nl}  {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<DefSectionLine>.*{nl}   {
+                           yyextra->CCodeBuffer += "\n";
+                           BEGIN(DefSection);
+                         }
+<RulesSectionInit,RulesPattern>^{RulesEnd} {
+                           yyextra->CCodeBuffer += "}\n";
+                           BEGIN (UserSection);
+                         }
+<RulesSectionInit>^{nws}     {
+                           unput(*yytext);
+                           BEGIN(RulesPattern);
+                         }
+<RulesSectionInit>^{ws}.*{nl} {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<RulesSectionInit>^{nl}  {
+                           yyextra->CCodeBuffer += yytext;
+                         }
+<RulesPattern>"<<EOF>>"  {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                         }
+<RulesPattern>{EscapeRulesChar} {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                         }
+<RulesPattern>{RulesSharp} {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                         }
+<RulesPattern>{RulesCurly} {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                         }
+<RulesPattern>{StartDouble} {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           yyextra->lastContext = YY_START;
+                           BEGIN(RulesDouble);
+                        }
+<RulesDouble,RulesRoundDouble>"\\\\" {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesDouble,RulesRoundDouble>"\\\"" {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesDouble>"\""       {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           BEGIN( yyextra->lastContext ) ;
+                        }
+<RulesRoundDouble>"\""  {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           BEGIN(RulesRound) ;
+                        }
+<RulesDouble,RulesRoundDouble>. {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesPattern>{StartSquare} {
+                           yyextra->squareCount++;
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           yyextra->lastContext = YY_START;
+                           BEGIN(RulesSquare);
+                        }
+<RulesSquare,RulesRoundSquare>"\\[" |
+<RulesSquare,RulesRoundSquare>"\\]" {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesSquare,RulesRoundSquare>"[" {
+                           yyextra->squareCount++;
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesSquare>"]"        {
+                           yyextra->squareCount--;
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           if (!yyextra->squareCount) BEGIN(RulesPattern);
+                        }
+<RulesRoundSquare>"]"   {
+                           yyextra->squareCount--;
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           if (!yyextra->squareCount) BEGIN(RulesRound) ;
+                        }
+<RulesSquare,RulesRoundSquare>"\\\\" {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesSquare,RulesRoundSquare>. {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesPattern>{StartRound} {
+                           yyextra->roundCount++;
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           yyextra->lastContext = YY_START;
+                           BEGIN(RulesRound);
+                        }
+<RulesRound>{RulesCurly} {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesRound>{StartSquare} {
+                           yyextra->squareCount++;
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           BEGIN(RulesRoundSquare);
+                        }
+<RulesRound>{StartDouble} {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           BEGIN(RulesRoundDouble);
+                        }
+<RulesRound>"\\("       |
+<RulesRound>"\\)"       {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesRound>"("         {
+                           yyextra->roundCount++;
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesRound>")"         {
+                           yyextra->roundCount--;
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           if (!yyextra->roundCount) BEGIN( yyextra->lastContext ) ;
+                        }
+<RulesRound>.           {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                        }
+<RulesPattern>{ws}+"|"  {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                           yyextra->curlyCount = 0;
+                           BEGIN(SkipCurly);
+                         }
+<RulesPattern>^{ws}*{nl} {
+                           yyextra->CCodeBuffer += "\n";
+                         }
+<RulesPattern>^{ws}+     {
+                         }
+
+<RulesPattern>({ws}|{nl}) {
+                           unput(*yytext);
+                           yyextra->curlyCount = 0;
+                           BEGIN(SkipCurly);
+                         }
+<RulesPattern>"\\\\"     {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                         }
+<RulesPattern>"/*"       {
+                           yyextra->CCodeBuffer += yytext;
+                           yyextra->lastContext = YY_START;
+                           BEGIN(COMMENT);
+                         }
+<RulesPattern>.          {
+                           yyextra->CCodeBuffer += repeatChar(' ', yyleng);
+                         }
+<SkipCurly>{B}*"#"{B}+[0-9]+{B}+/"\"" { /* line control directive */
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->lastPreLineCtrlContext = YY_START;
+                            BEGIN( PreLineCtrl );
+                          }
+<PreLineCtrl>"\""[^\n\"]*"\"" {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<PreLineCtrl>.            {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<PreLineCtrl>\n           {
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->lastPreLineCtrlContext );
+                          }
+<SkipCurly>"{"            {
+                            yyextra->CCodeBuffer += yytext;
+                                          ++yyextra->curlyCount ;
+                          }
+<SkipCurly>"}"/{BN}*("/*!"|"/**"|"//!"|"///")"<!--" | /* see bug710917 */
+<SkipCurly>"}"            {
+                            yyextra->CCodeBuffer += yytext;
+                            if( yyextra->curlyCount )
+                            {
+                              --yyextra->curlyCount ;
+                            }
+                          }
+<SkipCurly>"}"{BN}*("/*!"|"/**"|"//!"|"///")"<" {
+                            yyextra->CCodeBuffer += yytext;
+                            if ( yyextra->curlyCount )
+                            {
+                              --yyextra->curlyCount ;
+                            }
+                            else
+                            {
+                              yyextra->docBlockContext   = SkipCurlyEndDoc;
+                              if (yytext[yyleng-3]=='/')
+                              {
+                                BEGIN( DocLine );
+                              }
+                              else
+                              {
+                                BEGIN( DocBlock );
+                              }
+                            }
+                          }
+<SkipCurly>\"             {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->lastStringContext=SkipCurly;
+                            BEGIN( SkipString );
+                          }
+<SkipCurly>^{B}*"#"       {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->lastPreLineCtrlContext = YY_START;
+                            BEGIN( PreLineCtrl );
+                          }
+<SkipCurly>{B}*{RAWBEGIN}  {
+                            QCString raw=QCString(yytext).stripWhiteSpace();
+                            yyextra->delimiter = raw.data()+2;
+                            yyextra->delimiter=yyextra->delimiter.left(yyextra->delimiter.length()-1);
+                            yyextra->lastRawStringContext = YY_START;
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN(RawString);
+                          }
+<SkipCurly>[^\n#"'@\\/{}<]+ {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCurly>"/*"           {
+                            yyextra->CCodeBuffer += yytext;
+                                          yyextra->lastCContext = YY_START;
+                                          BEGIN(SkipComment);
+                          }
+<SkipCurly>"//"           {
+                            yyextra->CCodeBuffer += yytext;
+                                          yyextra->lastCContext = YY_START;
+                                          BEGIN(SkipCxxComment);
+                          }
+<SkipCurly>{CHARLIT}      {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCurly>\'             {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCurly>.              {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCurly>("//"{B}*)?"/*!" {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockContext   = YY_START;
+                            BEGIN( DocBlock );
+                          }
+<SkipCurly>"/**"[*]+{BL}  {
+                            bool javadocBanner = Config_getBool(JAVADOC_BANNER);
+                            yyextra->CCodeBuffer += yytext;
+                            if( javadocBanner )
+                            {
+                              yyextra->docBlockContext   = YY_START;
+                              BEGIN( DocBlock );
+                            }
+                            else
+                            {
+                              BEGIN( Comment ) ;
+                            }
+                          }
+<SkipCurly>("//"{B}*)?"/**"/[^/*] {
+                             yyextra->CCodeBuffer += yytext;
+                             yyextra->docBlockContext   = YY_START;
+                             BEGIN( DocBlock );
+                          }
+<SkipCurly>"//!"          {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockContext   = YY_START;
+                            BEGIN( DocLine );
+                          }
+<SkipCurly>"///"/[^/]     {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockContext   = YY_START;
+                            BEGIN( DocLine );
+                          }
+
+<SkipCurly>\n             {
+                            yyextra->CCodeBuffer += yytext;
+                            if (yyextra->curlyCount<=0)
+                            {
+                              BEGIN(RulesPattern);
+                            }
+                          }
+<SkipString>\\.           {
+                             yyextra->CCodeBuffer += yytext;
+                          }
+<SkipString>\"            {
+                             yyextra->CCodeBuffer += yytext;
+                             BEGIN( yyextra->lastStringContext );
+                          }
+<SkipString>"/*"|"*/"|"//" {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipString>\n            {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipString>.             {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCxxComment>.*"\\\n"  {  // line continuation
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCxxComment>.*/\n     {
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->lastCContext ) ;
+                          }
+<Comment>{BN}+            {
+                            yyextra->CCodeBuffer += yytext ;
+                          }
+<Comment>"/*"             { yyextra->CCodeBuffer += yytext ; }
+<Comment>"//"             { yyextra->CCodeBuffer += yytext ; }
+<Comment>{CMD}("code"|"verbatim") {
+                            yyextra->insideCode=TRUE;
+                            yyextra->CCodeBuffer += yytext ;
+                          }
+<Comment>{CMD}("endcode"|"endverbatim") {
+                            yyextra->insideCode=FALSE;
+                            yyextra->CCodeBuffer += yytext ;
+                          }
+<Comment>[^ \.\t\r\n\/\*]+ { yyextra->CCodeBuffer += yytext ; }
+<Comment>"*/"             { yyextra->CCodeBuffer += yytext ;
+                                          if (!yyextra->insideCode) BEGIN( yyextra->lastContext ) ;
+                          }
+<Comment>.                { yyextra->CCodeBuffer += *yytext ; }
+
+<SkipComment>"//"|"/*"    {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipComment>[^\*\n]+     {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipComment>\n           {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipComment>{B}*"*/"     {
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->lastCContext );
+                          }
+<SkipComment>"*"          {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<RawString>{RAWEND}       {
+                            yyextra->CCodeBuffer += yytext;
+                            QCString delimiter = yytext+1;
+                            delimiter=delimiter.left(delimiter.length()-1);
+                            if (delimiter==yyextra->delimiter)
+                            {
+                              BEGIN(yyextra->lastRawStringContext);
+                            }
+                          }
+<RawString>[^)\n]+        {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<RawString>.              {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<RawString>\n             {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+
+
+  /* ---- Single line comments ------ */
+<DocLine>[^\n]*"\n"[ \t]*"//"[/!][<]? { // continuation of multiline C++-style comment
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocLine>{B}*"///"[/]+{B}*/"\n" { // ignore marker line (see bug700345)
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->docBlockContext );
+                          }
+<DocLine>[^\n]*/"\n"{B}*"//"[!/]{B}*{CMD}"}" { // next line is an end group marker, see bug 752712
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->docBlockContext );
+                          }
+<DocLine>[^\n]*/"\n"      { // whole line
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN( yyextra->docBlockContext );
+                          }
+
+ /* ---- Comments blocks ------ */
+
+<DocBlock>"*"*"*/"        { // end of comment block
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN(yyextra->docBlockContext);
+                          }
+<DocBlock>^{B}*"*"+/[^/]  {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>^{B}*("//")?{B}*"*"+/[^//a-z_A-Z0-9*] { // start of a comment line
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>^{B}*("//"){B}* { // strip embedded C++ comments if at the start of a line
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>"//"            { // slashes in the middle of a comment block
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>"/*"            { // start of a new comment in the
+                            // middle of a comment block
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>({CMD}{CMD}){ID}/[^a-z_A-Z0-9] { // escaped command
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>{CMD}("f$"|"f["|"f{") {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockName=&yytext[1];
+                            if (yyextra->docBlockName.at(1)=='{')
+                            {
+                              yyextra->docBlockName.at(1)='}';
+                            }
+                            yyextra->fencedSize=0;
+                            yyextra->nestedComment=FALSE;
+                            BEGIN(DocCopyBlock);
+                          }
+<DocBlock>{B}*"<"{PRE}">" {
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockName="<pre>";
+                            yyextra->fencedSize=0;
+                            yyextra->nestedComment=FALSE;
+                            BEGIN(DocCopyBlock);
+                          }
+<DocBlock>{CMD}("verbatim"|"latexonly"|"htmlonly"|"xmlonly"|"manonly"|"rtfonly"|"docbookonly"|"dot"|"code")/[^a-z_A-Z0-9\-] { // verbatim command (which could contain nested comments!)
+                            yyextra->CCodeBuffer += yytext;
+                            yyextra->docBlockName=&yytext[1];
+                            yyextra->fencedSize=0;
+                            yyextra->nestedComment=FALSE;
+                            BEGIN(DocCopyBlock);
+                          }
+<DocBlock>^({B}*"*"+)?{B}{0,3}"~~~"[~]* {
+                            yyextra->CCodeBuffer += yytext;
+                            QCString pat = substitute(yytext,"*"," ");
+                            yyextra->docBlockName="~~~";
+                            yyextra->fencedSize=pat.stripWhiteSpace().length();
+                            yyextra->nestedComment=FALSE;
+                            BEGIN(DocCopyBlock);
+                          }
+<DocBlock>^({B}*"*"+)?{B}{0,3}"```"[`]* {
+                            yyextra->CCodeBuffer += yytext;
+                            QCString pat = substitute(yytext,"*"," ");
+                            yyextra->docBlockName="```";
+                            yyextra->fencedSize=pat.stripWhiteSpace().length();
+                            yyextra->nestedComment=FALSE;
+                            BEGIN(DocCopyBlock);
+                          }
+<DocBlock>{B}*"<code>"    {
+                            REJECT;
+                          }
+<DocBlock>[^@*~\/\\\n]+   { // any character that isn't special
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>\n              { // newline
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocBlock>.               { // command block
+                            yyextra->CCodeBuffer += yytext;
+                          }
+ /* ---- Copy verbatim sections ------ */
+
+<DocCopyBlock>"</"{PRE}">" { // end of a <pre> block
+                            yyextra->CCodeBuffer += yytext;
+                            if (yyextra->docBlockName=="<pre>")
+                            {
+                              BEGIN(DocBlock);
+                            }
+                          }
+<DocCopyBlock>"</"{CODE}">" { // end of a <code> block
+                            yyextra->CCodeBuffer += yytext;
+                            if (yyextra->docBlockName=="<code>")
+                            {
+                              BEGIN(DocBlock);
+                            }
+                          }
+<DocCopyBlock>[\\@]("f$"|"f]"|"f}") {
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN(DocBlock);
+                          }
+<DocCopyBlock>[\\@]("endverbatim"|"endlatexonly"|"endhtmlonly"|"endxmlonly"|"enddocbookonly"|"endmanonly"|"endrtfonly"|"enddot"|"endcode")/[^a-z_A-Z0-9] { // end of verbatim block
+                            yyextra->CCodeBuffer += yytext;
+                            if (&yytext[4]==yyextra->docBlockName)
+                            {
+                              BEGIN(DocBlock);
+                            }
+                          }
+<DocCopyBlock>^{B}*"*"+/{BN}+ { // start of a comment line
+                            yyextra->CCodeBuffer += yytext;
+                            if (yyextra->docBlockName=="verbatim")
+                            {
+                              REJECT;
+                            }
+                            else if (yyextra->docBlockName=="code")
+                            {
+                              REJECT;
+                            }
+                            else
+                            {
+                              yyextra->CCodeBuffer += yytext;
+                            }
+                          }
+<DocCopyBlock>^{B}*"*"+/{B}+"*"{BN}* { // start of a comment line with two *'s
+                            if (yyextra->docBlockName=="code")
+                            {
+                              yyextra->CCodeBuffer += yytext;
+                            }
+                            else
+                            {
+                              REJECT;
+                            }
+                          }
+<DocCopyBlock>^{B}*"*"+/({ID}|"(") { // Assume *var or *(... is part of source code (see bug723516)
+                            if (yyextra->docBlockName=="code")
+                            {
+                              yyextra->CCodeBuffer += yytext;
+                            }
+                            else
+                            {
+                              REJECT;
+                            }
+                          }
+<DocCopyBlock>^{B}*"*"+/{BN}* { // start of a comment line with one *
+                            if (yyextra->docBlockName=="code")
+                            {
+                              if (yyextra->nestedComment) // keep * it is part of the code
+                              {
+                                yyextra->CCodeBuffer += yytext;
+                              }
+                              else // remove * it is part of the comment block
+                              {
+                                yyextra->CCodeBuffer += yytext;
+                              }
+                            }
+                            else
+                            {
+                              REJECT;
+                            }
+                          }
+<DocCopyBlock>^({B}*"*"+)?{B}{0,3}"~~~"[~]* {
+                            yyextra->CCodeBuffer += yytext;
+                            QCString pat = substitute(yytext,"*"," ");
+                            if (yyextra->fencedSize==pat.stripWhiteSpace().length())
+                            {
+                              BEGIN(DocBlock);
+                            }
+                          }
+<DocCopyBlock>^({B}*"*"+)?{B}{0,3}"```"[`]* {
+                            yyextra->CCodeBuffer += yytext;
+                            QCString pat = substitute(yytext,"*"," ");
+                            if (yyextra->fencedSize==pat.stripWhiteSpace().length())
+                            {
+                              BEGIN(DocBlock);
+                            }
+                          }
+<DocCopyBlock>[^\<@/*\]~\$\\\n]+ { // any character that is not special
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocCopyBlock>"/*"|"*/"|"//" {
+                            if (yytext[1]=='*')
+                            {
+                              yyextra->nestedComment=TRUE;
+                            }
+                            else if (yytext[0]=='*')
+                            {
+                              yyextra->nestedComment=FALSE;
+                            }
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocCopyBlock>\n          { // newline
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<DocCopyBlock>.           { // any other character
+                            yyextra->CCodeBuffer += yytext;
+                          }
+<SkipCurlyEndDoc>"}"{BN}*("/*!"|"/**"|"//!"|"///")"<" { // desc is followed by another one
+                            yyextra->docBlockContext   = SkipCurlyEndDoc;
+                            yyextra->CCodeBuffer += yytext;
+                            if (yytext[yyleng-3]=='/')
+                            {
+                              BEGIN( DocLine );
+                            }
+                            else
+                            {
+                              BEGIN( DocBlock );
+                            }
+                          }
+<SkipCurlyEndDoc>"}"      {
+                            yyextra->CCodeBuffer += yytext;
+                            BEGIN(SkipCurly);
+                          }
+
+<UserSection>.*{nl}       {
+                            yyextra->CCodeBuffer += yytext;
+                          }
+
+  /*
+<*>.  { fprintf(stderr,"Lex scanner Def rule for %s: #%s#\n",stateToString(YY_START),yytext);}
+  */
+<*><<EOF>>                {
+                            handleCCode(yyscanner);
+                            yyterminate();
+                          }
+%%
+
+//----------------------------------------------------------------------------
+static yy_size_t yyread(yyscan_t yyscanner,char *buf,yy_size_t max_size)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+  yy_size_t c=0;
+  while( c < max_size && yyextra->inputString[yyextra->inputPosition] )
+  {
+    *buf = yyextra->inputString[yyextra->inputPosition++] ;
+    //printf("%d (%c)\n",*buf,*buf);
+    c++; buf++;
+  }
+  return c;
+}
+
+//-----------------------------------------------------------------------------
+
+static void parseMain(yyscan_t yyscanner,
+                      const char *fileName,
+                      const char *fileBuf,
+                      const std::shared_ptr<Entry> &rt,
+                      ClangTUParser *clangParser)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+
+  yyextra->inputString = fileBuf;
+  yyextra->inputPosition = 0;
+  lexscannerYYrestart(0,yyscanner);
+
+  yyextra->current_root  = rt;
+  yyextra->yyFileName = fileName;
+  yyextra->clangParser = clangParser;
+  yyextra->language    = getLanguageFromFileName(yyextra->yyFileName);
+  rt->lang = yyextra->language;
+  msg("Parsing file %s...\n",yyextra->yyFileName.data());
+
+  yyextra->current_root  = rt;
+  yyextra->current = std::make_shared<Entry>();
+  int sec=guessSection(yyextra->yyFileName);
+  if (sec)
+  {
+    yyextra->current->name    = yyextra->yyFileName;
+    yyextra->current->section = sec;
+    yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
+  }
+  yyextra->current->reset();
+  BEGIN( DefSection );
+
+  lexscannerYYlex(yyscanner);
+
+  rt->program.resize(0);
+}
+
+//----------------------------------------------------------------------------
+
+
+static void handleCCode(yyscan_t yyscanner)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
+
+  if (yyextra->CCodeBuffer.isEmpty()) return;
+  yyextra->cOutlineParser.parseInput(yyextra->yyFileName,
+                                     yyextra->CCodeBuffer,
+                                     yyextra->current_root,
+                                     yyextra->clangParser);
+               // SrcLangExt_Cpp,
+  yyextra->CCodeBuffer.resize(0);
+  return;
+}
+//----------------------------------------------------------------------------
+
+struct LexOutlineParser::Private
+{
+  yyscan_t yyscanner;
+  lexscannerYY_state state;
+};
+
+LexOutlineParser::LexOutlineParser() : p(std::make_unique<LexOutlineParser::Private>())
+{
+  lexscannerYYlex_init_extra(&p->state,&p->yyscanner);
+#ifdef FLEX_DEBUG
+  lexscannerYYset_debug(1,p->yyscanner);
+#endif
+}
+
+LexOutlineParser::~LexOutlineParser()
+{
+  lexscannerYYlex_destroy(p->yyscanner);
+}
+
+void LexOutlineParser::parseInput(const char *fileName,
+                                  const char *fileBuf,
+                                  const std::shared_ptr<Entry> &root,
+                                  ClangTUParser *clangParser)
+{
+  struct yyguts_t *yyg = (struct yyguts_t*)p->yyscanner;
+
+  printlex(yy_flex_debug, TRUE, __FILE__, fileName);
+
+  ::parseMain(p->yyscanner,fileName,fileBuf,root,clangParser);
+
+  printlex(yy_flex_debug, FALSE, __FILE__, fileName);
+}
+
+
+//----------------------------------------------------------------------------
+
+#if USE_STATE2STRING
+#include "lexscanner.l.h"
+#endif
diff --git a/src/memberdef.cpp b/src/memberdef.cpp
index 7e583318347..4eeacc67390 100644
--- a/src/memberdef.cpp
+++ b/src/memberdef.cpp
@@ -3512,10 +3512,17 @@ void MemberDefImpl::writeDocumentation(const MemberList *ml,
     else
       ol.parseText(theTranslator->trInitialValue());
     ol.endBold();
-    auto intf = Doxygen::parserManager->getCodeParser(getDefFileExtension());
+    QCString langCorrected = getDefFileExtension();
+    SrcLangExt srcLangExt = getLanguageFromFileName(getDefFileExtension());
+    if (srcLangExt == SrcLangExt_Lex)
+    {
+      langCorrected = ".doxygen_lex_c";
+      srcLangExt = SrcLangExt_Cpp;
+    }
+    auto intf = Doxygen::parserManager->getCodeParser(langCorrected);
     intf->resetCodeParserState();
     ol.startCodeFragment("DoxyCode");
-    intf->parseCode(ol,scopeName,m_impl->initializer,lang,FALSE,0,const_cast<FileDef*>(getFileDef()),
+    intf->parseCode(ol,scopeName,m_impl->initializer,srcLangExt,FALSE,0,const_cast<FileDef*>(getFileDef()),
                      -1,-1,TRUE,this,FALSE,this);
     ol.endCodeFragment("DoxyCode");
   }
diff --git a/src/pre.l b/src/pre.l
index e817a9d33db..4e423f90998 100644
--- a/src/pre.l
+++ b/src/pre.l
@@ -111,8 +111,8 @@ struct PreIncludeInfo
 /** A dictionary of managed Define objects. */
 typedef std::map< std::string, Define > DefineMap;
 
-/** @brief Class that manages the defines available while 
- *  preprocessing files. 
+/** @brief Class that manages the defines available while
+ *  preprocessing files.
  */
 class DefineManager
 {
@@ -122,7 +122,7 @@ class DefineManager
     {
       public:
         /** Creates an empty container for defines */
-        DefinesPerFile(DefineManager *parent) 
+        DefinesPerFile(DefineManager *parent)
           : m_parent(parent)
         {
         }
@@ -353,6 +353,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 %x	SkipLine
 %x	SkipString
 %x	CopyLine
+%x	LexCopyLine
 %x	CopyString
 %x	CopyStringCs
 %x	CopyStringFtn
@@ -396,9 +397,14 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
   					  unput(resolveTrigraph(yytext[2]));
   					}
 <Start>^{B}*"#"				{ BEGIN(Command); yyextra->yyColNr+=(int)yyleng; yyextra->yyMLines=0;}
+<Start>^("%top{"|"%{")                  {
+                                          if (getLanguageFromFileName(yyextra->yyFileName)!=SrcLangExt_Lex) REJECT
+                                          outputArray(yyscanner,yytext,(int)yyleng);
+                                          BEGIN(LexCopyLine);
+                                        }
 <Start>^{B}*/[^#]			{
  					  outputArray(yyscanner,yytext,(int)yyleng);
-  					  BEGIN(CopyLine); 
+  					  BEGIN(CopyLine);
 					}
 <Start>^{B}*[a-z_A-Z\x80-\xFF][a-z_A-Z0-9\x80-\xFF]+{B}*"("[^\)\n]*")"/{BN}{1,10}*[:{] { // constructors?
 					  int i;
@@ -439,46 +445,49 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					    BEGIN(CopyLine);
 					  }
   					}
-<CopyLine>"extern"{BN}{0,80}"\"C\""*{BN}{0,80}"{"	{
+<CopyLine,LexCopyLine>"extern"{BN}{0,80}"\"C\""*{BN}{0,80}"{"	{
                                           QCString text=yytext;
   					  yyextra->yyLineNr+=text.contains('\n');
 					  outputArray(yyscanner,yytext,(int)yyleng);
   					}
-<CopyLine>{RAWBEGIN}                    {
+<CopyLine,LexCopyLine>{RAWBEGIN}        {
                                           yyextra->delimiter = yytext+2;
                                           yyextra->delimiter=yyextra->delimiter.left(yyextra->delimiter.length()-1);
 					  outputArray(yyscanner,yytext,(int)yyleng);
                                           BEGIN(CopyRawString);
                                         }
-<CopyLine>"{"				{ // count brackets inside the main file
-  					  if (yyextra->includeStack.empty()) 
+<CopyLine,LexCopyLine>"{"		{ // count brackets inside the main file
+  					  if (yyextra->includeStack.empty())
 					  {
 					    yyextra->curlyCount++;
 					  }
 					  outputChar(yyscanner,*yytext);
   					}
-<CopyLine>"}"				{ // count brackets inside the main file
-  					  if (yyextra->includeStack.empty() && yyextra->curlyCount>0) 
+<LexCopyLine>^"%}"			{
+                                          outputArray(yyscanner,yytext,(int)yyleng);
+  					}
+<CopyLine,LexCopyLine>"}"		{ // count brackets inside the main file
+  					  if (yyextra->includeStack.empty() && yyextra->curlyCount>0)
 					  {
 					    yyextra->curlyCount--;
 					  }
 					  outputChar(yyscanner,*yytext);
   					}
-<CopyLine>"'"\\[0-7]{1,3}"'"		{ 
+<CopyLine,LexCopyLine>"'"\\[0-7]{1,3}"'" {
   					  outputArray(yyscanner,yytext,(int)yyleng);
 					}
-<CopyLine>"'"\\."'"			{ 
+<CopyLine,LexCopyLine>"'"\\."'"		{
   					  outputArray(yyscanner,yytext,(int)yyleng);
 					}
-<CopyLine>"'"."'"			{ 
+<CopyLine,LexCopyLine>"'"."'"		{
   					  outputArray(yyscanner,yytext,(int)yyleng);
 					}
-<CopyLine>@\"				{
+<CopyLine,LexCopyLine>@\"		{
                                           if (getLanguageFromFileName(yyextra->yyFileName)!=SrcLangExt_CSharp) REJECT;
 					  outputArray(yyscanner,yytext,(int)yyleng);
 					  BEGIN( CopyStringCs );
 					}
-<CopyLine>\"				{
+<CopyLine,LexCopyLine>\"		{
 					  outputChar(yyscanner,*yytext);
                                           if (getLanguageFromFileName(yyextra->yyFileName)!=SrcLangExt_Fortran)
                                           {
@@ -489,7 +498,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					    BEGIN( CopyStringFtnDouble );
                                           }
 					}
-<CopyLine>\'				{
+<CopyLine,LexCopyLine>\'		{
                                           if (getLanguageFromFileName(yyextra->yyFileName)!=SrcLangExt_Fortran) REJECT;
 					  outputChar(yyscanner,*yytext);
 					  BEGIN( CopyStringFtn );
@@ -542,7 +551,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 <CopyRawString>.                        {
 					  outputChar(yyscanner,*yytext);
                                         }
-<CopyLine>{ID}/{BN}{0,80}"("		{
+<CopyLine,LexCopyLine>{ID}/{BN}{0,80}"("	{
   					  yyextra->expectGuard = FALSE;
   					  Define *def=0;
 					  //def=yyextra->globalDefineDict->find(yytext);
@@ -579,9 +588,9 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					    outputArray(yyscanner,yytext,(int)yyleng);
 					  }
   					}
-<CopyLine>{ID}				{
+<CopyLine,LexCopyLine>{ID}		{
                                           Define *def=0;
-  					  if ((yyextra->includeStack.empty() || yyextra->curlyCount>0) && 
+  					  if ((yyextra->includeStack.empty() || yyextra->curlyCount>0) &&
 					      yyextra->macroExpansion &&
 					      (def=isDefined(yyscanner,yytext)) &&
 					      def->nargs==-1 &&
@@ -589,7 +598,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					      (!yyextra->expandOnlyPredef || def->isPredefined)
 					     )
 					  {
-					    QCString result=def->isPredefined ? def->definition : expandMacro(yyscanner,yytext); 
+					    QCString result=def->isPredefined ? def->definition : expandMacro(yyscanner,yytext);
 					    outputArray(yyscanner,result,result.length());
 					  }
 					  else
@@ -597,13 +606,13 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					    outputArray(yyscanner,yytext,(int)yyleng);
 					  }
   					}
-<CopyLine>"\\"\r?/\n			{ // strip line continuation characters
+<CopyLine,LexCopyLine>"\\"\r?/\n	{ // strip line continuation characters
                                           if (getLanguageFromFileName(yyextra->yyFileName)==SrcLangExt_Fortran) outputChar(yyscanner,*yytext);
   					}
-<CopyLine>.				{
+<CopyLine,LexCopyLine>.			{
   					  outputChar(yyscanner,*yytext);
   					}
-<CopyLine>\n				{
+<CopyLine,LexCopyLine>\n		{
   					  outputChar(yyscanner,'\n');
 					  BEGIN(Start);
 					  yyextra->yyLineNr++;
@@ -672,12 +681,12 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					  yyextra->defArgsStr+=yytext;
   					  BEGIN(FindDefineArgs);
   					}
-<ArgCopyCComment>\n			{ 
+<ArgCopyCComment>\n			{
                                           yyextra->defArgsStr+=' ';
   					  yyextra->yyLineNr++;
 					  outputChar(yyscanner,'\n');
   					}
-<ArgCopyCComment>.			{ 
+<ArgCopyCComment>.			{
                                           yyextra->defArgsStr+=yytext;
                                         }
 <ReadString>"\""			{
@@ -703,20 +712,20 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
   					}
 <Command>("include"|"import"){B}+/{ID}	{
   					  yyextra->isImported = yytext[1]=='m';
-  					  if (yyextra->macroExpansion) 
+  					  if (yyextra->macroExpansion)
 					    BEGIN(IncludeID);
   					}
-<Command>("include"|"import"){B}*[<"]	{ 
+<Command>("include"|"import"){B}*[<"]	{
   					  yyextra->isImported = yytext[1]=='m';
 					  char c[2];
 					  c[0]=yytext[yyleng-1];c[1]='\0';
 					  yyextra->incName=c;
-  					  BEGIN(Include); 
+  					  BEGIN(Include);
 					}
-<Command>("cmake")?"define"{B}+		{ 
-  			                  //printf("!!!DefName\n"); 
+<Command>("cmake")?"define"{B}+		{
+  			                  //printf("!!!DefName\n");
 					  yyextra->yyColNr+=(int)yyleng;
-  					  BEGIN(DefName); 
+  					  BEGIN(DefName);
 					}
 <Command>"ifdef"/{B}*"("		{
   					  incrLevel(yyscanner);
@@ -748,7 +757,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
   					  if (!otherCaseDone(yyscanner))
 					  {
 					    yyextra->guardExpr.resize(0);
-					    BEGIN(Guard);  
+					    BEGIN(Guard);
 					  }
 					  else
 					  {
@@ -765,7 +774,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					  else
 					  {
 					    setCaseDone(yyscanner,TRUE);
-					  } 
+					  }
   					}
 <Command>"undef"{B}+			{
   					  BEGIN(UndefName);
@@ -800,7 +809,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 <Command>. {yyextra->yyColNr+=(int)yyleng;}
 <UndefName>{ID}				{
   					  Define *def;
-  					  if ((def=isDefined(yyscanner,yytext)) 
+  					  if ((def=isDefined(yyscanner,yytext))
 					      /*&& !def->isPredefined*/
 					      && !def->nonRecursive
 					     )
@@ -833,7 +842,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					  if (guard)
 					  {
 					    BEGIN(Start);
-					  } 
+					  }
 					  else
 					  {
 					    yyextra->ifcount=0;
@@ -859,7 +868,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 <DefinedExpr1,DefinedExpr2>\n		{ // should not happen, handle anyway
                                           yyextra->yyLineNr++;
   					  yyextra->ifcount=0;
- 					  BEGIN(SkipCPPBlock); 
+ 					  BEGIN(SkipCPPBlock);
 					}
 <DefinedExpr2>")"			{
   					  BEGIN(Guard);
@@ -869,9 +878,9 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 <SkipCPPBlock>^{B}*/[^#]		{ BEGIN(SkipLine); }
 <SkipCPPBlock>\n			{ yyextra->yyLineNr++; outputChar(yyscanner,'\n'); }
 <SkipCPPBlock>.
-<SkipCommand>"if"(("n")?("def"))?/[ \t(!]	{ 
+<SkipCommand>"if"(("n")?("def"))?/[ \t(!] {
   					  incrLevel(yyscanner);
-                                          yyextra->ifcount++; 
+                                          yyextra->ifcount++;
   					  //printf("#if... depth=%d\n",yyextra->ifcount);
 					}
 <SkipCommand>"else"			{
@@ -884,7 +893,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					  }
   					}
 <SkipCommand>("elif"|"else"{B}*"if")/[ \t(!]		{
-  					  if (yyextra->ifcount==0) 
+  					  if (yyextra->ifcount==0)
 					  {
   					    if (!otherCaseDone(yyscanner))
 					    {
@@ -898,7 +907,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					    }
 					  }
 					}
-<SkipCommand>"endif"			{ 
+<SkipCommand>"endif"			{
 					  yyextra->expectGuard = FALSE;
   					  decrLevel(yyscanner);
   				          if (--yyextra->ifcount<0)
@@ -907,13 +916,13 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					    BEGIN(Start);
 					  }
 					}
-<SkipCommand>\n				{ 
+<SkipCommand>\n				{
   					  outputChar(yyscanner,'\n');
-  					  yyextra->yyLineNr++; 
+  					  yyextra->yyLineNr++;
 					  BEGIN(SkipCPPBlock);
 					}
-<SkipCommand>{ID}			{ // unknown directive 
-  					  BEGIN(SkipLine); 
+<SkipCommand>{ID}			{ // unknown directive
+  					  BEGIN(SkipLine);
 					}
 <SkipCommand>.
 <SkipLine>[^'"/\n]+			
@@ -922,13 +931,13 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					  BEGIN(SkipString);
 					}
 <SkipLine>.
-<SkipString>"//"/[^\n]*                 { 
+<SkipString>"//"/[^\n]*                 {
                                         }
 <SkipLine,SkipCommand,SkipCPPBlock>"//"[^\n]* {
   					  yyextra->lastCPPContext=YY_START;
   					  BEGIN(RemoveCPPComment);
 					}
-<SkipString>"/*"/[^\n]*                 { 
+<SkipString>"/*"/[^\n]*                 {
                                         }
 <SkipLine,SkipCommand,SkipCPPBlock>"/*"/[^\n]* {
 					  yyextra->lastCContext=YY_START;
@@ -936,7 +945,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
   					}
 <SkipLine>\n				{
   					  outputChar(yyscanner,'\n');
-					  yyextra->yyLineNr++;  
+					  yyextra->yyLineNr++;
 					  BEGIN(SkipCPPBlock);
 					}
 <SkipString>[^"\\\n]+			{ }
@@ -957,7 +966,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
                                           readIncludeFile(yyscanner,expandMacro(yyscanner,yytext));
 					  BEGIN(Start);
   					}
-<Include>[^\">\n]+[\">]			{ 
+<Include>[^\">\n]+[\">]			{
 					  yyextra->incName+=yytext;
 					  readIncludeFile(yyscanner,yyextra->incName);
 					  if (yyextra->isImported)
@@ -972,7 +981,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 <EndImport>[^\\\n]*/\n			{
   					  BEGIN(Start);
   					}
-<EndImport>\\[\r]?"\n"			{ 
+<EndImport>\\[\r]?"\n"			{
 					  outputChar(yyscanner,'\n');
 					  yyextra->yyLineNr++;
 					}
@@ -1007,9 +1016,9 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					    yyextra->quoteArg=FALSE;
 					    yyextra->insideComment=FALSE;
 					    yyextra->lastGuardName.resize(0);
-				            yyextra->defText="1"; 
-					    yyextra->defLitText="1"; 
-					    BEGIN(DefineText); 
+				            yyextra->defText="1";
+					    yyextra->defLitText="1";
+					    BEGIN(DefineText);
 					  }
 					  else // define is a guard => hide
 					  {
@@ -1061,7 +1070,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					  outputArray(yyscanner,tmp.data(),tmp.length());
 					  yyextra->quoteArg=FALSE;
 					  yyextra->insideComment=FALSE;
-					  BEGIN(DefineText); 
+					  BEGIN(DefineText);
   					}
 <DefineArg>"\\\n"                       {
   					  yyextra->defExtraSpacing+="\n";
@@ -1070,7 +1079,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 <DefineArg>","{B}*			{ yyextra->defArgsStr+=yytext; }
 <DefineArg>"("{B}*                      { yyextra->defArgsStr+=yytext; }
 <DefineArg>{B}*")"{B}*			{
-                                          yyextra->defArgsStr+=yytext; 
+                                          yyextra->defArgsStr+=yytext;
 					  QCString tmp=(QCString)"#define "+yyextra->defName+yyextra->defArgsStr+yyextra->defExtraSpacing;
 					  outputArray(yyscanner,tmp.data(),tmp.length());
 					  yyextra->quoteArg=FALSE;
@@ -1126,13 +1135,13 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
   					  outputChar(yyscanner,'*');outputChar(yyscanner,'/');
 					  if (--yyextra->commentCount<=0)
 					  {
-					    if (yyextra->lastCContext==Start) 
+					    if (yyextra->lastCContext==Start)
 					      // small hack to make sure that ^... rule will
 					      // match when going to Start... Example: "/*...*/ some stuff..."
 					    {
 					      YY_CURRENT_BUFFER->yy_at_bol=1;
 					    }
-  					    BEGIN(yyextra->lastCContext);  
+  					    BEGIN(yyextra->lastCContext);
 					  }
   					}
 <SkipCComment>"//"("/")*		{
@@ -1196,12 +1205,12 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
   					  outputArray(yyscanner,yytext,(int)yyleng);
                                         }
 <SkipCPPComment>[\\@]"cond"[ \t]+	{ // conditional section
-                                          yyextra->ccomment=TRUE;  
+                                          yyextra->ccomment=TRUE;
                                           yyextra->condCtx=YY_START;
   					  BEGIN(CondLineCpp);
   					}
 <SkipCComment>[\\@]"cond"[ \t]+	{ // conditional section
-                                          yyextra->ccomment=FALSE;  
+                                          yyextra->ccomment=FALSE;
                                           yyextra->condCtx=YY_START;
   					  BEGIN(CondLineC);
   					}
@@ -1274,7 +1283,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
   					    outputArray(yyscanner,yytext,(int)yyleng);
                                           }
                                         }
-<SkipCond>[\\@]"endcond"/[^a-z_A-Z0-9\x80-\xFF]  { 
+<SkipCond>[\\@]"endcond"/[^a-z_A-Z0-9\x80-\xFF]  {
                                           bool oldSkip = yyextra->skip;
                                           endCondSection(yyscanner);
                                           if (oldSkip && !yyextra->skip)
@@ -1289,7 +1298,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 <SkipCComment,SkipCPPComment>[\\@]"endcond"/[^a-z_A-Z0-9\x80-\xFF] {
                                           bool oldSkip = yyextra->skip;
   					  endCondSection(yyscanner);
-                                          if (oldSkip && !yyextra->skip) 
+                                          if (oldSkip && !yyextra->skip)
                                           {
                                             BEGIN(yyextra->condCtx);
                                           }
@@ -1325,7 +1334,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 <SkipCComment,SkipVerbatim>[^*\\@\x06~`\n\/]+ {
   					  outputArray(yyscanner,yytext,(int)yyleng);
   					}
-<SkipCComment,SkipVerbatim>\n		{ 
+<SkipCComment,SkipVerbatim>\n		{
   					  yyextra->yyLineNr++;
   					  outputChar(yyscanner,'\n');
   					}
@@ -1347,7 +1356,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					  yyextra->defText+=yytext;
   					  BEGIN(yyextra->lastCContext);
   					}
-<CopyCComment>\n			{ 
+<CopyCComment>\n			{
   					  yyextra->yyLineNr++;
 					  yyextra->defLitText+=yytext;
 					  yyextra->defText+=' ';
@@ -1447,7 +1456,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
   					  outputChar(yyscanner,'\n');
   					  Define *def=0;
 					  //printf("Define name='%s' text='%s' litTexti='%s'\n",yyextra->defName.data(),yyextra->defText.data(),yyextra->defLitText.data());
-					  if (yyextra->includeStack.empty() || yyextra->curlyCount>0) 
+					  if (yyextra->includeStack.empty() || yyextra->curlyCount>0)
 					  {
 					    addMacroDefinition(yyscanner);
 					  }
@@ -1468,7 +1477,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					      def->name = yyextra->defName;
 					      def->definition = yyextra->defText.stripWhiteSpace();
 					      def->nargs = yyextra->defArgs;
-					      def->fileName = yyextra->yyFileName.copy(); 
+					      def->fileName = yyextra->yyFileName.copy();
 					      def->lineNr = yyextra->yyLineNr-yyextra->yyMLines;
 					      def->columnNr = yyextra->yyColNr;
 					    }
@@ -1486,16 +1495,16 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 <DefineText>{B}*			{ yyextra->defText += ' '; yyextra->defLitText+=yytext; }
 <DefineText>{B}*"##"{B}*		{ yyextra->defText += "##"; yyextra->defLitText+=yytext; }
 <DefineText>"@"				{ yyextra->defText += "@@"; yyextra->defLitText+=yytext; }
-<DefineText>\"				{ 
-                                          yyextra->defText += *yytext; 
-  					  yyextra->defLitText+=yytext; 
+<DefineText>\"				{
+                                          yyextra->defText += *yytext;
+  					  yyextra->defLitText+=yytext;
 					  if (!yyextra->insideComment)
 					  {
 					    BEGIN(SkipDoubleQuote);
 					  }
   					}
 <DefineText>\'				{ yyextra->defText += *yytext;
-  					  yyextra->defLitText+=yytext; 
+  					  yyextra->defLitText+=yytext;
 					  if (!yyextra->insideComment)
 					  {
   					    BEGIN(SkipSingleQuote);
@@ -1504,7 +1513,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 <SkipDoubleQuote>"//"[/]?		{ yyextra->defText += yytext; yyextra->defLitText+=yytext; }
 <SkipDoubleQuote>"/*"[*]?		{ yyextra->defText += yytext; yyextra->defLitText+=yytext; }
 <SkipDoubleQuote>\"			{
-  					  yyextra->defText += *yytext; yyextra->defLitText+=yytext; 
+  					  yyextra->defText += *yytext; yyextra->defLitText+=yytext;
 					  BEGIN(DefineText);
   					}
 <SkipSingleQuote,SkipDoubleQuote>\\.	{
@@ -1541,7 +1550,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					    setFileName(yyscanner,fs->fileName);
 					    DBG_CTX((stderr,"######## FileName %s\n",yyextra->yyFileName.data()));
 
-                                            // Deal with file changes due to 
+                                            // Deal with file changes due to
                                             // #include's within { .. } blocks
                                             QCString lineStr(15+yyextra->yyFileName.length());
                                             lineStr.sprintf("# %d \"%s\" 2",yyextra->yyLineNr,yyextra->yyFileName.data());
@@ -1593,7 +1602,7 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					    outputArray(yyscanner,yytext,(int)yyleng);
   					    yyextra->lastCContext=YY_START;
 					    yyextra->commentCount=1;
-					    if (yyleng==3) 
+					    if (yyleng==3)
                                             {
                                               yyextra->isSpecialComment = true;
                                               yyextra->lastGuardName.resize(0); // reset guard in case the #define is documented!
@@ -1626,9 +1635,9 @@ CHARLIT   (("'"\\[0-7]{1,3}"'")|("'"\\."'")|("'"[^'\\\n]{1,4}"'"))
 					    BEGIN(SkipCPPComment);
                                           }
 					}
-<*>\n					{ 
+<*>\n					{
   					  outputChar(yyscanner,'\n');
-  					  yyextra->yyLineNr++; 
+  					  yyextra->yyLineNr++;
 					}
 <*>.				        {
   					  yyextra->expectGuard = FALSE;
@@ -1845,23 +1854,23 @@ static QCString extractTrailingComment(const char *s)
 	  {
 	    i--;
 	    while (i>0 && !(s[i-1]=='/' && s[i]=='*')) i--;
-	    if (i==0) 
+	    if (i==0)
 	    {
 	      i++;
 	    }
 	    // only /*!< or /**< are treated as a comment for the macro name,
 	    // otherwise the comment is treated as part of the macro definition
-	    return ((s[i+1]=='*' || s[i+1]=='!') && s[i+2]=='<') ? &s[i-1] : ""; 
+	    return ((s[i+1]=='*' || s[i+1]=='!') && s[i+2]=='<') ? &s[i-1] : "";
 	  }
 	  else
 	  {
 	    return "";
 	  }
-	} 
+	}
 	break;
 	// whitespace or line-continuation
       case ' ':
-      case '\t': 
+      case '\t':
       case '\r':
       case '\n':
       case '\\':
@@ -1935,7 +1944,7 @@ static QCString stringize(const QCString &s)
       while (i<s.length() && inString)
       {
 	c=s.at(i++);
-	if (c=='"') 
+	if (c=='"')
 	{
 	  result+="\\\"";
 	  inString= pc=='\\';
@@ -1952,15 +1961,15 @@ static QCString stringize(const QCString &s)
   return result;
 }
 
-/*! Execute all ## operators in expr. 
- * If the macro name before or after the operator contains a no-rescan 
+/*! Execute all ## operators in expr.
+ * If the macro name before or after the operator contains a no-rescan
  * marker (@-) then this is removed (before the concatenated macro name
  * may be expanded again.
  */
 static void processConcatOperators(QCString &expr)
 {
   //printf("processConcatOperators: in='%s'\n",expr.data());
-  QRegExp r("[ \\t\\n]*##[ \\t\\n]*"); 
+  QRegExp r("[ \\t\\n]*##[ \\t\\n]*");
   int l,n,i=0;
   if (expr.isEmpty()) return;
   while ((n=r.match(expr,i,&l))!=-1)
@@ -1975,7 +1984,7 @@ static void processConcatOperators(QCString &expr)
     // remove the ## operator and the surrounding whitespace
     expr=expr.left(n)+expr.right(expr.length()-n-l);
     int k=n-1;
-    while (k>=0 && isId(expr.at(k))) k--; 
+    while (k>=0 && isId(expr.at(k))) k--;
     if (k>0 && expr.at(k)=='-' && expr.at(k-1)=='@')
     {
       // remove no-rescan marker before ID
@@ -2006,12 +2015,12 @@ static inline void addTillEndOfString(yyscan_t yyscanner,const QCString &expr,QC
 }
 
 /*! replaces the function macro \a def whose argument list starts at
- * \a pos in expression \a expr. 
+ * \a pos in expression \a expr.
  * Notice that this routine may scan beyond the \a expr string if needed.
  * In that case the characters will be read from the input file.
- * The replacement string will be returned in \a result and the 
+ * The replacement string will be returned in \a result and the
  * length of the (unexpanded) argument list is stored in \a len.
- */ 
+ */
 static bool replaceFunctionMacro(yyscan_t yyscanner,const QCString &expr,QCString *rest,int pos,int &len,const Define *def,QCString &result,int level)
 {
   YY_EXTRA_TYPE state = preYYget_extra(yyscanner);
@@ -2020,15 +2029,15 @@ static bool replaceFunctionMacro(yyscan_t yyscanner,const QCString &expr,QCStrin
   len=0;
   result.resize(0);
   int cc;
-  while ((cc=getCurrentChar(yyscanner,expr,rest,j))!=EOF && isspace(cc)) 
-  { 
-    len++; 
-    getNextChar(yyscanner,expr,rest,j); 
+  while ((cc=getCurrentChar(yyscanner,expr,rest,j))!=EOF && isspace(cc))
+  {
+    len++;
+    getNextChar(yyscanner,expr,rest,j);
   }
-  if (cc!='(') 
-  { 
-    unputChar(yyscanner,expr,rest,j,(char)cc); 
-    return FALSE; 
+  if (cc!='(')
+  {
+    unputChar(yyscanner,expr,rest,j,(char)cc);
+    return FALSE;
   }
   getNextChar(yyscanner,expr,rest,j); // eat the '(' character
 
@@ -2048,7 +2057,7 @@ static bool replaceFunctionMacro(yyscan_t yyscanner,const QCString &expr,QCStrin
   }
   else
   {
-    while (!done && (argCount<def->nargs || def->varArgs) && 
+    while (!done && (argCount<def->nargs || def->varArgs) &&
 	((cc=getNextChar(yyscanner,expr,rest,j))!=EOF && cc!=0)
 	  )
     {
@@ -2102,21 +2111,21 @@ static bool replaceFunctionMacro(yyscan_t yyscanner,const QCString &expr,QCStrin
 	    done=TRUE;
 	  }
 	}
-      } 
+      }
       else if (c=='\"') // append literal strings
       {
-	arg+=c; 
+	arg+=c;
 	bool found=FALSE;
 	while (!found && (cc=getNextChar(yyscanner,expr,rest,j))!=EOF && cc!=0)
 	{
 	  found = cc=='"';
 	  if (cc=='\\')
 	  {
-	    c=(char)cc;	  
+	    c=(char)cc;
 	    arg+=c;
 	    if ((cc=getNextChar(yyscanner,expr,rest,j))==EOF || cc==0) break;
 	  }
-	  c=(char)cc;	  
+	  c=(char)cc;
 	  arg+=c;
 	}
       }
@@ -2129,14 +2138,14 @@ static bool replaceFunctionMacro(yyscan_t yyscanner,const QCString &expr,QCStrin
 	  found = cc=='\'';
 	  if (cc=='\\')
 	  {
-	    c=(char)cc;	  
+	    c=(char)cc;
 	    arg+=c;
 	    if ((cc=getNextChar(yyscanner,expr,rest,j))==EOF || cc==0) break;
 	  }
 	  c=(char)cc;
 	  arg+=c;
 	}
-      }	    
+      }
       else if (c=='/') // possible start of a comment
       {
         char prevChar = '\0';
@@ -2196,7 +2205,7 @@ static bool replaceFunctionMacro(yyscan_t yyscanner,const QCString &expr,QCStrin
 	  k++;
 	  // scan the number
 	  while (k<d.length() && d.at(k)>='0' && d.at(k)<='9') key+=d.at(k++);
-	  if (!hash) 
+	  if (!hash)
 	  {
 	    // search for ## forward
 	    l=k;
@@ -2220,7 +2229,7 @@ static bool replaceFunctionMacro(yyscan_t yyscanner,const QCString &expr,QCStrin
 	    {
 	      //printf("'%s'=stringize('%s')\n",stringize(*subst).data(),subst->data());
 
-	      // if the marker is inside a string (because a # was put 
+	      // if the marker is inside a string (because a # was put
 	      // before the macro name) we must escape " and \ characters
 	      resExpr+=stringize(substArg);
 	    }
@@ -2244,7 +2253,7 @@ static bool replaceFunctionMacro(yyscan_t yyscanner,const QCString &expr,QCStrin
       }
       else // no marker, just copy
       {
-	if (!inString && d.at(k)=='\"') 
+	if (!inString && d.at(k)=='\"')
 	{
 	  inString=TRUE; // entering a literal string
 	}
@@ -2284,13 +2293,13 @@ static int getNextId(const QCString &expr,int p,int *l)
       n=p-1;
       while (p<(int)expr.length() && isId(expr.at(p))) p++;
       *l=p-n;
-      return n; 
+      return n;
     }
     else if (c=='"') // skip string
     {
       char ppc=0,pc=c;
       if (p<(int)expr.length()) c=expr.at(p);
-      while (p<(int)expr.length() && (c!='"' || (pc=='\\' && ppc!='\\'))) 
+      while (p<(int)expr.length() && (c!='"' || (pc=='\\' && ppc!='\\')))
 	// continue as long as no " is found, but ignoring \", but not \\"
       {
 	ppc=pc;
@@ -2304,11 +2313,11 @@ static int getNextId(const QCString &expr,int p,int *l)
     {
       //printf("Found C comment at p=%d\n",p);
       char pc=c;
-      if (p<(int)expr.length()) 
+      if (p<(int)expr.length())
       {
 	c=expr.at(p);
         if (c=='*')  // Start of C comment
-        { 
+        {
 	  p++;
   	  while (p<(int)expr.length() && !(pc=='*' && c=='/'))
 	  {
@@ -2369,7 +2378,7 @@ static bool expandExpression(yyscan_t yyscanner,QCString &expr,QCString *rest,in
   	  //printf("found defined inside macro definition '%s'\n",expr.right(expr.length()-p).data());
 	  definedTest=TRUE;
         }
-	else if (definedTest) // macro name was found after defined 
+	else if (definedTest) // macro name was found after defined
 	{
 	  if (def) expMacro = " 1 "; else expMacro = " 0 ";
 	  replaced=TRUE;
@@ -2527,7 +2536,7 @@ static QCString removeIdsAndMarkers(const char *s)
       {
 	if (*(p+1)=='@')
 	{
-	  result+=c; 
+	  result+=c;
 	}
 	else if (*(p+1)=='E')
 	{
@@ -2547,7 +2556,7 @@ static QCString removeIdsAndMarkers(const char *s)
       }
       else if (c=='d' && !inNum) // identifier starting with a 'd'
       {
-	if (qstrncmp(p,"defined ",8)==0 || qstrncmp(p,"defined(",8)==0) 
+	if (qstrncmp(p,"defined ",8)==0 || qstrncmp(p,"defined(",8)==0)
 	           // defined keyword
 	{
 	  p+=7; // skip defined
@@ -2599,7 +2608,7 @@ static QCString removeIdsAndMarkers(const char *s)
 	char pc=c;
 	c=*++p;
 	if (c=='*') // start of C comment
-	{ 
+	{
 	  while (*p && !(pc=='*' && c=='/')) // search end of comment
 	  {
 	    pc=c;
@@ -2613,7 +2622,7 @@ static QCString removeIdsAndMarkers(const char *s)
 	  goto nextChar;
 	}
       }
-      else 
+      else
       {
 nextChar:
 	result+=c;
@@ -2628,7 +2637,7 @@ nextChar:
 }
 
 /*! replaces all occurrences of @@ in \a s by @
- *  \par assumption: 
+ *  \par assumption:
  *   \a s only contains pairs of @@'s
  */
 static QCString removeMarkers(const char *s)
@@ -2646,7 +2655,7 @@ static QCString removeMarkers(const char *s)
 	  {
 	    if (*(p+1)=='@')
 	    {
-	      result+=c; 
+	      result+=c;
 	    }
 	    p+=2;
 	  }
@@ -2657,12 +2666,12 @@ static QCString removeMarkers(const char *s)
 	    char pc=c;
 	    c=*++p;
 	    if (c=='*') // start of C comment
-	    { 
+	    {
 	      while (*p && !(pc=='*' && c=='/')) // search end of comment
 	      {
-		if (*p=='@' && *(p+1)=='@') 
+		if (*p=='@' && *(p+1)=='@')
 		  result+=c,p++;
-		else 
+		else
 		  result+=c;
 		pc=c;
 		c=*++p;
@@ -2727,7 +2736,7 @@ static void addDefine(yyscan_t yyscanner)
   def.name       = state->defName;
   def.definition = state->defText.stripWhiteSpace();
   def.nargs      = state->defArgs;
-  def.fileName   = state->yyFileName; 
+  def.fileName   = state->yyFileName;
   def.fileDef    = state->yyFileDef;
   def.lineNr     = state->yyLineNr-state->yyMLines;
   def.columnNr   = state->yyColNr;
@@ -2735,7 +2744,7 @@ static void addDefine(yyscan_t yyscanner)
   //printf("newDefine: %s %s file: %s\n",def.name.data(),def.definition.data(),
   //    def.fileDef ? def.fileDef->name().data() : def.fileName.data());
   //printf("newDefine: '%s'->'%s'\n",def.name.data(),def.definition.data());
-  if (!def.name.isEmpty() && 
+  if (!def.name.isEmpty() &&
       Doxygen::expandAsDefinedSet.find(def.name.str())!=Doxygen::expandAsDefinedSet.end())
   {
     def.isPredefined=TRUE;
@@ -2751,7 +2760,7 @@ static void addDefine(yyscan_t yyscanner)
 static void addMacroDefinition(yyscan_t yyscanner)
 {
   YY_EXTRA_TYPE state = preYYget_extra(yyscanner);
-  if (state->skip) return; // do not add this define as it is inside a 
+  if (state->skip) return; // do not add this define as it is inside a
                       // conditional section (cond command) that is disabled.
 
   Define define;
@@ -2892,7 +2901,7 @@ static void readIncludeFile(yyscan_t yyscanner,const QCString &inc)
       //printf("Found include file!\n");
       if (Debug::isFlagSet(Debug::Preprocessor))
       {
-        for (i=0;i<state->includeStack.size();i++) 
+        for (i=0;i<state->includeStack.size();i++)
         {
           Debug::print(Debug::Preprocessor,0,"  ");
         }
@@ -2927,7 +2936,7 @@ static void readIncludeFile(yyscan_t yyscanner,const QCString &inc)
       state->includeStack.emplace_back(fs);
       // set the scanner to the include file
 
-      // Deal with file changes due to 
+      // Deal with file changes due to
       // #include's within { .. } blocks
       QCString lineStr(state->yyFileName.length()+20);
       lineStr.sprintf("# 1 \"%s\" 1\n",state->yyFileName.data());
@@ -2968,7 +2977,7 @@ static void readIncludeFile(yyscan_t yyscanner,const QCString &inc)
 
       if (Debug::isFlagSet(Debug::Preprocessor))
       {
-        for (i=0;i<state->includeStack.size();i++) 
+        for (i=0;i<state->includeStack.size();i++)
         {
           Debug::print(Debug::Preprocessor,0,"  ");
         }
@@ -3089,7 +3098,7 @@ static int getNextChar(yyscan_t yyscanner,const QCString &expr,QCString *rest,ui
     return cc;
   }
 }
- 
+
 static int getCurrentChar(yyscan_t yyscanner,const QCString &expr,QCString *rest,uint pos)
 {
   //printf("getCurrentChar(%s,%s,%d)\n",expr.data(),rest ? rest->data() : 0,pos);
@@ -3185,8 +3194,8 @@ static void initPredefined(yyscan_t yyscanner,const char *fileName)
       continue; // no define name
     }
 
-    if (i_obrace<i_equals && i_cbrace<i_equals && 
-        i_obrace!=-1      && i_cbrace!=-1      && 
+    if (i_obrace<i_equals && i_cbrace<i_equals &&
+        i_obrace!=-1      && i_cbrace!=-1      &&
         i_obrace<i_cbrace
        ) // predefined function macro definition
     {
@@ -3205,7 +3214,7 @@ static void initPredefined(yyscan_t yyscanner,const char *fileName)
       {
         //printf("predefined function macro '%s'\n",qPrint(ds.mid(i_obrace+1,i_cbrace-i_obrace-1)));
         i=i_obrace+1;
-        // gather the formal arguments in a dictionary 
+        // gather the formal arguments in a dictionary
         while (i<i_cbrace && (pi=reId.match(ds,i,&l)))
         {
           if (l>0) // see bug375037
@@ -3224,7 +3233,7 @@ static void initPredefined(yyscan_t yyscanner,const char *fileName)
       QCString tmp=ds.right(ds.length()-i_equals-1);
       QCString definition;
       i=0;
-      // substitute all occurrences of formal arguments by their 
+      // substitute all occurrences of formal arguments by their
       // corresponding markers
       while ((pi=reId.match(tmp,i,&l))!=-1)
       {
@@ -3355,20 +3364,20 @@ void Preprocessor::processFile(const char *fileName,BufStr &input,BufStr &output
 
   state->inputFileDef = state->yyFileDef;
   //yyextra->defineManager.startContext(state->yyFileName);
-  
+
   initPredefined(yyscanner,fileName);
- 
+
   state->yyLineNr = 1;
   state->yyColNr  = 1;
   state->ifcount  = 0;
 
   BEGIN( Start );
-  
+
   state->expectGuard = guessSection(fileName)==Entry::HEADER_SEC;
   state->guardName.resize(0);
   state->lastGuardName.resize(0);
   state->guardExpr.resize(0);
-  
+
   preYYlex(yyscanner);
 
   while (!state->condStack.empty())
@@ -3391,7 +3400,7 @@ void Preprocessor::processFile(const char *fileName,BufStr &input,BufStr &output
     Debug::print(Debug::Preprocessor,0,"Preprocessor output of %s (size: %d bytes):\n",fileName,newPos-orgPos);
     int line=1;
     Debug::print(Debug::Preprocessor,0,"---------\n00001 ");
-    while (orgPos<newPos) 
+    while (orgPos<newPos)
     {
       putchar(*orgPos);
       if (*orgPos=='\n') Debug::print(Debug::Preprocessor,0,"%05d ",++line);
diff --git a/src/scanner.l b/src/scanner.l
index 6970d3ea594..7edfc9b331c 100644
--- a/src/scanner.l
+++ b/src/scanner.l
@@ -6842,7 +6842,8 @@ static void setContext(yyscan_t yyscanner)
   yyextra->insideObjC  = yyextra->language==SrcLangExt_ObjC;
   yyextra->insideJS    = yyextra->language==SrcLangExt_JS;
   yyextra->insideSlice = yyextra->language==SrcLangExt_Slice;
-  yyextra->insideCpp   = yyextra->language==SrcLangExt_Cpp;
+  yyextra->insideCpp   = (yyextra->language==SrcLangExt_Cpp ||
+                          yyextra->language==SrcLangExt_Lex);
   //printf("setContext(%s) yyextra->insideIDL=%d yyextra->insideJava=%d yyextra->insideCS=%d "
   //       "yyextra->insideD=%d yyextra->insidePHP=%d yyextra->insideObjC=%d\n",
   //       yyextra->yyFileName.data(),yyextra->insideIDL,yyextra->insideJava,yyextra->insideCS,yyextra->insideD,yyextra->insidePHP,yyextra->insideObjC
@@ -7458,7 +7459,7 @@ bool COutlineParser::needsPreprocessing(const QCString &extension) const
 {
   QCString fe=extension.lower();
   SrcLangExt lang = getLanguageFromFileName(extension);
-  return (SrcLangExt_Cpp == lang) ||
+  return (SrcLangExt_Cpp == lang) || (SrcLangExt_Lex == lang) ||
    !( fe==".java" || fe==".as"  || fe==".d"    || fe==".php" ||
       fe==".php4" || fe==".inc" || fe==".phtml"|| fe==".php5"
     );
diff --git a/src/types.h b/src/types.h
index d34444c3675..3667f3d1424 100644
--- a/src/types.h
+++ b/src/types.h
@@ -57,7 +57,8 @@ enum SrcLangExt
   //SrcLangExt_Tcl      = 0x08000, // no longer supported
   SrcLangExt_Markdown = 0x10000,
   SrcLangExt_SQL      = 0x20000,
-  SrcLangExt_Slice    = 0x40000
+  SrcLangExt_Slice    = 0x40000,
+  SrcLangExt_Lex      = 0x100000
 };
 
 /** Grouping info */
diff --git a/src/util.cpp b/src/util.cpp
index 3bf349a8312..ad6b2081ebf 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -325,6 +325,7 @@ int guessSection(const char *name)
       n.right(4)==".i++"  ||
       n.right(4)==".inl"  ||
       n.right(4)==".xml"  ||
+      n.right(4)==".lex"  ||
       n.right(4)==".sql"
      ) return Entry::SOURCE_SEC;
   if (n.right(2)==".h"    || // header
@@ -5483,6 +5484,7 @@ g_lang2extMap[] =
   { "xml",         "xml",           SrcLangExt_XML      },
   { "sql",         "sql",           SrcLangExt_SQL      },
   { "md",          "md",            SrcLangExt_Markdown },
+  { "lex",         "lex",           SrcLangExt_Lex      },
   { 0,             0,              (SrcLangExt)0        }
 };
 
@@ -5580,6 +5582,9 @@ void initDefaultExtensionMapping()
   updateLanguageMapping(".md",       "md");
   updateLanguageMapping(".markdown", "md");
   updateLanguageMapping(".ice",      "slice");
+  updateLanguageMapping(".l",        "lex");
+  updateLanguageMapping(".doxygen_lex_c", "c"); // this is a placeholder so we can map initializations
+                                                // in the lex scanning to cpp
 }
 
 void addCodeOnlyMappings()
@@ -6592,6 +6597,7 @@ QCString langToString(SrcLangExt lang)
     case SrcLangExt_SQL:      return "SQL";
     case SrcLangExt_Markdown: return "Markdown";
     case SrcLangExt_Slice:    return "Slice";
+    case SrcLangExt_Lex:      return "Lex";
   }
   return "Unknown";
 }