mdtools/interface_implementation/BASS_interface.cpp

#include <cstring>
#include <cstdio>
#include <cstdlib>

#include "SimSetup.hpp"
#include "Globals.hpp"
#include "BASS_interface.h"


// Globals ************************************************

typedef enum { GLOBAL_BLK, MOLECULE_BLK, ATOM_BLK, BOND_BLK, BEND_BLK,
               TORSION_BLK, COMPONENT_BLK } block_type;

block_type current_block = GLOBAL_BLK;
#define MAX_NEST 20 // the max number of nested blocks
block_type block_stack[MAX_NEST];
int block_stack_ptr = 0;

void incr_block( block_type new_block );
void decr_block();

MakeStamps *the_stamps;
Globals *the_globals;

// Functions **********************************************

/*
 * This is the main event handler
 *
 * returns 1 if the event was handled. If the event isn't handled, the
 * event's err_msg is set, and 0 is returned
 */

int event_handler( event* the_event ){

  int handled = 0;

  switch( current_block ){
    
  case GLOBAL_BLK:
    switch( the_event->event_type ){
      
    case MOLECULE:
      incr_block( MOLECULE_BLK );
      handled = the_stamps->newMolecule( the_event );
      break;
      
    case COMPONENT:
      incr_block( COMPONENT_BLK );
      handled = the_globals->newComponent( the_event );
      break;

    case ASSIGNMENT:
      handled = the_globals->globalAssign( the_event );
      break;

    case BLOCK_END:
      handled = the_globals->globalEnd( the_event );
      break;
      
    default:
      the_event->err_msg = 
        strdup("Not a valid global event\n" );
      return 0;
    }
    break;

  case MOLECULE_BLK:
    
    switch( the_event->event_type ){
      
    case ATOM:
      incr_block( ATOM_BLK );
      handled = the_stamps->newAtom( the_event );
      break;
      
    case BOND:
      incr_block( BOND_BLK );
      handled = the_stamps->newBond( the_event );
      break;
      
    case BEND:
      incr_block( BEND_BLK );
      handled = the_stamps->newBend( the_event );
      break;

    case TORSION:
      incr_block( TORSION_BLK );
      handled = the_stamps->newTorsion( the_event );
      break;

    case ASSIGNMENT:
      handled = the_stamps->moleculeAssign( the_event );
      break;

    case BLOCK_END:
      decr_block();
      handled = the_stamps->moleculeEnd( the_event );
      break;

    default:
      the_event->err_msg = 
        strdup( "Not a valid molecule event\n" );
      return 0;
    }
    break;

  case ATOM_BLK:
    
    switch( the_event->event_type ){
      
    case POSITION:
      handled = the_stamps->atomPosition( the_event );
      break;
      
    case ORIENTATION:
      handled = the_stamps->atomOrientation( the_event );
      break;

    case ASSIGNMENT:
      handled = the_stamps->atomAssign( the_event );
      break;
      
    case BLOCK_END:
      decr_block();
      handled = the_stamps->atomEnd( the_event );
      break;
      
    default:
      the_event->err_msg = 
        strdup( "Not a valid atom event\n" );
      return 0;
    }
    break;

  case BOND_BLK:

    switch( the_event->event_type ){
      
    case ASSIGNMENT:
      handled = the_stamps->bondAssign( the_event );
      break;
      
    case MEMBER:
      handled = the_stamps->bondMember( the_event );
      break;
      
    case CONSTRAINT:
      handled = the_stamps->bondConstraint( the_event );
      break;

    case BLOCK_END:
      decr_block();
      handled = the_stamps->bondEnd(the_event );
      break;

    default:
      the_event->err_msg = 
        strdup( "not a valid bond event\n" );
      return 0;
    }
    break;
    
  case BEND_BLK:
    
    switch( the_event->event_type ){
      
    case ASSIGNMENT:
      handled = the_stamps->bendAssign( the_event );
      break;
      
    case MEMBER:
      handled = the_stamps->bendMember( the_event );
      break;
      
    case CONSTRAINT:
      handled = the_stamps->bendConstraint( the_event );
      break;

    case BLOCK_END:
      decr_block();
      handled = the_stamps->bendEnd(the_event );
      break;

    default:
      the_event->err_msg = 
        strdup( "not a valid bend event\n" );
      return 0;
    }
    break;

  case TORSION_BLK:
    
    switch( the_event->event_type ){
      
    case ASSIGNMENT:
      handled = the_stamps->torsionAssign( the_event );
      break;
      
    case MEMBER:
      handled = the_stamps->torsionMember( the_event );
      break;
      
    case CONSTRAINT:
      handled = the_stamps->torsionConstraint( the_event );
      break;

    case BLOCK_END:
      decr_block();
      handled = the_stamps->torsionEnd(the_event );
      break;

    default:
      the_event->err_msg = 
        strdup( "not a valid torsion event\n" );
      return 0;
    }
    break;
    
  case COMPONENT_BLK:
    
    switch( the_event->event_type ){
      
    case ASSIGNMENT:
      handled = the_globals->componentAssign( the_event );
      break;
      
    case START_INDEX:
      handled = the_globals->componentStartIndex( the_event );
      break;
      
    case BLOCK_END:
      decr_block();
      handled = the_globals->componentEnd(the_event );
      break;

    default:
      the_event->err_msg = 
        strdup( "not a valid component event\n" );
      return 0;
    }
   break;
   
  default:
    the_event->err_msg = 
      strdup( "event is not in a valid block type\n" );
    return 0;
  }
  
  return handled;
}

