PageRenderTime 51ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 0ms

/src/constobj.d

https://github.com/ynd/clisp-branch--ynd-devel
D | 709 lines | 593 code | 4 blank | 112 comment | 7 complexity | 3028a95fba71440add7be05366465588 MD5 | raw file
Possible License(s): LGPL-2.0, GPL-2.0, BSD-3-Clause 
    

  1. /*
    2. 

  2.  * list of all objects known to the C-program ("program-constants")
    3. 

  3.  * Bruno Haible 1990-2005
    4. 

  4.  * Sam Steingold 1998-2008
    5. 

  5.  * German comments translated into English: Stefan Kain 2002-02-20
    6. 

    7. 

  7.  The symbols are already treated specially in CONSTSYM.
    8. 

  8.  A table of all other objects known to the C-program is maintained here.
    9. 

    10. 

  10.  The macro LISPOBJ declares a LISP object.
    11. 

  11.  LISPOBJ(name,initstring)
    12. 

  12.  > name: object is addressable as object_tab.name or as O(name)
    13. 

  13.  > initstring: initialization-string in LISP syntax */
    14. 

  14. 

  15. /* expander for the declaration of the object-table: */
    16. 

  16. #define LISPOBJ_A(name,initstring)              \
    17. 

  17.     gcv_object_t name;
    18. 

  18. 

  19. /* expander for the initialization of the object-table: */
    20. 

  20. #define LISPOBJ_B(name,initstring)              \
    21. 

  21.     NIL,
    22. 

  22. #define LISPOBJ_C(name,initstring)              \
    23. 

  23.     initstring,
    24. 

  24. 

  25. /* Which expander is used, must be configured by the main file.
    26. 

    27. 

  27.  The macro LISPOBJ_S declares a LISP string.
    28. 

  28.  > name: object is addressable as object_tab.name or as O(name)
    29. 

  29.  > initstring: initialization-string in C-syntax, may not contain
    30. 

  30.                backslashes */
    31. 

  31. #define LISPOBJ_S(name,initstring)              \
    32. 

  32.     LISPOBJ(name,"\"" initstring "\"")
    33. 

  33. 

  34. /* for SPVW.D:
    35. 

  35.    chained list of all active weak-pointers: */
    36. 

  36.   LISPOBJ(all_weakpointers,"0")
    37. 

  37.   /* list of all finalizers: */
    38. 

  38.   LISPOBJ(all_finalizers,"0")
    39. 

  39.   /* During GC: the list of finalizers to be processed after the GC: */
    40. 

  40.   LISPOBJ(pending_finalizers,"0")
    41. 

  41. /* for ENCODING.D:
    42. 

  42.    Encodings for which both the charset and the line-terminator matter:
    43. 

  43.    The default encoding for file streams, pipe streams, socket streams. */
    44. 

  44.   LISPOBJ(default_file_encoding,".")
    45. 

  45.   /* The encoding of the terminal stream. */
    46. 

  46.   LISPOBJ(terminal_encoding,".")
    47. 

  47.   /* Encodings for which only the charset matters: */
    48. 

  48.   #ifdef UNICODE
    49. 

  49.     /* The encoding of the C strings compiled into the executable. */
    50. 

  50.     LISPOBJ(internal_encoding,".")
    51. 

  51.     /* The encoding of pathnames on the file system. */
    52. 

  52.     LISPOBJ(pathname_encoding,".")
    53. 

  53.     #if defined(HAVE_FFI)
    54. 

  54.       /* The encoding of strings passed through the FFI. */
    55. 

  55.       LISPOBJ(foreign_encoding,".")
    56. 

  56.       /* The encoding of characters passed through the FFI.
    57. 

  57.        Must be 1:1, i.e. one of the nls_* encodings. */
    58. 

  58.       LISPOBJ(foreign_8bit_encoding,".")
    59. 

  59.     #endif
    60. 

  60.     /* The encoding for everything else (environment variables, command-line
    61. 

  61.      options etc.) */
    62. 

  62.     LISPOBJ(misc_encoding,".")
    63. 

  63.   #endif
    64. 

  64.   LISPOBJ(type_line_terminator,"(MEMBER :DEFAULT :UNIX :MAC :DOS)")
    65. 

  65.   LISPOBJ(type_input_error_action,"(OR (MEMBER :ERROR :IGNORE) CHARACTER)")
    66. 

  66.   LISPOBJ(type_output_error_action,"(OR (MEMBER :ERROR :IGNORE) CHARACTER (UNSIGNED-BYTE 8))")
    67. 

  67. /* for CHARSTRG.D:
    68. 

  68.    On change of character-names except of CONSTOBJ.D, also
    69. 

  69.    readjust CHARSTRG.D, FORMAT.LISP, IMPNOTES.HTML! */
    70. 

  70.   #ifdef WIN32_CHARNAMES
    71. 

  71.     /* names of characters with codes 0,7,...,13,26,27,32,8,10: */
    72. 

  72.     LISPOBJ(charname_0,"\"Null\"")
    73. 

  73.     LISPOBJ(charname_7,"\"Bell\"")
    74. 

  74.     LISPOBJ(charname_8,"\"Backspace\"")
    75. 

  75.     LISPOBJ(charname_9,"\"Tab\"")
    76. 

  76.     LISPOBJ(charname_10,"\"Newline\"")
    77. 

  77.     LISPOBJ(charname_11,"\"Code11\"")
    78. 

  78.     LISPOBJ(charname_12,"\"Page\"")
    79. 

  79.     LISPOBJ(charname_13,"\"Return\"")
    80. 

  80.     LISPOBJ(charname_26,"\"Code26\"")
    81. 

  81.     LISPOBJ(charname_27,"\"Escape\"")
    82. 

  82.     LISPOBJ(charname_32,"\"Space\"")
    83. 

  83.     LISPOBJ(charname_127,"\"Rubout\"")
    84. 

  84.     LISPOBJ(charname_10bis,"\"Linefeed\"")
    85. 

  85.     LISPOBJ(charname_27bis,"\"Esc\"")
    86. 

  86.   #endif
    87. 

  87.   #ifdef UNIX_CHARNAMES
    88. 

  88.     LISPOBJ(charname_0bis,"\"Null\"")
    89. 

  89.     LISPOBJ(charname_7bis,"\"Bell\"")
    90. 

  90.     LISPOBJ(charname_8bis,"\"Backspace\"")
    91. 

  91.     LISPOBJ(charname_9bis,"\"Tab\"")
    92. 

  92.     LISPOBJ(charname_10bis,"\"Newline\"")
    93. 

  93.     LISPOBJ(charname_10tris,"\"Linefeed\"")
    94. 

  94.     LISPOBJ(charname_12bis,"\"Page\"")
    95. 

  95.     LISPOBJ(charname_13bis,"\"Return\"")
    96. 

  96.     LISPOBJ(charname_27bis,"\"Escape\"")
    97. 

  97.     LISPOBJ(charname_32bis,"\"Space\"")
    98. 

  98.     LISPOBJ(charname_127bis,"\"Rubout\"")
    99. 

  99.     LISPOBJ(charname_127tris,"\"Delete\"")
    100. 

  100.     LISPOBJ(charname_0,"\"Nul\"")
    101. 

  101.     LISPOBJ(charname_1,"\"Soh\"")
    102. 

  102.     LISPOBJ(charname_2,"\"Stx\"")
    103. 

  103.     LISPOBJ(charname_3,"\"Etx\"")
    104. 

  104.     LISPOBJ(charname_4,"\"Eot\"")
    105. 

  105.     LISPOBJ(charname_5,"\"Enq\"")
    106. 

  106.     LISPOBJ(charname_6,"\"Ack\"")
    107. 

  107.     LISPOBJ(charname_7,"\"Bel\"")
    108. 

  108.     LISPOBJ(charname_8,"\"Bs\"")
    109. 

  109.     LISPOBJ(charname_9,"\"Ht\"")
    110. 

  110.     LISPOBJ(charname_10,"\"Nl\"")
    111. 

  111.     LISPOBJ(charname_11,"\"Vt\"")
    112. 

  112.     LISPOBJ(charname_12,"\"Np\"")
    113. 

  113.     LISPOBJ(charname_13,"\"Cr\"")
    114. 

  114.     LISPOBJ(charname_14,"\"So\"")
    115. 

  115.     LISPOBJ(charname_15,"\"Si\"")
    116. 

  116.     LISPOBJ(charname_16,"\"Dle\"")
    117. 

  117.     LISPOBJ(charname_17,"\"Dc1\"")
    118. 

  118.     LISPOBJ(charname_18,"\"Dc2\"")
    119. 

  119.     LISPOBJ(charname_19,"\"Dc3\"")
    120. 

  120.     LISPOBJ(charname_20,"\"Dc4\"")
    121. 

  121.     LISPOBJ(charname_21,"\"Nak\"")
    122. 

  122.     LISPOBJ(charname_22,"\"Syn\"")
    123. 

  123.     LISPOBJ(charname_23,"\"Etb\"")
    124. 

  124.     LISPOBJ(charname_24,"\"Can\"")
    125. 

  125.     LISPOBJ(charname_25,"\"Em\"")
    126. 

  126.     LISPOBJ(charname_26,"\"Sub\"")
    127. 

  127.     LISPOBJ(charname_27,"\"Esc\"")
    128. 

  128.     LISPOBJ(charname_28,"\"Fs\"")
    129. 

  129.     LISPOBJ(charname_29,"\"Gs\"")
    130. 

  130.     LISPOBJ(charname_30,"\"Rs\"")
    131. 

  131.     LISPOBJ(charname_31,"\"Us\"")
    132. 

  132.     LISPOBJ(charname_32,"\"Sp\"")
    133. 

  133.     LISPOBJ(charname_127,"\"Del\"")
    134. 

  134.     /* The proposal to add:
    135. 

  135.       constobj.d (UNIX_CHARNAMES): #\Erik is a synonym for #\Null.
    136. 

  136.       LISPOBJ(charname_0tris,"\"Erik\"") - special "honour" for Mr. Nutgum
    137. 

  137.      has been rejected because of a seriousness attack. */
    138. 

  138.   #endif
    139. 

  139. /* for ARRAY.D: */
    140. 

  140.   LISPOBJ(type_vector_with_fill_pointer,"(AND VECTOR (SATISFIES ARRAY-HAS-FILL-POINTER-P))") /* type for error message */
    141. 

  141. /* for HASHTABL.D: */
    142. 

  142.  #ifdef GENERATIONAL_GC
    143. 

  143.   LISPOBJ(gc_count,"0")
    144. 

  144.  #endif
    145. 

  145.   LISPOBJ(type_eq_hashfunction,"(MEMBER EXT::FASTHASH-EQ EXT::STABLEHASH-EQ)")
    146. 

  146.   LISPOBJ(type_eql_hashfunction,"(MEMBER EXT::FASTHASH-EQL EXT::STABLEHASH-EQL)")
    147. 

  147.   LISPOBJ(type_equal_hashfunction,"(MEMBER EXT::FASTHASH-EQUAL EXT::STABLEHASH-EQUAL)")
    148. 

  148.   LISPOBJ(type_weak_ht,"(MEMBER :KEY :VALUE :KEY-AND-VALUE :KEY-OR-VALUE NIL)")
    149. 

  149. /* for RECORD.D: */
    150. 

  150.   LISPOBJ(constant_initfunction_code,".")
    151. 

  151.   LISPOBJ(endless_loop_code,".")
    152. 

  152. /* for WEAK.D: */
    153. 

  153.   LISPOBJ(type_weak_alist,"(MEMBER :KEY :VALUE :KEY-AND-VALUE :KEY-OR-VALUE)")
    154. 

  154. /* for SEQUENCE.D:
    155. 

  155.    internal list of all defined sequence-types: */
    156. 

  156.   LISPOBJ(seq_types,"NIL")
    157. 

  157.   LISPOBJ(type_recognizable_sequence_type,"(SATISFIES SYSTEM::RECOGNIZABLE-SEQUENCE-TYPE-P)") /* type for error message */
    158. 

  158.   /* keyword-pairs for test_start_end (do not separate pairs!): */
    159. 

  159.   LISPOBJ(kwpair_start,":START")
    160. 

  160.   LISPOBJ(kwpair_end,":END")
    161. 

  161.   LISPOBJ(kwpair_start1,":START1")
    162. 

  162.   LISPOBJ(kwpair_end1,":END1")
    163. 

  163.   LISPOBJ(kwpair_start2,":START2")
    164. 

  164.   LISPOBJ(kwpair_end2,":END2")
    165. 

  165. /* for PREDTYPE.D:
    166. 

  166.    distinctive marks for classes, are filled by CLOS::%DEFCLOS */
    167. 

  167.   LISPOBJ(class_version_standard_class,"#()")
    168. 

  168.   LISPOBJ(class_version_structure_class,"#()")
    169. 

  169.   LISPOBJ(class_version_built_in_class,"#()")
    170. 

  170.   LISPOBJ(class_defined_class,"CLOS::DEFINED-CLASS")
    171. 

  171.   LISPOBJ(class_potential_class,"CLOS::POTENTIAL-CLASS")
    172. 

  172.   /* some built-in-classes, are filled by CLOS::%DEFCLOS */
    173. 

  173.   LISPOBJ(class_array,"ARRAY")           /* ---+ */
    174. 

  174.   LISPOBJ(class_bit_vector,"BIT-VECTOR") /*    |   order */
    175. 

  175.   LISPOBJ(class_character,"CHARACTER")   /*    |   coordinated */
    176. 

  176.   LISPOBJ(class_complex,"COMPLEX")       /*    |   with clos.lisp! */
    177. 

  177.   LISPOBJ(class_cons,"CONS")
    178. 

  178.   LISPOBJ(class_float,"FLOAT")
    179. 

  179.   LISPOBJ(class_function,"FUNCTION")
    180. 

  180.   LISPOBJ(class_hash_table,"HASH-TABLE")
    181. 

  181.   LISPOBJ(class_integer,"INTEGER")
    182. 

  182.   LISPOBJ(class_list,"LIST")
    183. 

  183.   LISPOBJ(class_null,"NULL")
    184. 

  184.   LISPOBJ(class_package,"PACKAGE")
    185. 

  185.   LISPOBJ(class_pathname,"PATHNAME")
    186. 

  186.   #ifdef LOGICAL_PATHNAMES
    187. 

  187.   LISPOBJ(class_logical_pathname,"LOGICAL-PATHNAME")
    188. 

  188.   #endif
    189. 

  189.   LISPOBJ(class_random_state,"RANDOM-STATE")
    190. 

  190.   LISPOBJ(class_ratio,"RATIO")
    191. 

  191.   LISPOBJ(class_readtable,"READTABLE")
    192. 

  192.   LISPOBJ(class_stream,"STREAM")
    193. 

  193.   LISPOBJ(class_file_stream,"FILE-STREAM")
    194. 

  194.   LISPOBJ(class_synonym_stream,"SYNONYM-STREAM")
    195. 

  195.   LISPOBJ(class_broadcast_stream,"BROADCAST-STREAM")
    196. 

  196.   LISPOBJ(class_concatenated_stream,"CONCATENATED-STREAM")
    197. 

  197.   LISPOBJ(class_two_way_stream,"TWO-WAY-STREAM")
    198. 

  198.   LISPOBJ(class_echo_stream,"ECHO-STREAM")
    199. 

  199.   LISPOBJ(class_string_stream,"STRING-STREAM")
    200. 

  200.   LISPOBJ(class_string,"STRING")
    201. 

  201.   LISPOBJ(class_symbol,"SYMBOL")         /*    | */
    202. 

  202.   LISPOBJ(class_t,"T")                   /*    | */
    203. 

  203.   LISPOBJ(class_vector,"VECTOR")         /* ---+ */
    204. 

  204.   LISPOBJ(type_designator_character,"(EXT::DESIGNATOR CHARACTER)")
    205. 

  205.   #if (base_char_code_limit < char_code_limit)
    206. 

  206.   LISPOBJ(type_designator_base_char,"(EXT::DESIGNATOR BASE-CHAR)")
    207. 

  207.   #endif
    208. 

  208.   LISPOBJ(type_designator_function,"(OR FUNCTION SYMBOL (CONS (EQL SETF) (CONS SYMBOL NULL)) (CONS (EQL LAMBDA)))")
    209. 

  209.   /* Upper bound for the number of structure classes present in the system: */
    210. 

  210.   LISPOBJ(structure_class_count_max,"0")
    211. 

  211.   /* Upper bound for the number of standard classes present in the system: */
    212. 

  212.   LISPOBJ(standard_class_count_max,"0")
    213. 

  213.   /* built-in-types for HEAP-STATISTICS */
    214. 

  214.   LISPOBJ(hs_t,"T")                       /* ---+ */
    215. 

  215.   LISPOBJ(hs_cons,"CONS")                 /*    |  order */
    216. 

  216.   LISPOBJ(hs_null,"NULL")                 /*    |  coordinated */
    217. 

  217.   LISPOBJ(hs_symbol,"SYMBOL")             /*    |  with enum_hs_... */
    218. 

  218.   LISPOBJ(hs_simple_bit_vector,"SIMPLE-BIT-VECTOR") /*    |  in predtype.d! */
    219. 

  219.   LISPOBJ(hs_simple_2bit_vector,"EXT::SIMPLE-2BIT-VECTOR")
    220. 

  220.   LISPOBJ(hs_simple_4bit_vector,"EXT::SIMPLE-4BIT-VECTOR")
    221. 

  221.   LISPOBJ(hs_simple_8bit_vector,"EXT::SIMPLE-8BIT-VECTOR")
    222. 

  222.   LISPOBJ(hs_simple_16bit_vector,"EXT::SIMPLE-16BIT-VECTOR")
    223. 

  223.   LISPOBJ(hs_simple_32bit_vector,"EXT::SIMPLE-32BIT-VECTOR")
    224. 

  224.   LISPOBJ(hs_simple_nilvector,"EXT::SIMPLE-NIL-VECTOR")
    225. 

  225.   LISPOBJ(hs_simple_string,"SIMPLE-STRING")
    226. 

  226.   LISPOBJ(hs_simple_vector,"SIMPLE-VECTOR")
    227. 

  227.   LISPOBJ(hs_bit_vector,"BIT-VECTOR")
    228. 

  228.   LISPOBJ(hs_2bit_vector,"EXT::2BIT-VECTOR")
    229. 

  229.   LISPOBJ(hs_4bit_vector,"EXT::4BIT-VECTOR")
    230. 

  230.   LISPOBJ(hs_8bit_vector,"EXT::8BIT-VECTOR")
    231. 

  231.   LISPOBJ(hs_16bit_vector,"EXT::16BIT-VECTOR")
    232. 

  232.   LISPOBJ(hs_32bit_vector,"EXT::32BIT-VECTOR")
    233. 

  233.   LISPOBJ(hs_nilvector,"EXT::NIL-VECTOR")
    234. 

  234.   LISPOBJ(hs_string,"STRING")
    235. 

  235.   LISPOBJ(hs_vector,"VECTOR")
    236. 

  236.   LISPOBJ(hs_simple_array,"SIMPLE-ARRAY")
    237. 

  237.   LISPOBJ(hs_array,"ARRAY")
    238. 

  238.   LISPOBJ(hs_function,"FUNCTION")
    239. 

  239.   LISPOBJ(hs_file_stream,"FILE-STREAM")
    240. 

  240.   LISPOBJ(hs_synonym_stream,"SYNONYM-STREAM")
    241. 

  241.   LISPOBJ(hs_broadcast_stream,"BROADCAST-STREAM")
    242. 

  242.   LISPOBJ(hs_concatenated_stream,"CONCATENATED-STREAM")
    243. 

  243.   LISPOBJ(hs_two_way_stream,"TWO-WAY-STREAM")
    244. 

  244.   LISPOBJ(hs_echo_stream,"ECHO-STREAM")
    245. 

  245.   LISPOBJ(hs_string_stream,"STRING-STREAM")
    246. 

  246.   LISPOBJ(hs_stream,"STREAM")
    247. 

  247.   LISPOBJ(hs_hash_table,"HASH-TABLE")
    248. 

  248.   LISPOBJ(hs_package,"PACKAGE")
    249. 

  249.   LISPOBJ(hs_readtable,"READTABLE")
    250. 

  250.   LISPOBJ(hs_pathname,"PATHNAME")
    251. 

  251.   #ifdef LOGICAL_PATHNAMES
    252. 

  252.   LISPOBJ(hs_logical_pathname,"LOGICAL-PATHNAME")
    253. 

  253.   #endif
    254. 

  254.   LISPOBJ(hs_random_state,"RANDOM-STATE")
    255. 

  255.   LISPOBJ(hs_byte,"BYTE")
    256. 

  256.   LISPOBJ(hs_special_operator,"EXT::SPECIAL-OPERATOR")
    257. 

  257.   LISPOBJ(hs_load_time_eval,"EXT::LOAD-TIME-EVAL")
    258. 

  258.   LISPOBJ(hs_symbol_macro,"EXT::SYMBOL-MACRO")
    259. 

  259.   LISPOBJ(hs_global_symbol_macro,"EXT::GLOBAL-SYMBOL-MACRO")
    260. 

  260.   LISPOBJ(hs_macro,"SYS::MACRO")
    261. 

  261.   LISPOBJ(hs_function_macro,"EXT::FUNCTION-MACRO")
    262. 

  262.   LISPOBJ(hs_big_read_label,"SYS::READ-LABEL")
    263. 

  263.   LISPOBJ(hs_encoding,"EXT::ENCODING")
    264. 

  264.   #ifdef FOREIGN
    265. 

  265.   LISPOBJ(hs_foreign_pointer,"EXT::FOREIGN-POINTER")
    266. 

  266.   #endif
    267. 

  267.   #ifdef DYNAMIC_FFI
    268. 

  268.   LISPOBJ(hs_foreign_address,"FFI::FOREIGN-ADDRESS")
    269. 

  269.   LISPOBJ(hs_foreign_variable,"FFI::FOREIGN-VARIABLE")
    270. 

  270.   LISPOBJ(hs_foreign_function,"FFI::FOREIGN-FUNCTION")
    271. 

  271.   #endif
    272. 

  272.   #ifdef HAVE_SMALL_SSTRING
    273. 

  273.   LISPOBJ(hs_realloc_simple_string,"EXT::FORWARD-POINTER-SIMPLE-STRING")
    274. 

  274.   #endif
    275. 

  275.   LISPOBJ(hs_realloc_instance,"EXT::FORWARD-POINTER-INSTANCE")
    276. 

  276.   LISPOBJ(hs_weakpointer,"EXT::WEAK-POINTER")
    277. 

  277.   LISPOBJ(hs_weak_list,"EXT::WEAK-LIST")
    278. 

  278.   LISPOBJ(hs_weak_alist,"EXT::WEAK-ALIST")
    279. 

  279.   LISPOBJ(hs_weakmapping,"EXT::WEAK-MAPPING")
    280. 

  280.   LISPOBJ(hs_finalizer,"EXT::FINALIZER")
    281. 

  281.   #ifdef SOCKET_STREAMS
    282. 

  282.   LISPOBJ(hs_socket_server,"SOCKET::SOCKET-SERVER")
    283. 

  283.   #endif
    284. 

  284.   #ifdef YET_ANOTHER_RECORD
    285. 

  285.   LISPOBJ(hs_yetanother,"SYS::YETANOTHER")
    286. 

  286.   #endif
    287. 

  287.   LISPOBJ(hs_internal_weak_list,"SYS::INTERNAL-WEAK-LIST")
    288. 

  288.   LISPOBJ(hs_weak_and_relation,"EXT::WEAK-AND-RELATION")
    289. 

  289.   LISPOBJ(hs_weak_or_relation,"EXT::WEAK-OR-RELATION")
    290. 

  290.   LISPOBJ(hs_weak_and_mapping,"EXT::WEAK-AND-MAPPING")
    291. 

  291.   LISPOBJ(hs_weak_or_mapping,"EXT::WEAK-OR-MAPPING")
    292. 

  292.   LISPOBJ(hs_internal_weak_alist,"SYS::INTERNAL-WEAK-ALIST")
    293. 

  293.   LISPOBJ(hs_internal_weak_hashed_alist,"SYS::INTERNAL-WEAK-HASHED-ALIST")
    294. 

  294.   LISPOBJ(hs_system_function,"EXT::SYSTEM-FUNCTION")
    295. 

  295.   LISPOBJ(hs_bignum,"BIGNUM")
    296. 

  296.   LISPOBJ(hs_ratio,"RATIO")
    297. 

  297.   #ifndef IMMEDIATE_FFLOAT
    298. 

  298.   LISPOBJ(hs_single_float,"SINGLE-FLOAT")
    299. 

  299.   #endif                                  /*    | */
    300. 

  300.   LISPOBJ(hs_double_float,"DOUBLE-FLOAT") /*    | */
    301. 

  301.   LISPOBJ(hs_long_float,"LONG-FLOAT")     /*    | */
    302. 

  302.   LISPOBJ(hs_complex,"COMPLEX")           /* ---+ */
    303. 

  303.   LISPOBJ(gc_statistics_list,"NIL")
    304. 

  304. /* for PACKAGE.D:
    305. 

  305.    internal list of all packages: */
    306. 

  306.   LISPOBJ(all_packages,".")
    307. 

  307.   /* the keyword-package: */
    308. 

  308.   LISPOBJ(keyword_package,".")
    309. 

  309.   /* the charset-package: */
    310. 

  310.   LISPOBJ(charset_package,".")
    311. 

  311.   /* the default-package for *PACKAGE*: */
    312. 

  312.   LISPOBJ(default_package,".")
    313. 

  313.   /* default-use-list: */
    314. 

  314.   LISPOBJ(use_default,"(\"COMMON-LISP\")")
    315. 

  315.   /* default-package for -modern: */
    316. 

  316.   LISPOBJ(modern_user_package,".")
    317. 

  317. /* for SYMBOL.D: */
    318. 

  318.   LISPOBJ(gensym_prefix,"\"G\"") /* prefix for gensym, a string */
    319. 

  319. /* for MISC.D:
    320. 

  320.    basic knowledge: */
    321. 

  321.   LISPOBJ_S(lisp_implementation_type_string,"CLISP")
    322. 

  322.   LISPOBJ_S(lisp_implementation_package_version,PACKAGE_VERSION)
    323. 

  323.   /* we want here the _LINK_ time, but I have no idea about how to get it */
    324. 

  324. #ifdef __DATE__
    325. 

  325.   LISPOBJ_S(lisp_implementation_version_built_string,__DATE__ __TIME__)
    326. 

  326. #else
    327. 

  327.   LISPOBJ(lisp_implementation_version_built_string,"NIL")
    328. 

  328. #endif
    329. 

  329.   LISPOBJ(lisp_implementation_version_string,"NIL") /* cache */
    330. 

  330.   LISPOBJ(memory_image_timestamp,"NIL") /* the dump date of the current image */
    331. 

  331.   LISPOBJ(memory_image_host,"NIL") /* the host on which this image was dumped */
    332. 

  332.   /* The date of the last change of the bytecode interpreter
    333. 

  333.      or the arglist of any built-in function in FUNTAB or FUNTABR */
    334. 

  334.   /* when changing, remove legacy ABI! */
    335. 

  335.   LISPOBJ(version,"(20080310)")
    336. 

  336. #ifdef MACHINE_KNOWN
    337. 

  337.   LISPOBJ(machine_type_string,"NIL")
    338. 

  338.   LISPOBJ(machine_version_string,"NIL")
    339. 

  339.   LISPOBJ(machine_instance_string,"NIL")
    340. 

  340. #endif
    341. 

  341.   LISPOBJ(software_type,"NIL")  /* initialized later */
    342. 

  342.  #if defined(GNU)
    343. 

  343.   LISPOBJ_S(c_compiler_version,__VERSION__)
    344. 

  344.  #endif
    345. 

  345.   LISPOBJ(argv,"NIL")
    346. 

  346. /* for I18N.D: */
    347. 

  347.   LISPOBJ(current_language,".")
    348. 

  348.   LISPOBJ(ansi,"NIL")
    349. 

  349. /* for TIME.D: */
    350. 

  350.  #ifdef TIME_RELATIVE
    351. 

  351.   /* start-universal-time: */
    352. 

  352.   LISPOBJ(start_UT,"NIL")
    353. 

  353.  #endif
    354. 

  354. /* for ERROR.D:
    355. 

  355.    error-message-startstring: */
    356. 

  356.   LISPOBJ_S(error_string1,"*** - ")
    357. 

  357.   /* vector with conditions and simple-conditions: */
    358. 

  358.   LISPOBJ(error_types,"#()")
    359. 

  359.   /* for errors of type TYPE-ERROR: */
    360. 

  360.   LISPOBJ(type_function_name,"(OR SYMBOL (CONS (EQL SETF) (CONS SYMBOL NULL)))")
    361. 

  361.   /* the following 8 object order should be in sync with error.d:prepare_c_integer_signal() */
    362. 

  362.   LISPOBJ(type_uint8,"(INTEGER 0 255)")    /* or "(UNSIGNED-BYTE 8)" */
    363. 

  363.   LISPOBJ(type_sint8,"(INTEGER -128 127)") /* or "(SIGNED-BYTE 8)" */
    364. 

  364.   LISPOBJ(type_uint16,"(INTEGER 0 65535)") /* or "(UNSIGNED-BYTE 16)" */
    365. 

  365.   LISPOBJ(type_sint16,"(INTEGER -32768 32767)") /* or "(SIGNED-BYTE 16)" */
    366. 

  366.   LISPOBJ(type_uint32,"(INTEGER 0 4294967295)") /* or "(UNSIGNED-BYTE 32)" */
    367. 

  367.   LISPOBJ(type_sint32,"(INTEGER -2147483648 2147483647)") /* or "(SIGNED-BYTE 32)" */
    368. 

  368.   LISPOBJ(type_uint64,"(INTEGER 0 18446744073709551615)") /* or "(UNSIGNED-BYTE 64)" */
    369. 

  369.   LISPOBJ(type_sint64,"(INTEGER -9223372036854775808 9223372036854775807)") /* or "(SIGNED-BYTE 64)" */
    370. 

  370.   LISPOBJ(type_array_index,"(INTEGER 0 (#.ARRAY-DIMENSION-LIMIT))")
    371. 

  371.   LISPOBJ(type_array_length,"(INTEGER 0 #.ARRAY-DIMENSION-LIMIT)")
    372. 

  372.   LISPOBJ(type_array_bit,"(ARRAY BIT)")
    373. 

  373.   LISPOBJ(type_posfixnum,"(INTEGER 0 #.MOST-POSITIVE-FIXNUM)")
    374. 

  374.   LISPOBJ(type_negfixnum,"(INTEGER #.MOST-NEGATIVE-FIXNUM (0))")
    375. 

  375.   LISPOBJ(type_posbignum,"(INTEGER (#.MOST-POSITIVE-FIXNUM))")
    376. 

  376.   LISPOBJ(type_negbignum,"(INTEGER * (#.MOST-NEGATIVE-FIXNUM))")
    377. 

  377.   LISPOBJ(type_posfixnum1,"(INTEGER (0) #.MOST-POSITIVE-FIXNUM)")
    378. 

  378.   LISPOBJ(type_array_rank,"(INTEGER 0 (#.ARRAY-RANK-LIMIT))")
    379. 

  379.   LISPOBJ(type_radix,"(INTEGER 2 36)")
    380. 

  380.   LISPOBJ(type_end_index,"(OR NULL INTEGER)")
    381. 

  381.   LISPOBJ(type_posinteger,"(INTEGER 0 *)")
    382. 

  382.   LISPOBJ(type_stringsymchar,"(OR STRING SYMBOL CHARACTER)")
    383. 

  383.   LISPOBJ(type_proper_list,"(SATISFIES EXT::PROPER-LIST-P)")
    384. 

  384.   LISPOBJ(type_svector2,"(SIMPLE-VECTOR 2)")
    385. 

  385.   LISPOBJ(type_svector5,"(SIMPLE-VECTOR 5)")
    386. 

  386.   LISPOBJ(type_climb_mode,"(INTEGER 1 5)")
    387. 

  387.   LISPOBJ(type_hashtable_test,"(MEMBER EQ EQL EQUAL EQUALP #.#'EQ #.#'EQL #.#'EQUAL #.#'EQUALP)")
    388. 

  388.   LISPOBJ(type_hashtable_size,"(INTEGER 0 #.(ASH MOST-POSITIVE-FIXNUM -1))")
    389. 

  389.   LISPOBJ(type_hashtable_rehash_size,"(OR (INTEGER 1 *) (FLOAT (1.0) *))")
    390. 

  390.   LISPOBJ(type_hashtable_rehash_threshold,"(REAL 0 1)")
    391. 

  391.   LISPOBJ(type_boole,"(INTEGER 0 15)")
    392. 

  392.   LISPOBJ(type_not_digit,"(AND CHARACTER (NOT (SATISFIES DIGIT-CHAR-P)))")
    393. 

  393.   LISPOBJ(type_rtcase,"(MEMBER :UPCASE :DOWNCASE :PRESERVE :INVERT)")
    394. 

  394.   LISPOBJ(type_peektype,"(OR BOOLEAN CHARACTER)")
    395. 

  395.   LISPOBJ(type_printcase,"(MEMBER :UPCASE :DOWNCASE :CAPITALIZE)")
    396. 

  396.   LISPOBJ(type_pprint_newline,"(MEMBER :LINEAR :FILL :MISER :MANDATORY)")
    397. 

  397.   LISPOBJ(type_pprint_indent,"(MEMBER :BLOCK :CURRENT)")
    398. 

  398.   LISPOBJ(type_random_arg,"(OR (INTEGER (0) *) (FLOAT (0.0) *))")
    399. 

  399.   LISPOBJ(type_packname,"(OR PACKAGE STRING SYMBOL CHARACTER)")
    400. 

  400.   LISPOBJ(type_posint16,"(INTEGER (0) (65536))")
    401. 

  401.   LISPOBJ(type_string_integer,"(OR STRING INTEGER)")
    402. 

  402.   LISPOBJ(type_stringsize,"(INTEGER 0 (#.SYS::STRING-DIMENSION-LIMIT))")
    403. 

  403.   LISPOBJ(type_uint8_vector,"(ARRAY (UNSIGNED-BYTE 8) (*))")
    404. 

  404.   LISPOBJ(type_position,"(OR (MEMBER :START :END) (INTEGER 0 4294967295))")
    405. 

  405.  #if HAS_HOST || defined(LOGICAL_PATHNAMES)
    406. 

  406.   LISPOBJ(type_host,"(OR NULL STRING)")
    407. 

  407.  #endif
    408. 

  408.   LISPOBJ(type_version,"(OR (MEMBER NIL :WILD :NEWEST) (INTEGER (0) #.MOST-POSITIVE-FIXNUM) PATHNAME)")
    409. 

  409.   LISPOBJ(type_direction,"(MEMBER :INPUT :INPUT-IMMUTABLE :OUTPUT :IO :PROBE)")
    410. 

  410.   LISPOBJ(type_if_exists,"(MEMBER :ERROR :NEW-VERSION :RENAME :RENAME-AND-DELETE :OVERWRITE :APPEND :SUPERSEDE NIL)")
    411. 

  411.   LISPOBJ(type_if_does_not_exist,"(MEMBER :ERROR :CREATE NIL)")
    412. 

  412.   LISPOBJ(type_directory_not_exist,"(MEMBER :DISCARD :ERROR :KEEP :IGNORE)")
    413. 

  413.   LISPOBJ(type_external_format,"(OR (MEMBER :DEFAULT) EXT::ENCODING (MEMBER :UNIX :MAC :DOS))")
    414. 

  414.   LISPOBJ(type_pathname_field_key,"(MEMBER :HOST :DEVICE :DIRECTORY :NAME :TYPE :VERSION NIL)")
    415. 

  415.  #ifdef SOCKET_STREAMS
    416. 

  416.   LISPOBJ(type_socket_option,"(MEMBER :SO-DEBUG : SO-ACCEPTCONN :SO-BROADCAST :SO-REUSEADDR :SO-DONTROUTE :SO-KEEPALIVE :SO-ERROR :SO-LINGER :SO-OOBINLINE :SO-TYPE :SO-RCVBUF :SO-SNDBUF :SO-RCVLOWAT :SO-SNDLOWAT :SO-RCVTIMEO :SO-SNDTIMEO)")
    417. 

  417.  #endif
    418. 

  418.  #ifdef LOGICAL_PATHNAMES
    419. 

  419.   LISPOBJ(type_logical_pathname,"(OR LOGICAL-PATHNAME STRING STREAM SYMBOL)")
    420. 

  420.  #endif
    421. 

  421.   LISPOBJ(type_builtin_stream,"(SATISFIES SYSTEM::BUILT-IN-STREAM-P)")
    422. 

  422. /* for PATHNAME.D: */
    423. 

  423.   LISPOBJ(lib_dir,"NIL")     /* must be set via a command line option */
    424. 

  424.   LISPOBJ(type_designator_pathname,"(OR STRING FILE-STREAM PATHNAME)")
    425. 

  425.  #if defined(UNIX) || defined (WIN32_NATIVE)
    426. 

  426.   LISPOBJ(type_priority,"(OR (MEMBER :HIGH :NORMAL :LOW) INTEGER)")
    427. 

  427.  #endif
    428. 

  428.  #ifdef LOGICAL_PATHNAMES
    429. 

  429.   LISPOBJ(empty_logical_pathname,".") /* (already initialized) */
    430. 

  430.   LISPOBJ(handler_for_parse_error,"(#(PARSE-ERROR NIL))")
    431. 

  431.   LISPOBJ(type_logical_pathname_string,"(AND STRING (SATISFIES SYSTEM::VALID-LOGICAL-PATHNAME-STRING-P))")
    432. 

  432.   LISPOBJ(default_logical_pathname_host,"\"SYS\"")
    433. 

  433.  #endif
    434. 

  434.   LISPOBJ_S(empty_string,"")
    435. 

  435.   LISPOBJ_S(wild_string,"*")
    436. 

  436.   LISPOBJ_S(colon_string,":")
    437. 

  437.   LISPOBJ_S(semicolon_string,";")
    438. 

  438.  #ifdef PATHNAME_WIN32
    439. 

  439.   LISPOBJ(backslash_string,"\"\\\\\"")
    440. 

  440.  #endif
    441. 

  441.  #if defined(PATHNAME_WIN32)
    442. 

  442.   LISPOBJ(backslashbackslash_string,"\"\\\\\\\\\"")
    443. 

  443.   LISPOBJ_S(lnk_string,"lnk") /* for woe32 shell link resolution */
    444. 

  444.  #endif
    445. 

  445.  #if defined(PATHNAME_UNIX)
    446. 

  446.   LISPOBJ_S(slash_string,"/")
    447. 

  447.  #endif
    448. 

  448.   LISPOBJ_S(dot_string,".")
    449. 

  449.  #if defined(PATHNAME_WIN32) || defined(PATHNAME_UNIX)
    450. 

  450.   LISPOBJ_S(dotdot_string,"..")
    451. 

  451.   LISPOBJ_S(dotdotdot_string,"...")
    452. 

  452.  #endif
    453. 

  453.  #ifdef PATHNAME_WIN32
    454. 

  454.   LISPOBJ_S(backupextend_string,".bak") /* name-extension of backupfiles */
    455. 

  455.  #endif
    456. 

  456.  #ifdef PATHNAME_UNIX
    457. 

  457.   LISPOBJ_S(backupextend_string,"%") /* name-extension of backupfiles */
    458. 

  458.  #endif
    459. 

  459.  #ifdef PATHNAME_WIN32
    460. 

  460.   /* default-drive (as string of length 1): */
    461. 

  461.   LISPOBJ(default_drive,"NIL")
    462. 

  462.  #endif
    463. 

  463.  #if defined(PATHNAME_UNIX) || defined(PATHNAME_WIN32)
    464. 

  464.   LISPOBJ_S(wildwild_string,"**")
    465. 

  465.   LISPOBJ(directory_absolute,"(:ABSOLUTE)") /* directory of the empty absolute pathname */
    466. 

  466.  #endif
    467. 

  467.  #ifdef USER_HOMEDIR
    468. 

  468.   LISPOBJ(user_homedir,"#\".\"") /* user-homedir-pathname */
    469. 

  469.  #endif
    470. 

  470.  #ifdef HAVE_SHELL
    471. 

  471.  #ifdef UNIX
    472. 

  472.   LISPOBJ(command_shell,"\""SHELL"\"") /* command-shell as string */
    473. 

  473.   LISPOBJ(command_shell_option,"\"-c\"") /* command-shell-option for command */
    474. 

  474.   LISPOBJ(user_shell,"\"/bin/csh\"")     /* user-shell as string */
    475. 

  475.  #endif
    476. 

  476.  #ifdef WIN32_NATIVE
    477. 

  477.   LISPOBJ(command_shell,"NIL")  /* command-interpreter as string */
    478. 

  478.  #endif
    479. 

  479.  #endif
    480. 

  480.   /* list of all open channel-streams, terminal-streams: */
    481. 

  481.   LISPOBJ(open_files,"NIL")
    482. 

  482.  #ifdef GC_CLOSES_FILES
    483. 

  483.   /* During the GC: the list of file-streams to be closed after the GC: */
    484. 

  484.   LISPOBJ(files_to_close,"NIL")
    485. 

  485.  #endif
    486. 

  486.   /* defaults for COMPILE-FILE-call in SPVW: */
    487. 

  487.   LISPOBJ(source_file_type,"#\".lisp\"")
    488. 

  488.   LISPOBJ(compiled_file_type,"#\".fas\"")
    489. 

  489.   LISPOBJ(listing_file_type,"#\".lis\"")
    490. 

  490. /* for STREAM.D: */
    491. 

  491.   #if defined(SPVW_PURE) || ((((STACK_ADDRESS_RANGE << addr_shift) >> garcol_bit_o) & 1) != 0)
    492. 

  492.   LISPOBJ(dynamic_8bit_vector,"NIL") /* cache for macro DYNAMIC_8BIT_VECTOR */
    493. 

  493.   LISPOBJ(dynamic_string,"NIL") /* cache for macro DYNAMIC_STRING */
    494. 

  494.   #endif
    495. 

  495.   LISPOBJ(class_fundamental_stream,"NIL") /* #<STANDARD-CLASS FUNDAMENTAL-STREAM> */
    496. 

  496.   LISPOBJ(class_fundamental_input_stream,"NIL") /* #<STANDARD-CLASS FUNDAMENTAL-INPUT-STREAM> */
    497. 

  497.   LISPOBJ(class_fundamental_output_stream,"NIL") /* #<STANDARD-CLASS FUNDAMENTAL-OUTPUT-STREAM> */
    498. 

  498.   LISPOBJ(type_input_stream,"(SATISFIES INPUT-STREAM-P)") /* type for error-message */
    499. 

  499.   LISPOBJ(type_output_stream,"(SATISFIES OUTPUT-STREAM-P)") /* type for error-message */
    500. 

  500.   LISPOBJ(type_string_with_fill_pointer,"(AND STRING (SATISFIES ARRAY-HAS-FILL-POINTER-P))") /* type for error-message */
    501. 

  501. #if defined(GNU_READLINE)
    502. 

  502.   LISPOBJ(handler_for_charset_type_error,"(#(SYSTEM::CHARSET-TYPE-ERROR NIL))")
    503. 

  503. #endif
    504. 

  504.   LISPOBJ(setf_stream_element_type,"(SETF STREAM-ELEMENT-TYPE)")
    505. 

  505.   LISPOBJ(type_endianness,"(MEMBER :LITTLE :BIG)") /* type for error-message */
    506. 

  506.   LISPOBJ(type_open_file_stream,"(AND FILE-STREAM (SATISFIES OPEN-STREAM-P))") /* type for error-message */
    507. 

  507.   LISPOBJ(strmtype_ubyte8,"(UNSIGNED-BYTE 8)") /* as stream-element-type */
    508. 

  508.   LISPOBJ(standard_input_file_stream,"NIL")
    509. 

  509.   LISPOBJ(standard_output_file_stream,"NIL")
    510. 

  510.   LISPOBJ(standard_error_file_stream,"NIL")
    511. 

  511. /* for IO.D:
    512. 

  512.    four readtable-case-values: */
    513. 

  513.   LISPOBJ(rtcase_0,":UPCASE")
    514. 

  514.   LISPOBJ(rtcase_1,":DOWNCASE")
    515. 

  515.   LISPOBJ(rtcase_2,":PRESERVE")
    516. 

  516.   LISPOBJ(rtcase_3,":INVERT")
    517. 

  517.  /* for reader:
    518. 

  518.    standard-readtable of Common Lisp */
    519. 

  519.   LISPOBJ(standard_readtable,".")
    520. 

  520.   /* prototype of the dispatch-reader-functions */
    521. 

  521.   LISPOBJ(dispatch_reader,"NIL")
    522. 

  522.   LISPOBJ(dispatch_reader_index,"0")
    523. 

  523.   /* prefix for character-names: */
    524. 

  524.   LISPOBJ(charname_prefix,"\"Code\"")
    525. 

  525.   /* internal variables of the reader: */
    526. 

  526.   LISPOBJ(token_buff_1,".")
    527. 

  527.   LISPOBJ(token_buff_2,".")
    528. 

  528.   LISPOBJ(displaced_string,".")
    529. 

  529.   /* handler-types: */
    530. 

  530.   LISPOBJ(handler_for_arithmetic_error,"(#(ARITHMETIC-ERROR NIL))")
    531. 

  531.   LISPOBJ_S(tildeA,"~A")
    532. 

  532.  /* for printer:
    533. 

  533.    substrings used for output of objects: */
    534. 

  534.   LISPOBJ_S(printstring_array,"ARRAY")
    535. 

  535.   LISPOBJ_S(printstring_fill_pointer,"FILL-POINTER=")
    536. 

  536.   LISPOBJ_S(printstring_address,"ADDRESS")
    537. 

  537.   LISPOBJ_S(printstring_system,"SYSTEM-POINTER")
    538. 

  538.   LISPOBJ_S(printstring_frame_pointer,"FRAME-POINTER")
    539. 

  539.   LISPOBJ_S(printstring_read_label,"READ-LABEL")
    540. 

  540.   LISPOBJ_S(printstring_unbound,"#<UNBOUND>")
    541. 

  541.   LISPOBJ_S(printstring_unbound_readably,"#.(SYS::%UNBOUND)")
    542. 

  542.   LISPOBJ_S(printstring_special_reference,"#<SPECIAL REFERENCE>")
    543. 

  543.   LISPOBJ_S(printstring_disabled_pointer,"#<DISABLED POINTER>")
    544. 

  544.   LISPOBJ_S(printstring_dot,"#<DOT>")
    545. 

  545.   LISPOBJ_S(printstring_eof,"#<END OF FILE>")
    546. 

  546.   LISPOBJ_S(printstring_deleted,"DELETED ")
    547. 

  547.   LISPOBJ_S(printstring_package,"PACKAGE")
    548. 

  548.   LISPOBJ_S(printstring_readtable,"READTABLE")
    549. 

  549.   LISPOBJ(pathname_slotlist,"#.(list (cons :HOST #'pathname-host) (cons :DEVICE #'pathname-device) (cons :DIRECTORY #'pathname-directory) (cons :NAME #'pathname-name) (cons :TYPE #'pathname-type) (cons :VERSION #'pathname-version))")
    550. 

  550.   LISPOBJ(byte_slotlist,"#.(list (cons :SIZE #'byte-size) (cons :POSITION #'byte-position))")
    551. 

  551.   LISPOBJ_S(printstring_symbolmacro,"SYMBOL-MACRO")
    552. 

  552.   LISPOBJ_S(printstring_globalsymbolmacro,"GLOBAL SYMBOL-MACRO")
    553. 

  553.   LISPOBJ_S(printstring_macro,"MACRO")
    554. 

  554.   LISPOBJ_S(printstring_functionmacro,"FUNCTION-MACRO")
    555. 

  555.   LISPOBJ_S(printstring_encoding,"ENCODING")
    556. 

  556.   #ifdef FOREIGN
    557. 

  557.   LISPOBJ_S(printstring_invalid,"INVALID ")
    558. 

  558.   LISPOBJ_S(printstring_fpointer,"FOREIGN-POINTER")
    559. 

  559.   #endif
    560. 

  560.   #ifdef DYNAMIC_FFI
    561. 

  561.   LISPOBJ_S(printstring_faddress,"FOREIGN-ADDRESS")
    562. 

  562.   LISPOBJ_S(printstring_fvariable,"FOREIGN-VARIABLE")
    563. 

  563.   LISPOBJ_S(printstring_ffunction,"FOREIGN-FUNCTION")
    564. 

  564.   #endif
    565. 

  565.   LISPOBJ_S(printstring_weakpointer,"WEAK-POINTER")
    566. 

  566.   LISPOBJ_S(printstring_broken_weakpointer,"#<BROKEN WEAK-POINTER>")
    567. 

  567.   LISPOBJ_S(printstring_weak_list,"WEAK-LIST")
    568. 

  568.   LISPOBJ_S(printstring_weak_alist,"WEAK-ALIST")
    569. 

  569.   LISPOBJ_S(printstring_weakmapping,"WEAK-MAPPING")
    570. 

  570.   LISPOBJ_S(printstring_broken_weakmapping,"#<BROKEN WEAK-MAPPING>")
    571. 

  571.   LISPOBJ_S(printstring_finalizer,"#<FINALIZER>")
    572. 

  572.   #ifdef SOCKET_STREAMS
    573. 

  573.   LISPOBJ_S(printstring_socket_server,"SOCKET-SERVER")
    574. 

  574.   #endif
    575. 

  575.   #ifdef YET_ANOTHER_RECORD
    576. 

  576.   LISPOBJ_S(printstring_yetanother,"YET-ANOTHER")
    577. 

  577.   #endif
    578. 

  578.   LISPOBJ_S(printstring_internal_weak_list,"#<INTERNAL-WEAK-LIST>")
    579. 

  579.   LISPOBJ_S(printstring_weak_and_relation,"WEAK-AND-RELATION")
    580. 

  580.   LISPOBJ_S(printstring_broken_weak_and_relation,"#<BROKEN WEAK-AND-RELATION>")
    581. 

  581.   LISPOBJ_S(printstring_weak_or_relation,"WEAK-OR-RELATION")
    582. 

  582.   LISPOBJ_S(printstring_broken_weak_or_relation,"#<BROKEN WEAK-OR-RELATION>")
    583. 

  583.   LISPOBJ_S(printstring_weak_and_mapping,"WEAK-AND-MAPPING")
    584. 

  584.   LISPOBJ_S(printstring_broken_weak_and_mapping,"#<BROKEN WEAK-AND-MAPPING>")
    585. 

  585.   LISPOBJ_S(printstring_weak_or_mapping,"WEAK-OR-MAPPING")
    586. 

  586.   LISPOBJ_S(printstring_broken_weak_or_mapping,"#<BROKEN WEAK-OR-MAPPING>")
    587. 

  587.   LISPOBJ_S(printstring_internal_weak_alist,"#<INTERNAL-WEAK-ALIST>")
    588. 

  588.   LISPOBJ_S(printstring_internal_weak_hashed_alist,"#<INTERNAL-WEAK-HASHED-ALIST>")
    589. 

  589.   LISPOBJ_S(printstring_closure,"FUNCTION")
    590. 

  590.   LISPOBJ_S(printstring_compiled_closure,"COMPILED-FUNCTION")
    591. 

  591.   LISPOBJ_S(printstring_subr,"SYSTEM-FUNCTION")
    592. 

  592.   LISPOBJ_S(printstring_addon_subr,"ADD-ON-SYSTEM-FUNCTION")
    593. 

  593.   LISPOBJ_S(printstring_fsubr,"SPECIAL-OPERATOR")
    594. 

  594.   LISPOBJ_S(printstring_closed,"CLOSED ")
    595. 

  595.   LISPOBJ_S(printstring_input,"INPUT ")
    596. 

  596.   LISPOBJ_S(printstring_output,"OUTPUT ")
    597. 

  597.   LISPOBJ_S(printstring_io,"IO ")
    598. 

  598.   /* Buffering mode, addressed by
    599. 

  599.    (bit(1) if input-buffered) | (bit(0) if output-buffered). */
    600. 

  600.   LISPOBJ_S(printstring_buffered_00,"UNBUFFERED ")
    601. 

  601.   LISPOBJ_S(printstring_buffered_01,"OUTPUT-BUFFERED ")
    602. 

  602.   LISPOBJ_S(printstring_buffered_10,"INPUT-BUFFERED ")
    603. 

  603.   LISPOBJ_S(printstring_buffered_11,"BUFFERED ")
    604. 

  604.     /* name-string for each streamtype, addressed by streamtype: */
    605. 

  605.     LISPOBJ_S(printstring_strmtype_synonym,"SYNONYM")
    606. 

  606.     LISPOBJ_S(printstring_strmtype_broad,"BROADCAST")
    607. 

  607.     LISPOBJ_S(printstring_strmtype_concat,"CONCATENATED")
    608. 

  608.     LISPOBJ_S(printstring_strmtype_twoway,"TWO-WAY")
    609. 

  609.     LISPOBJ_S(printstring_strmtype_echo,"ECHO")
    610. 

  610.     LISPOBJ_S(printstring_strmtype_str_in,"STRING-INPUT")
    611. 

  611.     LISPOBJ_S(printstring_strmtype_str_out,"STRING-OUTPUT")
    612. 

  612.     LISPOBJ_S(printstring_strmtype_str_push,"STRING-PUSH")
    613. 

  613.     LISPOBJ_S(printstring_strmtype_pphelp,"PRETTY-PRINTER-HELP")
    614. 

  614.     LISPOBJ_S(printstring_strmtype_buff_in,"BUFFERED-INPUT")
    615. 

  615.     LISPOBJ_S(printstring_strmtype_buff_out,"BUFFERED-OUTPUT")
    616. 

  616.     #ifdef GENERIC_STREAMS
    617. 

  617.     LISPOBJ_S(printstring_strmtype_generic,"GENERIC")
    618. 

  618.     #endif
    619. 

  619.     LISPOBJ_S(printstring_strmtype_file,"FILE")
    620. 

  620.     #ifdef KEYBOARD
    621. 

  621.     LISPOBJ_S(printstring_strmtype_keyboard,"KEYBOARD")
    622. 

  622.     #endif
    623. 

  623.     LISPOBJ_S(printstring_strmtype_terminal,"TERMINAL")
    624. 

  624.     #ifdef SCREEN
    625. 

  625.     LISPOBJ_S(printstring_strmtype_window,"WINDOW")
    626. 

  626.     #endif
    627. 

  627.     #ifdef PRINTER
    628. 

  628.     LISPOBJ_S(printstring_strmtype_printer,"PRINTER")
    629. 

  629.     #endif
    630. 

  630.     #ifdef PIPES
    631. 

  631.     LISPOBJ_S(printstring_strmtype_pipe_in,"PIPE-INPUT")
    632. 

  632.     LISPOBJ_S(printstring_strmtype_pipe_out,"PIPE-OUTPUT")
    633. 

  633.     #endif
    634. 

  634.     #ifdef X11SOCKETS
    635. 

  635.     LISPOBJ_S(printstring_strmtype_x11socket,"X11-SOCKET")
    636. 

  636.     #endif
    637. 

  637.     #ifdef SOCKET_STREAMS
    638. 

  638.     LISPOBJ_S(printstring_strmtype_socket,"SOCKET")
    639. 

  639.     LISPOBJ_S(printstring_strmtype_twoway_socket,"SOCKET")
    640. 

  640.     #endif
    641. 

  641.   LISPOBJ_S(printstring_stream,"-STREAM")
    642. 

  642. #ifdef MULTITHREAD
    643. 

  643.   LISPOBJ_S(printstring_thread,"THREAD")
    644. 

  644.   LISPOBJ_S(printstring_mutex,"MUTEX")
    645. 

  645.   LISPOBJ_S(printstring_exemption,"EXEMPTION")
    646. 

  646. #endif
    647. 

  647. /* for LISPARIT.D:
    648. 

  648.    various constant numbers: */
    649. 

  649.   #ifndef IMMEDIATE_FFLOAT
    650. 

  650.   LISPOBJ(FF_zero,"0.0F0")
    651. 

  651.   LISPOBJ(FF_one,"1.0F0")
    652. 

  652.   LISPOBJ(FF_minusone,"-1.0F0")
    653. 

  653.   #endif
    654. 

  654.   LISPOBJ(DF_zero,"0.0D0")
    655. 

  655.   LISPOBJ(DF_one,"1.0D0")
    656. 

  656.   LISPOBJ(DF_minusone,"-1.0D0")
    657. 

  657.   /* defaultlength for reading of long-floats (Integer >=LF_minlen, <2^intWCsize): */
    658. 

  658.   LISPOBJ(LF_digits,".")   /* (already initialized) */
    659. 

  659.   /* variable long-floats: (already initialized) */
    660. 

  660.   LISPOBJ(SF_pi,".")          /* value of pi as Short-Float */
    661. 

  661.   LISPOBJ(FF_pi,".")          /* value of pi as Single-Float */
    662. 

  662.   LISPOBJ(DF_pi,".")          /* value of pi as Double-Float */
    663. 

  663.   LISPOBJ(pi,".")         /* value of pi, Long-Float of defaultlenght */
    664. 

  664.   LISPOBJ(LF_pi,".")      /* value of pi, so exact as known */
    665. 

  665.   LISPOBJ(LF_ln2,".")     /* value of ln 2, so exact as known */
    666. 

  666.   LISPOBJ(LF_ln10,".")    /* value of ln 10, so exact as known */
    667. 

  667. /* for EVAL.D:
    668. 

  668.    toplevel-declaration-environment: */
    669. 

  669.   LISPOBJ(top_decl_env,"(NIL)") /* list of O(declaration_types) (is initialized later) */
    670. 

  670.   /* decl-spec with list of declaration-types to be recognized: */
    671. 

  671.   LISPOBJ(declaration_types,"(DECLARATION OPTIMIZE DECLARATION)")
    672. 

  672. /* for DEBUG.D: */
    673. 

  673.   LISPOBJ_S(newline_string,NLstring)
    674. 

  674.   /* prompts: */
    675. 

  675.   LISPOBJ_S(prompt_string,"> ")
    676. 

  676.   LISPOBJ_S(breakprompt_string,". Break> ")
    677. 

  677.   /* various strings for description of the stack: */
    678. 

  678.   LISPOBJ_S(showstack_string_lisp_obj,"- ")
    679. 

  679.   LISPOBJ_S(showstack_string_bindung,NLstring "  | ")
    680. 

  680.   LISPOBJ_S(showstack_string_zuord," <--> ")
    681. 

  681.   LISPOBJ_S(showstack_string_zuordtag," --> ")
    682. 

  682.   LISPOBJ_S(showstack_string_VENV_frame,NLstring "  VAR_ENV <--> ")
    683. 

  683.   LISPOBJ_S(showstack_string_FENV_frame,NLstring "  FUN_ENV <--> ")
    684. 

  684.   LISPOBJ_S(showstack_string_BENV_frame,NLstring "  BLOCK_ENV <--> ")
    685. 

  685.   LISPOBJ_S(showstack_string_GENV_frame,NLstring "  GO_ENV <--> ")
    686. 

  686.   LISPOBJ_S(showstack_string_DENV_frame,NLstring "  DECL_ENV <--> ")
    687. 

  687. /* for SPVW.D: */
    688. 

  688.  #ifdef WIN32_NATIVE
    689. 

  689.   LISPOBJ(load_extra_file_types,"(\".BAT\")")
    690. 

  690.  #endif
    691. 

  691. /* for control & io, function seclass_object(): */
    692. 

  692.   LISPOBJ(seclass_no_se,"(NIL NIL NIL)")
    693. 

  693.   LISPOBJ(seclass_read,"(T NIL NIL)")
    694. 

  694.   LISPOBJ(seclass_write,"(NIL T T)")
    695. 

  695.   LISPOBJ(seclass_default,"(T T T)")
    696. 

  696. /* for FOREIGN.D: */
    697. 

  697.  #ifdef DYNAMIC_FFI
    698. 

  698.   LISPOBJ(fp_zero,"NIL")
    699. 

  699.   LISPOBJ(foreign_variable_table,"#.(make-hash-table :test #'equal)")
    700. 

  700.   LISPOBJ(foreign_function_table,"#.(make-hash-table :test #'equal)")
    701. 

  701.   LISPOBJ(foreign_inttype_table,"#.(make-hash-table :test #'equal)")
    702. 

  702.   LISPOBJ(type_foreign_variable,"(OR FFI::FOREIGN-VARIABLE FFI::FOREIGN-ADDRESS)")
    703. 

  703.   LISPOBJ(type_foreign_function,"(OR FFI::FOREIGN-FUNCTION FFI::FOREIGN-ADDRESS)")
    704. 

  704.  #if defined(WIN32_NATIVE) || defined(HAVE_DLOPEN)
    705. 

  705.   LISPOBJ(foreign_libraries,"NIL")
    706. 

  706.  #endif
    707. 

  707.   LISPOBJ(foreign_callin_table,"#.(make-hash-table :test #'eq)")
    708. 

  708.   LISPOBJ(foreign_callin_vector,"#.(let ((array (make-array 1 :adjustable t :fill-pointer 1))) (sys::store array 0 0) array)")
    709. 

  709.  #endif
    710. 

  710.