OOPSE/libBASS/make_nodes.c

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

#include "node_list.h"
#include "make_nodes.h"
#include "simError.h"

/*
  walks to to the top of a stmt_list. Needed when assigning the
  statment list to a block of code.
*/

struct node_tag* walk_to_top( struct node_tag* walk_me ){

  while( walk_me->prev_stmt != NULL ){
    walk_me = walk_me->prev_stmt;
  }
  return walk_me;
}

/*
  the next three functions are for creating and initializing the
  assignment statements.
*/

struct node_tag* assign_i( char* lhs, int rhs ){

  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = ASSIGNMENT_STMT;
  the_node->index = 0;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = NULL;
  
  the_node->the_data.asmt.type = INT_ASSN;
  the_node->the_data.asmt.identifier = lhs;
  the_node->the_data.asmt.rhs.i_val = rhs;

  return the_node;
}

struct node_tag* assign_d( char* lhs, double rhs ){

  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = ASSIGNMENT_STMT;
  the_node->index = 0;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = NULL;
  
  the_node->the_data.asmt.type = DOUBLE_ASSN;
  the_node->the_data.asmt.identifier = lhs;
  the_node->the_data.asmt.rhs.d_val = rhs;

  return the_node;
}

struct node_tag* assign_s( char* lhs, char* rhs ){

  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = ASSIGNMENT_STMT;
  the_node->index = 0;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = NULL;
  
  the_node->the_data.asmt.type = STR_ASSN;
  the_node->the_data.asmt.identifier = lhs;
  the_node->the_data.asmt.rhs.str_ptr = rhs;

  return the_node;
}

/*
  The next function deals with creating and initializing of the
  members statements used by the bonds, bends, torsions, rigid bodies, 
  and cutoff groups.
*/

struct node_tag* members( char* list_str ){

  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = MEMBERS_STMT;
  the_node->index = 0;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = NULL;
  
  int nTokens, i;
  char *foo;

  nTokens = count_tokens(list_str, " ,;\t");

  if (nTokens < 1) {
    yyerror("can't find any members in this members statement");
  }

  the_node->the_data.mbrs.nMembers = nTokens;

  the_node->the_data.mbrs.memberList = (int *) calloc(nTokens, sizeof(int));

  foo = strtok(list_str, " ,;\t");
  the_node->the_data.mbrs.memberList[0] = atoi( foo );

  for (i = 1; i < nTokens; i++) {
    foo = strtok(NULL, " ,;\t");
    the_node->the_data.mbrs.memberList[i] = atoi( foo );
  }

  return the_node;
}

/*
  This function does the C & I of the constraint statements
*/

struct node_tag* constraint( char* list_str ){

  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = CONSTRAINT_STMT;
  the_node->index = 0;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = NULL;
  
  int nTokens;
  char *foo;

  nTokens = count_tokens(list_str, " ,;\t");
  if (nTokens != 1) {
    yyerror("wrong number of arguments given in constraint statement");
  }
      
  foo = strtok(list_str, " ,;\t");
  the_node->the_data.cnstr.constraint_val = atof( foo );

  return the_node;
}

/*
  This function does the C & I for the orientation statements
*/

struct node_tag* orientation( char* list_str ){

  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = ORIENTATION_STMT;
  the_node->index = 0;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = NULL;
 
  int nTokens;
  char *foo;

  nTokens = count_tokens(list_str, " ,;\t");
  if (nTokens != 3) {
    yyerror("wrong number of arguments given in orientation");
  }
      
  foo = strtok(list_str, " ,;\t");
  the_node->the_data.ort.phi = atof( foo );

  foo = strtok(NULL, " ,;\t");
  the_node->the_data.ort.theta = atof( foo );

  foo = strtok(NULL, " ,;\t");
  the_node->the_data.ort.psi = atof( foo );

  return the_node;
}

/*
  This function does the C & I for the position statements
*/

struct node_tag* position( char* list_str ){

  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = POSITION_STMT;
  the_node->index = 0;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = NULL;

  int nTokens;
  char *foo;

  nTokens = count_tokens(list_str, " ,;\t");
  if (nTokens != 3) {
    yyerror("wrong number of arguments given in position");
  }
      
