
{BL}\|                          return Parser::ORNL;

{BL}[^[:space:]]                {
                                    if (int token = inspectBlock())
                                        return token;
                                }

{BL}                            {   // skip white space unless in a block
                                    if (d_inBlock)
                                        return ' ';
                                }

<INITIAL,pre>{
    {OPTBL}"//".*               // skip EOLN comment

    ^"//include"[[:blank:]].*   maybeSwitchStream();

    {OPTBL}"/*"                 push(StartCondition__::comment);

    \"                          {
                                    more();
                                    push(StartCondition__::string);
                                }

    {IDENTIFIER}                return Parser::IDENTIFIER;


    \n{OPTBL}                   return '\n';

    =                           return '=';
}

<comment>{
    .|\n                        // ignore
    "*/"                        {
                                    popSc();
                                    push(' ');
                                }
}

<string>{
    "\\".                       more();
    \"                          return popSc(Parser::STRING);
    .                           more();
}

    // A quote is 
    //      1. a single quote followed by 
    //      2. either an escape sequence or a single character not being 
    //          a newline, quote, or backslash
    //      3. a single quote
    // In all other cases a quote is returned as a literal quote.
\'({ESCAPE_SEQUENCE}|[^\n'\\])\'    return Parser::QUOTES;

{DECIMAL}                       return Parser::DECIMAL;

{ESCAPE_SEQUENCE}               return Parser::ESCAPE_SEQUENCE;

"{+}"                           return Parser::CC_PLUS;

"{-}"                           return Parser::CC_MINUS;
        
"["                             |
"[]"                            |   
"[]["                           return Parser::CC_START;

"[^"                            |
"[^]"                           |
"[^]["                          return Parser::CC_NEGATED;

"[:"\^?"alnum:]"                |
"[:"\^?"alpha:]"                |
"[:"\^?"blank:]"                |
"[:"\^?"cntrl:]"                |
"[:"\^?"digit:]"                |
"[:"\^?"graph:]"                |
"[:"\^?"lower:]"                |
"[:"\^?"print:]"                |
"[:"\^?"punct:]"                |
"[:"\^?"space:]"                |
"[:"\^?"upper:]"                |
"[:"\^?"xdigit:]"               return Parser::PREDEFINED_CLASS;

"<<EOF>>"                       return Parser::EOF_PATTERN;

\{{IDENTIFIER}\}                pushNameExpansion();

                                    // return special chars as themselves
[]['.,^$/|()*+?{}<>-]           return matched()[0];

                                    // return other chars as CHAR
.                               return Parser::CHAR;

<pre>{
    {BL}                        // skip white space

    %%                          {
                                    switchToINITIAL();
                                    return Parser::SECTION_DELIMITER;
                                }

    %baseclass-header           return Parser::BASECLASSHEADER;
    %class-header               return Parser::CLASSHEADER;
    %class-name                 return Parser::CLASSNAME;
    %debug                      return Parser::DEBUG;
    %debug-steps                return Parser::DEBUG_STEPS;
    %implementation-header      return Parser::IMPLEMENTATIONHEADER;
    %input-implementation       return Parser::INPUTIMPLEMENTATION;
    %input-interface            return Parser::INPUTINTERFACE;
    %interactive                return Parser::INTERACTIVE;
    %lex-function-name          return Parser::LEXFUNCTIONNAME;
    %lex-source                 return Parser::LEXSOURCE;
    %no-lines                   return Parser::NOLINES;
    %namespace                  return Parser::NAMESPACE;
    %skeleton-directory         return Parser::SKELETON_DIRECTORY;
    "%s"                        return Parser::INCL_START_CONDITION;
    "%x"                        return Parser::EXCL_START_CONDITION;

    .                           return matched()[0];
}

<line>.*                        return Parser::STRING;
<line>\n                        return popSc('\n');



