Commit | Line | Data |
---|---|---|
c906108c SS |
1 | |
2 | #include <stdio.h> | |
3 | #include <stdlib.h> | |
4 | #include <string.h> | |
5 | ||
6 | /************************************************************************** | |
7 | * TESTS : | |
8 | * -- function arguments that are enumerated types | |
9 | * -- small structure arguments ( <= 64 bits ) | |
10 | * -- stored in registers | |
11 | * -- stored on the stack | |
12 | * -- large structure arguments ( > 64 bits ) | |
13 | * -- stored in registers | |
14 | * -- stored on the stack | |
15 | * -- array arguments | |
16 | * -- caller is a leaf routine : | |
17 | * -- use the call command from within an init routine (i.e. | |
18 | * init_bit_flags, init_bit_flags_combo, init_array_rep) | |
19 | * -- caller doesn't have enough space for all the function arguments : | |
20 | * -- call print_long_arg_list from inside print_small_structs | |
21 | ***************************************************************************/ | |
22 | ||
23 | /* Some enumerated types -- used to test that the structureal data type is | |
24 | * retrieved for function arguments with typedef data types. | |
25 | */ | |
26 | typedef int id_int; | |
27 | ||
28 | typedef enum { | |
29 | BLACK, | |
30 | BLUE, | |
31 | BROWN, | |
32 | ECRUE, | |
33 | GOLD, | |
34 | GRAY, | |
35 | GREEN, | |
36 | IVORY, | |
37 | MAUVE, | |
38 | ORANGE, | |
39 | PINK, | |
40 | PURPLE, | |
41 | RED, | |
42 | SILVER, | |
43 | TAN, | |
44 | VIOLET, | |
45 | WHITE, | |
46 | YELLOW} colors; | |
47 | ||
48 | /* A large structure (> 64 bits) used to test passing large structures as | |
49 | * parameters | |
50 | */ | |
51 | ||
52 | struct array_rep_info_t { | |
53 | int next_index[10]; | |
54 | int values[10]; | |
55 | int head; | |
56 | }; | |
57 | ||
58 | /***************************************************************************** | |
59 | * Small structures ( <= 64 bits). These are used to test passing small | |
60 | * structures as parameters and test argument size promotion. | |
61 | *****************************************************************************/ | |
62 | ||
63 | /* 64 bits | |
64 | */ | |
65 | struct small_rep_info_t { | |
66 | int value; | |
67 | int head; | |
68 | }; | |
69 | ||
70 | /* 6 bits : really fits in 8 bits and is promoted to 32 bits | |
71 | */ | |
72 | struct bit_flags_t { | |
73 | unsigned alpha :1; | |
74 | unsigned beta :1; | |
75 | unsigned gamma :1; | |
76 | unsigned delta :1; | |
77 | unsigned epsilon :1; | |
78 | unsigned omega :1; | |
79 | }; | |
80 | ||
81 | /* 22 bits : really fits in 40 bits and is promoted to 64 bits | |
82 | */ | |
83 | struct bit_flags_combo_t { | |
84 | unsigned alpha :1; | |
85 | unsigned beta :1; | |
86 | char ch1; | |
87 | unsigned gamma :1; | |
88 | unsigned delta :1; | |
89 | char ch2; | |
90 | unsigned epsilon :1; | |
91 | unsigned omega :1; | |
92 | }; | |
93 | ||
94 | /* 64 bits | |
95 | */ | |
96 | struct one_double_t { | |
97 | double double1; | |
98 | }; | |
99 | ||
100 | /* 64 bits | |
101 | */ | |
102 | struct two_floats_t { | |
103 | float float1; | |
104 | float float2; | |
105 | }; | |
106 | ||
107 | /* 16 bits : promoted to 32 bits | |
108 | */ | |
109 | struct two_char_t { | |
110 | char ch1; | |
111 | char ch2; | |
112 | }; | |
113 | ||
114 | /* 24 bits : promoted to 32 bits | |
115 | */ | |
116 | struct three_char_t { | |
117 | char ch1; | |
118 | char ch2; | |
119 | char ch3; | |
120 | }; | |
121 | ||
122 | /* 40 bits : promoted to 64 bits | |
123 | */ | |
124 | struct five_char_t { | |
125 | char ch1; | |
126 | char ch2; | |
127 | char ch3; | |
128 | char ch4; | |
129 | char ch5; | |
130 | }; | |
131 | ||
132 | /* 40 bits : promoted to 64 bits | |
133 | */ | |
134 | struct int_char_combo_t { | |
135 | int int1; | |
136 | char ch1; | |
137 | }; | |
138 | ||
139 | /***************************************************************** | |
140 | * PRINT_STUDENT_ID_SHIRT_COLOR : | |
141 | * IN id_int student -- enumerated type | |
142 | * IN colors shirt -- enumerated type | |
143 | *****************************************************************/ | |
085dd6e6 JM |
144 | #ifdef PROTOTYPES |
145 | void print_student_id_shirt_color (id_int student, colors shirt) | |
146 | #else | |
c906108c SS |
147 | void print_student_id_shirt_color ( student, shirt ) |
148 | id_int student; | |
149 | colors shirt; | |
085dd6e6 | 150 | #endif |
c906108c SS |
151 | { |
152 | ||
153 | printf("student id : %d\t", student); | |
154 | printf("shirt color : "); | |
155 | switch (shirt) { | |
156 | case BLACK : printf("BLACK\n"); | |
157 | break; | |
158 | case BLUE : printf("BLUE\n"); | |
159 | break; | |
160 | case BROWN : printf("BROWN\n"); | |
161 | break; | |
162 | case ECRUE : printf("ECRUE\n"); | |
163 | break; | |
164 | case GOLD : printf("GOLD\n"); | |
165 | break; | |
166 | case GRAY : printf("GRAY\n"); | |
167 | break; | |
168 | case GREEN : printf("GREEN\n"); | |
169 | break; | |
170 | case IVORY : printf("IVORY\n"); | |
171 | break; | |
172 | case MAUVE : printf("MAUVE\n"); | |
173 | break; | |
174 | case ORANGE : printf("ORANGE\n"); | |
175 | break; | |
176 | case PINK : printf("PINK\n"); | |
177 | break; | |
178 | case PURPLE : printf("PURPLE\n"); | |
179 | break; | |
180 | case RED : printf("RED\n"); | |
181 | break; | |
182 | case SILVER : printf("SILVER\n"); | |
183 | break; | |
184 | case TAN : printf("TAN\n"); | |
185 | break; | |
186 | case VIOLET : printf("VIOLET\n"); | |
187 | break; | |
188 | case WHITE : printf("WHITE\n"); | |
189 | break; | |
190 | case YELLOW : printf("YELLOW\n"); | |
191 | break; | |
192 | } | |
193 | } | |
194 | ||
195 | /***************************************************************** | |
196 | * PRINT_CHAR_ARRAY : | |
197 | * IN char array_c[] -- character array | |
198 | *****************************************************************/ | |
085dd6e6 JM |
199 | #ifdef PROTOTYPES |
200 | void print_char_array (char array_c[]) | |
201 | #else | |
c906108c SS |
202 | void print_char_array ( array_c ) |
203 | char array_c[]; | |
085dd6e6 | 204 | #endif |
c906108c SS |
205 | { |
206 | ||
207 | int index; | |
208 | ||
209 | printf("array_c :\n"); | |
210 | printf("=========\n\n"); | |
211 | for (index = 0; index < 120; index++) { | |
212 | printf("%1c", array_c[index]); | |
213 | if ((index%50) == 0) printf("\n"); | |
214 | } | |
215 | printf("\n\n"); | |
216 | } | |
217 | ||
218 | /***************************************************************** | |
219 | * PRINT_DOUBLE_ARRAY : | |
220 | * IN double array_d[] -- array of doubles | |
221 | *****************************************************************/ | |
085dd6e6 JM |
222 | #ifdef PROTOTYPES |
223 | void print_double_array (double array_d[]) | |
224 | #else | |
c906108c SS |
225 | void print_double_array (array_d) |
226 | double array_d[]; | |
085dd6e6 | 227 | #endif |
c906108c SS |
228 | { |
229 | ||
230 | int index; | |
231 | ||
232 | printf("array_d :\n"); | |
233 | printf("=========\n\n"); | |
1b7c05e7 | 234 | for (index = 0; index < 9; index++) { |
c906108c SS |
235 | printf("%f ", array_d[index]); |
236 | if ((index%8) == 0) printf("\n"); | |
237 | } | |
238 | printf("\n\n"); | |
239 | } | |
240 | ||
241 | /***************************************************************** | |
242 | * PRINT_FLOAT_ARRAY: | |
243 | * IN float array_f[] -- array of floats | |
244 | *****************************************************************/ | |
085dd6e6 JM |
245 | #ifdef PROTOTYPES |
246 | void print_float_array (float array_f[]) | |
247 | #else | |
c906108c SS |
248 | void print_float_array ( array_f ) |
249 | float array_f[]; | |
085dd6e6 | 250 | #endif |
c906108c SS |
251 | { |
252 | ||
253 | int index; | |
254 | ||
255 | printf("array_f :\n"); | |
256 | printf("=========\n\n"); | |
257 | for (index = 0; index < 15; index++) { | |
258 | printf("%f ", array_f[index]); | |
259 | if ((index%8) == 0) printf("\n"); | |
260 | ||
261 | } | |
262 | printf("\n\n"); | |
263 | } | |
264 | ||
265 | /***************************************************************** | |
266 | * PRINT_INT_ARRAY: | |
267 | * IN int array_i[] -- array of integers | |
268 | *****************************************************************/ | |
085dd6e6 JM |
269 | #ifdef PROTOTYPES |
270 | void print_int_array (int array_i[]) | |
271 | #else | |
c906108c SS |
272 | void print_int_array ( array_i ) |
273 | int array_i[]; | |
085dd6e6 | 274 | #endif |
c906108c SS |
275 | { |
276 | ||
277 | int index; | |
278 | ||
279 | printf("array_i :\n"); | |
280 | printf("=========\n\n"); | |
281 | for (index = 0; index < 50; index++) { | |
282 | printf("%d ", array_i[index]); | |
283 | if ((index%8) == 0) printf("\n"); | |
284 | } | |
285 | printf("\n\n"); | |
286 | ||
287 | } | |
288 | ||
289 | /***************************************************************** | |
290 | * PRINT_ALL_ARRAYS: | |
291 | * IN int array_i[] -- array of integers | |
292 | * IN char array_c[] -- array of characters | |
293 | * IN float array_f[] -- array of floats | |
294 | * IN double array_d[] -- array of doubles | |
295 | *****************************************************************/ | |
085dd6e6 JM |
296 | #ifdef PROTOTYPES |
297 | void print_all_arrays(int array_i[], char array_c[], float array_f[], double array_d[]) | |
298 | #else | |
c906108c SS |
299 | void print_all_arrays( array_i, array_c, array_f, array_d ) |
300 | int array_i[]; | |
301 | char array_c[]; | |
302 | float array_f[]; | |
303 | double array_d[]; | |
085dd6e6 | 304 | #endif |
c906108c SS |
305 | { |
306 | print_int_array(array_i); | |
307 | print_char_array(array_c); | |
308 | print_float_array(array_f); | |
309 | print_double_array(array_d); | |
310 | } | |
311 | ||
312 | /***************************************************************** | |
313 | * LOOP_COUNT : | |
314 | * A do nothing function. Used to provide a point at which calls can be made. | |
315 | *****************************************************************/ | |
316 | void loop_count () { | |
317 | ||
318 | int index; | |
319 | ||
320 | for (index=0; index<4; index++); | |
321 | } | |
322 | ||
323 | /***************************************************************** | |
324 | * COMPUTE_WITH_SMALL_STRUCTS : | |
325 | * A do nothing function. Used to provide a point at which calls can be made. | |
326 | * IN int seed | |
327 | *****************************************************************/ | |
085dd6e6 JM |
328 | #ifdef PROTOTYPES |
329 | void compute_with_small_structs (int seed) | |
330 | #else | |
c906108c SS |
331 | void compute_with_small_structs ( seed ) |
332 | int seed; | |
085dd6e6 | 333 | #endif |
c906108c SS |
334 | { |
335 | ||
336 | struct small_rep_info_t array[4]; | |
337 | int index; | |
338 | ||
339 | for (index = 0; index < 4; index++) { | |
340 | array[index].value = index*seed; | |
341 | array[index].head = (index+1)*seed; | |
342 | } | |
343 | ||
344 | for (index = 1; index < 4; index++) { | |
345 | array[index].value = array[index].value + array[index-1].value; | |
346 | array[index].head = array[index].head + array[index-1].head; | |
347 | } | |
348 | } | |
349 | ||
350 | /***************************************************************** | |
351 | * INIT_BIT_FLAGS : | |
352 | * Initializes a bit_flags_t structure. Can call this function see | |
353 | * the call command behavior when integer arguments do not fit into | |
354 | * registers and must be placed on the stack. | |
355 | * OUT struct bit_flags_t *bit_flags -- structure to be filled | |
356 | * IN unsigned a -- 0 or 1 | |
357 | * IN unsigned b -- 0 or 1 | |
358 | * IN unsigned g -- 0 or 1 | |
359 | * IN unsigned d -- 0 or 1 | |
360 | * IN unsigned e -- 0 or 1 | |
361 | * IN unsigned o -- 0 or 1 | |
362 | *****************************************************************/ | |
085dd6e6 JM |
363 | #ifdef PROTOTYPES |
364 | void init_bit_flags (struct bit_flags_t *bit_flags, unsigned a, unsigned b, unsigned g, unsigned d, unsigned e, unsigned o) | |
365 | #else | |
c906108c SS |
366 | void init_bit_flags ( bit_flags, a, b, g, d, e, o ) |
367 | struct bit_flags_t *bit_flags; | |
368 | unsigned a; | |
369 | unsigned b; | |
370 | unsigned g; | |
371 | unsigned d; | |
372 | unsigned e; | |
373 | unsigned o; | |
085dd6e6 | 374 | #endif |
c906108c SS |
375 | { |
376 | ||
377 | bit_flags->alpha = a; | |
378 | bit_flags->beta = b; | |
379 | bit_flags->gamma = g; | |
380 | bit_flags->delta = d; | |
381 | bit_flags->epsilon = e; | |
382 | bit_flags->omega = o; | |
383 | } | |
384 | ||
385 | /***************************************************************** | |
386 | * INIT_BIT_FLAGS_COMBO : | |
387 | * Initializes a bit_flags_combo_t structure. Can call this function | |
388 | * to see the call command behavior when integer and character arguments | |
389 | * do not fit into registers and must be placed on the stack. | |
390 | * OUT struct bit_flags_combo_t *bit_flags_combo -- structure to fill | |
391 | * IN unsigned a -- 0 or 1 | |
392 | * IN unsigned b -- 0 or 1 | |
393 | * IN char ch1 | |
394 | * IN unsigned g -- 0 or 1 | |
395 | * IN unsigned d -- 0 or 1 | |
396 | * IN char ch2 | |
397 | * IN unsigned e -- 0 or 1 | |
398 | * IN unsigned o -- 0 or 1 | |
399 | *****************************************************************/ | |
085dd6e6 JM |
400 | #ifdef PROTOTYPES |
401 | void init_bit_flags_combo (struct bit_flags_combo_t *bit_flags_combo, unsigned a, unsigned b, char ch1, unsigned g, unsigned d, char ch2, unsigned e, unsigned o) | |
402 | #else | |
c906108c SS |
403 | void init_bit_flags_combo ( bit_flags_combo, a, b, ch1, g, d, ch2, e, o ) |
404 | struct bit_flags_combo_t *bit_flags_combo; | |
405 | unsigned a; | |
406 | unsigned b; | |
407 | char ch1; | |
408 | unsigned g; | |
409 | unsigned d; | |
410 | char ch2; | |
411 | unsigned e; | |
412 | unsigned o; | |
085dd6e6 | 413 | #endif |
c906108c SS |
414 | { |
415 | ||
416 | bit_flags_combo->alpha = a; | |
417 | bit_flags_combo->beta = b; | |
418 | bit_flags_combo->ch1 = ch1; | |
419 | bit_flags_combo->gamma = g; | |
420 | bit_flags_combo->delta = d; | |
421 | bit_flags_combo->ch2 = ch2; | |
422 | bit_flags_combo->epsilon = e; | |
423 | bit_flags_combo->omega = o; | |
424 | } | |
425 | ||
426 | ||
427 | /***************************************************************** | |
428 | * INIT_ONE_DOUBLE : | |
429 | * OUT struct one_double_t *one_double -- structure to fill | |
430 | * IN double init_val | |
431 | *****************************************************************/ | |
085dd6e6 JM |
432 | #ifdef PROTOTYPES |
433 | void init_one_double (struct one_double_t *one_double, double init_val) | |
434 | #else | |
c906108c SS |
435 | void init_one_double ( one_double, init_val ) |
436 | struct one_double_t *one_double; | |
437 | double init_val; | |
085dd6e6 | 438 | #endif |
c906108c SS |
439 | { |
440 | ||
441 | one_double->double1 = init_val; | |
442 | } | |
443 | ||
444 | /***************************************************************** | |
445 | * INIT_TWO_FLOATS : | |
446 | * OUT struct two_floats_t *two_floats -- structure to be filled | |
447 | * IN float init_val1 | |
448 | * IN float init_val2 | |
449 | *****************************************************************/ | |
085dd6e6 JM |
450 | #ifdef PROTOTYPES |
451 | void init_two_floats (struct two_floats_t *two_floats, float init_val1, float init_val2) | |
452 | #else | |
c906108c SS |
453 | void init_two_floats ( two_floats, init_val1, init_val2 ) |
454 | struct two_floats_t *two_floats; | |
455 | float init_val1; | |
456 | float init_val2; | |
085dd6e6 | 457 | #endif |
c906108c SS |
458 | { |
459 | two_floats->float1 = init_val1; | |
460 | two_floats->float2 = init_val2; | |
461 | } | |
462 | ||
463 | /***************************************************************** | |
464 | * INIT_TWO_CHARS : | |
465 | * OUT struct two_char_t *two_char -- structure to be filled | |
466 | * IN char init_val1 | |
467 | * IN char init_val2 | |
468 | *****************************************************************/ | |
085dd6e6 JM |
469 | #ifdef PROTOTYPES |
470 | void init_two_chars (struct two_char_t *two_char, char init_val1, char init_val2) | |
471 | #else | |
c906108c SS |
472 | void init_two_chars ( two_char, init_val1, init_val2 ) |
473 | struct two_char_t *two_char; | |
474 | char init_val1; | |
475 | char init_val2; | |
085dd6e6 | 476 | #endif |
c906108c SS |
477 | { |
478 | ||
479 | two_char->ch1 = init_val1; | |
480 | two_char->ch2 = init_val2; | |
481 | } | |
482 | ||
483 | /***************************************************************** | |
484 | * INIT_THREE_CHARS : | |
485 | * OUT struct three_char_t *three_char -- structure to be filled | |
486 | * IN char init_val1 | |
487 | * IN char init_val2 | |
488 | * IN char init_val3 | |
489 | *****************************************************************/ | |
085dd6e6 JM |
490 | #ifdef PROTOTYPES |
491 | void init_three_chars (struct three_char_t *three_char, char init_val1, char init_val2, char init_val3) | |
492 | #else | |
c906108c SS |
493 | void init_three_chars ( three_char, init_val1, init_val2, init_val3 ) |
494 | struct three_char_t *three_char; | |
495 | char init_val1; | |
496 | char init_val2; | |
497 | char init_val3; | |
085dd6e6 | 498 | #endif |
c906108c SS |
499 | { |
500 | ||
501 | three_char->ch1 = init_val1; | |
502 | three_char->ch2 = init_val2; | |
503 | three_char->ch3 = init_val3; | |
504 | } | |
505 | ||
506 | /***************************************************************** | |
507 | * INIT_FIVE_CHARS : | |
508 | * OUT struct five_char_t *five_char -- structure to be filled | |
509 | * IN char init_val1 | |
510 | * IN char init_val2 | |
511 | * IN char init_val3 | |
512 | * IN char init_val4 | |
513 | * IN char init_val5 | |
514 | *****************************************************************/ | |
085dd6e6 JM |
515 | #ifdef PROTOTYPES |
516 | void init_five_chars (struct five_char_t *five_char, char init_val1, char init_val2, char init_val3, char init_val4, char init_val5) | |
517 | #else | |
c906108c SS |
518 | void init_five_chars ( five_char, init_val1, init_val2, init_val3,init_val4,init_val5 ) |
519 | struct five_char_t *five_char; | |
520 | char init_val1; | |
521 | char init_val2; | |
522 | char init_val3; | |
523 | char init_val4; | |
524 | char init_val5; | |
085dd6e6 | 525 | #endif |
c906108c SS |
526 | { |
527 | five_char->ch1 = init_val1; | |
528 | five_char->ch2 = init_val2; | |
529 | five_char->ch3 = init_val3; | |
530 | five_char->ch4 = init_val4; | |
531 | five_char->ch5 = init_val5; | |
532 | } | |
533 | ||
534 | /***************************************************************** | |
535 | * INIT_INT_CHAR_COMBO : | |
536 | * OUT struct int_char_combo_t *combo -- structure to be filled | |
537 | * IN int init_val1 | |
538 | * IN char init_val2 | |
539 | *****************************************************************/ | |
085dd6e6 JM |
540 | #ifdef PROTOTYPES |
541 | void init_int_char_combo (struct int_char_combo_t *combo, int init_val1, char init_val2) | |
542 | #else | |
c906108c SS |
543 | void init_int_char_combo ( combo, init_val1, init_val2 ) |
544 | struct int_char_combo_t *combo; | |
545 | int init_val1; | |
546 | char init_val2; | |
085dd6e6 | 547 | #endif |
c906108c SS |
548 | { |
549 | ||
550 | combo->int1 = init_val1; | |
551 | combo->ch1 = init_val2; | |
552 | } | |
553 | ||
554 | /***************************************************************** | |
555 | * INIT_STRUCT_REP : | |
556 | * OUT struct small_rep_into_t *small_struct -- structure to be filled | |
557 | * IN int seed | |
558 | *****************************************************************/ | |
085dd6e6 JM |
559 | #ifdef PROTOTYPES |
560 | void init_struct_rep(struct small_rep_info_t *small_struct, int seed) | |
561 | #else | |
c906108c SS |
562 | void init_struct_rep( small_struct, seed ) |
563 | struct small_rep_info_t *small_struct; | |
564 | int seed; | |
085dd6e6 | 565 | #endif |
c906108c SS |
566 | { |
567 | ||
568 | small_struct->value = 2 + (seed*2); | |
569 | small_struct->head = 0; | |
570 | } | |
571 | ||
572 | /***************************************************************** | |
573 | * INIT_SMALL_STRUCTS : | |
574 | * Takes all the small structures as input and calls the appropriate | |
575 | * initialization routine for each structure | |
576 | *****************************************************************/ | |
085dd6e6 JM |
577 | #ifdef PROTOTYPES |
578 | void init_small_structs ( | |
579 | struct small_rep_info_t *struct1, | |
580 | struct small_rep_info_t *struct2, | |
581 | struct small_rep_info_t *struct3, | |
582 | struct small_rep_info_t *struct4, | |
583 | struct bit_flags_t *flags, | |
584 | struct bit_flags_combo_t *flags_combo, | |
585 | struct three_char_t *three_char, | |
586 | struct five_char_t *five_char, | |
587 | struct int_char_combo_t *int_char_combo, | |
588 | struct one_double_t *d1, | |
589 | struct one_double_t *d2, | |
590 | struct one_double_t *d3, | |
591 | struct two_floats_t *f1, | |
592 | struct two_floats_t *f2, | |
593 | struct two_floats_t *f3) | |
594 | #else | |
c906108c SS |
595 | void init_small_structs (struct1, struct2, struct3,struct4,flags,flags_combo, |
596 | three_char, five_char,int_char_combo, d1, d2,d3,f1,f2,f3) | |
597 | struct small_rep_info_t *struct1; | |
598 | struct small_rep_info_t *struct2; | |
599 | struct small_rep_info_t *struct3; | |
600 | struct small_rep_info_t *struct4; | |
601 | struct bit_flags_t *flags; | |
602 | struct bit_flags_combo_t *flags_combo; | |
603 | struct three_char_t *three_char; | |
604 | struct five_char_t *five_char; | |
605 | struct int_char_combo_t *int_char_combo; | |
606 | struct one_double_t *d1; | |
607 | struct one_double_t *d2; | |
608 | struct one_double_t *d3; | |
609 | struct two_floats_t *f1; | |
610 | struct two_floats_t *f2; | |
611 | struct two_floats_t *f3; | |
085dd6e6 | 612 | #endif |
c906108c SS |
613 | { |
614 | ||
615 | init_bit_flags(flags, (unsigned)1, (unsigned)0, (unsigned)1, | |
616 | (unsigned)0, (unsigned)1, (unsigned)0 ); | |
617 | init_bit_flags_combo(flags_combo, (unsigned)1, (unsigned)0, 'y', | |
618 | (unsigned)1, (unsigned)0, 'n', | |
619 | (unsigned)1, (unsigned)0 ); | |
620 | init_three_chars(three_char, 'a', 'b', 'c'); | |
621 | init_five_chars(five_char, 'l', 'm', 'n', 'o', 'p'); | |
622 | init_int_char_combo(int_char_combo, 123, 'z'); | |
623 | init_struct_rep(struct1, 2); | |
624 | init_struct_rep(struct2, 4); | |
625 | init_struct_rep(struct3, 5); | |
626 | init_struct_rep(struct4, 6); | |
627 | init_one_double ( d1, 10.5); | |
591b8fa3 PDM |
628 | init_one_double ( d2, -3.375); |
629 | init_one_double ( d3, 675.09375); | |
c906108c SS |
630 | init_two_floats ( f1, 45.234, 43.6); |
631 | init_two_floats ( f2, 78.01, 122.10); | |
632 | init_two_floats ( f3, -1232.345, -199.21); | |
633 | } | |
634 | ||
635 | /***************************************************************** | |
636 | * PRINT_TEN_DOUBLES : | |
637 | * ????????????????????????????? | |
638 | ****************************************************************/ | |
085dd6e6 JM |
639 | #ifdef PROTOTYPES |
640 | void print_ten_doubles ( | |
641 | double d1, | |
642 | double d2, | |
643 | double d3, | |
644 | double d4, | |
645 | double d5, | |
646 | double d6, | |
647 | double d7, | |
648 | double d8, | |
649 | double d9, | |
650 | double d10) | |
651 | #else | |
c906108c SS |
652 | void print_ten_doubles ( d1, d2, d3, d4, d5, d6, d7, d8, d9, d10 ) |
653 | double d1; | |
654 | double d2; | |
655 | double d3; | |
656 | double d4; | |
657 | double d5; | |
658 | double d6; | |
659 | double d7; | |
660 | double d8; | |
661 | double d9; | |
662 | double d10; | |
085dd6e6 | 663 | #endif |
c906108c SS |
664 | { |
665 | ||
666 | printf("Two Doubles : %f\t%f\n", d1, d2); | |
667 | printf("Two Doubles : %f\t%f\n", d3, d4); | |
668 | printf("Two Doubles : %f\t%f\n", d5, d6); | |
669 | printf("Two Doubles : %f\t%f\n", d7, d8); | |
670 | printf("Two Doubles : %f\t%f\n", d9, d10); | |
671 | } | |
672 | ||
673 | /***************************************************************** | |
674 | * PRINT_BIT_FLAGS : | |
675 | * IN struct bit_flags_t bit_flags | |
676 | ****************************************************************/ | |
085dd6e6 JM |
677 | #ifdef PROTOTYPES |
678 | void print_bit_flags (struct bit_flags_t bit_flags) | |
679 | #else | |
c906108c SS |
680 | void print_bit_flags ( bit_flags ) |
681 | struct bit_flags_t bit_flags; | |
085dd6e6 | 682 | #endif |
c906108c SS |
683 | { |
684 | ||
685 | if (bit_flags.alpha) printf("alpha\n"); | |
686 | if (bit_flags.beta) printf("beta\n"); | |
687 | if (bit_flags.gamma) printf("gamma\n"); | |
688 | if (bit_flags.delta) printf("delta\n"); | |
689 | if (bit_flags.epsilon) printf("epsilon\n"); | |
690 | if (bit_flags.omega) printf("omega\n"); | |
691 | } | |
692 | ||
693 | /***************************************************************** | |
694 | * PRINT_BIT_FLAGS_COMBO : | |
695 | * IN struct bit_flags_combo_t bit_flags_combo | |
696 | ****************************************************************/ | |
085dd6e6 JM |
697 | #ifdef PROTOTYPES |
698 | void print_bit_flags_combo (struct bit_flags_combo_t bit_flags_combo) | |
699 | #else | |
c906108c | 700 | void print_bit_flags_combo ( bit_flags_combo ) |
085dd6e6 JM |
701 | struct bit_flags_combo_t bit_flags_combo; |
702 | #endif | |
c906108c SS |
703 | { |
704 | ||
705 | if (bit_flags_combo.alpha) printf("alpha\n"); | |
706 | if (bit_flags_combo.beta) printf("beta\n"); | |
707 | if (bit_flags_combo.gamma) printf("gamma\n"); | |
708 | if (bit_flags_combo.delta) printf("delta\n"); | |
709 | if (bit_flags_combo.epsilon) printf("epsilon\n"); | |
710 | if (bit_flags_combo.omega) printf("omega\n"); | |
711 | printf("ch1: %c\tch2: %c\n", bit_flags_combo.ch1, bit_flags_combo.ch2); | |
712 | } | |
713 | ||
714 | /***************************************************************** | |
715 | * PRINT_ONE_DOUBLE : | |
716 | * IN struct one_double_t one_double | |
717 | ****************************************************************/ | |
085dd6e6 JM |
718 | #ifdef PROTOTYPES |
719 | void print_one_double (struct one_double_t one_double) | |
720 | #else | |
c906108c SS |
721 | void print_one_double ( one_double ) |
722 | struct one_double_t one_double; | |
085dd6e6 | 723 | #endif |
c906108c SS |
724 | { |
725 | ||
726 | printf("Contents of one_double_t: \n\n"); | |
727 | printf("%f\n", one_double.double1); | |
728 | } | |
729 | ||
730 | /***************************************************************** | |
731 | * PRINT_TWO_FLOATS : | |
732 | * IN struct two_floats_t two_floats | |
733 | ****************************************************************/ | |
085dd6e6 JM |
734 | #ifdef PROTOTYPES |
735 | void print_two_floats (struct two_floats_t two_floats) | |
736 | #else | |
c906108c SS |
737 | void print_two_floats ( two_floats ) |
738 | struct two_floats_t two_floats; | |
085dd6e6 | 739 | #endif |
c906108c SS |
740 | { |
741 | ||
742 | printf("Contents of two_floats_t: \n\n"); | |
743 | printf("%f\t%f\n", two_floats.float1, two_floats.float2); | |
744 | } | |
745 | ||
746 | /***************************************************************** | |
747 | * PRINT_TWO_CHARS : | |
748 | * IN struct two_char_t two_char | |
749 | ****************************************************************/ | |
085dd6e6 JM |
750 | #ifdef PROTOTYPES |
751 | void print_two_chars (struct two_char_t two_char) | |
752 | #else | |
c906108c SS |
753 | void print_two_chars ( two_char ) |
754 | struct two_char_t two_char; | |
085dd6e6 | 755 | #endif |
c906108c SS |
756 | { |
757 | ||
758 | printf("Contents of two_char_t: \n\n"); | |
759 | printf("%c\t%c\n", two_char.ch1, two_char.ch2); | |
760 | } | |
761 | ||
762 | /***************************************************************** | |
763 | * PRINT_THREE_CHARS : | |
764 | * IN struct three_char_t three_char | |
765 | ****************************************************************/ | |
085dd6e6 JM |
766 | #ifdef PROTOTYPES |
767 | void print_three_chars (struct three_char_t three_char) | |
768 | #else | |
c906108c SS |
769 | void print_three_chars ( three_char ) |
770 | struct three_char_t three_char; | |
085dd6e6 | 771 | #endif |
c906108c SS |
772 | { |
773 | ||
774 | printf("Contents of three_char_t: \n\n"); | |
775 | printf("%c\t%c\t%c\n", three_char.ch1, three_char.ch2, three_char.ch3); | |
776 | } | |
777 | ||
778 | /***************************************************************** | |
779 | * PRINT_FIVE_CHARS : | |
780 | * IN struct five_char_t five_char | |
781 | ****************************************************************/ | |
085dd6e6 JM |
782 | #ifdef PROTOTYPES |
783 | void print_five_chars (struct five_char_t five_char) | |
784 | #else | |
c906108c SS |
785 | void print_five_chars ( five_char ) |
786 | struct five_char_t five_char; | |
085dd6e6 | 787 | #endif |
c906108c SS |
788 | { |
789 | ||
790 | printf("Contents of five_char_t: \n\n"); | |
791 | printf("%c\t%c\t%c\t%c\t%c\n", five_char.ch1, five_char.ch2, | |
792 | five_char.ch3, five_char.ch4, | |
793 | five_char.ch5); | |
794 | } | |
795 | ||
796 | /***************************************************************** | |
797 | * PRINT_INT_CHAR_COMBO : | |
798 | * IN struct int_char_combo_t int_char_combo | |
799 | ****************************************************************/ | |
085dd6e6 JM |
800 | #ifdef PROTOTYPES |
801 | void print_int_char_combo (struct int_char_combo_t int_char_combo) | |
802 | #else | |
c906108c SS |
803 | void print_int_char_combo ( int_char_combo ) |
804 | struct int_char_combo_t int_char_combo; | |
085dd6e6 | 805 | #endif |
c906108c SS |
806 | { |
807 | ||
808 | printf("Contents of int_char_combo_t: \n\n"); | |
809 | printf("%d\t%c\n", int_char_combo.int1, int_char_combo.ch1); | |
810 | } | |
811 | ||
812 | /***************************************************************** | |
813 | * PRINT_STRUCT_REP : | |
814 | * The last parameter must go onto the stack rather than into a register. | |
815 | * This is a good function to call to test small structures. | |
816 | * IN struct small_rep_info_t struct1 | |
817 | * IN struct small_rep_info_t struct2 | |
818 | * IN struct small_rep_info_t struct3 | |
819 | ****************************************************************/ | |
085dd6e6 JM |
820 | #ifdef PROTOTYPES |
821 | void print_struct_rep( | |
822 | struct small_rep_info_t struct1, | |
823 | struct small_rep_info_t struct2, | |
824 | struct small_rep_info_t struct3) | |
825 | #else | |
c906108c SS |
826 | void print_struct_rep( struct1, struct2, struct3) |
827 | struct small_rep_info_t struct1; | |
828 | struct small_rep_info_t struct2; | |
829 | struct small_rep_info_t struct3; | |
085dd6e6 | 830 | #endif |
c906108c SS |
831 | { |
832 | ||
833 | ||
834 | printf("Contents of struct1: \n\n"); | |
835 | printf("%10d%10d\n", struct1.value, struct1.head); | |
836 | printf("Contents of struct2: \n\n"); | |
837 | printf("%10d%10d\n", struct2.value, struct2.head); | |
838 | printf("Contents of struct3: \n\n"); | |
839 | printf("%10d%10d\n", struct3.value, struct3.head); | |
840 | ||
841 | } | |
842 | ||
843 | /***************************************************************** | |
844 | * SUM_STRUCT_PRINT : | |
845 | * The last two parameters must go onto the stack rather than into a register. | |
846 | * This is a good function to call to test small structures. | |
847 | * IN struct small_rep_info_t struct1 | |
848 | * IN struct small_rep_info_t struct2 | |
849 | * IN struct small_rep_info_t struct3 | |
850 | * IN struct small_rep_info_t struct4 | |
851 | ****************************************************************/ | |
085dd6e6 JM |
852 | #ifdef PROTOTYPES |
853 | void sum_struct_print ( | |
854 | int seed, | |
855 | struct small_rep_info_t struct1, | |
856 | struct small_rep_info_t struct2, | |
857 | struct small_rep_info_t struct3, | |
858 | struct small_rep_info_t struct4) | |
859 | #else | |
c906108c SS |
860 | void sum_struct_print ( seed, struct1, struct2, struct3, struct4) |
861 | int seed; | |
862 | struct small_rep_info_t struct1; | |
863 | struct small_rep_info_t struct2; | |
864 | struct small_rep_info_t struct3; | |
865 | struct small_rep_info_t struct4; | |
085dd6e6 | 866 | #endif |
c906108c SS |
867 | { |
868 | int sum; | |
869 | ||
870 | printf("Sum of the 4 struct values and seed : \n\n"); | |
871 | sum = seed + struct1.value + struct2.value + struct3.value + struct4.value; | |
872 | printf("%10d\n", sum); | |
873 | } | |
874 | ||
875 | /***************************************************************** | |
876 | * PRINT_SMALL_STRUCTS : | |
877 | * This is a good function to call to test small structures. | |
878 | * All of the small structures of odd sizes (40 bits, 8bits, etc.) | |
879 | * are pushed onto the stack. | |
880 | ****************************************************************/ | |
085dd6e6 JM |
881 | #ifdef PROTOTYPES |
882 | void print_small_structs ( | |
883 | struct small_rep_info_t struct1, | |
884 | struct small_rep_info_t struct2, | |
885 | struct small_rep_info_t struct3, | |
886 | struct small_rep_info_t struct4, | |
887 | struct bit_flags_t flags, | |
888 | struct bit_flags_combo_t flags_combo, | |
889 | struct three_char_t three_char, | |
890 | struct five_char_t five_char, | |
891 | struct int_char_combo_t int_char_combo, | |
892 | struct one_double_t d1, | |
893 | struct one_double_t d2, | |
894 | struct one_double_t d3, | |
895 | struct two_floats_t f1, | |
896 | struct two_floats_t f2, | |
897 | struct two_floats_t f3) | |
898 | #else | |
c906108c SS |
899 | void print_small_structs ( struct1, struct2, struct3, struct4, flags, |
900 | flags_combo, three_char, five_char, int_char_combo, d1, d2,d3,f1,f2,f3) | |
901 | struct small_rep_info_t struct1; | |
902 | struct small_rep_info_t struct2; | |
903 | struct small_rep_info_t struct3; | |
904 | struct small_rep_info_t struct4; | |
905 | struct bit_flags_t flags; | |
906 | struct bit_flags_combo_t flags_combo; | |
907 | struct three_char_t three_char; | |
908 | struct five_char_t five_char; | |
909 | struct int_char_combo_t int_char_combo; | |
910 | struct one_double_t d1; | |
911 | struct one_double_t d2; | |
912 | struct one_double_t d3; | |
913 | struct two_floats_t f1; | |
914 | struct two_floats_t f2; | |
915 | struct two_floats_t f3; | |
085dd6e6 | 916 | #endif |
c906108c SS |
917 | { |
918 | print_bit_flags(flags); | |
919 | print_bit_flags_combo(flags_combo); | |
920 | print_three_chars(three_char); | |
921 | print_five_chars(five_char); | |
922 | print_int_char_combo(int_char_combo); | |
923 | sum_struct_print(10, struct1, struct2, struct3, struct4); | |
924 | print_struct_rep(struct1, struct2, struct3); | |
925 | print_one_double(d1); | |
926 | print_one_double(d2); | |
927 | print_one_double(d3); | |
928 | print_two_floats(f1); | |
929 | print_two_floats(f2); | |
930 | print_two_floats(f3); | |
931 | } | |
932 | ||
933 | /***************************************************************** | |
934 | * PRINT_LONG_ARG_LIST : | |
935 | * This is a good function to call to test small structures. | |
936 | * The first two parameters ( the doubles ) go into registers. The | |
937 | * remaining arguments are pushed onto the stack. Depending on where | |
938 | * print_long_arg_list is called from, the size of the argument list | |
939 | * may force more space to be pushed onto the stack as part of the callers | |
940 | * frame. | |
941 | ****************************************************************/ | |
085dd6e6 JM |
942 | #ifdef PROTOTYPES |
943 | void print_long_arg_list ( | |
944 | double a, | |
945 | double b, | |
946 | int c, | |
947 | int d, | |
948 | int e, | |
949 | int f, | |
950 | struct small_rep_info_t struct1, | |
951 | struct small_rep_info_t struct2, | |
952 | struct small_rep_info_t struct3, | |
953 | struct small_rep_info_t struct4, | |
954 | struct bit_flags_t flags, | |
955 | struct bit_flags_combo_t flags_combo, | |
956 | struct three_char_t three_char, | |
957 | struct five_char_t five_char, | |
958 | struct int_char_combo_t int_char_combo, | |
959 | struct one_double_t d1, | |
960 | struct one_double_t d2, | |
961 | struct one_double_t d3, | |
962 | struct two_floats_t f1, | |
963 | struct two_floats_t f2, | |
964 | struct two_floats_t f3) | |
965 | #else | |
c906108c SS |
966 | void print_long_arg_list ( a, b, c, d, e, f, struct1, struct2, struct3, |
967 | struct4, flags, flags_combo, three_char, five_char, int_char_combo, d1,d2,d3, | |
968 | f1, f2, f3 ) | |
969 | double a; | |
970 | double b; | |
971 | int c; | |
972 | int d; | |
973 | int e; | |
974 | int f; | |
975 | struct small_rep_info_t struct1; | |
976 | struct small_rep_info_t struct2; | |
977 | struct small_rep_info_t struct3; | |
978 | struct small_rep_info_t struct4; | |
979 | struct bit_flags_t flags; | |
980 | struct bit_flags_combo_t flags_combo; | |
981 | struct three_char_t three_char; | |
982 | struct five_char_t five_char; | |
983 | struct int_char_combo_t int_char_combo; | |
984 | struct one_double_t d1; | |
985 | struct one_double_t d2; | |
986 | struct one_double_t d3; | |
987 | struct two_floats_t f1; | |
988 | struct two_floats_t f2; | |
989 | struct two_floats_t f3; | |
085dd6e6 | 990 | #endif |
c906108c SS |
991 | { |
992 | printf("double : %f\n", a); | |
993 | printf("double : %f\n", b); | |
994 | printf("int : %d\n", c); | |
995 | printf("int : %d\n", d); | |
996 | printf("int : %d\n", e); | |
997 | printf("int : %d\n", f); | |
998 | print_small_structs( struct1, struct2, struct3, struct4, flags, flags_combo, | |
999 | three_char, five_char, int_char_combo, d1, d2, d3, | |
1000 | f1, f2, f3); | |
1001 | } | |
1002 | ||
1003 | ||
085dd6e6 JM |
1004 | #ifdef PROTOTYPES |
1005 | void print_one_large_struct (struct array_rep_info_t linked_list1) | |
1006 | #else | |
c906108c SS |
1007 | void print_one_large_struct( linked_list1 ) |
1008 | struct array_rep_info_t linked_list1; | |
085dd6e6 | 1009 | #endif |
c906108c SS |
1010 | { |
1011 | ||
1012 | /* printf("Contents of linked list1: \n\n"); | |
1013 | printf("Element Value | Index of Next Element\n"); | |
1014 | printf("-------------------------------------\n"); | |
1015 | printf(" | \n");*/ | |
1016 | /*for (index = 0; index < 10; index++) {*/ | |
1017 | ||
1018 | printf("%10d%10d\n", linked_list1.values[0], | |
1019 | linked_list1.next_index[0]); | |
1020 | /*}*/ | |
1021 | } | |
1022 | ||
1023 | /***************************************************************** | |
1024 | * PRINT_ARRAY_REP : | |
1025 | * The three structure parameters should fit into registers. | |
1026 | * IN struct array_rep_info_t linked_list1 | |
1027 | * IN struct array_rep_info_t linked_list2 | |
1028 | * IN struct array_rep_info_t linked_list3 | |
1029 | ****************************************************************/ | |
085dd6e6 JM |
1030 | #ifdef PROTOTYPES |
1031 | void print_array_rep( | |
1032 | struct array_rep_info_t linked_list1, | |
1033 | struct array_rep_info_t linked_list2, | |
1034 | struct array_rep_info_t linked_list3) | |
1035 | #else | |
c906108c SS |
1036 | void print_array_rep( linked_list1, linked_list2, linked_list3 ) |
1037 | struct array_rep_info_t linked_list1; | |
1038 | struct array_rep_info_t linked_list2; | |
1039 | struct array_rep_info_t linked_list3; | |
085dd6e6 | 1040 | #endif |
c906108c SS |
1041 | { |
1042 | ||
1043 | int index; | |
1044 | ||
1045 | printf("Contents of linked list1: \n\n"); | |
1046 | printf("Element Value | Index of Next Element\n"); | |
1047 | printf("-------------------------------------\n"); | |
1048 | printf(" | \n"); | |
1049 | for (index = 0; index < 10; index++) { | |
1050 | ||
1051 | printf("%10d%10d\n", linked_list1.values[index], | |
1052 | linked_list1.next_index[index]); | |
1053 | } | |
1054 | ||
1055 | printf("Contents of linked list2: \n\n"); | |
1056 | printf("Element Value | Index of Next Element\n"); | |
1057 | printf("-------------------------------------\n"); | |
1058 | printf(" | \n"); | |
1059 | for (index = 0; index < 10; index++) { | |
1060 | ||
1061 | printf("%10d%10d\n", linked_list2.values[index], | |
1062 | linked_list2.next_index[index]); | |
1063 | } | |
1064 | ||
1065 | printf("Contents of linked list3: \n\n"); | |
1066 | printf("Element Value | Index of Next Element\n"); | |
1067 | printf("-------------------------------------\n"); | |
1068 | printf(" | \n"); | |
1069 | for (index = 0; index < 10; index++) { | |
1070 | ||
1071 | printf("%10d%10d\n", linked_list3.values[index], | |
1072 | linked_list3.next_index[index]); | |
1073 | } | |
1074 | ||
1075 | } | |
1076 | ||
1077 | /***************************************************************** | |
1078 | * SUM_ARRAY_PRINT : | |
1079 | * The last structure parameter must be pushed onto the stack | |
1080 | * IN int seed | |
1081 | * IN struct array_rep_info_t linked_list1 | |
1082 | * IN struct array_rep_info_t linked_list2 | |
1083 | * IN struct array_rep_info_t linked_list3 | |
1084 | * IN struct array_rep_info_t linked_list4 | |
1085 | ****************************************************************/ | |
085dd6e6 JM |
1086 | #ifdef PROTOTYPES |
1087 | void sum_array_print ( | |
1088 | int seed, | |
1089 | struct array_rep_info_t linked_list1, | |
1090 | struct array_rep_info_t linked_list2, | |
1091 | struct array_rep_info_t linked_list3, | |
1092 | struct array_rep_info_t linked_list4) | |
1093 | #else | |
c906108c SS |
1094 | void sum_array_print ( seed, linked_list1, linked_list2, linked_list3,linked_list4) |
1095 | int seed; | |
1096 | struct array_rep_info_t linked_list1; | |
1097 | struct array_rep_info_t linked_list2; | |
1098 | struct array_rep_info_t linked_list3; | |
1099 | struct array_rep_info_t linked_list4; | |
085dd6e6 | 1100 | #endif |
c906108c SS |
1101 | { |
1102 | int index; | |
1103 | int sum; | |
1104 | ||
1105 | printf("Sum of 4 arrays, by element (add in seed as well): \n\n"); | |
1106 | printf("Seed: %d\n", seed); | |
1107 | printf("Element Index | Sum \n"); | |
1108 | printf("-------------------------\n"); | |
1109 | printf(" | \n"); | |
1110 | ||
1111 | for (index = 0; index < 10; index++) { | |
1112 | ||
1113 | sum = seed + linked_list1.values[index] + linked_list2.values[index] + | |
1114 | linked_list3.values[index] + linked_list4.values[index]; | |
1115 | printf("%10d%10d\n", index, sum); | |
1116 | } | |
1117 | } | |
1118 | ||
1119 | /***************************************************************** | |
1120 | * INIT_ARRAY_REP : | |
1121 | * IN struct array_rep_info_t *linked_list | |
1122 | * IN int seed | |
1123 | ****************************************************************/ | |
085dd6e6 JM |
1124 | #ifdef PROTOTYPES |
1125 | void init_array_rep( | |
1126 | struct array_rep_info_t *linked_list, | |
1127 | int seed) | |
1128 | #else | |
c906108c SS |
1129 | void init_array_rep( linked_list, seed ) |
1130 | struct array_rep_info_t *linked_list; | |
1131 | int seed; | |
085dd6e6 | 1132 | #endif |
c906108c SS |
1133 | { |
1134 | ||
1135 | int index; | |
1136 | ||
1137 | for (index = 0; index < 10; index++) { | |
1138 | ||
1139 | linked_list->values[index] = (2*index) + (seed*2); | |
1140 | linked_list->next_index[index] = index + 1; | |
1141 | } | |
1142 | linked_list->head = 0; | |
1143 | } | |
1144 | ||
1145 | ||
1146 | int main () { | |
1147 | ||
1148 | /* variables for array and enumerated type testing | |
1149 | */ | |
1b7c05e7 CV |
1150 | static char char_array[121]; |
1151 | static double double_array[9]; | |
1152 | static float float_array[15]; | |
1153 | static int integer_array[50]; | |
1154 | static int index; | |
1155 | static id_int student_id = 23; | |
1156 | static colors my_shirt = YELLOW; | |
c906108c SS |
1157 | |
1158 | /* variables for large structure testing | |
1159 | */ | |
1b7c05e7 CV |
1160 | static int number = 10; |
1161 | static struct array_rep_info_t *list1; | |
1162 | static struct array_rep_info_t *list2; | |
1163 | static struct array_rep_info_t *list3; | |
1164 | static struct array_rep_info_t *list4; | |
c906108c SS |
1165 | |
1166 | /* variables for testing a very long argument list | |
1167 | */ | |
1b7c05e7 CV |
1168 | static double a; |
1169 | static double b; | |
1170 | static int c; | |
1171 | static int d; | |
1172 | static int e; | |
1173 | static int f; | |
c906108c SS |
1174 | |
1175 | /* variables for testing a small structures and a very long argument list | |
1176 | */ | |
1b7c05e7 CV |
1177 | static struct small_rep_info_t *struct1; |
1178 | static struct small_rep_info_t *struct2; | |
1179 | static struct small_rep_info_t *struct3; | |
1180 | static struct small_rep_info_t *struct4; | |
1181 | static struct bit_flags_t *flags; | |
1182 | static struct bit_flags_combo_t *flags_combo; | |
1183 | static struct three_char_t *three_char; | |
1184 | static struct five_char_t *five_char; | |
1185 | static struct int_char_combo_t *int_char_combo; | |
1186 | static struct one_double_t *d1; | |
1187 | static struct one_double_t *d2; | |
1188 | static struct one_double_t *d3; | |
1189 | static struct two_floats_t *f1; | |
1190 | static struct two_floats_t *f2; | |
1191 | static struct two_floats_t *f3; | |
c906108c SS |
1192 | |
1193 | /* Initialize arrays | |
1194 | */ | |
1195 | for (index = 0; index < 120; index++) { | |
1196 | if ((index%2) == 0) char_array[index] = 'Z'; | |
1197 | else char_array[index] = 'a'; | |
085dd6e6 JM |
1198 | } |
1199 | char_array[120] = '\0'; | |
c906108c | 1200 | |
1b7c05e7 | 1201 | for (index = 0; index < 9; index++) { |
c906108c SS |
1202 | double_array[index] = index*23.4567; |
1203 | } | |
1204 | ||
1205 | for (index = 0; index < 15; index++) { | |
1206 | float_array[index] = index/7.02; | |
1207 | } | |
1208 | ||
1209 | for (index = 0; index < 50; index++) { | |
1210 | integer_array[index] = -index; | |
1211 | } | |
1212 | ||
1213 | /* Print arrays | |
1214 | */ | |
1215 | print_char_array(char_array); | |
1216 | print_double_array(double_array); | |
1217 | print_float_array(float_array); | |
1218 | print_student_id_shirt_color(student_id, my_shirt); | |
1219 | print_int_array(integer_array); | |
1220 | print_all_arrays(integer_array, char_array, float_array, double_array); | |
1221 | ||
1222 | /* Allocate space for large structures | |
1223 | */ | |
1224 | list1 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t)); | |
1225 | list2 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t)); | |
1226 | list3 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t)); | |
1227 | list4 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t)); | |
1228 | ||
1229 | /* Initialize large structures | |
1230 | */ | |
1231 | init_array_rep(list1, 2); | |
1232 | init_array_rep(list2, 4); | |
1233 | init_array_rep(list3, 5); | |
1234 | init_array_rep(list4, 10); | |
1235 | printf("HELLO WORLD\n"); | |
1236 | printf("BYE BYE FOR NOW\n"); | |
1237 | printf("VERY GREEN GRASS\n"); | |
1238 | ||
1239 | /* Print large structures | |
1240 | */ | |
1241 | sum_array_print(10, *list1, *list2, *list3, *list4); | |
1242 | print_array_rep(*list1, *list2, *list3); | |
1243 | print_one_large_struct(*list1); | |
1244 | ||
1245 | /* Allocate space for small structures | |
1246 | */ | |
1247 | struct1 = (struct small_rep_info_t *)malloc(sizeof(struct small_rep_info_t)); | |
1248 | struct2 = (struct small_rep_info_t *)malloc(sizeof(struct small_rep_info_t)); | |
1249 | struct3 = (struct small_rep_info_t *)malloc(sizeof(struct small_rep_info_t)); | |
1250 | struct4 = (struct small_rep_info_t *)malloc(sizeof(struct small_rep_info_t)); | |
1251 | flags = (struct bit_flags_t *)malloc(sizeof(struct bit_flags_t)); | |
1252 | flags_combo = (struct bit_flags_combo_t *)malloc(sizeof(struct bit_flags_combo_t)); | |
1253 | three_char = (struct three_char_t *)malloc(sizeof(struct three_char_t)); | |
1254 | five_char = (struct five_char_t *)malloc(sizeof(struct five_char_t)); | |
1255 | int_char_combo = (struct int_char_combo_t *)malloc(sizeof(struct int_char_combo_t)); | |
1256 | ||
1257 | d1 = (struct one_double_t *)malloc(sizeof(struct one_double_t)); | |
1258 | d2 = (struct one_double_t *)malloc(sizeof(struct one_double_t)); | |
1259 | d3 = (struct one_double_t *)malloc(sizeof(struct one_double_t)); | |
1260 | ||
1261 | f1 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t)); | |
1262 | f2 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t)); | |
1263 | f3 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t)); | |
1264 | ||
1265 | /* Initialize small structures | |
1266 | */ | |
1267 | init_small_structs ( struct1, struct2, struct3, struct4, flags, | |
1268 | flags_combo, three_char, five_char, int_char_combo, | |
1269 | d1, d2, d3, f1, f2, f3); | |
1270 | ||
1271 | /* Print small structures | |
1272 | */ | |
1273 | print_small_structs ( *struct1, *struct2, *struct3, *struct4, *flags, | |
1274 | *flags_combo, *three_char, *five_char, *int_char_combo, | |
1275 | *d1, *d2, *d3, *f1, *f2, *f3); | |
1276 | ||
1277 | /* Print a very long arg list | |
1278 | */ | |
591b8fa3 PDM |
1279 | a = 22.25; |
1280 | b = 33.375; | |
c906108c SS |
1281 | c = 0; |
1282 | d = -25; | |
1283 | e = 100; | |
1284 | f = 2345; | |
1285 | ||
1286 | print_long_arg_list ( a, b, c, d, e, f, *struct1, *struct2, *struct3, *struct4, | |
1287 | *flags, *flags_combo, *three_char, *five_char, *int_char_combo, | |
1288 | *d1, *d2, *d3, *f1, *f2, *f3); | |
1289 | ||
1290 | /* Initialize small structures | |
1291 | */ | |
1292 | init_one_double ( d1, 1.11111); | |
1293 | init_one_double ( d2, -345.34); | |
1294 | init_one_double ( d3, 546464.2); | |
1295 | init_two_floats ( f1, 0.234, 453.1); | |
1296 | init_two_floats ( f2, 78.345, 23.09); | |
1297 | init_two_floats ( f3, -2.345, 1.0); | |
1298 | init_bit_flags(flags, (unsigned)1, (unsigned)0, (unsigned)1, | |
1299 | (unsigned)0, (unsigned)1, (unsigned)0 ); | |
1300 | init_bit_flags_combo(flags_combo, (unsigned)1, (unsigned)0, 'y', | |
1301 | (unsigned)1, (unsigned)0, 'n', | |
1302 | (unsigned)1, (unsigned)0 ); | |
1303 | init_three_chars(three_char, 'x', 'y', 'z'); | |
1304 | init_five_chars(five_char, 'h', 'e', 'l', 'l', 'o'); | |
1305 | init_int_char_combo(int_char_combo, 13, '!'); | |
1306 | init_struct_rep(struct1, 10); | |
1307 | init_struct_rep(struct2, 20); | |
1308 | init_struct_rep(struct3, 30); | |
1309 | init_struct_rep(struct4, 40); | |
1310 | ||
1311 | compute_with_small_structs(35); | |
1312 | loop_count(); | |
1313 | printf("HELLO WORLD\n"); | |
1314 | printf("BYE BYE FOR NOW\n"); | |
1315 | printf("VERY GREEN GRASS\n"); | |
1316 | ||
1317 | /* Print small structures | |
1318 | */ | |
1319 | print_one_double(*d1); | |
1320 | print_one_double(*d2); | |
1321 | print_one_double(*d3); | |
1322 | print_two_floats(*f1); | |
1323 | print_two_floats(*f2); | |
1324 | print_two_floats(*f3); | |
1325 | print_bit_flags(*flags); | |
1326 | print_bit_flags_combo(*flags_combo); | |
1327 | print_three_chars(*three_char); | |
1328 | print_five_chars(*five_char); | |
1329 | print_int_char_combo(*int_char_combo); | |
1330 | sum_struct_print(10, *struct1, *struct2, *struct3, *struct4); | |
1331 | print_struct_rep(*struct1, *struct2, *struct3); | |
1332 | ||
1333 | return 0; | |
1334 | } | |
1335 | ||
1336 | ||
1337 | ||
1338 | ||
1339 |