void incr_block( block_type new_block ){

  block_stack[block_stack_ptr] = current_block;
  block_stack_ptr++;
  
  if( block_stack_ptr >= MAX_NEST ){
    fprintf( stderr, "Event blocks nested too deeply\n" );
#ifdef MPI
    mpiInterfaceExit();
#endif
    exit(1);
  }

  else current_block = new_block; 
}


void decr_block( void ){

  block_stack_ptr--;

  if( block_stack_ptr < 0 ){
    
    fprintf( stderr, "Too many event blocks closed\n" );
#ifdef MPI
    mpiInterfaceExit();
#endif
    exit(1);
  }
  
  else current_block = block_stack[block_stack_ptr];
}

void set_interface_stamps( MakeStamps* ms, Globals* g ){

  the_stamps = ms;
  the_globals = g;
}
Revision:	118
Committed:	Wed Sep 25 22:51:14 2002 UTC (21 years, 9 months ago) by chuckv
File size:	5928 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
#	Content
1	#include <cstring>
2	#include <cstdio>
3	#include <cstdlib>
4
5	#include "SimSetup.hpp"
6	#include "Globals.hpp"
7	#include "BASS_interface.h"
8
9
10
11	// Globals ************************************************
12
13	typedef enum { GLOBAL_BLK, MOLECULE_BLK, ATOM_BLK, BOND_BLK, BEND_BLK,
14	TORSION_BLK, COMPONENT_BLK } block_type;
15
16	block_type current_block = GLOBAL_BLK;
17	#define MAX_NEST 20 // the max number of nested blocks
18	block_type block_stack[MAX_NEST];
19	int block_stack_ptr = 0;
20
21	void incr_block( block_type new_block );
22	void decr_block();
23
24	MakeStamps *the_stamps;
25	Globals *the_globals;
26
27	// Functions **********************************************
28
29	/*
30	* This is the main event handler
31	*
32	* returns 1 if the event was handled. If the event isn't handled, the
33	* event's err_msg is set, and 0 is returned
34	*/
35
36	int event_handler( event* the_event ){
37
38	int handled = 0;
39
40	switch( current_block ){
41
42	case GLOBAL_BLK:
43	switch( the_event->event_type ){
44
45	case MOLECULE:
46	incr_block( MOLECULE_BLK );
47	handled = the_stamps->newMolecule( the_event );
48	break;
49
50	case COMPONENT:
51	incr_block( COMPONENT_BLK );
52	handled = the_globals->newComponent( the_event );
53	break;
54
55	case ASSIGNMENT:
56	handled = the_globals->globalAssign( the_event );
57	break;
58
59	case BLOCK_END:
60	handled = the_globals->globalEnd( the_event );
61	break;
62
63	default:
64	the_event->err_msg =
65	strdup("Not a valid global event\n" );
66	return 0;
67	}
68	break;
69
70	case MOLECULE_BLK:
71
72	switch( the_event->event_type ){
73
74	case ATOM:
75	incr_block( ATOM_BLK );
76	handled = the_stamps->newAtom( the_event );
77	break;
78
79	case BOND:
80	incr_block( BOND_BLK );
81	handled = the_stamps->newBond( the_event );
82	break;
83
84	case BEND:
85	incr_block( BEND_BLK );
86	handled = the_stamps->newBend( the_event );
87	break;
88
89	case TORSION:
90	incr_block( TORSION_BLK );
91	handled = the_stamps->newTorsion( the_event );
92	break;
93
94	case ASSIGNMENT:
95	handled = the_stamps->moleculeAssign( the_event );
96	break;
97
98	case BLOCK_END:
99	decr_block();
100	handled = the_stamps->moleculeEnd( the_event );
101	break;
102
103	default:
104	the_event->err_msg =
105	strdup( "Not a valid molecule event\n" );
106	return 0;
107	}
108	break;
109
110	case ATOM_BLK:
111
112	switch( the_event->event_type ){
113
114	case POSITION:
115	handled = the_stamps->atomPosition( the_event );
116	break;
117
118	case ORIENTATION:
119	handled = the_stamps->atomOrientation( the_event );
120	break;
121
122	case ASSIGNMENT:
123	handled = the_stamps->atomAssign( the_event );
124	break;
125
126	case BLOCK_END:
127	decr_block();
128	handled = the_stamps->atomEnd( the_event );
129	break;
130
131	default:
132	the_event->err_msg =
133	strdup( "Not a valid atom event\n" );
134	return 0;
135	}
136	break;
137
138	case BOND_BLK:
139
140	switch( the_event->event_type ){
141
142	case ASSIGNMENT:
143	handled = the_stamps->bondAssign( the_event );
144	break;
145
146	case MEMBER:
147	handled = the_stamps->bondMember( the_event );
148	break;
149
150	case CONSTRAINT:
151	handled = the_stamps->bondConstraint( the_event );
152	break;
153
154	case BLOCK_END:
155	decr_block();
156	handled = the_stamps->bondEnd(the_event );
157	break;
158
159	default:
160	the_event->err_msg =
161	strdup( "not a valid bond event\n" );
162	return 0;
163	}
164	break;
165
166	case BEND_BLK:
167
168	switch( the_event->event_type ){
169
170	case ASSIGNMENT:
171	handled = the_stamps->bendAssign( the_event );
172	break;
173
174	case MEMBER:
175	handled = the_stamps->bendMember( the_event );
176	break;
177
178	case CONSTRAINT:
179	handled = the_stamps->bendConstraint( the_event );
180	break;
181
182	case BLOCK_END:
183	decr_block();
184	handled = the_stamps->bendEnd(the_event );
185	break;
186
187	default:
188	the_event->err_msg =
189	strdup( "not a valid bend event\n" );
190	return 0;
191	}
192	break;
193
194	case TORSION_BLK:
195
196	switch( the_event->event_type ){
197
198	case ASSIGNMENT:
199	handled = the_stamps->torsionAssign( the_event );
200	break;
201
202	case MEMBER:
203	handled = the_stamps->torsionMember( the_event );
204	break;
205
206	case CONSTRAINT:
207	handled = the_stamps->torsionConstraint( the_event );
208	break;
209
210	case BLOCK_END:
211	decr_block();
212	handled = the_stamps->torsionEnd(the_event );
213	break;
214
215	default:
216	the_event->err_msg =
217	strdup( "not a valid torsion event\n" );
218	return 0;
219	}
220	break;
221
222	case COMPONENT_BLK:
223
224	switch( the_event->event_type ){
225
226	case ASSIGNMENT:
227	handled = the_globals->componentAssign( the_event );
228	break;
229
230	case START_INDEX:
231	handled = the_globals->componentStartIndex( the_event );
232	break;
233
234	case BLOCK_END:
235	decr_block();
236	handled = the_globals->componentEnd(the_event );
237	break;
238
239	default:
240	the_event->err_msg =
241	strdup( "not a valid component event\n" );
242	return 0;
243	}
244	break;
245
246	default:
247	the_event->err_msg =
248	strdup( "event is not in a valid block type\n" );
249	return 0;
250	}
251
252	return handled;
253	}
254
255	void incr_block( block_type new_block ){
256
257	block_stack[block_stack_ptr] = current_block;
258	block_stack_ptr++;
259
260	if( block_stack_ptr >= MAX_NEST ){
261	fprintf( stderr, "Event blocks nested too deeply\n" );
262	#ifdef MPI
263	mpiInterfaceExit();
264	#endif
265	exit(1);
266	}
267
268	else current_block = new_block;
269	}
270
271
272	void decr_block( void ){
273
274	block_stack_ptr--;
275
276	if( block_stack_ptr < 0 ){
277
278	fprintf( stderr, "Too many event blocks closed\n" );
279	#ifdef MPI
280	mpiInterfaceExit();
281	#endif
282	exit(1);
283	}
284
285	else current_block = block_stack[block_stack_ptr];
286	}
287
288	void set_interface_stamps( MakeStamps* ms, Globals* g ){
289
290	the_stamps = ms;
291	the_globals = g;
292	}