home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / languages / elisp / patches / float-sup.patch < prev    next >
Encoding:
Internet Message Format  |  1991-08-22  |  80.1 KB
  1. Path: dg-rtp!rock!mcnc!gatech!usenet.ins.cwru.edu!magnus.acs.ohio-state.edu!cis.ohio-state.edu!ucbvax!bloom-beacon!eru!kth.se!news
  2. From: bg@bg.nada.kth.se (Bjorn Gronvall)
  3. Newsgroups: gnu.emacs.sources
  4. Subject: Floting-point numbers in emacs
  5. Date: 13 Aug 91 13:12:47 GMT
  6. Organization: Royal Institute of Technology, Stockholm, Sweden
  7.  
  8. ;; LCD Archive Entry:
  9. ;; float-sup.patch
  10. ;; |Wolfgang Rupprecht, Bjorn Gronvall|wolfgang@mgm.mit.edu, bg@bg.nada.kth.se
  11. ;; |True floating point lisp data type for Emacs 18.57 (source code patch)
  12. ;; |91-08-13||~/patches/float-sup.patch.Z|
  13.  
  14.  
  15. Yes, I know that programmers don't use flotingpoint
  16. but some of our users does. Therfore I have updated
  17. Wolfgang Rupprecht patch to work with emacs-18.57.
  18.  
  19. To install this patch follow the following steps:
  20.  
  21. 1)
  22. Run patch (on file included below).
  23.  
  24. 2)
  25. cp lisp/float-sup.el lisp/float-sup.elc
  26. This is for bootstrapping, your old emacs
  27. can't compile this beast (yet).
  28.  
  29. 3)
  30. byte-recompile-directory lisp (using emacs)
  31.  
  32. 4)
  33. Add LISP_FLOAT_TYPE to your src/config.h.
  34. You will also need to increase the value
  35. of PURESIZE by roughly 5000.
  36.  
  37. 5)
  38. Run make
  39.  
  40. 6)
  41. byte-compile lisp/float-sup.el
  42.  
  43. 7)
  44. Run make again (to complete bootstrap process).
  45.  
  46. and your hopfully done.
  47.  
  48.     Cheers
  49.     Bjvrn
  50.  
  51. Only in emacs: FLONUM
  52. *** emacs-18.57/FLONUM    Tue Aug 13 14:06:45 1991
  53. --- emacs/FLONUM    Tue Aug 13 10:50:22 1991
  54. ***************
  55. *** 0 ****
  56. --- 1,263 ----
  57. + ###############################################################################
  58. + ##                                         ##
  59. + ##    File:     FLONUMS                             ##
  60. + ##    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 ##
  61. + ##    Created:  Tue Oct 27 15:58:53 EST 1987                     ##
  62. + ##    Contents: Documentation File for GnuEmacs with floats             ##
  63. + ##                                         ##
  64. + ##    Copyright (c) 1987 Wolfgang Rupprecht.                     ##
  65. + ##    All rights reserved.                             ##
  66. + ##                                         ##
  67. + ##    $Log$                                     ##
  68. + ###############################################################################
  69. + 
  70. + INTRO
  71. + 
  72. + I have added a true floating point data type (flonum in lisp jargon)
  73. + to the lisp interpreter of GnuEmacs.  This allows one to do emacs-lisp
  74. + calculations using floating point numbers as well as integers.  In
  75. + addition, GnuEmacs now has hooks to call all of the common
  76. + trigonometric functions from lisp.  One may now, for example, use the
  77. + *scratch* buffer as a real scientific calculator (programable even!!).
  78. + It is not that hard to write a super spreadsheet calculator in elisp,
  79. + using this package.
  80. + 
  81. + NEW FEATURES
  82. + 
  83. + The basic features features provided are:
  84. + 
  85. + *    a lisp float data type, that uses the C type "double" for it's
  86. +     basic storage
  87. + *    upgrading of the built-in math subroutines to allow manipulation
  88. +     of floats
  89. + *    conversion routines to convert to and from floats and ints
  90. + *    predicates for testing if a number is a float, float-or-int,
  91. +     or float-or-int-or-marker
  92. + *    trig math routines. (sin, cos, tan, exponentials, logs, bessels, etc.)
  93. + *    upgrading of int-to-string, string-to-int, and the basic printing
  94. +     and reading routines to allow float reading/printing.
  95. + *    changes to garbage-collect to also collect old floats.
  96. + 
  97. + The lisp reader will interpret strings of one of the following three
  98. + forms as a float:
  99. + 
  100. +      <number>.<number>
  101. +      <number>e<number>
  102. +      <number>.<number>e<number>
  103. + 
  104. + The mantissa and the exponent may both have a single + or - sign
  105. + prefixed.  All other strings are treated as symbols.  This is
  106. + intentional, and meant to prevent numbers and dotted pairs of 
  107. + ints from looking too much like one another. 
  108. + 
  109. +      legal numbers:
  110. +       (0 . 1)      a doted pair of integers 0 and 1
  111. +       (0.1)        a list of one float with value 1/10
  112. + 
  113. +       0.0        the floating pt. zero
  114. +       1.0        the floating point one
  115. +       1e0        also floating pt. one
  116. +       0e0        also floating pt. zero
  117. + 
  118. +          (0. 1)        a list of symbol "0\." and integer 0
  119. +      (0 .1)        a list of integer 0 and symbol "\.1"
  120. +           0.        symbol "0\."
  121. +       .1        symbol "\.1"
  122. + 
  123. + The built in math functions promote the type of the calculation from
  124. + integer to float at the first encounter with a float.
  125. + 
  126. +     (+ 1 2 3 4 5 6.0 7 8 9)
  127. + 
  128. + The above expression will be done in integer math for the addition of
  129. + 1, 2, 3, 4 and 5.  The rest of the calculation is done in floating
  130. + point math with the result being a float.  This allows an integer 
  131. + calculation to still return an integer.  To force a floating point
  132. + calculation, convert the first argument to a float.
  133. + 
  134. + Ints can be converted to floats by using the function "float".
  135. + Floats can be converted to ints by one of several functions, 
  136. + depending on the type of rounding desired.
  137. + 
  138. +        round        returns the closest integer
  139. +        ceiling        returns the largest integer that is not larger 
  140. +             than the arg (round towards -infinity)
  141. +        floor        returns the smallest integer that is not smaller
  142. +             than the arg (round towards +infinity)
  143. +        truncate        returns the integer corresponding to the mantissa
  144. +             of the float. (round towards zero)
  145. + 
  146. + On most machines that gnuemacs runs on, lisp integers are only 24 bits
  147. + long.  One must be careful when convering large floats to integers that
  148. + one doesn't exceed the storage capacity of integers.  Integers (of 24
  149. + bit size) can only have a range of slightly over +/- 8 million.  The
  150. + same caution applies when performing mathematical operations on
  151. + integers.  If you need to work with large numbers, it's safest to use 
  152. + floats.
  153. + 
  154. + The math trig functions sin/cos/tan all take their arguments in
  155. + radians.  Values can be converted to the desired radix with the
  156. + functions degrees-to-radians and radians-to-degrees.
  157. + 
  158. + Some of the new functions (or functions with new args/return values):
  159. + 
  160. + abs acosh asin asinh atan atanh ceiling cos cosh cube-root erf erfc
  161. + exp expm1 expt fceiling ffloor float floor fround ftruncate
  162. + garbage-collect int-to-string integer-or-float-or-marker-p
  163. + integer-or-floatp j0 j1 jn log log-gamma log10 log1p round sin sinh
  164. + sqrt tan tanh truncate y0 y1 yn
  165. + 
  166. + The full documentations for these functions is on-line under C-h f
  167. + <function-name> and at the end of this document. 
  168. + 
  169. + The lisp variable float-output-format controls the printed
  170. + representation of floats.  The available print formats are:
  171. + 
  172. +        <number>.<number>         with a 'd' specifier
  173. +        <number>.<number>e<number>    with an 'e' specifier
  174. +        (or data dependent switching 
  175. +         between the above two)         with no letter specifier
  176. + 
  177. + The field width may be contolled by an optional numeric field
  178. + preceeding the above format specifier. 
  179. + 
  180. + 
  181. + MAKING FLOAT-EMACS:
  182. + 
  183. + To make emacs with flonums (ie. lisp floats) define LISP_FLOAT_TYPE in
  184. + your conf.h file.  The resultant emacs will be less than 6% larger.
  185. + This has been tested on a Vax-750 running BSD 4.3.
  186. + 
  187. +     text    data    bss    dec    hex
  188. +     369664    180224    0    549888    86400    emacs-18.49
  189. +     391168    187392    0    578560    8d400    float-emacs-18.49
  190. + 
  191. + PORTING to other machines:
  192. + 
  193. + If you aren't running with a BSD/vax style printf, you may no be able
  194. + to use the optional runtime selectable floating point print-width stuff.
  195. + (I'll probably fix this soon.)
  196. + 
  197. + If you don't have some of the math-lib functions that emacs wants
  198. + linked in, don't worry.  These are all entirely optional.  Just #ifdef
  199. + the math routines out, stub them up, or find a copy of the 4.3 BSD
  200. + routines. (Check the 4.3 BSD math(3) man page for details on copying
  201. + the math-lib routines.)
  202. + 
  203. + Appendix A: floating pt. docstrings
  204. + 
  205. + abs
  206. +    Function: Return the absolute value of ARG.
  207. + acosh
  208. +    Function: Return the inverse hyperbolic cosine of ARG.
  209. + asin
  210. +    Function: Return the inverse sine of ARG.
  211. + asinh
  212. +    Function: Return the inverse hyperbolic sine of ARG.
  213. + atan
  214. +    Function: Return the inverse tangent of ARG.
  215. + atanh
  216. +    Function: Return the inverse hyperbolic tangent of ARG.
  217. + ceiling
  218. +    Function: Return the smallest integer no less than ARG. (round toward +inf)
  219. + cos
  220. +    Function: Return the cosine of ARG.
  221. + cosh
  222. +    Function: Return the hyperbolic cosine of ARG.
  223. + cube-root
  224. +    Function: Return the cube root of ARG.
  225. + erf
  226. +    Function: Return the mathematical error function of ARG.
  227. + erfc
  228. +    Function: Return the complementary error function of ARG.
  229. + exp
  230. +    Function: Return the exponential base e of ARG.
  231. + expm1
  232. +    Function: Return the exp(x)-1 of ARG.
  233. + expt
  234. +    Function: Return the exponential x ** y.
  235. + fceiling
  236. +    Function: Return the smallest integral floating pt. number no less than ARG.
  237. +    (round towards +inf)
  238. + ffloor
  239. +    Function: Return the largest floating pt number no greater than ARG.
  240. +    (round towards -inf)
  241. + float
  242. +    Function: Return the floating pt. number equal to ARG.
  243. + floatp
  244. +    Function: T if OBJECT is a floating pt. number.
  245. + float-output-format
  246. +    Variable: The format descriptor string (or nil) that lisp uses to print out
  247. +    floats.  Nil means use built-in defaults.
  248. +    The descriptor string consists of an optional field-width spec,
  249. +    followed by an optional output-style descriptor.
  250. +    
  251. +    Valid field-widths specs are:
  252. +    The empty string for default precision.
  253. +    0-20 for exponential notation, or 1-20 for decimal point notation.  A 0
  254. +    field spec causes the printing of the decimal point to be supressed.
  255. +    Using an out of bounds specs cause the closest valid spec to be used.
  256. +    
  257. +    Valid ouput-styles may be one of the following:
  258. +    The letter 'e' for exponential notation "<number>.<number>e<number>"
  259. +    The letter 'd' for decimal point notation "<number>.<number>".
  260. +    The empty string, for the defaulted output style.  This may print in
  261. +    either format in a data-dependent manner, choosing whatever produces
  262. +    the shortest string.
  263. +    
  264. + floor
  265. +    Function: Return the largest integer no greater than ARG. (round towards -inf)
  266. + fround
  267. +    Function: Return the nearest integral floating pt. number to ARG.
  268. + ftruncate
  269. +    Function: Truncate a floating point number, returns a float.
  270. +    (Truncates towards zero.) Will fail for floats > max integer.
  271. + garbage-collect
  272. +    Function: Reclaim storage for Lisp objects no longer needed.
  273. +    Returns info on amount of space in use:
  274. +     ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
  275. +      (USED-MARKERS . FREE-MARKERS) (USED-FLOATS . FREE-FLOATS) 
  276. +      USED-STRING-CHARS USED-VECTOR-SLOTS)
  277. +    Garbage collection happens automatically if you cons more than
  278. +    gc-cons-threshold  bytes of Lisp data since previous garbage collection.
  279. + int-to-string
  280. +    Function: Convert INT to a string by printing it in decimal, with minus sign if negative.
  281. + integer-or-float-or-marker-p
  282. +    Function: T if OBJECT is a floating pointt, normal number, or marker.
  283. + integer-or-floatp
  284. +    Function: T if OBJECT is a floating pt. or normal number.
  285. + j0
  286. +    Function: Return the bessel function j0 of ARG.
  287. + j1
  288. +    Function: Return the bessel function j1 of ARG.
  289. + jn
  290. +    Function: Return the bessel function jN of ARG.
  291. + log
  292. +    Function: Return the natural logarithm of ARG.
  293. + log-gamma
  294. +    Function: Return the log gamma of ARG.
  295. + log10
  296. +    Function: Return the logarithm base 10 of ARG.
  297. + log1p
  298. +    Function: Return the log(1+x) of ARG.
  299. + round
  300. +    Function: Return the nearest integer to ARG.
  301. + sin
  302. +    Function: Return the sine of ARG.
  303. + sinh
  304. +    Function: Return the hyperbolic sine of ARG.
  305. + sqrt
  306. +    Function: Return the square root of ARG.
  307. + tan
  308. +    Function: Return the tangent of ARG.
  309. + tanh
  310. +    Function: Return the hyperbolic tangent of ARG.
  311. + truncate
  312. +    Function: Truncate a floating point number to an int.
  313. +    (Truncates toward zero.)
  314. + y0
  315. +    Function: Return the bessel function y0 of ARG.
  316. + y1
  317. +    Function: Return the bessel function y1 of ARG.
  318. + yn
  319. +    Function: Return the bessel function yN of ARG.
  320.  
  321. *** emacs-18.57/lisp/float-sup.el    Tue Aug 13 14:18:46 1991
  322. --- emacs/lisp/float-sup.el    Tue Aug 13 10:52:38 1991
  323. ***************
  324. *** 0 ****
  325. --- 1,81 ----
  326. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  327. + ;;                                         ;;
  328. + ;;    File:     float-sup.el                             ;;
  329. + ;;    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 ;;
  330. + ;;    Created:  Mon Oct 26 09:12:18 EST 1987                     ;;
  331. + ;;    Contents: Flonum support routines and useful constants.             ;;
  332. + ;;          This file is just the tip of the of the iceberg, as        ;;
  333. + ;;          most of the flonum stuff is in the C code.                  ;;
  334. + ;;                                         ;;
  335. + ;;    Copyright (c) 1987 Wolfgang Rupprecht.                     ;;
  336. + ;;    All rights reserved.                             ;;
  337. + ;;                                         ;;
  338. + ;;    $Log$                                     ;;
  339. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  340. + 
  341. + ;; GNU Emacs and this file "float-sup.el", is distributed in the hope
  342. + ;; that it will be useful, but WITHOUT ANY WARRANTY.  No author or
  343. + ;; distributor accepts responsibility to anyone for the consequences of
  344. + ;; using it or for whether it serves any particular purpose or works at
  345. + ;; all, unless he says so in writing.  Refer to the GNU Emacs General
  346. + ;; Public License for full details.
  347. + 
  348. + ;; Everyone is granted permission to copy, modify and redistribute GNU
  349. + ;; Emacs and float-sup.el, but only under the conditions described in the
  350. + ;; GNU Emacs General Public License.  A copy of this license is supposed
  351. + ;; to have been given to you along with GNU Emacs so you can know your
  352. + ;; rights and responsibilities.  It should be in a file named COPYING.
  353. + ;; Among other things, the copyright notice and this notice must be
  354. + ;; preserved on all copies.
  355. + 
  356. + ;; If you like my floating point hack, and would like other custom
  357. + ;; (non-proprietary) GnuEmacs extensions, let me know. I may be
  358. + ;; interested in doing it for you on a contract basis. -wsr
  359. + 
  360. + ;; Provide a meaningful error message if we are running on
  361. + ;; bare (non-float) emacs.
  362. + ;; Can't test for 'floatp since that may be defined by float-imitation
  363. + ;; packages like float.el in this very directory.
  364. + 
  365. + (if (fboundp 'integer-or-floatp)
  366. +     nil
  367. +   (error
  368. +     "Can't load float-sup. You aren't running GnuEmacs with the Lisp_Float data type."))
  369. + 
  370. + ;; provide an easy hook to tell if we are running with floats or not.
  371. + (provide 'lisp-float-type)
  372. + 
  373. + ;; define pi and e via math-lib calls. (much less prone to killer typos.)
  374. + (defconst pi (* 4 (atan 1)) "The value of Pi (3.1415926...)")
  375. + (defconst e (exp 1) "The value of e (2.7182818...)")
  376. + 
  377. + ;; Careful when editing this file ... typos here will be hard to spot.
  378. + ;; (defconst pi       3.14159265358979323846264338327
  379. + ;;  "The value of Pi (3.14159265358979323846264338327...)")
  380. + 
  381. + (defconst degrees-to-radians (/ pi 180.0)
  382. +   "Degrees to radian conversion constant")
  383. + (defconst radians-to-degrees (/ 180.0 pi)
  384. +   "Radian to degree conversion constant")
  385. + 
  386. + ;; these expand to a single multiply by a float
  387. + ;; when byte compiled
  388. + 
  389. + (defmacro degrees-to-radians (x)
  390. +   "Convert ARG from degrees to radians."
  391. +   (list '* (/ pi 180.0) x))
  392. + (defmacro radians-to-degrees (x)
  393. +   "Convert ARG from radians to degrees."
  394. +   (list '* (/ 180.0 pi) x))
  395. + 
  396. + ;; some readability macros.
  397. + ;; will eval arg several times,
  398. + ;; but is that a problem?
  399. + 
  400. + (defmacro squared (x)
  401. +   "Return the square of ARG."
  402. +   (list '* x x))
  403. + (defmacro cubed (x)
  404. +   "Return the cube of ARG."
  405. +   (list '* x x x))
  406. + 
  407. diff -rc emacs-18.57/lisp/bytecomp.el emacs/lisp/bytecomp.el
  408. *** emacs-18.57/lisp/bytecomp.el    Wed Jan  9 22:56:32 1991
  409. --- emacs/lisp/bytecomp.el    Tue Aug 13 10:52:38 1991
  410. ***************
  411. *** 1,3 ****
  412. --- 1,15 ----
  413. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  414. + ;;                                         ;;
  415. + ;;    File:     bytecomp.el                             ;;
  416. + ;;    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 ;;
  417. + ;;    Created:  Thu Nov  5 15:06:50 EST 1987                     ;;
  418. + ;;    Contents: Gnu bytecomp file, with changes for lisp floats         ;;
  419. + ;;                                         ;;
  420. + ;;    Copyright (c) 1987 Wolfgang Rupprecht.                     ;;
  421. + ;;    All rights reserved.                             ;;
  422. + ;;                                         ;;
  423. + ;;    $Log$                                     ;;
  424. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  425.   ;; Compilation of Lisp code into byte code.
  426.   ;; Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
  427.   
  428. ***************
  429. *** 220,233 ****
  430.         (set-buffer outbuffer)
  431.         (emacs-lisp-mode)
  432.         (erase-buffer)
  433. !       (while (save-excursion
  434. !            (set-buffer inbuffer)
  435. !            (while (progn (skip-chars-forward " \t\n\^l")
  436. !                  (looking-at ";"))
  437. !          (forward-line 1))
  438. !            (not (eobp)))
  439. !     (setq sexp (read inbuffer))
  440. !     (print (byte-compile-file-form sexp) outbuffer))
  441.         (set-buffer outbuffer)
  442.         (goto-char 1)
  443.         ;; In each defun or autoload, if there is a doc string,
  444. --- 232,247 ----
  445.         (set-buffer outbuffer)
  446.         (emacs-lisp-mode)
  447.         (erase-buffer)
  448. ! ;; don't let floats get truncated in the process of printing them.
  449. !       (let ((float-output-format "20e"))
  450. !     (while (save-excursion
  451. !          (set-buffer inbuffer)
  452. !          (while (progn (skip-chars-forward " \t\n\^l")
  453. !                    (looking-at ";"))
  454. !            (forward-line 1))
  455. !          (not (eobp)))
  456. !       (setq sexp (read inbuffer))
  457. !       (print (byte-compile-file-form sexp) outbuffer)))
  458.         (set-buffer outbuffer)
  459.         (goto-char 1)
  460.         ;; In each defun or autoload, if there is a doc string,
  461. Only in emacs/lisp: float-sup.el
  462. diff -rc emacs-18.57/lisp/lisp-mode.el emacs/lisp/lisp-mode.el
  463. *** emacs-18.57/lisp/lisp-mode.el    Wed Jan  9 23:01:19 1991
  464. --- emacs/lisp/lisp-mode.el    Tue Aug 13 10:52:55 1991
  465. ***************
  466. *** 1,3 ****
  467. --- 1,15 ----
  468. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  469. + ;;                                         ;;
  470. + ;;    File:     lisp-mode.el                             ;;
  471. + ;;    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 ;;
  472. + ;;    Created:  Thu Nov  5 23:36:37 EST 1987                     ;;
  473. + ;;    Contents: GNU lisp-mode file, with my changes for float support         ;;
  474. + ;;                                         ;;
  475. + ;;    Copyright (c) 1987 Wolfgang Rupprecht.                     ;;
  476. + ;;    All rights reserved.                             ;;
  477. + ;;                                         ;;
  478. + ;;    $Log$                                     ;;
  479. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  480.   ;; Lisp mode, and its idiosyncratic commands.
  481.   ;; Copyright (C) 1985 Free Software Foundation, Inc.
  482.   
  483. ***************
  484. *** 48,54 ****
  485.         (modify-syntax-entry ?` "'   " emacs-lisp-mode-syntax-table)
  486.         (modify-syntax-entry ?' "'   " emacs-lisp-mode-syntax-table)
  487.         (modify-syntax-entry ?, "'   " emacs-lisp-mode-syntax-table)
  488. !       (modify-syntax-entry ?. "'   " emacs-lisp-mode-syntax-table)
  489.         (modify-syntax-entry ?# "'   " emacs-lisp-mode-syntax-table)
  490.         (modify-syntax-entry ?\" "\"    " emacs-lisp-mode-syntax-table)
  491.         (modify-syntax-entry ?\\ "\\   " emacs-lisp-mode-syntax-table)
  492. --- 60,72 ----
  493.         (modify-syntax-entry ?` "'   " emacs-lisp-mode-syntax-table)
  494.         (modify-syntax-entry ?' "'   " emacs-lisp-mode-syntax-table)
  495.         (modify-syntax-entry ?, "'   " emacs-lisp-mode-syntax-table)
  496. ! 
  497. !       ;; This needs to be changed for the float stuff.
  498. !       ;; I don't want to conditionalize this since it should
  499. !       ;; work the same way if floats are present or not. -wsr
  500. !       ;; (modify-syntax-entry ?. "'   " lisp-mode-syntax-table)
  501. !       (modify-syntax-entry ?. "_   " lisp-mode-syntax-table)
  502. ! 
  503.         (modify-syntax-entry ?# "'   " emacs-lisp-mode-syntax-table)
  504.         (modify-syntax-entry ?\" "\"    " emacs-lisp-mode-syntax-table)
  505.         (modify-syntax-entry ?\\ "\\   " emacs-lisp-mode-syntax-table)
  506. diff -rc emacs-18.57/lisp/loadup.el emacs/lisp/loadup.el
  507. *** emacs-18.57/lisp/loadup.el    Wed Jan  9 23:01:30 1991
  508. --- emacs/lisp/loadup.el    Tue Aug 13 10:53:01 1991
  509. ***************
  510. *** 1,3 ****
  511. --- 1,15 ----
  512. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  513. + ;;                                         ;;
  514. + ;;    File:     loadup.el                             ;;
  515. + ;;    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 ;;
  516. + ;;    Created:  Thu Nov  5 11:44:26 EST 1987                     ;;
  517. + ;;    Contents: GNU loadup file, with my float code                 ;;
  518. + ;;                                         ;;
  519. + ;;    Copyright (c) 1987 Wolfgang Rupprecht.                     ;;
  520. + ;;    All rights reserved.                             ;;
  521. + ;;                                         ;;
  522. + ;;    $Log$                                     ;;
  523. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  524.   ;Load up standardly loaded Lisp files for Emacs.
  525.   ;; This is loaded into a bare Emacs to make a dumpable one.
  526.   ;; Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  527. ***************
  528. *** 62,67 ****
  529. --- 74,84 ----
  530.       (progn
  531.         (garbage-collect)
  532.         (load "vms-patch")))
  533. + (if (fboundp 'integer-or-floatp)    ; preload some constants and 
  534. +     (progn                ; floating pt. functions if 
  535. +       (garbage-collect)            ; we have float support.
  536. +       (load "float-sup")))
  537. + 
  538.   
  539.   ;If you want additional libraries to be preloaded and their
  540.   ;doc strings kept in the DOC file rather than in core,
  541. diff -rc emacs-18.57/lisp/sort.el emacs/lisp/sort.el
  542. *** emacs-18.57/lisp/sort.el    Wed Jan  9 23:04:27 1991
  543. --- emacs/lisp/sort.el    Tue Aug 13 11:21:48 1991
  544. ***************
  545. *** 1,3 ****
  546. --- 1,16 ----
  547. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  548. + ;;                                         ;;
  549. + ;;    File:     sort.el                             ;;
  550. + ;;    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 ;;
  551. + ;;    Created:  Wed May 18 12:48:23 EDT 1988                     ;;
  552. + ;;    Contents: Gnu emacs code, with patches to make it work with floats   ;;
  553. + ;;                                         ;;
  554. + ;;    Copyright (c) 1988 Wolfgang Rupprecht.                     ;;
  555. + ;;    All rights reserved.                             ;;
  556. + ;;                                         ;;
  557. + ;;    $Log$                                     ;;
  558. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  559. + 
  560.   ;; Commands to sort text in an Emacs buffer.
  561.   ;; Copyright (C) 1986, 1987 Free Software Foundation, Inc.
  562.   
  563. ***************
  564. *** 199,204 ****
  565. --- 212,218 ----
  566.       (modify-syntax-entry ?\  " " table)
  567.       (modify-syntax-entry ?\t " " table)
  568.       (modify-syntax-entry ?\n " " table)
  569. +     (modify-syntax-entry ?\. "_" table)    ; for floating pt. numbers. -wsr
  570.       (setq sort-fields-syntax-table table)))
  571.   
  572.   (defun sort-numeric-fields (field beg end)
  573. ***************
  574. *** 216,222 ****
  575.                     (buffer-substring
  576.                       (point)
  577.                   (save-excursion
  578. !                   (skip-chars-forward "-0-9")
  579.                     (point))))))
  580.            nil))
  581.   
  582. --- 230,238 ----
  583.                     (buffer-substring
  584.                       (point)
  585.                   (save-excursion
  586. !                   ;; This is just wrong! Even without floats...
  587. !                   ;; (skip-chars-forward "-0-9")
  588. !                   (forward-sexp 1)
  589.                     (point))))))
  590.            nil))
  591.   
  592. *** emacs-18.57/lisp/startup.el    Wed Jan 16 05:19:04 1991
  593. --- emacs/lisp/startup.el    Tue Aug 13 10:53:14 1991
  594. ***************
  595. *** 1,3 ****
  596. --- 1,15 ----
  597. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  598. + ;;                                         ;;
  599. + ;;    File:     startup.el                             ;;
  600. + ;;    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 ;;
  601. + ;;    Created:  Thu Nov  5 16:58:42 EST 1987                     ;;
  602. + ;;    Contents: GNU startup file with floating point support              ;;
  603. + ;;                                         ;;
  604. + ;;    Copyright (c) 1987 Wolfgang Rupprecht.                     ;;
  605. + ;;    All rights reserved.                             ;;
  606. + ;;                                         ;;
  607. + ;;    $Log$                                     ;;
  608. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  609.   ;; Process Emacs shell arguments
  610.   ;; Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  611.   
  612. ***************
  613. *** 166,171 ****
  614. --- 178,188 ----
  615.            (unwind-protect
  616.            (progn
  617.              (insert (emacs-version)
  618. +                ;; this next sexp can get nuked once FSF
  619. +                ;; owns this code. -wsr
  620. +                (if (featurep 'lisp-float-type)
  621. +                    "\nCopyright (C) 1987 Wolfgang Rupprecht."
  622. +                  "")
  623.                  "
  624.   Copyright (C) 1990 Free Software Foundation, Inc.\n")
  625.              ;; If keys have their default meanings,
  626. ***************
  627. *** 190,195 ****
  628. --- 207,221 ----
  629.   You may give out copies of Emacs; type \\[describe-copying] to see the conditions.
  630.   Type \\[describe-distribution] for information on getting the latest version.
  631.   Type \\[help-with-tutorial] for a tutorial on using Emacs.")))
  632. + ;;;
  633. + ;;; And now a message for the lawyer-slimes of this world. -wsr
  634. + ;;;
  635. +            (if (featurep 'lisp-float-type)
  636. +                (insert "\n
  637. + This version of emacs contains a floating point data type allowing you
  638. + do calculations with real numbers, just like a calculator.  This code
  639. + may not always yield the correct answers under all conditions.
  640. +     YOU ARE RESPONSIBLE FOR CHECKING THE ANSWERS!\n"))
  641.              (set-buffer-modified-p nil)
  642.              (sit-for 120))
  643.              (save-excursion
  644. diff -rc emacs-18.57/lisp/subr.el emacs/lisp/subr.el
  645. *** emacs-18.57/lisp/subr.el    Wed Jan  9 23:04:45 1991
  646. --- emacs/lisp/subr.el    Tue Aug 13 10:53:24 1991
  647. ***************
  648. *** 1,3 ****
  649. --- 1,15 ----
  650. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  651. + ;;                                         ;;
  652. + ;;    File:     subr.el                             ;;
  653. + ;;    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 ;;
  654. + ;;    Created:  Thu Dec 31 14:01:32 EST 1987                     ;;
  655. + ;;    Contents: The Gnu subr.el file, with my float stuff             ;;
  656. + ;;                                         ;;
  657. + ;;    Copyright (c) 1987 Wolfgang Rupprecht.                     ;;
  658. + ;;    All rights reserved.                             ;;
  659. + ;;                                         ;;
  660. + ;;    $Log$                                     ;;
  661. + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  662.   ;; Basic lisp subroutines for Emacs
  663.   ;; Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
  664.   
  665. ***************
  666. *** 150,156 ****
  667.   (fset 'move-marker 'set-marker)
  668.   (fset 'eql 'eq)
  669.   (fset 'not 'null)
  670. ! (fset 'numberp 'integerp)
  671.   (fset 'rplaca 'setcar)
  672.   (fset 'rplacd 'setcdr)
  673.   (fset 'beep 'ding) ;preserve lingual purtity
  674. --- 162,170 ----
  675.   (fset 'move-marker 'set-marker)
  676.   (fset 'eql 'eq)
  677.   (fset 'not 'null)
  678. ! (if (fboundp 'integer-or-floatp)
  679. !     (fset 'numberp 'integer-or-floatp)
  680. !   (fset 'numberp 'integerp))
  681.   (fset 'rplaca 'setcar)
  682.   (fset 'rplacd 'setcdr)
  683.   (fset 'beep 'ding) ;preserve lingual purtity
  684. diff -rc emacs-18.57/src/alloc.c emacs/src/alloc.c
  685. *** emacs-18.57/src/alloc.c    Sat Jan  5 01:12:10 1991
  686. --- emacs/src/alloc.c    Tue Aug 13 10:50:53 1991
  687. ***************
  688. *** 1,3 ****
  689. --- 1,15 ----
  690. + /******************************************************************************
  691. + *                                          *
  692. + *    File:     alloc.c                              *
  693. + *    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 *
  694. + *    Created:  Mon Nov  2 15:20:48 EST 1987                      *
  695. + *    Contents: GNU alloc.c with my float code                  *
  696. + *                                          *
  697. + *    Copyright (c) 1987 Wolfgang Rupprecht.                      *
  698. + *    All rights reserved.                              *
  699. + *                                          *
  700. + *    $Log$                                      *
  701. + ******************************************************************************/
  702.   /* Storage allocation and gc for GNU Emacs Lisp interpreter.
  703.      Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  704.   
  705. ***************
  706. *** 195,200 ****
  707. --- 207,287 ----
  708.     cons_free_list = ptr;
  709.   }
  710.   
  711. + #ifdef LISP_FLOAT_TYPE
  712. + 
  713. + /* Allocation of float cells, just like conses */
  714. + /* We store float cells inside of float_blocks, allocating a new
  715. +  float_block with malloc whenever necessary.  Float cells reclaimed by
  716. +  GC are put on a free list to be reallocated before allocating
  717. +  any new float cells from the latest float_block.
  718. + 
  719. +  Each float_block is just under 1020 bytes long,
  720. +  since malloc really allocates in units of powers of two
  721. +  and uses 4 bytes for its own overhead. */
  722. + 
  723. + #define FLOAT_BLOCK_SIZE \
  724. +   ((1020 - sizeof (struct float_block *)) / sizeof (struct Lisp_Float))
  725. + 
  726. + struct float_block
  727. +   {
  728. +     struct float_block *next;
  729. +     struct Lisp_Float floats[FLOAT_BLOCK_SIZE];
  730. +   };
  731. + 
  732. + struct float_block *float_block;
  733. + int float_block_index;
  734. + 
  735. + struct Lisp_Float *float_free_list;
  736. + 
  737. + void
  738. + init_float ()
  739. + {
  740. +   float_block = (struct float_block *) malloc (sizeof (struct float_block));
  741. +   float_block->next = 0;
  742. +   bzero (float_block->floats, sizeof float_block->floats);
  743. +   float_block_index = 0;
  744. +   float_free_list = 0;
  745. + }
  746. + 
  747. + /* Explicitly free a float cell.  */
  748. + free_float (ptr)
  749. +      struct Lisp_Float *ptr;
  750. + {
  751. +   XFASTINT (ptr->type) = (int) float_free_list;
  752. +   float_free_list = ptr;
  753. + }
  754. + 
  755. + Lisp_Object
  756. + make_float (float_value)
  757. +      double float_value;
  758. + {
  759. +   register Lisp_Object val;
  760. + 
  761. +   if (float_free_list)
  762. +     {
  763. +       XSET (val, Lisp_Float, float_free_list);
  764. +       float_free_list = (struct Lisp_Float *) XFASTINT (float_free_list->type);
  765. +     }
  766. +   else
  767. +     {
  768. +       if (float_block_index == FLOAT_BLOCK_SIZE)
  769. +     {
  770. +       register struct float_block *new = (struct float_block *) malloc (sizeof (struct float_block));
  771. +       if (!new) memory_full ();
  772. +       new->next = float_block;
  773. +       float_block = new;
  774. +       float_block_index = 0;
  775. +     }
  776. +       XSET (val, Lisp_Float, &float_block->floats[float_block_index++]);
  777. +     }
  778. +   XFLOAT (val)->data = float_value;
  779. +   XFLOAT (val)->type = 0;    /* bug chasing -wsr */
  780. +   consing_since_gc += sizeof (struct Lisp_Float);
  781. +   return val;
  782. + }
  783. + #endif LISP_FLOAT_TYPE
  784. + 
  785. + 
  786.   DEFUN ("cons", Fcons, Scons, 2, 2, 0,
  787.     "Create a new cons, give it CAR and CDR as components, and return it.")
  788.     (car, cdr)
  789. ***************
  790. *** 650,656 ****
  791. --- 737,761 ----
  792.     return new;
  793.   }
  794.   
  795. + #ifdef LISP_FLOAT_TYPE
  796.   Lisp_Object
  797. + pure_float (num)
  798. +      double num;
  799. + {
  800. +   register Lisp_Object new;
  801. + 
  802. +   if (pureptr + sizeof (struct Lisp_Float) > PURESIZE)
  803. +     error ("Pure Lisp storage exhausted");
  804. +   XSET (new, Lisp_Float, PUREBEG + pureptr);
  805. +   pureptr += sizeof (struct Lisp_Float);
  806. +   XFLOAT (new)->data = num;
  807. +   XFLOAT (new)->type = 0;    /* bug chasing -wsr */
  808. +   return new;
  809. + }
  810. + 
  811. + #endif LISP_FLOAT_TYPE
  812. + 
  813. + Lisp_Object
  814.   make_pure_vector (len)
  815.        int len;
  816.   {
  817. ***************
  818. *** 695,700 ****
  819. --- 800,810 ----
  820.       case Lisp_Cons:
  821.         return pure_cons (XCONS (obj)->car, XCONS (obj)->cdr);
  822.   
  823. + #ifdef LISP_FLOAT_TYPE
  824. +     case Lisp_Float:
  825. +       return pure_float (XFLOAT (obj)->data);
  826. + #endif LISP_FLOAT_TYPE
  827. + 
  828.       case Lisp_String:
  829.         return make_pure_string (XSTRING (obj)->data, XSTRING (obj)->size);
  830.   
  831. ***************
  832. *** 784,794 ****
  833. --- 894,909 ----
  834.   
  835.   int total_conses, total_markers, total_symbols, total_string_size, total_vector_size;
  836.   int total_free_conses, total_free_markers, total_free_symbols;
  837. + #ifdef LISP_FLOAT_TYPE
  838. + int total_free_floats, total_floats;
  839. + #endif LISP_FLOAT_TYPE
  840.   
  841.   static void mark_object (), mark_buffer ();
  842.   static void clear_marks (), gc_sweep ();
  843.   static void compact_strings ();
  844.   
  845. + #ifndef LISP_FLOAT_TYPE
  846. + 
  847.   DEFUN ("garbage-collect", Fgarbage_collect, Sgarbage_collect, 0, 0, "",
  848.     "Reclaim storage for Lisp objects no longer needed.\n\
  849.   Returns info on amount of space in use:\n\
  850. ***************
  851. *** 795,802 ****
  852.    ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)\n\
  853.     (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS)\n\
  854.   Garbage collection happens automatically if you cons more than\n\
  855. ! gc-cons-threshold  bytes of Lisp data since previous garbage collection.")
  856.     ()
  857.   {
  858.     register struct gcpro *tail;
  859.     register struct specbinding *bind;
  860. --- 910,930 ----
  861.    ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)\n\
  862.     (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS)\n\
  863.   Garbage collection happens automatically if you cons more than\n\
  864. ! gc-cons-threshold  bytes of Lisp data since previous garbage collection."
  865. !        )
  866.     ()
  867. + #else LISP_FLOAT_TYPE
  868. + 
  869. + DEFUN ("garbage-collect", Fgarbage_collect, Sgarbage_collect, 0, 0, "",  "Reclaim storage for Lisp objects no longer needed.\n\
  870. + Returns info on amount of space in use:\n\
  871. +  ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)\n\
  872. +   (USED-MARKERS . FREE-MARKERS) (USED-FLOATS . FREE-FLOATS) \n\
  873. +   USED-STRING-CHARS USED-VECTOR-SLOTS)\n\
  874. + Garbage collection happens automatically if you cons more than\n\
  875. + gc-cons-threshold  bytes of Lisp data since previous garbage collection."
  876. +        )
  877. +   ()
  878. + #endif LISP_FLOAT_TYPE
  879.   {
  880.     register struct gcpro *tail;
  881.     register struct specbinding *bind;
  882. ***************
  883. *** 919,927 ****
  884. --- 1047,1064 ----
  885.                     make_number (total_free_symbols)),
  886.                  Fcons (Fcons (make_number (total_markers),
  887.                        make_number (total_free_markers)),
  888. + #ifdef LISP_FLOAT_TYPE
  889. +                   Fcons (Fcons (make_number (total_floats),
  890. +                         make_number (total_free_floats)),
  891. +                      Fcons (make_number (total_string_size),
  892. +                         Fcons (make_number (total_vector_size),
  893. +                            Qnil))))));
  894. + #else not LISP_FLOAT_TYPE
  895.                     Fcons (make_number (total_string_size),
  896.                        Fcons (make_number (total_vector_size),
  897.                           Qnil)))));
  898. + #endif LISP_FLOAT_TYPE
  899. + 
  900.   }
  901.   
  902.   #if 0
  903. ***************
  904. *** 1113,1118 ****
  905. --- 1250,1261 ----
  906.       goto loop;
  907.         }
  908.   
  909. + #ifdef LISP_FLOAT_TYPE
  910. +  case Lisp_Float:
  911. +       XMARK (XFLOAT (obj)->type);
  912. +       break;
  913. + #endif LISP_FLOAT_TYPE
  914. + 
  915.       case Lisp_Buffer:
  916.         if (!XMARKBIT (XBUFFER (obj)->name))
  917.       mark_buffer (obj);
  918. ***************
  919. *** 1193,1199 ****
  920. --- 1336,1372 ----
  921.       total_conses = num_used;
  922.       total_free_conses = num_free;
  923.     }
  924. + #ifdef LISP_FLOAT_TYPE
  925. +   /* Put all unmarked floats on free list */
  926. +   {
  927. +     register struct float_block *fblk;
  928. +     register int lim = float_block_index;
  929. +     register int num_free = 0, num_used = 0;
  930.   
  931. +     float_free_list = 0;
  932. +   
  933. +     for (fblk = float_block; fblk; fblk = fblk->next)
  934. +       {
  935. +     register int i;
  936. +     for (i = 0; i < lim; i++)
  937. +       if (!XMARKBIT (fblk->floats[i].type))
  938. +         {
  939. +           XFASTINT (fblk->floats[i].type) = (int) float_free_list;
  940. +           num_free++;
  941. +           float_free_list = &fblk->floats[i];
  942. +         }
  943. +       else
  944. +         {
  945. +           num_used++;
  946. +           XUNMARK (fblk->floats[i].type);
  947. +         }
  948. +     lim = FLOAT_BLOCK_SIZE;
  949. +       }
  950. +     total_floats = num_used;
  951. +     total_free_floats = num_free;
  952. +   }
  953. + #endif LISP_FLOAT_TYPE
  954. + 
  955.     /* Put all unmarked symbols on free list */
  956.     {
  957.       register struct symbol_block *sblk;
  958. ***************
  959. *** 1484,1489 ****
  960. --- 1657,1665 ----
  961.     all_vectors = 0;
  962.     init_strings ();
  963.     init_cons ();
  964. + #ifdef LISP_FLOAT_TYPE
  965. +   init_float ();
  966. + #endif LISP_FLOAT_TYPE
  967.     init_symbol ();
  968.     init_marker ();
  969.     gcprolist = 0;
  970. diff -rc emacs-18.57/src/callint.c emacs/src/callint.c
  971. *** emacs-18.57/src/callint.c    Sat Jan  5 01:13:13 1991
  972. --- emacs/src/callint.c    Tue Aug 13 10:51:08 1991
  973. ***************
  974. *** 352,358 ****
  975. --- 352,363 ----
  976.       case 'n':        /* Read number from minibuffer.  */
  977.         do
  978.           args[i] = Fread_minibuffer (build_string (prompt), Qnil);
  979. + #ifdef LISP_FLOAT_TYPE
  980. +       while ((XTYPE (args[i]) != Lisp_Int) &&
  981. +          (XTYPE (args[i]) != Lisp_Float));
  982. + #else
  983.         while (XTYPE (args[i]) != Lisp_Int);
  984. + #endif
  985.         visargs[i] = last_minibuf_string;
  986.         break;
  987.   
  988. diff -rc emacs-18.57/src/config.h-dist emacs/src/config.h-dist
  989. *** emacs-18.57/src/config.h-dist    Tue Jan  8 19:24:37 1991
  990. --- emacs/src/config.h-dist    Tue Aug 13 10:51:26 1991
  991. ***************
  992. *** 17,23 ****
  993. --- 17,28 ----
  994.   along with GNU Emacs; see the file COPYING.  If not, write to
  995.   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  996.   
  997. + /* This is a hack feature added by me.
  998. +  * It probably won't break anything too badly, but it may not do
  999. +  * much for you either. -Wolfgang Rupprecht 10/25/87
  1000. +  */
  1001.   
  1002. + /* #define LISP_FLOAT_TYPE        /* define this for floating pt. numbers */
  1003.   
  1004.   /* Include here a s- file that describes the system type you are using.
  1005.      See the file ../etc/MACHINES for a list of systems and
  1006. diff -rc emacs-18.57/src/crt0.c emacs/src/crt0.c
  1007. *** emacs-18.57/src/crt0.c    Tue Jan  8 18:23:04 1991
  1008. --- emacs/src/crt0.c    Tue Aug 13 10:51:36 1991
  1009. ***************
  1010. *** 287,292 ****
  1011. --- 287,297 ----
  1012.   
  1013.   _start ()
  1014.   {
  1015. + #ifdef LISP_FLOAT_TYPE
  1016. + # ifdef sun3
  1017. +   finitfp_();
  1018. + # endif
  1019. + #endif
  1020.   /* On 68000, _start pushes a6 onto stack  */
  1021.     start1 ();
  1022.   }
  1023. diff -rc emacs-18.57/src/data.c emacs/src/data.c
  1024. *** emacs-18.57/src/data.c    Sat Jan  5 01:15:14 1991
  1025. --- emacs/src/data.c    Tue Aug 13 11:15:28 1991
  1026. ***************
  1027. *** 1,3 ****
  1028. --- 1,15 ----
  1029. + /******************************************************************************
  1030. + *                                          *
  1031. + *    File:     data.c                              *
  1032. + *    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 *
  1033. + *    Created:  Mon Nov  2 15:22:23 EST 1987                      *
  1034. + *    Contents: GNU data.c with my float code                      *
  1035. + *                                          *
  1036. + *    Copyright (c) 1987 Wolfgang Rupprecht.                      *
  1037. + *    All rights reserved.                              *
  1038. + *                                          *
  1039. + *    $Log$                                      *
  1040. + ******************************************************************************/
  1041.   /* Primitive operations on Lisp data types for GNU Emacs Lisp interpreter.
  1042.      Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  1043.   
  1044. ***************
  1045. *** 27,32 ****
  1046. --- 39,48 ----
  1047.   #include "buffer.h"
  1048.   #endif
  1049.   
  1050. + #ifdef LISP_FLOAT_TYPE
  1051. + #include <math.h>
  1052. + #endif LISP_FLOAT_TYPE
  1053. + 
  1054.   Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
  1055.   Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
  1056.   Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
  1057. ***************
  1058. *** 40,46 ****
  1059. --- 56,67 ----
  1060.   Lisp_Object Qchar_or_string_p, Qmarkerp, Qinteger_or_marker_p, Qvectorp;
  1061.   Lisp_Object Qboundp, Qfboundp;
  1062.   Lisp_Object Qcdr;
  1063. + #ifdef LISP_FLOAT_TYPE
  1064. + Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
  1065. + #endif LISP_FLOAT_TYPE
  1066.   
  1067. + 
  1068. + 
  1069.   Lisp_Object
  1070.   wrong_type_argument (predicate, value)
  1071.        register Lisp_Object predicate, value;
  1072. ***************
  1073. *** 176,181 ****
  1074. --- 197,237 ----
  1075.     return Qnil;
  1076.   }
  1077.   
  1078. + #ifdef LISP_FLOAT_TYPE
  1079. + DEFUN ("floatp", Ffloatp, Sfloatp, 1, 1, 0,
  1080. +        "T if OBJECT is a floating pt. number.")
  1081. +   (obj)
  1082. +      Lisp_Object obj;
  1083. + {
  1084. +   if (XTYPE (obj) == Lisp_Float)
  1085. +     return Qt;
  1086. +   return Qnil;
  1087. + }
  1088. + 
  1089. + DEFUN ("integer-or-floatp", Finteger_or_floatp, Sinteger_or_floatp,
  1090. +        1, 1, 0, "T if OBJECT is a floating pt. or normal number.")
  1091. +   (obj)
  1092. +      Lisp_Object obj;
  1093. + {
  1094. +   if ((XTYPE (obj) == Lisp_Float) || (XTYPE (obj) == Lisp_Int))
  1095. +     return Qt;
  1096. +   return Qnil;
  1097. + }
  1098. + 
  1099. + DEFUN ("integer-or-float-or-marker-p", Finteger_or_float_or_marker_p,
  1100. +        Sinteger_or_float_or_marker_p, 1, 1, 0,
  1101. +        "T if OBJECT is a floating pointt, normal number, or marker.")
  1102. +   (obj)
  1103. +      Lisp_Object obj;
  1104. + {
  1105. +   if ((XTYPE (obj) == Lisp_Float) ||
  1106. +       (XTYPE (obj) == Lisp_Int) ||
  1107. +       (XTYPE (obj) == Lisp_Marker))
  1108. +     return Qt;
  1109. +   return Qnil;
  1110. + }
  1111. + #endif LISP_FLOAT_TYPE
  1112. + 
  1113.   DEFUN ("natnump", Fnatnump, Snatnump, 1, 1, 0, "T if OBJECT is a nonnegative number.")
  1114.     (obj)
  1115.        Lisp_Object obj;
  1116. ***************
  1117. *** 971,978 ****
  1118. --- 1027,1051 ----
  1119.     (num1, num2)
  1120.        register Lisp_Object num1, num2;
  1121.   {
  1122. + #ifdef LISP_FLOAT_TYPE
  1123. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  1124. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
  1125. + 
  1126. +   if ((XTYPE(num1) == Lisp_Float) || (XTYPE(num2) == Lisp_Float))
  1127. +     {
  1128. +       double f1, f2;
  1129. + 
  1130. +       f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  1131. +       f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  1132. +       if (f1 == f2)
  1133. +     return Qt;
  1134. +       return Qnil;
  1135. +     }
  1136. + 
  1137. + #else
  1138.     CHECK_NUMBER_COERCE_MARKER (num1, 0);
  1139.     CHECK_NUMBER_COERCE_MARKER (num2, 0);
  1140. + #endif LISP_FLOAT_TYPE
  1141.   
  1142.     if (XINT (num1) == XINT (num2))
  1143.       return Qt;
  1144. ***************
  1145. *** 984,991 ****
  1146. --- 1057,1080 ----
  1147.     (num1, num2)
  1148.        register Lisp_Object num1, num2;
  1149.   {
  1150. + #ifdef LISP_FLOAT_TYPE
  1151. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  1152. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
  1153. + 
  1154. +   if ((XTYPE(num1) == Lisp_Float) || (XTYPE(num2) == Lisp_Float))
  1155. +     {
  1156. +       double f1, f2;
  1157. + 
  1158. +       f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  1159. +       f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  1160. +       if (f1 < f2)
  1161. +     return Qt;
  1162. +       return Qnil;
  1163. +     }
  1164. + #else
  1165.     CHECK_NUMBER_COERCE_MARKER (num1, 0);
  1166.     CHECK_NUMBER_COERCE_MARKER (num2, 0);
  1167. + #endif LISP_FLOAT_TYPE
  1168.   
  1169.     if (XINT (num1) < XINT (num2))
  1170.       return Qt;
  1171. ***************
  1172. *** 997,1004 ****
  1173. --- 1086,1109 ----
  1174.     (num1, num2)
  1175.        register Lisp_Object num1, num2;
  1176.   {
  1177. + #ifdef LISP_FLOAT_TYPE
  1178. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  1179. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
  1180. + 
  1181. +   if ((XTYPE(num1) == Lisp_Float) || (XTYPE(num2) == Lisp_Float))
  1182. +     {
  1183. +       double f1, f2;
  1184. + 
  1185. +       f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  1186. +       f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  1187. +       if (f1 > f2)
  1188. +     return Qt;
  1189. +       return Qnil;
  1190. +     }
  1191. + #else
  1192.     CHECK_NUMBER_COERCE_MARKER (num1, 0);
  1193.     CHECK_NUMBER_COERCE_MARKER (num2, 0);
  1194. + #endif LISP_FLOAT_TYPE
  1195.   
  1196.     if (XINT (num1) > XINT (num2))
  1197.       return Qt;
  1198. ***************
  1199. *** 1010,1017 ****
  1200. --- 1115,1138 ----
  1201.     (num1, num2)
  1202.        register Lisp_Object num1, num2;
  1203.   {
  1204. + #ifdef LISP_FLOAT_TYPE
  1205. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  1206. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
  1207. + 
  1208. +   if ((XTYPE(num1) == Lisp_Float) || (XTYPE(num2) == Lisp_Float))
  1209. +     {
  1210. +       double f1, f2;
  1211. + 
  1212. +       f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  1213. +       f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  1214. +       if (f1 <= f2)
  1215. +     return Qt;
  1216. +       return Qnil;
  1217. +     }
  1218. + #else
  1219.     CHECK_NUMBER_COERCE_MARKER (num1, 0);
  1220.     CHECK_NUMBER_COERCE_MARKER (num2, 0);
  1221. + #endif LISP_FLOAT_TYPE
  1222.   
  1223.     if (XINT (num1) <= XINT (num2))
  1224.       return Qt;
  1225. ***************
  1226. *** 1023,1030 ****
  1227. --- 1144,1167 ----
  1228.     (num1, num2)
  1229.        register Lisp_Object num1, num2;
  1230.   {
  1231. + #ifdef LISP_FLOAT_TYPE
  1232. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  1233. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
  1234. + 
  1235. +   if ((XTYPE(num1) == Lisp_Float) || (XTYPE(num2) == Lisp_Float))
  1236. +     {
  1237. +       double f1, f2;
  1238. + 
  1239. +       f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  1240. +       f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  1241. +       if (f1 >= f2)
  1242. +     return Qt;
  1243. +       return Qnil;
  1244. +     }
  1245. + #else
  1246.     CHECK_NUMBER_COERCE_MARKER (num1, 0);
  1247.     CHECK_NUMBER_COERCE_MARKER (num2, 0);
  1248. + #endif LISP_FLOAT_TYPE
  1249.   
  1250.     if (XINT (num1) >= XINT (num2))
  1251.       return Qt;
  1252. ***************
  1253. *** 1036,1043 ****
  1254. --- 1173,1196 ----
  1255.     (num1, num2)
  1256.        register Lisp_Object num1, num2;
  1257.   {
  1258. + #ifdef LISP_FLOAT_TYPE
  1259. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
  1260. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
  1261. + 
  1262. +   if ((XTYPE(num1) == Lisp_Float) || (XTYPE(num2) == Lisp_Float))
  1263. +     {
  1264. +       double f1, f2;
  1265. + 
  1266. +       f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  1267. +       f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  1268. +       if (f1 != f2)
  1269. +     return Qt;
  1270. +       return Qnil;
  1271. +     }
  1272. + #else
  1273.     CHECK_NUMBER_COERCE_MARKER (num1, 0);
  1274.     CHECK_NUMBER_COERCE_MARKER (num2, 0);
  1275. + #endif LISP_FLOAT_TYPE
  1276.   
  1277.     if (XINT (num1) != XINT (num2))
  1278.       return Qt;
  1279. ***************
  1280. *** 1048,1054 ****
  1281. --- 1201,1218 ----
  1282.     (num)
  1283.        register Lisp_Object num;
  1284.   {
  1285. + #ifdef LISP_FLOAT_TYPE
  1286. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1287. + 
  1288. +   if (XTYPE(num) == Lisp_Float)
  1289. +     {
  1290. +       if (XFLOAT(num)->data == 0.0)
  1291. +     return Qt;
  1292. +       return Qnil;
  1293. +     }
  1294. + #else
  1295.     CHECK_NUMBER (num, 0);
  1296. + #endif LISP_FLOAT_TYPE
  1297.   
  1298.     if (!XINT (num))
  1299.       return Qt;
  1300. ***************
  1301. *** 1062,1068 ****
  1302. --- 1226,1246 ----
  1303.   {
  1304.     char buffer[20];
  1305.   
  1306. + #ifndef LISP_FLOAT_TYPE
  1307. + 
  1308.     CHECK_NUMBER (num, 0);
  1309. + #else
  1310. + 
  1311. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1312. + 
  1313. +   if (XTYPE(num) == Lisp_Float)
  1314. +     {
  1315. +       char pigbuf[350];    /* see comments in float_to_string */
  1316. + 
  1317. +       float_to_string (pigbuf, XFLOAT(num)->data);
  1318. +       return build_string (pigbuf);      
  1319. +     }
  1320. + #endif LISP_FLOAT_TYPE
  1321.     sprintf (buffer, "%d", XINT (num));
  1322.     return build_string (buffer);
  1323.   }
  1324. ***************
  1325. *** 1073,1078 ****
  1326. --- 1251,1260 ----
  1327.        register Lisp_Object str, flag;
  1328.   {
  1329.     CHECK_STRING (str, 0);
  1330. + #ifdef LISP_FLOAT_TYPE
  1331. +   if (isfloat_string (XSTRING (str)->data))
  1332. +     return make_float (atof(XSTRING (str)->data));
  1333. + #endif LISP_FLOAT_TYPE
  1334.     return make_number (atoi (XSTRING (str)->data));
  1335.   }
  1336.     
  1337. ***************
  1338. *** 1111,1117 ****
  1339. --- 1293,1307 ----
  1340.     for (argnum = 0; argnum < nargs; argnum++)
  1341.       {
  1342.         val = args[argnum];    /* using args[argnum] as argument to CHECK_NUMBER_... */
  1343. + #ifdef LISP_FLOAT_TYPE
  1344. +       CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val, argnum);
  1345. + 
  1346. +       if (XTYPE(val) == Lisp_Float) /* time to do serious math */
  1347. +     return (float_arith_driver((double) accum, argnum, code,
  1348. +                    nargs, args));
  1349. + #else
  1350.         CHECK_NUMBER_COERCE_MARKER (val, argnum);
  1351. + #endif LISP_FLOAT_TYPE
  1352.         args[argnum] = val;    /* runs into a compiler bug. */
  1353.         next = XINT (args[argnum]);
  1354.   #ifdef SWITCH_ENUM_BUG
  1355. ***************
  1356. *** 1143,1148 ****
  1357. --- 1333,1418 ----
  1358.     return val;
  1359.   }
  1360.   
  1361. + #ifdef LISP_FLOAT_TYPE
  1362. + Lisp_Object
  1363. + float_arith_driver
  1364. +   (accum, argnum, code, nargs, args)
  1365. +      double accum;
  1366. +      register int argnum;
  1367. +      enum arithop code;
  1368. +      int nargs;
  1369. +      register Lisp_Object *args;
  1370. + {
  1371. +   register Lisp_Object val;
  1372. +   double next;
  1373. +   
  1374. +   for (; argnum < nargs; argnum++)
  1375. +     {
  1376. +       val = args[argnum];    /* using args[argnum] as argument to CHECK_NUMBER_... */
  1377. +       CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val, argnum);
  1378. + 
  1379. +       if (XTYPE(val) == Lisp_Float)
  1380. +     {
  1381. +       next = XFLOAT(val)->data;
  1382. +     }
  1383. +       else
  1384. +     {
  1385. +       args[argnum] = val;    /* runs into a compiler bug. */
  1386. +       next = XINT (args[argnum]);
  1387. +     }
  1388. + #ifdef SWITCH_ENUM_BUG
  1389. +       switch ((int) code)
  1390. + #else
  1391. +       switch (code)
  1392. + #endif
  1393. +     {
  1394. +     case Aadd: accum += next; break;
  1395. +     case Asub:
  1396. +       if (!argnum && nargs != 1)
  1397. +         next = - next;
  1398. +       accum -= next;
  1399. +       break;
  1400. +     case Amult: accum *= next; break;
  1401. +     case Adiv:
  1402. +       if (!argnum) accum = next;
  1403. +       else accum /= next;
  1404. +       break;
  1405. + #ifdef pigs_had_wings
  1406. +     case Alogand: accum &= next; break;
  1407. +     case Alogior: accum |= next; break;
  1408. +     case Alogxor: accum ^= next; break;
  1409. + #else
  1410. +     case Alogand:
  1411. +     case Alogior:
  1412. +     case Alogxor:
  1413. +       return (wrong_type_argument (Qinteger_or_marker_p, val));
  1414. +       break;
  1415. + #endif
  1416. +     case Amax: if (!argnum || next > accum) accum = next; break;
  1417. +     case Amin: if (!argnum || next < accum) accum = next; break;
  1418. +     }
  1419. +     }
  1420. + 
  1421. +   return make_float(accum);
  1422. + }
  1423. + 
  1424. + DEFUN ("logb", Flogb, Slogb, 1, 1, 0,
  1425. +  "Returns the integer that is the base 2 log of ARG.\n\
  1426. + This is the same as the exponent of a float.")
  1427. +      (num)
  1428. + Lisp_Object num;
  1429. + {
  1430. +   Lisp_Object val;
  1431. +   double f;
  1432. + 
  1433. +   CHECK_NUMBER_OR_FLOAT(num, 0);
  1434. +   f = (XTYPE(num) == Lisp_Float) ? XFLOAT(num)->data : XINT(num);
  1435. +   val = logb(f);
  1436. +   XSET(val, Lisp_Int, val);
  1437. +   return val;
  1438. + }
  1439. + #endif LISP_FLOAT_TYPE
  1440. + 
  1441.   DEFUN ("+", Fplus, Splus, 0, MANY, 0,
  1442.     "Return sum of any number of numbers.")
  1443.     (nargs, args)
  1444. ***************
  1445. *** 1187,1195 ****
  1446. --- 1457,1478 ----
  1447.        register Lisp_Object num1, num2;
  1448.   {
  1449.     Lisp_Object val;
  1450. + #ifdef LISP_FLOAT_TYPE
  1451. +   CHECK_NUMBER_OR_FLOAT (num1, 0);
  1452. +   CHECK_NUMBER_OR_FLOAT (num2, 0);
  1453.   
  1454. +   if ((XTYPE(num1) == Lisp_Float) || (XTYPE(num2) == Lisp_Float))
  1455. +     {
  1456. +       double f1, f2;
  1457. + 
  1458. +       f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  1459. +       f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  1460. +       return (make_float(drem(f1,f2)));
  1461. +     }
  1462. + #else
  1463.     CHECK_NUMBER (num1, 0);
  1464.     CHECK_NUMBER (num2, 1);
  1465. + #endif LISP_FLOAT_TYPE
  1466.   
  1467.     XSET (val, Lisp_Int, XINT (num1) % XINT (num2));
  1468.     return val;
  1469. ***************
  1470. *** 1283,1289 ****
  1471. --- 1566,1579 ----
  1472.     (num)
  1473.        register Lisp_Object num;
  1474.   {
  1475. + #ifdef LISP_FLOAT_TYPE
  1476. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num, 0);
  1477. + 
  1478. +   if (XTYPE(num) == Lisp_Float)
  1479. +     return (make_float((1.0) + XFLOAT(num)->data));
  1480. + #else
  1481.     CHECK_NUMBER_COERCE_MARKER (num, 0);
  1482. + #endif LISP_FLOAT_TYPE
  1483.     XSETINT (num, XFASTINT (num) + 1);
  1484.     return num;
  1485.   }
  1486. ***************
  1487. *** 1293,1299 ****
  1488. --- 1583,1596 ----
  1489.     (num)
  1490.        register Lisp_Object num;
  1491.   {
  1492. + #ifdef LISP_FLOAT_TYPE
  1493. +   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num, 0);
  1494. + 
  1495. +   if (XTYPE(num) == Lisp_Float)
  1496. +     return (make_float((-1.0) + XFLOAT(num)->data));
  1497. + #else
  1498.     CHECK_NUMBER_COERCE_MARKER (num, 0);
  1499. + #endif LISP_FLOAT_TYPE
  1500.     XSETINT (num, XFASTINT (num) - 1);
  1501.     return num;
  1502.   }
  1503. ***************
  1504. *** 1307,1312 ****
  1505. --- 1604,2160 ----
  1506.     XSETINT (num, ~XFASTINT (num));
  1507.     return num;
  1508.   }
  1509. + 
  1510. + #ifdef LISP_FLOAT_TYPE
  1511. + 
  1512. + DEFUN ("acos", Facos, Sacos, 1, 1, 0,
  1513. +   "Return the inverse cosine of ARG.")
  1514. +   (num)
  1515. +      register Lisp_Object num;
  1516. + {
  1517. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1518. + 
  1519. +   if (XTYPE(num) == Lisp_Float)
  1520. +     return (make_float (acos(XFLOAT(num)->data)));
  1521. +   return (make_float (acos((double) XINT(num))));
  1522. + }
  1523. + 
  1524. + 
  1525. + DEFUN ("acosh", Facosh, Sacosh, 1, 1, 0,
  1526. +   "Return the inverse hyperbolic cosine of ARG.")
  1527. +   (num)
  1528. +      register Lisp_Object num;
  1529. + {
  1530. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1531. + 
  1532. +   if (XTYPE(num) == Lisp_Float)
  1533. +     return (make_float (acosh(XFLOAT(num)->data)));
  1534. +   return (make_float (acosh((double) XINT(num))));
  1535. + }
  1536. + 
  1537. + DEFUN ("asin", Fasin, Sasin, 1, 1, 0,
  1538. +   "Return the inverse sine of ARG.")
  1539. +   (num)
  1540. +      register Lisp_Object num;
  1541. + {
  1542. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1543. + 
  1544. +   if (XTYPE(num) == Lisp_Float)
  1545. +     return (make_float (asin(XFLOAT(num)->data)));
  1546. +   return (make_float (asin((double) XINT(num))));
  1547. + }
  1548. + 
  1549. + DEFUN ("asinh", Fasinh, Sasinh, 1, 1, 0,
  1550. +   "Return the inverse hyperbolic sine of ARG.")
  1551. +   (num)
  1552. +      register Lisp_Object num;
  1553. + {
  1554. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1555. + 
  1556. +   if (XTYPE(num) == Lisp_Float)
  1557. +     return (make_float (asinh(XFLOAT(num)->data)));
  1558. +   return (make_float (asinh((double) XINT(num))));
  1559. + }
  1560. + 
  1561. + DEFUN ("atan", Fatan, Satan, 1, 1, 0,
  1562. +   "Return the inverse tangent of ARG.")
  1563. +   (num)
  1564. +      register Lisp_Object num;
  1565. + {
  1566. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1567. + 
  1568. +   if (XTYPE(num) == Lisp_Float)
  1569. +     return (make_float (atan(XFLOAT(num)->data)));
  1570. +   return (make_float (atan((double) XINT(num))));
  1571. + }
  1572. + 
  1573. + DEFUN ("atanh", Fatanh, Satanh, 1, 1, 0,
  1574. +   "Return the inverse hyperbolic tangent of ARG.")
  1575. +   (num)
  1576. +      register Lisp_Object num;
  1577. + {
  1578. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1579. + 
  1580. +   if (XTYPE(num) == Lisp_Float)
  1581. +     return (make_float (atanh(XFLOAT(num)->data)));
  1582. +   return (make_float (atanh((double) XINT(num))));
  1583. + }
  1584. + 
  1585. + 
  1586. + DEFUN ("cube-root", Fcube_root, Scube_root, 1, 1, 0,
  1587. +   "Return the cube root of ARG.")
  1588. +   (num)
  1589. +      register Lisp_Object num;
  1590. + {
  1591. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1592. + 
  1593. +   if (XTYPE(num) == Lisp_Float)
  1594. +     return (make_float (cbrt(XFLOAT(num)->data)));
  1595. +   return (make_float (cbrt((double) XINT(num))));
  1596. + }
  1597. + DEFUN ("cos", Fcos, Scos, 1, 1, 0,
  1598. +   "Return the cosine of ARG.")
  1599. +   (num)
  1600. +      register Lisp_Object num;
  1601. + {
  1602. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1603. + 
  1604. +   if (XTYPE(num) == Lisp_Float)
  1605. +     return (make_float (cos(XFLOAT(num)->data)));
  1606. +   return (make_float (cos((double) XINT(num))));
  1607. + }
  1608. + 
  1609. + DEFUN ("cosh", Fcosh, Scosh, 1, 1, 0,
  1610. +   "Return the hyperbolic cosine of ARG.")
  1611. +   (num)
  1612. +      register Lisp_Object num;
  1613. + {
  1614. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1615. + 
  1616. +   if (XTYPE(num) == Lisp_Float)
  1617. +     return (make_float (cosh(XFLOAT(num)->data)));
  1618. +   return (make_float (cosh((double) XINT(num))));
  1619. + }
  1620. + 
  1621. + DEFUN ("erf", Ferf, Serf, 1, 1, 0,
  1622. +   "Return the mathematical error function of ARG.")
  1623. +   (num)
  1624. +      register Lisp_Object num;
  1625. + {
  1626. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1627. + 
  1628. +   if (XTYPE(num) == Lisp_Float)
  1629. +     return (make_float (erf(XFLOAT(num)->data)));
  1630. +   return (make_float (erf((double) XINT(num))));
  1631. + }
  1632. + 
  1633. + DEFUN ("erfc", Ferfc, Serfc, 1, 1, 0,
  1634. +   "Return the complementary error function of ARG.")
  1635. +   (num)
  1636. +      register Lisp_Object num;
  1637. + {
  1638. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1639. + 
  1640. +   if (XTYPE(num) == Lisp_Float)
  1641. +     return (make_float (erfc(XFLOAT(num)->data)));
  1642. +   return (make_float (erfc((double) XINT(num))));
  1643. + }
  1644. + 
  1645. + DEFUN ("exp", Fexp, Sexp, 1, 1, 0,
  1646. +   "Return the exponential base e of ARG.")
  1647. +   (num)
  1648. +      register Lisp_Object num;
  1649. + {
  1650. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1651. + 
  1652. +   if (XTYPE(num) == Lisp_Float)
  1653. +     return (make_float (exp(XFLOAT(num)->data)));
  1654. +   return (make_float (exp((double) XINT(num))));
  1655. + }
  1656. + 
  1657. + DEFUN ("expm1", Fexpm1, Sexpm1, 1, 1, 0,
  1658. +   "Return the exp(x)-1 of ARG.")
  1659. +   (num)
  1660. +      register Lisp_Object num;
  1661. + {
  1662. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1663. + 
  1664. +   if (XTYPE(num) == Lisp_Float)
  1665. +     return (make_float (expm1(XFLOAT(num)->data)));
  1666. +   return (make_float (expm1((double) XINT(num))));
  1667. + }
  1668. + 
  1669. + DEFUN ("j0", Fj0, Sj0, 1, 1, 0,
  1670. +   "Return the bessel function j0 of ARG.")
  1671. +   (num)
  1672. +      register Lisp_Object num;
  1673. + {
  1674. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1675. + 
  1676. +   if (XTYPE(num) == Lisp_Float)
  1677. +     return (make_float (j0(XFLOAT(num)->data)));
  1678. +   return (make_float (j0((double) XINT(num))));
  1679. + }
  1680. + 
  1681. + DEFUN ("j1", Fj1, Sj1, 1, 1, 0,
  1682. +   "Return the bessel function j1 of ARG.")
  1683. +   (num)
  1684. +      register Lisp_Object num;
  1685. + {
  1686. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1687. + 
  1688. +   if (XTYPE(num) == Lisp_Float)
  1689. +     return (make_float (j1(XFLOAT(num)->data)));
  1690. +   return (make_float (j1((double) XINT(num))));
  1691. + }
  1692. + 
  1693. + DEFUN ("jn", Fjn, Sjn, 2, 2, 0,
  1694. + "Return the nth ORDER bessel function output jn of ARG.  First arg is\n\
  1695. + the ORDER of the bessel, and is truncated to an integer.")
  1696. +   (num1, num2)
  1697. +      register Lisp_Object num1, num2;
  1698. + {
  1699. +   int i1;
  1700. +   double f2;
  1701. + 
  1702. +   CHECK_NUMBER_OR_FLOAT (num1, 0);
  1703. +   CHECK_NUMBER_OR_FLOAT (num2, 0);
  1704. +   i1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  1705. +   f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  1706. + 
  1707. +   return (make_float (jn(i1, f2)));
  1708. + }
  1709. + 
  1710. + DEFUN ("log-gamma", Flog_gamma, Slog_gamma, 1, 1, 0,
  1711. +   "Return the log gamma of ARG.")
  1712. +   (num)
  1713. +      register Lisp_Object num;
  1714. + {
  1715. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1716. + 
  1717. +   if (XTYPE(num) == Lisp_Float)
  1718. +     return (make_float (lgamma(XFLOAT(num)->data)));
  1719. +   return (make_float (lgamma((double) XINT(num))));
  1720. + }
  1721. + 
  1722. + DEFUN ("log", Flog, Slog, 1, 1, 0,
  1723. +   "Return the natural logarithm of ARG.")
  1724. +   (num)
  1725. +      register Lisp_Object num;
  1726. + {
  1727. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1728. + 
  1729. +   if (XTYPE(num) == Lisp_Float)
  1730. +     return (make_float (log(XFLOAT(num)->data)));
  1731. +   return (make_float (log((double) XINT(num))));
  1732. + }
  1733. + 
  1734. + DEFUN ("log10", Flog10, Slog10, 1, 1, 0,
  1735. +   "Return the logarithm base 10 of ARG.")
  1736. +   (num)
  1737. +      register Lisp_Object num;
  1738. + {
  1739. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1740. + 
  1741. +   if (XTYPE(num) == Lisp_Float)
  1742. +     return (make_float (log10(XFLOAT(num)->data)));
  1743. +   return (make_float (log10((double) XINT(num))));
  1744. + }
  1745. + 
  1746. + DEFUN ("log1p", Flog1p, Slog1p, 1, 1, 0,
  1747. +   "Return the log(1+x) of ARG.")
  1748. +   (num)
  1749. +      register Lisp_Object num;
  1750. + {
  1751. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1752. + 
  1753. +   if (XTYPE(num) == Lisp_Float)
  1754. +     return (make_float (log1p(XFLOAT(num)->data)));
  1755. +   return (make_float (log1p((double) XINT(num))));
  1756. + }
  1757. + 
  1758. + DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
  1759. +   "Return the exponential x ** y.")
  1760. +   (num1, num2)
  1761. +      register Lisp_Object num1, num2;
  1762. + {
  1763. +   double f1, f2;
  1764. + 
  1765. +   CHECK_NUMBER_OR_FLOAT (num1, 0);
  1766. +   CHECK_NUMBER_OR_FLOAT (num2, 0);
  1767. +   if ((XTYPE(num1) == Lisp_Int) && /* common lisp spec */
  1768. +       (XTYPE(num2) == Lisp_Int)) /* don't promote, if both are ints */
  1769. +     {                /* this can be improved by pre-calculating */
  1770. +       int acc, x, y;        /* some binary powers of x then acumulating */
  1771. +                 /* these, therby saving some time. -wsr */
  1772. +       x = XINT(num1);
  1773. +       y = XINT(num2);
  1774. +       acc = 1;
  1775. +       
  1776. +       if (y < 0)
  1777. +     {
  1778. +       for (; y < 0; y++)
  1779. +           acc /= x;
  1780. +     }
  1781. +       else
  1782. +     {
  1783. +       for (; y > 0; y--)
  1784. +           acc *= x;
  1785. +     }
  1786. +       return (XSET(x , Lisp_Int, acc));
  1787. +     }
  1788. +   f1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  1789. +   f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  1790. +   return (make_float (pow(f1, f2)));
  1791. + }
  1792. + 
  1793. + DEFUN ("sin", Fsin, Ssin, 1, 1, 0,
  1794. +   "Return the sine of ARG.")
  1795. +   (num)
  1796. +      register Lisp_Object num;
  1797. + {
  1798. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1799. + 
  1800. +   if (XTYPE(num) == Lisp_Float)
  1801. +     return (make_float (sin(XFLOAT(num)->data)));
  1802. +   return (make_float (sin((double) XINT(num))));
  1803. + }
  1804. + 
  1805. + DEFUN ("sinh", Fsinh, Ssinh, 1, 1, 0,
  1806. +   "Return the hyperbolic sine of ARG.")
  1807. +   (num)
  1808. +      register Lisp_Object num;
  1809. + {
  1810. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1811. + 
  1812. +   if (XTYPE(num) == Lisp_Float)
  1813. +     return (make_float (sinh(XFLOAT(num)->data)));
  1814. +   return (make_float (sinh((double) XINT(num))));
  1815. + }
  1816. + 
  1817. + DEFUN ("sqrt", Fsqrt, Ssqrt, 1, 1, 0,
  1818. +   "Return the square root of ARG.")
  1819. +   (num)
  1820. +      register Lisp_Object num;
  1821. + {
  1822. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1823. + 
  1824. +   if (XTYPE(num) == Lisp_Float)
  1825. +     return (make_float (sqrt(XFLOAT(num)->data)));
  1826. +   return (make_float (sqrt((double) XINT(num))));
  1827. + }
  1828. + 
  1829. + DEFUN ("tan", Ftan, Stan, 1, 1, 0,
  1830. +   "Return the tangent of ARG.")
  1831. +   (num)
  1832. +      register Lisp_Object num;
  1833. + {
  1834. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1835. + 
  1836. +   if (XTYPE(num) == Lisp_Float)
  1837. +     return (make_float (tan(XFLOAT(num)->data)));
  1838. +   return (make_float (tan((double) XINT(num))));
  1839. + }
  1840. + 
  1841. + DEFUN ("tanh", Ftanh, Stanh, 1, 1, 0,
  1842. +   "Return the hyperbolic tangent of ARG.")
  1843. +   (num)
  1844. +      register Lisp_Object num;
  1845. + {
  1846. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1847. + 
  1848. +   if (XTYPE(num) == Lisp_Float)
  1849. +     return (make_float (tanh(XFLOAT(num)->data)));
  1850. +   return (make_float (tanh((double) XINT(num))));
  1851. + }
  1852. + 
  1853. + DEFUN ("y0", Fy0, Sy0, 1, 1, 0,
  1854. +   "Return the bessel function y0 of ARG.")
  1855. +   (num)
  1856. +      register Lisp_Object num;
  1857. + {
  1858. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1859. + 
  1860. +   if (XTYPE(num) == Lisp_Float)
  1861. +     return (make_float (y0(XFLOAT(num)->data)));
  1862. +   return (make_float (y0((double) XINT(num))));
  1863. + }
  1864. + 
  1865. + DEFUN ("y1", Fy1, Sy1, 1, 1, 0,
  1866. +   "Return the bessel function y1 of ARG.")
  1867. +   (num)
  1868. +      register Lisp_Object num;
  1869. + {
  1870. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1871. + 
  1872. +   if (XTYPE(num) == Lisp_Float)
  1873. +     return (make_float (y1(XFLOAT(num)->data)));
  1874. +   return (make_float (y1((double) XINT(num))));
  1875. + }
  1876. + 
  1877. + DEFUN ("yn", Fyn, Syn, 2, 2, 0,
  1878. + "Return the nth ORDER bessel function output yn of ARG.  First arg is\n\
  1879. + the order of the bessel, and is truncated to an integer.")
  1880. +   (num1, num2)
  1881. +      register Lisp_Object num1, num2;
  1882. + {
  1883. +   int i1;
  1884. +   double f2;
  1885. + 
  1886. +   CHECK_NUMBER_OR_FLOAT (num1, 0);
  1887. +   CHECK_NUMBER_OR_FLOAT (num2, 0);
  1888. +   i1 = (XTYPE(num1) == Lisp_Float) ? XFLOAT(num1)->data : XINT(num1);
  1889. +   f2 = (XTYPE(num2) == Lisp_Float) ? XFLOAT(num2)->data : XINT(num2);
  1890. + 
  1891. +   return (make_float (yn(i1, f2)));
  1892. + }
  1893. + /* the rounding functions  */
  1894. + 
  1895. + DEFUN ("ceiling", Fceiling, Sceiling, 1, 1, 0,
  1896. +   "Return the smallest integer no less than ARG. (round toward +inf)")
  1897. +   (num)
  1898. +      register Lisp_Object num;
  1899. + {
  1900. +   Lisp_Object val = num;
  1901. +      
  1902. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1903. + 
  1904. +   if (XTYPE(num) == Lisp_Float)
  1905. +        XSET (val, Lisp_Int, ceil(XFLOAT(num)->data));
  1906. +   return (val);
  1907. + }
  1908. + 
  1909. + DEFUN ("fceiling", Ffceiling, Sfceiling, 1, 1, 0,
  1910. +        "Return the smallest integral floating pt. number no less than ARG.\n\
  1911. + (round towards +inf)")
  1912. +   (num)
  1913. +      register Lisp_Object num;
  1914. + {
  1915. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1916. + 
  1917. +   if (XTYPE(num) == Lisp_Float)
  1918. +     return (make_float (ceil(XFLOAT(num)->data)));
  1919. +   return (make_float ((double) XINT(num)));
  1920. + }
  1921. + 
  1922. + 
  1923. + DEFUN ("abs", Fabs, Sabs, 1, 1, 0,
  1924. +   "Return the absolute value of ARG.")
  1925. +   (num)
  1926. +      register Lisp_Object num;
  1927. + {
  1928. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1929. + 
  1930. +   if (XTYPE(num) == Lisp_Float)
  1931. +     return (make_float (fabs(XFLOAT(num)->data)));
  1932. +   if (XINT(num) < 0)
  1933. +     XSETINT (num, - XFASTINT (num));
  1934. +   return (num);
  1935. + }
  1936. + 
  1937. + 
  1938. + DEFUN ("ffloor", Fffloor, Sffloor, 1, 1, 0,
  1939. +        "Return the largest floating pt number no greater than ARG.\n\
  1940. + (round towards -inf)")
  1941. +   (num)
  1942. +      register Lisp_Object num;
  1943. + {
  1944. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1945. + 
  1946. +   if (XTYPE(num) == Lisp_Float)
  1947. +     return (make_float (floor(XFLOAT(num)->data)));
  1948. +   return (make_float (floor((double) XINT(num))));
  1949. + }
  1950. + 
  1951. + DEFUN ("floor", Ffloor, Sfloor, 1, 1, 0,
  1952. +   "Return the largest integer no greater than ARG. (round towards -inf)")
  1953. +   (num)
  1954. +      register Lisp_Object num;
  1955. + {
  1956. +   Lisp_Object val = num; 
  1957. + 
  1958. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1959. + 
  1960. +   if (XTYPE(num) == Lisp_Float)
  1961. +     XSET (val, Lisp_Int, floor(XFLOAT(num)->data));
  1962. +   return (val);
  1963. + }
  1964. + 
  1965. + DEFUN ("float", Ffloat, Sfloat, 1, 1, 0,
  1966. +   "Return the floating pt. number equal to ARG.")
  1967. +   (num)
  1968. +      register Lisp_Object num;
  1969. + {
  1970. +   Lisp_Object val; 
  1971. + 
  1972. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  1973. + 
  1974. +   if (XTYPE(num) == Lisp_Int)
  1975. +     val = make_float ((double) XINT(num));
  1976. +   else                /* give 'em the same float back */
  1977. +     val = num;
  1978. +   
  1979. +   return (val);
  1980. + }
  1981. + 
  1982. + 
  1983. + DEFUN ("fround", Ffround, Sfround, 1, 1, 0,
  1984. +   "Return the nearest integral floating pt. number to ARG.")
  1985. +   (num)
  1986. +      register Lisp_Object num;
  1987. + {
  1988. +   CHECK_NUMBER_OR_FLOAT(num, 0);
  1989. + 
  1990. +   if (XTYPE(num) == Lisp_Float)
  1991. +     return (make_float (rint(XFLOAT(num)->data)));
  1992. +   return (make_float (rint((double) XINT(num))));
  1993. + }
  1994. + 
  1995. + DEFUN ("round", Fround, Sround, 1, 1, 0,
  1996. +   "Return the nearest integer to ARG.")
  1997. +   (num)
  1998. +      register Lisp_Object num;
  1999. + {
  2000. +   Lisp_Object val = num; 
  2001. + 
  2002. +   CHECK_NUMBER_OR_FLOAT (num, 0);
  2003. + 
  2004. +   if (XTYPE(num) == Lisp_Float)
  2005. +     XSET (val, Lisp_Int, rint(XFLOAT(num)->data));
  2006. +   return (val);
  2007. + }
  2008. + 
  2009. + DEFUN ("truncate", Ftruncate, Struncate, 1, 1, 0,
  2010. +        "Truncate a floating point number to an int.\n\
  2011. + (Truncates toward zero.)")
  2012. +   (num)
  2013. +      register Lisp_Object num;
  2014. + {
  2015. +   Lisp_Object val = num;
  2016. + 
  2017. +   CHECK_NUMBER_OR_FLOAT(num, 0);
  2018. + 
  2019. +   if (XTYPE(num) == Lisp_Float)
  2020. +       XSET (val, Lisp_Int, XFLOAT(num)->data);
  2021. +   return val;
  2022. + }
  2023. + 
  2024. + DEFUN ("ftruncate", Fftruncate, Sftruncate, 1, 1, 0,
  2025. +        "Truncate a floating point number, returns a float.\n\
  2026. + (Truncates towards zero.) Will fail for floats > max integer.")
  2027. +   (num)
  2028. +      register Lisp_Object num;
  2029. + {
  2030. +   int val;
  2031. + 
  2032. +   CHECK_NUMBER_OR_FLOAT(num, 0);
  2033. + 
  2034. +   if (XTYPE(num) == Lisp_Float)
  2035. +        val = XFLOAT(num)->data;
  2036. +   else 
  2037. +        val = XINT (num);
  2038. +   return (make_float((double) val));
  2039. + }
  2040. + 
  2041. + # ifdef vax
  2042. + /*
  2043. +  * Replacement infnan for 4.3 (vax) math lib.  The original 4.3BSD
  2044. +  * infnan() causes an intentional illegal-instruction and core dump.
  2045. +  * 
  2046. +  * This one is more benign and only signals an error.
  2047. +  */
  2048. + 
  2049. + double 
  2050. + infnan(iarg)
  2051. +     int             iarg;
  2052. + {
  2053. +         Fsignal (Qarith_error, Qnil);
  2054. +     /* NOTREACHED */
  2055. +     return (0.0);
  2056. + }
  2057. + # endif vax
  2058. + #endif LISP_FLOAT_TYPE
  2059. + 
  2060.   
  2061.   void
  2062.   syms_of_data ()
  2063. ***************
  2064. *** 1353,1358 ****
  2065. --- 2201,2211 ----
  2066.     Qfboundp = intern ("fboundp");
  2067.   
  2068.     Qcdr = intern ("cdr");
  2069. + #ifdef LISP_FLOAT_TYPE
  2070. +   Qfloatp = intern ("floatp");
  2071. +   Qinteger_or_floatp = intern ("integer-or-floatp");
  2072. +   Qinteger_or_float_or_marker_p = intern ("integer-or-float-or-marker-p");
  2073. + #endif LISP_FLOAT_TYPE
  2074.   
  2075.     /* ERROR is used as a signaler for random errors for which nothing else is right */
  2076.   
  2077. ***************
  2078. *** 1476,1481 ****
  2079. --- 2329,2339 ----
  2080.     staticpro (&Qchar_or_string_p);
  2081.     staticpro (&Qmarkerp);
  2082.     staticpro (&Qinteger_or_marker_p);
  2083. + #ifdef LISP_FLOAT_TYPE
  2084. +   staticpro (&Qfloatp);
  2085. +   staticpro (&Qinteger_or_floatp);
  2086. +   staticpro (&Qinteger_or_float_or_marker_p);
  2087. + #endif LISP_FLOAT_TYPE
  2088.     staticpro (&Qboundp);
  2089.     staticpro (&Qfboundp);
  2090.     staticpro (&Qcdr);
  2091. ***************
  2092. *** 1547,1552 ****
  2093. --- 2405,2455 ----
  2094.     defsubr (&Sadd1);
  2095.     defsubr (&Ssub1);
  2096.     defsubr (&Slognot);
  2097. + #ifdef LISP_FLOAT_TYPE
  2098. +   defsubr (&Sfloatp);
  2099. +   defsubr (&Sinteger_or_floatp);
  2100. +   defsubr (&Sinteger_or_float_or_marker_p);
  2101. +   defsubr (&Sacos);
  2102. +   defsubr (&Sacosh);
  2103. +   defsubr (&Sasin);
  2104. +   defsubr (&Sasinh);
  2105. +   defsubr (&Satan);
  2106. +   defsubr (&Satanh);
  2107. +   defsubr (&Scube_root);
  2108. +   defsubr (&Scos);
  2109. +   defsubr (&Scosh);
  2110. +   defsubr (&Serf);
  2111. +   defsubr (&Serfc);
  2112. +   defsubr (&Sexp);
  2113. +   defsubr (&Sexpm1);
  2114. +   defsubr (&Sj0);
  2115. +   defsubr (&Sj1);
  2116. +   defsubr (&Sjn);
  2117. +   defsubr (&Slog_gamma);
  2118. +   defsubr (&Slog);
  2119. +   defsubr (&Slog10);
  2120. +   defsubr (&Slog1p);
  2121. +   defsubr (&Sexpt);
  2122. +   defsubr (&Ssin);
  2123. +   defsubr (&Ssinh);
  2124. +   defsubr (&Ssqrt);
  2125. +   defsubr (&Stan);
  2126. +   defsubr (&Stanh);
  2127. +   defsubr (&Sy0);
  2128. +   defsubr (&Sy1);
  2129. +   defsubr (&Syn);
  2130. +   defsubr (&Sceiling);
  2131. +   defsubr (&Sabs);
  2132. +   defsubr (&Sfloor);
  2133. +   defsubr (&Sfloat);
  2134. +   defsubr (&Sround);
  2135. +   defsubr (&Struncate);
  2136. +   defsubr (&Sfceiling);
  2137. +   defsubr (&Sffloor);
  2138. +   defsubr (&Sfround);
  2139. +   defsubr (&Sftruncate);
  2140. +   defsubr (&Slogb);
  2141. + #endif LISP_FLOAT_TYPE
  2142.   }
  2143.   
  2144.   arith_error (signo)
  2145. diff -rc emacs-18.57/src/lisp.h emacs/src/lisp.h
  2146. *** emacs-18.57/src/lisp.h    Tue Jan  8 18:51:28 1991
  2147. --- emacs/src/lisp.h    Tue Aug 13 10:51:53 1991
  2148. ***************
  2149. *** 1,3 ****
  2150. --- 1,15 ----
  2151. + /******************************************************************************
  2152. + *                                          *
  2153. + *    File:     lisp.h                              *
  2154. + *    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 *
  2155. + *    Created:  Mon Nov  2 15:19:17 EST 1987                      *
  2156. + *    Contents: gnuemacs lisp.h with float code                  *
  2157. + *                                          *
  2158. + *    Copyright (c) 1987 Wolfgang Rupprecht.                      *
  2159. + *    All rights reserved.                              *
  2160. + *                                          *
  2161. + *    $Log$                                      *
  2162. + ******************************************************************************/
  2163.   /* Fundamental definitions for GNU Emacs Lisp interpreter.
  2164.      Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
  2165.   
  2166. ***************
  2167. *** 149,156 ****
  2168. --- 161,174 ----
  2169.          Data inside looks like a Lisp_Vector.  */
  2170.       Lisp_Window,
  2171.   
  2172. + #ifdef LISP_FLOAT_TYPE
  2173. +     /* optional Lisp floating point data type -wolfgang 10/24/87 */
  2174. +     Lisp_Float,
  2175. + #endif LISP_FLOAT_TYPE
  2176. + 
  2177.       /* Used by save,set,restore-window-configuration */
  2178.       Lisp_Window_Configuration
  2179. + 
  2180.     };
  2181.   
  2182.   #ifndef NO_UNION_TYPE
  2183. ***************
  2184. *** 402,407 ****
  2185. --- 420,429 ----
  2186.   #define XWINDOW(a) ((struct window *) XPNTR(a))
  2187.   #define XPROCESS(a) ((struct Lisp_Process *) XPNTR(a))
  2188.   
  2189. + #ifdef LISP_FLOAT_TYPE
  2190. + # define XFLOAT(a) ((struct Lisp_Float *) XPNTR(a))
  2191. + #endif LISP_FLOAT_TYPE
  2192. + 
  2193.   #define XSETCONS(a, b) XSETPNTR(a, (int) (b))
  2194.   #define XSETBUFFER(a, b) XSETPNTR(a, (int) (b))
  2195.   #define XSETVECTOR(a, b) XSETPNTR(a, (int) (b))
  2196. ***************
  2197. *** 414,419 ****
  2198. --- 436,444 ----
  2199.   #define XSETINTPTR(a, b) XSETPNTR(a, (int) (b))
  2200.   #define XSETWINDOW(a, b) XSETPNTR(a, (int) (b))
  2201.   #define XSETPROCESS(a, b) XSETPNTR(a, (int) (b))
  2202. + #ifdef LISP_FLOAT_TYPE
  2203. + # define XSETFLOAT(a, b) XSETPNTR(a, (int) (b))
  2204. + #endif LISP_FLOAT_TYPE
  2205.   
  2206.   /* In a cons, the markbit of the car is the gc mark bit */
  2207.   
  2208. ***************
  2209. *** 475,480 ****
  2210. --- 500,515 ----
  2211.       Lisp_Object chain;
  2212.       int bufpos;
  2213.     };
  2214. + 
  2215. + #ifdef LISP_FLOAT_TYPE
  2216. + /* optional Lisp floating point type */
  2217. + struct Lisp_Float
  2218. +    {
  2219. +      Lisp_Object type;        /* essentially used for mark-bit 
  2220. +                    and chaining when on free-list */
  2221. +      double data;  
  2222. +    };
  2223. + #endif LISP_FLOAT_TYPE
  2224.   
  2225.   /* Data type checking */
  2226.   
  2227. ***************
  2228. *** 520,525 ****
  2229. --- 555,572 ----
  2230.     { if (XTYPE ((x)) == Lisp_Marker) XFASTINT (x) = marker_position (x); \
  2231.       else if (XTYPE ((x)) != Lisp_Int) x = wrong_type_argument (Qinteger_or_marker_p, (x)); }
  2232.   
  2233. + #ifdef LISP_FLOAT_TYPE
  2234. + #define CHECK_FLOAT(x, i) \
  2235. +   { if (XTYPE ((x)) != Lisp_Float) x = wrong_type_argument (Qfloatp, (x)); }
  2236. + #define CHECK_NUMBER_OR_FLOAT(x, i) \
  2237. + { if ((XTYPE ((x)) != Lisp_Float) && (XTYPE ((x)) != Lisp_Int))\
  2238. +     x = wrong_type_argument (Qinteger_or_floatp, (x)); }
  2239. + #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x, i) \
  2240. +   { if (XTYPE ((x)) == Lisp_Marker) XFASTINT (x) = marker_position (x); \
  2241. +   else if ((XTYPE ((x)) != Lisp_Int) && (XTYPE ((x)) != Lisp_Float)) \
  2242. +     x = wrong_type_argument (Qinteger_or_float_or_marker_p, (x)); }
  2243. + #endif LISP_FLOAT_TYPE
  2244. + 
  2245.   #ifdef VIRT_ADDR_VARIES
  2246.   
  2247.   /* For machines like APOLLO where text and data can go anywhere
  2248. ***************
  2249. *** 762,772 ****
  2250. --- 809,827 ----
  2251.   extern Lisp_Object Qinteger_or_marker_p, Qboundp, Qfboundp;
  2252.   extern Lisp_Object Qcdr;
  2253.   
  2254. + #ifdef LISP_FLOAT_TYPE
  2255. + extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
  2256. + #endif LISP_FLOAT_TYPE
  2257. + 
  2258.   extern Lisp_Object Feq (), Fnull (), Flistp (), Fconsp (), Fatom (), Fnlistp ();
  2259.   extern Lisp_Object Fintegerp (), Fnatnump (), Fsymbolp ();
  2260.   extern Lisp_Object Fvectorp (), Fstringp (), Farrayp (), Fsequencep ();
  2261.   extern Lisp_Object Fbufferp (), Fmarkerp (), Fsubrp (), Fchar_or_string_p ();
  2262.   extern Lisp_Object Finteger_or_marker_p ();
  2263. + #ifdef LISP_FLOAT_TYPE
  2264. + extern Lisp_Object Ffloatp(), Finteger_or_floatp(),
  2265. +   Finteger_or_float_or_marker_p(), Ftruncate();
  2266. + #endif LISP_FLOAT_TYPE
  2267.   
  2268.   extern Lisp_Object Fcar (), Fcar_safe(), Fcdr (), Fcdr_safe();
  2269.   extern Lisp_Object Fsetcar (), Fsetcdr ();
  2270. ***************
  2271. *** 788,793 ****
  2272. --- 843,852 ----
  2273.   extern void args_out_of_range ();
  2274.   extern void args_out_of_range_3 ();
  2275.   extern Lisp_Object wrong_type_argument ();
  2276. + #ifdef LISP_FLOAT_TYPE
  2277. + extern Lisp_Object Ffloat_to_int(), Fint_to_float();
  2278. + #endif LISP_FLOAT_TYPE
  2279. + 
  2280.   
  2281.   /* Defined in fns.c */
  2282.   extern Lisp_Object Qstring_lessp;
  2283. diff -rc emacs-18.57/src/lread.c emacs/src/lread.c
  2284. *** emacs-18.57/src/lread.c    Tue Jan  8 18:52:01 1991
  2285. --- emacs/src/lread.c    Tue Aug 13 10:52:06 1991
  2286. ***************
  2287. *** 1,3 ****
  2288. --- 1,15 ----
  2289. + /******************************************************************************
  2290. + *                                          *
  2291. + *    File:     lread.c                              *
  2292. + *    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 *
  2293. + *    Created:  Mon Nov  2 15:23:48 EST 1987                      *
  2294. + *    Contents: GNU lread.c with my float code                  *
  2295. + *                                          *
  2296. + *    Copyright (c) 1987 Wolfgang Rupprecht.                      *
  2297. + *    All rights reserved.                              *
  2298. + *                                          *
  2299. + *    $Log$                                      *
  2300. + ******************************************************************************/
  2301.   /* Lisp parsing and input streams.
  2302.      Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
  2303.   
  2304. ***************
  2305. *** 39,44 ****
  2306. --- 51,60 ----
  2307.   #define X_OK 01
  2308.   #endif
  2309.   
  2310. + #ifdef LISP_FLOAT_TYPE
  2311. + #include <math.h>
  2312. + #endif LISP_FLOAT_TYPE
  2313. + 
  2314.   Lisp_Object Qread_char, Qget_file_char, Qstandard_input;
  2315.   Lisp_Object Qvariable_documentation, Vvalues, Vstandard_input;
  2316.   
  2317. ***************
  2318. *** 661,670 ****
  2319.   
  2320.         while (c > 040 && 
  2321.            !(c == '\"' || c == '\'' || c == ';' || c == '?'
  2322. !            || c == '(' || c == ')' || c =='.'
  2323.              || c == '[' || c == ']' || c == '#'
  2324.              ))
  2325.           {
  2326.             if (p == end)
  2327.           {
  2328.             register char *new = (char *) xrealloc (read_buffer, read_buffer_size *= 2);
  2329. --- 677,699 ----
  2330.   
  2331.         while (c > 040 && 
  2332.            !(c == '\"' || c == '\'' || c == ';' || c == '?'
  2333. !            || c == '(' || c == ')'
  2334. ! #ifndef LISP_FLOAT_TYPE        /* we need to see <number><dot><number> */
  2335. !            || c =='.'
  2336. ! #endif not LISP_FLOAT_TYPE
  2337.              || c == '[' || c == ']' || c == '#'
  2338.              ))
  2339.           {
  2340. + #ifdef LISP_FLOAT_TYPE_nuked    /* for added robustness */
  2341. +           if (c == '.')
  2342. +         {        /* fix up dotted pair stuff */
  2343. +           if (((p - 1) < read_buffer) ||
  2344. +               ((*(p-1)) < '0') ||
  2345. +               ((*(p-1)) > '9'))
  2346. +             break;    /* wasn't <numeric-string><dot> */
  2347. +         }
  2348. + #endif LISP_FLOAT_TYPE
  2349. + 
  2350.             if (p == end)
  2351.           {
  2352.             register char *new = (char *) xrealloc (read_buffer, read_buffer_size *= 2);
  2353. ***************
  2354. *** 705,716 ****
  2355.             return val;
  2356.           }
  2357.           }
  2358.       }
  2359. - 
  2360.       return intern (read_buffer);
  2361.         }
  2362.       }
  2363.   }
  2364.   
  2365.   static Lisp_Object
  2366.   read_vector (readcharfun)
  2367. --- 734,801 ----
  2368.             return val;
  2369.           }
  2370.           }
  2371. +       if (isfloat_string (read_buffer))
  2372. +         return make_float (atof(read_buffer));
  2373.       }
  2374.       return intern (read_buffer);
  2375.         }
  2376.       }
  2377.   }
  2378. + 
  2379. + #ifdef LISP_FLOAT_TYPE
  2380. + #include <ctype.h>
  2381. + #define LEAD_INT 1
  2382. + #define DOT_CHAR 2
  2383. + #define TRAIL_INT 4
  2384. + #define E_CHAR 8
  2385. + #define EXP_INT 16
  2386. + 
  2387. + isfloat_string(cp)
  2388. +      register char *cp;
  2389. + {
  2390. +   register state;
  2391. +   
  2392. +   state = 0;
  2393. +   if ((*cp == '+') || (*cp == '-'))
  2394. +     cp++;
  2395. +   if (isdigit(*cp))
  2396. +     {
  2397. +       state |= LEAD_INT;
  2398. +       while (isdigit (*cp))
  2399. +     cp ++;
  2400. +     }
  2401. +   if (*cp == '.')
  2402. +     {
  2403. +       state |= DOT_CHAR;
  2404. +       cp++;
  2405. +     }
  2406. +   if (isdigit(*cp))
  2407. +     {
  2408. +       state |= TRAIL_INT;
  2409. +       while (isdigit (*cp))
  2410. +     cp++;
  2411. +     }
  2412. +   if (*cp == 'e')
  2413. +     {
  2414. +       state |= E_CHAR;
  2415. +       cp++;
  2416. +     }
  2417. +   if ((*cp == '+') || (*cp == '-'))
  2418. +     {
  2419. +       cp++;
  2420. +     }
  2421. +   if (isdigit(*cp))
  2422. +     {
  2423. +       state |= EXP_INT;
  2424. +       while (isdigit (*cp))
  2425. +     cp++;
  2426. +     }
  2427. +   return ((*cp == 0) &&
  2428. +       ((state == (LEAD_INT|DOT_CHAR|TRAIL_INT)) ||
  2429. +        (state == (LEAD_INT|E_CHAR|EXP_INT)) ||
  2430. +        (state == (LEAD_INT|DOT_CHAR|TRAIL_INT|E_CHAR|EXP_INT))));
  2431. + }
  2432. + #endif LISP_FLOAT_TYPE
  2433.   
  2434.   static Lisp_Object
  2435.   read_vector (readcharfun)
  2436. diff -rc emacs-18.57/src/m-sun3.h emacs/src/m-sun3.h
  2437. *** emacs-18.57/src/m-sun3.h    Wed Jun 20 18:42:45 1990
  2438. --- emacs/src/m-sun3.h    Tue Aug 13 10:52:12 1991
  2439. ***************
  2440. *** 14,19 ****
  2441. --- 14,22 ----
  2442.   #define A_TEXT_OFFSET(HDR) sizeof (HDR)
  2443.   
  2444.   /* In case we are using floating point, work together with crt0.c.  */
  2445. + #define C_SWITCH_MACHINE -fsoft
  2446. + 
  2447. + /* In case we are using floating point, work together with crt0.c.  */
  2448.   
  2449.   #ifndef __GNUC__
  2450.   #define C_SWITCH_MACHINE -fsoft
  2451. diff -rc emacs-18.57/src/print.c emacs/src/print.c
  2452. *** emacs-18.57/src/print.c    Tue Jan  8 19:01:11 1991
  2453. --- emacs/src/print.c    Tue Aug 13 10:52:18 1991
  2454. ***************
  2455. *** 1,3 ****
  2456. --- 1,15 ----
  2457. + /******************************************************************************
  2458. + *                                          *
  2459. + *    File:     print.c                              *
  2460. + *    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 *
  2461. + *    Created:  Mon Nov  2 15:24:52 EST 1987                      *
  2462. + *    Contents: GNU print.c with my float code                  *
  2463. + *                                          *
  2464. + *    Copyright (c) 1987 Wolfgang Rupprecht.                      *
  2465. + *    All rights reserved.                              *
  2466. + *                                          *
  2467. + *    $Log$                                      *
  2468. + ******************************************************************************/
  2469.   /* Lisp object printing and output streams.
  2470.      Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
  2471.   
  2472. ***************
  2473. *** 33,38 ****
  2474. --- 45,55 ----
  2475.   
  2476.   Lisp_Object Vstandard_output, Qstandard_output;
  2477.   
  2478. + #ifdef LISP_FLOAT_TYPE
  2479. + Lisp_Object Vfloat_output_format,Qfloat_output_format;
  2480. + #endif LISP_FLOAT_TYPE
  2481. + 
  2482. + 
  2483.   /* Avoid actual stack overflow in print.  */
  2484.   int print_depth;
  2485.   
  2486. ***************
  2487. *** 440,445 ****
  2488. --- 457,540 ----
  2489.     return obj;
  2490.   }
  2491.   
  2492. + #ifdef LISP_FLOAT_TYPE
  2493. + 
  2494. + #define WFLAG 0x80
  2495. + #define FIXBOUNDS(x,l,u) { if (x < l) {x = l;} else if (x > u) {x = u;}}
  2496. + 
  2497. + void
  2498. +   float_to_string (buf, data)
  2499. + char * buf;
  2500. + /*
  2501. +  * This buffer should be at least as large as the max string size of the
  2502. +  * largest float, printed in the biggest notation.  This is undoubtably
  2503. +  * 20d float_output_format, with the negative of the C-constant "HUGE"
  2504. +  * from <math.h>.
  2505. +  * 
  2506. +  * On the vax the worst case is -1e38 in 20d format which takes 61 bytes.
  2507. +  * 
  2508. +  * I assume that IEEE-754 format numbers can take 329 bytes for the worst
  2509. +  * case of -1e307 in 20d float_output_format. What is one to do (short of
  2510. +  * re-writing _doprnt to be more sane)?
  2511. +  *             -wsr
  2512. +  */
  2513. + double data;
  2514. + {
  2515. +   register unsigned char *cp, c, *endp;
  2516. +   register int width;
  2517. +   unsigned int state;
  2518. +       
  2519. +   if (NULL (Vfloat_output_format) ||
  2520. +       (XTYPE(Vfloat_output_format) != Lisp_String))
  2521. +     sprintf (buf, "%.2e", data);
  2522. +   else            /* oink oink */
  2523. +     {
  2524. +       cp = XSTRING(Vfloat_output_format)->data;
  2525. +       endp = XSTRING(Vfloat_output_format)->size + cp;
  2526. +       state = 0;
  2527. +       
  2528. +       for (width = 0;
  2529. +        ((cp < endp) && ((c = *cp) >= '0') && (c <= '9'));
  2530. +        cp++)
  2531. +     {
  2532. +       state = WFLAG;
  2533. +       width *= 10;
  2534. +       width += c - '0';
  2535. +     }
  2536. +       
  2537. +       if ((cp < endp) &&
  2538. +       ((c = *cp) == 'e') || (c == 'd'))
  2539. +     state |= c;
  2540. +       
  2541. +       switch (state)
  2542. +     {
  2543. +     default:        /* never happen ... */
  2544. +     case 0:
  2545. +       sprintf (buf, "%.3g", data);
  2546. +       break;
  2547. +     case WFLAG:
  2548. +       FIXBOUNDS(width, 1, 20);
  2549. +       sprintf (buf, "%.*g", width, data);
  2550. +       break;
  2551. +     case 'e':
  2552. +       sprintf (buf, "%.2e", data);
  2553. +       break;
  2554. +     case 'e'|WFLAG:
  2555. +       FIXBOUNDS(width, 0, 20);
  2556. +       sprintf (buf, "%.*e", width, data);
  2557. +       break;
  2558. +     case 'd':
  2559. +       sprintf (buf, "%.3f", data);
  2560. +       break;
  2561. +     case 'd'|WFLAG:
  2562. +       FIXBOUNDS(width, 1, 20);
  2563. +       sprintf (buf, "%.*f", width, data);
  2564. +       break;
  2565. +     }
  2566. +     }
  2567. + }
  2568. + #endif LISP_FLOAT_TYPE
  2569. + 
  2570.   static void
  2571.   print (obj, printcharfun, escapeflag)
  2572.   #ifndef RTPC_REGISTER_BUG
  2573. ***************
  2574. *** 481,486 ****
  2575. --- 576,592 ----
  2576.             -1, printcharfun);
  2577.         break;
  2578.   
  2579. + #ifdef LISP_FLOAT_TYPE
  2580. +     case Lisp_Float:
  2581. +       {
  2582. +     char pigbuf[350];    /* see comments in float_to_string */
  2583. + 
  2584. +     float_to_string (pigbuf, XFLOAT(obj)->data);
  2585. +     strout (pigbuf, -1, printcharfun);
  2586. +       }
  2587. +       break;
  2588. + #endif LISP_FLOAT_TYPE
  2589. + 
  2590.       case Lisp_Int:
  2591.         sprintf (buf, "%d", XINT (obj));
  2592.         strout (buf, -1, printcharfun);
  2593. ***************
  2594. *** 673,678 ****
  2595. --- 779,809 ----
  2596.     Vstandard_output = Qt;
  2597.     Qstandard_output = intern ("standard-output");
  2598.     staticpro (&Qstandard_output);
  2599. + 
  2600. + #ifdef LISP_FLOAT_TYPE
  2601. +   DEFVAR_LISP ("float-output-format", &Vfloat_output_format,
  2602. + "The format descriptor string (or nil) that lisp uses to print out\n\
  2603. + floats. Nil means use built-in defaults.\n\
  2604. + The descriptor string consists of an optional field-width spec,\n\
  2605. + followed by an optional output-style descriptor.\n\
  2606. + \n\
  2607. + Valid field-widths specs are:\n\
  2608. + The empty string for default precision.\n\
  2609. + 0-20 for exponential notation, or 1-20 for decimal point notation. A 0\n\
  2610. + field spec causes the printing of the decimal point to be supressed.\n\
  2611. + Using an out of bounds specs cause the closest valid spec to be used.\n\
  2612. + \n\
  2613. + Valid ouput-styles may be one of the following:\n\
  2614. + The letter 'e' for exponential notation \"<number>.<number>e<number>\"\n\
  2615. + The letter 'd' for decimal point notation \"<number>.<number>\".\n\
  2616. + The empty string, for the defaulted output style.  This may print in\n\
  2617. + either format in a data-dependent manner, choosing whatever produces\n\
  2618. + the shortest string.\n\
  2619. + ");
  2620. +   Vfloat_output_format = Qnil;
  2621. +   Qfloat_output_format = intern ("float-output-format");
  2622. +   staticpro (&Qfloat_output_format);
  2623. + #endif LISP_FLOAT_TYPE
  2624.   
  2625.     DEFVAR_LISP ("print-length", &Vprint_length,
  2626.       "Maximum length of list to print before abbreviating.\
  2627. diff -rc emacs-18.57/src/ymakefile emacs/src/ymakefile
  2628. *** emacs-18.57/src/ymakefile    Tue Jan  8 19:23:01 1991
  2629. --- emacs/src/ymakefile    Tue Aug 13 11:47:39 1991
  2630. ***************
  2631. *** 1,3 ****
  2632. --- 1,15 ----
  2633. + /******************************************************************************
  2634. + *                                          *
  2635. + *    File:     ymakefile                              *
  2636. + *    Author:   Wolfgang S. Rupprecht <wolfgang@wsrcc.com>                 *
  2637. + *    Created:  Mon Nov  2 15:27:47 EST 1987                      *
  2638. + *    Contents: GNU ymakefile with my float code                  *
  2639. + *                                          *
  2640. + *    Copyright (c) 1987 Wolfgang Rupprecht.                      *
  2641. + *    All rights reserved.                              *
  2642. + *                                          *
  2643. + *    $Log$                                      *
  2644. + ******************************************************************************/
  2645.   /* Makefile for GNU Emacs.
  2646.      Copyright (C) 1985, 1987, 1988, 1990 Free Software Foundation, Inc.
  2647.   
  2648. ***************
  2649. *** 62,67 ****
  2650. --- 74,88 ----
  2651.   #define LIBS_MACHINE
  2652.   #endif
  2653.   
  2654. + 
  2655. + #ifndef LIB_MATH
  2656. + # ifdef LISP_FLOAT_TYPE
  2657. + #  define LIB_MATH -lm
  2658. + # else 
  2659. + #  define LIB_MATH
  2660. + # endif
  2661. + #endif
  2662. + 
  2663.   /* Some s- files define this to request special switches in ld.  */
  2664.   #ifndef LD_SWITCH_SYSTEM
  2665.   #if defined (BSD) && !defined (COFF)
  2666. ***************
  2667. *** 144,150 ****
  2668.   SHORT= shortnames
  2669.   #endif /* SHORTNAMES */
  2670.   
  2671. ! CFLAGS= C_DEBUG_SWITCH -Demacs $(MYCPPFLAG) C_SWITCH_MACHINE C_SWITCH_SYSTEM
  2672.   /* DO NOT use -R.  There is a special hack described in lastfile.c
  2673.      which is used instead.  Some initialized data areas are modified
  2674.      at initial startup, then labeled as part of the text area when
  2675. --- 165,171 ----
  2676.   SHORT= shortnames
  2677.   #endif /* SHORTNAMES */
  2678.   
  2679. ! CFLAGS= C_OPTIMIZE_SWITCH C_DEBUG_SWITCH -Demacs $(MYCPPFLAG) C_SWITCH_MACHINE C_SWITCH_SYSTEM
  2680.   /* DO NOT use -R.  There is a special hack described in lastfile.c
  2681.      which is used instead.  Some initialized data areas are modified
  2682.      at initial startup, then labeled as part of the text area when
  2683. ***************
  2684. *** 272,277 ****
  2685. --- 293,301 ----
  2686.       ${lispdir}text-mode.elc ${lispdir}fill.elc \
  2687.       ${lispdir}c-mode.elc ${lispdir}isearch.elc \
  2688.       ${lispdir}replace.elc ${lispdir}abbrev.elc \
  2689. + #ifdef LISP_FLOAT_TYPE
  2690. +     ${lispdir}float-sup.elc \
  2691. + #endif LISP_FLOAT_TYPE
  2692.       ${lispdir}buff-menu.elc ${lispdir}subr.elc
  2693.   
  2694.   /* just to be sure the sh is used */
  2695. ***************
  2696. *** 278,284 ****
  2697.   SHELL=/bin/sh
  2698.   
  2699.   /* Construct full set of libraries to be linked.  */
  2700. ! LIBES = LIBS_TERMCAP $(LIBX) LIBS_SYSTEM LIBS_MACHINE LIBS_DEBUG LIB_STANDARD $(GNULIB_VAR)
  2701.   
  2702.   /* Enable recompilation of certain other files depending on system type.  */
  2703.   
  2704. --- 302,308 ----
  2705.   SHELL=/bin/sh
  2706.   
  2707.   /* Construct full set of libraries to be linked.  */
  2708. ! LIBES = LIBS_TERMCAP $(LIBX) LIBS_SYSTEM LIBS_MACHINE LIBS_DEBUG LIB_MATH LIB_STANDARD $(GNULIB_VAR)
  2709.   
  2710.   /* Enable recompilation of certain other files depending on system type.  */
  2711.