wrfv2_fire/chem/KPP/kpp/kpp-2.1/src/scan.l

   1 /******************************************************************************
   2
   3   KPP - The Kinetic PreProcessor
   4         Builds simulation code for chemical kinetic systems
   5
   6   Copyright (C) 1995-1996 Valeriu Damian and Adrian Sandu
   7   Copyright (C) 1997-2005 Adrian Sandu
   8
   9   KPP is free software; you can redistribute it and/or modify it under the
  10   terms of the GNU General Public License as published by the Free Software
  11   Foundation (http://www.gnu.org/copyleft/gpl.html); either version 2 of the
  12   License, or (at your option) any later version.
  13
  14   KPP is distributed in the hope that it will be useful, but WITHOUT ANY
  15   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  16   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  17   details.
  18
  19   You should have received a copy of the GNU General Public License along
  20   with this program; if not, consult http://www.gnu.org/copyleft/gpl.html or
  21   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22   Boston, MA  02111-1307,  USA.
  23
  24   Adrian Sandu
  25   Computer Science Department
  26   Virginia Polytechnic Institute and State University
  27   Blacksburg, VA 24060
  28   E-mail: sandu@cs.vt.edu
  29
  30 ******************************************************************************/
  31
  32
  33
  34 %s CMD_STATE INC_STATE MOD_STATE INT_STATE
  35 %s PRM_STATE DSP_STATE SSP_STATE INI_STATE EQN_STATE EQNTAG_STATE
  36 %s RATE_STATE LMP_STATE CR_IGNORE SC_IGNORE ATM_STATE LKT_STATE INL_STATE
  37 %s MNI_STATE TPT_STATE USE_STATE
  38 %s COMMENT COMMENT2 EQN_ID
  39 %x INL_CODE
  40
  41 %{
  42   #include "gdata.h"
  43   #include "scan.h"
  44   #include "y.tab.h"
  45
  46   void Include ( char * filename );
  47   int EndInclude();
  48
  49   int crt_line_no = 1;
  50   char *crt_filename;
  51
  52   #define MAX_INCLUDE 10
  53
  54   YY_BUFFER_STATE yy_buffers[ MAX_INCLUDE ];
  55   int yy_line_no[ MAX_INCLUDE ];
  56   char *yy_filename[ MAX_INCLUDE ];
  57   int yy_buf_level = 0;
  58
  59   char crtToken[100];
  60   char nextToken[100];
  61   int crtTokType;
  62   int nextTokType;
  63   int crtLine;
  64   char crtFile[100];
  65   char crt_rate[100];
  66
  67   int oldnErr = 0;
  68
  69   int idx;
  70   int oldstate;
  71   extern int yyerrflag;
  72
  73   typedef struct {
  74                    char *name;
  75                    int next;
  76                    int cmd;
  77                  } KEYWORD;
  78
  79   KEYWORD keywords[] = { { "INCLUDE",    INC_STATE, 0 },
  80                          { "MODEL",      MOD_STATE, 0 },
  81                          { "INTEGRATOR", INT_STATE, 0 },
  82                          { "JACOBIAN",   PRM_STATE, JACOBIAN },
  83                          { "HESSIAN",    PRM_STATE, HESSIAN },
  84                          { "STOICMAT",   PRM_STATE, STOICMAT },
  85                          { "STOCHASTIC", PRM_STATE, STOCHASTIC },
  86                          { "DOUBLE",     PRM_STATE, DOUBLE },
  87                          { "REORDER",    PRM_STATE, REORDER },
  88                          { "MEX",        PRM_STATE, MEX },
  89                          { "DUMMYINDEX", PRM_STATE, DUMMYINDEX},
  90                          { "EQNTAGS",    PRM_STATE, EQNTAGS},
  91                          { "FUNCTION",   PRM_STATE, FUNCTION },
  92                          { "ATOMS",      ATM_STATE, ATOMDECL },
  93                          { "CHECK",      ATM_STATE, CHECK },
  94                          { "CHECKALL",   INITIAL,   CHECKALL },
  95                          { "DEFVAR",     DSP_STATE, DEFVAR },
  96                          { "DEFRAD",     DSP_STATE, DEFRAD },
  97                          { "DEFFIX",     DSP_STATE, DEFFIX },
  98                          { "SETVAR",     SSP_STATE, SETVAR },
  99                          { "SETRAD",     SSP_STATE, SETRAD },
 100                          { "SETFIX",     SSP_STATE, SETFIX },
 101                          { "INITVALUES", INI_STATE, INITVALUES },
 102                          { "EQUATIONS",  EQN_STATE, EQUATIONS },
 103                          { "LUMP",       LMP_STATE, LUMP },
 104                          { "LOOKAT",     LKT_STATE, LOOKAT },
 105                          { "LOOKATALL",  INITIAL,   LOOKATALL },
 106                          { "TRANSPORT",  TPT_STATE, TRANSPORT },
 107                          { "TRANSPORTALL", INITIAL,   TRANSPORTALL },
 108                          { "INITIALIZE", PRM_STATE, INITIALIZE },
 109                          { "XGRID",      PRM_STATE, XGRID },
 110                          { "YGRID",      PRM_STATE, YGRID },
 111                          { "ZGRID",      PRM_STATE, ZGRID },
 112                          { "MONITOR",    MNI_STATE, MONITOR },
 113                          { "WRITE_ATM",  INITIAL,   WRITE_ATM },
 114                          { "WRITE_SPC",  INITIAL,   WRITE_SPC },
 115                          { "WRITE_MAT",  INITIAL,   WRITE_MAT },
 116                          { "WRITE_OPT",  INITIAL,   WRITE_OPT },
 117                          { "USE",        PRM_STATE, USE },
 118                          { "LANGUAGE",   PRM_STATE, LANGUAGE },
 119                          { "INLINE",     INL_STATE, INLINE },
 120                          { "ENDINLINE",  INITIAL,   ENDINLINE },
 121                          { "INTFILE",    PRM_STATE, INTFILE },
 122                          { "DRIVER",     PRM_STATE, DRIVER },
 123                          { "RUN",        PRM_STATE, RUN },
 124                          { "USES",       USE_STATE, USES },
 125                          { "SPARSEDATA", PRM_STATE, SPARSEDATA },
 126                          { "WRFCONFORM",   INITIAL,   WRFCONFORM },
 127                          { 0, 0, 0 }
 128                        };
 129
 130   int CheckKeyword( char *cmd );
 131
 132 #define RETURN( x ) \
 133         if(1) { \
 134           if ( yyerrflag == 0) { \
 135             strcpy( crtToken, nextToken ); \
 136             crtTokType = nextTokType; \
 137             crtLine = crt_line_no; \
 138             strcpy( crtFile, crt_filename ); \
 139           } \
 140           strcpy( nextToken, yytext); \
 141           nextTokType = x; \
 142           return (x); \
 143         }
 144 %}
 145
 146
 147 BT      [ \t]
 148 SPACE   [ \t]
 149 CR      [\n]
 150 TAG     [a-zA-Z_0-9]+
 151 STRING  [^ \t\n{}#;]+
 152
 153 LIT     [a-zA-Z_]
 154 CIF     [0-9]
 155
 156 IDSPC   {LIT}[a-zA-Z_0-9]*
 157
 158 NR      {CIF}*
 159 NRS     [+-]?{CIF}+
 160 REAL    {NRS}?"."?{NR}
 161 UREAL   {NR}?"."?{NR}
 162 FLOAT   {REAL}([eE]{NRS})?
 163 UFLOAT  {UREAL}([eE]{NRS})?
 164
 165 %%
 166 {SPACE}+                {
 167                         }
 168 #                       { BEGIN CMD_STATE;
 169                         }
 170 \{                      { oldstate = (yy_start - 1) / 2;
 171                           BEGIN COMMENT;
 172                         }
 173 \/\/                    { oldstate = (yy_start - 1) / 2;
 174                           BEGIN COMMENT2;
 175                         }
 176 <COMMENT>[^\}\n]*       {
 177                         }
 178 <COMMENT>\}             { BEGIN oldstate;
 179                         }
 180 <COMMENT2>[^\n]*        {
 181                         }
 182 <COMMENT2>{CR}          { crt_line_no++;
 183                           BEGIN oldstate;
 184                         }
 185 {CR}                    { crt_line_no++;
 186                         }
 187 <CMD_STATE>{STRING}     { idx = CheckKeyword( yytext );
 188                           if ( idx < 0 ) {
 189                             BEGIN CR_IGNORE;
 190                             break;
 191                           }
 192                           BEGIN keywords[idx].next;
 193                           if ( keywords[idx].cmd ) {
 194                             crt_section = keywords[idx].cmd;
 195                             RETURN( keywords[idx].cmd );
 196                           }
 197                         }
 198 <INC_STATE>{STRING}     { Include( IncName(yytext) );
 199                           BEGIN CR_IGNORE;
 200                         }
 201 <MOD_STATE>{STRING}     { Include( ModelName(yytext) );
 202                           BEGIN CR_IGNORE;
 203                         }
 204 <INT_STATE>{STRING}     { Include( IntegName(yytext) );
 205                           BEGIN CR_IGNORE;
 206                         }
 207 <PRM_STATE>{STRING}     { strcpy( yylval.str, yytext );
 208                           BEGIN CR_IGNORE;
 209                           RETURN( PARAMETER );
 210                         }
 211 <CR_IGNORE>{STRING}     { ScanError("Extra parameter on command line '%s'", yytext);
 212                         }
 213 <ATM_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 214                           RETURN( ATOMID );
 215                         }
 216 <ATM_STATE>;            { RETURN( yytext[0] );
 217                         }
 218 <DSP_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 219                           RETURN( SPCSPC );
 220                         }
 221 <DSP_STATE>{NR}         { strcpy( yylval.str, yytext );
 222                           RETURN( SPCNR );
 223                         }
 224 <DSP_STATE>[=]          { RETURN( SPCEQUAL );
 225                         }
 226 <DSP_STATE>[+]          { RETURN( SPCPLUS );
 227                         }
 228 <DSP_STATE>;            { RETURN( yytext[0] );
 229                         }
 230 <DSP_STATE>[^;#]        { ScanError("Invalid character '%c' in species definition", yytext[0] );
 231                         }
 232 <SSP_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 233                           RETURN( SSPID );
 234                         }
 235 <SSP_STATE>;            { RETURN( yytext[0] );
 236                         }
 237 <INI_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 238                           RETURN( INISPC );
 239                         }
 240 <INI_STATE>[=]          { RETURN( INIEQUAL );
 241                         }
 242 <INI_STATE>;            { RETURN( yytext[0] );
 243                         }
 244 <INI_STATE>{FLOAT}      { strcpy( yylval.str, yytext );
 245                           RETURN( INIVALUE );
 246                         }
 247 <INI_STATE>[^=;#]       { ScanError("Invalid character '%c' in initial values", yytext[0] );
 248                         }
 249 <EQN_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 250                           RETURN( EQNSPC );
 251                         }
 252 <EQN_STATE>[=]          { RETURN( EQNEQUAL );
 253                         }
 254 <EQN_STATE>{UFLOAT}     { strcpy( yylval.str, yytext );
 255                           RETURN( EQNCOEF );
 256                         }
 257 <EQN_STATE>[:]          { BEGIN RATE_STATE;
 258                           *crt_rate = 0;
 259                           RETURN( EQNCOLON );
 260                         }
 261 <EQN_STATE>[+-]         { strcpy( yylval.str, yytext );
 262                           RETURN( EQNSIGN );
 263                         }
 264 <EQN_STATE>[<]          { BEGIN EQNTAG_STATE;
 265                           RETURN( EQNLESS );
 266                         }
 267 <EQNTAG_STATE>{TAG}     { strcpy( yylval.str, yytext );
 268                           RETURN( EQNTAG );
 269                         }
 270 <EQNTAG_STATE>[>]       { BEGIN EQN_STATE;
 271                           RETURN( EQNGREATER );
 272                         }
 273 <RATE_STATE>{STRING}    { strcpy( yylval.str, yytext );
 274                           RETURN( RATE );
 275                         }
 276 <RATE_STATE>;           { BEGIN EQN_STATE;
 277                           RETURN( yytext[0] );
 278                         }
 279 <LMP_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 280                           RETURN( LMPSPC );
 281                         }
 282 <LMP_STATE>[+]          { RETURN( LMPPLUS );
 283                         }
 284 <LMP_STATE>[:]          { RETURN( LMPCOLON );
 285                         }
 286 <LMP_STATE>;            { RETURN( yytext[0] );
 287                         }
 288 <LMP_STATE>[^;#]        { ScanError("Invalid character '%c' in species definition", yytext[0] );
 289                         }
 290 <LKT_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 291                           RETURN( LKTID );
 292                         }
 293 <LKT_STATE>;            { RETURN( yytext[0] );
 294                         }
 295 <TPT_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 296                           RETURN( TPTID );
 297                         }
 298 <TPT_STATE>;            { RETURN( yytext[0] );
 299                         }
 300 <USE_STATE>{STRING}     { strcpy( yylval.str, yytext );
 301                           RETURN( USEID );
 302                         }
 303 <USE_STATE>;            { RETURN( yytext[0] );
 304                         }
 305 <MNI_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 306                           RETURN( MNIID );
 307                         }
 308 <MNI_STATE>;            { RETURN( yytext[0] );
 309                         }
 310 <INL_STATE>{STRING}     { strcpy( yylval.str, yytext );
 311                           BEGIN INL_CODE;
 312                           RETURN( INLCTX );
 313                         }
 314 <INL_CODE>#[^ \t\n]*    { if ( EqNoCase( yytext+1, "ENDINLINE" ) ){
 315                             BEGIN INITIAL;
 316                             RETURN( ENDINLINE );
 317                           }
 318                           else {
 319                             strcpy( yylval.str, yytext );
 320                             RETURN( INCODE );
 321                           }
 322                         }
 323 <INL_CODE>\n            { crt_line_no++;
 324                           strcpy( yylval.str,yytext );
 325                           RETURN( INCODE );
 326                         }
 327 <INL_CODE>[^#\n]*       { strcpy( yylval.str,yytext );
 328                           RETURN( INCODE );
 329                         }
 330 <<EOF>>                 { if ( ! EndInclude() ) {
 331                             RETURN( INITIAL );
 332                           }
 333                         }
 334 %%
 335
 336 void Include ( char * name )
 337 {
 338 FILE *f;
 339 YY_BUFFER_STATE newb;
 340
 341   if ( yy_buf_level == MAX_INCLUDE ) {
 342     printf("\nInclude nested too deep. Include %s ignored", name);
 343     return;
 344   }
 345
 346   yy_buffers[ yy_buf_level ]  = yy_current_buffer;
 347   yy_line_no[ yy_buf_level ]  = crt_line_no;
 348   yy_filename[ yy_buf_level ] = crt_filename;
 349   yy_buf_level++;
 350
 351   crt_line_no = 1;
 352
 353   crt_filename = malloc( 1 + strlen( name ) );
 354   strcpy( crt_filename, name );
 355
 356
 357   f = fopen( name, "r" );
 358   if( f == 0 )
 359     FatalError(3,"%s: Can't read file", name );
 360
 361   newb = yy_create_buffer(f, YY_BUF_SIZE);
 362   yy_switch_to_buffer( newb );
 363 }
 364
 365 int EndInclude()
 366 {
 367 YY_BUFFER_STATE oldb;
 368 char * oldn;
 369
 370   if ( yy_buf_level > 0 ) {
 371     oldb = yy_current_buffer;
 372     oldn = crt_filename;
 373     yy_buf_level--;
 374     yy_switch_to_buffer( yy_buffers[yy_buf_level] );
 375     crt_line_no = yy_line_no[ yy_buf_level ];
 376     crt_filename = yy_filename[ yy_buf_level ];
 377     yy_delete_buffer( oldb );
 378     free( oldn );
 379     return 1;
 380   }
 381   return 0;
 382 }
 383
 384 int EqNoCase( char *s1, char *s2 )
 385 {
 386   while( *s1 ) {
 387     if ( toupper(*s1++) != toupper(*s2++) ) return 0;
 388   }
 389   return *s1 == *s2;
 390 }
 391
 392 int CheckKeyword( char *cmd )
 393 {
 394 int i;
 395
 396   i = 0;
 397   while( 1 ) {
 398     if( keywords[i].name == 0 ) {
 399       ScanError( "'%s': Unknown command (ignored)", cmd);
 400       return -1;
 401     }
 402     if( EqNoCase( cmd, keywords[i].name ) ) {
 403       return i;
 404     }
 405     i++;
 406   }
 407 }
 408