OOPSE/libBASS/BASSyacc.y


/* define some general tokens */

%token MOLECULE ATOM BOND BEND TORSION POSITION MEMBERS CONSTRAINT
%token COMPONENT START_INDEX DEFINED ORIENTATION ZCONSTRAINT

/* more advanced tokens */

%union {
  int i_val;                 /* integer value */
  double d_val;              /* double value  */
  char * s_ptr;              /* string pointer */
  struct node_tag* node_ptr; /* pointer to the statement node tree */
}

%token <i_val> INTEGER
%token <i_val> ARRAY_INDEX

%token <d_val> DOUBLE

%token <s_ptr> IDENTIFIER
%token <s_ptr> QUOTED_STRING

%type <node_ptr> stmt
%type <node_ptr> stmt_list
%type <node_ptr> assignment
%type <node_ptr> member
%type <node_ptr> constraint
%type <node_ptr> orientation
%type <node_ptr> position
%type <node_ptr> block
%type <node_ptr> molecule_block
%type <node_ptr> atom_block
%type <node_ptr> bond_block
%type <node_ptr> bend_block
%type <node_ptr> torsion_block
%type <node_ptr> component_block
%type <node_ptr> zconstraint_block
 

%{
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "node_list.h"
#include "make_nodes.h"
#include "parse_tree.h"
#include "simError.h"
#ifdef IS_MPI
#define __is_lex__
#include "mpiBASS.h"
#endif

extern int yylineno;

struct filename_list{
  char my_name[300];
  struct filename_list* next;
};
extern struct filename_list* yyfile_name;

extern void change_in_file( FILE* in_file );
extern void yacc_model( char* file_name );
extern void kill_lists(void);

/* top of the node list */

struct node_tag* head_node;
struct node_tag* current_node;

%}

%%

program: 
        commands
        ;

commands: /* NULL */
        | commands stmt         { 
                                  current_node->next_stmt = $2;
                                  $2->prev_stmt = current_node;
                                  current_node = $2;
                                }
        ;

stmt:
          assignment            { $$ = $1; }
        | member                { $$ = $1; }
        | constraint            { $$ = $1; }
        | orientation           { $$ = $1; }
        | position              { $$ = $1; }
        | block                 { $$ = $1; }
        ;

assignment:
          IDENTIFIER '=' INTEGER ';'
                                { $$ = assign_i( $1, $3 ); }
        | IDENTIFIER '=' DOUBLE ';'
                                { $$ = assign_d( $1, $3 ); }
        | IDENTIFIER '=' IDENTIFIER ';'
                                { $$ = assign_s( $1, $3 ); }
        | IDENTIFIER '=' QUOTED_STRING ';'
                                { $$ = assign_s( $1, $3 ); }
        ;

member:
          MEMBERS '(' INTEGER ',' INTEGER ')' ';'
                                { $$ = members_2( $3, $5 ); }
        | MEMBERS '(' INTEGER ',' INTEGER ',' INTEGER ')' ';'
                                { $$ = members_3( $3, $5, $7 ); }
        | MEMBERS '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')' ';'
                                { $$ = members_4( $3, $5, $7, $9 ); }
        ;

constraint:
          CONSTRAINT '(' INTEGER ')' ';'
                                { $$ = constraint( (double)$3 ); }
        | CONSTRAINT '(' DOUBLE ')' ';'
                                { $$ = constraint( $3 ); }
        ;

