OOPSE/libBASS/BASSyacc.y


/* define some general tokens */

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

/* 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
%token <s_ptr> LIST_STRING

%type <node_ptr> stmt
%type <node_ptr> stmt_list
%type <node_ptr> assignment
%type <node_ptr> members
%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
%type <node_ptr> rigidbody_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; }
        | members               { $$ = $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 ); }
        ;

members:
          MEMBERS LIST_STRING ';'
                                { $$ = members( $2 ); }
        ;

constraint:
          CONSTRAINT LIST_STRING ';'
                                { $$ = constraint( $2 ); }
        ;

orientation:
          ORIENTATION LIST_STRING ';'
                                { $$ = orientation( $2 ); }
        ;

position:
          POSITION LIST_STRING ';'
                                { $$ = position( $2 ); }
        ;

block:
          molecule_block        { $$ = $1; }
        | atom_block            { $$ = $1; }
        | bond_block            { $$ = $1; }
        | bend_block            { $$ = $1; }
        | torsion_block         { $$ = $1; }
        | zconstraint_block     { $$ = $1; }
        | rigidbody_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 ); }
        ;

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