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