orientation:
          ORIENTATION '(' DOUBLE ',' DOUBLE ',' DOUBLE ')' ';'
                                { $$ = orientation( $3, $5, $7 ); }
        | ORIENTATION '(' INTEGER ',' DOUBLE ',' DOUBLE ')' ';'
                                { $$ = orientation( (double)$3, $5, $7 ); }
        | ORIENTATION '(' DOUBLE ',' INTEGER ',' DOUBLE ')' ';'
                                { $$ = orientation( $3, (double)$5, $7 ); }
        | ORIENTATION '(' DOUBLE ',' DOUBLE ',' INTEGER ')' ';'
                                { $$ = orientation( $3, $5, (double)$7 ); }
        | ORIENTATION '(' INTEGER ',' INTEGER ',' INTEGER ')' ';'
                                { $$ = orientation( (double)$3, (double)$5, (double)$7 ); }
        | ORIENTATION '(' DOUBLE ',' INTEGER ',' INTEGER ')' ';'
                                { $$ = orientation( $3, (double)$5, (double)$7 ); }
        | ORIENTATION '(' INTEGER ',' DOUBLE ',' INTEGER ')' ';'
                                { $$ = orientation( (double)$3, $5, (double)$7 ); }
        | ORIENTATION '(' INTEGER ',' INTEGER ',' DOUBLE ')' ';'
                                { $$ = orientation( (double)$3, (double)$5, $7 ); }
        ;

position:
          POSITION '(' DOUBLE ',' DOUBLE ',' DOUBLE ')' ';'
                                { $$ = position( $3, $5, $7 ); }
        | POSITION '(' INTEGER ',' DOUBLE ',' DOUBLE ')' ';'
                                { $$ = position( (double)$3, $5, $7 ); }
        | POSITION '(' DOUBLE ',' INTEGER ',' DOUBLE ')' ';'
                                { $$ = position( $3, (double)$5, $7 ); }
        | POSITION '(' DOUBLE ',' DOUBLE ',' INTEGER ')' ';'
                                { $$ = position( $3, $5, (double)$7 ); }
        | POSITION '(' INTEGER ',' INTEGER ',' INTEGER ')' ';'
                                { $$ = position( (double)$3, (double)$5, (double)$7 ); }
        | POSITION '(' DOUBLE ',' INTEGER ',' INTEGER ')' ';'
                                { $$ = position( $3, (double)$5, (double)$7 ); }
        | POSITION '(' INTEGER ',' DOUBLE ',' INTEGER ')' ';'
                                { $$ = position( (double)$3, $5, (double)$7 ); }
        | POSITION '(' INTEGER ',' INTEGER ',' DOUBLE ')' ';'
                                { $$ = position( (double)$3, (double)$5, $7 ); }
        ;

block:
          molecule_block        { $$ = $1; }
        | atom_block            { $$ = $1; }
        | bond_block            { $$ = $1; }
        | bend_block            { $$ = $1; }
        | torsion_block         { $$ = $1; }
        | zconstraint_block     { $$ = $1; }
        | component_block       { $$ = $1; }
        ;

molecule_block:
        MOLECULE '{' stmt_list '}'
                                { $$ = molecule_blk( $3 ); }
        ;

atom_block:
        ATOM ARRAY_INDEX '{' stmt_list '}'
                                { $$ = atom_blk( $2, $4 ); }
        ;
        
bond_block:
        BOND ARRAY_INDEX '{' stmt_list '}'
                                { $$ = bond_blk( $2, $4 ); }
        ;
        
bend_block:
        BEND ARRAY_INDEX '{' stmt_list '}'
                                { $$ = bend_blk( $2, $4 ); }
        ;
        
torsion_block:
        TORSION ARRAY_INDEX '{' stmt_list '}'
                                { $$ = torsion_blk( $2, $4 ); }
        ;

zconstraint_block:
        ZCONSTRAINT ARRAY_INDEX '{' stmt_list '}'
                                { $$ = zconstraint_blk( $2, $4 ); }
        ;
        
component_block:
        COMPONENT '{' stmt_list '}'
                                { $$ = component_blk( $3 ); }
        ;

stmt_list:
          stmt                  { $$ = $1; }
        | stmt_list stmt        { 
                                  $1->next_stmt = $2;
                                  $2->prev_stmt = $1;
                                  $$ = $2;
                                }
        ;

%%

int yyerror( char *err_msg ){

  sprintf( painCave.errMsg, "yacc parse error in %s at line %d: %s\n", 
           yyfile_name->my_name, yylineno, err_msg );
  painCave.isFatal = 1;
  simError();
  return 0;
}

