mdtools/BASS_parse/interface.c

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

#include "interface.h"
#include "../headers/BASS_interface.h"

void interface_error( event* the_event );

void init_component( int comp_index ){
  event* the_event;

  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = COMPONENT;
  the_event->err_msg = NULL;
  the_event->evt.blk_index = comp_index;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );  
}

void init_molecule( int mol_index ){
  event* the_event;

  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = MOLECULE;
  the_event->err_msg = NULL;
  the_event->evt.blk_index = mol_index;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );  
}

void init_atom( int atom_index ){
  event* the_event;
  
  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = ATOM;
  the_event->err_msg = NULL;
  the_event->evt.blk_index = atom_index;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}

void init_bond( int bond_index ){
  event* the_event;

  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = BOND;
  the_event->err_msg = NULL;
  the_event->evt.blk_index = bond_index;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}

void init_bend( int bend_index ){
  event* the_event;

  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = BEND;
  the_event->err_msg = NULL;
  the_event->evt.blk_index = bend_index;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}

void init_torsion( int torsion_index ){
  event* the_event;

  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = TORSION;
  the_event->err_msg = NULL;
  the_event->evt.blk_index = torsion_index;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}


/*
 * the next few deal with the statement initializations 
 */

void init_members( struct node_tag* the_node, 
                   struct namespc the_namespc ){
  event* the_event;

  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = MEMBER;
  the_event->err_msg = NULL;
  the_event->evt.mbr.a = the_node->the_data.mbr.a;
  the_event->evt.mbr.b = the_node->the_data.mbr.b;
  the_event->evt.mbr.c = the_node->the_data.mbr.c;
  the_event->evt.mbr.d = the_node->the_data.mbr.d;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}

void init_constraint( struct node_tag* the_node, 
                      struct namespc the_namespc ){
  event* the_event;

  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = CONSTRAINT;
  the_event->err_msg = NULL;
  the_event->evt.cnstr = the_node->the_data.cnstr.constraint_val;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}

void init_assignment( struct node_tag* the_node, 
                      struct namespc the_namespc ){
  event* the_event;

  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = ASSIGNMENT;
  the_event->err_msg = NULL;

  strcpy( the_event->evt.asmt.lhs, the_node->the_data.asmt.identifier );
  switch( the_node->the_data.asmt.type ){
    
  case STR_ASSN:
    the_event->evt.asmt.asmt_type = STRING;
    strcpy( the_event->evt.asmt.rhs.sval,
            the_node->the_data.asmt.rhs.str_ptr );
    break;

  case INT_ASSN:
    the_event->evt.asmt.asmt_type = INT;
    the_event->evt.asmt.rhs.ival = the_node->the_data.asmt.rhs.i_val;
    break;

  case DOUBLE_ASSN:
    the_event->evt.asmt.asmt_type = DOUBLE;
    the_event->evt.asmt.rhs.dval = the_node->the_data.asmt.rhs.d_val;
    break;
  }

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}

void init_position( struct node_tag* the_node, 
                    struct namespc the_namespc ){
  event* the_event;

  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = POSITION;
  the_event->err_msg = NULL;
  the_event->evt.pos.x = the_node->the_data.pos.x;
  the_event->evt.pos.y = the_node->the_data.pos.y;
  the_event->evt.pos.z = the_node->the_data.pos.z;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}

void init_orientation( struct node_tag* the_node, 
                       struct namespc the_namespc ){
  event* the_event;

  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = ORIENTATION;
  the_event->err_msg = NULL;
  the_event->evt.ornt.x = the_node->the_data.ort.x;
  the_event->evt.ornt.y = the_node->the_data.ort.y;
  the_event->evt.ornt.z = the_node->the_data.ort.z;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}

void init_start_index( struct node_tag* the_node, 
                       struct namespc the_namespc ){
  event* the_event;
  int* si_array;
  int n_elements = 0;
  int index = 0;

  struct integer_list_tag* head;
  struct integer_list_tag* current;
  
  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = ORIENTATION;
  the_event->err_msg = NULL;

  head = the_node->the_data.il_head;
  n_elements++;

  current = head->next;
  while( current != NULL ){
    n_elements++;
    current = current->next;
  }

  the_event->evt.si.n_elements = n_elements;
  si_array = ( int* ) calloc( n_elements, sizeof( int ) );
  
  si_array[index] = head->the_int;
  
  current = head->next;
  while( current != NULL ){
    index++;
    si_array[index] = current->the_int;
    current = current->next;
  }
  the_event->evt.si.array = si_array;
  
  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}

