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