void yacc_BASS( char* file_name ){

  FILE* in_file;

  head_node = (struct node_tag* )malloc( sizeof( node ) );

  head_node->type = GLOBAL_HEAD;
  head_node->index =0;
  head_node->next_stmt = NULL;
  head_node->prev_stmt = NULL;
  head_node->stmt_list = NULL;

  current_node = head_node;

  in_file = fopen( file_name, "r" );
  if( in_file == NULL ){
    sprintf( painCave.errMsg, "yacc error: couldn't open file =>%s\n", 
             file_name );
    painCave.isFatal = 1;
    simError();
  }

  yyfile_name = 
    (struct filename_list*)malloc( sizeof( struct filename_list ) );
  yyfile_name->next = NULL;
  strcpy( yyfile_name->my_name, file_name );
  change_in_file( in_file );
  
  yyparse();
  
#ifdef IS_MPI
  strcpy( checkPointMsg, "yyParse successful." );
  MPIcheckPoint();
  painCave.isEventLoop = 1;
#endif // is_mpi
  
  fclose( in_file );
  kill_lists();
  
  pt_me( head_node );

#ifdef IS_MPI
  painCave.isEventLoop = 0;
#endif // is_mpi
  
  kill_tree( head_node );
  head_node = NULL;
}
Revision:	854
Committed:	Thu Nov 6 19:24:31 2003 UTC (20 years, 8 months ago) by mmeineke
File size:	6548 byte(s)
Log Message:	fixed the includes in the Make.dep
#	User	Rev	Content
1	mmeineke	377
2			/* define some general tokens */
3
4			%token MOLECULE ATOM BOND BEND TORSION POSITION MEMBERS CONSTRAINT
5	mmeineke	675	%token COMPONENT START_INDEX DEFINED ORIENTATION ZCONSTRAINT
6	mmeineke	377
7			/* more advanced tokens */
8
9			%union {
10			int i_val; /* integer value */
11			double d_val; /* double value */
12			char * s_ptr; /* string pointer */
13			struct node_tag* node_ptr; /* pointer to the statement node tree */
14			}
15
16			%token <i_val> INTEGER
17			%token <i_val> ARRAY_INDEX
18
19			%token <d_val> DOUBLE
20
21			%token <s_ptr> IDENTIFIER
22			%token <s_ptr> QUOTED_STRING
23
24			%type <node_ptr> stmt
25			%type <node_ptr> stmt_list
26			%type <node_ptr> assignment
27			%type <node_ptr> member
28			%type <node_ptr> constraint
29			%type <node_ptr> orientation
30			%type <node_ptr> position
31			%type <node_ptr> block
32			%type <node_ptr> molecule_block
33			%type <node_ptr> atom_block
34			%type <node_ptr> bond_block
35			%type <node_ptr> bend_block
36			%type <node_ptr> torsion_block
37			%type <node_ptr> component_block
38	mmeineke	675	%type <node_ptr> zconstraint_block
39	mmeineke	377
40
41			%{
42			#include <stdlib.h>
43			#include <stdio.h>
44			#include <string.h>
45
46	mmeineke	854	#include "node_list.h"
47			#include "make_nodes.h"
48			#include "parse_tree.h"
49			#include "simError.h"
50	mmeineke	377	#ifdef IS_MPI
51			#define __is_lex__
52	mmeineke	854	#include "mpiBASS.h"
53	mmeineke	377	#endif
54
55			extern int yylineno;
56
57			struct filename_list{
58			char my_name[300];
59			struct filename_list* next;
60			};
61			extern struct filename_list* yyfile_name;
62
63			extern void change_in_file( FILE* in_file );
64			extern void yacc_model( char* file_name );
65			extern void kill_lists(void);
66
67			/* top of the node list */
68
69			struct node_tag* head_node;
70			struct node_tag* current_node;
71
72			%}
73
74			%%
75
76			program:
77			commands
78			;
79
80			commands: /* NULL */
81			\| commands stmt {
82			current_node->next_stmt = $2;
83			$2->prev_stmt = current_node;
84			current_node = $2;
85			}
86			;
87
88			stmt:
89			assignment { $$ = $1; }
90			\| member { $$ = $1; }
91			\| constraint { $$ = $1; }
92			\| orientation { $$ = $1; }
93			\| position { $$ = $1; }
94			\| block { $$ = $1; }
95			;
96
97			assignment:
98			IDENTIFIER '=' INTEGER ';'
99			{ $$ = assign_i( $1, $3 ); }
100			\| IDENTIFIER '=' DOUBLE ';'
101			{ $$ = assign_d( $1, $3 ); }
102			\| IDENTIFIER '=' IDENTIFIER ';'
103			{ $$ = assign_s( $1, $3 ); }
104			\| IDENTIFIER '=' QUOTED_STRING ';'
105			{ $$ = assign_s( $1, $3 ); }
106			;
107
108			member:
109			MEMBERS '(' INTEGER ',' INTEGER ')' ';'
110			{ $$ = members_2( $3, $5 ); }
111			\| MEMBERS '(' INTEGER ',' INTEGER ',' INTEGER ')' ';'
112			{ $$ = members_3( $3, $5, $7 ); }
113			\| MEMBERS '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')' ';'
114			{ $$ = members_4( $3, $5, $7, $9 ); }
115			;
116
117			constraint:
118			CONSTRAINT '(' INTEGER ')' ';'
119			{ $$ = constraint( (double)$3 ); }
120			\| CONSTRAINT '(' DOUBLE ')' ';'
121			{ $$ = constraint( $3 ); }
122			;
123
124			orientation:
125			ORIENTATION '(' DOUBLE ',' DOUBLE ',' DOUBLE ')' ';'
126			{ $$ = orientation( $3, $5, $7 ); }
127			\| ORIENTATION '(' INTEGER ',' DOUBLE ',' DOUBLE ')' ';'
128			{ $$ = orientation( (double)$3, $5, $7 ); }
129			\| ORIENTATION '(' DOUBLE ',' INTEGER ',' DOUBLE ')' ';'
130			{ $$ = orientation( $3, (double)$5, $7 ); }
131			\| ORIENTATION '(' DOUBLE ',' DOUBLE ',' INTEGER ')' ';'
132			{ $$ = orientation( $3, $5, (double)$7 ); }
133			\| ORIENTATION '(' INTEGER ',' INTEGER ',' INTEGER ')' ';'
134			{ $$ = orientation( (double)$3, (double)$5, (double)$7 ); }
135			\| ORIENTATION '(' DOUBLE ',' INTEGER ',' INTEGER ')' ';'
136			{ $$ = orientation( $3, (double)$5, (double)$7 ); }
137			\| ORIENTATION '(' INTEGER ',' DOUBLE ',' INTEGER ')' ';'
138			{ $$ = orientation( (double)$3, $5, (double)$7 ); }
139			\| ORIENTATION '(' INTEGER ',' INTEGER ',' DOUBLE ')' ';'
140			{ $$ = orientation( (double)$3, (double)$5, $7 ); }
141			;
142
143			position:
144			POSITION '(' DOUBLE ',' DOUBLE ',' DOUBLE ')' ';'
145			{ $$ = position( $3, $5, $7 ); }
146			\| POSITION '(' INTEGER ',' DOUBLE ',' DOUBLE ')' ';'
147			{ $$ = position( (double)$3, $5, $7 ); }
148			\| POSITION '(' DOUBLE ',' INTEGER ',' DOUBLE ')' ';'
149			{ $$ = position( $3, (double)$5, $7 ); }
150			\| POSITION '(' DOUBLE ',' DOUBLE ',' INTEGER ')' ';'
151			{ $$ = position( $3, $5, (double)$7 ); }
152			\| POSITION '(' INTEGER ',' INTEGER ',' INTEGER ')' ';'
153			{ $$ = position( (double)$3, (double)$5, (double)$7 ); }
154			\| POSITION '(' DOUBLE ',' INTEGER ',' INTEGER ')' ';'
155			{ $$ = position( $3, (double)$5, (double)$7 ); }
156			\| POSITION '(' INTEGER ',' DOUBLE ',' INTEGER ')' ';'
157			{ $$ = position( (double)$3, $5, (double)$7 ); }
158			\| POSITION '(' INTEGER ',' INTEGER ',' DOUBLE ')' ';'
159			{ $$ = position( (double)$3, (double)$5, $7 ); }
160			;
161
162			block:
163			molecule_block { $$ = $1; }
164			\| atom_block { $$ = $1; }
165			\| bond_block { $$ = $1; }
166			\| bend_block { $$ = $1; }
167			\| torsion_block { $$ = $1; }
168	mmeineke	675	\| zconstraint_block { $$ = $1; }
169	mmeineke	377	\| component_block { $$ = $1; }
170			;
171
172			molecule_block:
173			MOLECULE '{' stmt_list '}'
174			{ $$ = molecule_blk( $3 ); }
175			;
176
177			atom_block:
178			ATOM ARRAY_INDEX '{' stmt_list '}'
179			{ $$ = atom_blk( $2, $4 ); }
180			;
181
182			bond_block:
183			BOND ARRAY_INDEX '{' stmt_list '}'
184			{ $$ = bond_blk( $2, $4 ); }
185			;
186
187			bend_block:
188			BEND ARRAY_INDEX '{' stmt_list '}'
189			{ $$ = bend_blk( $2, $4 ); }
190			;
191
192			torsion_block:
193			TORSION ARRAY_INDEX '{' stmt_list '}'
194			{ $$ = torsion_blk( $2, $4 ); }
195			;
196	mmeineke	675
197			zconstraint_block:
198			ZCONSTRAINT ARRAY_INDEX '{' stmt_list '}'
199			{ $$ = zconstraint_blk( $2, $4 ); }
200			;
201	mmeineke	377
202			component_block:
203			COMPONENT '{' stmt_list '}'
204			{ $$ = component_blk( $3 ); }
205			;
206	mmeineke	675
207	mmeineke	377	stmt_list:
208			stmt { $$ = $1; }
209			\| stmt_list stmt {
210			$1->next_stmt = $2;
211			$2->prev_stmt = $1;
212			$$ = $2;
213			}
214			;
215
216			%%
217
218			int yyerror( char *err_msg ){
219
220			sprintf( painCave.errMsg, "yacc parse error in %s at line %d: %s\n",
221			yyfile_name->my_name, yylineno, err_msg );
222			painCave.isFatal = 1;
223			simError();
224			return 0;
225			}
226
227			void yacc_BASS( char* file_name ){
228
229			FILE* in_file;
230
231			head_node = (struct node_tag* )malloc( sizeof( node ) );
232
233			head_node->type = GLOBAL_HEAD;
234			head_node->index =0;
235			head_node->next_stmt = NULL;
236			head_node->prev_stmt = NULL;
237			head_node->stmt_list = NULL;
238
239			current_node = head_node;
240
241			in_file = fopen( file_name, "r" );
242			if( in_file == NULL ){
243			sprintf( painCave.errMsg, "yacc error: couldn't open file =>%s\n",
244			file_name );
245			painCave.isFatal = 1;
246			simError();
247			}
248
249			yyfile_name =
250			(struct filename_list*)malloc( sizeof( struct filename_list ) );
251			yyfile_name->next = NULL;
252			strcpy( yyfile_name->my_name, file_name );
253			change_in_file( in_file );
254
255			yyparse();
256
257			#ifdef IS_MPI
258			strcpy( checkPointMsg, "yyParse successful." );
259			MPIcheckPoint();
260			painCave.isEventLoop = 1;
261			#endif // is_mpi
262
263			fclose( in_file );
264			kill_lists();
265
266			pt_me( head_node );
267
268			#ifdef IS_MPI
269			painCave.isEventLoop = 0;
270			#endif // is_mpi
271
272			kill_tree( head_node );
273			head_node = NULL;
274			}