mdtools/BASS_parse/parse_tree.c

#include <stdlib.h>
#include <stdio.h>

#include "parse_tree.h"

void walk_down( struct node_tag* the_node, struct namespc the_namespc );
int mol_index; // keeps track of the number of molecules
int comp_index; // keeps track of the number of components.

/*
 * This is the parse tree function that is called by the yacc
 * routine. It passes the global node and namespace to the recursive
 * walk_down routine to explore the node tree.
 */

void pt_me( struct node_tag* head_node ){

  struct namespc global_namespc;
  
  if( head_node->type != GLOBAL_HEAD ){
    fprintf( stderr, "Parse tree error: "
             "The head node was not the global node.\n" );
  }

  global_namespc.index = 0;
  global_namespc.type = GLOBAL_HEAD;

  mol_index = 0;
  comp_index = 0;
  walk_down( head_node->next_stmt, global_namespc ); // closed global namespace + exit

}

/*
 * This is the main logic workhorse routine for the node tree
 * parser. It recursively walks down the node list and calls the
 * appropriate interface functions acording to the node types. It will
 * also set the appropriate namespace for the nodes.  
 *
 *       Note: the nodes only know about the namespace of their
 *       current level, the namespace above themselves is hidden.
 */

void walk_down( struct node_tag* the_node, struct namespc the_namespc ){
  
  struct namespc current_namespc;

  if( the_node != NULL ){
    
    if( the_node->type == GLOBAL_HEAD ){
      print_tree_error( the_node, "Too many global regions" );
      exit(0);
    }

    if( the_node->stmt_list != NULL ){

      // the statement is a block node of some sort
      
      switch( the_node->type ){

      case COMPONENT_HEAD:
        if( the_namespc.type != GLOBAL_HEAD ){
          print_tree_error( the_node, 
                            "component block is not in the global namespace" );
          exit(0);
        }
        else{
          init_component( comp_index );
          current_namespc.index = comp_index;
          current_namespc.type = COMPONENT_HEAD;
          walk_down( the_node->stmt_list, current_namespc );
          comp_index++;
        }
        break;

      case MOLECULE_HEAD:
        if( the_namespc.type != GLOBAL_HEAD ){
          print_tree_error( the_node, 
                            "Molecule block is not in the global namespace" );
          exit(0);
        }
        else{
          init_molecule( mol_index );
          current_namespc.index = mol_index;
          current_namespc.type = MOLECULE_HEAD;
          walk_down( the_node->stmt_list, current_namespc );
          mol_index++;
        }
        break;

      case ATOM_HEAD:
        if( the_namespc.type != MOLECULE_HEAD ){
          print_tree_error( the_node,
                            "The atom block is not in a molecule namespace" );
          exit(0);
        }
        else{
          init_atom( the_node->index );
          current_namespc.index = the_node->index;
          current_namespc.type = the_node->type;
          walk_down( the_node->stmt_list, current_namespc );
        }
        break;
        
      case BOND_HEAD:
        if( the_namespc.type != MOLECULE_HEAD ){
          print_tree_error( the_node,
                            "The bond block is not in a molecule namespace" );
          exit(0);
        }
        else{
          init_bond( the_node->index );
          current_namespc.index = the_node->index;
          current_namespc.type = the_node->type;
          walk_down( the_node->stmt_list, current_namespc );
        }
        break;

      case BEND_HEAD:
        if( the_namespc.type != MOLECULE_HEAD ){
          print_tree_error( the_node,
                            "The bend block is not in a molecule namespace" );
          exit(0);
        }
        else{
          init_bend( the_node->index );
          current_namespc.index = the_node->index;
          current_namespc.type = the_node->type;
          walk_down( the_node->stmt_list, current_namespc );
        }
        break;

      case TORSION_HEAD:
        if( the_namespc.type != MOLECULE_HEAD ){
          print_tree_error( the_node,
                            "The torsion block is not in "
                            "a molecule namespace" );
          exit(0);
        }
        else{
          init_torsion( the_node->index );
          current_namespc.index = the_node->index;
          current_namespc.type = the_node->type;
          walk_down( the_node->stmt_list, current_namespc );
        }
        break;
        
      default:
        print_tree_error( the_node, "Not a valid code block" );
        exit(0);
      }
    }
    
    else{
      
      // the node is a statement 

      switch( the_node->type ){

      case MEMBER_STMT:
        switch( the_namespc.type ){
        case BOND_HEAD: // fall through
        case BEND_HEAD: // fall through
        case TORSION_HEAD: // same for the first three
          init_members( the_node, the_namespc );
          break;

        default:
          print_tree_error( the_node, 
                            "Member statement not in a bond, bend, "
                            "or torsion" );
          exit(0);
          break;
        }
        break;

      case CONSTRAINT_STMT:
        switch( the_namespc.type ){
        case BOND_HEAD: // fall through
        case BEND_HEAD: // fall through
        case TORSION_HEAD: // same for the first three
          init_constraint( the_node, the_namespc );
          break;

        default:
          print_tree_error( the_node, 
                            "Constraint statement not in a bond, bend, "
                            "or torsion" );
          exit(0);
          break;
        }
        break;

      case ASSIGNMENT_STMT:
        init_assignment( the_node, the_namespc );
        break;

      case POSITION_STMT:
        if( the_namespc.type != ATOM_HEAD ){
          print_tree_error( the_node,
                            "position statement is not located in an "
                            "atom block" );
          exit(0);
        }
        
        init_position( the_node, the_namespc );
        break;

      case ORIENTATION_STMT:
        if( the_namespc.type != ATOM_HEAD ){
          print_tree_error( the_node,
                            "orientation statement is not located in an "
                            "atom block" );
          exit(0);
        }
        
        init_orientation( the_node, the_namespc );
        break;

      case START_INDEX_STMT:
        if( the_namespc.type != COMPONENT_HEAD ){
          print_tree_error( the_node,
                            "start_index statement is not located in an "
                            "component block" );
          exit(0);
        }
        
        init_start_index( the_node, the_namespc );
        break;

      default:
        print_tree_error( the_node, "unrecognized statement" );
        exit(0);
        break;
      }
    }
    
    // recurse down to the next node

    walk_down( the_node->next_stmt, the_namespc );
  }

  // send an end of block signal
  else end_of_block();
  
  // we're done
}


