home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / CLISP / CLISPSRC.TAR / clisp-1995-01-01 / src / machine.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-16  |  35.5 KB  |  560 lines
  1. #line 1 "machine.d"
  2. /* Bestimmung einiger Maschinen-Parameter und -AbhΣngigkeiten */
  3. /* und Ausgabe in ein Include-File */
  4. /* Bruno Haible 10.9.1991, 12.10.1992, 6.12.1992, 24.10.1993 */
  5.  
  6. #define _POSIX_SOURCE
  7. #include <stdio.h>
  8.  
  9. #define loop  while(1)
  10.  
  11. typedef int boolean;
  12. #define TRUE  1
  13. #define FALSE 0
  14.  
  15. #ifdef __CHAR_UNSIGNED__
  16. typedef signed char  schar;
  17. #else
  18. typedef char  schar;
  19. #endif
  20. typedef unsigned char  uchar;
  21. typedef unsigned short  ushort;
  22. typedef unsigned /* int */  uint;
  23. typedef unsigned long  ulong;
  24. #ifdef HAVE_LONGLONG
  25. typedef long long  longlong;
  26. typedef unsigned long long  ulonglong;
  27. #endif
  28. typedef int (function)();
  29.  
  30. static int random_table[256] = /* 2048 zufΣllige Bits, hier von pi */
  31.   { 0xC9,0x0F,0xDA,0xA2,0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,
  32.     0x80,0xDC,0x1C,0xD1,0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,
  33.     0x02,0x0B,0xBE,0xA6,0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,
  34.     0x8E,0x34,0x04,0xDD,0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,
  35.     0x30,0x2B,0x0A,0x6D,0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,
  36.     0x6D,0x51,0xC2,0x45,0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,
  37.     0xF4,0x4C,0x42,0xE9,0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,
  38.     0xF4,0x06,0xB7,0xED,0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,
  39.     0xAE,0x9F,0x24,0x11,0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,
  40.     0xEC,0xE4,0x5B,0x3D,0xC2,0x00,0x7C,0xB8,0xA1,0x63,0xBF,0x05,
  41.     0x98,0xDA,0x48,0x36,0x1C,0x55,0xD3,0x9A,0x69,0x16,0x3F,0xA8,
  42.     0xFD,0x24,0xCF,0x5F,0x83,0x65,0x5D,0x23,0xDC,0xA3,0xAD,0x96,
  43.     0x1C,0x62,0xF3,0x56,0x20,0x85,0x52,0xBB,0x9E,0xD5,0x29,0x07,
  44.     0x70,0x96,0x96,0x6D,0x67,0x0C,0x35,0x4E,0x4A,0xBC,0x98,0x04,
  45.     0xF1,0x74,0x6C,0x08,0xCA,0x18,0x21,0x7C,0x32,0x90,0x5E,0x46,
  46.     0x2E,0x36,0xCE,0x3B,0xE3,0x9E,0x77,0x2C,0x18,0x0E,0x86,0x03,
  47.     0x9B,0x27,0x83,0xA2,0xEC,0x07,0xA2,0x8F,0xB5,0xC5,0x5D,0xF0,
  48.     0x6F,0x4C,0x52,0xC9,0xDE,0x2B,0xCB,0xF6,0x95,0x58,0x17,0x18,
  49.     0x39,0x95,0x49,0x7C,0xEA,0x95,0x6A,0xE5,0x15,0xD2,0x26,0x18,
  50.     0x98,0xFA,0x05,0x10,0x15,0x72,0x8E,0x5A,0x8A,0xAA,0xC4,0x2D,
  51.     0xAD,0x33,0x17,0x0D,0x04,0x50,0x7A,0x33,0xA8,0x55,0x21,0xAB,
  52.     0xDF,0x1C,0xBA,0x65,
  53.   };
  54. #define random_table_length  (8*256)
  55. static int random_position = -1;
  56. int next_random_bit()
  57.   { random_position++;
  58.     if (random_position==random_table_length) random_position = 0;
  59.     return (random_table[random_position/8] >> (random_position % 8)) & 1;
  60.   }
  61.  
  62. #ifdef __STDC__
  63. printf_underscored (char* string)
  64. #else
  65. printf_underscored(string)
  66.   char* string;
  67. #endif
  68.   { char c;
  69.     while (!((c = *string++) == '\0')) { printf("%c",(c==' ' ? '_' : c)); }
  70.   }
  71.  
  72. /* string_length(string) is the same as strlen(string). */
  73. /* Better avoid to depend on <string.h>. */
  74. #ifdef __STDC__
  75. int string_length (char* string)
  76. #else
  77. int string_length(string)
  78.   char* string;
  79. #endif
  80.   { int count = 0;
  81.     while (!(*string++ == '\0')) { count++; }
  82.     return count;
  83.   }
  84.  
  85. static int char_bitsize, short_bitsize, int_bitsize, long_bitsize;
  86. static int uchar_bitsize, ushort_bitsize, uint_bitsize, ulong_bitsize;
  87. static boolean char_uchar_same, short_ushort_same, int_uint_same, long_ulong_same;
  88. static int pointer_bitsize;
  89. #ifdef HAVE_LONGLONG
  90. static int longlong_bitsize, ulonglong_bitsize;
  91. static boolean longlong_ulonglong_same;
  92. #endif
  93.  
  94. main1() {
  95. #define get_integer_bitsize(type,where)  \
  96.   { type x = 1;                                 \
  97.     int bits = 0;                               \
  98.     loop                                        \
  99.       { if (x==0) break;                        \
  100.         x = x+x;                                \
  101.         bits++;                                 \
  102.         if (bits==1000) { bits = -1; break; }   \
  103.       }                                         \
  104.     where = bits;                               \
  105.   }
  106. #define print_integer_bitsize(type,typestr,where)  \
  107.   { if (where >= 0)                                                  \
  108.       { printf("/* Integers of t%spe %s have %ld bits. */\n","y",typestr,(long)where); \
  109.         if (!(typestr[0] == 'u'))                                    \
  110.           { printf("#define "); printf_underscored(typestr); printf("_bitsize %ld\n",(long)where); } \
  111.         printf("\n");                                                \
  112.       }                                                              \
  113.       else                                                           \
  114.       { printf("#error \"Integers of t%spe %s have no binary representation!!\"\n","y",typestr); } \
  115.     if (!(where == char_bitsize * sizeof(type)))                     \
  116.       { printf("#error \"Formula BITSIZE(T) = SIZEOF(T) * BITSPERBYTE does not hold for t%spe %s!!\"\n","y",typestr); } \
  117.   }
  118.   get_integer_bitsize(schar,char_bitsize);
  119.   get_integer_bitsize(short,short_bitsize);
  120.   get_integer_bitsize(int,int_bitsize);
  121.   get_integer_bitsize(long,long_bitsize);
  122.   print_integer_bitsize(schar,"char",char_bitsize);
  123.   print_integer_bitsize(short,"short",short_bitsize);
  124.   print_integer_bitsize(int,"int",int_bitsize);
  125.   print_integer_bitsize(long,"long",long_bitsize);
  126. #ifdef HAVE_LONGLONG
  127.   get_integer_bitsize(longlong,longlong_bitsize);
  128.   print_integer_bitsize(longlong,"long long",longlong_bitsize);
  129. #endif
  130.   get_integer_bitsize(uchar,uchar_bitsize);
  131.   get_integer_bitsize(ushort,ushort_bitsize);
  132.   get_integer_bitsize(uint,uint_bitsize);
  133.   get_integer_bitsize(ulong,ulong_bitsize);
  134.   print_integer_bitsize(uchar,"unsigned char",uchar_bitsize);
  135.   print_integer_bitsize(ushort,"unsigned short",ushort_bitsize);
  136.   print_integer_bitsize(uint,"unsigned int",uint_bitsize);
  137.   print_integer_bitsize(ulong,"unsigned long",ulong_bitsize);
  138. #ifdef HAVE_LONGLONG
  139.   get_integer_bitsize(ulonglong,ulonglong_bitsize);
  140.   print_integer_bitsize(ulonglong,"unsigned long long",ulonglong_bitsize);
  141. #endif
  142. }
  143.  
  144. main2() {
  145. #define compare_integer_bitsizes(typestr1,typestr2,type1_bitsize,type2_bitsize)  \
  146.   { if (!(type1_bitsize==type2_bitsize))                                                       \
  147.       printf("#error \"Integer types %s and %s have different sizes!!\"\n",typestr1,typestr2); \
  148.   }
  149.   compare_integer_bitsizes("char","unsigned char",char_bitsize,uchar_bitsize);
  150.   compare_integer_bitsizes("short","unsigned short",short_bitsize,ushort_bitsize);
  151.   compare_integer_bitsizes("int","unsigned int",int_bitsize,uint_bitsize);
  152.   compare_integer_bitsizes("long","unsigned long",long_bitsize,ulong_bitsize);
  153. #ifdef HAVE_LONGLONG
  154.   compare_integer_bitsizes("long long","unsigned long long",longlong_bitsize,ulonglong_bitsize);
  155. #endif
  156. }
  157.  
  158. #define get_a_random(type,bitsize,where)  \
  159.   { type x = 0;                                          \
  160.     int i = bitsize;                                     \
  161.     while (i>0) { x = (x<<1) + next_random_bit(); i--; } \
  162.     where = x;                                           \
  163.   }
  164. #define get_a_random_twice(type1,type2,bitsize,where1,where2)  \
  165.   { type1 x1 = 0; type2 x2 = 0;                 \
  166.     int i = bitsize;                            \
  167.     while (i>0)                                 \
  168.       { type1 b = next_random_bit();            \
  169.         x1 = ((x1<<1) + b); x2 = ((x2<<1) + b); \
  170.         i--;                                    \
  171.       }                                         \
  172.     where1 = x1; where2 = x2;                   \
  173.   }
  174.  
  175. main3() {
  176. #define compare_integer_representation(type1,type2,typestr1,typestr2,type1_bitsize,type2_bitsize,where)  \
  177.   { if ((type1_bitsize>=0) && (type2_bitsize>=0) && (type1_bitsize==type2_bitsize))           \
  178.       { int i,j;                                                                              \
  179.         type1 sample1; type2 sample2;                                                         \
  180.         where = TRUE;                                                                         \
  181.         for (i = 0; i<100; i++)                                                               \
  182.           { get_a_random_twice(type1,type2,type1_bitsize,sample1,sample2);                    \
  183.             if (!(sample1 == (type1)(sample2))) { where = FALSE; }                            \
  184.             if (!(sample2 == (type2)(sample1))) { where = FALSE; }                            \
  185.           }                                                                                   \
  186.         for (i = 0; i<100; i++)                                                               \
  187.           { get_a_random(type1,type1_bitsize,sample1);                                        \
  188.             sample2 = (type2)(sample1);                                                       \
  189.             for (j = 0; j < type1_bitsize; j++)                                               \
  190.               if (!( ((sample1 & ((type1)1<<j)) == 0)                                         \
  191.                      == ((sample2 & ((type2)1<<j)) == 0)                                      \
  192.                  ) )                                                                          \
  193.                 { where = FALSE; }                                                            \
  194.           }                                                                                   \
  195.         if (where)                                                                            \
  196.           { printf("/* Integer types %s and %s have the same binary representation. */\n",typestr1,typestr2); } \
  197.           else                                                                                \
  198.           { printf("#error \"Integer types %s and %s have different binary representations!!\"\n",typestr1,typestr2); } \
  199.       }                                                                                       \
  200.       else                                                                                    \
  201.       { where = FALSE; }                                                                      \
  202.   }
  203.   compare_integer_representation(schar,uchar,"char","unsigned char",char_bitsize,uchar_bitsize,char_uchar_same);
  204.   compare_integer_representation(short,ushort,"short","unsigned short",short_bitsize,ushort_bitsize,short_ushort_same);
  205.   compare_integer_representation(int,uint,"int","unsigned int",int_bitsize,uint_bitsize,int_uint_same);
  206.   compare_integer_representation(long,ulong,"long","unsigned long",long_bitsize,ulong_bitsize,long_ulong_same);
  207. #ifdef HAVE_LONGLONG
  208.   compare_integer_representation(longlong,ulonglong,"long long","unsigned long long",longlong_bitsize,ulonglong_bitsize,longlong_ulonglong_same);
  209. #endif
  210.   printf("\n");
  211. }
  212.  
  213. main4() {
  214. #define test_integer_ushift(type,typestr,type_bitsize)  \
  215.   if (type_bitsize >= 0)                                                                        \
  216.     { int i,j,shc;                                                                              \
  217.       type sample1,sample2;                                                                     \
  218.       boolean left_works = TRUE, right_works = TRUE;                                            \
  219.       for (i = 0; i<100; i++)                                                                   \
  220.         { get_a_random(type,type_bitsize,sample1);                                              \
  221.           for (shc = 0; shc < type_bitsize; shc++)                                              \
  222.             { sample2 = sample1 << shc;                                                         \
  223.               for (j=0; j < type_bitsize; j++)                                                  \
  224.                 { if (!( ((sample2 & ((type)1<<j)) == 0)                                        \
  225.                          ==                                                                     \
  226.                          (j < shc ? TRUE : ((sample1 & ((type)1<<(j-shc))) == 0))               \
  227.                      ) )                                                                        \
  228.                     { left_works = FALSE; }                                                     \
  229.         }   }   }                                                                               \
  230.       for (i = 0; i<100; i++)                                                                   \
  231.         { get_a_random(type,type_bitsize,sample1);                                              \
  232.           for (shc = 0; shc < type_bitsize; shc++)                                              \
  233.             { sample2 = sample1 >> shc;                                                         \
  234.               for (j=0; j < type_bitsize; j++)                                                  \
  235.                 { if (!( ((sample2 & ((type)1<<j)) == 0)                                        \
  236.                          ==                                                                     \
  237.                          (j >= type_bitsize-shc ? TRUE : ((sample1 & ((type)1<<(j+shc))) == 0)) \
  238.                      ) )                                                                        \
  239.                     { right_works = FALSE; }                                                    \
  240.         }   }   }                                                                               \
  241.       if (!left_works)                                                                          \
  242.         { printf("#error \"Left shift of integers of t%spe %s does not work!!\"\n","y",typestr); } \
  243.       if (!right_works)                                                                         \
  244.         { printf("#error \"Right shift of integers of t%spe %s does not work!!\"\n","y",typestr); } \
  245.     }
  246. #define test_integer_sshift(type,typestr,type_bitsize)  \
  247.   if (type_bitsize >= 0)                                                                       \
  248.     { int i,j,shc;                                                                             \
  249.       type sample1,sample2;                                                                    \
  250.       boolean left_works = TRUE, right_works = TRUE;                                           \
  251.       for (i = 0; i<100; i++)                                                                  \
  252.         { get_a_random(type,type_bitsize,sample1);                                             \
  253.           for (shc = 0; shc < type_bitsize; shc++)                                             \
  254.             { sample2 = sample1 << shc;                                                        \
  255.               for (j=0; j < type_bitsize; j++)                                                 \
  256.                 { if (!( ((sample2 & ((type)1<<j)) == 0)                                       \
  257.                          ==                                                                    \
  258.                          (j < shc ? TRUE : ((sample1 & ((type)1<<(j-shc))) == 0))              \
  259.                      ) )                                                                       \
  260.                     { left_works = FALSE; }                                                    \
  261.         }   }   }                                                                              \
  262.       for (i = 0; i<100; i++)                                                                  \
  263.         { get_a_random(type,type_bitsize,sample1);                                             \
  264.           for (shc = 0; shc < type_bitsize; shc++)                                             \
  265.             { sample2 = sample1 >> shc;                                                        \
  266.               for (j=0; j < type_bitsize; j++)                                                 \
  267.                 { if (!( ((sample2 & ((type)1<<j)) == 0)                                       \
  268.                          ==                                                                    \
  269.                          ((sample1 & ((type)1<< (j+shc>=type_bitsize ? type_bitsize-1 : j+shc))) == 0) \
  270.                      ) )                                                                       \
  271.                     { right_works = FALSE; }                                                   \
  272.         }   }   }                                                                              \
  273.       if (!left_works)                                                                         \
  274.         { printf("#error \"Left shift of integers of t%spe %s does not work!!\"\n","y",typestr); } \
  275.       if (!right_works)                                                                        \
  276.         { printf("#error \"Right shift of integers of t%spe %s does not work!!\"\n","y",typestr); } \
  277.     }
  278.   test_integer_ushift(uchar,"unsigned char",uchar_bitsize);
  279.   test_integer_ushift(ushort,"unsigned short",ushort_bitsize);
  280.   test_integer_ushift(uint,"unsigned int",uint_bitsize);
  281.   test_integer_ushift(ulong,"unsigned long",ulong_bitsize);
  282. #ifdef HAVE_LONGLONG
  283.   test_integer_ushift(ulonglong,"unsigned long long",ulonglong_bitsize);
  284. #endif
  285.   test_integer_sshift(schar,"char",char_bitsize);
  286.   test_integer_sshift(short,"short",short_bitsize);
  287.   test_integer_sshift(int,"int",int_bitsize);
  288.   test_integer_sshift(long,"long",long_bitsize);
  289. #ifdef HAVE_LONGLONG
  290.   test_integer_sshift(longlong,"long long",longlong_bitsize);
  291. #endif
  292. }
  293.  
  294. main5() {
  295. #define test_integer_casts(type1,type2,typestr1,typestr2,type1_bitsize,type2_bitsize,want)  \
  296.   if (type1_bitsize <= type2_bitsize)                                                                      \
  297.     { int i,j;                                                                                             \
  298.       boolean modifies = FALSE;                                                                            \
  299.       boolean zero_extends = TRUE;                                                                         \
  300.       boolean sign_extends = TRUE;                                                                         \
  301.       for (i = 0; i<100; i++)                                                                              \
  302.         { type1 sample1;                                                                                   \
  303.           type2 sample2;                                                                                   \
  304.           get_a_random(type1,type1_bitsize,sample1);                                                       \
  305.           sample2 = (type2)sample1;                                                                        \
  306.           if (!(sample1 == (type1)sample2)) { modifies = TRUE; }                                           \
  307.           for (j = 0; j<type1_bitsize; j++)                                                                \
  308.             if (!( ((sample1 & ((type1)1<<j)) == 0) == ((sample2 & ((type2)1<<j)) == 0) ))                 \
  309.               { zero_extends = FALSE; sign_extends = FALSE; }                                              \
  310.           for (j = type1_bitsize; j<type2_bitsize; j++)                                                    \
  311.             if (!((sample2 & ((type2)1<<j)) == 0))                                                         \
  312.               { zero_extends = FALSE; }                                                                    \
  313.           for (j = type1_bitsize; j<type2_bitsize; j++)                                                    \
  314.             if (!( ((sample1 & ((type1)1<<(type1_bitsize-1))) == 0) == ((sample2 & ((type2)1<<j)) == 0) )) \
  315.               { sign_extends = FALSE; }                                                                    \
  316.         }                                                                                                  \
  317.       if (modifies)                                                                                        \
  318.         printf("#error \"Casts: (%s)(%s)(x) == x does not hold for every %s x !!\"\n",typestr1,typestr2,typestr1); \
  319.       if (zero_extends && sign_extends)                                                                    \
  320.         { if (!(type1_bitsize == type2_bitsize))                                                           \
  321.             printf("#error \"Casts from %s to %s works by identity!!\"\n",typestr1,typestr2);              \
  322.         }                                                                                                  \
  323.       if (zero_extends && !sign_extends)                                                                   \
  324.         { if ((type1_bitsize == type2_bitsize) || !(typestr1[0] == 'u') || !(want==1))                     \
  325.             printf("#error \"Casts from %s to %s works by zero-extend!!\"\n",typestr1,typestr2);           \
  326.         }                                                                                                  \
  327.       if (sign_extends && !zero_extends)                                                                   \
  328.         { if ((type1_bitsize == type2_bitsize) || (typestr1[0] == 'u') || !(want==2))                      \
  329.             printf("#error \"Casts from %s to %s works by sign-extend!!\"\n",typestr1,typestr2);           \
  330.         }                                                                                                  \
  331.       if (!sign_extends && !zero_extends)                                                                  \
  332.         printf("#error \"Casts from %s to %s works in an unknown manner!!\"\n",typestr1,typestr2);         \
  333.     }
  334.   /* erst Casts zwischen Integers vermutlich gleicher Gr÷▀e: */
  335.   test_integer_casts(schar,uchar,"char","unsigned char",char_bitsize,uchar_bitsize,0);
  336.   test_integer_casts(short,ushort,"short","unsigned short",short_bitsize,ushort_bitsize,0);
  337.   test_integer_casts(int,uint,"int","unsigned int",int_bitsize,uint_bitsize,0);
  338.   test_integer_casts(long,ulong,"long","unsigned long",long_bitsize,ulong_bitsize,0);
  339.   test_integer_casts(uchar,schar,"unsigned char","char",uchar_bitsize,char_bitsize,0);
  340.   test_integer_casts(ushort,short,"unsigned short","short",ushort_bitsize,short_bitsize,0);
  341.   test_integer_casts(uint,int,"unsigned int","int",uint_bitsize,int_bitsize,0);
  342.   test_integer_casts(ulong,long,"unsigned long","long",ulong_bitsize,long_bitsize,0);
  343. #ifdef HAVE_LONGLONG
  344.   test_integer_casts(longlong,ulonglong,"long long","unsigned long long",longlong_bitsize,ulonglong_bitsize,0);
  345.   test_integer_casts(ulonglong,longlong,"unsigned long long","long long",ulonglong_bitsize,longlong_bitsize,0);
  346. #endif
  347.   /* dann Casts zwischen Integers unterschiedlicher Gr÷▀e, aber gleichen Vorzeichens: */
  348.   test_integer_casts(uchar,ushort,"unsigned char","unsigned short",uchar_bitsize,ushort_bitsize,1);
  349.   test_integer_casts(uchar,uint,"unsigned char","unsigned int",uchar_bitsize,uint_bitsize,1);
  350.   test_integer_casts(uchar,ulong,"unsigned char","unsigned long",uchar_bitsize,ulong_bitsize,1);
  351.   test_integer_casts(ushort,uint,"unsigned short","unsigned int",ushort_bitsize,uint_bitsize,1);
  352.   test_integer_casts(ushort,ulong,"unsigned short","unsigned long",ushort_bitsize,ulong_bitsize,1);
  353.   test_integer_casts(uint,ulong,"unsigned int","unsigned long",uint_bitsize,ulong_bitsize,1);
  354. #ifdef HAVE_LONGLONG
  355.   test_integer_casts(uchar,ulonglong,"unsigned char","unsigned long long",uchar_bitsize,ulonglong_bitsize,1);
  356.   test_integer_casts(ushort,ulonglong,"unsigned short","unsigned long long",ushort_bitsize,ulonglong_bitsize,1);
  357.   test_integer_casts(uint,ulonglong,"unsigned int","unsigned long long",uint_bitsize,ulonglong_bitsize,1);
  358.   test_integer_casts(ulong,ulonglong,"unsigned long","unsigned long long",ulong_bitsize,ulonglong_bitsize,1);
  359. #endif
  360.   test_integer_casts(schar,short,"char","short",char_bitsize,short_bitsize,2);
  361.   test_integer_casts(schar,int,"char","int",char_bitsize,int_bitsize,2);
  362.   test_integer_casts(schar,long,"char","long",char_bitsize,long_bitsize,2);
  363.   test_integer_casts(short,int,"short","int",short_bitsize,int_bitsize,2);
  364.   test_integer_casts(short,long,"short","long",short_bitsize,long_bitsize,2);
  365.   test_integer_casts(int,long,"int","long",int_bitsize,long_bitsize,2);
  366. #ifdef HAVE_LONGLONG
  367.   test_integer_casts(schar,longlong,"char","long long",char_bitsize,longlong_bitsize,2);
  368.   test_integer_casts(short,longlong,"short","long long",short_bitsize,longlong_bitsize,2);
  369.   test_integer_casts(int,longlong,"int","long long",int_bitsize,longlong_bitsize,2);
  370.   test_integer_casts(long,longlong,"long","long long",long_bitsize,longlong_bitsize,2);
  371. #endif
  372.   /* dann Casts zwischen Integers unterschiedlicher Gr÷▀e und unterschiedlichen Vorzeichens: */
  373.   test_integer_casts(uchar,short,"unsigned char","short",uchar_bitsize,short_bitsize,1);
  374.   test_integer_casts(uchar,int,"unsigned char","int",uchar_bitsize,int_bitsize,1);
  375.   test_integer_casts(uchar,long,"unsigned char","long",uchar_bitsize,long_bitsize,1);
  376.   test_integer_casts(ushort,int,"unsigned short","int",ushort_bitsize,int_bitsize,1);
  377.   test_integer_casts(ushort,long,"unsigned short","long",ushort_bitsize,long_bitsize,1);
  378.   test_integer_casts(uint,long,"unsigned int","long",uint_bitsize,long_bitsize,1);
  379. #ifdef HAVE_LONGLONG
  380.   test_integer_casts(uchar,longlong,"unsigned char","long long",uchar_bitsize,longlong_bitsize,1);
  381.   test_integer_casts(ushort,longlong,"unsigned short","long long",ushort_bitsize,longlong_bitsize,1);
  382.   test_integer_casts(uint,longlong,"unsigned int","long long",uint_bitsize,longlong_bitsize,1);
  383.   test_integer_casts(ulong,longlong,"unsigned long","long long",ulong_bitsize,longlong_bitsize,1);
  384. #endif
  385.   test_integer_casts(schar,ushort,"char","unsigned short",char_bitsize,ushort_bitsize,2);
  386.   test_integer_casts(schar,uint,"char","unsigned int",char_bitsize,uint_bitsize,2);
  387.   test_integer_casts(schar,ulong,"char","unsigned long",char_bitsize,ulong_bitsize,2);
  388.   test_integer_casts(short,uint,"short","unsigned int",short_bitsize,uint_bitsize,2);
  389.   test_integer_casts(short,ulong,"short","unsigned long",short_bitsize,ulong_bitsize,2);
  390.   test_integer_casts(int,ulong,"int","unsigned long",int_bitsize,ulong_bitsize,2);
  391. #ifdef HAVE_LONGLONG
  392.   test_integer_casts(schar,ulonglong,"char","unsigned long long",char_bitsize,ulonglong_bitsize,2);
  393.   test_integer_casts(short,ulonglong,"short","unsigned long long",short_bitsize,ulonglong_bitsize,2);
  394.   test_integer_casts(int,ulonglong,"int","unsigned long long",int_bitsize,ulonglong_bitsize,2);
  395.   test_integer_casts(long,ulonglong,"long","unsigned long long",long_bitsize,ulonglong_bitsize,2);
  396. #endif
  397. }
  398.  
  399. main6() {
  400. #define check_sizeof_pointer(type,typestr)  \
  401.   { if (!(sizeof(type) <= sizeof(long)))                                 \
  402.       printf("#error \"Type %s does not fit into a long!!\"\n",typestr); \
  403.   }
  404.   check_sizeof_pointer(char*,"char *");
  405.   check_sizeof_pointer(long*,"long *");
  406.   check_sizeof_pointer(function*,"function *");
  407.   pointer_bitsize = char_bitsize * sizeof(char*);
  408.   printf("/* Pointers of t%spe %s have %ld bits. */\n","y","char *",(long)pointer_bitsize);
  409.   printf("#define pointer_bitsize %ld\n",(long)pointer_bitsize);
  410.   printf("\n");
  411. }
  412.  
  413. main7() {
  414. #define test_pointer_casts(type1,type2,typestr1,typestr2)  \
  415.   if (!(sizeof(type1) == sizeof(type2)))                                                               \
  416.     { printf("#error \"Pointer types %s and %s have different sizes!!\"\n",typestr1,typestr2); }       \
  417.     else                                                                                               \
  418.     { int i;                                                                                           \
  419.       ulong differences1 = 0, differences2 = 0;                                                        \
  420.       for (i = 0; i<100; i++)                                                                          \
  421.         { ulong sample;                                                                                \
  422.           type1 sample1;                                                                               \
  423.           type2 sample2;                                                                               \
  424.           get_a_random(ulong,ulong_bitsize,sample);                                                    \
  425.           sample1 = (type1)sample;                                                                     \
  426.           sample2 = (type2)sample;                                                                     \
  427.           differences1 |= ((ulong)sample1 ^ (ulong)(type1)(sample2));                                  \
  428.           differences2 |= ((ulong)sample2 ^ (ulong)(type2)(sample1));                                  \
  429.         }                                                                                              \
  430.       if (differences1==0)                                                                             \
  431.         printf("/* Casts from %s to %s is OK (does nothing). */\n",typestr2,typestr1);                 \
  432.       else                                                                                             \
  433.       if (differences1 == ~(ulong)0)                                                                   \
  434.         printf("#error \"Casts from %s to %s work in an unknown way!!\"\n",typestr2,typestr1);         \
  435.       else                                                                                             \
  436.         printf("#error \"Casts from %s to %s modify part 0x%8X of pointer!!\"\n",typestr2,typestr1,differences1); \
  437.       if (differences2==0)                                                                             \
  438.         printf("/* Casts from %s to %s is OK (does nothing). */\n",typestr1,typestr2);                 \
  439.       else                                                                                             \
  440.       if (differences2 == ~(ulong)0)                                                                   \
  441.         printf("#error \"Casts from %s to %s work in an unknown way!!\"\n",typestr1,typestr2);         \
  442.       else                                                                                             \
  443.         printf("#error \"Casts from %s to %s modify part 0x%8X of pointer!!\"\n",typestr1,typestr2,differences2); \
  444.     }
  445.   test_pointer_casts(char*,long*,"char *","long *");
  446.   test_pointer_casts(char*,function*,"char *","function *");
  447.   printf("\n");
  448. }
  449.  
  450. main8() {
  451. #define alignmentof(type)  \
  452.   (int)(&((struct { char dummy1; type dummy2; } *)0)->dummy2)
  453. #define get_alignment(type,typestr)  \
  454.   { printf("/* Type %s has sizeof = %ld and alignment = %ld. */\n",typestr,(long)sizeof(type),(long)alignmentof(type)); \
  455.     if (!(typestr[0] == 'u') && !(typestr[string_length(typestr)-1] == '*'))                                            \
  456.       { printf("#define sizeof_"); printf_underscored(typestr); printf(" %ld\n",(long)sizeof(type));                    \
  457.         printf("#define alignment_"); printf_underscored(typestr); printf(" %ld\n",(long)alignmentof(type));            \
  458.       }                                                                                                                 \
  459.    {int align = alignmentof(type);                                                                                      \
  460.     if (!((align & (align-1)) == 0))                                                                                    \
  461.       printf("#error \"The alignment %ld of t%spe %s is not a power of two!!\"\n",(long)align,"y",typestr);             \
  462.    }                                                                                                                    \
  463.     printf("\n");                                                                                                       \
  464.   }
  465.   get_alignment(char,"char"); get_alignment(uchar,"unsigned char");
  466.   get_alignment(short,"short"); get_alignment(ushort,"unsigned short");
  467.   get_alignment(int,"int"); get_alignment(uint,"unsigned int");
  468.   get_alignment(long,"long"); get_alignment(ulong,"unsigned long");
  469. #ifdef HAVE_LONGLONG
  470.   get_alignment(longlong,"long long"); get_alignment(ulonglong,"unsigned long long");
  471. #endif
  472.   get_alignment(float,"float");
  473.   get_alignment(double,"double");
  474.   get_alignment(char*,"char *");
  475.   get_alignment(long*,"long *");
  476.   get_alignment(function*,"function *");
  477. }
  478.  
  479. main9() {
  480. #define get_endian(type,typestr,type_bitsize)  \
  481.   { if (type_bitsize == uchar_bitsize * sizeof(type))                                            \
  482.       { auto union { uchar einzeln[sizeof(type)]; type gesamt; } x;                              \
  483.         int i,j;                                                                                 \
  484.         boolean big_endian = TRUE;                                                               \
  485.         boolean little_endian = TRUE;                                                            \
  486.         for (i = 0; i<100; i++)                                                                  \
  487.           { type sample;                                                                         \
  488.             get_a_random(type,type_bitsize,sample);                                              \
  489.             x.gesamt = sample;                                                                   \
  490.             for (j = 0; j<sizeof(type); j++, sample >>= uchar_bitsize)                           \
  491.               { if (!( (sample & (((type)1<<uchar_bitsize)-1)) == x.einzeln[j] ))                \
  492.                   { little_endian = FALSE; }                                                     \
  493.                 if (!( (sample & (((type)1<<uchar_bitsize)-1)) == x.einzeln[sizeof(type)-1-j] )) \
  494.                   { big_endian = FALSE; }                                                        \
  495.           }   }                                                                                  \
  496.         if (big_endian && little_endian)                                                         \
  497.           { if (!(sizeof(type) == 1))                                                            \
  498.               printf("#error \"Endianness of t%spe %s in memory doesn't matter.\"\n","y",typestr); } \
  499.         if (big_endian && !little_endian)                                                        \
  500.           { printf("/* Type %s is stored BIG-ENDIAN in memory (i.e. like mc68000 or sparc). */\n",typestr); \
  501.             printf("#define "); printf_underscored(&typestr[9]); printf("_big_endian\n");        \
  502.           }                                                                                      \
  503.         if (little_endian && !big_endian)                                                        \
  504.           { printf("/* Type %s is stored LITTLE-ENDIAN in memory (i.e. like Z80 or VAX). */\n",typestr); \
  505.             printf("#define "); printf_underscored(&typestr[9]); printf("_little_endian\n");     \
  506.           }                                                                                      \
  507.         if (!big_endian && !little_endian)                                                       \
  508.           { printf("#error \"Type %s is stored in memory in an obscure manner!!\"\n",typestr); } \
  509.       }                                                                                          \
  510.       else                                                                                       \
  511.       { printf("#error \"Endianness makes no sense for t%spe %s !!\"\n","y",typestr); }          \
  512.   }
  513.   get_endian(uchar,"unsigned char",uchar_bitsize);
  514.   get_endian(ushort,"unsigned short",ushort_bitsize);
  515.   get_endian(uint,"unsigned int",uint_bitsize);
  516.   get_endian(ulong,"unsigned long",ulong_bitsize);
  517. #ifdef HAVE_LONGLONG
  518.   get_endian(ulonglong,"unsigned long long",ulonglong_bitsize);
  519. #endif
  520.   printf("\n");
  521. }
  522.  
  523. long get_stack_direction()
  524.   { auto char dummy;
  525.     static char* dummyaddr = (char*)0;
  526.     if (!(dummyaddr == (char*)0))
  527.       { return (&dummy) - dummyaddr; }
  528.     else
  529.       { dummyaddr = &dummy; return get_stack_direction(); }
  530.   }
  531.  
  532. main10()
  533.   { long stack_direction = get_stack_direction();
  534.     if (stack_direction > 0)
  535.       { printf("/* Stack grows up, ca. %ld bytes per function call. */\n",(long)stack_direction);
  536.         printf("#define stack_grows_up\n");
  537.       }
  538.     else if (stack_direction < 0)
  539.       { printf("/* Stack grows down, ca. %ld bytes per function call. */\n",-(long)stack_direction);
  540.         printf("#define stack_grows_down\n");
  541.       }
  542.     else
  543.       printf("#error \"Unknown stack model -- incorrect C semantics!!\"\n");
  544.   }
  545.  
  546. main()
  547. { main1();
  548.   main2();
  549.   main3();
  550.   main4();
  551.   main5();
  552.   main6();
  553.   main7();
  554.   main8();
  555.   main9();
  556.   main10();
  557.   if (ferror(stdout)) { exit(1); }
  558.   exit(0);
  559. }
  560.