void end_of_block( void ){
  event* the_event;
  
  the_event = (event* )malloc( sizeof( event ) );
  
  the_event->event_type = BLOCK_END;
  the_event->err_msg = NULL;

  if( !event_handler( the_event ) ) interface_error( the_event );
  
  free( the_event );
}

void interface_error( event* the_event ){

  fprintf( stderr,
           "**Interface event error**\n"
           "%s\n",
           the_event->err_msg );
  exit(1);
}
Revision:	10
Committed:	Tue Jul 9 18:40:59 2002 UTC (23 years, 3 months ago) by mmeineke
Content type:	text/plain
Original Path:	*branches/mmeineke/mdtools/BASS_parse/interface.c*
File size:	6166 byte(s)
Log Message:	everything you need to make libmdtools
#	Content
1	#include <stdio.h>
2	#include <stdlib.h>
3
4	#include "interface.h"
5	#include "../headers/BASS_interface.h"
6
7	void interface_error( event* the_event );
8
9	void init_component( int comp_index ){
10	event* the_event;
11
12	the_event = (event* )malloc( sizeof( event ) );
13
14	the_event->event_type = COMPONENT;
15	the_event->err_msg = NULL;
16	the_event->evt.blk_index = comp_index;
17
18	if( !event_handler( the_event ) ) interface_error( the_event );
19
20	free( the_event );
21	}
22
23	void init_molecule( int mol_index ){
24	event* the_event;
25
26	the_event = (event* )malloc( sizeof( event ) );
27
28	the_event->event_type = MOLECULE;
29	the_event->err_msg = NULL;
30	the_event->evt.blk_index = mol_index;
31
32	if( !event_handler( the_event ) ) interface_error( the_event );
33
34	free( the_event );
35	}
36
37	void init_atom( int atom_index ){
38	event* the_event;
39
40	the_event = (event* )malloc( sizeof( event ) );
41
42	the_event->event_type = ATOM;
43	the_event->err_msg = NULL;
44	the_event->evt.blk_index = atom_index;
45
46	if( !event_handler( the_event ) ) interface_error( the_event );
47
48	free( the_event );
49	}
50
51	void init_bond( int bond_index ){
52	event* the_event;
53
54	the_event = (event* )malloc( sizeof( event ) );
55
56	the_event->event_type = BOND;
57	the_event->err_msg = NULL;
58	the_event->evt.blk_index = bond_index;
59
60	if( !event_handler( the_event ) ) interface_error( the_event );
61
62	free( the_event );
63	}
64
65	void init_bend( int bend_index ){
66	event* the_event;
67
68	the_event = (event* )malloc( sizeof( event ) );
69
70	the_event->event_type = BEND;
71	the_event->err_msg = NULL;
72	the_event->evt.blk_index = bend_index;
73
74	if( !event_handler( the_event ) ) interface_error( the_event );
75
76	free( the_event );
77	}
78
79	void init_torsion( int torsion_index ){
80	event* the_event;
81
82	the_event = (event* )malloc( sizeof( event ) );
83
84	the_event->event_type = TORSION;
85	the_event->err_msg = NULL;
86	the_event->evt.blk_index = torsion_index;
87
88	if( !event_handler( the_event ) ) interface_error( the_event );
89
90	free( the_event );
91	}
92
93
94	/*
95	* the next few deal with the statement initializations
96	*/
97
98	void init_members( struct node_tag* the_node,
99	struct namespc the_namespc ){
100	event* the_event;
101
102	the_event = (event* )malloc( sizeof( event ) );
103
104	the_event->event_type = MEMBER;
105	the_event->err_msg = NULL;
106	the_event->evt.mbr.a = the_node->the_data.mbr.a;
107	the_event->evt.mbr.b = the_node->the_data.mbr.b;
108	the_event->evt.mbr.c = the_node->the_data.mbr.c;
109	the_event->evt.mbr.d = the_node->the_data.mbr.d;
110
111	if( !event_handler( the_event ) ) interface_error( the_event );
112
113	free( the_event );
114	}
115
116	void init_constraint( struct node_tag* the_node,
117	struct namespc the_namespc ){
118	event* the_event;
119
120	the_event = (event* )malloc( sizeof( event ) );
121
122	the_event->event_type = CONSTRAINT;
123	the_event->err_msg = NULL;
124	the_event->evt.cnstr = the_node->the_data.cnstr.constraint_val;
125
126	if( !event_handler( the_event ) ) interface_error( the_event );
127
128	free( the_event );
129	}
130
131	void init_assignment( struct node_tag* the_node,
132	struct namespc the_namespc ){
133	event* the_event;
134
135	the_event = (event* )malloc( sizeof( event ) );
136
137	the_event->event_type = ASSIGNMENT;
138	the_event->err_msg = NULL;
139
140	strcpy( the_event->evt.asmt.lhs, the_node->the_data.asmt.identifier );
141	switch( the_node->the_data.asmt.type ){
142
143	case STR_ASSN:
144	the_event->evt.asmt.asmt_type = STRING;
145	strcpy( the_event->evt.asmt.rhs.sval,
146	the_node->the_data.asmt.rhs.str_ptr );
147	break;
148
149	case INT_ASSN:
150	the_event->evt.asmt.asmt_type = INT;
151	the_event->evt.asmt.rhs.ival = the_node->the_data.asmt.rhs.i_val;
152	break;
153
154	case DOUBLE_ASSN:
155	the_event->evt.asmt.asmt_type = DOUBLE;
156	the_event->evt.asmt.rhs.dval = the_node->the_data.asmt.rhs.d_val;
157	break;
158	}
159
160	if( !event_handler( the_event ) ) interface_error( the_event );
161
162	free( the_event );
163	}
164
165	void init_position( struct node_tag* the_node,
166	struct namespc the_namespc ){
167	event* the_event;
168
169	the_event = (event* )malloc( sizeof( event ) );
170
171	the_event->event_type = POSITION;
172	the_event->err_msg = NULL;
173	the_event->evt.pos.x = the_node->the_data.pos.x;
174	the_event->evt.pos.y = the_node->the_data.pos.y;
175	the_event->evt.pos.z = the_node->the_data.pos.z;
176
177	if( !event_handler( the_event ) ) interface_error( the_event );
178
179	free( the_event );
180	}
181
182	void init_orientation( struct node_tag* the_node,
183	struct namespc the_namespc ){
184	event* the_event;
185
186	the_event = (event* )malloc( sizeof( event ) );
187
188	the_event->event_type = ORIENTATION;
189	the_event->err_msg = NULL;
190	the_event->evt.ornt.x = the_node->the_data.ort.x;
191	the_event->evt.ornt.y = the_node->the_data.ort.y;
192	the_event->evt.ornt.z = the_node->the_data.ort.z;
193
194	if( !event_handler( the_event ) ) interface_error( the_event );
195
196	free( the_event );
197	}
198
199	void init_start_index( struct node_tag* the_node,
200	struct namespc the_namespc ){
201	event* the_event;
202	int* si_array;
203	int n_elements = 0;
204	int index = 0;
205
206	struct integer_list_tag* head;
207	struct integer_list_tag* current;
208
209	the_event = (event* )malloc( sizeof( event ) );
210
211	the_event->event_type = ORIENTATION;
212	the_event->err_msg = NULL;
213
214	head = the_node->the_data.il_head;
215	n_elements++;
216
217	current = head->next;
218	while( current != NULL ){
219	n_elements++;
220	current = current->next;
221	}
222
223	the_event->evt.si.n_elements = n_elements;
224	si_array = ( int* ) calloc( n_elements, sizeof( int ) );
225
226	si_array[index] = head->the_int;
227
228	current = head->next;
229	while( current != NULL ){
230	index++;
231	si_array[index] = current->the_int;
232	current = current->next;
233	}
234	the_event->evt.si.array = si_array;
235
236	if( !event_handler( the_event ) ) interface_error( the_event );
237
238	free( the_event );
239	}
240
241	void end_of_block( void ){
242	event* the_event;
243
244	the_event = (event* )malloc( sizeof( event ) );
245
246	the_event->event_type = BLOCK_END;
247	the_event->err_msg = NULL;
248
249	if( !event_handler( the_event ) ) interface_error( the_event );
250
251	free( the_event );
252	}
253
254	void interface_error( event* the_event ){
255
256	fprintf( stderr,
257	"Interface event error\n"
258	"%s\n",
259	the_event->err_msg );
260	exit(1);
261	}