/*
 * This is a routine utilized by the node parsers to make printing
 * error messages easy.
 */

void print_tree_error( struct node_tag* err_node, char* err_msg ){

  switch( err_node->type ){

  case GLOBAL_HEAD:
    fprintf( stderr,
             "Parse tree error: global head node error -> %s\n",
             err_msg );
    break;
    
  case COMPONENT_HEAD:
    fprintf( stderr,
             "Parse tree error: component head node error -> %s\n",
             err_msg );
    break;

  case MOLECULE_HEAD:
    fprintf( stderr,
             "Parse tree error: molecule head node error -> %s\n",
             err_msg );
    break;

  case ATOM_HEAD:
    fprintf( stderr,
             "Parse tree error: atom head node error [%d] -> %s\n",
             err_node->index,
             err_msg );
    break;
    
  case BOND_HEAD:
    fprintf( stderr,
             "Parse tree error: bond head node error [%d] -> %s\n",
             err_node->index,
             err_msg );
    break;
    
  case BEND_HEAD:
    fprintf( stderr,
             "Parse tree error: bend head node error [%d] -> %s\n",
             err_node->index,
             err_msg );
    break;
    
  case TORSION_HEAD:
    fprintf( stderr,
             "Parse tree error: torsion head node error [%d] -> %s\n",
             err_node->index,
             err_msg );
    break;
    
  case MEMBER_STMT:
    fprintf( stderr,
             "Parse tree error: member node error => ( %d, %d, %d, %d )\n"
             "                  -> %s\n",
             err_node->the_data.mbr.a,
             err_node->the_data.mbr.b,
             err_node->the_data.mbr.c,
             err_node->the_data.mbr.d,
             err_msg );
    break;

  case CONSTRAINT_STMT:
    fprintf( stderr,
            "Parse tree error: constraint node error => ( %lf )\n"
            "                 -> %s\n",
            err_node->the_data.cnstr.constraint_val,
            err_msg );
    break;
    
  case ASSIGNMENT_STMT:
    fprintf( stderr,
             "Parse tree error: assignment node error\n"
             "                  => %s = ",
             err_node->the_data.asmt.identifier );
    
    switch( err_node->the_data.asmt.type ){
      
    case STR_ASSN:
      fprintf( stderr,
               "%s",
               err_node->the_data.asmt.rhs.str_ptr );
      break;
      
    case INT_ASSN:
      fprintf( stderr,
               "%d",
               err_node->the_data.asmt.rhs.i_val );
      break;
      
    case DOUBLE_ASSN:
      fprintf( stderr,
               "%lf",
               err_node->the_data.asmt.rhs.d_val );
      break;
    }
    
    fprintf( stderr,
             "\n"
             "                  -> %s\n",
             err_msg );
    break;

  case POSITION_STMT:
    fprintf( stderr,
             "Parse tree error: position node error => ( %lf, %lf, %lf )\n"
             "                  -> %s\n",
             err_node->the_data.pos.x, 
             err_node->the_data.pos.y, 
             err_node->the_data.pos.z, 
             err_msg );
    break;

  case ORIENTATION_STMT:
    fprintf( stderr,
             "Parse tree error: orientation node error => ( %lf, %lf, %lf )\n"
             "                  -> %s\n",
             err_node->the_data.ort.x, 
             err_node->the_data.ort.y, 
             err_node->the_data.ort.z, 
             err_msg );
    break;

  case START_INDEX_STMT:
    fprintf( stderr,
             "Parse tree error: start_index error -> %s\n",
             err_msg );
    break;


  default:
    fprintf( stderr,
             "Parse tree error: unknown node type -> %s\n",
             err_msg );
  }

#ifdef MPI
  mpiInterfaceExit();
#endif

}


