src/cscanner.l

   1 /*;-*-C-*-;
   2 ** Splint - annotation-assisted static program checker
   3 ** Copyright (C) 1994-2003 University of Virginia,
   4 **         Massachusetts Institute of Technology
   5 **
   6 ** This program is free software; you can redistribute it and/or modify it
   7 ** under the terms of the GNU General Public License as published by the
   8 ** Free Software Foundation; either version 2 of the License, or (at your
   9 ** option) any later version.
  10 **
  11 ** This program is distributed in the hope that it will be useful, but
  12 ** WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 ** General Public License for more details.
  15 **
  16 ** The GNU General Public License is available from http://www.gnu.org/ or
  17 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 ** MA 02111-1307, USA.
  19 **
  20 ** For information on splint: splint@cs.virginia.edu
  21 ** To report a bug: splint-bug@cs.virginia.edu
  22 ** For more information: http://www.splint.org
  23 */
  24 /*
  25 ** cscanner.l
  26 **
  27 ** Flex lexer for C.
  28 ** Based on a C lexer by Nate Osgood
  29 **    from hacrat@catfish.lcs.mit.edu Mon Jun 14 13:06:32 1993
  30 */
  31 /*
  32 ** Modified by Herbert 08/19/97:
  33 ** - added #include for IBM's OS/2 compiler.
  34 ** - fixed weird bug with lookup of tmp files (OS/2 and MSDOS only).
  35 */
  36 /*
  37 ** Modified by Mike Smith
  38 ** Corrected missing 'line' in scanf() calls in handleSpecial().
  39 ** Without this, I get an error when Splint hits a '#line' directive
  40 ** in the pre-pre-processed source files. For safety, I have made these
  41 ** conditional on OS2 and MSDOS because I don't understand why noone else
  42 ** has seen this problem.
  43 **
  44 ** Modified by Mike Smith, 4th June 1997
  45 ** Finally resolved the #line problem.  The scanf() calls have been fixed to
  46 ** allow the following #line forms:-
  47 **
  48 **        #line 123 "filename"
  49 **        #line 123
  50 **        # 123 "filename"
  51 **        # 123
  52 **
  53 ** The last two are generated by the GNU pre-processor, apparently
  54 */
  55
  56 Digit                   [0-9]
  57 Letter                  [a-zA-Z_$]
  58 H                       [a-fA-F0-9]
  59 E                       [Ee][+-]?{Digit}+
  60 U                       (u|U)
  61 L                       (l|L)
  62 FS                      (f|F|l|L)
  63 IS                      (u|U|l|L)*
  64 ULSuffix                ({U}{L}|{L}{U})
  65
  66 %{
  67 # include "splintMacros.nf"
  68 # if defined(OS2) && defined(__IBMC__)
  69    /* needed for isatty()... */
  70 # include <io.h>
  71 # else
  72
  73 /*
  74 ** Win32 doesn't have unistd.h
  75 */
  76
  77 # ifndef WIN32
  78 # include <unistd.h>
  79 # endif
  80
  81 # endif
  82
  83 # include "basic.h"
  84
  85 # include "cscannerHelp.h"
  86 # include "cgrammar.h"
  87 # include "cgrammar_tokens.h"
  88 # include "portab.h"
  89
  90 /*@notfunction@*/
  91 # define yyinput() (incColumn (), getc (yyin))
  92
  93 # include "flex.head"
  94
  95 %}
  96
  97 %%
  98
  99 "/*"            { llfatalerror (cstring_makeLiteral ("Comment in pre-processor output")); }
 100
 101 "#"{Letter}({Letter}|{Digit})*  {
 102                  context_saveLocation ();
 103                  cscannerHelp_setTokLength (longUnsigned_toInt (mstring_length (yytext)));
 104
 105                  if (cscannerHelp_processHashIdentifier
 106                      (cscannerHelp_makeIdentifier (yytext + 1)))
 107                    {
 108                      return cscannerHelp_returnString (cstring_makeLiteral ("\"\""));
 109                    }
 110                  else
 111                    {
 112                      if (cscannerHelp_handleSpecial (yytext))
 113                        {
 114                          cscannerHelp_setTokLength (1);
 115                          return cscannerHelp_returnToken (0);
 116                        }
 117                    }
 118                 }
 119 "#"             { if (cscannerHelp_handleSpecial (yytext))
 120                     {
 121                        cscannerHelp_setTokLength (1); return cscannerHelp_returnToken (0);
 122                      }
 123                 }
 124 "..."           { cscannerHelp_setTokLength (3); return cscannerHelp_returnToken (CTOK_ELIPSIS); }
 125 "break"         { cscannerHelp_setTokLength (5); return cscannerHelp_returnToken (BREAK); }
 126 "case"          { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (CASE); }
 127 "continue"      { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (CONTINUE); }
 128 "default"       { cscannerHelp_setTokLength (7); return cscannerHelp_returnToken (DEFAULT); }
 129 "do"            { cscannerHelp_setTokLength (2); return cscannerHelp_returnToken (DO); }
 130 "else"          { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (CELSE); }
 131 "for"           { cscannerHelp_setTokLength (3); return cscannerHelp_returnToken (CFOR); }
 132 "goto"          { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (GOTO); }
 133 "if"            { cscannerHelp_setTokLength (2); return cscannerHelp_returnToken (CIF); }
 134 "return"        { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (RETURN); }
 135 "sizeof"        { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (CSIZEOF); }
 136 "offsetof"      { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (COFFSETOF); }
 137 "switch"        { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (SWITCH); }
 138 "while"         { cscannerHelp_setTokLength (5); return cscannerHelp_returnToken (WHILE); }
 139 "va_arg"        { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (VA_ARG); }
 140 "va_dcl"        { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (VA_DCL); }
 141 "inline"        {
 142                   /* gcc extension...this might not be appropriate */
 143                   cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (QINLINE); }
 144
 145 "struct"        { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (CSTRUCT); }
 146 "typedef"       { cscannerHelp_setTokLength (7); return cscannerHelp_returnToken (CTYPEDEF); }
 147
 148 "union"         { cscannerHelp_setTokLength (5); return cscannerHelp_returnToken (CUNION); }
 149 "enum"          { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (CENUM); }
 150
 151 "void"          { cscannerHelp_setTokLength (4); return cscannerHelp_returnType (CVOID, ctype_void); }
 152 "int"           { cscannerHelp_setTokLength (3); return cscannerHelp_returnType (CINT, ctype_int); }
 153 "double"        { cscannerHelp_setTokLength (6); return cscannerHelp_returnType (CDOUBLE, ctype_double); }
 154 "char"          { cscannerHelp_setTokLength (4); return cscannerHelp_returnType (CGCHAR, ctype_char); }
 155 "float"         { cscannerHelp_setTokLength (5); return cscannerHelp_returnType (CGFLOAT, ctype_float); }
 156
 157 "long"          { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (QLONG); }
 158 "short"         { cscannerHelp_setTokLength (5); return cscannerHelp_returnToken (QSHORT); }
 159 "unsigned"      { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (QUNSIGNED); }
 160 "signed"        { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (QSIGNED); }
 161
 162 "volatile"      { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (QVOLATILE); }
 163 "const"         { cscannerHelp_setTokLength (5); return cscannerHelp_returnToken (QCONST); }
 164 "restrict"      { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (QRESTRICT); }
 165
 166                         /* some systems expect this! [gack!] */
 167 "__const"       { cscannerHelp_setTokLength (7); return cscannerHelp_returnToken (QCONST); }
 168
 169 "extern"        { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (QEXTERN); }
 170 "auto"          { cscannerHelp_setTokLength (4); return cscannerHelp_returnToken (QAUTO); }
 171 "register"      { cscannerHelp_setTokLength (8); return cscannerHelp_returnToken (QREGISTER); }
 172 "static"        { cscannerHelp_setTokLength (6); return cscannerHelp_returnToken (QSTATIC); }
 173
 174 \"(\\.|[^\\"])*\"([ \t\n]*\"(\\.|[^\\"])*\")* { return cscannerHelp_returnExpr (cscannerHelp_processString ()); }
 175 L\"(\\.|[^\\"])*\"([ \t\n]*\"(\\.|[^\\"])*\")* { return cscannerHelp_returnExpr (cscannerHelp_processWideString ()); }
 176 "out"                   { return (cscannerHelp_processSpec (QOUT)); }
 177 "in"                    { return (cscannerHelp_processSpec (QIN)); }
 178 "partial"               { return (cscannerHelp_processSpec (QPARTIAL)); }
 179 "special"               { return (cscannerHelp_processSpec (QSPECIAL)); }
 180 "anytype"               { return (cscannerHelp_processSpec (QANYTYPE)); }
 181 "integraltype"          { return (cscannerHelp_processSpec (QINTEGRALTYPE)); }
 182 "unsignedintegraltype"  { return (cscannerHelp_processSpec (QUNSIGNEDINTEGRALTYPE)); }
 183 "signedintegraltype"    { return (cscannerHelp_processSpec (QSIGNEDINTEGRALTYPE)); }
 184 "keep"                  { return (cscannerHelp_processSpec (QKEEP)); }
 185 "null"                  { return (cscannerHelp_processSpec (QNULL)); }
 186 "notnull"               { return (cscannerHelp_processSpec (QNOTNULL)); }
 187 "isnull"                { return (cscannerHelp_processSpec (QISNULL)); }
 188 "truenull"              { return (cscannerHelp_processSpec (QTRUENULL)); }
 189 "falsenull"             { return (cscannerHelp_processSpec (QFALSENULL)); }
 190 "nullwhentrue"          { return (cscannerHelp_processSpec (QTRUENULL)); }
 191 "nullwhenfalse"         { return (cscannerHelp_processSpec (QFALSENULL)); }
 192 "relnull"               { return (cscannerHelp_processSpec (QRELNULL)); }
 193 "reldef"                { return (cscannerHelp_processSpec (QRELDEF)); }
 194 "exposed"               { return (cscannerHelp_processSpec (QEXPOSED)); }
 195 "newref"                { return (cscannerHelp_processSpec (QNEWREF)); }
 196 "tempref"               { return (cscannerHelp_processSpec (QTEMPREF)); }
 197 "killref"               { return (cscannerHelp_processSpec (QKILLREF)); }
 198 "refcounted"            { return (cscannerHelp_processSpec (QREFCOUNTED)); }
 199 "checked"               { return (cscannerHelp_processSpec (QCHECKED)); }
 200 "checkmod"              { return (cscannerHelp_processSpec (QCHECKMOD)); }
 201 "checkedstrict"         { return (cscannerHelp_processSpec (QCHECKEDSTRICT)); }
 202 "unchecked"             { return (cscannerHelp_processSpec (QUNCHECKED)); }
 203 "only"                  { return (cscannerHelp_processSpec (QONLY)); }
 204 "owned"                 { return (cscannerHelp_processSpec (QOWNED)); }
 205 "observer"              { return (cscannerHelp_processSpec (QOBSERVER)); }
 206 "dependent"             { return (cscannerHelp_processSpec (QDEPENDENT)); }
 207 "unused"                { return (cscannerHelp_processSpec (QUNUSED)); }
 208 "external"              { return (cscannerHelp_processSpec (QEXTERNAL)); }
 209 "sef"                   { return (cscannerHelp_processSpec (QSEF)); }
 210 "shared"                { return (cscannerHelp_processSpec (QSHARED)); }
 211 "yield"                 { return (cscannerHelp_processSpec (QYIELD)); }
 212 "undef"                 { return (cscannerHelp_processSpec (QUNDEF)); }
 213 "killed"                { return (cscannerHelp_processSpec (QKILLED)); }
 214 "nullterminated"        { return (cscannerHelp_processSpec (QNULLTERMINATED));}
 215 "MaxSet"                { return (cscannerHelp_processSpec (QMAXSET));}
 216 "MaxRead"               { return (cscannerHelp_processSpec (QMAXREAD));}
 217 "maxSet"                { return (cscannerHelp_processSpec (QMAXSET));}
 218 "maxRead"               { return (cscannerHelp_processSpec (QMAXREAD));}
 219
 220 {Letter}({Letter}|{Digit})* { int tok = cscannerHelp_processTextIdentifier (yytext);
 221                               if (tok != BADTOK)
 222                                 {
 223                                   return (tok);
 224                                 }
 225                             }
 226 0[xX]{H}+               { cscannerHelp_setTokLengthT (mstring_length (yytext));
 227                           return cscannerHelp_returnInt (ctype_int, cscannerHelp_processHex ());  /* evs 2000-05-17 was ctype_uint */
 228                         }
 229 0[xX]{H}+{L}            { cscannerHelp_setTokLengthT (mstring_length (yytext));
 230                           return cscannerHelp_returnInt (ctype_lint, cscannerHelp_processHex ()); }
 231 0[xX]{H}+{L}{L}         { cscannerHelp_setTokLengthT (mstring_length (yytext));
 232                           return cscannerHelp_returnInt (ctype_llint, cscannerHelp_processHex ()); }
 233 0[xX]{H}+{U}            { cscannerHelp_setTokLengthT (mstring_length (yytext));
 234                           return cscannerHelp_returnInt (ctype_uint, cscannerHelp_processHex ()); }
 235 0[xX]{H}+{ULSuffix}     { cscannerHelp_setTokLengthT (mstring_length (yytext));
 236                           return cscannerHelp_returnInt (ctype_ulint, cscannerHelp_processHex ()); }
 237 0[xX]{H}+{U}{L}{L}      { cscannerHelp_setTokLengthT (mstring_length (yytext));
 238                           return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processHex ()); }
 239 0[xX]{H}+{L}{L}{U}      { cscannerHelp_setTokLengthT (mstring_length (yytext));
 240                           return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processHex ()); }
 241 0{Digit}+               { cscannerHelp_setTokLengthT (mstring_length (yytext));
 242                           return cscannerHelp_returnInt (ctype_int, cscannerHelp_processOctal ()); }
 243 0{Digit}+{U}            { cscannerHelp_setTokLengthT (mstring_length (yytext));
 244                           return cscannerHelp_returnInt (ctype_uint, cscannerHelp_processOctal ()); }
 245 0{Digit}+{L}            { cscannerHelp_setTokLengthT (mstring_length (yytext));
 246                           return cscannerHelp_returnInt (ctype_lint, cscannerHelp_processOctal ()); }
 247 0{Digit}+{L}{L}         { cscannerHelp_setTokLengthT (mstring_length (yytext));
 248                           return cscannerHelp_returnInt (ctype_llint, cscannerHelp_processOctal ()); }
 249 0{Digit}+{ULSuffix}     { cscannerHelp_setTokLengthT (mstring_length (yytext));
 250                           return cscannerHelp_returnInt (ctype_ulint, cscannerHelp_processOctal ()); }
 251 0{Digit}+{U}{L}{L}      { cscannerHelp_setTokLengthT (mstring_length (yytext));
 252                           return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processOctal ()); }
 253 0{Digit}+{L}{L}{U}      { cscannerHelp_setTokLengthT (mstring_length (yytext));
 254                           return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processOctal ()); }
 255 {Digit}+               { cscannerHelp_setTokLengthT (mstring_length (yytext));
 256                          return cscannerHelp_returnInt (ctype_int, cscannerHelp_processDec ()); }
 257 {Digit}+{U}            { cscannerHelp_setTokLengthT (mstring_length (yytext));
 258                          return cscannerHelp_returnInt (ctype_uint, cscannerHelp_processDec ()); }
 259 {Digit}+{L}            { cscannerHelp_setTokLengthT (mstring_length (yytext));
 260                          return cscannerHelp_returnInt (ctype_lint, cscannerHelp_processDec ()); }
 261 {Digit}+{L}{L}         { cscannerHelp_setTokLengthT (mstring_length (yytext));
 262                          return cscannerHelp_returnInt (ctype_llint, cscannerHelp_processDec ()); }
 263 {Digit}+{ULSuffix}     { cscannerHelp_setTokLengthT (mstring_length (yytext));
 264                          return cscannerHelp_returnInt (ctype_ulint, cscannerHelp_processDec ()); }
 265 {Digit}+{U}{L}{L}      { cscannerHelp_setTokLengthT (mstring_length (yytext));
 266                          return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processDec ()); }
 267 {Digit}+{L}{L}{U}      { cscannerHelp_setTokLengthT (mstring_length (yytext));
 268                          return cscannerHelp_returnInt (ctype_ullint, cscannerHelp_processDec ()); }
 269 '(\\.|[^\\'])+'        { cscannerHelp_setTokLengthT (mstring_length (yytext));
 270                          return cscannerHelp_returnChar (cscannerHelp_processChar ()); }
 271 L'(\\.|[^\\'])+'       { cscannerHelp_setTokLengthT (mstring_length (yytext));
 272                          return cscannerHelp_returnChar (cscannerHelp_processChar ()); }
 273 {Digit}+{E}[fF]        { cscannerHelp_setTokLengthT (mstring_length (yytext));
 274                          return cscannerHelp_returnFloat (ctype_float, cscannerHelp_processFloat ()); }
 275 {Digit}+{E}[lL]        { cscannerHelp_setTokLengthT (mstring_length (yytext));
 276                          return cscannerHelp_returnFloat (ctype_ldouble, cscannerHelp_processFloat ()); }
 277 {Digit}+{E}            { cscannerHelp_setTokLengthT (mstring_length (yytext));
 278                          return cscannerHelp_returnFloat (ctype_double, cscannerHelp_processFloat ()); }
 279
 280 {Digit}*"."{Digit}+({E})?[fF] { cscannerHelp_setTokLengthT (mstring_length (yytext));
 281                                 return cscannerHelp_returnFloat (ctype_float, cscannerHelp_processFloat ()); }
 282 {Digit}*"."{Digit}+({E})?[lL] { cscannerHelp_setTokLengthT (mstring_length (yytext));
 283                                 return cscannerHelp_returnFloat (ctype_ldouble, cscannerHelp_processFloat ()); }
 284 {Digit}*"."{Digit}+({E})?     { cscannerHelp_setTokLengthT (mstring_length (yytext));
 285                                 return cscannerHelp_returnFloat (ctype_double, cscannerHelp_processFloat ()); }
 286
 287 {Digit}+"."{Digit}*({E})?[fF]   { cscannerHelp_setTokLengthT (mstring_length (yytext));
 288                                   return cscannerHelp_returnFloat (ctype_float, cscannerHelp_processFloat ()); }
 289 {Digit}+"."{Digit}*({E})?[lL]   { cscannerHelp_setTokLengthT (mstring_length (yytext));
 290                                   return cscannerHelp_returnFloat (ctype_ldouble, cscannerHelp_processFloat ()); }
 291 {Digit}+"."{Digit}*({E})?       { cscannerHelp_setTokLengthT (mstring_length (yytext));
 292                                   return cscannerHelp_returnFloat (ctype_double, cscannerHelp_processFloat ()); }
 293
 294 ">>="           { return cscannerHelp_returnTokenLength (RIGHT_ASSIGN, 3); }
 295 "<<="           { return cscannerHelp_returnTokenLength (LEFT_ASSIGN, 3); }
 296 "+="            { return cscannerHelp_returnTokenLength (ADD_ASSIGN, 2); }
 297 "-="            { return cscannerHelp_returnTokenLength (SUB_ASSIGN, 2); }
 298 "*="            { return cscannerHelp_returnTokenLength (MUL_ASSIGN, 2); }
 299 "/="            { return cscannerHelp_returnTokenLength (DIV_ASSIGN, 2); }
 300 "%="            { return cscannerHelp_returnTokenLength (MOD_ASSIGN, 2); }
 301 "&="            { return cscannerHelp_returnTokenLength (AND_ASSIGN, 2); }
 302 "^="            { return cscannerHelp_returnTokenLength (XOR_ASSIGN, 2); }
 303 "|="            { return cscannerHelp_returnTokenLength (OR_ASSIGN, 2); }
 304 ">>"            { return cscannerHelp_returnTokenLength (RIGHT_OP, 2); }
 305 "<<"            { return cscannerHelp_returnTokenLength (LEFT_OP, 2); }
 306 "++"            { return cscannerHelp_returnTokenLength (INC_OP, 2); }
 307 "--"            { return cscannerHelp_returnTokenLength (DEC_OP, 2); }
 308 "->"            { return cscannerHelp_returnTokenLength (ARROW_OP, 2); }
 309 "&&"            { return cscannerHelp_returnTokenLength (AND_OP, 2); }
 310 "||"            { return cscannerHelp_returnTokenLength (OR_OP, 2); }
 311 "/\\"           { return cscannerHelp_returnTokenLength (TCAND, 2); }
 312 "<="            { return cscannerHelp_returnTokenLength (LE_OP, 2); }
 313 ">="            { return cscannerHelp_returnTokenLength (GE_OP, 2); }
 314 "=="            { return cscannerHelp_returnTokenLength (EQ_OP, 2); }
 315 "!="            { return cscannerHelp_returnTokenLength (NE_OP, 2); }
 316 ";"             { return cscannerHelp_returnTokenLength (TSEMI, 1); }
 317 "{"             { return cscannerHelp_returnTokenLength (TLBRACE, 1); }
 318 "}"             { return cscannerHelp_returnTokenLength (TRBRACE, 1); }
 319 ","             { return cscannerHelp_returnTokenLength (TCOMMA, 1); }
 320 ":"             { return cscannerHelp_returnTokenLength (TCOLON, 1); }
 321 "="             { return cscannerHelp_returnTokenLength (TASSIGN, 1); }
 322 "("             { return cscannerHelp_returnTokenLength (TLPAREN, 1); }
 323 ")"             { return cscannerHelp_returnTokenLength (TRPAREN, 1); }
 324 "["             { return cscannerHelp_returnTokenLength (TLSQBR, 1); }
 325 "]"             { return cscannerHelp_returnTokenLength (TRSQBR, 1); }
 326 "."             { return cscannerHelp_returnTokenLength (TDOT, 1); }
 327 "&"             { return cscannerHelp_returnTokenLength (TAMPERSAND, 1); }
 328 "!"             { return cscannerHelp_returnTokenLength (TEXCL, 1); }
 329 "~"             { return cscannerHelp_returnTokenLength (TTILDE, 1); }
 330 "-"             { return cscannerHelp_returnTokenLength (TMINUS, 1); }
 331 "+"             { return cscannerHelp_returnTokenLength (TPLUS, 1); }
 332 "*"             { return cscannerHelp_returnTokenLength (TMULT, 1); }
 333 "/"             { return cscannerHelp_returnTokenLength (TDIV, 1); }
 334 "%"             { return cscannerHelp_returnTokenLength (TPERCENT, 1); }
 335 "<"             { return cscannerHelp_returnTokenLength (TLT, 1); }
 336 ">"             { return cscannerHelp_returnTokenLength (TGT, 1); }
 337 "^"             { return cscannerHelp_returnTokenLength (TCIRC, 1); }
 338 "|"             { return cscannerHelp_returnTokenLength (TBAR, 1); }
 339 "?"             { return cscannerHelp_returnTokenLength (TQUEST, 1); }
 340
 341 [ \t\v\f]       { incColumn (); }
 342 \n              { int tok = cscannerHelp_handleNewLine ();
 343                   if (tok != BADTOK) return tok; }
 344 "@@MR@@"        { cscannerHelp_setTokLength (6);
 345
 346                   if (cscannerHelp_processMacro ()) {
 347                     if (context_inIterDef ())
 348                       {
 349                         return cscannerHelp_returnToken (LLMACROITER);
 350                       }
 351                     if (context_inIterEnd ())
 352                       {
 353                         return cscannerHelp_returnToken (LLMACROEND);
 354                       }
 355                     if (context_inMacro ())
 356                       {
 357                         return cscannerHelp_returnToken (LLMACRO);
 358                       }
 359                   }
 360                 }
 361 "@QLMR"         { if (context_inHeader () || context_inFunction ())
 362                     {
 363                       cscannerHelp_handleMacro ();
 364                     }
 365                   else
 366                     {
 367                       int nspchar = cscannerHelp_ninput ();
 368                       int nspaces;
 369
 370                       /*
 371                       ** This is a hack to get the column number correct.
 372                       */
 373
 374                       llassert (nspchar >= '0' && nspchar <= '9');
 375
 376                       nspaces = nspchar - '0';
 377
 378                       cscannerHelp_setTokLength (5 + nspaces);
 379
 380                       if (cscannerHelp_processMacro ())
 381                         {
 382                           DPRINTF (("Here we are: %s", context_unparse ()));
 383
 384                           if (context_inIterDef ())
 385                             {
 386                               return cscannerHelp_returnToken (LLMACROITER);
 387                             }
 388                           if (context_inIterEnd ())
 389                             {
 390                               return cscannerHelp_returnToken (LLMACROEND);
 391                             }
 392                           if (context_inMacro ())
 393                             {
 394                               return cscannerHelp_returnToken (LLMACRO);
 395                             }
 396                         }
 397                     }
 398                 }
 399 "@.CT"          { cscannerHelp_setTokLength (4); lldiagmsg (ctype_unparseTable ()); }
 400 "@.FA"          { cscannerHelp_setTokLength (4); lldiagmsg (message ("Access types: %q", typeIdSet_unparse (context_fileAccessTypes ()))); }
 401 "@.F"           { cscannerHelp_setTokLength (3);
 402                   lldiagmsg (message ("%q: *** marker ***", fileloc_unparse (g_currentloc)));
 403                 }
 404 "@.L"           { cscannerHelp_setTokLength (3); usymtab_printLocal (); }
 405 "@.A"           { cscannerHelp_setTokLength (3); lldiagmsg (usymtab_unparseAliases ()); }
 406 "@.C"           { cscannerHelp_setTokLength (3); lldiagmsg (context_unparse ()); }
 407 "@.W"           { cscannerHelp_setTokLength (3); lldiagmsg (context_unparseClauses ()); }
 408 "@.G"           { cscannerHelp_setTokLength (3); usymtab_printGuards (); }
 409 "@.S"           { cscannerHelp_setTokLength (3); usymtab_printOut (); }
 410 "@.X"           { cscannerHelp_setTokLength (3); usymtab_printAll (); }
 411 "@.Z"           { cscannerHelp_setTokLength (3); usymtab_printComplete (); }
 412 "@.T"           { cscannerHelp_setTokLength (3); usymtab_printTypes (); }
 413 "@.K"           { cscannerHelp_setTokLength (3); lldiagmsg (usymtab_unparseStack ()); }
 414 "@.M"           { cscannerHelp_setTokLength (3);
 415                   lldiagmsg (message ("Can modify: %q",
 416                                   sRefSet_unparse (context_modList ())));
 417                 }
 418 "%{"            { /* BEFORE_COMMENT_MARKER */
 419                   int tok;
 420                   incColumn (); incColumn ();
 421                   tok = cscannerHelp_handleLlSpecial ();
 422
 423                   if (tok != BADTOK)
 424                     {
 425                       if (tok == CANNOTATION) {
 426                         return (tok);
 427                       } else {
 428                         /* Beware - this bashes yylval! */
 429                         return cscannerHelp_returnToken (tok);
 430                       }
 431                     }
 432                 }
 433 "%}"            { /* AFTER_COMMENT_MARKER */
 434                   cscannerHelp_setTokLength (2);
 435                   cscannerHelp_exitSpecPart ();
 436                   return cscannerHelp_returnToken (QENDMACRO); }
 437 "\\"            { incColumn (); cscannerHelp_setContinueLine (); }
 438 .               { incColumn ();
 439                   if ((int) *yytext == 13 ) {
 440                      ;
 441                   } else {
 442                     voptgenerror
 443                       (FLG_SYNTAX,
 444                        message ("Invalid character (ascii: %d), skipping character",
 445                                 (int)(*yytext)),
 446                        g_currentloc);
 447                   }
 448                 }
 449 %%
 450
 451 /*
 452 ** These need to go here, after flex-generated code defined input and unput.
 453 */
 454
 455 int cscanner_input (void)
 456 {
 457   return input (); /* input is a static procedure defined by flex-generated code */
 458 }
 459
 460 void cscanner_unput (int c)
 461 {
 462   unput (c); /* unput is a static procedure defined by flex-generated code */
 463 }
 464
 465
 466