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, 3 years 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.