  foo = strtok(list_str, " ,;\t");
  the_node->the_data.pos.x = atof( foo );

  foo = strtok(NULL, " ,;\t");
  the_node->the_data.pos.y = atof( foo );

  foo = strtok(NULL, " ,;\t");
  the_node->the_data.pos.z = atof( foo );

  
  return the_node;
}

/*
  The following six functions initialize the statement nodes
  coresponding to the different code block types.
*/

struct node_tag* molecule_blk( struct node_tag* stmt_list ){
  
  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = MOLECULE_HEAD;
  the_node->index = 0;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = walk_to_top( stmt_list );
    
  return the_node;
}

struct node_tag* rigidbody_blk( int index, struct node_tag* stmt_list ){
  
  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = RIGIDBODY_HEAD;
  the_node->index = index;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = walk_to_top( stmt_list );
    
  return the_node;
}

struct node_tag* cutoffgroup_blk( int index, struct node_tag* stmt_list ){
  
  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  // The guillotine statement:
  the_node->type = CUTOFFGROUP_HEAD;
  the_node->index = index;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = walk_to_top( stmt_list );
    
  return the_node;
}

struct node_tag* atom_blk( int index, struct node_tag* stmt_list ){
  
  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = ATOM_HEAD;
  the_node->index = index;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = walk_to_top( stmt_list );
    
  return the_node;
}

struct node_tag* bond_blk( int index, struct node_tag* stmt_list ){
  
  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = BOND_HEAD;
  the_node->index = index;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = walk_to_top( stmt_list );
    
  return the_node;
}
 
struct node_tag* bend_blk( int index, struct node_tag* stmt_list ){
  
  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = BEND_HEAD;
  the_node->index = index;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = walk_to_top( stmt_list );
    
  return the_node;
}

struct node_tag* torsion_blk( int index, struct node_tag* stmt_list ){
  
  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = TORSION_HEAD;
  the_node->index = index;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = walk_to_top( stmt_list );
    
  return the_node;
}

struct node_tag* zconstraint_blk( int index, struct node_tag* stmt_list ){
  
  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = ZCONSTRAINT_HEAD;
  the_node->index = index;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = walk_to_top( stmt_list );
    
  return the_node;
} 
 
struct node_tag* component_blk( struct node_tag* stmt_list ){
  
  struct node_tag* the_node;
  the_node = ( struct node_tag* )malloc( sizeof( node ) );
  
  the_node->type = COMPONENT_HEAD;
  the_node->index = 0;
  the_node->next_stmt = NULL;
  the_node->prev_stmt = NULL;
  the_node->stmt_list = walk_to_top( stmt_list );
  
  return the_node;
}


