?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync usage with man page.
[netbsd-mini2440.git] / gnu / dist / gdb6 / gdb / testsuite / gdb.base / call-ar-st.c
blobd903f0d3f6bff0ff79f934e213c6df230d08b559
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 *****************************************************************/
144 #ifdef PROTOTYPES
145 void print_student_id_shirt_color (id_int student, colors shirt)
146 #else
147 void print_student_id_shirt_color ( student, shirt )
148 id_int student;
149 colors shirt;
150 #endif
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 *****************************************************************/
199 #ifdef PROTOTYPES
200 void print_char_array (char array_c[])
201 #else
202 void print_char_array ( array_c )
203 char array_c[];
204 #endif
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 *****************************************************************/
222 #ifdef PROTOTYPES
223 void print_double_array (double array_d[])
224 #else
225 void print_double_array (array_d)
226 double array_d[];
227 #endif
228 {
229
230 int index;
231
232 printf("array_d :\n");
233 printf("=========\n\n");
234 for (index = 0; index < 9; index++) {
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 *****************************************************************/
245 #ifdef PROTOTYPES
246 void print_float_array (float array_f[])
247 #else
248 void print_float_array ( array_f )
249 float array_f[];
250 #endif
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 *****************************************************************/
269 #ifdef PROTOTYPES
270 void print_int_array (int array_i[])
271 #else
272 void print_int_array ( array_i )
273 int array_i[];
274 #endif
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 *****************************************************************/
296 #ifdef PROTOTYPES
297 void print_all_arrays(int array_i[], char array_c[], float array_f[], double array_d[])
298 #else
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[];
304 #endif
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 *****************************************************************/
328 #ifdef PROTOTYPES
329 void compute_with_small_structs (int seed)
330 #else
331 void compute_with_small_structs ( seed )
332 int seed;
333 #endif
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 *****************************************************************/
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
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;
374 #endif
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 *****************************************************************/
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
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;
413 #endif
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 *****************************************************************/
432 #ifdef PROTOTYPES
433 void init_one_double (struct one_double_t *one_double, double init_val)
434 #else
435 void init_one_double ( one_double, init_val )
436 struct one_double_t *one_double;
437 double init_val;
438 #endif
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 *****************************************************************/
450 #ifdef PROTOTYPES
451 void init_two_floats (struct two_floats_t *two_floats, float init_val1, float init_val2)
452 #else
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;
457 #endif
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 *****************************************************************/
469 #ifdef PROTOTYPES
470 void init_two_chars (struct two_char_t *two_char, char init_val1, char init_val2)
471 #else
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;
476 #endif
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 *****************************************************************/
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
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;
498 #endif
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 *****************************************************************/
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
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;
525 #endif
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 *****************************************************************/
540 #ifdef PROTOTYPES
541 void init_int_char_combo (struct int_char_combo_t *combo, int init_val1, char init_val2)
542 #else
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;
547 #endif
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 *****************************************************************/
559 #ifdef PROTOTYPES
560 void init_struct_rep(struct small_rep_info_t *small_struct, int seed)
561 #else
562 void init_struct_rep( small_struct, seed )
563 struct small_rep_info_t *small_struct;
564 int seed;
565 #endif
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 *****************************************************************/
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
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;
612 #endif
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);
628 init_one_double ( d2, -3.375);
629 init_one_double ( d3, 675.09375);
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 ****************************************************************/
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
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;
663 #endif
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 ****************************************************************/
677 #ifdef PROTOTYPES
678 void print_bit_flags (struct bit_flags_t bit_flags)
679 #else
680 void print_bit_flags ( bit_flags )
681 struct bit_flags_t bit_flags;
682 #endif
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 ****************************************************************/
697 #ifdef PROTOTYPES
698 void print_bit_flags_combo (struct bit_flags_combo_t bit_flags_combo)
699 #else
700 void print_bit_flags_combo ( bit_flags_combo )
701 struct bit_flags_combo_t bit_flags_combo;
702 #endif
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 ****************************************************************/
718 #ifdef PROTOTYPES
719 void print_one_double (struct one_double_t one_double)
720 #else
721 void print_one_double ( one_double )
722 struct one_double_t one_double;
723 #endif
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 ****************************************************************/
734 #ifdef PROTOTYPES
735 void print_two_floats (struct two_floats_t two_floats)
736 #else
737 void print_two_floats ( two_floats )
738 struct two_floats_t two_floats;
739 #endif
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 ****************************************************************/
750 #ifdef PROTOTYPES
751 void print_two_chars (struct two_char_t two_char)
752 #else
753 void print_two_chars ( two_char )
754 struct two_char_t two_char;
755 #endif
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 ****************************************************************/
766 #ifdef PROTOTYPES
767 void print_three_chars (struct three_char_t three_char)
768 #else
769 void print_three_chars ( three_char )
770 struct three_char_t three_char;
771 #endif
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 ****************************************************************/
782 #ifdef PROTOTYPES
783 void print_five_chars (struct five_char_t five_char)
784 #else
785 void print_five_chars ( five_char )
786 struct five_char_t five_char;
787 #endif
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 ****************************************************************/
800 #ifdef PROTOTYPES
801 void print_int_char_combo (struct int_char_combo_t int_char_combo)
802 #else
803 void print_int_char_combo ( int_char_combo )
804 struct int_char_combo_t int_char_combo;
805 #endif
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 ****************************************************************/
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
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;
830 #endif
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 ****************************************************************/
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
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;
866 #endif
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 ****************************************************************/
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
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;
916 #endif
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 ****************************************************************/
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
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;
990 #endif
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
1004 #ifdef PROTOTYPES
1005 void print_one_large_struct (struct array_rep_info_t linked_list1)
1006 #else
1007 void print_one_large_struct( linked_list1 )
1008 struct array_rep_info_t linked_list1;
1009 #endif
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 ****************************************************************/
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
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;
1040 #endif
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 ****************************************************************/
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
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;
1100 #endif
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 ****************************************************************/
1124 #ifdef PROTOTYPES
1125 void init_array_rep(
1126 struct array_rep_info_t *linked_list,
1127 int seed)
1128 #else
1129 void init_array_rep( linked_list, seed )
1130 struct array_rep_info_t *linked_list;
1131 int seed;
1132 #endif
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 */
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;
1157
1158 /* variables for large structure testing
1159 */
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;
1165
1166 /* variables for testing a very long argument list
1167 */
1168 static double a;
1169 static double b;
1170 static int c;
1171 static int d;
1172 static int e;
1173 static int f;
1174
1175 /* variables for testing a small structures and a very long argument list
1176 */
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;
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';
1198 }
1199 char_array[120] = '\0';
1200
1201 for (index = 0; index < 9; index++) {
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 */
1279 a = 22.25;
1280 b = 33.375;
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
NetBSD on the FriendlyARM MINI2440