/*
 * recursive walkdown and kill of the node tree
 * note: looks mighty similar to the walkdown routine.
 */ 
  
void kill_tree( struct node_tag* the_node ){
  
  // These two are needed to get rid of the integer list

  struct integer_list_tag* current_il;
  struct integer_list_tag* temp_il;


  if( the_node != NULL ){
    
    if( the_node->stmt_list != NULL ){

      // the statement is a block node of some sort
      
      kill_tree( the_node->stmt_list );
    }
    
    else{
      
      // the node is a statement 

      switch( the_node->type ){

      case ASSIGNMENT_STMT:
        
        if( the_node->the_data.asmt.type == STR_ASSN )
          free( the_node->the_data.asmt.rhs.str_ptr );
        
        free( the_node->the_data.asmt.identifier );
        break;

      case START_INDEX_STMT:
        
        current_il = the_node->the_data.il_head;
        while( current_il != NULL ){
          temp_il = current_il->next;
          free( current_il );
          current_il = temp_il;
        }
        the_node->the_data.il_head = NULL;
        break;

      default:
        // nothing to do here, everyone else can be freed normally.
        break;
      }
    }
    
    // recurse down to the next node

    kill_tree( the_node->next_stmt );
    free( the_node );    
  }

  // we're done
}
Revision:	118
Committed:	Wed Sep 25 22:51:14 2002 UTC (21 years, 9 months ago) by chuckv
Content type:	text/plain
File size:	10362 byte(s)
Log Message:	begin the pain that is MPI. abandon all hope ye who check out this branch.. P.S. we've added consistent BASS error checking
#	User	Rev	Content
1	mmeineke	10	#include <stdlib.h>
2			#include <stdio.h>
3
4			#include "parse_tree.h"
5
6			void walk_down( struct node_tag* the_node, struct namespc the_namespc );
7			int mol_index; // keeps track of the number of molecules
8			int comp_index; // keeps track of the number of components.
9
10			/*
11			* This is the parse tree function that is called by the yacc
12			* routine. It passes the global node and namespace to the recursive
13			* walk_down routine to explore the node tree.
14			*/
15
16			void pt_me( struct node_tag* head_node ){
17
18			struct namespc global_namespc;
19
20			if( head_node->type != GLOBAL_HEAD ){
21			fprintf( stderr, "Parse tree error: "
22			"The head node was not the global node.\n" );
23			}
24
25			global_namespc.index = 0;
26			global_namespc.type = GLOBAL_HEAD;
27
28			mol_index = 0;
29			comp_index = 0;
30	chuckv	118	walk_down( head_node->next_stmt, global_namespc ); // closed global namespace + exit
31
32	mmeineke	10	}
33
34			/*
35			* This is the main logic workhorse routine for the node tree
36			* parser. It recursively walks down the node list and calls the
37			* appropriate interface functions acording to the node types. It will
38			* also set the appropriate namespace for the nodes.
39			*
40			* Note: the nodes only know about the namespace of their
41			* current level, the namespace above themselves is hidden.
42			*/
43
44			void walk_down( struct node_tag* the_node, struct namespc the_namespc ){
45
46			struct namespc current_namespc;
47
48			if( the_node != NULL ){
49
50			if( the_node->type == GLOBAL_HEAD ){
51			print_tree_error( the_node, "Too many global regions" );
52			exit(0);
53			}
54
55			if( the_node->stmt_list != NULL ){
56
57			// the statement is a block node of some sort
58
59			switch( the_node->type ){
60
61			case COMPONENT_HEAD:
62			if( the_namespc.type != GLOBAL_HEAD ){
63			print_tree_error( the_node,
64			"component block is not in the global namespace" );
65			exit(0);
66			}
67			else{
68			init_component( comp_index );
69			current_namespc.index = comp_index;
70			current_namespc.type = COMPONENT_HEAD;
71			walk_down( the_node->stmt_list, current_namespc );
72			comp_index++;
73			}
74			break;
75
76			case MOLECULE_HEAD:
77			if( the_namespc.type != GLOBAL_HEAD ){
78			print_tree_error( the_node,
79			"Molecule block is not in the global namespace" );
80			exit(0);
81			}
82			else{
83			init_molecule( mol_index );
84			current_namespc.index = mol_index;
85			current_namespc.type = MOLECULE_HEAD;
86			walk_down( the_node->stmt_list, current_namespc );
87			mol_index++;
88			}
89			break;
90
91			case ATOM_HEAD:
92			if( the_namespc.type != MOLECULE_HEAD ){
93			print_tree_error( the_node,
94			"The atom block is not in a molecule namespace" );
95			exit(0);
96			}
97			else{
98			init_atom( the_node->index );
99			current_namespc.index = the_node->index;
100			current_namespc.type = the_node->type;
101			walk_down( the_node->stmt_list, current_namespc );
102			}
103			break;
104
105			case BOND_HEAD:
106			if( the_namespc.type != MOLECULE_HEAD ){
107			print_tree_error( the_node,
108			"The bond block is not in a molecule namespace" );
109			exit(0);
110			}
111			else{
112			init_bond( the_node->index );
113			current_namespc.index = the_node->index;
114			current_namespc.type = the_node->type;
115			walk_down( the_node->stmt_list, current_namespc );
116			}
117			break;
118
119			case BEND_HEAD:
120			if( the_namespc.type != MOLECULE_HEAD ){
121			print_tree_error( the_node,
122			"The bend block is not in a molecule namespace" );
123			exit(0);
124			}
125			else{
126			init_bend( the_node->index );
127			current_namespc.index = the_node->index;
128			current_namespc.type = the_node->type;
129			walk_down( the_node->stmt_list, current_namespc );
130			}
131			break;
132
133			case TORSION_HEAD:
134			if( the_namespc.type != MOLECULE_HEAD ){
135			print_tree_error( the_node,
136			"The torsion block is not in "
137			"a molecule namespace" );
138			exit(0);
139			}
140			else{
141			init_torsion( the_node->index );
142			current_namespc.index = the_node->index;
143			current_namespc.type = the_node->type;
144			walk_down( the_node->stmt_list, current_namespc );
145			}
146			break;
147
148			default:
149			print_tree_error( the_node, "Not a valid code block" );
150			exit(0);
151			}
152			}
153
154			else{
155
156			// the node is a statement
157
158			switch( the_node->type ){
159
160			case MEMBER_STMT:
161			switch( the_namespc.type ){
162			case BOND_HEAD: // fall through
163			case BEND_HEAD: // fall through
164			case TORSION_HEAD: // same for the first three
165			init_members( the_node, the_namespc );
166			break;
167
168			default:
169			print_tree_error( the_node,
170			"Member statement not in a bond, bend, "
171			"or torsion" );
172			exit(0);
173			break;
174			}
175			break;
176
177			case CONSTRAINT_STMT:
178			switch( the_namespc.type ){
179			case BOND_HEAD: // fall through
180			case BEND_HEAD: // fall through
181			case TORSION_HEAD: // same for the first three
182			init_constraint( the_node, the_namespc );
183			break;
184
185			default:
186			print_tree_error( the_node,
187			"Constraint statement not in a bond, bend, "
188			"or torsion" );
189			exit(0);
190			break;
191			}
192			break;
193
194			case ASSIGNMENT_STMT:
195			init_assignment( the_node, the_namespc );
196			break;
197
198			case POSITION_STMT:
199			if( the_namespc.type != ATOM_HEAD ){
200			print_tree_error( the_node,
201			"position statement is not located in an "
202			"atom block" );
203			exit(0);
204			}
205
206			init_position( the_node, the_namespc );
207			break;
208
209			case ORIENTATION_STMT:
210			if( the_namespc.type != ATOM_HEAD ){
211			print_tree_error( the_node,
212			"orientation statement is not located in an "
213			"atom block" );
214			exit(0);
215			}
216
217			init_orientation( the_node, the_namespc );
218			break;
219
220			case START_INDEX_STMT:
221			if( the_namespc.type != COMPONENT_HEAD ){
222			print_tree_error( the_node,
223			"start_index statement is not located in an "
224			"component block" );
225			exit(0);
226			}
227
228			init_start_index( the_node, the_namespc );
229			break;
230
231			default:
232			print_tree_error( the_node, "unrecognized statement" );
233			exit(0);
234			break;
235			}
236			}
237
238			// recurse down to the next node
239
240			walk_down( the_node->next_stmt, the_namespc );
241			}
242
243			// send an end of block signal
244			else end_of_block();
245
246			// we're done
247			}
248
249
250
251			/*
252			* This is a routine utilized by the node parsers to make printing
253			* error messages easy.
254			*/
255
256			void print_tree_error( struct node_tag* err_node, char* err_msg ){
257
258			switch( err_node->type ){
259
260			case GLOBAL_HEAD:
261			fprintf( stderr,
262			"Parse tree error: global head node error -> %s\n",
263			err_msg );
264			break;
265
266			case COMPONENT_HEAD:
267			fprintf( stderr,
268			"Parse tree error: component head node error -> %s\n",
269			err_msg );
270			break;
271
272			case MOLECULE_HEAD:
273			fprintf( stderr,
274			"Parse tree error: molecule head node error -> %s\n",
275			err_msg );
276			break;
277
278			case ATOM_HEAD:
279			fprintf( stderr,
280			"Parse tree error: atom head node error [%d] -> %s\n",
281			err_node->index,
282			err_msg );
283			break;
284
285			case BOND_HEAD:
286			fprintf( stderr,
287			"Parse tree error: bond head node error [%d] -> %s\n",
288			err_node->index,
289			err_msg );
290			break;
291
292			case BEND_HEAD:
293			fprintf( stderr,
294			"Parse tree error: bend head node error [%d] -> %s\n",
295			err_node->index,
296			err_msg );
297			break;
298
299			case TORSION_HEAD:
300			fprintf( stderr,
301			"Parse tree error: torsion head node error [%d] -> %s\n",
302			err_node->index,
303			err_msg );
304			break;
305
306			case MEMBER_STMT:
307			fprintf( stderr,
308			"Parse tree error: member node error => ( %d, %d, %d, %d )\n"
309			" -> %s\n",
310			err_node->the_data.mbr.a,
311			err_node->the_data.mbr.b,
312			err_node->the_data.mbr.c,
313			err_node->the_data.mbr.d,
314			err_msg );
315			break;
316
317			case CONSTRAINT_STMT:
318			fprintf( stderr,
319			"Parse tree error: constraint node error => ( %lf )\n"
320			" -> %s\n",
321			err_node->the_data.cnstr.constraint_val,
322			err_msg );
323			break;
324
325			case ASSIGNMENT_STMT:
326			fprintf( stderr,
327			"Parse tree error: assignment node error\n"
328			" => %s = ",
329			err_node->the_data.asmt.identifier );
330
331			switch( err_node->the_data.asmt.type ){
332
333			case STR_ASSN:
334			fprintf( stderr,
335			"%s",
336	mmeineke	117	err_node->the_data.asmt.rhs.str_ptr );
337	mmeineke	10	break;
338
339			case INT_ASSN:
340			fprintf( stderr,
341			"%d",
342	mmeineke	117	err_node->the_data.asmt.rhs.i_val );
343	mmeineke	10	break;
344
345			case DOUBLE_ASSN:
346			fprintf( stderr,
347			"%lf",
348	mmeineke	117	err_node->the_data.asmt.rhs.d_val );
349	mmeineke	10	break;
350			}
351
352			fprintf( stderr,
353			"\n"
354			" -> %s\n",
355			err_msg );
356			break;
357
358			case POSITION_STMT:
359			fprintf( stderr,
360			"Parse tree error: position node error => ( %lf, %lf, %lf )\n"
361			" -> %s\n",
362	mmeineke	117	err_node->the_data.pos.x,
363			err_node->the_data.pos.y,
364			err_node->the_data.pos.z,
365	mmeineke	10	err_msg );
366			break;
367
368			case ORIENTATION_STMT:
369			fprintf( stderr,
370			"Parse tree error: orientation node error => ( %lf, %lf, %lf )\n"
371			" -> %s\n",
372	mmeineke	117	err_node->the_data.ort.x,
373			err_node->the_data.ort.y,
374			err_node->the_data.ort.z,
375	mmeineke	10	err_msg );
376			break;
377
378			case START_INDEX_STMT:
379			fprintf( stderr,
380			"Parse tree error: start_index error -> %s\n",
381			err_msg );
382			break;
383
384
385			default:
386			fprintf( stderr,
387			"Parse tree error: unknown node type -> %s\n",
388			err_msg );
389			}
390	chuckv	118
391			#ifdef MPI
392			mpiInterfaceExit();
393			#endif
394
395	mmeineke	10	}
396
397
398			/*
399			* recursive walkdown and kill of the node tree
400			* note: looks mighty similar to the walkdown routine.
401			*/
402
403			void kill_tree( struct node_tag* the_node ){
404
405			// These two are needed to get rid of the integer list
406
407			struct integer_list_tag* current_il;
408			struct integer_list_tag* temp_il;
409
410
411			if( the_node != NULL ){
412
413			if( the_node->stmt_list != NULL ){
414
415			// the statement is a block node of some sort
416
417			kill_tree( the_node->stmt_list );
418			}
419
420			else{
421
422			// the node is a statement
423
424			switch( the_node->type ){
425
426			case ASSIGNMENT_STMT:
427
428			if( the_node->the_data.asmt.type == STR_ASSN )
429			free( the_node->the_data.asmt.rhs.str_ptr );
430
431			free( the_node->the_data.asmt.identifier );
432			break;
433
434			case START_INDEX_STMT:
435
436			current_il = the_node->the_data.il_head;
437			while( current_il != NULL ){
438			temp_il = current_il->next;
439			free( current_il );
440			current_il = temp_il;
441			}
442			the_node->the_data.il_head = NULL;
443			break;
444
445			default:
446			// nothing to do here, everyone else can be freed normally.
447			break;
448			}
449			}
450
451			// recurse down to the next node
452
453			kill_tree( the_node->next_stmt );
454			free( the_node );
455			}
456
457			// we're done
458			}