Home

Context Navigation

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

Rev	Line
[2696]	1	/******************************************************************************
	2
	3	KPP - The Kinetic PreProcessor
	4	Builds simulation code for chemical kinetic systems
	5
[4843]	6	Copyright (C) -2021 996 Valeriu Damian and Adrian Sandu
	7	Copyright (C) -2021 005 Adrian Sandu
[2696]	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
	96	program : section
	97	\| section program
	98	;
	99	section : 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	;
	205	semicolon : semicolon ';'
	206	{ ScanWarning("Unnecessary ';'");
	207	}
	208	\| ';'
	209	;
	210	atomlist : atomlist atomdef semicolon
	211	\| atomdef semicolon
	212	\| error semicolon
	213	{ ParserErrorMessage(); }
	214	;
	215	atomdef : ATOMID
	216	{ switch( crt_section ) {
	217	case ATOMDECL: DeclareAtom( $1 ); break;
	218	case CHECK: SetAtomType( $1, DO_CHECK ); break;
	219	}
	220	}
	221	;
	222	lookatlist : lookatlist lookatspc semicolon
	223	\| lookatspc semicolon
	224	\| error semicolon
	225	{ ParserErrorMessage(); }
	226	;
	227	lookatspc : LKTID
	228	{ AddLookAt( $1 );
	229	}
	230	;
	231	monitorlist : monitorlist monitorspc semicolon
	232	\| monitorspc semicolon
	233	\| error semicolon
	234	{ ParserErrorMessage(); }
	235	;
	236	monitorspc : MNIID
	237	{ AddMonitor( $1 );
	238	}
	239	;
	240	translist : translist transspc semicolon
	241	\| transspc semicolon
	242	\| error semicolon
	243	{ ParserErrorMessage(); }
	244	;
	245	transspc : TPTID
	246	{ AddTransport( $1 );
	247	}
	248	;
	249	uselist : uselist usefile semicolon
	250	\| usefile semicolon
	251	\| error semicolon
	252	{ ParserErrorMessage(); }
	253	;
	254	usefile : USEID
	255	{ AddUseFile( $1 );
	256	}
	257	;
	258	setspclist : setspclist setspcspc semicolon
	259	\| setspcspc semicolon
	260	\| error semicolon
	261	{ ParserErrorMessage(); }
	262	;
	263	setspcspc : 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	;
	271	species : species spc semicolon
	272	\| spc semicolon
	273	\| error semicolon
	274	{ ParserErrorMessage(); }
	275	;
	276	spc : spcname
	277	\| spcdef
	278	;
	279	spcname : 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	;
	287	spcdef : 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	;
	295	atoms : atoms SPCPLUS atom
	296	\| atom
	297	;
	298	atom : SPCNR SPCSPC
	299	{ AddAtom( $2, $1 );
	300	}
	301	\| SPCSPC
	302	{ AddAtom( $1, "1" );
	303	}
	304	;
	305	initvalues : initvalues assignment semicolon
	306	\| assignment semicolon
	307	\| error semicolon
	308	{ ParserErrorMessage(); }
	309	;
	310	assignment : INISPC INIEQUAL INIVALUE
	311	{ AssignInitialValue( $1, $3 ); }
	312	;
	313	equations : equations equation semicolon
	314	\| equation semicolon
	315	\| error semicolon
	316	{ ParserErrorMessage();
	317	eqState = LHS;
	318	}
	319	;
	320	equation : 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	}
	330	rate : RATE rate
	331	{ strcpy( $$, $1 );
	332	strcat( $$, $2 );
	333	}
	334	\| RATE
	335	{ strcpy( $$, $1 );
	336	}
	337	;
	338	eqntag : EQNLESS EQNTAG EQNGREATER
	339	{ strcpy( $$, $2 );
	340	}
	341	;
	342	lefths : expresion EQNEQUAL
	343	{ eqState = RHS; }
	344	;
	345	righths : expresion EQNCOLON
	346	{ eqState = RAT; }
	347	;
	348	expresion : 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	;
	358	term : 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	;
	367	lumps : lumps lump semicolon
	368	\| lump semicolon
	369	\| error semicolon
	370	{ ParserErrorMessage(); }
	371	;
	372	lump : LMPSPC LMPPLUS lump
	373	{ AddLumpSpecies( $1 );
	374	}
	375	\| LMPSPC LMPCOLON LMPSPC
	376	{
	377	AddLumpSpecies( $1 );
	378	CheckLump( $3 );
	379	}
	380	inlinecode : 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
	393	void yyerror( char * str )
	394	{
	395	}
	396
	397	void 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
	473	int Parser( char * filename )
	474	{
	475	extern int yydebug;
	476	FILE *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.

Download in other formats:

Original Format