home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / languages / elisp / patches / float-emacs.diff < prev    next >
Encoding:
Text File  |  1991-07-01  |  25.5 KB  |  820 lines
  1. This is a complete diff -c for making a version of gnuemacs18.52
  2. with lisp flonums. 
  3.  
  4. ***** start of diff (on Thu Apr 20 11:52:50 EST 1989) *****
  5.  
  6. *** src/FLONUM.orig    Thu Apr 20 11:51:11 1989
  7. --- src/FLONUM    Wed Apr 19 11:57:18 1989
  8. ***************
  9. *** 0 ****
  10. --- 1,263 ----
  11. + ###############################################################################
  12. + ##                                         ##
  13. + ##    File:     FLONUMS                             ##
  14. + ##    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 ##
  15. + ##    Created:  Tue Oct 27 15:58:53 EST 1987                     ##
  16. + ##    Contents: Documentation File for GnuEmacs with floats             ##
  17. + ##                                         ##
  18. + ##    Copyright (c) 1987 Wolfgang Rupprecht.                     ##
  19. + ##    All rights reserved.                             ##
  20. + ##                                         ##
  21. + ##    $Log$                                     ##
  22. + ###############################################################################
  23. + 
  24. + INTRO
  25. + 
  26. + I have added a true floating point data type (flonum in lisp jargon)
  27. + to the lisp interpreter of GnuEmacs.  This allows one to do emacs-lisp
  28. + calculations using floating point numbers as well as integers.  In
  29. + addition, GnuEmacs now has hooks to call all of the common
  30. + trigonometric functions from lisp.  One may now, for example, use the
  31. + *scratch* buffer as a real scientific calculator (programable even!!).
  32. + It is not that hard to write a super spreadsheet calculator in elisp,
  33. + using this package.
  34. + 
  35. + NEW FEATURES
  36. + 
  37. + The basic features features provided are:
  38. + 
  39. + *    a lisp float data type, that uses the C type "double" for it's
  40. +     basic storage
  41. + *    upgrading of the built-in math subroutines to allow manipulation
  42. +     of floats
  43. + *    conversion routines to convert to and from floats and ints
  44. + *    predicates for testing if a number is a float, float-or-int,
  45. +     or float-or-int-or-marker
  46. + *    trig math routines. (sin, cos, tan, exponentials, logs, bessels, etc.)
  47. + *    upgrading of int-to-string, string-to-int, and the basic printing
  48. +     and reading routines to allow float reading/printing.
  49. + *    changes to garbage-collect to also collect old floats.
  50. + 
  51. + The lisp reader will interpret strings of one of the following three
  52. + forms as a float:
  53. + 
  54. +      <number>.<number>
  55. +      <number>e<number>
  56. +      <number>.<number>e<number>
  57. + 
  58. + The mantissa and the exponent may both have a single + or - sign
  59. + prefixed.  All other strings are treated as symbols.  This is
  60. + intentional, and meant to prevent numbers and dotted pairs of 
  61. + ints from looking too much like one another. 
  62. + 
  63. +      legal numbers:
  64. +       (0 . 1)      a doted pair of integers 0 and 1
  65. +       (0.1)        a list of one float with value 1/10
  66. + 
  67. +       0.0        the floating pt. zero
  68. +       1.0        the floating point one
  69. +       1e0        also floating pt. one
  70. +       0e0        also floating pt. zero
  71. + 
  72. +          (0. 1)        a list of symbol "0\." and integer 0
  73. +      (0 .1)        a list of integer 0 and symbol "\.1"
  74. +           0.        symbol "0\."
  75. +       .1        symbol "\.1"
  76. + 
  77. + The built in math functions promote the type of the calculation from
  78. + integer to float at the first encounter with a float.
  79. + 
  80. +     (+ 1 2 3 4 5 6.0 7 8 9)
  81. + 
  82. + The above expression will be done in integer math for the addition of
  83. + 1, 2, 3, 4 and 5.  The rest of the calculation is done in floating
  84. + point math with the result being a float.  This allows an integer 
  85. + calculation to still return an integer.  To force a floating point
  86. + calculation, convert the first argument to a float.
  87. + 
  88. + Ints can be converted to floats by using the function "float".
  89. + Floats can be converted to ints by one of several functions, 
  90. + depending on the type of rounding desired.
  91. + 
  92. +        round        returns the closest integer
  93. +        ceiling        returns the largest integer that is not larger 
  94. +             than the arg (round towards -infinity)
  95. +        floor        returns the smallest integer that is not smaller
  96. +             than the arg (round towards +infinity)
  97. +        truncate        returns the integer corresponding to the mantissa
  98. +             of the float. (round towards zero)
  99. + 
  100. + On most machines that gnuemacs runs on, lisp integers are only 24 bits
  101. + long.  One must be careful when convering large floats to integers that
  102. + one doesn't exceed the storage capacity of integers.  Integers (of 24
  103. + bit size) can only have a range of slightly over +/- 8 million.  The
  104. + same caution applies when performing mathematical operations on
  105. + integers.  If you need to work with large numbers, it's safest to use 
  106. + floats.
  107. + 
  108. + The math trig functions sin/cos/tan all take their arguments in
  109. + radians.  Values can be converted to the desired radix with the
  110. + functions degrees-to-radians and radians-to-degrees.
  111. + 
  112. + Some of the new functions (or functions with new args/return values):
  113. + 
  114. + abs acosh asin asinh atan atanh ceiling cos cosh cube-root erf erfc
  115. + exp expm1 expt fceiling ffloor float floor fround ftruncate
  116. + garbage-collect int-to-string integer-or-float-or-marker-p
  117. + integer-or-floatp j0 j1 jn log log-gamma log10 log1p round sin sinh
  118. + sqrt tan tanh truncate y0 y1 yn
  119. + 
  120. + The full documentations for these functions is on-line under C-h f
  121. + <function-name> and at the end of this document. 
  122. + 
  123. + The lisp variable float-output-format controls the printed
  124. + representation of floats.  The available print formats are:
  125. + 
  126. +        <number>.<number>         with a 'd' specifier
  127. +        <number>.<number>e<number>    with an 'e' specifier
  128. +        (or data dependent switching 
  129. +         between the above two)         with no letter specifier
  130. + 
  131. + The field width may be contolled by an optional numeric field
  132. + preceeding the above format specifier. 
  133. + 
  134. + 
  135. + MAKING FLOAT-EMACS:
  136. + 
  137. + To make emacs with flonums (ie. lisp floats) define LISP_FLOAT_TYPE in
  138. + your conf.h file.  The resultant emacs will be less than 6% larger.
  139. + This has been tested on a Vax-750 running BSD 4.3.
  140. + 
  141. +     text    data    bss    dec    hex
  142. +     369664    180224    0    549888    86400    emacs-18.49
  143. +     391168    187392    0    578560    8d400    float-emacs-18.49
  144. + 
  145. + PORTING to other machines:
  146. + 
  147. + If you aren't running with a BSD/vax style printf, you may no be able
  148. + to use the optional runtime selectable floating point print-width stuff.
  149. + (I'll probably fix this soon.)
  150. + 
  151. + If you don't have some of the math-lib functions that emacs wants
  152. + linked in, don't worry.  These are all entirely optional.  Just #ifdef
  153. + the math routines out, stub them up, or find a copy of the 4.3 BSD
  154. + routines. (Check the 4.3 BSD math(3) man page for details on copying
  155. + the math-lib routines.)
  156. + 
  157. + Appendix A: floating pt. docstrings
  158. + 
  159. + abs
  160. +    Function: Return the absolute value of ARG.
  161. + acosh
  162. +    Function: Return the inverse hyperbolic cosine of ARG.
  163. + asin
  164. +    Function: Return the inverse sine of ARG.
  165. + asinh
  166. +    Function: Return the inverse hyperbolic sine of ARG.
  167. + atan
  168. +    Function: Return the inverse tangent of ARG.
  169. + atanh
  170. +    Function: Return the inverse hyperbolic tangent of ARG.
  171. + ceiling
  172. +    Function: Return the smallest integer no less than ARG. (round toward +inf)
  173. + cos
  174. +    Function: Return the cosine of ARG.
  175. + cosh
  176. +    Function: Return the hyperbolic cosine of ARG.
  177. + cube-root
  178. +    Function: Return the cube root of ARG.
  179. + erf
  180. +    Function: Return the mathematical error function of ARG.
  181. + erfc
  182. +    Function: Return the complementary error function of ARG.
  183. + exp
  184. +    Function: Return the exponential base e of ARG.
  185. + expm1
  186. +    Function: Return the exp(x)-1 of ARG.
  187. + expt
  188. +    Function: Return the exponential x ** y.
  189. + fceiling
  190. +    Function: Return the smallest integral floating pt. number no less than ARG.
  191. +    (round towards +inf)
  192. + ffloor
  193. +    Function: Return the largest floating pt number no greater than ARG.
  194. +    (round towards -inf)
  195. + float
  196. +    Function: Return the floating pt. number equal to ARG.
  197. + floatp
  198. +    Function: T if OBJECT is a floating pt. number.
  199. + float-output-format
  200. +    Variable: The format descriptor string (or nil) that lisp uses to print out
  201. +    floats.  Nil means use built-in defaults.
  202. +    The descriptor string consists of an optional field-width spec,
  203. +    followed by an optional output-style descriptor.
  204. +    
  205. +    Valid field-widths specs are:
  206. +    The empty string for default precision.
  207. +    0-20 for exponential notation, or 1-20 for decimal point notation.  A 0
  208. +    field spec causes the printing of the decimal point to be supressed.
  209. +    Using an out of bounds specs cause the closest valid spec to be used.
  210. +    
  211. +    Valid ouput-styles may be one of the following:
  212. +    The letter 'e' for exponential notation "<number>.<number>e<number>"
  213. +    The letter 'd' for decimal point notation "<number>.<number>".
  214. +    The empty string, for the defaulted output style.  This may print in
  215. +    either format in a data-dependent manner, choosing whatever produces
  216. +    the shortest string.
  217. +    
  218. + floor
  219. +    Function: Return the largest integer no greater than ARG. (round towards -inf)
  220. + fround
  221. +    Function: Return the nearest integral floating pt. number to ARG.
  222. + ftruncate
  223. +    Function: Truncate a floating point number, returns a float.
  224. +    (Truncates towards zero.) Will fail for floats > max integer.
  225. + garbage-collect
  226. +    Function: Reclaim storage for Lisp objects no longer needed.
  227. +    Returns info on amount of space in use:
  228. +     ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
  229. +      (USED-MARKERS . FREE-MARKERS) (USED-FLOATS . FREE-FLOATS) 
  230. +      USED-STRING-CHARS USED-VECTOR-SLOTS)
  231. +    Garbage collection happens automatically if you cons more than
  232. +    gc-cons-threshold  bytes of Lisp data since previous garbage collection.
  233. + int-to-string
  234. +    Function: Convert INT to a string by printing it in decimal, with minus sign if negative.
  235. + integer-or-float-or-marker-p
  236. +    Function: T if OBJECT is a floating pointt, normal number, or marker.
  237. + integer-or-floatp
  238. +    Function: T if OBJECT is a floating pt. or normal number.
  239. + j0
  240. +    Function: Return the bessel function j0 of ARG.
  241. + j1
  242. +    Function: Return the bessel function j1 of ARG.
  243. + jn
  244. +    Function: Return the bessel function jN of ARG.
  245. + log
  246. +    Function: Return the natural logarithm of ARG.
  247. + log-gamma
  248. +    Function: Return the log gamma of ARG.
  249. + log10
  250. +    Function: Return the logarithm base 10 of ARG.
  251. + log1p
  252. +    Function: Return the log(1+x) of ARG.
  253. + round
  254. +    Function: Return the nearest integer to ARG.
  255. + sin
  256. +    Function: Return the sine of ARG.
  257. + sinh
  258. +    Function: Return the hyperbolic sine of ARG.
  259. + sqrt
  260. +    Function: Return the square root of ARG.
  261. + tan
  262. +    Function: Return the tangent of ARG.
  263. + tanh
  264. +    Function: Return the hyperbolic tangent of ARG.
  265. + truncate
  266. +    Function: Truncate a floating point number to an int.
  267. +    (Truncates toward zero.)
  268. + y0
  269. +    Function: Return the bessel function y0 of ARG.
  270. + y1
  271. +    Function: Return the bessel function y1 of ARG.
  272. + yn
  273. +    Function: Return the bessel function yN of ARG.
  274. *** src/alloc.c.orig    Thu Feb 11 02:09:48 1988
  275. --- src/alloc.c    Fri Sep  2 23:01:22 1988
  276. ***************
  277. *** 1,3 ****
  278. --- 1,15 ----
  279. + /******************************************************************************
  280. + *                                          *
  281. + *    File:     alloc.c                              *
  282. + *    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 *
  283. + *    Created:  Mon Nov  2 15:20:48 EST 1987                      *
  284. + *    Contents: GNU alloc.c with my float code                  *
  285. + *                                          *
  286. + *    Copyright (c) 1987 Wolfgang Rupprecht.                      *
  287. + *    All rights reserved.                              *
  288. + *                                          *
  289. + *    $Log$                                      *
  290. + ******************************************************************************/
  291.   /* Storage allocation and gc for GNU Emacs Lisp interpreter.
  292.      Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  293.   
  294. ***************
  295. *** 147,152 ****
  296. --- 159,239 ----
  297.     cons_free_list = ptr;
  298.   }
  299.   
  300. + #ifdef LISP_FLOAT_TYPE
  301. + 
  302. + /* Allocation of float cells, just like conses */
  303. + /* We store float cells inside of float_blocks, allocating a new
  304. +  float_block with malloc whenever necessary.  Float cells reclaimed by
  305. +  GC are put on a free list to be reallocated before allocating
  306. +  any new float cells from the latest float_block.
  307. + 
  308. +  Each float_block is just under 1020 bytes long,
  309. +  since malloc really allocates in units of powers of two
  310. +  and uses 4 bytes for its own overhead. */
  311. + 
  312. + #define FLOAT_BLOCK_SIZE \
  313. +   ((1020 - sizeof (struct float_block *)) / sizeof (struct Lisp_Float))
  314. + 
  315. + struct float_block
  316. +   {
  317. +     struct float_block *next;
  318. +     struct Lisp_Float floats[FLOAT_BLOCK_SIZE];
  319. +   };
  320. + 
  321. + struct float_block *float_block;
  322. + int float_block_index;
  323. + 
  324. + struct Lisp_Float *float_free_list;
  325. + 
  326. + void
  327. + init_float ()
  328. + {
  329. +   float_block = (struct float_block *) malloc (sizeof (struct float_block));
  330. +   float_block->next = 0;
  331. +   bzero (float_block->floats, sizeof float_block->floats);
  332. +   float_block_index = 0;
  333. +   float_free_list = 0;
  334. + }
  335. + 
  336. + /* Explicitly free a float cell.  */
  337. + free_float (ptr)
  338. +      struct Lisp_Float *ptr;
  339. + {
  340. +   XFASTINT (ptr->type) = (int) float_free_list;
  341. +   float_free_list = ptr;
  342. + }
  343. + 
  344. + Lisp_Object
  345. + make_float (float_value)
  346. +      double float_value;
  347. + {
  348. +   register Lisp_Object val;
  349. + 
  350. +   if (float_free_list)
  351. +     {
  352. +       XSET (val, Lisp_Float, float_free_list);
  353. +       float_free_list = (struct Lisp_Float *) XFASTINT (float_free_list->type);
  354. +     }
  355. +   else
  356. +     {
  357. +       if (float_block_index == FLOAT_BLOCK_SIZE)
  358. +     {
  359. +       register struct float_block *new = (struct float_block *) malloc (sizeof (struct float_block));
  360. +       if (!new) memory_full ();
  361. +       new->next = float_block;
  362. +       float_block = new;
  363. +       float_block_index = 0;
  364. +     }
  365. +       XSET (val, Lisp_Float, &float_block->floats[float_block_index++]);
  366. +     }
  367. +   XFLOAT (val)->data = float_value;
  368. +   XFLOAT (val)->type = 0;    /* bug chasing -wsr */
  369. +   consing_since_gc += sizeof (struct Lisp_Float);
  370. +   return val;
  371. + }
  372. + #endif LISP_FLOAT_TYPE
  373. + 
  374. + 
  375.   DEFUN ("cons", Fcons, Scons, 2, 2, 0,
  376.     "Create a new cons, give it CAR and CDR as components, and return it.")
  377.     (car, cdr)
  378. ***************
  379. *** 596,602 ****
  380. --- 683,707 ----
  381.     return new;
  382.   }
  383.   
  384. + #ifdef LISP_FLOAT_TYPE
  385.   Lisp_Object
  386. + pure_float (num)
  387. +      double num;
  388. + {
  389. +   register Lisp_Object new;
  390. + 
  391. +   if (pureptr + sizeof (struct Lisp_Float) > PURESIZE)
  392. +     error ("Pure Lisp storage exhausted");
  393. +   XSET (new, Lisp_Float, PUREBEG + pureptr);
  394. +   pureptr += sizeof (struct Lisp_Float);
  395. +   XFLOAT (new)->data = num;
  396. +   XFLOAT (new)->type = 0;    /* bug chasing -wsr */
  397. +   return new;
  398. + }
  399. + 
  400. + #endif LISP_FLOAT_TYPE
  401. + 
  402. + Lisp_Object
  403.   make_pure_vector (len)
  404.        int len;
  405.   {
  406. ***************
  407. *** 641,646 ****
  408. --- 746,756 ----
  409.       case Lisp_Cons:
  410.         return pure_cons (XCONS (obj)->car, XCONS (obj)->cdr);
  411.   
  412. + #ifdef LISP_FLOAT_TYPE
  413. +     case Lisp_Float:
  414. +       return pure_float (XFLOAT (obj)->data);
  415. + #endif LISP_FLOAT_TYPE
  416. + 
  417.       case Lisp_String:
  418.         return make_pure_string (XSTRING (obj)->data, XSTRING (obj)->size);
  419.   
  420. ***************
  421. *** 727,737 ****
  422. --- 837,852 ----
  423.   
  424.   int total_conses, total_markers, total_symbols, total_string_size, total_vector_size;
  425.   int total_free_conses, total_free_markers, total_free_symbols;
  426. + #ifdef LISP_FLOAT_TYPE
  427. + int total_free_floats, total_floats;
  428. + #endif LISP_FLOAT_TYPE
  429.   
  430.   static void mark_object (), mark_buffer ();
  431.   static void clear_marks (), gc_sweep ();
  432.   static void compact_strings ();
  433.   
  434. + #ifndef LISP_FLOAT_TYPE
  435. + 
  436.   DEFUN ("garbage-collect", Fgarbage_collect, Sgarbage_collect, 0, 0, "",
  437.     "Reclaim storage for Lisp objects no longer needed.\n\
  438.   Returns info on amount of space in use:\n\
  439. ***************
  440. *** 738,745 ****
  441.    ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)\n\
  442.     (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS)\n\
  443.   Garbage collection happens automatically if you cons more than\n\
  444. ! gc-cons-threshold  bytes of Lisp data since previous garbage collection.")
  445.     ()
  446.   {
  447.     register struct gcpro *tail;
  448.     register struct specbinding *bind;
  449. --- 853,873 ----
  450.    ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)\n\
  451.     (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS)\n\
  452.   Garbage collection happens automatically if you cons more than\n\
  453. ! gc-cons-threshold  bytes of Lisp data since previous garbage collection."
  454. !        )
  455.     ()
  456. + #else LISP_FLOAT_TYPE
  457. + 
  458. + DEFUN ("garbage-collect", Fgarbage_collect, Sgarbage_collect, 0, 0, "",  "Reclaim storage for Lisp objects no longer needed.\n\
  459. + Returns info on amount of space in use:\n\
  460. +  ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)\n\
  461. +   (USED-MARKERS . FREE-MARKERS) (USED-FLOATS . FREE-FLOATS) \n\
  462. +   USED-STRING-CHARS USED-VECTOR-SLOTS)\n\
  463. + Garbage collection happens automatically if you cons more than\n\
  464. + gc-cons-threshold  bytes of Lisp data since previous garbage collection."
  465. +        )
  466. +   ()
  467. + #endif LISP_FLOAT_TYPE
  468.   {
  469.     register struct gcpro *tail;
  470.     register struct specbinding *bind;
  471. ***************
  472. *** 859,867 ****
  473. --- 987,1004 ----
  474.                     make_number (total_free_symbols)),
  475.                  Fcons (Fcons (make_number (total_markers),
  476.                        make_number (total_free_markers)),
  477. + #ifdef LISP_FLOAT_TYPE
  478. +                   Fcons (Fcons (make_number (total_floats),
  479. +                         make_number (total_free_floats)),
  480. +                      Fcons (make_number (total_string_size),
  481. +                         Fcons (make_number (total_vector_size),
  482. +                            Qnil))))));
  483. + #else not LISP_FLOAT_TYPE
  484.                     Fcons (make_number (total_string_size),
  485.                        Fcons (make_number (total_vector_size),
  486.                           Qnil)))));
  487. + #endif LISP_FLOAT_TYPE
  488. + 
  489.   }
  490.   
  491.   #if 0
  492. ***************
  493. *** 1053,1058 ****
  494. --- 1190,1201 ----
  495.       goto loop;
  496.         }
  497.   
  498. + #ifdef LISP_FLOAT_TYPE
  499. +  case Lisp_Float:
  500. +       XMARK (XFLOAT (obj)->type);
  501. +       break;
  502. + #endif LISP_FLOAT_TYPE
  503. + 
  504.       case Lisp_Buffer:
  505.         if (!XMARKBIT (XBUFFER (obj)->name))
  506.       mark_buffer (obj);
  507. ***************
  508. *** 1137,1143 ****
  509. --- 1280,1316 ----
  510.       total_conses = num_used;
  511.       total_free_conses = num_free;
  512.     }
  513. + #ifdef LISP_FLOAT_TYPE
  514. +   /* Put all unmarked floats on free list */
  515. +   {
  516. +     register struct float_block *fblk;
  517. +     register int lim = float_block_index;
  518. +     register int num_free = 0, num_used = 0;
  519.   
  520. +     float_free_list = 0;
  521. +   
  522. +     for (fblk = float_block; fblk; fblk = fblk->next)
  523. +       {
  524. +     register int i;
  525. +     for (i = 0; i < lim; i++)
  526. +       if (!XMARKBIT (fblk->floats[i].type))
  527. +         {
  528. +           XFASTINT (fblk->floats[i].type) = (int) float_free_list;
  529. +           num_free++;
  530. +           float_free_list = &fblk->floats[i];
  531. +         }
  532. +       else
  533. +         {
  534. +           num_used++;
  535. +           XUNMARK (fblk->floats[i].type);
  536. +         }
  537. +     lim = FLOAT_BLOCK_SIZE;
  538. +       }
  539. +     total_floats = num_used;
  540. +     total_free_floats = num_free;
  541. +   }
  542. + #endif LISP_FLOAT_TYPE
  543. + 
  544.     /* Put all unmarked symbols on free list */
  545.     {
  546.       register struct symbol_block *sblk;
  547. ***************
  548. *** 1412,1417 ****
  549. --- 1585,1593 ----
  550.     all_vectors = 0;
  551.     init_strings ();
  552.     init_cons ();
  553. + #ifdef LISP_FLOAT_TYPE
  554. +   init_float ();
  555. + #endif LISP_FLOAT_TYPE
  556.     init_symbol ();
  557.     init_marker ();
  558.     gcprolist = 0;
  559. *** src/callint.c.orig    Tue Jun 28 19:57:24 1988
  560. --- src/callint.c    Fri Sep  2 23:01:26 1988
  561. ***************
  562. *** 353,359 ****
  563. --- 353,364 ----
  564.       case 'n':        /* Read number from minibuffer.  */
  565.         do
  566.           args[i] = Fread_minibuffer (build_string (prompt), Qnil);
  567. + #ifdef LISP_FLOAT_TYPE
  568. +       while ((XTYPE (args[i]) != Lisp_Int) &&
  569. +          (XTYPE (args[i]) != Lisp_Float));
  570. + #else
  571.         while (XTYPE (args[i]) != Lisp_Int);
  572. + #endif
  573.         visargs[i] = last_minibuf_string;
  574.         break;
  575.   
  576. *** src/config.h-dist.orig    Thu Apr 21 03:18:33 1988
  577. --- src/config.h-dist    Fri Sep  2 23:01:27 1988
  578. ***************
  579. *** 18,24 ****
  580. --- 18,29 ----
  581.   file named COPYING.  Among other things, the copyright notice
  582.   and this notice must be preserved on all copies.  */
  583.   
  584. + /* This is a hack feature added by me.
  585. +  * It probably won't break anything too badly, but it may not do
  586. +  * much for you either. -Wolfgang Rupprecht 10/25/87
  587. +  */
  588.   
  589. + /* #define LISP_FLOAT_TYPE        /* define this for floating pt. numbers */
  590.   
  591.   /* Include here a s- file that describes the system type you are using.
  592.      See the file ../etc/MACHINES for a list of systems and
  593. ***************
  594. *** 100,110 ****
  595.      Note that s-vms.h and m-sun2.h may override this default.  */
  596.   
  597.   #ifndef PURESIZE
  598. ! #ifdef HAVE_X_WINDOWS
  599. ! #define PURESIZE 122000
  600. ! #else
  601. ! #define PURESIZE 118000
  602. ! #endif
  603.   #endif
  604.   
  605.   /* Define HIGHPRI as a negative number
  606. --- 105,119 ----
  607.      Note that s-vms.h and m-sun2.h may override this default.  */
  608.   
  609.   #ifndef PURESIZE
  610. ! # ifdef HAVE_X_WINDOWS
  611. ! #  define PURESIZE 122000
  612. ! # else
  613. ! #  ifdef LISP_FLOAT_TYPE        /* oink oink */
  614. ! #   define PURESIZE 122000
  615. ! #  else
  616. ! #   define PURESIZE 118000
  617. ! #  endif
  618. ! # endif
  619.   #endif
  620.   
  621.   /* Define HIGHPRI as a negative number
  622. *** src/crt0.c.orig    Wed Aug 31 02:48:46 1988
  623. --- src/crt0.c    Thu Apr 20 10:57:02 1989
  624. ***************
  625. *** 369,374 ****
  626. --- 369,379 ----
  627.   
  628.   _start ()
  629.   {
  630. + #ifdef LISP_FLOAT_TYPE
  631. + # ifdef sun3
  632. +   finitfp_();
  633. + # endif
  634. + #endif
  635.   /* On 68000, _start pushes a6 onto stack  */
  636.     start1 ();
  637.   }
  638. *** src/data.c.orig    Fri Aug 26 20:36:23 1988
  639. --- src/data.c    Fri Sep  2 23:01:39 1988
  640. ***************
  641. *** 1,3 ****
  642. --- 1,15 ----
  643. + /******************************************************************************
  644. + *                                          *
  645. + *    File:     data.c                              *
  646. + *    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 *
  647. + *    Created:  Mon Nov  2 15:22:23 EST 1987                      *
  648. + *    Contents: GNU data.c with my float code                      *
  649. + *                                          *
  650. + *    Copyright (c) 1987 Wolfgang Rupprecht.                      *
  651. + *    All rights reserved.                              *
  652. + *                                          *
  653. + *    $Log$                                      *
  654. + ******************************************************************************/
  655.   /* Primitive operations on Lisp data types for GNU Emacs Lisp interpreter.
  656.      Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  657.   
  658. ***************
  659. *** 28,33 ****
  660. --- 40,49 ----
  661.   #include "buffer.h"
  662.   #endif
  663.   
  664. + #ifdef LISP_FLOAT_TYPE
  665. + #include <math.h>
  666. + #endif LISP_FLOAT_TYPE
  667. + 
  668.   Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
  669.   Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
  670.   Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
  671. ***************
  672. *** 41,47 ****
  673. --- 57,68 ----
  674.   Lisp_Object Qchar_or_string_p, Qmarkerp, Qinteger_or_marker_p, Qvectorp;
  675.   Lisp_Object Qboundp, Qfboundp;
  676.   Lisp_Object Qcdr;
  677. + #ifdef LISP_FLOAT_TYPE
  678. + Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
  679. + #endif LISP_FLOAT_TYPE
  680.   
  681. + 
  682. + 
  683.   Lisp_Object
  684.   wrong_type_argument (predicate, value)
  685.        register Lisp_Object predicate, value;
  686. ***************
  687. *** 177,182 ****
  688. --- 198,238 ----
  689.     return Qnil;
  690.   }
  691.   
  692. + #ifdef LISP_FLOAT_TYPE
  693. + DEFUN ("floatp", Ffloatp, Sfloatp, 1, 1, 0,
  694. +        "T if OBJECT is a floating pt. number.")
  695. +   (obj)
  696. +      Lisp_Object obj;
  697. + {
  698. +   if (XTYPE (obj) == Lisp_Float)
  699. +     return Qt;
  700. +   return Qnil;
  701. + }
  702. + 
  703. + DEFUN ("integer-or-floatp", Finteger_or_floatp, Sinteger_or_floatp,
  704. +        1, 1, 0, "T if OBJECT is a floating pt. or normal number.")
  705. +   (obj)
  706. +      Lisp_Object obj;
  707. + {
  708. +   if ((XTYPE (obj) == Lisp_Float) || (XTYPE (obj) == Lisp_Int))
  709. +     return Qt;
  710. +   return Qnil;
  711. + }
  712. + 
  713. + DEFUN ("integer-or-float-or-marker-p", Finteger_or_float_or_marker_p,
  714. +        Sinteger_or_float_or_marker_p, 1, 1, 0,
  715. +        "T if OBJECT is a floating pointt, normal number, or marker.")
  716. +   (obj)
  717. +      Lisp_Object obj;
  718. + {
  719. +   if ((XTYPE (obj) == Lisp_Float) ||
  720. +       (XTYPE (obj) == Lisp_Int) ||
  721. +       (XTYPE (obj) == Lisp_Marker))
  722. +     return Qt;
  723. +   return Qnil;
  724. + }
  725. + #endif LISP_FLOAT_TYPE
  726. + 
  727.   DEFUN ("natnump", Fnatnump, Snatnump, 1, 1, 0, "T if OBJECT is a nonnegative number.")
  728.     (obj)
  729.        Lisp_Object obj;
  730. ***************
  731. *** 961,968 ****
  732. --- 1017,1041 ----
  733.     (num1, num2)
  734.        register Lisp_Object num1, num2;
  735.   {
  736. + #ifdef LISP_FLOAT_TYPE
  737. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  738. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
  739. + 
  740. +   if ((XTYPE(num1) == Lisp_Float) || (XTYPE(num2) == Lisp_Float))
  741. +     {
  742. +       double f1, f2;
  743. + 
  744. +       f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  745. +       f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  746. +       if (f1 == f2)
  747. +     return Qt;
  748. +       return Qnil;
  749. +     }
  750. + 
  751. + #else
  752.     CHECK_NUMBER_COERCE_MARKER (num1, 0);
  753.     CHECK_NUMBER_COERCE_MARKER (num2, 0);
  754. + #endif LISP_FLOAT_TYPE
  755.   
  756.     if (XINT (num1) == XINT (num2))
  757.       return Qt;
  758. ***************
  759. *** 974,981 ****
  760. --- 1047,1070 ----
  761.     (num1, num2)
  762.        register Lisp_Object num1, num2;
  763.   {
  764. + #ifdef LISP_FLOAT_TYPE
  765. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  766. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
  767. + 
  768. +   if ((XTYPE(num1) == Lisp_Float) || (XTYPE(num2) == Lisp_Float))
  769. +     {
  770. +       double f1, f2;
  771. + 
  772. +       f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  773. +       f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  774. +       if (f1 < f2)
  775. +     return Qt;
  776. +       return Qnil;
  777. +     }
  778. + #else
  779.     CHECK_NUMBER_COERCE_MARKER (num1, 0);
  780.     CHECK_NUMBER_COERCE_MARKER (num2, 0);
  781. + #endif LISP_FLOAT_TYPE
  782.   
  783.     if (XINT (num1) < XINT (num2))
  784.       return Qt;
  785. ***************
  786. *** 987,994 ****
  787. --- 1076,1099 ----
  788.     (num1, num2)
  789.        register Lisp_Object num1, num2;
  790.   {
  791. + #ifdef LISP_FLOAT_TYPE
  792. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  793. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
  794. + 
  795. +   if ((XTYPE(num1) == Lisp_Float) || (XTYPE(num2) == Lisp_Float))
  796. +     {
  797. +       double f1, f2;
  798. + 
  799. +       f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  800. +       f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  801. +       if (f1 > f2)
  802. +     return Qt;
  803. +       return Qnil;
  804. +     }
  805. + #else
  806.     CHECK_NUMBER_COERCE_MARKER (num1, 0);
  807.     CHECK_NUMBER_COERCE_MARKER (num2, 0);
  808. + #endif LISP_FLOAT_TYPE
  809.   
  810.     if (XINT (num1) > XINT (num2))
  811.       return Qt;
  812. ***************
  813. *** 1000,1007 ****
  814. --- 1105,1128 ----
  815.     (num1, num2)
  816.        register Lisp_Object num1, num2;
  817.   {
  818. + #ifdef LISP_FLOAT_TYPE
  819. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  820. +   CHECK_NUMBER