gdb/testsuite/gdb.base/call-ar-st.c

   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