src/io/parse_tree.c

/*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Acknowledgement of the program authors must be made in any
 *    publication of scientific results based in part on use of the
 *    program.  An acceptable form of acknowledgement is citation of
 *    the article in which the program was described (Matthew
 *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
 *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
 *    Parallel Simulation Engine for Molecular Dynamics,"
 *    J. Comput. Chem. 26, pp. 252-271 (2005))
 *
 * 2. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 3. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 */
 
#include <stdlib.h>
#include <stdio.h>

#include "io/parse_tree.h"
#include "utils/simError.h"

#ifdef IS_MPI
#define __is_lex__
#include "io/mpiBASS.h"
#endif

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 ){
    sprintf( painCave.errMsg, 
             "Parse tree error: The head node was not the global node.\n" );
    painCave.isFatal = 1;
    simError();
#ifdef IS_MPI
    mpiInterfaceExit();
#endif //is_mpi
  }

  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 and 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" );
    }

    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" );
        }
        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" );
        }
        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" );
        }
        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 RIGIDBODY_HEAD:
        if( the_namespc.type != MOLECULE_HEAD ){
          print_tree_error( the_node,
                            "The RigidBody block is not in a Molecule namespace" );
        }
        else{
          init_rigidbody( 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 CUTOFFGROUP_HEAD:
        if( the_namespc.type != MOLECULE_HEAD ){
          print_tree_error( the_node,
                            "The CutoffGroup block is not in a Molecule namespace" );
        }
        else{
          init_cutoffgroup( 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" );
        }
        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" );
        }
        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" );
        }
        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;
      
      case ZCONSTRAINT_HEAD:
        if( the_namespc.type != GLOBAL_HEAD ){
          print_tree_error( the_node,
                            "The Zconstraint block is not in "
                            "the global namespace" );
        }
        else{
          init_zconstraint( 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" );
      }
    }
    
    else{
      
      // the node is a statement 

      switch( the_node->type ){

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

        default:
          print_tree_error( the_node, 
                            "Members statement not in a bond, bend, "
                            "torsion, RigidBody, or CutoffGroup" );
          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" );
          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" );
        }
        
        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" );
        }
        
        init_orientation( the_node, the_namespc );
        break;

      default:
        print_tree_error( the_node, "unrecognized statement" );
        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:
    sprintf( painCave.errMsg,
             "Parse tree error: global head node error -> %s\n",
             err_msg );
    break;
    
  case COMPONENT_HEAD:
    sprintf( painCave.errMsg,
             "Parse tree error: component head node error -> %s\n",
             err_msg );
    break;

  case MOLECULE_HEAD:
    sprintf( painCave.errMsg,
             "Parse tree error: molecule head node error -> %s\n",
             err_msg );
    break;

  case RIGIDBODY_HEAD:
    sprintf( painCave.errMsg,
             "Parse tree error: rigidBody head node error -> %s\n",
             err_msg );
    break;
    
  case CUTOFFGROUP_HEAD:
    sprintf( painCave.errMsg,
             "Parse tree error: CutoffGroup head node error -> %s\n",
             err_msg );
    break;

  case ATOM_HEAD:
    sprintf( painCave.errMsg,
             "Parse tree error: atom head node error [%d] -> %s\n",
             err_node->index,
             err_msg );
    break;
    
  case BOND_HEAD:
    sprintf( painCave.errMsg,
             "Parse tree error: bond head node error [%d] -> %s\n",
             err_node->index,
             err_msg );
    break;
    
  case BEND_HEAD:
    sprintf( painCave.errMsg,
             "Parse tree error: bend head node error [%d] -> %s\n",
             err_node->index,
             err_msg );
    break;
      
  case ZCONSTRAINT_HEAD:
    sprintf( painCave.errMsg,
             "Parse tree error: Zconstraint head node error [%d] -> %s\n",
             err_node->index,
             err_msg );
    break;

  case MEMBERS_STMT:
    sprintf( painCave.errMsg,
             "Parse tree error: members node error (nMembers = %d)\n"
             "                  -> %s\n",
             err_node->the_data.mbrs.nMembers,
             err_msg );
    break;

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

  case POSITION_STMT:
    sprintf( painCave.errMsg,
             "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:
    sprintf( painCave.errMsg,
             "Parse tree error: orientation node error => ( %lf, %lf, %lf )\n"
             "                  -> %s\n",
             err_node->the_data.ort.phi, 
             err_node->the_data.ort.theta, 
             err_node->the_data.ort.psi, 
             err_msg );
    break;

  default:
    sprintf( painCave.errMsg,
             "Parse tree error: unknown node type -> %s\n",
             err_msg );
  }

  painCave.isFatal = 1;
  simError();
#ifdef IS_MPI
  mpiInterfaceExit();
#endif //is_mpi

}


