source: palm/trunk/UTIL/chemistry/gasphase_preproc/kpp/src/scan.y @ 4843

Last change on this file since 4843 was 4843, checked in by raasch, 16 months ago

local namelist parameter added to switch off the module although the respective module namelist appears in the namelist file, further copyright updates

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