Commit | Line | Data |
---|---|---|
c906108c SS |
1 | #include <stdio.h> |
2 | #include <stdlib.h> | |
3 | #include <string.h> | |
4 | ||
dedad4e3 PA |
5 | #include "../lib/unbuffer_output.c" |
6 | ||
c906108c SS |
7 | /************************************************************************** |
8 | * TESTS : | |
9 | * function returning large structures, which go on the stack | |
10 | * functions returning varied sized structs which go on in the registers. | |
11 | ***************************************************************************/ | |
12 | ||
13 | ||
14 | /* A large structure (> 64 bits) used to test passing large structures as | |
15 | * parameters | |
16 | */ | |
17 | ||
18 | struct array_rep_info_t { | |
19 | int next_index[10]; | |
20 | int values[10]; | |
21 | int head; | |
22 | }; | |
23 | ||
24 | /***************************************************************************** | |
25 | * Small structures ( <= 64 bits). These are used to test passing small | |
26 | * structures as parameters and test argument size promotion. | |
27 | *****************************************************************************/ | |
28 | ||
29 | /* 64 bits | |
30 | */ | |
31 | struct small_rep_info_t { | |
32 | int value; | |
33 | int head; | |
34 | }; | |
35 | ||
618ec112 CV |
36 | /* 6 bits : really fits in 8 bits and is promoted to 8 bits |
37 | */ | |
38 | struct bit_flags_char_t { | |
39 | unsigned char alpha :1; | |
40 | unsigned char beta :1; | |
41 | unsigned char gamma :1; | |
42 | unsigned char delta :1; | |
43 | unsigned char epsilon :1; | |
44 | unsigned char omega :1; | |
45 | }; | |
46 | ||
47 | /* 6 bits : really fits in 8 bits and is promoted to 16 bits | |
48 | */ | |
49 | struct bit_flags_short_t { | |
50 | unsigned short alpha :1; | |
51 | unsigned short beta :1; | |
52 | unsigned short gamma :1; | |
53 | unsigned short delta :1; | |
54 | unsigned short epsilon :1; | |
55 | unsigned short omega :1; | |
56 | }; | |
57 | ||
c906108c SS |
58 | /* 6 bits : really fits in 8 bits and is promoted to 32 bits |
59 | */ | |
60 | struct bit_flags_t { | |
61 | unsigned alpha :1; | |
62 | unsigned beta :1; | |
63 | unsigned gamma :1; | |
64 | unsigned delta :1; | |
65 | unsigned epsilon :1; | |
66 | unsigned omega :1; | |
67 | }; | |
68 | ||
69 | /* 22 bits : really fits in 40 bits and is promoted to 64 bits | |
70 | */ | |
71 | struct bit_flags_combo_t { | |
72 | unsigned alpha :1; | |
73 | unsigned beta :1; | |
74 | char ch1; | |
75 | unsigned gamma :1; | |
76 | unsigned delta :1; | |
77 | char ch2; | |
78 | unsigned epsilon :1; | |
79 | unsigned omega :1; | |
80 | }; | |
81 | ||
82 | /* 64 bits | |
83 | */ | |
84 | struct one_double_t { | |
85 | double double1; | |
86 | }; | |
87 | ||
88 | /* 64 bits | |
89 | */ | |
90 | struct two_floats_t { | |
91 | float float1; | |
92 | float float2; | |
93 | }; | |
94 | ||
95 | ||
96 | /* 24 bits : promoted to 32 bits | |
97 | */ | |
98 | struct three_char_t { | |
99 | char ch1; | |
100 | char ch2; | |
101 | char ch3; | |
102 | }; | |
103 | ||
104 | /* 40 bits : promoted to 64 bits | |
105 | */ | |
106 | struct five_char_t { | |
107 | char ch1; | |
108 | char ch2; | |
109 | char ch3; | |
110 | char ch4; | |
111 | char ch5; | |
112 | }; | |
113 | ||
114 | /* 40 bits : promoted to 64 bits | |
115 | */ | |
116 | struct int_char_combo_t { | |
117 | int int1; | |
118 | char ch1; | |
119 | }; | |
120 | ||
121 | ||
122 | /***************************************************************** | |
123 | * LOOP_COUNT : | |
124 | * A do nothing function. Used to provide a point at which calls can be made. | |
125 | *****************************************************************/ | |
126 | void loop_count () { | |
127 | ||
128 | int index; | |
129 | ||
dbfdb174 | 130 | for (index=0; index<4; index++); /* -break1- */ |
c906108c SS |
131 | } |
132 | ||
618ec112 CV |
133 | /***************************************************************** |
134 | * INIT_BIT_FLAGS_CHAR : | |
135 | * Initializes a bit_flags_char_t structure. Can call this function see | |
136 | * the call command behavior when integer arguments do not fit into | |
137 | * registers and must be placed on the stack. | |
138 | * OUT struct bit_flags_char_t *bit_flags -- structure to be filled | |
139 | * IN unsigned a -- 0 or 1 | |
140 | * IN unsigned b -- 0 or 1 | |
141 | * IN unsigned g -- 0 or 1 | |
142 | * IN unsigned d -- 0 or 1 | |
143 | * IN unsigned e -- 0 or 1 | |
144 | * IN unsigned o -- 0 or 1 | |
145 | *****************************************************************/ | |
618ec112 CV |
146 | void init_bit_flags_char ( |
147 | struct bit_flags_char_t *bit_flags, | |
148 | unsigned a, | |
149 | unsigned b, | |
150 | unsigned g, | |
151 | unsigned d, | |
152 | unsigned e, | |
153 | unsigned o) | |
618ec112 CV |
154 | { |
155 | ||
156 | bit_flags->alpha = a; | |
157 | bit_flags->beta = b; | |
158 | bit_flags->gamma = g; | |
159 | bit_flags->delta = d; | |
160 | bit_flags->epsilon = e; | |
161 | bit_flags->omega = o; | |
162 | } | |
163 | ||
164 | /***************************************************************** | |
165 | * INIT_BIT_FLAGS_SHORT : | |
166 | * Initializes a bit_flags_short_t structure. Can call this function see | |
167 | * the call command behavior when integer arguments do not fit into | |
168 | * registers and must be placed on the stack. | |
169 | * OUT struct bit_flags_short_t *bit_flags -- structure to be filled | |
170 | * IN unsigned a -- 0 or 1 | |
171 | * IN unsigned b -- 0 or 1 | |
172 | * IN unsigned g -- 0 or 1 | |
173 | * IN unsigned d -- 0 or 1 | |
174 | * IN unsigned e -- 0 or 1 | |
175 | * IN unsigned o -- 0 or 1 | |
176 | *****************************************************************/ | |
618ec112 CV |
177 | void init_bit_flags_short ( |
178 | struct bit_flags_short_t *bit_flags, | |
179 | unsigned a, | |
180 | unsigned b, | |
181 | unsigned g, | |
182 | unsigned d, | |
183 | unsigned e, | |
184 | unsigned o) | |
618ec112 CV |
185 | { |
186 | ||
187 | bit_flags->alpha = a; | |
188 | bit_flags->beta = b; | |
189 | bit_flags->gamma = g; | |
190 | bit_flags->delta = d; | |
191 | bit_flags->epsilon = e; | |
192 | bit_flags->omega = o; | |
193 | } | |
194 | ||
c906108c SS |
195 | /***************************************************************** |
196 | * INIT_BIT_FLAGS : | |
197 | * Initializes a bit_flags_t structure. Can call this function see | |
198 | * the call command behavior when integer arguments do not fit into | |
199 | * registers and must be placed on the stack. | |
200 | * OUT struct bit_flags_t *bit_flags -- structure to be filled | |
201 | * IN unsigned a -- 0 or 1 | |
202 | * IN unsigned b -- 0 or 1 | |
203 | * IN unsigned g -- 0 or 1 | |
204 | * IN unsigned d -- 0 or 1 | |
205 | * IN unsigned e -- 0 or 1 | |
206 | * IN unsigned o -- 0 or 1 | |
207 | *****************************************************************/ | |
085dd6e6 JM |
208 | void init_bit_flags ( |
209 | struct bit_flags_t *bit_flags, | |
210 | unsigned a, | |
211 | unsigned b, | |
212 | unsigned g, | |
213 | unsigned d, | |
214 | unsigned e, | |
215 | unsigned o) | |
c906108c SS |
216 | { |
217 | ||
218 | bit_flags->alpha = a; | |
219 | bit_flags->beta = b; | |
220 | bit_flags->gamma = g; | |
221 | bit_flags->delta = d; | |
222 | bit_flags->epsilon = e; | |
223 | bit_flags->omega = o; | |
224 | } | |
225 | ||
226 | /***************************************************************** | |
227 | * INIT_BIT_FLAGS_COMBO : | |
228 | * Initializes a bit_flags_combo_t structure. Can call this function | |
229 | * to see the call command behavior when integer and character arguments | |
230 | * do not fit into registers and must be placed on the stack. | |
231 | * OUT struct bit_flags_combo_t *bit_flags_combo -- structure to fill | |
232 | * IN unsigned a -- 0 or 1 | |
233 | * IN unsigned b -- 0 or 1 | |
234 | * IN char ch1 | |
235 | * IN unsigned g -- 0 or 1 | |
236 | * IN unsigned d -- 0 or 1 | |
237 | * IN char ch2 | |
238 | * IN unsigned e -- 0 or 1 | |
239 | * IN unsigned o -- 0 or 1 | |
240 | *****************************************************************/ | |
085dd6e6 JM |
241 | void init_bit_flags_combo ( |
242 | struct bit_flags_combo_t *bit_flags_combo, | |
243 | unsigned a, | |
244 | unsigned b, | |
245 | char ch1, | |
246 | unsigned g, | |
247 | unsigned d, | |
248 | char ch2, | |
249 | unsigned e, | |
250 | unsigned o) | |
c906108c SS |
251 | { |
252 | ||
253 | bit_flags_combo->alpha = a; | |
254 | bit_flags_combo->beta = b; | |
255 | bit_flags_combo->ch1 = ch1; | |
256 | bit_flags_combo->gamma = g; | |
257 | bit_flags_combo->delta = d; | |
258 | bit_flags_combo->ch2 = ch2; | |
259 | bit_flags_combo->epsilon = e; | |
260 | bit_flags_combo->omega = o; | |
261 | } | |
262 | ||
263 | ||
264 | /***************************************************************** | |
265 | * INIT_ONE_DOUBLE : | |
266 | * OUT struct one_double_t *one_double -- structure to fill | |
267 | * IN double init_val | |
268 | *****************************************************************/ | |
085dd6e6 | 269 | void init_one_double ( struct one_double_t *one_double, double init_val) |
c906108c SS |
270 | { |
271 | ||
272 | one_double->double1 = init_val; | |
273 | } | |
274 | ||
275 | /***************************************************************** | |
276 | * INIT_TWO_FLOATS : | |
277 | * OUT struct two_floats_t *two_floats -- structure to be filled | |
278 | * IN float init_val1 | |
279 | * IN float init_val2 | |
280 | *****************************************************************/ | |
085dd6e6 JM |
281 | void init_two_floats ( |
282 | struct two_floats_t *two_floats, | |
283 | float init_val1, | |
284 | float init_val2) | |
c906108c SS |
285 | { |
286 | ||
287 | two_floats->float1 = init_val1; | |
288 | two_floats->float2 = init_val2; | |
289 | } | |
290 | ||
291 | /***************************************************************** | |
292 | * INIT_THREE_CHARS : | |
293 | * OUT struct three_char_t *three_char -- structure to be filled | |
294 | * IN char init_val1 | |
295 | * IN char init_val2 | |
296 | * IN char init_val3 | |
297 | *****************************************************************/ | |
085dd6e6 JM |
298 | void init_three_chars ( |
299 | struct three_char_t *three_char, | |
300 | char init_val1, | |
301 | char init_val2, | |
302 | char init_val3) | |
c906108c SS |
303 | { |
304 | ||
305 | three_char->ch1 = init_val1; | |
306 | three_char->ch2 = init_val2; | |
307 | three_char->ch3 = init_val3; | |
308 | } | |
309 | ||
310 | /***************************************************************** | |
311 | * INIT_FIVE_CHARS : | |
312 | * OUT struct five_char_t *five_char -- structure to be filled | |
313 | * IN char init_val1 | |
314 | * IN char init_val2 | |
315 | * IN char init_val3 | |
316 | * IN char init_val4 | |
317 | * IN char init_val5 | |
318 | *****************************************************************/ | |
085dd6e6 JM |
319 | void init_five_chars ( |
320 | struct five_char_t *five_char, | |
321 | char init_val1, | |
322 | char init_val2, | |
323 | char init_val3, | |
324 | char init_val4, | |
325 | char init_val5) | |
c906108c SS |
326 | { |
327 | ||
328 | five_char->ch1 = init_val1; | |
329 | five_char->ch2 = init_val2; | |
330 | five_char->ch3 = init_val3; | |
331 | five_char->ch4 = init_val4; | |
332 | five_char->ch5 = init_val5; | |
333 | } | |
334 | ||
335 | /***************************************************************** | |
336 | * INIT_INT_CHAR_COMBO : | |
337 | * OUT struct int_char_combo_t *combo -- structure to be filled | |
338 | * IN int init_val1 | |
339 | * IN char init_val2 | |
340 | *****************************************************************/ | |
085dd6e6 JM |
341 | void init_int_char_combo ( |
342 | struct int_char_combo_t *combo, | |
343 | int init_val1, | |
344 | char init_val2) | |
c906108c SS |
345 | { |
346 | ||
347 | combo->int1 = init_val1; | |
348 | combo->ch1 = init_val2; | |
349 | } | |
350 | ||
351 | /***************************************************************** | |
352 | * INIT_STRUCT_REP : | |
353 | * OUT struct small_rep_into_t *small_struct -- structure to be filled | |
354 | * IN int seed | |
355 | *****************************************************************/ | |
085dd6e6 JM |
356 | void init_struct_rep( |
357 | struct small_rep_info_t *small_struct, | |
358 | int seed) | |
c906108c SS |
359 | { |
360 | ||
361 | small_struct->value = 2 + (seed*2); | |
362 | small_struct->head = 0; | |
363 | } | |
364 | ||
618ec112 CV |
365 | /***************************************************************** |
366 | * PRINT_BIT_FLAGS_CHAR : | |
367 | * IN struct bit_flags_char_t bit_flags | |
368 | ****************************************************************/ | |
618ec112 | 369 | struct bit_flags_char_t print_bit_flags_char (struct bit_flags_char_t bit_flags) |
618ec112 CV |
370 | { |
371 | ||
372 | if (bit_flags.alpha) printf("alpha\n"); | |
373 | if (bit_flags.beta) printf("beta\n"); | |
374 | if (bit_flags.gamma) printf("gamma\n"); | |
375 | if (bit_flags.delta) printf("delta\n"); | |
376 | if (bit_flags.epsilon) printf("epsilon\n"); | |
377 | if (bit_flags.omega) printf("omega\n"); | |
378 | return bit_flags; | |
379 | ||
380 | } | |
381 | ||
382 | /***************************************************************** | |
383 | * PRINT_BIT_FLAGS_SHORT : | |
384 | * IN struct bit_flags_short_t bit_flags | |
385 | ****************************************************************/ | |
618ec112 | 386 | struct bit_flags_short_t print_bit_flags_short (struct bit_flags_short_t bit_flags) |
618ec112 CV |
387 | { |
388 | ||
389 | if (bit_flags.alpha) printf("alpha\n"); | |
390 | if (bit_flags.beta) printf("beta\n"); | |
391 | if (bit_flags.gamma) printf("gamma\n"); | |
392 | if (bit_flags.delta) printf("delta\n"); | |
393 | if (bit_flags.epsilon) printf("epsilon\n"); | |
394 | if (bit_flags.omega) printf("omega\n"); | |
395 | return bit_flags; | |
396 | ||
397 | } | |
398 | ||
c906108c SS |
399 | /***************************************************************** |
400 | * PRINT_BIT_FLAGS : | |
401 | * IN struct bit_flags_t bit_flags | |
402 | ****************************************************************/ | |
085dd6e6 | 403 | struct bit_flags_t print_bit_flags (struct bit_flags_t bit_flags) |
c906108c SS |
404 | { |
405 | ||
406 | if (bit_flags.alpha) printf("alpha\n"); | |
407 | if (bit_flags.beta) printf("beta\n"); | |
408 | if (bit_flags.gamma) printf("gamma\n"); | |
409 | if (bit_flags.delta) printf("delta\n"); | |
410 | if (bit_flags.epsilon) printf("epsilon\n"); | |
411 | if (bit_flags.omega) printf("omega\n"); | |
412 | return bit_flags; | |
413 | ||
414 | } | |
415 | ||
416 | /***************************************************************** | |
417 | * PRINT_BIT_FLAGS_COMBO : | |
418 | * IN struct bit_flags_combo_t bit_flags_combo | |
419 | ****************************************************************/ | |
085dd6e6 | 420 | struct bit_flags_combo_t print_bit_flags_combo (struct bit_flags_combo_t bit_flags_combo) |
c906108c SS |
421 | { |
422 | ||
423 | if (bit_flags_combo.alpha) printf("alpha\n"); | |
424 | if (bit_flags_combo.beta) printf("beta\n"); | |
425 | if (bit_flags_combo.gamma) printf("gamma\n"); | |
426 | if (bit_flags_combo.delta) printf("delta\n"); | |
427 | if (bit_flags_combo.epsilon) printf("epsilon\n"); | |
428 | if (bit_flags_combo.omega) printf("omega\n"); | |
429 | printf("ch1: %c\tch2: %c\n", bit_flags_combo.ch1, bit_flags_combo.ch2); | |
430 | return bit_flags_combo; | |
431 | ||
432 | } | |
433 | ||
434 | /***************************************************************** | |
435 | * PRINT_ONE_DOUBLE : | |
436 | * IN struct one_double_t one_double | |
437 | ****************************************************************/ | |
085dd6e6 | 438 | struct one_double_t print_one_double (struct one_double_t one_double) |
c906108c SS |
439 | { |
440 | ||
441 | printf("Contents of one_double_t: \n\n"); | |
442 | printf("%f\n", one_double.double1); | |
443 | return one_double; | |
444 | ||
445 | } | |
446 | ||
447 | /***************************************************************** | |
448 | * PRINT_TWO_FLOATS : | |
449 | * IN struct two_floats_t two_floats | |
450 | ****************************************************************/ | |
085dd6e6 | 451 | struct two_floats_t print_two_floats (struct two_floats_t two_floats) |
c906108c SS |
452 | { |
453 | ||
454 | printf("Contents of two_floats_t: \n\n"); | |
455 | printf("%f\t%f\n", two_floats.float1, two_floats.float2); | |
456 | return two_floats; | |
457 | ||
458 | } | |
459 | ||
460 | /***************************************************************** | |
461 | * PRINT_THREE_CHARS : | |
462 | * IN struct three_char_t three_char | |
463 | ****************************************************************/ | |
085dd6e6 | 464 | struct three_char_t print_three_chars (struct three_char_t three_char) |
c906108c SS |
465 | { |
466 | ||
467 | printf("Contents of three_char_t: \n\n"); | |
468 | printf("%c\t%c\t%c\n", three_char.ch1, three_char.ch2, three_char.ch3); | |
469 | return three_char; | |
470 | ||
471 | } | |
472 | ||
473 | /***************************************************************** | |
474 | * PRINT_FIVE_CHARS : | |
475 | * IN struct five_char_t five_char | |
476 | ****************************************************************/ | |
085dd6e6 | 477 | struct five_char_t print_five_chars (struct five_char_t five_char) |
c906108c SS |
478 | { |
479 | ||
480 | printf("Contents of five_char_t: \n\n"); | |
481 | printf("%c\t%c\t%c\t%c\t%c\n", five_char.ch1, five_char.ch2, | |
482 | five_char.ch3, five_char.ch4, | |
483 | five_char.ch5); | |
484 | return five_char; | |
485 | ||
486 | } | |
487 | ||
488 | /***************************************************************** | |
489 | * PRINT_INT_CHAR_COMBO : | |
490 | * IN struct int_char_combo_t int_char_combo | |
491 | ****************************************************************/ | |
085dd6e6 | 492 | struct int_char_combo_t print_int_char_combo (struct int_char_combo_t int_char_combo) |
c906108c SS |
493 | { |
494 | ||
495 | printf("Contents of int_char_combo_t: \n\n"); | |
496 | printf("%d\t%c\n", int_char_combo.int1, int_char_combo.ch1); | |
497 | return int_char_combo; | |
498 | ||
499 | } | |
500 | ||
501 | /***************************************************************** | |
502 | * PRINT_STRUCT_REP : | |
503 | ****************************************************************/ | |
085dd6e6 | 504 | struct small_rep_info_t print_struct_rep(struct small_rep_info_t struct1) |
c906108c SS |
505 | { |
506 | ||
507 | printf("Contents of struct1: \n\n"); | |
508 | printf("%10d%10d\n", struct1.value, struct1.head); | |
509 | struct1.value =+5; | |
510 | ||
511 | return struct1; | |
512 | ||
513 | ||
514 | } | |
515 | ||
516 | ||
085dd6e6 | 517 | struct array_rep_info_t print_one_large_struct(struct array_rep_info_t linked_list1) |
c906108c SS |
518 | { |
519 | ||
520 | ||
521 | printf("%10d%10d\n", linked_list1.values[0], | |
522 | linked_list1.next_index[0]); | |
523 | ||
524 | return linked_list1; | |
525 | ||
526 | } | |
527 | ||
528 | /***************************************************************** | |
529 | * INIT_ARRAY_REP : | |
530 | * IN struct array_rep_info_t *linked_list | |
531 | * IN int seed | |
532 | ****************************************************************/ | |
085dd6e6 | 533 | void init_array_rep(struct array_rep_info_t *linked_list, int seed) |
c906108c SS |
534 | { |
535 | ||
536 | int index; | |
537 | ||
538 | for (index = 0; index < 10; index++) { | |
539 | ||
540 | linked_list->values[index] = (2*index) + (seed*2); | |
541 | linked_list->next_index[index] = index + 1; | |
542 | } | |
543 | linked_list->head = 0; | |
544 | } | |
545 | ||
546 | ||
547 | int main () { | |
548 | ||
549 | /* variables for large structure testing | |
550 | */ | |
551 | int number = 10; | |
552 | struct array_rep_info_t *list1; | |
553 | ||
554 | /* variables for testing a small structures and a very long argument list | |
555 | */ | |
556 | struct small_rep_info_t *struct1; | |
618ec112 CV |
557 | struct bit_flags_char_t *cflags; |
558 | struct bit_flags_short_t *sflags; | |
c906108c SS |
559 | struct bit_flags_t *flags; |
560 | struct bit_flags_combo_t *flags_combo; | |
561 | struct three_char_t *three_char; | |
562 | struct five_char_t *five_char; | |
563 | struct int_char_combo_t *int_char_combo; | |
564 | struct one_double_t *d1; | |
565 | struct two_floats_t *f3; | |
566 | ||
dedad4e3 | 567 | gdb_unbuffer_output (); |
c906108c SS |
568 | |
569 | /* Allocate space for large structures | |
570 | */ | |
571 | list1 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t)); | |
572 | ||
573 | /* Initialize large structures | |
574 | */ | |
575 | init_array_rep(list1, 2); | |
576 | ||
577 | /* Print large structures | |
578 | */ | |
579 | print_one_large_struct(*list1); | |
580 | ||
581 | /* Allocate space for small structures | |
582 | */ | |
583 | struct1 = (struct small_rep_info_t *)malloc(sizeof(struct small_rep_info_t)); | |
618ec112 CV |
584 | cflags = (struct bit_flags_char_t *)malloc(sizeof(struct bit_flags_char_t)); |
585 | sflags = (struct bit_flags_short_t *)malloc(sizeof(struct bit_flags_short_t)); | |
c906108c SS |
586 | flags = (struct bit_flags_t *)malloc(sizeof(struct bit_flags_t)); |
587 | flags_combo = (struct bit_flags_combo_t *)malloc(sizeof(struct bit_flags_combo_t)); | |
588 | three_char = (struct three_char_t *)malloc(sizeof(struct three_char_t)); | |
589 | five_char = (struct five_char_t *)malloc(sizeof(struct five_char_t)); | |
590 | int_char_combo = (struct int_char_combo_t *)malloc(sizeof(struct int_char_combo_t)); | |
591 | ||
592 | d1 = (struct one_double_t *)malloc(sizeof(struct one_double_t)); | |
593 | f3 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t)); | |
594 | ||
595 | /* Initialize small structures | |
596 | */ | |
597 | init_one_double ( d1, 1.11111); | |
598 | init_two_floats ( f3, -2.345, 1.0); | |
618ec112 CV |
599 | init_bit_flags_char(cflags, (unsigned)1, (unsigned)0, (unsigned)1, |
600 | (unsigned)0, (unsigned)1, (unsigned)0 ); | |
601 | init_bit_flags_short(sflags, (unsigned)1, (unsigned)0, (unsigned)1, | |
602 | (unsigned)0, (unsigned)1, (unsigned)0 ); | |
c906108c SS |
603 | init_bit_flags(flags, (unsigned)1, (unsigned)0, (unsigned)1, |
604 | (unsigned)0, (unsigned)1, (unsigned)0 ); | |
605 | init_bit_flags_combo(flags_combo, (unsigned)1, (unsigned)0, 'y', | |
606 | (unsigned)1, (unsigned)0, 'n', | |
607 | (unsigned)1, (unsigned)0 ); | |
608 | init_three_chars(three_char, 'x', 'y', 'z'); | |
609 | init_five_chars(five_char, 'h', 'e', 'l', 'l', 'o'); | |
610 | init_int_char_combo(int_char_combo, 13, '!'); | |
611 | init_struct_rep(struct1, 10); | |
612 | ||
613 | ||
614 | /* Print small structures | |
615 | */ | |
616 | print_one_double(*d1); | |
617 | print_two_floats(*f3); | |
618ec112 CV |
618 | print_bit_flags_char(*cflags); |
619 | print_bit_flags_short(*sflags); | |
c906108c SS |
620 | print_bit_flags(*flags); |
621 | print_bit_flags_combo(*flags_combo); | |
622 | print_three_chars(*three_char); | |
623 | print_five_chars(*five_char); | |
624 | print_int_char_combo(*int_char_combo); | |
625 | print_struct_rep(*struct1); | |
626 | ||
dbfdb174 | 627 | loop_count(); /* -finish2- */ |
c906108c | 628 | |
dbfdb174 | 629 | return 0; /* -finish1- */ |
c906108c SS |
630 | } |
631 | ||
632 | ||
633 | ||
634 | ||
635 | ||
636 | ||
637 | ||
638 | ||
639 | ||
640 | ||
641 | ||
642 | ||
643 | ||
644 | ||
645 |