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

   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 %{
  35   #include <stdio.h>
  36   #include <stdlib.h>
  37   #include <malloc.h>
  38   #include <string.h>
  39   #include <unistd.h>
  40   #include "scan.h"
  41
  42   #define __YYSCLASS
  43
  44   #define YYDEBUG 1
  45   extern char yytext[];
  46   extern FILE * yyin;
  47
  48   int nError   = 0;
  49   int nWarning = 0;
  50
  51   int crt_section;
  52   int eqState;
  53   int isPhoto = 0;
  54
  55   char crt_term[ 30 ];
  56   char crt_coef[ 30 ];
  57
  58   char * InlineBuf;
  59   int InlineLen;
  60
  61   void SemicolonError();
  62   extern int yyerrflag;
  63
  64 %}
  65
  66 %union{
  67   char str[80];
  68 };
  69
  70 %token JACOBIAN DOUBLE FUNCTION DEFVAR DEFRAD DEFFIX SETVAR SETRAD SETFIX
  71 %token HESSIAN STOICMAT STOCHASTIC
  72 %token INITVALUES EQUATIONS LUMP INIEQUAL EQNEQUAL EQNCOLON
  73 %token LMPCOLON LMPPLUS SPCPLUS SPCEQUAL ATOMDECL CHECK CHECKALL REORDER
  74 %token MEX DUMMYINDEX EQNTAGS
  75 %token LOOKAT LOOKATALL TRANSPORT TRANSPORTALL MONITOR USES SPARSEDATA
  76 %token WRFCONFORM
  77 %token WRITE_ATM WRITE_SPC WRITE_MAT WRITE_OPT INITIALIZE XGRID YGRID ZGRID
  78 %token USE LANGUAGE INTFILE DRIVER RUN INLINE ENDINLINE
  79 %token      PARAMETER SPCSPC INISPC INIVALUE EQNSPC EQNSIGN EQNCOEF
  80 %type <str> PARAMETER SPCSPC INISPC INIVALUE EQNSPC EQNSIGN EQNCOEF
  81 %token      RATE LMPSPC SPCNR ATOMID LKTID MNIID INLCTX INCODE SSPID
  82 %type <str> RATE LMPSPC SPCNR ATOMID LKTID MNIID INLCTX INCODE SSPID
  83 %token      EQNLESS EQNTAG EQNGREATER
  84 %type <str> EQNLESS EQNTAG EQNGREATER
  85 %token      TPTID USEID
  86 %type <str> TPTID USEID
  87 %type <str> rate eqntag
  88
  89 %%
  90
  91 program         : section
  92                 | section program
  93                 ;
  94 section         : JACOBIAN PARAMETER
  95                   { CmdJacobian( $2 );
  96                   }
  97                 | HESSIAN PARAMETER
  98                   { CmdHessian( $2 );
  99                   }
 100                 | STOICMAT PARAMETER
 101                   { CmdStoicmat( $2 );
 102                   }
 103                 | DOUBLE PARAMETER
 104                   { CmdDouble( $2 );
 105                   }
 106                 | REORDER PARAMETER
 107                   { CmdReorder( $2 );
 108                   }
 109                 | MEX PARAMETER
 110                   { CmdMex( $2 );
 111                   }
 112                 | DUMMYINDEX PARAMETER
 113                   { CmdDummyindex( $2 );
 114                   }
 115                 | EQNTAGS PARAMETER
 116                   { CmdEqntags( $2 );
 117                   }
 118                 | FUNCTION PARAMETER
 119                   { CmdFunction( $2 );
 120                   }
 121                 | STOCHASTIC PARAMETER
 122                   { CmdStochastic( $2 );
 123                   }
 124                 | ATOMDECL atomlist
 125                   {}
 126                 | CHECK atomlist
 127                   {}
 128                 | DEFVAR species
 129                   {}
 130                 | DEFRAD species
 131                   {}
 132                 | DEFFIX species
 133                   {}
 134                 | SETVAR setspclist
 135                   {}
 136                 | SETRAD setspclist
 137                   {}
 138                 | SETFIX setspclist
 139                   {}
 140                 | INITVALUES initvalues
 141                   {}
 142                 | EQUATIONS equations
 143                   {}
 144                 | LUMP lumps
 145                   {}
 146                 | LOOKAT lookatlist
 147                   {}
 148                 | MONITOR monitorlist
 149                   {}
 150                 | TRANSPORT translist
 151                   {}
 152                 | CHECKALL
 153                   { CheckAll(); }
 154                 | LOOKATALL
 155                   { LookAtAll(); }
 156                 | TRANSPORTALL
 157                   { TransportAll(); }
 158                 | WRITE_ATM
 159                   { WriteAtoms(); }
 160                 | WRITE_SPC
 161                   { WriteSpecies(); }
 162                 | WRITE_MAT
 163                   { WriteMatrices(); }
 164                 | WRITE_OPT
 165                   { WriteOptions(); }
 166                 | USE PARAMETER
 167                   { CmdUse( $2 ); }
 168                 | LANGUAGE PARAMETER
 169                   { CmdLanguage( $2 ); }
 170                 | INITIALIZE PARAMETER
 171                   { DefineInitializeNbr( $2 ); }
 172                 | XGRID PARAMETER
 173                   { DefineXGrid( $2 ); }
 174                 | YGRID PARAMETER
 175                   { DefineYGrid( $2 ); }
 176                 | ZGRID PARAMETER
 177                   { DefineZGrid( $2 ); }
 178                 | INLINE INLCTX inlinecode ENDINLINE
 179                   {
 180                     AddInlineCode( $2, InlineBuf );
 181                     free( InlineBuf );
 182                   }
 183                 | INLINE error
 184                   { ParserErrorMessage(); }
 185                 | INTFILE PARAMETER
 186                   { CmdIntegrator( $2 ); }
 187                 | DRIVER PARAMETER
 188                   { CmdDriver( $2 ); }
 189                 | RUN PARAMETER
 190                   { CmdRun( $2 ); }
 191                 | USES uselist
 192                   {}
 193                 | SPARSEDATA PARAMETER
 194                   { SparseData( $2 );
 195                   }
 196                 | WRFCONFORM
 197                   { WRFConform();
 198                   }
 199                 ;
 200 semicolon       : semicolon ';'
 201                   { ScanWarning("Unnecessary ';'");
 202                   }
 203                 | ';'
 204                 ;
 205 atomlist        : atomlist atomdef semicolon
 206                 | atomdef semicolon
 207                 | error semicolon
 208                   { ParserErrorMessage(); }
 209                 ;
 210 atomdef         : ATOMID
 211                   { switch( crt_section ) {
 212                       case ATOMDECL: DeclareAtom( $1 ); break;
 213                       case CHECK:    SetAtomType( $1, DO_CHECK ); break;
 214                     }
 215                   }
 216                 ;
 217 lookatlist      : lookatlist lookatspc semicolon
 218                 | lookatspc semicolon
 219                 | error semicolon
 220                   { ParserErrorMessage(); }
 221                 ;
 222 lookatspc       : LKTID
 223                   { AddLookAt( $1 );
 224                   }
 225                 ;
 226 monitorlist     : monitorlist monitorspc semicolon
 227                 | monitorspc semicolon
 228                 | error semicolon
 229                   { ParserErrorMessage(); }
 230                 ;
 231 monitorspc      : MNIID
 232                   { AddMonitor( $1 );
 233                   }
 234                 ;
 235 translist       : translist transspc semicolon
 236                 | transspc semicolon
 237                 | error semicolon
 238                   { ParserErrorMessage(); }
 239                 ;
 240 transspc        : TPTID
 241                   { AddTransport( $1 );
 242                   }
 243                 ;
 244 uselist         : uselist usefile semicolon
 245                 | usefile semicolon
 246                 | error semicolon
 247                   { ParserErrorMessage(); }
 248                 ;
 249 usefile         : USEID
 250                   { AddUseFile( $1 );
 251                   }
 252                 ;
 253 setspclist      : setspclist setspcspc semicolon
 254                 | setspcspc semicolon
 255                 | error semicolon
 256                   { ParserErrorMessage(); }
 257                 ;
 258 setspcspc       : SSPID
 259                   { switch( crt_section ) {
 260                       case SETVAR: SetSpcType( VAR_SPC, $1 ); break;
 261                       case SETRAD: SetSpcType( RAD_SPC, $1 ); break;
 262                       case SETFIX: SetSpcType( FIX_SPC, $1 ); break;
 263                     }
 264                   }
 265                 ;
 266 species         : species spc semicolon
 267                 | spc semicolon
 268                 | error semicolon
 269                   { ParserErrorMessage(); }
 270                 ;
 271 spc             : spcname
 272                 | spcdef
 273                 ;
 274 spcname         : SPCSPC SPCEQUAL atoms
 275                   { switch( crt_section ) {
 276                       case DEFVAR: DeclareSpecies( VAR_SPC, $1 ); break;
 277                       case DEFRAD: DeclareSpecies( RAD_SPC, $1 ); break;
 278                       case DEFFIX: DeclareSpecies( FIX_SPC, $1 ); break;
 279                     }
 280                   }
 281                 ;
 282 spcdef          : SPCSPC
 283                   { switch( crt_section ) {
 284                       case DEFVAR: DeclareSpecies( VAR_SPC, $1 ); break;
 285                       case DEFRAD: DeclareSpecies( RAD_SPC, $1 ); break;
 286                       case DEFFIX: DeclareSpecies( FIX_SPC, $1 ); break;
 287                     }
 288                   }
 289                 ;
 290 atoms           : atoms SPCPLUS atom
 291                 | atom
 292                 ;
 293 atom            : SPCNR SPCSPC
 294                   { AddAtom( $2, $1 );
 295                   }
 296                 | SPCSPC
 297                   { AddAtom( $1, "1" );
 298                   }
 299                 ;
 300 initvalues      : initvalues assignment semicolon
 301                 | assignment semicolon
 302                 | error semicolon
 303                   { ParserErrorMessage(); }
 304                 ;
 305 assignment      : INISPC INIEQUAL INIVALUE
 306                   { AssignInitialValue( $1, $3 ); }
 307                 ;
 308 equations       : equations equation semicolon
 309                 | equation semicolon
 310                 | error semicolon
 311                   { ParserErrorMessage();
 312                     eqState = LHS;
 313                   }
 314                 ;
 315 equation        : eqntag lefths righths rate
 316                   { eqState = LHS;
 317                     StoreEquationRate( $4, $1 );
 318                     CheckEquation();
 319                   }
 320                 | lefths righths rate
 321                   { eqState = LHS;
 322                     StoreEquationRate( $3, "          " );
 323                     CheckEquation();
 324                   }
 325 rate            : RATE rate
 326                   { strcpy( $$, $1 );
 327                     strcat( $$, $2 );
 328                   }
 329                 | RATE
 330                   { strcpy( $$, $1 );
 331                   }
 332                 ;
 333 eqntag           : EQNLESS EQNTAG EQNGREATER
 334                   { strcpy( $$, $2 );
 335                   }
 336                 ;
 337 lefths          : expresion EQNEQUAL
 338                   { eqState = RHS; }
 339                 ;
 340 righths         : expresion EQNCOLON
 341                   { eqState = RAT; }
 342                 ;
 343 expresion       : expresion EQNSIGN term
 344                   { ProcessTerm( eqState, $2, crt_coef, crt_term );
 345                   }
 346                 | EQNSIGN term
 347                   { ProcessTerm( eqState, $1, crt_coef, crt_term );
 348                   }
 349                 | term
 350                   { ProcessTerm( eqState, "+", crt_coef, crt_term );
 351                   }
 352                 ;
 353 term            : EQNCOEF EQNSPC
 354                   { strcpy( crt_term, $2 );
 355                     strcpy( crt_coef, $1 );
 356                   }
 357                 | EQNSPC
 358                   { strcpy( crt_term, $1 );
 359                     strcpy( crt_coef, "1" );
 360                   }
 361                 ;
 362 lumps           : lumps lump semicolon
 363                 | lump semicolon
 364                 | error semicolon
 365                   { ParserErrorMessage(); }
 366                 ;
 367 lump            : LMPSPC LMPPLUS lump
 368                   { AddLumpSpecies( $1 );
 369                   }
 370                 | LMPSPC LMPCOLON LMPSPC
 371                   {
 372                     AddLumpSpecies( $1 );
 373                     CheckLump( $3 );
 374                   }
 375 inlinecode      : inlinecode INCODE
 376                   {
 377                     InlineBuf = AppendString( InlineBuf, $2, &InlineLen, MAX_INLINE );
 378                   }
 379                 | INCODE
 380                   {
 381                     InlineBuf = malloc( MAX_INLINE );
 382                     InlineLen = MAX_INLINE;
 383                     strcpy( InlineBuf, $1);
 384                   }
 385                 ;
 386 %%
 387
 388 void yyerror( char * str )
 389 {
 390 }
 391
 392 void ParserErrorMessage()
 393 {
 394   yyerrok;
 395 /*
 396   Message("[%d,%s] -> [%d,%s]", crtTokType, crtToken, nextTokType, nextToken );
 397 */
 398   if( crtToken[0] == ';' ) {
 399     ParserError("Misplaced ';'");
 400     return;
 401   }
 402   switch( crtTokType ) {
 403     case ATOMID:
 404       ParserError("Missing ';' after '%s'", crtToken );
 405       break;
 406
 407     case SPCSPC:
 408       ParserError("Missing ';' or '+' after '%s'", crtToken );
 409       break;
 410     case SPCNR:
 411       ParserError("Missing species after '%s'", crtToken );
 412       break;
 413     case SPCPLUS:
 414       ParserError("Missing atom after '%s'", crtToken );
 415       break;
 416     case SPCEQUAL:
 417       ParserError("Invalid '=' after '%s'", crtToken );
 418       break;
 419
 420     case INISPC:
 421       ParserError("Missing '=' after '%s'", crtToken );
 422       break;
 423     case INIEQUAL:
 424       ParserError("Missing value after '%s'", crtToken );
 425       break;
 426     case INIVALUE:
 427       ParserError("Missing ';' after '%s'", crtToken );
 428       break;
 429
 430     case EQNSPC:
 431       ParserError("Missing '+' or '=' after '%s'", crtToken );
 432       break;
 433     case EQNEQUAL:
 434       ParserError("Invalid right hand side of equation");
 435       break;
 436     case EQNCOLON:
 437       ParserError("Missing rate after '%s'", crtToken );
 438       break;
 439     case EQNSIGN:
 440       ParserError("Missing coeficient after '%s'", crtToken );
 441       break;
 442     case EQNCOEF:
 443       ParserError("Missing species after '%s'", crtToken );
 444       break;
 445     case RATE:
 446       ParserError("Missing ';' after '%s'", crtToken );
 447       break;
 448
 449     case LMPSPC:
 450       ParserError("Missing '+' or ':' or ';' after '%s'", crtToken );
 451       break;
 452     case LMPPLUS:
 453       ParserError("Missing species after '%s'", crtToken );
 454       break;
 455     case LMPCOLON:
 456       ParserError("Missing species after '%s'", crtToken );
 457       break;
 458     case INLINE:
 459       ParserError("Missing inline option after '%s'", crtToken );
 460       break;
 461
 462     default:
 463       ParserError("Syntax error after '%s'", crtToken );
 464   }
 465 }
 466
 467
 468 int Parser( char * filename )
 469 {
 470 extern int yydebug;
 471 FILE *f;
 472
 473   crt_filename = filename;
 474
 475   f = fopen( crt_filename, "r" );
 476   if( f == 0 ) {
 477     FatalError(7,"%s: File not found", crt_filename);
 478   }
 479
 480   yyin = f;
 481   nError   = 0;
 482   nWarning = 0;
 483   yydebug = 0;
 484
 485   yyparse();
 486
 487   fclose( f );
 488
 489   return nError;
 490 }
 491