wrfv2_fire/chem/KPP/kpp/kpp-2.1/src.org/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                          { 0, 0, 0 }
 127                        };
 128
 129   int CheckKeyword( char *cmd );
 130
 131 #define RETURN( x ) \
 132         if(1) { \
 133           if ( yyerrflag == 0) { \
 134             strcpy( crtToken, nextToken ); \
 135             crtTokType = nextTokType; \
 136             crtLine = crt_line_no; \
 137             strcpy( crtFile, crt_filename ); \
 138           } \
 139           strcpy( nextToken, yytext); \
 140           nextTokType = x; \
 141           return (x); \
 142         }
 143 %}
 144
 145
 146 BT      [ \t]
 147 SPACE   [ \t]
 148 CR      [\n]
 149 TAG     [a-zA-Z_0-9]+
 150 STRING  [^ \t\n{}#;]+
 151
 152 LIT     [a-zA-Z_]
 153 CIF     [0-9]
 154
 155 IDSPC   {LIT}[a-zA-Z_0-9]*
 156
 157 NR      {CIF}*
 158 NRS     [+-]?{CIF}+
 159 REAL    {NRS}?"."?{NR}
 160 UREAL   {NR}?"."?{NR}
 161 FLOAT   {REAL}([eE]{NRS})?
 162 UFLOAT  {UREAL}([eE]{NRS})?
 163
 164 %%
 165 {SPACE}+                {
 166                         }
 167 #                       { BEGIN CMD_STATE;
 168                         }
 169 \{                      { oldstate = (yy_start - 1) / 2;
 170                           BEGIN COMMENT;
 171                         }
 172 \/\/                    { oldstate = (yy_start - 1) / 2;
 173                           BEGIN COMMENT2;
 174                         }
 175 <COMMENT>[^\}\n]*       {
 176                         }
 177 <COMMENT>\}             { BEGIN oldstate;
 178                         }
 179 <COMMENT2>[^\n]*        {
 180                         }
 181 <COMMENT2>{CR}          { crt_line_no++;
 182                           BEGIN oldstate;
 183                         }
 184 {CR}                    { crt_line_no++;
 185                         }
 186 <CMD_STATE>{STRING}     { idx = CheckKeyword( yytext );
 187                           if ( idx < 0 ) {
 188                             BEGIN CR_IGNORE;
 189                             break;
 190                           }
 191                           BEGIN keywords[idx].next;
 192                           if ( keywords[idx].cmd ) {
 193                             crt_section = keywords[idx].cmd;
 194                             RETURN( keywords[idx].cmd );
 195                           }
 196                         }
 197 <INC_STATE>{STRING}     { Include( IncName(yytext) );
 198                           BEGIN CR_IGNORE;
 199                         }
 200 <MOD_STATE>{STRING}     { Include( ModelName(yytext) );
 201                           BEGIN CR_IGNORE;
 202                         }
 203 <INT_STATE>{STRING}     { Include( IntegName(yytext) );
 204                           BEGIN CR_IGNORE;
 205                         }
 206 <PRM_STATE>{STRING}     { strcpy( yylval.str, yytext );
 207                           BEGIN CR_IGNORE;
 208                           RETURN( PARAMETER );
 209                         }
 210 <CR_IGNORE>{STRING}     { ScanError("Extra parameter on command line '%s'", yytext);
 211                         }
 212 <ATM_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 213                           RETURN( ATOMID );
 214                         }
 215 <ATM_STATE>;            { RETURN( yytext[0] );
 216                         }
 217 <DSP_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 218                           RETURN( SPCSPC );
 219                         }
 220 <DSP_STATE>{NR}         { strcpy( yylval.str, yytext );
 221                           RETURN( SPCNR );
 222                         }
 223 <DSP_STATE>[=]          { RETURN( SPCEQUAL );
 224                         }
 225 <DSP_STATE>[+]          { RETURN( SPCPLUS );
 226                         }
 227 <DSP_STATE>;            { RETURN( yytext[0] );
 228                         }
 229 <DSP_STATE>[^;#]        { ScanError("Invalid character '%c' in species definition", yytext[0] );
 230                         }
 231 <SSP_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 232                           RETURN( SSPID );
 233                         }
 234 <SSP_STATE>;            { RETURN( yytext[0] );
 235                         }
 236 <INI_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 237                           RETURN( INISPC );
 238                         }
 239 <INI_STATE>[=]          { RETURN( INIEQUAL );
 240                         }
 241 <INI_STATE>;            { RETURN( yytext[0] );
 242                         }
 243 <INI_STATE>{FLOAT}      { strcpy( yylval.str, yytext );
 244                           RETURN( INIVALUE );
 245                         }
 246 <INI_STATE>[^=;#]       { ScanError("Invalid character '%c' in initial values", yytext[0] );
 247                         }
 248 <EQN_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 249                           RETURN( EQNSPC );
 250                         }
 251 <EQN_STATE>[=]          { RETURN( EQNEQUAL );
 252                         }
 253 <EQN_STATE>{UFLOAT}     { strcpy( yylval.str, yytext );
 254                           RETURN( EQNCOEF );
 255                         }
 256 <EQN_STATE>[:]          { BEGIN RATE_STATE;
 257                           *crt_rate = 0;
 258                           RETURN( EQNCOLON );
 259                         }
 260 <EQN_STATE>[+-]         { strcpy( yylval.str, yytext );
 261                           RETURN( EQNSIGN );
 262                         }
 263 <EQN_STATE>[<]          { BEGIN EQNTAG_STATE;
 264                           RETURN( EQNLESS );
 265                         }
 266 <EQNTAG_STATE>{TAG}     { strcpy( yylval.str, yytext );
 267                           RETURN( EQNTAG );
 268                         }
 269 <EQNTAG_STATE>[>]       { BEGIN EQN_STATE;
 270                           RETURN( EQNGREATER );
 271                         }
 272 <RATE_STATE>{STRING}    { strcpy( yylval.str, yytext );
 273                           RETURN( RATE );
 274                         }
 275 <RATE_STATE>;           { BEGIN EQN_STATE;
 276                           RETURN( yytext[0] );
 277                         }
 278 <LMP_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 279                           RETURN( LMPSPC );
 280                         }
 281 <LMP_STATE>[+]          { RETURN( LMPPLUS );
 282                         }
 283 <LMP_STATE>[:]          { RETURN( LMPCOLON );
 284                         }
 285 <LMP_STATE>;            { RETURN( yytext[0] );
 286                         }
 287 <LMP_STATE>[^;#]        { ScanError("Invalid character '%c' in species definition", yytext[0] );
 288                         }
 289 <LKT_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 290                           RETURN( LKTID );
 291                         }
 292 <LKT_STATE>;            { RETURN( yytext[0] );
 293                         }
 294 <TPT_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 295                           RETURN( TPTID );
 296                         }
 297 <TPT_STATE>;            { RETURN( yytext[0] );
 298                         }
 299 <USE_STATE>{STRING}     { strcpy( yylval.str, yytext );
 300                           RETURN( USEID );
 301                         }
 302 <USE_STATE>;            { RETURN( yytext[0] );
 303                         }
 304 <MNI_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
 305                           RETURN( MNIID );
 306                         }
 307 <MNI_STATE>;            { RETURN( yytext[0] );
 308                         }
 309 <INL_STATE>{STRING}     { strcpy( yylval.str, yytext );
 310                           BEGIN INL_CODE;
 311                           RETURN( INLCTX );
 312                         }
 313 <INL_CODE>#[^ \t\n]*    { if ( EqNoCase( yytext+1, "ENDINLINE" ) ){
 314                             BEGIN INITIAL;
 315                             RETURN( ENDINLINE );
 316                           }
 317                           else {
 318                             strcpy( yylval.str, yytext );
 319                             RETURN( INCODE );
 320                           }
 321                         }
 322 <INL_CODE>\n            { crt_line_no++;
 323                           strcpy( yylval.str,yytext );
 324                           RETURN( INCODE );
 325                         }
 326 <INL_CODE>[^#\n]*       { strcpy( yylval.str,yytext );
 327                           RETURN( INCODE );
 328                         }
 329 <<EOF>>                 { if ( ! EndInclude() ) {
 330                             RETURN( INITIAL );
 331                           }
 332                         }
 333 %%
 334
 335 void Include ( char * name )
 336 {
 337 FILE *f;
 338 YY_BUFFER_STATE newb;
 339
 340   if ( yy_buf_level == MAX_INCLUDE ) {
 341     printf("\nInclude nested too deep. Include %s ignored", name);
 342     return;
 343   }
 344
 345   yy_buffers[ yy_buf_level ]  = yy_current_buffer;
 346   yy_line_no[ yy_buf_level ]  = crt_line_no;
 347   yy_filename[ yy_buf_level ] = crt_filename;
 348   yy_buf_level++;
 349
 350   crt_line_no = 1;
 351
 352   crt_filename = malloc( 1 + strlen( name ) );
 353   strcpy( crt_filename, name );
 354
 355
 356   f = fopen( name, "r" );
 357   if( f == 0 )
 358     FatalError(3,"%s: Can't read file", name );
 359
 360   newb = yy_create_buffer(f, YY_BUF_SIZE);
 361   yy_switch_to_buffer( newb );
 362 }
 363
 364 int EndInclude()
 365 {
 366 YY_BUFFER_STATE oldb;
 367 char * oldn;
 368
 369   if ( yy_buf_level > 0 ) {
 370     oldb = yy_current_buffer;
 371     oldn = crt_filename;
 372     yy_buf_level--;
 373     yy_switch_to_buffer( yy_buffers[yy_buf_level] );
 374     crt_line_no = yy_line_no[ yy_buf_level ];
 375     crt_filename = yy_filename[ yy_buf_level ];
 376     yy_delete_buffer( oldb );
 377     free( oldn );
 378     return 1;
 379   }
 380   return 0;
 381 }
 382
 383 int EqNoCase( char *s1, char *s2 )
 384 {
 385   while( *s1 ) {
 386     if ( toupper(*s1++) != toupper(*s2++) ) return 0;
 387   }
 388   return *s1 == *s2;
 389 }
 390
 391 int CheckKeyword( char *cmd )
 392 {
 393 int i;
 394
 395   i = 0;
 396   while( 1 ) {
 397     if( keywords[i].name == 0 ) {
 398       ScanError( "'%s': Unknown command (ignored)", cmd);
 399       return -1;
 400     }
 401     if( EqNoCase( cmd, keywords[i].name ) ) {
 402       return i;
 403     }
 404     i++;
 405   }
 406 }
 407