/*
 * recursive walkdown and kill of the node tree
 * note: looks mighty similar to the walkdown routine.
 */ 
  
void kill_tree( struct node_tag* the_node ){
  

  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 MEMBERS_STMT:

        if (the_node->the_data.mbrs.nMembers >0 ){
          free(the_node->the_data.mbrs.memberList);
        }
        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:	507
Committed:	Fri Apr 15 22:04:00 2005 UTC (20 years ago) by gezelter
Content type:	text/plain
File size:	13505 byte(s)
Log Message:	xemacs has been drafted to perform our indentation services
#	User	Rev	Content
1	gezelter	507	/*
2	gezelter	246	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3			*
4			* The University of Notre Dame grants you ("Licensee") a
5			* non-exclusive, royalty free, license to use, modify and
6			* redistribute this software in source and binary code form, provided
7			* that the following conditions are met:
8			*
9			* 1. Acknowledgement of the program authors must be made in any
10			* publication of scientific results based in part on use of the
11			* program. An acceptable form of acknowledgement is citation of
12			* the article in which the program was described (Matthew
13			* A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14			* J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15			* Parallel Simulation Engine for Molecular Dynamics,"
16			* J. Comput. Chem. 26, pp. 252-271 (2005))
17			*
18			* 2. Redistributions of source code must retain the above copyright
19			* notice, this list of conditions and the following disclaimer.
20			*
21			* 3. Redistributions in binary form must reproduce the above copyright
22			* notice, this list of conditions and the following disclaimer in the
23			* documentation and/or other materials provided with the
24			* distribution.
25			*
26			* This software is provided "AS IS," without a warranty of any
27			* kind. All express or implied conditions, representations and
28			* warranties, including any implied warranty of merchantability,
29			* fitness for a particular purpose or non-infringement, are hereby
30			* excluded. The University of Notre Dame and its licensors shall not
31			* be liable for any damages suffered by licensee as a result of
32			* using, modifying or distributing the software or its
33			* derivatives. In no event will the University of Notre Dame or its
34			* licensors be liable for any lost revenue, profit or data, or for
35			* direct, indirect, special, consequential, incidental or punitive
36			* damages, however caused and regardless of the theory of liability,
37			* arising out of the use of or inability to use software, even if the
38			* University of Notre Dame has been advised of the possibility of
39			* such damages.
40			*/
41
42	gezelter	2	#include <stdlib.h>
43			#include <stdio.h>
44
45	tim	3	#include "io/parse_tree.h"
46			#include "utils/simError.h"
47	gezelter	2
48			#ifdef IS_MPI
49			#define __is_lex__
50	tim	3	#include "io/mpiBASS.h"
51	gezelter	2	#endif
52
53			void walk_down( struct node_tag* the_node, struct namespc the_namespc );
54			int mol_index; // keeps track of the number of molecules
55			int comp_index; // keeps track of the number of components.
56
57			/*
58			* This is the parse tree function that is called by the yacc
59			* routine. It passes the global node and namespace to the recursive
60			* walk_down routine to explore the node tree.
61			*/
62
63			void pt_me( struct node_tag* head_node ){
64
65			struct namespc global_namespc;
66
67			if( head_node->type != GLOBAL_HEAD ){
68			sprintf( painCave.errMsg,
69			"Parse tree error: The head node was not the global node.\n" );
70			painCave.isFatal = 1;
71			simError();
72			#ifdef IS_MPI
73			mpiInterfaceExit();
74			#endif //is_mpi
75			}
76
77			global_namespc.index = 0;
78			global_namespc.type = GLOBAL_HEAD;
79
80			mol_index = 0;
81			comp_index = 0;
82			walk_down( head_node->next_stmt, global_namespc );
83			// closed global namespace and exit
84
85			}
86
87			/*
88			* This is the main logic workhorse routine for the node tree
89			* parser. It recursively walks down the node list and calls the
90			* appropriate interface functions acording to the node types. It will
91			* also set the appropriate namespace for the nodes.
92			*
93			* Note: the nodes only know about the namespace of their
94			* current level, the namespace above themselves is hidden.
95			*/
96
97			void walk_down( struct node_tag* the_node, struct namespc the_namespc ){
98
99			struct namespc current_namespc;
100
101			if( the_node != NULL ){
102
103			if( the_node->type == GLOBAL_HEAD ){
104			print_tree_error( the_node, "Too many global regions" );
105			}
106
107			if( the_node->stmt_list != NULL ){
108
109			// the statement is a block node of some sort
110
111			switch( the_node->type ){
112
113			case COMPONENT_HEAD:
114			if( the_namespc.type != GLOBAL_HEAD ){
115			print_tree_error( the_node,
116			"component block is not in the global namespace" );
117			}
118			else{
119			init_component( comp_index );
120			current_namespc.index = comp_index;
121			current_namespc.type = COMPONENT_HEAD;
122			walk_down( the_node->stmt_list, current_namespc );
123			comp_index++;
124			}
125			break;
126
127			case MOLECULE_HEAD:
128			if( the_namespc.type != GLOBAL_HEAD ){
129			print_tree_error( the_node,
130			"Molecule block is not in the global namespace" );
131			}
132			else{
133			init_molecule( mol_index );
134			current_namespc.index = mol_index;
135			current_namespc.type = MOLECULE_HEAD;
136			walk_down( the_node->stmt_list, current_namespc );
137			mol_index++;
138			}
139			break;
140
141			case ATOM_HEAD:
142			if( the_namespc.type != MOLECULE_HEAD ){
143	gezelter	507	print_tree_error( the_node,
144	gezelter	2	"The atom block is not in a molecule namespace" );
145			}
146			else{
147			init_atom( the_node->index );
148			current_namespc.index = the_node->index;
149			current_namespc.type = the_node->type;
150			walk_down( the_node->stmt_list, current_namespc );
151			}
152			break;
153
154			case RIGIDBODY_HEAD:
155			if( the_namespc.type != MOLECULE_HEAD ){
156			print_tree_error( the_node,
157			"The RigidBody block is not in a Molecule namespace" );
158			}
159			else{
160			init_rigidbody( the_node->index );
161			current_namespc.index = the_node->index;
162			current_namespc.type = the_node->type;
163			walk_down( the_node->stmt_list, current_namespc );
164			}
165			break;
166
167			case CUTOFFGROUP_HEAD:
168			if( the_namespc.type != MOLECULE_HEAD ){
169			print_tree_error( the_node,
170			"The CutoffGroup block is not in a Molecule namespace" );
171			}
172			else{
173			init_cutoffgroup( the_node->index );
174			current_namespc.index = the_node->index;
175			current_namespc.type = the_node->type;
176			walk_down( the_node->stmt_list, current_namespc );
177			}
178			break;
179
180			case BOND_HEAD:
181			if( the_namespc.type != MOLECULE_HEAD ){
182			print_tree_error( the_node,
183			"The bond block is not in a molecule namespace" );
184			}
185			else{
186			init_bond( the_node->index );
187			current_namespc.index = the_node->index;
188			current_namespc.type = the_node->type;
189			walk_down( the_node->stmt_list, current_namespc );
190			}
191			break;
192
193			case BEND_HEAD:
194			if( the_namespc.type != MOLECULE_HEAD ){
195			print_tree_error( the_node,
196			"The bend block is not in a molecule namespace" );
197			}
198			else{
199			init_bend( the_node->index );
200			current_namespc.index = the_node->index;
201			current_namespc.type = the_node->type;
202			walk_down( the_node->stmt_list, current_namespc );
203			}
204			break;
205
206			case TORSION_HEAD:
207			if( the_namespc.type != MOLECULE_HEAD ){
208			print_tree_error( the_node,
209			"The torsion block is not in "
210			"a molecule namespace" );
211			}
212			else{
213			init_torsion( the_node->index );
214			current_namespc.index = the_node->index;
215			current_namespc.type = the_node->type;
216			walk_down( the_node->stmt_list, current_namespc );
217			}
218			break;
219
220			case ZCONSTRAINT_HEAD:
221			if( the_namespc.type != GLOBAL_HEAD ){
222			print_tree_error( the_node,
223			"The Zconstraint block is not in "
224			"the global namespace" );
225			}
226			else{
227			init_zconstraint( the_node->index );
228			current_namespc.index = the_node->index;
229			current_namespc.type = the_node->type;
230			walk_down( the_node->stmt_list, current_namespc );
231			}
232			break;
233
234			default:
235			print_tree_error( the_node, "Not a valid code block" );
236			}
237			}
238
239			else{
240
241			// the node is a statement
242
243			switch( the_node->type ){
244
245			case MEMBERS_STMT:
246			switch( the_namespc.type ){
247			case BOND_HEAD: // fall through
248			case BEND_HEAD: // fall through
249			case TORSION_HEAD:
250			case RIGIDBODY_HEAD:
251			case CUTOFFGROUP_HEAD: // same for the first four
252			init_members( the_node, the_namespc );
253			break;
254
255			default:
256			print_tree_error( the_node,
257			"Members statement not in a bond, bend, "
258			"torsion, RigidBody, or CutoffGroup" );
259			break;
260			}
261			break;
262
263			case CONSTRAINT_STMT:
264			switch( the_namespc.type ){
265			case BOND_HEAD: // fall through
266			case BEND_HEAD: // fall through
267			case TORSION_HEAD: // same for the first three
268			init_constraint( the_node, the_namespc );
269			break;
270
271			default:
272			print_tree_error( the_node,
273			"Constraint statement not in a bond, bend, "
274			"or torsion" );
275			break;
276			}
277			break;
278
279			case ASSIGNMENT_STMT:
280			init_assignment( the_node, the_namespc );
281			break;
282
283			case POSITION_STMT:
284			if( the_namespc.type != ATOM_HEAD ){
285			print_tree_error( the_node,
286			"position statement is not located in an "
287			"atom block" );
288			}
289
290			init_position( the_node, the_namespc );
291			break;
292
293			case ORIENTATION_STMT:
294			if( the_namespc.type != ATOM_HEAD ){
295			print_tree_error( the_node,
296			"orientation statement is not located in an "
297			"atom block" );
298			}
299
300			init_orientation( the_node, the_namespc );
301			break;
302
303			default:
304			print_tree_error( the_node, "unrecognized statement" );
305			break;
306			}
307			}
308
309			// recurse down to the next node
310
311			walk_down( the_node->next_stmt, the_namespc );
312			}
313
314			// send an end of block signal
315			else end_of_block();
316
317			// we're done
318			}
319
320
321
322			/*
323			* This is a routine utilized by the node parsers to make printing
324			* error messages easy.
325			*/
326
327			void print_tree_error( struct node_tag* err_node, char* err_msg ){
328
329			switch( err_node->type ){
330
331			case GLOBAL_HEAD:
332			sprintf( painCave.errMsg,
333			"Parse tree error: global head node error -> %s\n",
334			err_msg );
335			break;
336
337			case COMPONENT_HEAD:
338			sprintf( painCave.errMsg,
339			"Parse tree error: component head node error -> %s\n",
340			err_msg );
341			break;
342
343			case MOLECULE_HEAD:
344			sprintf( painCave.errMsg,
345			"Parse tree error: molecule head node error -> %s\n",
346			err_msg );
347			break;
348
349			case RIGIDBODY_HEAD:
350			sprintf( painCave.errMsg,
351			"Parse tree error: rigidBody head node error -> %s\n",
352			err_msg );
353			break;
354
355			case CUTOFFGROUP_HEAD:
356			sprintf( painCave.errMsg,
357			"Parse tree error: CutoffGroup head node error -> %s\n",
358			err_msg );
359			break;
360
361			case ATOM_HEAD:
362			sprintf( painCave.errMsg,
363			"Parse tree error: atom head node error [%d] -> %s\n",
364			err_node->index,
365			err_msg );
366			break;
367
368			case BOND_HEAD:
369			sprintf( painCave.errMsg,
370			"Parse tree error: bond head node error [%d] -> %s\n",
371			err_node->index,
372			err_msg );
373			break;
374
375			case BEND_HEAD:
376			sprintf( painCave.errMsg,
377			"Parse tree error: bend head node error [%d] -> %s\n",
378			err_node->index,
379			err_msg );
380			break;
381
382			case ZCONSTRAINT_HEAD:
383			sprintf( painCave.errMsg,
384			"Parse tree error: Zconstraint head node error [%d] -> %s\n",
385			err_node->index,
386			err_msg );
387			break;
388
389			case MEMBERS_STMT:
390			sprintf( painCave.errMsg,
391			"Parse tree error: members node error (nMembers = %d)\n"
392			" -> %s\n",
393			err_node->the_data.mbrs.nMembers,
394			err_msg );
395			break;
396
397			case CONSTRAINT_STMT:
398			sprintf( painCave.errMsg,
399	gezelter	507	"Parse tree error: constraint node error => ( %lf )\n"
400			" -> %s\n",
401			err_node->the_data.cnstr.constraint_val,
402			err_msg );
403	gezelter	2	break;
404
405			case ASSIGNMENT_STMT:
406			sprintf( painCave.errMsg,
407			"Parse tree error: assignment node error\n"
408			" => %s = ",
409			err_node->the_data.asmt.identifier );
410
411			switch( err_node->the_data.asmt.type ){
412
413			case STR_ASSN:
414			sprintf( painCave.errMsg,
415			"%s",
416			err_node->the_data.asmt.rhs.str_ptr );
417			break;
418
419			case INT_ASSN:
420			sprintf( painCave.errMsg,
421			"%d",
422			err_node->the_data.asmt.rhs.i_val );
423			break;
424
425			case DOUBLE_ASSN:
426			sprintf( painCave.errMsg,
427			"%lf",
428			err_node->the_data.asmt.rhs.d_val );
429			break;
430			}
431
432			sprintf( painCave.errMsg,
433			"\n"
434			" -> %s\n",
435			err_msg );
436			break;
437
438			case POSITION_STMT:
439			sprintf( painCave.errMsg,
440			"Parse tree error: position node error => ( %lf, %lf, %lf )\n"
441			" -> %s\n",
442			err_node->the_data.pos.x,
443			err_node->the_data.pos.y,
444			err_node->the_data.pos.z,
445			err_msg );
446			break;
447
448			case ORIENTATION_STMT:
449			sprintf( painCave.errMsg,
450			"Parse tree error: orientation node error => ( %lf, %lf, %lf )\n"
451			" -> %s\n",
452			err_node->the_data.ort.phi,
453			err_node->the_data.ort.theta,
454			err_node->the_data.ort.psi,
455			err_msg );
456			break;
457
458			default:
459			sprintf( painCave.errMsg,
460			"Parse tree error: unknown node type -> %s\n",
461			err_msg );
462			}
463
464			painCave.isFatal = 1;
465			simError();
466			#ifdef IS_MPI
467			mpiInterfaceExit();
468			#endif //is_mpi
469
470			}
471
472
473			/*
474			* recursive walkdown and kill of the node tree
475			* note: looks mighty similar to the walkdown routine.
476			*/
477
478			void kill_tree( struct node_tag* the_node ){
479
480
481			if( the_node != NULL ){
482
483			if( the_node->stmt_list != NULL ){
484
485			// the statement is a block node of some sort
486
487			kill_tree( the_node->stmt_list );
488			}
489
490			else{
491
492			// the node is a statement
493
494			switch( the_node->type ){
495
496			case ASSIGNMENT_STMT:
497
498			if( the_node->the_data.asmt.type == STR_ASSN )
499			free( the_node->the_data.asmt.rhs.str_ptr );
500
501			free( the_node->the_data.asmt.identifier );
502			break;
503
504	tim	490	case MEMBERS_STMT:
505
506			if (the_node->the_data.mbrs.nMembers >0 ){
507			free(the_node->the_data.mbrs.memberList);
508			}
509			break;
510
511	gezelter	2	default:
512			// nothing to do here, everyone else can be freed normally.
513			break;
514			}
515			}
516
517			// recurse down to the next node
518
519			kill_tree( the_node->next_stmt );
520			free( the_node );
521			}
522
523			// we're done
524			}