PageRenderTime 69ms CodeModel.GetById 21ms RepoModel.GetById 1ms app.codeStats 2ms

/src/lispbibl.d

https://github.com/ynd/clisp-branch--ynd-devel
D | 12025 lines | 7981 code | 741 blank | 3303 comment | 1075 complexity | c404e42f858ad768575a5be350bf7543 MD5 | raw file
Possible License(s): LGPL-2.0, GPL-2.0, BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. /*
    2. 

  2.  * Main include-file for CLISP
    3. 

  3.  * Bruno Haible 1990-2008
    4. 

  4.  * Marcus Daniels 11.11.1994
    5. 

  5.  * Sam Steingold 1998-2008
    6. 

  6.  * German comments translated into English: Stefan Kain 2001-09-24
    7. 

    8. 

  8.  Flags intended to be set through CFLAGS:
    9. 

  9.    Readline library:
    10. 

  10.      NO_READLINE
    11. 

  11.    Termcap/ncurses library:
    12. 

  12.      NO_TERMCAP_NCURSES
    13. 

  13.    Internationalization:
    14. 

  14.      NO_GETTEXT, UNICODE
    15. 

  15.    Fault handling:
    16. 

  16.      NO_SIGSEGV
    17. 

  17.    Foreign function interface:
    18. 

  18.      DYNAMIC_FFI
    19. 

  19.    Dynamic loading of modules:
    20. 

  20.      DYNAMIC_MODULES
    21. 

  21.    Safety level:
    22. 

  22.      SAFETY={0,1,2,3}
    23. 

  23.    Exploit GCC global register variables:
    24. 

  24.      USE_GCC_REGISTER_VARIABLES
    25. 

  25.    Debugging (turned on by --with-debug configure option):
    26. 

  26.      DEBUG_GCSAFETY (requires G++)
    27. 

  27.      DEBUG_OS_ERROR
    28. 

  28.      DEBUG_SPVW
    29. 

  29.      DEBUG_BYTECODE
    30. 

  30.      DEBUG_BACKTRACE
    31. 

  31.      DEBUG_COMPILER
    32. 

  32.  Flags that may be set through CFLAGS, in order to override the defaults:
    33. 

  33.    Object representation (on 32-bit platforms only):
    34. 

  34.      TYPECODES, HEAPCODES, STANDARD_HEAPCODES, LINUX_NOEXEC_HEAPCODES, WIDE
    35. 

  35.    Advanced memory management:
    36. 

  36.      NO_SINGLEMAP, NO_TRIVIALMAP, NO_MULTIMAP_FILE, NO_MULTIMAP_SHM,
    37. 

  37.      NO_VIRTUAL_MEMORY, CONS_HEAP_GROWS_DOWN, CONS_HEAP_GROWS_UP,
    38. 

  38.      NO_MORRIS_GC, NO_GENERATIONAL_GC
    39. 

  39.    String representation:
    40. 

  40.      NO_SMALL_SSTRING
    41. 

    42. 

    43. 

  43.  Implementation is prepared for the following computers,
    44. 

  44.  operating systems and c-compilers
    45. 

  45.  (Only a rough listing, check the file PLATFORMS for further details.)
    46. 

  46.  Machine      Producer           Operating system              C-Compiler    recognized through
    47. 

  47.  AMIGA        Commodore          AMIGA-OS (AMIGADOS)           GNU           amiga or AMIGA, __GNUC__, maybe MC68000 or AMIGA3000
    48. 

  48.  any          any                UNIX                          GNU           unix, __GNUC__, ...
    49. 

  49.  any          any                UNIX                          CC            unix, ...
    50. 

  50.  Amiga 3000   Commodore          Amiga UNIX 2.1 SVR4.0         GNU           unix, __unix__, AMIX, __AMIX__, __svr4__, m68k, __m68k__, __motorola__, __GNUC__
    51. 

  51.  SUN-3        Sun                SUN-OS3 (UNIX BSD 4.2)        GNU           sun, unix, mc68020, __GNUC__
    52. 

  52.  SUN-3        Sun                SUN-OS4 (UNIX SUNOS 4.1)      GNU           sun, unix, mc68020, __GNUC__
    53. 

  53.  SUN-386      Sun                SUN-OS4 (UNIX SUNOS 4.0)      GNU           sun, unix, sun386, i386, __GNUC__
    54. 

  54.  SUN-386      Sun                SUN-OS4 (UNIX SUNOS 4.0)      CC            sun, unix, sun386, i386
    55. 

  55.  SUN-4        Sun                SUN-OS4 (UNIX SUNOS 4.1)      GNU           sun, unix, sparc, __GNUC__
    56. 

  56.  SUN-4        Sun                SUN-OS4 (UNIX SUNOS 4.1)      CC            sun, unix, sparc
    57. 

  57.  SUN-4        Sun                SUN-OS5 (UNIX Solaris)        GCC           sun, unix, sparc, __GNUC__
    58. 

  58.  UltraSparc   Sun                Solaris 7 (UNIX SUNOS 5.7)    CC            sun, unix, __sparc, __sparcv9
    59. 

  59.  UltraSparc   Sun                Solaris 7 (UNIX SUNOS 5.7)    GCC           sun, unix, __sparc, __arch64__, __GNUC__
    60. 

  60.  IBM-PC/386   any                SUN-OS5 (UNIX Solaris)        GCC           sun, unix, __svr4__, i386, __GNUC__
    61. 

  61.  HP9000-300   Hewlett-Packard    NetBSD 0.9 (UNIX BSD 4.3)     GNU           unix, __NetBSD__, mc68000, __GNUC__
    62. 

  62.  HP9000-300   Hewlett-Packard    HP-UX 8.0 (UNIX SYS V)        GNU           [__]hpux, [__]unix, [__]hp9000s300, mc68000, __GNUC__
    63. 

  63.  HP9000-800   Hewlett-Packard    HP-UX 8.0 (UNIX SYS V)        GNU           [__]hpux, [__]unix, [__]hp9000s800
    64. 

  64.  IRIS         Silicon Graphics   IRIX (UNIX SYS V 3.2)         GNU           unix, SVR3, mips, sgi, __GNUC__
    65. 

  65.  IRIS         Silicon Graphics   IRIX (UNIX SYS V)             cc -ansi      [__]unix, [__]SVR3, [__]mips, [__]sgi
    66. 

  66.  IRIS         Silicon Graphics   IRIX 5 (UNIX SYS V 4)         GNU           [__]unix, [__]SYSTYPE_SVR4, [__]mips, [__]host_mips, [__]MIPSEB, [__]sgi, __DSO__, [__]_MODERN_C, __GNUC__
    67. 

  67.  DECstation 5000                 RISC/OS (Ultrix V4.2A)        GNU           unix, [__]mips, [__]ultrix
    68. 

  68.  DG-UX 88k    Data General       DG/UX                         GNU           unix, m88000, DGUX
    69. 

  69.  DEC Alpha    DEC                OSF/1 1.3                     cc            [unix,] __unix__, __osf__, __alpha
    70. 

  70.  DEC Alpha    DEC                OSF/1 1.3                     GNU           unix, __unix__, __osf__, __alpha, __alpha__, _LONGLONG
    71. 

  71.  Apple MacII  Apple              A/UX (UNIX SYS V 2)           GNU           [__]unix, [__]AUX, [__]macII, [__]m68k, mc68020, mc68881, __GNUC__
    72. 

  72.  NeXT         NeXT               NeXTstep 3.1 (UNIX)           cc            NeXT, m68k
    73. 

  73.  PowerPC      Apple              Mach 3.0 + MkLinux            GNU           unix, __powerpc__, __PPC__, _ARCH_PPC, _CALL_SYSV, __ELF__, __linux__
    74. 

  74.  PowerPC      Apple              Mach + Rhapsody               cc            __MACH__, __APPLE__, __ppc[__], __GNUC__, __APPLE_CC__
    75. 

  75.  PowerPC      Apple              Mach + MacOS X                cc            __MACH__, __APPLE__, __ppc__, __GNUC__, __APPLE_CC__
    76. 

  76.  Sequent      Sequent            PTX 3.2.0 V2.1.0 i386 (SYS V) GNU           unix, i386, _SEQUENT_, __GNUC__
    77. 

  77.  Sequent      Sequent            PTX V4.1.3                    GNU           unix, i386, _SEQUENT_, __svr4__, __GNUC__
    78. 

  78.  Convex C2    Convex             ConvexOS 10.1                 GNU           __convex__, __GNUC__
    79. 

  79.  IBM RS/6000  IBM                AIX 3.2                       GNU           _AIX, _AIX32, _IBMR2, __CHAR_UNSIGNED__, __GNUC__
    80. 

  80.  IBM-PC/386   any                LINUX (free UNIX)             GNU           unix, linux, i386, __GNUC__
    81. 

  81.  IBM-PC/386   any                LINUX (free UNIX)             Intel 5.0     __unix__, __linux__, __INTEL_COMPILER, __ICC, __USLC__
    82. 

  82.  IBM-PC/386   any                386BSD 0.1 (UNIX BSD 4.2)     GNU           unix, __386BSD__, i386, __GNUC__
    83. 

  83.  IBM-PC/386   any                NetBSD 0.9 (UNIX BSD 4.3)     GNU           unix, __NetBSD__, i386, __GNUC__
    84. 

  84.  IBM-PC/386   any                FreeBSD 4.0 (UNIX BSD 4.4)    GNU           unix, __FreeBSD__, i386, __GNUC__
    85. 

  85.  IBM-PC/386   any                EMX 0.9c (UNIXlike on OS/2)   GNU           [unix,] i386, __GNUC__, __EMX__
    86. 

  86.  IBM-PC/386   any                Cygwin32 on WinNT/Win95       GNU           _WIN32, __WINNT__, __CYGWIN32__, __POSIX__, _X86_, i386, __GNUC__
    87. 

  87.  IBM-PC/386   any                Mingw32 on WinNT/Win95        GNU           _WIN32, __WINNT__, __MINGW32__, _X86_, i386, __GNUC__
    88. 

  88.  IBM-PC/386   any                WinNT/Win95                   MSVC          _WIN32, _M_IX86, _MSC_VER
    89. 

  89.  IBM-PC/386   any                WinNT/Win95                   Borland 5.0   __WIN32__, _M_IX86, __TURBOC__, __BORLANDC__
    90. 

  90.  IBM-PC/386   any                WinNT/Win95 and Cygwin32      GNU           _WIN32, __WINNT__, __CYGWIN32__, __POSIX__, __i386__, _X86_, __GNUC__
    91. 

  91.  IBM-PC/586   any                BeOS 5                        GNU           __BEOS__, __INTEL__, __i386__, _X86_, __GNUC__
    92. 

  92.  IBM-PC/586   any                HP NUE/ski, Linux             GNU           unix, linux, __ia64[__], __GNUC__, __LP64__
    93. 

  93.  RM400        Siemens-Nixdorf    SINIX-N 5.42                  c89           unix, mips, MIPSEB, host_mips, sinix, SNI, _XPG_IV
    94. 

  94.  Acorn        Risc PC            RISC OS 3.x                   GNU           [__]arm, [__]riscos, __GNUC__
    95. 

  95.  Acorn        Risc PC            RISC OS 3.x                   Norcroft      [__]arm, [__]riscos
    96. 

  96.  APPLE IIGS   Apple              ??                            ??
    97. 

  97.  For ANSI-C-Compiler: use pre-processors comment5, varbrace
    98. 

  98.    (and maybe gcc-cpp, ccpaux).
    99. 

    100. 

  100.  this machine: WIN32 or GENERIC_UNIX */
    101. 

  101. #if (defined(__unix) || defined(__unix__) || defined(_AIX) || defined(sinix) || defined(__MACH__) || defined(__POSIX__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__BEOS__)) && !defined(unix)
    102. 

  102.   #define unix
    103. 

  103. #endif
    104. 

  104. #if (defined(_WIN32) && (defined(_MSC_VER) || defined(__MINGW32__))) || (defined(__WIN32__) && defined(__BORLANDC__))
    105. 

  105.   #undef WIN32                  /* because of __MINGW32__ */
    106. 

  106.   #define WIN32
    107. 

  107. #endif
    108. 

  108. #if !defined(WIN32)
    109. 

  109.   #if defined(unix)
    110. 

  110.     #define GENERIC_UNIX
    111. 

  111.   #else
    112. 

  112.     #error "Unknown machine type -- set machine again!"
    113. 

  113.   #endif
    114. 

  114. #endif
    115. 

  115. /* additional specification of the machine: */
    116. 

  116. #if defined(WIN32)
    117. 

  117.   /* declare availability of typical PC facilities,
    118. 

  118.    like a console with a graphics mode that differs from the text mode,
    119. 

  119.    or a keyboard with function keys F1..F12. */
    120. 

  120.   #define PC386 /* IBMPC-compatible with 80386/80486-processor */
    121. 

  121. #endif
    122. 

  122. #ifdef GENERIC_UNIX
    123. 

  123.   #if (defined(sun) && defined(unix) && defined(sun386))
    124. 

  124.     #define SUN386
    125. 

  125.   #endif
    126. 

  126.   #if (defined(unix) && (defined(linux) || defined(__CYGWIN32__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)) && (defined(i386) || defined(__i386__) || defined(__x86_64__) || defined(__amd64__)))
    127. 

  127.     #define PC386
    128. 

  128.   #endif
    129. 

  129.   #if (defined(sun) && defined(unix) && defined(mc68020))
    130. 

  130.     #define SUN3
    131. 

  131.   #endif
    132. 

  132.   #if (defined(sun) && defined(unix) && defined(sparc))
    133. 

  133.     #define SUN4
    134. 

  134.   #endif
    135. 

  135.   #if defined(sparc) || defined(__sparc__)
    136. 

  136.     /* maybe SUN4_29 if only addresses <2^29 are supported */
    137. 

  137.   #endif
    138. 

  138.   #if defined(hp9000s800) || defined(__hp9000s800)
    139. 

  139.     #define HP8XX
    140. 

  140.   #endif
    141. 

  141. #endif
    142. 

  142. 

  143. /* Determine the processor:
    144. 

  144.  MC680X0 == all processors of the Motorola 68000 series
    145. 

  145.  MC680Y0 == all processors of the Motorola 68000 series, starting at MC68020
    146. 

  146.  SPARC == the Sun SPARC processor
    147. 

  147.  HPPA == all processors of the HP Precision Architecture
    148. 

  148.  MIPS == all processors of the MIPS series
    149. 

  149.  M88000 == all processors of the Motorola 88000 series
    150. 

  150.  POWERPC == the IBM RS/6000 and PowerPC processor family
    151. 

  151.  I80386 == all processors of the Intel 8086 series, starting at 80386,
    152. 

  152.            nowadays called IA32
    153. 

  153.  VAX == the VAX processor
    154. 

  154.  ARM == the ARM processor
    155. 

  155.  DECALPHA == the DEC Alpha superchip
    156. 

  156.  IA64 == the Intel IA-64 latecomer chip
    157. 

  157.  AMD64 == the AMD hammer chip
    158. 

  158.  S390 == the IBM S/390 processor */
    159. 

  159. #if defined(__vax__)
    160. 

  160.   #define VAX
    161. 

  161. #endif
    162. 

  162. #if defined(arm) || defined(__arm) || defined(__arm__)
    163. 

  163.   #define ARM
    164. 

  164. #endif
    165. 

  165. #ifdef WIN32
    166. 

  166.   #if defined(_M_IX86) || defined(_X86_)
    167. 

  167.     #define I80386
    168. 

  168.   #endif
    169. 

  169. #endif
    170. 

  170. #ifdef GENERIC_UNIX
    171. 

  171.   #if defined(m68k) || defined(__m68k__) || defined(mc68000)
    172. 

  172.     #define MC680X0
    173. 

  173.   #endif
    174. 

  174.   #if defined(mc68020) || defined(__mc68020__) || (defined(m68k) && defined(NeXT))
    175. 

  175.     #define MC680X0
    176. 

  176.     #define MC680Y0
    177. 

  177.   #endif
    178. 

  178.   #if defined(i386) || defined(__i386) || defined(__i386__) || defined(_I386)
    179. 

  179.     #define I80386
    180. 

  180.   #endif
    181. 

  181.   #if defined(sparc) || defined(__sparc__)
    182. 

  182.     #define SPARC
    183. 

  183.     #if defined(__sparcv9) || defined(__arch64__)
    184. 

  184.       #define SPARC64
    185. 

  185.     #endif
    186. 

  186.   #endif
    187. 

  187.   #if defined(mips) || defined(__mips) || defined(__mips__)
    188. 

  188.     #define MIPS
    189. 

  189.     #if defined(_MIPS_SZLONG)
    190. 

  190.       #if (_MIPS_SZLONG == 64)
    191. 

  191.         /* We should also check for (_MIPS_SZPTR == 64), but gcc keeps this at 32. */
    192. 

  192.         #define MIPS64
    193. 

  193.       #endif
    194. 

  194.     #endif
    195. 

  195.   #endif
    196. 

  196.   #if defined(HP8XX) || defined(hppa) || defined(__hppa) || defined(__hppa__)
    197. 

  197.     #define HPPA
    198. 

  198.   #endif
    199. 

  199.   #if defined(m88000) || defined(__m88k__)
    200. 

  200.     #define M88000
    201. 

  201.   #endif
    202. 

  202.   #if defined(_IBMR2) || defined(__powerpc) || defined(__ppc) || defined(__ppc__) || defined(__powerpc__)
    203. 

  203.     #define POWERPC
    204. 

  204.   #endif
    205. 

  205.   #ifdef __alpha
    206. 

  206.     #define DECALPHA
    207. 

  207.   #endif
    208. 

  208.   #ifdef __ia64__
    209. 

  209.     #define IA64
    210. 

  210.   #endif
    211. 

  211.   #if defined(__x86_64__) || defined(__amd64__)
    212. 

  212.     #define AMD64
    213. 

  213.   #endif
    214. 

  214.   #ifdef __s390__
    215. 

  215.     #define S390
    216. 

  216.   #endif
    217. 

  217. #endif
    218. 

  218. 

  219. 

  220. /* Selection of the operating system */
    221. 

  221. #ifdef WIN32
    222. 

  222.   /* Windows NT, Windows 95 */
    223. 

  223.   #define WIN32_NATIVE  /* native NT API, no DOS calls */
    224. 

  224. #endif
    225. 

  225. #ifdef GENERIC_UNIX
    226. 

  226.   #define UNIX
    227. 

  227.   #ifdef __linux__
    228. 

  228.     #define UNIX_LINUX  /* Linux (Linus Torvalds Unix) */
    229. 

  229.   #endif
    230. 

  230.   #ifdef __GNU__
    231. 

  231.     #define UNIX_HURD  /* the GNU system (Hurd + glibc) */
    232. 

  232.   #endif
    233. 

  233.   #ifdef __NetBSD__
    234. 

  234.     #define UNIX_NETBSD
    235. 

  235.   #endif
    236. 

  236.   #if defined(__FreeBSD__) || defined(__DragonFly__)
    237. 

  237.     /* FreeBSD or its fork called DragonFly BSD. */
    238. 

  238.     #define UNIX_FREEBSD
    239. 

  239.   #endif
    240. 

  240.   #ifdef __OpenBSD__
    241. 

  241.     #define UNIX_OPENBSD
    242. 

  242.   #endif
    243. 

  243.   #if defined(hpux) || defined(__hpux)
    244. 

  244.     #define UNIX_HPUX  /* HP-UX */
    245. 

  245.   #endif
    246. 

  246.   #if defined(SVR3) || defined(__SVR3) || defined(SVR4) || defined(__SVR4) || defined(SYSTYPE_SVR4) || defined(__SYSTYPE_SVR4) || defined(__svr4__) || defined(USG) || defined(UNIX_HPUX) /* ?? */
    247. 

  247.     #define UNIX_SYSV  /* UNIX System V */
    248. 

  248.   #endif
    249. 

  249.   #if defined(UNIX_SYSV) && (defined(sgi) || defined(__sgi))
    250. 

  250.     #define UNIX_IRIX  /* Irix */
    251. 

  251.     #if defined(SYSTYPE_SVR4) || defined(__SYSTYPE_SVR4)
    252. 

  252.       #define UNIX_IRIX5  /* Irix 5 */
    253. 

  253.     #endif
    254. 

  254.   #endif
    255. 

  255.   #if defined(MIPS) && (defined(ultrix) || defined(__ultrix))
    256. 

  256.     #define UNIX_DEC_ULTRIX  /* DEC's (or IBM's ?) RISC/OS Ultrix on DEC MIPS */
    257. 

  257.     #ifdef __GNUC__
    258. 

  258.       #define UNIX_DEC_ULTRIX_GCCBUG  /* work around a bug in GCC 2.3.3 */
    259. 

  259.     #endif
    260. 

  260.   #endif
    261. 

  261.   #if defined(MIPS) && defined(sinix) /* && defined(SNI) */
    262. 

  262.     #define UNIX_SINIX /* Siemens is nix */
    263. 

  263.   #endif
    264. 

  264.   #if defined(USL) || (defined(__svr4__) && defined(I80386) && !defined(__sun))
    265. 

  265.     /* A couple of Unices for 386s (all running under different names)
    266. 

  266.      derive from USL SysV R 4:
    267. 

  267.        386 UHC UNIX System V release 4
    268. 

  268.        Consensys System V 4.2
    269. 

  269.        Onsite System V 4.2
    270. 

  270.        SINIX-Z
    271. 

  271.        DYNIX/ptx V4.1.3
    272. 

  272.        SunOS 5 */
    273. 

  273.     #define UNIX_SYSV_USL  /* Unix System V R 4 by AT&T's subsidiary USL */
    274. 

  274.     #define UNIX_SYSV_UHC_1 /* treat like HPPA && UNIX_HPUX */
    275. 

  275.     #ifdef SNI
    276. 

  276.       #define UNIX_SINIX /* Siemens is nix */
    277. 

  277.     #endif
    278. 

  278.   #endif
    279. 

  279.   #if defined(_SEQUENT_) && !defined(__svr4__)
    280. 

  280.     #define UNIX_SYSV_PTX  /* Dynix/ptx v. 2 or 3 */
    281. 

  281.   #endif
    282. 

  282.   #ifdef _AIX
    283. 

  283.     #define UNIX_AIX  /* IBM AIX */
    284. 

  284.   #endif
    285. 

  285.   #ifdef DGUX
    286. 

  286.     #define UNIX_DGUX  /* Data General DG/UX */
    287. 

  287.   #endif
    288. 

  288.   #ifdef __osf__
    289. 

  289.     #define UNIX_OSF  /* OSF/1 */
    290. 

  290.   #endif
    291. 

  291.   #ifdef AUX
    292. 

  292.     #define UNIX_AUX  /* Apple A/UX, a spiced-up SVR2 */
    293. 

  293.   #endif
    294. 

  294.   #ifdef NeXT
    295. 

  295.     #define UNIX_NEXTSTEP  /* NeXTstep */
    296. 

  296.   #endif
    297. 

  297.   #if defined(__APPLE__) && defined(__MACH__)
    298. 

  298.     #define UNIX_MACOSX  /* MacOS X */
    299. 

  299.   #endif
    300. 

  300.   #ifdef AMIX
    301. 

  301.     #define UNIX_AMIX  /* Amiga UNIX */
    302. 

  302.   #endif
    303. 

  303.   #ifdef __CYGWIN32__
    304. 

  304.     #define UNIX_CYGWIN32  /* Cygwin32 (UNIXlike on WinNT/Win95) */
    305. 

  305.   #endif
    306. 

  306.   #ifdef __BEOS__
    307. 

  307.     #define UNIX_BEOS  /* BeOS (UNIXlike) */
    308. 

  308.   #endif
    309. 

  309. #endif
    310. 

  310. %% #ifdef WIN32_NATIVE
    311. 

  311. %%   puts("#define WIN32_NATIVE");
    312. 

  312. %% #endif
    313. 

  313. %% #ifdef UNIX
    314. 

  314. %%   puts("#define UNIX");
    315. 

  315. %% #endif
    316. 

  316. 

  317. 

  318. /* Determine properties of compiler and environment: */
    319. 

  319. #if defined(UNIX) || defined(__MINGW32__)
    320. 

  320.   #include "config.h"  /* configuration generated by configure */
    321. 

  321.   #include "intparam.h"  /* integer-type characteristics created by the machine */
    322. 

  322.   #include "floatparam.h" /* floating-point type characteristics */
    323. 

  323. #elif defined(WIN32) && !defined(__MINGW32__)
    324. 

  324.   #include "version.h"          /* defines PACKAGE_* */
    325. 

  325.   #define char_bitsize 8
    326. 

  326.   #define short_bitsize 16
    327. 

  327.   #define int_bitsize 32
    328. 

  328.   #if defined(I80386)
    329. 

  329.     #define long_bitsize 32
    330. 

  330.   #elif defined(DECALPHA)
    331. 

  331.     #define long_bitsize 64
    332. 

  332.   #endif
    333. 

  333.   #if defined(I80386)
    334. 

  334.     #define pointer_bitsize 32
    335. 

  335.   #elif defined(DECALPHA)
    336. 

  336.     #define pointer_bitsize 64
    337. 

  337.   #endif
    338. 

  338.   #define alignment_long 4
    339. 

  339.   #if defined(I80386) || defined(VAX) || defined(ARM) || defined(DECALPHA)
    340. 

  340.     #define short_little_endian
    341. 

  341.     #define long_little_endian
    342. 

  342.   #endif
    343. 

  343.   #define stack_grows_down
    344. 

  344.   #define CODE_ADDRESS_RANGE 0
    345. 

  345.   #define MALLOC_ADDRESS_RANGE 0
    346. 

  346.   #define SHLIB_ADDRESS_RANGE 0
    347. 

  347.   #define STACK_ADDRESS_RANGE ~0UL
    348. 

  348.   #define ICONV_CONST
    349. 

  349. #else
    350. 

  350.   #error "where is the configuration for your platform?"
    351. 

  351. #endif
    352. 

  352. 

  353. 

  354. /* A more precise classification of the operating system: */
    355. 

  355. #if defined(UNIX) && defined(SIGNALBLOCK_BSD) && !defined(SIGNALBLOCK_SYSV)
    356. 

  356.   #define UNIX_BSD  /* BSD Unix */
    357. 

  357. #endif
    358. 

  358. #if (defined(SUN3) || defined(SUN386) || defined(SUN4)) && defined(HAVE_MMAP) && defined(HAVE_VADVISE)
    359. 

  359.   #define UNIX_SUNOS4  /* Sun OS Version 4 */
    360. 

  360. #endif
    361. 

  361. #if (defined(SUN4) || (defined(I80386) && defined(__svr4__) && defined(__sun))) && !defined(HAVE_VADVISE) /* && !defined(HAVE_GETPAGESIZE) */
    362. 

  362.   #define UNIX_SUNOS5  /* Sun OS Version 5.[1-5] (Solaris 2) */
    363. 

  363. #endif
    364. 

  364. #if defined(UNIX_MACOSX) && !defined(HAVE_MSYNC)
    365. 

  365.   #define UNIX_RHAPSODY  /* MacOS X Server, a.k.a. Rhapsody */
    366. 

  366. #endif
    367. 

  367. #if defined(UNIX_MACOSX) && defined(HAVE_MSYNC)
    368. 

  368.   #define UNIX_DARWIN  /* MacOS X, a.k.a. Darwin */
    369. 

  369. #endif
    370. 

  370. 

  371. 

  372. /* Choose the character set: */
    373. 

  373. #if defined(UNIX) || defined(WIN32)
    374. 

  374.   #define ISOLATIN_CHS  /* ISO 8859-1, see isolatin.chs */
    375. 

  375.   /* Most Unix systems today support the ISO Latin-1 character set, in
    376. 

  376.    particular because they have X11 and the X11 fonts are in ISO Latin-1.
    377. 

  377.    Exceptions below.
    378. 

  378.    On Win32, the standard character set is ISO-8859-1. Only the DOS box
    379. 

  379.    displays CP437, but we convert from ISO-8859-1 to CP437 in the
    380. 

  380.    low-level output routine full_write(). */
    381. 

  381. #endif
    382. 

  382. #ifdef UNIX_BEOS
    383. 

  383.   /* The default encoding on BeOS is UTF-8, not ISO 8859-1.
    384. 

  384.    If compiling with Unicode support, we use it. Else fall back to ASCII. */
    385. 

  385.   #undef ISOLATIN_CHS
    386. 

  386.   #ifdef UNICODE
    387. 

  387.     #define UTF8_CHS  /* UTF-8 */
    388. 

  388.   #endif
    389. 

  389. #endif
    390. 

  390. #ifdef HP8XX
    391. 

  391.   #undef ISOLATIN_CHS
    392. 

  392.   #define HPROMAN8_CHS  /* HP-Roman8, see hproman8.chs */
    393. 

  393.   /* under X-Term however: #define ISOLATIN_CHS ?? */
    394. 

  394. #endif
    395. 

  395. #ifdef UNIX_NEXTSTEP
    396. 

  396.   #undef ISOLATIN_CHS
    397. 

  397.   #define NEXTSTEP_CHS  /* NeXTstep, see nextstep.chs */
    398. 

  398. #endif
    399. 

  399. #if !(defined(ISOLATIN_CHS) || defined(HPROMAN8_CHS) || defined(NEXTSTEP_CHS))
    400. 

  400.   #define ASCII_CHS  /* Default: plain ASCII charset without special chars */
    401. 

  401. #endif
    402. 

  402. 

  403. 

  404. /* Choose the compiler: */
    405. 

  405. #if defined(__GNUC__)
    406. 

  406.   #define GNU
    407. 

  407. #endif
    408. 

  408. #if defined(__STDC__) || defined(__BORLANDC__) || defined(__cplusplus)
    409. 

  409.   /* ANSI C compilers define __STDC__ (but some define __STDC__=0 !).
    410. 

  410.    Borland C has an ANSI preprocessor and compiler, but fails to define
    411. 

  411.    __STDC__.
    412. 

  412.    HP aCC is an example of a C++ compiler which defines __cplusplus but
    413. 

  413.    not __STDC__. */
    414. 

  414.   #define ANSI
    415. 

  415. #endif
    416. 

  416. #if defined(_MSC_VER)
    417. 

  417.   #define MICROSOFT
    418. 

  418. #endif
    419. 

  419. #if defined(__BORLANDC__)
    420. 

  420.   #define BORLAND
    421. 

  421. #endif
    422. 

  422. #if defined(__INTEL_COMPILER)
    423. 

  423.   #define INTEL
    424. 

  424. #endif
    425. 

  425. 

  426. 

  427. /* Selection of floating-point capabilities:
    428. 

  428.  FAST_DOUBLE should be defined if there is a floating-point coprocessor
    429. 

  429.  with a 'double'-type IEEE-Floating-Points with 64 Bits.
    430. 

  430.  FAST_FLOAT should be defined if there is a floating-point co-processor
    431. 

  431.  with a 'float'-type IEEE-Floating-Points with 32 Bits,
    432. 

  432.  and a C-Compiler that generates 'float'-operations
    433. 

  433.  instead of 'double'-operations */
    434. 

  434. #if (float_mant_bits == 24) && (float_rounds == rounds_to_nearest) && float_rounds_correctly && !defined(FLOAT_OVERFLOW_EXCEPTION) && !defined(FLOAT_UNDERFLOW_EXCEPTION) && !defined(FLOAT_INEXACT_EXCEPTION)
    435. 

  435.   #define FAST_FLOAT
    436. 

  436. #endif
    437. 

  437. #if (double_mant_bits == 53) && (double_rounds == rounds_to_nearest) && double_rounds_correctly && !defined(DOUBLE_OVERFLOW_EXCEPTION) && !defined(DOUBLE_UNDERFLOW_EXCEPTION) && !defined(DOUBLE_INEXACT_EXCEPTION)
    438. 

  438.   #define FAST_DOUBLE
    439. 

  439. #endif
    440. 

  440. #ifdef ARM
    441. 

  441.   /* The processor is little-endian w.r.t. integer types but stores 'double'
    442. 

  442.    floats in big-endian word order! */
    443. 

  443.   #undef FAST_DOUBLE
    444. 

  444. #endif
    445. 

  445. #ifdef NO_FAST_DOUBLE
    446. 

  446.   #undef FAST_DOUBLE
    447. 

  447. #endif
    448. 

  448. #ifdef NO_FAST_FLOAT
    449. 

  449.   #undef FAST_FLOAT
    450. 

  450. #endif
    451. 

  451. 

  452. 

  453. /* Selection of the language: */
    454. 

  454. #ifdef ENGLISH
    455. 

  455.   #undef ENGLISH
    456. 

  456.   #define ENGLISH 1
    457. 

  457.   #define LANGUAGE_STATIC
    458. 

  458. #endif
    459. 

  459. 

  460. 

  461. /* Selection of the safety-level:
    462. 

  462.  SAFETY=0 : all optimizations are turned on
    463. 

  463.  SAFETY=1 : all optimizations on, but keep STACKCHECKs
    464. 

  464.  SAFETY=2 : only simple assembler-support
    465. 

  465.  SAFETY=3 : no optimizations */
    466. 

  466. #ifndef SAFETY
    467. 

  467.   #define SAFETY 0
    468. 

  468. #endif
    469. 

  469. #if SAFETY >= 3
    470. 

  470.   #define NO_ASM
    471. 

  471.   #define NO_ARI_ASM
    472. 

  472.   #define NO_FAST_DISPATCH
    473. 

  473. #endif
    474. 

  474. 

  475. /* We don't support pre-ANSI-C compilers any more. */
    476. 

  476. #if !defined(ANSI)
    477. 

  477.   #error "An ANSI C or C++ compiler is required to compile CLISP!"
    478. 

  478. #endif
    479. 

  479. 

  480. /* gcc-2.7.2 has a bug: it interpretes `const' as meaning `not modified by
    481. 

  481.  other parts of the program', and thus miscompiles at least justify_empty_2
    482. 

  482.  and pr_enter_1 in io.d. */
    483. 

  483. #if defined(GNU) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 7)
    484. 

  484.   #undef const
    485. 

  485.   #define const
    486. 

  486.   #define __const const
    487. 

  487.   /* We define __const to const, not to empty, to avoid warnings on
    488. 

  488.    UNIX_RHAPSODY, which unconditionally defines __const to const when
    489. 

  489.    <sys/cdefs.h> is included via <setjmp.h> below. */
    490. 

  490.   #ifdef MULTITHREAD
    491. 

  491.     #warning "Multithreading will not be efficient because of a workaround to a gcc bug."
    492. 

  492.     #warning "Get a newer version of gcc."
    493. 

  493.   #endif
    494. 

  494. #endif
    495. 

  495. 

  496. /* A property of the processor:
    497. 

  497.  The sequence in which words/long-words are being put into bytes */
    498. 

  498. #if defined(short_little_endian) || defined(int_little_endian) || defined(long_little_endian)
    499. 

  499.   /* Z80, VAX, I80386, DECALPHA, MIPSEL, IA64, AMD64, ...:
    500. 

  500.    Low Byte is the lowest, High Byte in a higher address */
    501. 

  501.   #if defined(BIG_ENDIAN_P)
    502. 

  502.     #error "Bogus BIG_ENDIAN_P -- set BIG_ENDIAN_P again!"
    503. 

  503.   #endif
    504. 

  504.   #define BIG_ENDIAN_P  0
    505. 

  505. #endif
    506. 

  506. #if defined(short_big_endian) || defined(int_big_endian) || defined(long_big_endian)
    507. 

  507.   /* MC680X0, SPARC, HPPA, MIPSEB, M88000, POWERPC, S390, ...:
    508. 

  508.    High Byte is the lowest, Low Byte is a higher adress (easier to read) */
    509. 

  509.   #if defined(BIG_ENDIAN_P)
    510. 

  510.     #error "Bogus BIG_ENDIAN_P -- set BIG_ENDIAN_P again"
    511. 

  511.   #endif
    512. 

  512.   #define BIG_ENDIAN_P  1
    513. 

  513. #endif
    514. 

  514. #if !defined(BIG_ENDIAN_P)
    515. 

  515.   #error "Bogus BIG_ENDIAN_P -- set BIG_ENDIAN_P again!"
    516. 

  516. #endif
    517. 

  517. %% export_def(BIG_ENDIAN_P);
    518. 

  518. 

  519. /* A property of the processor (and C compiler): The alignment of C functions.
    520. 

  520.  (See gcc's machine descriptions, macro FUNCTION_BOUNDARY, for information.) */
    521. 

  521. #if defined(IA64)
    522. 

  522.   #define C_CODE_ALIGNMENT  16
    523. 

  523.   #define log2_C_CODE_ALIGNMENT  4
    524. 

  524. #endif
    525. 

  525. #if defined(DECALPHA)
    526. 

  526.   #define C_CODE_ALIGNMENT  8
    527. 

  527.   #define log2_C_CODE_ALIGNMENT  3
    528. 

  528. #endif
    529. 

  529. #if (defined(I80386) && defined(GNU)) || defined(SPARC) || defined(MIPS) || defined(M88000) || defined(POWERPC) || defined(ARM) || defined(AMD64) || defined(S390)
    530. 

  530.   /* When using gcc on i386, this assumes that -malign-functions has not been
    531. 

  531.    used to specify an alignment smaller than 4 bytes. */
    532. 

  532.   #define C_CODE_ALIGNMENT  4
    533. 

  533.   #define log2_C_CODE_ALIGNMENT  2
    534. 

  534. #endif
    535. 

  535. #if defined(HPPA)
    536. 

  536.   /* A function pointer on hppa is either
    537. 

  537.      - a code pointer == 0 mod 4, or
    538. 

  538.      - a pointer to a two-word structure (first word: a code pointer,
    539. 

  539.        second word: a value which will be put in register %r19),
    540. 

  540.        incremented by 2, hence == 2 mod 4.
    541. 

  541.    The current compilers only emit the second kind of function pointers,
    542. 

  542.    hence we can assume that all function pointers are == 2 mod 4. */
    543. 

  543.   #define C_CODE_ALIGNMENT  2
    544. 

  544.   #define log2_C_CODE_ALIGNMENT  1
    545. 

  545. #endif
    546. 

  546. #if defined(MC680X0)
    547. 

  547.   #define C_CODE_ALIGNMENT  2
    548. 

  548.   #define log2_C_CODE_ALIGNMENT  1
    549. 

  549. #endif
    550. 

  550. #if !defined(C_CODE_ALIGNMENT) /* e.g. (defined(I80386) && defined(MICROSOFT)) */
    551. 

  551.   #define C_CODE_ALIGNMENT  1
    552. 

  552.   #define log2_C_CODE_ALIGNMENT  0
    553. 

  553. #endif
    554. 

  554. 

  555. 

  556. /* Flags for the system's include files. */
    557. 

  557. #ifdef MULTITHREAD
    558. 

  558.   #if defined(UNIX_GNU) || defined(UNIX_SUNOS5)
    559. 

  559.     #define _REENTRANT
    560. 

  560.   #endif
    561. 

  561.   #if defined(__GNUC__)
    562. 

  562.     #define per_thread __thread
    563. 

  563.   #else
    564. 

  564.     #error "how does your compiler specify per-thread storage class?"
    565. 

  565.   #endif
    566. 

  566. #else
    567. 

  567.   #define per_thread
    568. 

  568. #endif
    569. 

  569. 

  570. 

  571. /* Width of object representation:
    572. 

  572.  WIDE means than an object (pointer) occupies 64 bits (instead of 32 bits).
    573. 

  573.  WIDE_HARD means on a 64-bit platform.
    574. 

  574.  WIDE_SOFT means on a 32-bit platform, each object pointer occupies 2 words.
    575. 

  575.  WIDE_AUXI means on a 32-bit platform, each object occupies 2 words, the
    576. 

  576.            pointer and some auxiliary word. */
    577. 

  577. 

  578. #if defined(DECALPHA) || defined(MIPS64) || defined(SPARC64) || defined(IA64) || defined(AMD64)
    579. 

  579.   #define WIDE_HARD
    580. 

  580. #endif
    581. 

  581. 

  582. #if defined(WIDE_SOFT_LARGEFIXNUM) && !defined(WIDE_SOFT)
    583. 

  583.   #define WIDE_SOFT
    584. 

  584. #endif
    585. 

  585. 

  586. #if defined(WIDE) && !(defined(WIDE_HARD) || defined(WIDE_SOFT) || defined(WIDE_AUXI))
    587. 

  587.   #define WIDE_SOFT
    588. 

  588. #endif
    589. 

  589. #if (defined(WIDE_HARD) || defined(WIDE_SOFT) || defined(WIDE_AUXI)) && !defined(WIDE)
    590. 

  590.   #define WIDE
    591. 

  591. #endif
    592. 

  592. /* Now: defined(WIDE) == defined(WIDE_HARD) || defined(WIDE_SOFT) || defined(WIDE_AUXI) */
    593. 

  593. 

  594. 

  595. /* Global register declarations.
    596. 

  596.    Speed benefit: Just putting the STACK into a register, brought 5% of speed
    597. 

  597.    around 1992. Now, with an AMD Athlon CPU from 2000, with good caches, it
    598. 

  598.    still brings 4%.
    599. 

  599.    The declarations must occur before any system include files define any
    600. 

  600.    inline function, which is the case on UNIX_DGUX and UNIX_GNU.
    601. 

  601.    Only GCC supports global register variables. Not Apple's variant of GCC.
    602. 

  602.    And only the C frontend, not the C++ frontend, understands the syntax.
    603. 

  603.    And gcc-3.0 to 3.3.3 has severe bugs with global register variables, see
    604. 

  604.    CLISP bugs 710737 and 723097 and
    605. 

  605.    http://gcc.gnu.org/bugzilla/show_bug.cgi?id=7871
    606. 

  606.    http://gcc.gnu.org/bugzilla/show_bug.cgi?id=10684
    607. 

  607.    http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14937
    608. 

  608.    http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14938
    609. 

  609.    Likewise, gcc-4.2 has severe bugs with global register variables, see
    610. 

  610.    CLISP bug 1836142 and http://gcc.gnu.org/bugzilla/show_bug.cgi?id=34300
    611. 

  611.    Likewise for gcc-4.3-20080215 and probably future versions of GCC as well.
    612. 

  612.    Therefore for these versions of gcc enable the global register variables
    613. 

  613.    only when USE_GCC_REGISTER_VARIABLES is explicitly defined.  */
    614. 

  614. #if defined(GNU) && !(__APPLE_CC__ > 1) && !defined(__cplusplus) && !(__GNUC__ == 3 && (__GNUC_MINOR__ < 3 || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 4))) && !(((__GNUC__ == 4 && __GNUC_MINOR__ >= 2) || __GNUC__ > 4) && !defined(USE_GCC_REGISTER_VARIABLES)) && !defined(MULTITHREAD) && (SAFETY < 2) && !defined(USE_JITC)
    615. 

  615. /* Overview of use of registers in gcc terminology:
    616. 

  616.  fixed: mentioned in FIXED_REGISTERS
    617. 

  617.  used:  mentioned in CALL_USED_REGISTERS but not FIXED_REGISTERS
    618. 

  618.                      (i.e. caller-saved)
    619. 

  619.  save:  otherwise (i.e. call-preserved, callee-saved)
    620. 

    621. 

  621.                STACK    mv_count  value1   back_trace
    622. 

  622.  MC680X0       used
    623. 

  623.  I80386        save
    624. 

  624.  SPARC (gcc2)  fixed    fixed     fixed    used
    625. 

  625.  MIPS
    626. 

  626.  HPPA          save     save      save     save
    627. 

  627.  M88000        save     save      save
    628. 

  628.  ARM           save
    629. 

  629.  DECALPHA      save     save      save
    630. 

  630.  IA64
    631. 

  631.  AMD64
    632. 

  632.  S390          save
    633. 

    634. 

  634.  Special notes:
    635. 

  635.  - gcc3/Sparc (Linux & Solaris) handles registers differently from gcc2. FIXME
    636. 

  636.  - If STACK is in a "used"/"save" register, it needs to be saved into
    637. 

  637.    saved_STACK upon begin_call(), so that asynchronous interrupts will
    638. 

  638.    be able to restore it.
    639. 

  639.  - All of the "used" registers need to be backed up upon begin_call()
    640. 

  640.    and restored during end_call().
    641. 

  641.  - All of the "save" registers need to be backed up upon begin_callback()
    642. 

  642.    and restored during end_callback().
    643. 

  643.  - When the interpreter does a longjmp(), the registers STACK, mv_count,
    644. 

  644.    value1 may need to be temporarily saved. This is highly machine
    645. 

  645.    dependent and is indicated by the NEED_temp_xxxx macros.
    646. 

    647. 

  647.    * Register for STACK. */
    648. 

  648.   #if defined(MC680X0)
    649. 

  649.     #define STACK_register "a4" /* highest address register after sp=A7,fp=A6/A5 */
    650. 

  650.   #endif
    651. 

  651.   #if defined(I80386) && !defined(UNIX_BEOS) && !defined(DYNAMIC_MODULES)
    652. 

  652.     /* On BeOS, everything is compiled as PIC, hence %ebx is already booked.
    653. 

  653.      If DYNAMIC_MODULES is defined, external modules are compiled as PIC,
    654. 

  654.      which is why %ebx is already in use. */
    655. 

  655.     #if (__GNUC__ >= 2) /* The register names have changed */
    656. 

  656.       #define STACK_register  "%ebx"  /* one of the call-saved registers without special hardware commands */
    657. 

  657.     #else
    658. 

  658.       #define STACK_register  "bx"
    659. 

  659.     #endif
    660. 

  660.   #endif
    661. 

  661.   #if defined(SPARC)
    662. 

  662.     #define STACK_register  "%g5"  /* a global register */
    663. 

  663.   #endif
    664. 

  664.   #if defined(HPPA) && (__GNUC__*100 + __GNUC_MINOR__ >= 2*100+7) /* gcc versions earlier than 2.7 had bugs */
    665. 

  665.     #define STACK_register  "%r10"  /* one of the general registers %r5..%r18 */
    666. 

  666.   #endif
    667. 

  667.   #if defined(M88000)
    668. 

  668.     #define STACK_register  "%r14"  /* one of the general registers %r14..%r25 */
    669. 

  669.   #endif
    670. 

  670.   #if defined(ARM)
    671. 

  671.     #define STACK_register  "%r8"   /* one of the general registers %r4..%r8 */
    672. 

  672.   #endif
    673. 

  673.   #if defined(DECALPHA)
    674. 

  674.     #define STACK_register  "$9"    /* one of the general registers $9..$14 */
    675. 

  675.   #endif
    676. 

  676.   #if defined(S390) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)))
    677. 

  677.     /* global register assignment did not work on s390 until gcc 3.1 */
    678. 

  678.     #define STACK_register  "9"     /* one of the general registers %r8..%r9 */
    679. 

  679.   #endif
    680. 

  680.   /* What about NEED_temp_STACK ?? Needed if STACK is in a "used" register??
    681. 

  681.    Register for mv_count. */
    682. 

  682.   #if defined(SPARC)
    683. 

  683.     #define mv_count_register  "%g6"
    684. 

  684.     #if defined(UNIX_NETBSD)
    685. 

  685.       #define NEED_temp_mv_count
    686. 

  686.     #endif
    687. 

  687.   #endif
    688. 

  688.   #if defined(HPPA)
    689. 

  689.     #define mv_count_register  "%r11"  /* one of the general registers %r5..%r18 */
    690. 

  690.     #define NEED_temp_mv_count
    691. 

  691.   #endif
    692. 

  692.   #if defined(M88000)
    693. 

  693.     #define mv_count_register  "%r15" /* one of the general registers %r14..%r25 */
    694. 

  694.     #define NEED_temp_mv_count
    695. 

  695.   #endif
    696. 

  696.   #if defined(DECALPHA)
    697. 

  697.     #define mv_count_register  "$10"  /* one of the general registers $9..$14 */
    698. 

  698.     #define NEED_temp_mv_count
    699. 

  699.   #endif
    700. 

  700.   /* Register for value1. */
    701. 

  701.   #if !(defined(WIDE) && !defined(WIDE_HARD))
    702. 

  702.     #if defined(SPARC)
    703. 

  703.       #define value1_register  "%g7"
    704. 

  704.       #if defined(UNIX_NETBSD)
    705. 

  705.         #define NEED_temp_value1
    706. 

  706.       #endif
    707. 

  707.     #endif
    708. 

  708.     #if defined(HPPA)
    709. 

  709.       #define value1_register  "%r12"  /* one of the general registers %r5..%r18 */
    710. 

  710.       #define NEED_temp_value1
    711. 

  711.     #endif
    712. 

  712.     #if defined(M88000)
    713. 

  713.       #define value1_register  "%r16"  /* one of the general registers %r14..%r25 */
    714. 

  714.       #define NEED_temp_value1
    715. 

  715.     #endif
    716. 

  716.     #if defined(DECALPHA)
    717. 

  717.       #define value1_register  "$11"  /* one of the general registers $9..$14 */
    718. 

  718.       #define NEED_temp_value1
    719. 

  719.     #endif
    720. 

  720.   #endif
    721. 

  721.   /* Register for back_trace. */
    722. 

  722.   #if !(defined(WIDE) && !defined(WIDE_HARD))
    723. 

  723.     #if defined(SPARC)
    724. 

  724.       #define back_trace_register  "%g4"  /* a global register */
    725. 

  725.       /* %g4 seems to be a scratch-register as of lately with gcc 2.3
    726. 

  726.        This causes problems with libc.so.1.6.1 (and higher) (in getwd())
    727. 

  727.        That's why HAVE_SAVED_back_trace has been defined above. */
    728. 

  728.     #endif
    729. 

  729.     #if defined(HPPA)
    730. 

  730.       #define back_trace_register  "%r13"  /* one of the general registers  %r5..%r18 */
    731. 

  731.     #endif
    732. 

  732.   #endif
    733. 

  733.   /* Declare the registers now (before any system include file which could
    734. 

  734.    contain some inline functions). */
    735. 

  735.   #ifdef STACK_register
    736. 

  736.     register long STACK_reg __asm__(STACK_register);
    737. 

  737.   #endif
    738. 

  738.   #ifdef mv_count_register
    739. 

  739.     register long mv_count_reg __asm__(mv_count_register);
    740. 

  740.   #endif
    741. 

  741.   #ifdef value1_register
    742. 

  742.     register long value1_reg __asm__(value1_register);
    743. 

  743.   #endif
    744. 

  744.   #ifdef back_trace_register
    745. 

  745.     register long back_trace_reg __asm__(back_trace_register);
    746. 

  746.   #endif
    747. 

  747.   /* Saving "save" registers. */
    748. 

  748.   #if (defined(I80386) || defined(HPPA) || defined(M88000) || defined(ARM) || defined(DECALPHA) || defined(S390)) && (defined(STACK_register) || defined(mv_count_register) || defined(value1_register) || defined(back_trace_register))
    749. 

  749.     #define HAVE_SAVED_REGISTERS
    750. 

  750.     struct registers {
    751. 

  751.       #ifdef STACK_register
    752. 

  752.         long STACK_register_contents;
    753. 

  753.       #endif
    754. 

  754.       #ifdef mv_count_register
    755. 

  755.         long mv_count_register_contents;
    756. 

  756.       #endif
    757. 

  757.       #ifdef value1_register
    758. 

  758.         long value1_register_contents;
    759. 

  759.       #endif
    760. 

  760.       #ifdef back_trace_register
    761. 

  761.         long back_trace_register_contents;
    762. 

  762.       #endif
    763. 

  763.     };
    764. 

  764.     extern per_thread struct registers * callback_saved_registers;
    765. 

  765.     #ifdef STACK_register
    766. 

  766.       #define SAVE_STACK_register(registers)     \
    767. 

  767.               registers->STACK_register_contents = STACK_reg
    768. 

  768.       #define RESTORE_STACK_register(registers)  \
    769. 

  769.               STACK_reg = registers->STACK_register_contents
    770. 

  770.     #else
    771. 

  771.       #define SAVE_STACK_register(registers)
    772. 

  772.       #define RESTORE_STACK_register(registers)
    773. 

  773.     #endif
    774. 

  774.     #ifdef mv_count_register
    775. 

  775.       #define SAVE_mv_count_register(registers)     \
    776. 

  776.               registers->mv_count_register_contents = mv_count_reg
    777. 

  777.       #define RESTORE_mv_count_register(registers)  \
    778. 

  778.               mv_count_reg = registers->mv_count_register_contents
    779. 

  779.     #else
    780. 

  780.       #define SAVE_mv_count_register(registers)
    781. 

  781.       #define RESTORE_mv_count_register(registers)
    782. 

  782.     #endif
    783. 

  783.     #ifdef value1_register
    784. 

  784.       #define SAVE_value1_register(registers)     \
    785. 

  785.               registers->value1_register_contents = value1_reg
    786. 

  786.       #define RESTORE_value1_register(registers)  \
    787. 

  787.               value1_reg = registers->value1_register_contents
    788. 

  788.     #else
    789. 

  789.       #define SAVE_value1_register(registers)
    790. 

  790.       #define RESTORE_value1_register(registers)
    791. 

  791.     #endif
    792. 

  792.     #ifdef back_trace_register
    793. 

  793.       #define SAVE_back_trace_register(registers)     \
    794. 

  794.               registers->back_trace_register_contents = back_trace_reg
    795. 

  795.       #define RESTORE_back_trace_register(registers)  \
    796. 

  796.               back_trace_reg = registers->back_trace_register_contents
    797. 

  797.     #else
    798. 

  798.       #define SAVE_back_trace_register(registers)
    799. 

  799.       #define RESTORE_back_trace_register(registers)
    800. 

  800.     #endif
    801. 

  801.     #define SAVE_REGISTERS(inner_statement)                                  \
    802. 

  802.       do {                                                                   \
    803. 

  803.         var struct registers * registers = alloca(sizeof(struct registers)); \
    804. 

  804.         SAVE_STACK_register(registers);                                      \
    805. 

  805.         SAVE_mv_count_register(registers);                                   \
    806. 

  806.         SAVE_value1_register(registers);                                     \
    807. 

  807.         SAVE_back_trace_register(registers);                                 \
    808. 

  808.         inner_statement;                                                     \
    809. 

  809.         { var gcv_object_t* top_of_frame = STACK;                            \
    810. 

  810.           pushSTACK(fake_gcv_object((aint)callback_saved_registers));        \
    811. 

  811.           finish_frame(CALLBACK);                                            \
    812. 

  812.         }                                                                    \
    813. 

  813.         callback_saved_registers = registers;                                \
    814. 

  814.       } while(0)
    815. 

  815.     #define RESTORE_REGISTERS(inner_statement)                                \
    816. 

  816.       do {                                                                    \
    817. 

  817.         var struct registers * registers = callback_saved_registers;          \
    818. 

  818.         if (!(framecode(STACK_0) == CALLBACK_frame_info)) abort();            \
    819. 

  819.         callback_saved_registers = (struct registers *)(aint)as_oint(STACK_1);\
    820. 

  820.         skipSTACK(2);                                                         \
    821. 

  821.         inner_statement;                                                      \
    822. 

  822.         RESTORE_STACK_register(registers);                                    \
    823. 

  823.         RESTORE_mv_count_register(registers);                                 \
    824. 

  824.         RESTORE_value1_register(registers);                                   \
    825. 

  825.         RESTORE_back_trace_register(registers);                               \
    826. 

  826.       } while(0)
    827. 

  827.   #endif
    828. 

  828.   /* Saving the STACK (for asynchronous interrupts).
    829. 

  829.    If STACK is a global variable or lies in a register which is left
    830. 

  830.    untouched by operating system and library (this is the case on SUN4),
    831. 

  831.    we don't need to worry about it. */
    832. 

  832.   #if defined(STACK_register) && !defined(SUN4)
    833. 

  833.     #define HAVE_SAVED_STACK
    834. 

  834.   #endif
    835. 

  835.   /* Saving "used" registers. */
    836. 

  836.   #if defined(mv_count_register) && 0
    837. 

  837.     #define HAVE_SAVED_mv_count
    838. 

  838.   #endif
    839. 

  839.   #if defined(value1_register) && 0
    840. 

  840.     #define HAVE_SAVED_value1
    841. 

  841.   #endif
    842. 

  842.   #if defined(back_trace_register) && defined(SPARC)
    843. 

  843.     #define HAVE_SAVED_back_trace
    844. 

  844.   #endif
    845. 

  845. #endif
    846. 

  846. #ifndef HAVE_SAVED_REGISTERS
    847. 

  847.   #define SAVE_REGISTERS(inner_statement)
    848. 

  848.   #define RESTORE_REGISTERS(inner_statement)
    849. 

  849. #endif
    850. 

  850. %% #ifdef HAVE_SAVED_REGISTERS
    851. 

  851. %%   puts("#ifndef IN_MODULE_CC");
    852. 

  852. %%   #ifdef STACK_register
    853. 

  853. %%     printf("register long STACK_reg __asm__(\"%s\");\n",STACK_register);
    854. 

  854. %%   #endif
    855. 

  855. %%   #ifdef mv_count_register
    856. 

  856. %%     printf("register long mv_count_reg __asm__(\"%s\");\n",mv_count_register);
    857. 

  857. %%   #endif
    858. 

  858. %%   #ifdef value1_register
    859. 

  859. %%     printf("register long value1_reg __asm__(\"%s\");\n",value1_register);
    860. 

  860. %%   #endif
    861. 

  861. %%   #ifdef back_trace_register
    862. 

  862. %%     printf("register long back_trace_reg __asm__(\"%s\");\n",back_trace_register);
    863. 

  863. %%   #endif
    864. 

  864. %%   printf("struct registers { ");
    865. 

  865. %%   #ifdef STACK_register
    866. 

  866. %%     printf("long STACK_register_contents; ");
    867. 

  867. %%   #endif
    868. 

  868. %%   #ifdef mv_count_register
    869. 

  869. %%     printf("long mv_count_register_contents; ");
    870. 

  870. %%   #endif
    871. 

  871. %%   #ifdef value1_register
    872. 

  872. %%     printf("long value1_register_contents; ");
    873. 

  873. %%   #endif
    874. 

  874. %%   #ifdef back_trace_register
    875. 

  875. %%     printf("long back_trace_register_contents; ");
    876. 

  876. %%   #endif
    877. 

  877. %%   puts("};");
    878. 

  878. %%   puts("extern struct registers * callback_saved_registers;");
    879. 

  879. %%   puts("#endif");
    880. 

  880. %% #endif
    881. 

  881. 

  882. #define VALUES_IF(cond)                         \
    883. 

  883.   do { value1 = (cond) ? T : NIL; mv_count = 1; } while (0)
    884. 

  884. %% export_def(VALUES_IF(C));
    885. 

  885. 

  886. #define VALUES0                                 \
    887. 

  887.   do { value1 = NIL; mv_count = 0; } while (0)
    888. 

  888. %% export_def(VALUES0);
    889. 

  889. 

  890. #define VALUES1(A)                               \
    891. 

  891.   do { value1 = (A); mv_count = 1; } while (0)
    892. 

  892. %% export_def(VALUES1(A));
    893. 

  893. 

  894. #define VALUES2(A,B)                            \
    895. 

  895.   do { value1 = (A); value2 = (B); mv_count = 2; } while (0)
    896. 

  896. %% export_def(VALUES2(A,B));
    897. 

  897. 

  898. #define VALUES3(A,B,C)                          \
    899. 

  899.   do { value1 = (A); value2 = (B); value3 = (C); mv_count = 3; } while (0)
    900. 

  900. %% export_def(VALUES3(A,B,C));
    901. 

  901. 

  902. /* ###################### Macros for C #################### */
    903. 

  903. 

  904. #if !defined(return_void)
    905. 

  905.   /* To return a type of value void: return_void(...); */
    906. 

  906.   #ifdef GNU
    907. 

  907.     #define return_void  return /* 'return void;' is admissible */
    908. 

  908.   #else
    909. 

  909.     /* In general it is not legal to return `void' values. */
    910. 

  910.     #define return_void  /* Don't use 'return' for expressions of type 'void'. */
    911. 

  911.   #endif
    912. 

  912. #endif
    913. 

  913. #if defined(GNU) && defined(__GNUG__)
    914. 

  914.   /* Although legal, g++ warns about 'return void;'. Shut up the warning. */
    915. 

  915.   #undef return_void
    916. 

  916.   #define return_void
    917. 

  917. #endif
    918. 

  918. 

  919. #if !defined(GNU) && !defined(inline)
    920. 

  920.   #define inline      /* inline foo() {...} --> foo() {...} */
    921. 

  921. #endif
    922. 

  922. %% puts("#if !defined(__GNUC__) && !defined(inline)");
    923. 

  923. %% puts("#define inline");
    924. 

  924. %% puts("#endif");
    925. 

  925. 

  926. /* Definitions for C++-Compilers: */
    927. 

  927. #ifdef __cplusplus
    928. 

  928.   #define BEGIN_DECLS  extern "C" {
    929. 

  929.   #define END_DECLS    }
    930. 

  930. #else
    931. 

  931.   #define BEGIN_DECLS
    932. 

  932.   #define END_DECLS
    933. 

  933. #endif
    934. 

  934. %% export_def(BEGIN_DECLS);
    935. 

  935. %% export_def(END_DECLS);
    936. 

  936. 

  937. /* Empty macro-arguments:
    938. 

  938.  Some compilers (ie. cc under HP-UX) seem to interpret a macro call
    939. 

  939.  foo(arg1,...,argn,) as equivalent to foo(arg1,...,argn), which will
    940. 

  940.  yield an error. _EMA_ stands for "empty macro argument".
    941. 

  941.  It will be inserted by CC_NEED_DEEMA,
    942. 

  942.  each time between comma and closing parentheses.
    943. 

  943.  It is also needed when potentially empty arguments
    944. 

  944.  are returned to other macros */
    945. 

  945. 

  946. #define _EMA_
    947. 

  947. 

  948. /* Concatenation of two macro-expanded tokens:
    949. 

  949.  Example:
    950. 

  950.    #undef x
    951. 

  951.    #define y 16
    952. 

  952.    CONCAT(x,y)        ==>  'x16' (not 'xy' !) */
    953. 

  953. #define CONCAT_(xxx,yyy)  xxx##yyy
    954. 

  954. #define CONCAT3_(aaa,bbb,ccc)  aaa##bbb##ccc
    955. 

  955. #define CONCAT4_(aaa,bbb,ccc,ddd)  aaa##bbb##ccc##ddd
    956. 

  956. #define CONCAT5_(aaa,bbb,ccc,ddd,eee)  aaa##bbb##ccc##ddd##eee
    957. 

  957. #define CONCAT6_(aaa,bbb,ccc,ddd,eee,fff)  aaa##bbb##ccc##ddd##eee##fff
    958. 

  958. #define CONCAT7_(aaa,bbb,ccc,ddd,eee,fff,ggg)  aaa##bbb##ccc##ddd##eee##fff##ggg
    959. 

  959. #define CONCAT(xxx,yyy)  CONCAT_(xxx,yyy)
    960. 

  960. #define CONCAT3(aaa,bbb,ccc)  CONCAT3_(aaa,bbb,ccc)
    961. 

  961. #define CONCAT4(aaa,bbb,ccc,ddd)  CONCAT4_(aaa,bbb,ccc,ddd)
    962. 

  962. #define CONCAT5(aaa,bbb,ccc,ddd,eee)  CONCAT5_(aaa,bbb,ccc,ddd,eee)
    963. 

  963. #define CONCAT6(aaa,bbb,ccc,ddd,eee,fff)  CONCAT6_(aaa,bbb,ccc,ddd,eee,fff)
    964. 

  964. #define CONCAT7(aaa,bbb,ccc,ddd,eee,fff,ggg)  CONCAT7_(aaa,bbb,ccc,ddd,eee,fff,ggg)
    965. 

  965. %% puts("#define CONCAT_(xxx,yyy)  xxx##yyy");
    966. 

  966. %% puts("#define CONCAT3_(aaa,bbb,ccc)  aaa##bbb##ccc");
    967. 

  967. %% #if notused
    968. 

  968. %% puts("#define CONCAT4_(aaa,bbb,ccc,ddd)  aaa##bbb##ccc##ddd");
    969. 

  969. %% puts("#define CONCAT5_(aaa,bbb,ccc,ddd,eee)  aaa##bbb##ccc##ddd##eee");
    970. 

  970. %% #endif
    971. 

  971. %% puts("#define CONCAT(xxx,yyy)  CONCAT_(xxx,yyy)");
    972. 

  972. %% puts("#define CONCAT3(aaa,bbb,ccc)  CONCAT3_(aaa,bbb,ccc)");
    973. 

  973. %% #if notused
    974. 

  974. %% puts("#define CONCAT4(aaa,bbb,ccc,ddd)  CONCAT4_(aaa,bbb,ccc,ddd)");
    975. 

  975. %% puts("#define CONCAT5(aaa,bbb,ccc,ddd,eee)  CONCAT5_(aaa,bbb,ccc,ddd,eee)");
    976. 

  976. %% #endif
    977. 

  977. 

  978. /* Generation of goto-tag macros:
    979. 

  979.  GENTAG(end)  ==>  end116
    980. 

  980.  This allows a macro defining marks to be used more than once per function
    981. 

  981.  but still only once per source-line. */
    982. 

  982. #define GENTAG(xxx)  CONCAT(xxx,__LINE__)
    983. 

  983. 

  984. /* Converting tokens to strings:
    985. 

  985.  STRING(token)  ==>  "token" */
    986. 

  986. #define STRING(token) #token
    987. 

  987. #define STRINGIFY(token) STRING(token)
    988. 

  988. %% puts("#define STRING(token) #token");
    989. 

  989. %% puts("#define STRINGIFY(token) STRING(token)");
    990. 

  990. 

  991. /* Storage-Class-Specifier in top-level-declarations:
    992. 

  992.  for variables:
    993. 

  993.    global           globally visible variable
    994. 

  994.    local            variable that is only visible in the file (local)
    995. 

  995.    extern           pointer to a variable that's defined externally
    996. 

  996.  for functions:
    997. 

  997.    global           globally visible function
    998. 

  998.    local            function that is only visible in the file (local)
    999. 

  999.    extern           pointer to a function that's defined externally
    1000. 

  1000.    extern_C         pointer to a c-function that's defined externally
    1001. 

  1001.    nonreturning     function that will never return
    1002. 

  1002.    maygc            function that can trigger GC */
    1003. 

  1003. #define global
    1004. 

  1004. #define local  static
    1005. 

  1005. /* #define extern extern */
    1006. 

  1006. #ifdef __cplusplus
    1007. 

  1007.   #define extern_C  extern "C"
    1008. 

  1008. #else
    1009. 

  1009.   #define extern_C  extern
    1010. 

  1010. #endif
    1011. 

  1011. 

  1012. /* Declaration of a function that will never return (nonreturning function)
    1013. 

  1013.  nonreturning_function(extern,abort,(void)); == extern void abort (void); */
    1014. 

  1014. #if defined(GNU) && !(__APPLE_CC__ > 1)
    1015. 

  1015.   #if (__GNUC__ >= 3) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 7))
    1016. 

  1016.     /* Note:
    1017. 

  1017.        storclass __attribute__((__noreturn__)) void funname arguments
    1018. 

  1018.          works in gcc 2.95 or newer, and in g++ 2.7.2 or newer.
    1019. 

  1019.        storclass void __attribute__((__noreturn__)) funname arguments
    1020. 

  1020.          works in gcc 2.7.2 or newer and in g++ 2.7.2 or newer.
    1021. 

  1021.        storclass void funname arguments __attribute__((__noreturn__))
    1022. 

  1022.          works in gcc 2.7.2 or newer and in g++ 2.7.2 or newer, but
    1023. 

  1023.          only when followed by a semicolon, not in a function definition. */
    1024. 

  1024.     #define nonreturning_function(storclass,funname,arguments)  \
    1025. 

  1025.       storclass void __attribute__((__noreturn__)) funname arguments
    1026. 

  1026.   #else
    1027. 

  1027.     #define nonreturning_function(storclass,funname,arguments)  \
    1028. 

  1028.       storclass void funname arguments
    1029. 

  1029.   #endif
    1030. 

  1030. #elif defined(MICROSOFT)
    1031. 

  1031.   #define nonreturning_function(storclass,funname,arguments)  \
    1032. 

  1032.     __declspec(noreturn) storclass void funname arguments
    1033. 

  1033. #else
    1034. 

  1034.   #define nonreturning_function(storclass,funname,arguments)  \
    1035. 

  1035.     storclass void funname arguments
    1036. 

  1036. #endif
    1037. 

  1037. %% export_def(nonreturning_function(storclass,funname,arguments));
    1038. 

  1038. 

  1039. /* A function that can trigger GC is declared either as
    1040. 

  1040.    - maygc, if (1) all callers must assume the worst case: that it triggers GC,
    1041. 

  1041.             and (2) the function uses only the 'object's passed as arguments and
    1042. 

  1042.             on the STACK, but no objects stored in other non-GCsafe locations.
    1043. 

  1043.    - ／＊maygc＊／ otherwise. If (1) is not fulfilled, the functions begins
    1044. 

  1044.                    with an appropriate GCTRIGGER_IF statement. If (2) is not
    1045. 

  1045.                    fulfilled, the GCTRIGGER call needs to mention all other
    1046. 

  1046.                    non-GCsafe locations whose values are used by the function,
    1047. 

  1047.                    such as 'value1' or 'mv_space'. */
    1048. 

  1048. #define maygc
    1049. 

  1049. 

  1050. /* Storage-Class-Specifier in declarations at the beginning of a block:
    1051. 

  1051.  var                       will lead a variable declaration
    1052. 

  1052.  used by utils/varbrace to allow declarations mixed with other statements */
    1053. 

  1053. #define var
    1054. 

  1054. 

  1055. /* Ignore C++ keyword. */
    1056. 

  1056. #define export export_sym
    1057. 

  1057. 

  1058. /* Swap the contents of two variables:  swap(register int, x1, x2); */
    1059. 

  1059. #define swap(swap_type,swap_var1,swap_var2)  \
    1060. 

  1060.   do { var swap_type swap_temp;                                          \
    1061. 

  1061.     swap_temp = swap_var1; swap_var1 = swap_var2; swap_var2 = swap_temp; \
    1062. 

  1062.   } while(0)
    1063. 

  1063. 

  1064. /* Marking a program line that may not be reached: NOTREACHED; */
    1065. 

  1065. #define NOTREACHED  error_notreached(__FILE__,__LINE__)
    1066. 

  1066. %% puts("#define NOTREACHED  error_notreached(__FILE__,__LINE__)");
    1067. 

  1067. 

  1068. /* Asserting an arithmetic expression: ASSERT(expr); */
    1069. 

  1069. #define ASSERT(expr)  do { if (!(expr)) NOTREACHED; } while(0)
    1070. 

  1070. %%  puts("#define ASSERT(expr)  do { if (!(expr)) NOTREACHED; } while(0)");
    1071. 

  1071. 

  1072. /* alloca() */
    1073. 

  1073. #ifdef GNU
    1074. 

  1074.   #define alloca  __builtin_alloca
    1075. 

  1075. #elif defined(MICROSOFT)
    1076. 

  1076.   #include <malloc.h>
    1077. 

  1077.   #define alloca _alloca
    1078. 

  1078. #elif defined(HAVE_ALLOCA_H)
    1079. 

  1079.   #include <alloca.h>
    1080. 

  1080.   #ifndef alloca /* Manche definieren 'alloca' als Macro... */
    1081. 

  1081.     #if !(defined(UNIX_OSF) || defined(UNIX_DEC_ULTRIX))
    1082. 

  1082.       /* OSF/1 V3 declares `alloca' as returning char*, but in OSF/1 V4
    1083. 

  1083.        it returns void*. I don't know how to distinguish the two. */
    1084. 

  1084.       extern_C void* alloca (int size); /* see MALLOC(3V) */
    1085. 

  1085.     #endif
    1086. 

  1086.   #endif
    1087. 

  1087. #elif defined(_AIX)
    1088. 

  1088.   #pragma alloca /* AIX requires this to be the first thing in the file. */
    1089. 

  1089. #elif defined(BORLAND)
    1090. 

  1090.   #include <malloc.h> /* defines  'alloca' as macro */
    1091. 

  1091. #elif !defined(NO_ALLOCA)
    1092. 

  1092.   extern_C void* alloca (int size); /* see MALLOC(3V) */
    1093. 

  1093. #endif
    1094. 

  1094. %% #ifdef GNU
    1095. 

  1095. %%   emit_define("alloca","__builtin_alloca");
    1096. 

  1096. %% #elif defined(MICROSOFT)
    1097. 

  1097. %%   puts("#include <malloc.h>");
    1098. 

  1098. %%   emit_define("alloca","_alloca");
    1099. 

  1099. %% #elif defined(HAVE_ALLOCA_H)
    1100. 

  1100. %%   puts("#include <alloca.h>");
    1101. 

  1101. %%   #ifndef alloca
    1102. 

  1102. %%     #if !(defined(UNIX_OSF) || defined(UNIX_DEC_ULTRIX))
    1103. 

  1103. %%       puts("extern void* alloca (int size);");
    1104. 

  1104. %%     #endif
    1105. 

  1105. %%   #endif
    1106. 

  1106. %% #elif defined(_AIX)
    1107. 

  1107. %%   puts("#pragma alloca");
    1108. 

  1108. %% #elif !defined(NO_ALLOCA)
    1109. 

  1109. %%   puts("extern void* alloca (int size);");
    1110. 

  1110. %% #endif
    1111. 

  1111. 

  1112. #define MALLOC(size,type)   (type*)malloc((size)*sizeof(type))
    1113. 

  1113. 

  1114. /* Literal constants of 64-bit integer types
    1115. 

  1115.  LL(nnnn)  = nnnn parsed as a sint64
    1116. 

  1116.  ULL(nnnn) = nnnn parsed as a uint64 */
    1117. 

  1117. #if defined(HAVE_LONG_LONG_INT)
    1118. 

  1118.   #define LL(nnnn) nnnn##LL
    1119. 

  1119.   #define ULL(nnnn) nnnn##ULL
    1120. 

  1120. #elif defined(MICROSOFT)
    1121. 

  1121.   #define LL(nnnn) nnnn##i64
    1122. 

  1122.   #define ULL(nnnn) nnnn##ui64
    1123. 

  1123. #endif
    1124. 

  1124. %% #if defined(HAVE_LONG_LONG_INT)
    1125. 

  1125. %%   puts("#define LL(nnnn) nnnn##LL");
    1126. 

  1126. %%   puts("#define ULL(nnnn) nnnn##ULL");
    1127. 

  1127. %% #elif defined(MICROSOFT)
    1128. 

  1128. %%   puts("#define LL(nnnn) nnnn##i64");
    1129. 

  1129. %%   puts("#define ULL(nnnn) nnnn##ui64");
    1130. 

  1130. %% #endif
    1131. 

  1131. 

  1132. /* Synonyms for Byte, Word, Longword:
    1133. 

  1133.  SBYTE   = signed 8 bit integer
    1134. 

  1134.  UBYTE   = unsigned 8 bit int
    1135. 

  1135.  SWORD   = signed 16 bit int
    1136. 

  1136.  UWORD   = unsigned 16 bit int
    1137. 

  1137.  SLONG   = signed 32 bit int
    1138. 

  1138.  ULONG   = unsigned 32 bit int
    1139. 

  1139.  On the other hand, "char" is only used as an element of a string
    1140. 

  1140.  You never really compute with a "char"; it might depend on
    1141. 

  1141.  __CHAR_UNSIGNED___! */
    1142. 

  1142. #if (char_bitsize==8)
    1143. 

  1143.   #ifdef __CHAR_UNSIGNED__
    1144. 

  1144.     typedef signed char  SBYTE;
    1145. 

  1145.   #else
    1146. 

  1146.     typedef char         SBYTE;
    1147. 

  1147.   #endif
    1148. 

  1148.   typedef unsigned char  UBYTE;
    1149. 

  1149. #else
    1150. 

  1150.   #error "No 8 bit integer type? -- Which Interger-type has 8 Bit?"
    1151. 

  1151. #endif
    1152. 

  1152. #if (short_bitsize==16)
    1153. 

  1153.   typedef short          SWORD;
    1154. 

  1154.   typedef unsigned short UWORD;
    1155. 

  1155. #else
    1156. 

  1156.   #error "No 16 bit integer type? -- Which Integer-type has 16 Bit?"
    1157. 

  1157. #endif
    1158. 

  1158. #if (long_bitsize==32)
    1159. 

  1159.   typedef long           SLONG;
    1160. 

  1160.   typedef unsigned long  ULONG;
    1161. 

  1161. #elif (int_bitsize==32)
    1162. 

  1162.   typedef int            SLONG;
    1163. 

  1163.   typedef unsigned int   ULONG;
    1164. 

  1164. #else
    1165. 

  1165.   #error "No 32 bit integer type? -- Which Integer-type has 32 Bit?"
    1166. 

  1166. #endif
    1167. 

  1167. #if (long_bitsize==64)
    1168. 

  1168.   typedef long           SLONGLONG;
    1169. 

  1169.   typedef unsigned long  ULONGLONG;
    1170. 

  1170.   #ifndef HAVE_LONG_LONG_INT
    1171. 

  1171.   #define HAVE_LONG_LONG_INT
    1172. 

  1172.   #endif
    1173. 

  1173. #elif defined(MICROSOFT)
    1174. 

  1174.   typedef __int64           SLONGLONG;
    1175. 

  1175.   typedef unsigned __int64  ULONGLONG;
    1176. 

  1176.   #define HAVE_LONG_LONG_INT
    1177. 

  1177. #elif defined(HAVE_LONG_LONG_INT)
    1178. 

  1178.  #if defined(long_long_bitsize) && (long_long_bitsize==64)
    1179. 

  1179.   typedef long long           SLONGLONG;
    1180. 

  1180.   typedef unsigned long long  ULONGLONG;
    1181. 

  1181.  #else /* useless type */
    1182. 

  1182.   #undef HAVE_LONG_LONG_INT
    1183. 

  1183.  #endif
    1184. 

  1184. #endif
    1185. 

  1185. #if defined(WIDE) && !defined(HAVE_LONG_LONG_INT)
    1186. 

  1186.   #error "No 64 bit integer type? -- Which Integer-type has 64 Bit?"
    1187. 

  1187. #endif
    1188. 

  1188. %% #ifdef __CHAR_UNSIGNED__
    1189. 

  1189. %%   emit_typedef("signed char","SBYTE");
    1190. 

  1190. %% #else
    1191. 

  1191. %%   emit_typedef("char","SBYTE");
    1192. 

  1192. %% #endif
    1193. 

  1193. %% emit_typedef("unsigned char","UBYTE");
    1194. 

  1194. %% emit_typedef("short","SWORD");
    1195. 

  1195. %% emit_typedef("unsigned short","UWORD");
    1196. 

  1196. %% #if (long_bitsize==32)
    1197. 

  1197. %%   emit_typedef("long","SLONG");
    1198. 

  1198. %%   emit_typedef("unsigned long","ULONG");
    1199. 

  1199. %% #elif (int_bitsize==32)
    1200. 

  1200. %%   emit_typedef("int","SLONG");
    1201. 

  1201. %%   emit_typedef("unsigned int","ULONG");
    1202. 

  1202. %% #endif
    1203. 

  1203. %% #if (long_bitsize==64)
    1204. 

  1204. %%   emit_typedef("long","SLONGLONG");
    1205. 

  1205. %%   emit_typedef("unsigned long","ULONGLONG");
    1206. 

  1206. %% #elif defined(MICROSOFT)
    1207. 

  1207. %%   emit_typedef("__int64","SLONGLONG");
    1208. 

  1208. %%   emit_typedef("unsigned __int64","ULONGLONG");
    1209. 

  1209. %% #elif defined(HAVE_LONG_LONG_INT)
    1210. 

  1210. %%   emit_typedef("long long","SLONGLONG");
    1211. 

  1211. %%   emit_typedef("unsigned long long","ULONGLONG");
    1212. 

  1212. %% #endif
    1213. 

  1213. 

  1214. #include <stdbool.h>  /* boolean values */
    1215. 

  1215. %% #ifdef HAVE_STDBOOL_H
    1216. 

  1216. %%   puts("#include <stdbool.h>");
    1217. 

  1217. %% #else
    1218. 

  1218. %%   print_file("stdbool.h");
    1219. 

  1219. %% #endif
    1220. 

  1220. 

  1221. /* Type for signed values, results of comparisons, tertiary enums
    1222. 

  1222.  with values +1, 0, -1 */
    1223. 

  1223. typedef signed int  signean;
    1224. 

  1224. #define signean_plus    1 /* +1 */
    1225. 

  1225. #define signean_null    0 /*  0 */
    1226. 

  1226. #define signean_minus  -1 /* -1 */
    1227. 

  1227. 

  1228. /* Null pointers */
    1229. 

  1229. #ifdef __cplusplus
    1230. 

  1230.   #undef NULL
    1231. 

  1231.   #define NULL  0
    1232. 

  1232. #elif !(defined(INTEL) || defined(_AIX))
    1233. 

  1233.   #undef NULL
    1234. 

  1234.   #define NULL  ((void*) 0L)
    1235. 

  1235. #endif
    1236. 

  1236. %% puts("#undef NULL");
    1237. 

  1237. %% export_def(NULL);
    1238. 

  1238. 

  1239. #include <stdio.h>    /* libc i/o */
    1240. 

  1240. 

  1241. /* A more precise classification of the operating system:
    1242. 

  1242.  (This test works only after at least one system header has been included.) */
    1243. 

  1243. #if (__GLIBC__ >= 2)
    1244. 

  1244.   #define UNIX_GNU /* glibc2 (may be UNIX_LINUX, UNIX_HURD or UNIX_FREEBSD) */
    1245. 

  1245. #endif
    1246. 

  1246. 

  1247. /* Determine the offset of a component 'ident' in a struct of the type 'type':
    1248. 

  1248.  See 0 as pointer to 'type', put a struct 'type' there and determine the
    1249. 

  1249.  address of its component 'ident' and return it as number: */
    1250. 

  1250. #if defined(HAVE_OFFSETOF) || defined(__MINGW32__) || (defined(BORLAND) && defined(WIN32)) || defined(MICROSOFT)
    1251. 

  1251.   #include <stddef.h>
    1252. 

  1252. #else
    1253. 

  1253.   #undef offsetof
    1254. 

  1254.   #define o…
    1255.

Large files files are truncated, but you can click here to view the full file