int count_tokens(char *line, char *delimiters) {
/* PURPOSE: RETURN A COUNT OF THE NUMBER OF TOKENS ON THE LINE. */

  char *working_line;   /* WORKING COPY OF LINE. */
  int ntokens;          /* NUMBER OF TOKENS FOUND IN LINE. */
  char *strtok_ptr;     /* POINTER FOR STRTOK. */
  
  strtok_ptr= working_line= strdup(line);
  
  ntokens=0;
  while (strtok(strtok_ptr,delimiters)!=NULL)
    {
      ntokens++;
      strtok_ptr=NULL;
    }
  
  free(working_line);
  return(ntokens);
}
Revision:	1256
Committed:	Thu Jun 10 14:59:14 2004 UTC (20 years, 1 month ago) by gezelter
Content type:	text/plain
File size:	8905 byte(s)
Log Message:	Fixed indexing bug in stamps
#	User	Rev	Content
1	mmeineke	377	#include <stdio.h>
2			#include <stdlib.h>
3			#include <string.h>
4
5	mmeineke	854	#include "node_list.h"
6			#include "make_nodes.h"
7			#include "simError.h"
8	mmeineke	377
9			/*
10			walks to to the top of a stmt_list. Needed when assigning the
11			statment list to a block of code.
12			*/
13
14			struct node_tag* walk_to_top( struct node_tag* walk_me ){
15
16			while( walk_me->prev_stmt != NULL ){
17			walk_me = walk_me->prev_stmt;
18			}
19			return walk_me;
20			}
21
22			/*
23	mmeineke	675	the next three functions are for creating and initializing the
24	mmeineke	377	assignment statements.
25			*/
26
27			struct node_tag* assign_i( char* lhs, int rhs ){
28
29			struct node_tag* the_node;
30			the_node = ( struct node_tag* )malloc( sizeof( node ) );
31
32			the_node->type = ASSIGNMENT_STMT;
33			the_node->index = 0;
34			the_node->next_stmt = NULL;
35			the_node->prev_stmt = NULL;
36			the_node->stmt_list = NULL;
37
38			the_node->the_data.asmt.type = INT_ASSN;
39			the_node->the_data.asmt.identifier = lhs;
40			the_node->the_data.asmt.rhs.i_val = rhs;
41
42			return the_node;
43			}
44
45			struct node_tag* assign_d( char* lhs, double rhs ){
46
47			struct node_tag* the_node;
48			the_node = ( struct node_tag* )malloc( sizeof( node ) );
49
50			the_node->type = ASSIGNMENT_STMT;
51			the_node->index = 0;
52			the_node->next_stmt = NULL;
53			the_node->prev_stmt = NULL;
54			the_node->stmt_list = NULL;
55
56			the_node->the_data.asmt.type = DOUBLE_ASSN;
57			the_node->the_data.asmt.identifier = lhs;
58			the_node->the_data.asmt.rhs.d_val = rhs;
59
60			return the_node;
61			}
62
63			struct node_tag* assign_s( char* lhs, char* rhs ){
64
65			struct node_tag* the_node;
66			the_node = ( struct node_tag* )malloc( sizeof( node ) );
67
68			the_node->type = ASSIGNMENT_STMT;
69			the_node->index = 0;
70			the_node->next_stmt = NULL;
71			the_node->prev_stmt = NULL;
72			the_node->stmt_list = NULL;
73
74			the_node->the_data.asmt.type = STR_ASSN;
75			the_node->the_data.asmt.identifier = lhs;
76			the_node->the_data.asmt.rhs.str_ptr = rhs;
77
78			return the_node;
79			}
80
81			/*
82	gezelter	998	The next function deals with creating and initializing of the
83	gezelter	1153	members statements used by the bonds, bends, torsions, rigid bodies,
84			and cutoff groups.
85	mmeineke	377	*/
86
87	gezelter	998	struct node_tag* members( char* list_str ){
88	mmeineke	377
89			struct node_tag* the_node;
90			the_node = ( struct node_tag* )malloc( sizeof( node ) );
91
92	gezelter	988	the_node->type = MEMBERS_STMT;
93	mmeineke	377	the_node->index = 0;
94			the_node->next_stmt = NULL;
95			the_node->prev_stmt = NULL;
96			the_node->stmt_list = NULL;
97
98	gezelter	998	int nTokens, i;
99			char *foo;
100	mmeineke	377
101	gezelter	998	nTokens = count_tokens(list_str, " ,;\t");
102	mmeineke	377
103	gezelter	998	if (nTokens < 1) {
104			yyerror("can't find any members in this members statement");
105			}
106	mmeineke	377
107	gezelter	998	the_node->the_data.mbrs.nMembers = nTokens;
108	mmeineke	377
109	gezelter	998	the_node->the_data.mbrs.memberList = (int *) calloc(nTokens, sizeof(int));
110	mmeineke	377
111	gezelter	998	foo = strtok(list_str, " ,;\t");
112			the_node->the_data.mbrs.memberList[0] = atoi( foo );
113	mmeineke	377
114	gezelter	998	for (i = 1; i < nTokens; i++) {
115			foo = strtok(NULL, " ,;\t");
116			the_node->the_data.mbrs.memberList[i] = atoi( foo );
117			}
118	mmeineke	377
119			return the_node;
120			}
121
122			/*
123			This function does the C & I of the constraint statements
124			*/
125
126	gezelter	998	struct node_tag* constraint( char* list_str ){
127	mmeineke	377
128			struct node_tag* the_node;
129			the_node = ( struct node_tag* )malloc( sizeof( node ) );
130
131			the_node->type = CONSTRAINT_STMT;
132			the_node->index = 0;
133			the_node->next_stmt = NULL;
134			the_node->prev_stmt = NULL;
135			the_node->stmt_list = NULL;
136
137	gezelter	998	int nTokens;
138			char *foo;
139	mmeineke	377
140	gezelter	998	nTokens = count_tokens(list_str, " ,;\t");
141			if (nTokens != 1) {
142			yyerror("wrong number of arguments given in constraint statement");
143			}
144
145			foo = strtok(list_str, " ,;\t");
146			the_node->the_data.cnstr.constraint_val = atof( foo );
147
148	mmeineke	377	return the_node;
149			}
150
151			/*
152			This function does the C & I for the orientation statements
153			*/
154
155	gezelter	998	struct node_tag* orientation( char* list_str ){
156	mmeineke	377
157			struct node_tag* the_node;
158			the_node = ( struct node_tag* )malloc( sizeof( node ) );
159
160			the_node->type = ORIENTATION_STMT;
161			the_node->index = 0;
162			the_node->next_stmt = NULL;
163			the_node->prev_stmt = NULL;
164			the_node->stmt_list = NULL;
165	gezelter	998
166			int nTokens;
167			char *foo;
168
169			nTokens = count_tokens(list_str, " ,;\t");
170			if (nTokens != 3) {
171			yyerror("wrong number of arguments given in orientation");
172			}
173
174			foo = strtok(list_str, " ,;\t");
175			the_node->the_data.ort.phi = atof( foo );
176
177			foo = strtok(NULL, " ,;\t");
178			the_node->the_data.ort.theta = atof( foo );
179
180			foo = strtok(NULL, " ,;\t");
181			the_node->the_data.ort.psi = atof( foo );
182
183	mmeineke	377	return the_node;
184			}
185
186			/*
187			This function does the C & I for the position statements
188			*/
189
190	gezelter	998	struct node_tag* position( char* list_str ){
191	mmeineke	377
192			struct node_tag* the_node;
193			the_node = ( struct node_tag* )malloc( sizeof( node ) );
194
195			the_node->type = POSITION_STMT;
196			the_node->index = 0;
197			the_node->next_stmt = NULL;
198			the_node->prev_stmt = NULL;
199			the_node->stmt_list = NULL;
200	gezelter	998
201			int nTokens;
202			char *foo;
203
204			nTokens = count_tokens(list_str, " ,;\t");
205			if (nTokens != 3) {
206			yyerror("wrong number of arguments given in position");
207			}
208
209			foo = strtok(list_str, " ,;\t");
210			the_node->the_data.pos.x = atof( foo );
211
212			foo = strtok(NULL, " ,;\t");
213			the_node->the_data.pos.y = atof( foo );
214
215			foo = strtok(NULL, " ,;\t");
216			the_node->the_data.pos.z = atof( foo );
217
218	mmeineke	377
219			return the_node;
220			}
221
222			/*
223			The following six functions initialize the statement nodes
224			coresponding to the different code block types.
225			*/
226
227			struct node_tag* molecule_blk( struct node_tag* stmt_list ){
228
229			struct node_tag* the_node;
230			the_node = ( struct node_tag* )malloc( sizeof( node ) );
231
232			the_node->type = MOLECULE_HEAD;
233			the_node->index = 0;
234			the_node->next_stmt = NULL;
235			the_node->prev_stmt = NULL;
236			the_node->stmt_list = walk_to_top( stmt_list );
237
238			return the_node;
239			}
240
241	gezelter	957	struct node_tag* rigidbody_blk( int index, struct node_tag* stmt_list ){
242
243			struct node_tag* the_node;
244			the_node = ( struct node_tag* )malloc( sizeof( node ) );
245
246			the_node->type = RIGIDBODY_HEAD;
247	gezelter	1256	the_node->index = index;
248	gezelter	957	the_node->next_stmt = NULL;
249			the_node->prev_stmt = NULL;
250			the_node->stmt_list = walk_to_top( stmt_list );
251
252			return the_node;
253			}
254
255	gezelter	1153	struct node_tag* cutoffgroup_blk( int index, struct node_tag* stmt_list ){
256
257			struct node_tag* the_node;
258			the_node = ( struct node_tag* )malloc( sizeof( node ) );
259
260			// The guillotine statement:
261			the_node->type = CUTOFFGROUP_HEAD;
262	gezelter	1256	the_node->index = index;
263	gezelter	1153	the_node->next_stmt = NULL;
264			the_node->prev_stmt = NULL;
265			the_node->stmt_list = walk_to_top( stmt_list );
266
267			return the_node;
268			}
269
270	mmeineke	377	struct node_tag* atom_blk( int index, struct node_tag* stmt_list ){
271
272			struct node_tag* the_node;
273			the_node = ( struct node_tag* )malloc( sizeof( node ) );
274
275			the_node->type = ATOM_HEAD;
276			the_node->index = index;
277			the_node->next_stmt = NULL;
278			the_node->prev_stmt = NULL;
279			the_node->stmt_list = walk_to_top( stmt_list );
280
281			return the_node;
282			}
283
284			struct node_tag* bond_blk( int index, struct node_tag* stmt_list ){
285
286			struct node_tag* the_node;
287			the_node = ( struct node_tag* )malloc( sizeof( node ) );
288
289			the_node->type = BOND_HEAD;
290			the_node->index = index;
291			the_node->next_stmt = NULL;
292			the_node->prev_stmt = NULL;
293			the_node->stmt_list = walk_to_top( stmt_list );
294
295			return the_node;
296			}
297
298			struct node_tag* bend_blk( int index, struct node_tag* stmt_list ){
299
300			struct node_tag* the_node;
301			the_node = ( struct node_tag* )malloc( sizeof( node ) );
302
303			the_node->type = BEND_HEAD;
304			the_node->index = index;
305			the_node->next_stmt = NULL;
306			the_node->prev_stmt = NULL;
307			the_node->stmt_list = walk_to_top( stmt_list );
308
309			return the_node;
310			}
311
312			struct node_tag* torsion_blk( int index, struct node_tag* stmt_list ){
313
314			struct node_tag* the_node;
315			the_node = ( struct node_tag* )malloc( sizeof( node ) );
316
317			the_node->type = TORSION_HEAD;
318			the_node->index = index;
319			the_node->next_stmt = NULL;
320			the_node->prev_stmt = NULL;
321			the_node->stmt_list = walk_to_top( stmt_list );
322
323			return the_node;
324			}
325	mmeineke	675
326			struct node_tag* zconstraint_blk( int index, struct node_tag* stmt_list ){
327
328			struct node_tag* the_node;
329			the_node = ( struct node_tag* )malloc( sizeof( node ) );
330
331			the_node->type = ZCONSTRAINT_HEAD;
332			the_node->index = index;
333			the_node->next_stmt = NULL;
334			the_node->prev_stmt = NULL;
335			the_node->stmt_list = walk_to_top( stmt_list );
336
337			return the_node;
338			}
339	mmeineke	377
340			struct node_tag* component_blk( struct node_tag* stmt_list ){
341
342			struct node_tag* the_node;
343			the_node = ( struct node_tag* )malloc( sizeof( node ) );
344
345			the_node->type = COMPONENT_HEAD;
346			the_node->index = 0;
347			the_node->next_stmt = NULL;
348			the_node->prev_stmt = NULL;
349			the_node->stmt_list = walk_to_top( stmt_list );
350
351			return the_node;
352			}
353	gezelter	998
354
355			int count_tokens(char line, char delimiters) {
356			/* PURPOSE: RETURN A COUNT OF THE NUMBER OF TOKENS ON THE LINE. */
357
358			char working_line; / WORKING COPY OF LINE. */
359			int ntokens; /* NUMBER OF TOKENS FOUND IN LINE. */
360			char strtok_ptr; / POINTER FOR STRTOK. */
361
362			strtok_ptr= working_line= strdup(line);
363
364			ntokens=0;
365			while (strtok(strtok_ptr,delimiters)!=NULL)
366			{
367			ntokens++;
368			strtok_ptr=NULL;
369			}
370
371			free(working_line);
372			return(ntokens);
373			}