home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume3 / g-format / part1 next >
Encoding:
Internet Message Format  |  1986-11-30  |  29.2 KB
  1. From: J.D.Aplevich - Electrical Engineering <watmath!watdcsu!aplevich>
  2. Subject: G-format compilers for Ultrix/Unix Vaxes (1 of 4)
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 3, Issue 37
  7. Submitted by: J.D.Aplevich <watmath!watdcsu!aplevich>
  8.  
  9.  
  10. This and three following files contain patches for  convert-
  11. ing  the source for the Ultrix/BSD4.2 f77 compiler to run on
  12. and to produce code for G-format Vaxes.
  13.  
  14. On a G (IEEE standard) format Vax, a "double" floating-point
  15. number  is  represented by 1 sign bit, 11 exponent bits, and
  16. 52 bit significand, whereas on D-format machines a double is
  17. represented  by 1 sign bit, 7 exponent bits, and 56 bit sig-
  18. nificand.  Thus the numerical consequences of  G-format  are
  19. increased  dynamic  range at the expense of 4 bits of preci-
  20. sion.
  21.  
  22. In both formats a "float" is the same as the left 32 bits of
  23. the D-format double, and consequently on a G-format machine,
  24. any code will fail that explicitly requires a  float  to  be
  25. the  top  half  of  a double, as it is on the older D-format
  26. machines.  Examples are the Unix C and  f77  compilers,  and
  27. code produced by them.
  28.  
  29. Some G-format machines are: certain versions of the MicroVax
  30. I,  (which also emulates D-format instructions, with loss of
  31. precision),  and  the  MicroVax  II,  which  supports   both
  32. representations,  as do larger Vaxes with microcode options.
  33. DEC does not supply either f77 or Pascal G-format  compilers
  34. for Ultrix.
  35.  
  36. If one is equipped with a source license, it is possible  to
  37. produce  the  patches required for converting the Ultrix (or
  38. BSD 4.2) compiler to G-format. It is also necessary to  have
  39. G-format  system  libraries  (libc, libm) as in G-format Ul-
  40. trix, (but these are NOT included here).
  41.  
  42. Because f77 is a moving target, some of  these  patches  are
  43. context diffs, rather than ordinary diffs.  They convert f77
  44. source files to versions containing #ifdef  GFLOAT  switches
  45. although  it would also be simple to have G-format as a com-
  46. piler option, as in Ultrix C.  The widely-used patch program
  47. from  L. Wall is recommended to handle the details. It would
  48. have made sense to include its source here  but  that  would
  49. have  increased  the  size of the distribution by 50Kb.  The
  50. shar archives are of the directory `gfloat', which  contains
  51. patches    to    routines   from   f77/src/f1,   f77/src/f2,
  52. f77/src/f77pass1, libF77, and libU77.  A makefile is includ-
  53. ed  to handle most of the details, as are fixes for a couple
  54. of libc.a and libm.a routines.
  55.  
  56. CAVEAT COMPUTOR:
  57. The code that results from these patches is, of course,  not
  58. guaranteed to be bug-free, but has been tested by use on ap-
  59. plications programs. It may be that we  have  not  exercised
  60. code in which bugs exist.
  61.  
  62. ACKNOWLEDGMENT:
  63. This material is a by-product of a project  undertaken  with
  64. the  support  of  WATDEC,  a University of Waterloo, Digital
  65. Equipment of Canada research contract.
  66.  
  67. SPECIAL BONUS OFFER: pc (Pascal)!
  68. Once f77 works, it is very simple to get a usable pc working
  69. on  a  G-format  machine.  Some  strings in /usr/lib/pc0 and
  70. /usr/lib/pc2 have to be changed using adb.  In  the  version
  71. we have, in pc0 we change
  72.  
  73.      `double 0d' at location 18284 to `gfloat 0g'
  74. and in pc2, we change
  75.  
  76.      `cvtrdl' at location 100e to `cvtrgl',
  77.      `cvtdl' at location 102a to `cvtgl',
  78.      `cvtld' at location 197f to `cvtlg',
  79.      `divd2' at location 198b to `divg2',
  80.      `0d2.' at location 1993 to `0g2.'
  81.  
  82. It might be necessary to locate these strings using
  83. `od -s <file> 0x0' .
  84.  
  85. -------------- cut here --------------------------------------------
  86. #!/bin/sh
  87. # This is a shell archive, meaning:
  88. # 1. Remove everything above the #!/bin/sh line.
  89. # 2. Save the resulting text in a file.
  90. # 3. Execute the file with /bin/sh (not csh) to create the files:
  91. #    gfloat
  92. # This archive created: Tue Oct 29 20:28:27 1985
  93. export PATH; PATH=/bin:$PATH
  94. if test ! -d 'gfloat'
  95. then
  96.     mkdir 'gfloat'
  97. fi
  98. cd 'gfloat'
  99. if test -f 'Makefile'
  100. then
  101.     echo shar: over-writing existing file "'Makefile'"
  102. fi
  103. cat << \SHAR_EOF > 'Makefile'
  104. # Files changed in G-float code.
  105. f1FILES = local2.c otable.c table.c Makefile
  106.  
  107. f2FILES = c22.c Makefile
  108.  
  109. pass1FILES = bb.c\
  110. conv.c\
  111. conv.h\
  112. defs.h\
  113. expr.c\
  114. intr.c\
  115. optcse.c\
  116. optloop.c\
  117. put.c\
  118. vax.c\
  119. Makefile
  120.  
  121. libF77FILES = \
  122. opcodes.h\
  123. besj0_.c\
  124. besj1_.c\
  125. besjn_.c\
  126. besy0_.c\
  127. besy1_.c\
  128. besyn_.c\
  129. c_abs.c\
  130. erf_.c\
  131. erfc_.c\
  132. pow_ri.c\
  133. r_abs.c\
  134. r_acos.c\
  135. r_asin.c\
  136. r_atan.c\
  137. r_atn2.c\
  138. r_cos.c\
  139. r_cosh.c\
  140. r_dim.c\
  141. r_exp.c\
  142. r_imag.c\
  143. r_int.c\
  144. r_lg10.c\
  145. r_log.c\
  146. r_mod.c\
  147. r_nint.c\
  148. r_sign.c\
  149. r_sin.c\
  150. r_sinh.c\
  151. r_sqrt.c\
  152. r_tan.c\
  153. r_tanh.c\
  154. rand_.c\
  155. range.c\
  156. trapov_.c\
  157. trpfpe_.c\
  158. Makefile
  159.  
  160. libU77FILES =\
  161. dtime_.c\
  162. Makefile
  163.  
  164. LIB =
  165. FILES =
  166. DFLG =
  167.  
  168. # Generate diffs between original source and G-float switched source.
  169. # Diffs are put into the local diff directories only.
  170.  
  171. diffs:  f1diffs f2diffs pass1diffs libFdiffs libUdiffs
  172.  
  173. cdiffs: 
  174.     @make DFLG="-c" diffs
  175.  
  176. netdiffs:
  177.     @make DFLG="-c" f1diffs
  178.     @make           f2diffs
  179.     @make DFLG="-c" pass1diffs
  180.     @make           libFdiffs
  181.     @make           libUdiffs
  182.  
  183. f1diffs:
  184.     @make FILES="$(f1FILES)" LIB=f77/src/f1 DFLG="$(DFLG)" mkdiffs
  185.  
  186. f2diffs:
  187.     @make FILES="$(f2FILES)" LIB=f77/src/f2 DFLG="$(DFLG)" mkdiffs
  188.  
  189. pass1diffs:
  190.     @make FILES="$(pass1FILES)" LIB=f77/src/f77pass1 DFLG="$(DFLG)" mkdiffs
  191.  
  192. libFdiffs:
  193.     @make FILES="$(libF77FILES)" LIB=libF77 DFLG="$(DFLG)" mkdiffs
  194.  
  195. libUdiffs:
  196.     @make FILES="$(libU77FILES)" LIB=libU77 DFLG="$(DFLG)" mkdiffs
  197.  
  198. mkdiffs:
  199.     @-for i in ${FILES} ; do echo $(LIB)/$$i.diff ; \
  200.         diff $(DFLG) ../$(LIB)/$$i.orig ../$(LIB)/$$i > $(LIB)/$$i.diff ; done
  201.  
  202. # Remove local diff files.
  203.  
  204. cleandiffs:
  205.     rm -f f77/src/f1/*.diff
  206.     rm -f f77/src/f2/*.diff
  207.     rm -f f77/src/f77pass1/*.diff
  208.     rm -f libF77/*.diff
  209.     rm -f libU77/*.diff
  210.  
  211. reallyclean:
  212.     make orig
  213.     (cd ../f77/src/f77; rm -f *.o mkvers Version Version.c)
  214.     (cd ../f77/src/f1; rm -f *.o mkvers Version Version.c)
  215.     (cd ../f77/src/f2; rm -f *.o mkvers Version Version.c)
  216.     (cd ../f77/src/f77pass1; rm -f *.o mkvers Version Version.c \
  217.                                  tokdefs.h gram.in gram.c)
  218.     (cd ../libF77; rm -f *.o mkvers Version Version.c *.a mkindx)
  219.     (cd ../libF77/profiled; rm -f *.o mkvers Version Version.c)
  220.     (cd ../libI77; rm -f *.o mkvers Version Version.c *.a mkindx)
  221.     (cd ../libI77/profiled; rm -f *.o mkvers Version Version.c)
  222.     (cd ../libU77; rm -f *.o mkvers Version Version.c *.a mkindx)
  223.     (cd ../libU77/profiled; rm -f *.o mkvers Version Version.c)
  224.  
  225. all:
  226.     make mods
  227.     (cd ../f77; make install)
  228.     (cd ../libF77; make install)
  229.     (cd ../libI77; make install)
  230.     (cd ../libU77; make install)
  231.  
  232. # Apply local diff files to local source, moving source to *.orig.
  233.  
  234. mods:   f1mods f2mods pass1mods libFmods libUmods
  235.  
  236. f1mods:
  237.     @make FILES="$(f1FILES)" LIB=f77/src/f1 makemod
  238.  
  239. f2mods:
  240.     @make FILES="$(f2FILES)" LIB=f77/src/f2 makemod
  241.  
  242. pass1mods:
  243.     @make FILES="$(pass1FILES)" LIB=f77/src/f77pass1 makemod
  244.  
  245. libFmods:
  246.     @make FILES="$(libF77FILES)" LIB=libF77 makemod
  247.  
  248. libUmods:
  249.     @make FILES="$(libU77FILES)" LIB=libU77 makemod
  250.  
  251. makemod:
  252.     @-for i in ${FILES} ; do if test ! -f ../$(LIB)/$$i.orig ; then \
  253.         echo $(LIB)/$$i ; patch ../$(LIB)/$$i $(LIB)/$$i.diff ; \
  254.         fi done
  255.  
  256. # Move *.orig files back in place, restoring source to original condition.
  257.  
  258. orig: f1orig f2orig pass1orig libForig libUorig
  259.  
  260. f1orig:
  261.     @make FILES="$(f1FILES)" LIB=f77/src/f1 makeorig
  262. f2orig:
  263.     @make FILES="$(f2FILES)" LIB=f77/src/f2 makeorig
  264. pass1orig:
  265.     @make FILES="$(pass1FILES)" LIB=f77/src/f77pass1 makeorig
  266. libForig:
  267.     @make FILES="$(libF77FILES)" LIB=libF77 makeorig
  268. libUorig:
  269.     @make FILES="$(libU77FILES)" LIB=libU77 makeorig
  270.  
  271. makeorig:
  272.     @-for i in $(FILES); do if test -f $(LIB)/$$i.diff ; then \
  273.         mv ../$(LIB)/$$i.orig ../$(LIB)/$$i; fi done
  274. SHAR_EOF
  275. chmod +x 'Makefile'
  276. if test -f 'READ_ME'
  277. then
  278.     echo shar: over-writing existing file "'READ_ME'"
  279. fi
  280. cat << \SHAR_EOF > 'READ_ME'
  281.  
  282.      This directory contains a  makefile  for  handling  the
  283. differences between the f77 compiler source and the modified
  284. source with G-float switches in it.
  285.  
  286.      An original f77 source is kept, along with a  directory
  287. tree in gfloat (this directory) containing diff(1) files for
  288. constructing a source containing `#ifdef GFLOAT' switches.
  289.  
  290. 1.   To make a source containing the G-float  switches,  put
  291.      this  (gfloat)  directory into the new source directory
  292.      at the same level as the libF77, LibU77, and f77 source
  293.      directories  (or  links  to them). That is, the command
  294.      `lc' should give something like
  295.  
  296.              Directories:
  297.              f77    gfloat    libF77     libI77     libU77
  298.  
  299.      Now in gfloat, type `make  mods'.  In  each  directory,
  300.      original  files will be copied into *.orig before being
  301.      replaced by modified files of the original name, so you
  302.      need write permission everywhere.
  303.  
  304.      To help  avoid  blunders,  if  a  *.orig  file  already
  305.      exists, the file modification is silently ignored.
  306.  
  307.      If the source is not identical to the source from which
  308.      the  diff  files  were  made and context diffs were not
  309.      used, patch may fail. In this case, the  following  may
  310.      be tried:
  311.  
  312.      a)   Apply `make mods'  to  the  original  source  from
  313.           which  the diffs were obtained (if you have it, of
  314.           course).
  315.  
  316.      b)   Type `make cdiffs' to create  context  diff  files
  317.           (see  3.  below), copy the resulting gfloat direc-
  318.           tory as before  into  the  directory  of  the  new
  319.           source,  and  try  `make  mods'  again.  This time
  320.           patch is using context diffs, and should have more
  321.           success.    Correct  patches  are  of  course  not
  322.           guaranteed, but gross failures are detected.  They
  323.           have to be corrected by hand.
  324.  
  325. 2.   To restore the source directory to original form,  type
  326.      `make  orig',  which  moves  the *.orig files back into
  327.      place.  To help avoid losing modified files obtained at
  328.      much sweat, the move is ignored if an appropriate .diff
  329.      file does not exist.  However the time of last  modifi-
  330.      cation is not checked.
  331.  
  332. 3.   To compile and install the  G-float  code,  do  step  1
  333.      above,  then  in  f77,  libF77, libI77, and libU77 type
  334.      `make' or `make install' in the usual  way,  since  the
  335.      relevant Makefiles are modified to include the -DGFLOAT
  336.      CFLAG.  If you are really optimistic, type  `make  all'
  337.      from here and come back in about 3 hours.
  338.  
  339. 4.   To compute the diff files, use make  diffs  Which  con-
  340.      structs the diff files from the *.c and *.c.orig files.
  341.      Note that diff(1) correctly returns Error code  1  mes-
  342.      sages.  Directories containing changed files are:
  343.       f77/src/f1
  344.       f77/src/f2
  345.       f77/src/f77pass1
  346.       libF77
  347.       libU77
  348.  
  349.      If more files have to be modified, be sure to copy  the
  350.      original  into  *.orig first, and include the file name
  351.      in the appropriate place in Makefile.
  352.  
  353.      Because the f77 source  is  a  moving  target,  context
  354.      diffs may be required, and this is where the patch pro-
  355.      gram comes in handy. To make context diffs,  use  `make
  356.      cdiffs'.
  357.  
  358. 5.   The Ultrix G-float C  compiler  contains  a  bug.   For
  359.      example, a call to the modified libF77/r_sin.c routine
  360.  
  361.                   float r_sin(x)
  362.                   float *x;
  363.                   {
  364.                   double sin();
  365.                   return( sin(*x) );
  366.                   }
  367.  
  368.      returns a $#?!!*#@ double (NOT a float) in register  0.
  369.      Refer  to section 9.10 of "The C Programming Language -
  370.      Reference  Manual"  by  Dennis  M.  Ritchie.   This  is
  371.      invisible  when  programming  in C because the compiler
  372.      has another bug that treats the  returned  value  of  a
  373.      float  function  as  a double.  The bug becomes visible
  374.      when we interface assembly language to C, or  as  here,
  375.      hack  a  compiler  to  produce  assembly language which
  376.      calls functions written and compiled  in  C.   An  ugly
  377.      union  has  had to be used to force a float return in a
  378.      bunch of library functions, since accepting it as  dou-
  379.      ble  would coerce the fortran expression containing the
  380.      function reference to be double precision.
  381.  
  382. SHAR_EOF
  383. chmod +x 'READ_ME'
  384. if test ! -d 'libF77'
  385. then
  386.     mkdir 'libF77'
  387. fi
  388. cd 'libF77'
  389. if test -f 'c_abs.c.diff'
  390. then
  391.     echo shar: over-writing existing file "'c_abs.c.diff'"
  392. fi
  393. cat << \SHAR_EOF > 'c_abs.c.diff'
  394. 11c11,17
  395. < 
  396. ---
  397. > #ifdef GFLOAT
  398. > union { double d;
  399. >     float r[2];
  400. >     } res;
  401. >   res.r[0] = cabs( z->real, z->imag );
  402. >   return( res.d ); 
  403. > #else GFLOAT
  404. 12a19
  405. > #endif GFLOAT
  406. SHAR_EOF
  407. chmod +x 'c_abs.c.diff'
  408. if test -f 'opcodes.h.diff'
  409. then
  410.     echo shar: over-writing existing file "'opcodes.h.diff'"
  411. fi
  412. cat << \SHAR_EOF > 'opcodes.h.diff'
  413. 2c2
  414. <  * "@(#)opcodes.h    1.1" Vax op codes defined here
  415. ---
  416. >  * "@(#)opcodes.h    1.2" Vax op codes defined here
  417. 7a8
  418. > # define ACBG        0x4ffd
  419. 9a11
  420. > # define ADDG2        0x40fd
  421. 10a13
  422. > # define ADDG3        0x41fd
  423. 13a17
  424. > # define CMPG        0x51fd
  425. 14a19
  426. > # define CVTBG        0x4cfd
  427. 15a21
  428. > # define CVTGB        0x48fd
  429. 16a23
  430. > # define CVTGF        0x33fd
  431. 17a25
  432. > # define CVTGL        0x4afd
  433. 18a27
  434. > # define CVTGW        0x49fd
  435. 20a30
  436. > # define CVTFG        0x56fd
  437. 23a34
  438. > # define CVTRGL        0x4bfd
  439. 25a37
  440. > # define DIVG2        0x46fd
  441. 26a39
  442. > # define DIVG3        0x47fd
  443. 29a43
  444. > # define EMODG        0x54fd
  445. 31a46
  446. > # define MNEGG        0x52fd
  447. 33a49
  448. > # define MOVG        0x50fd
  449. 35a52
  450. > # define MULG2        0x44fd
  451. 36a54
  452. > # define MULG3        0x45fd
  453. 39a58
  454. > # define POLYG        0x55fd
  455. 41a61
  456. > # define SUBG2        0x42fd
  457. 42a63
  458. > # define SUBG3        0x43fd
  459. 45a67
  460. > # define TSTG        0x53fd
  461. SHAR_EOF
  462. chmod +x 'opcodes.h.diff'
  463. if test -f 'r_abs.c.diff'
  464. then
  465.     echo shar: over-writing existing file "'r_abs.c.diff'"
  466. fi
  467. cat << \SHAR_EOF > 'r_abs.c.diff'
  468. 7a8
  469. > #ifndef GFLOAT
  470. 10a12,20
  471. > #else GFLOAT
  472. > union { double d;
  473. >     float r[2];
  474. >     } res;
  475. >   res.r[0] = *x;
  476. >   if(*x >= 0)
  477. >     return( res.d );
  478. >   return( -res.d );
  479. > #endif GFLOAT
  480. SHAR_EOF
  481. chmod +x 'r_abs.c.diff'
  482. if test -f 'r_acos.c.diff'
  483. then
  484.     echo shar: over-writing existing file "'r_acos.c.diff'"
  485. fi
  486. cat << \SHAR_EOF > 'r_acos.c.diff'
  487. 8a9
  488. > #ifndef GFLOAT
  489. 9a11,17
  490. > #else GFLOAT
  491. > union { double d;
  492. >     float r[2];
  493. >     } res;
  494. >   res.r[0] = acos( *x );
  495. >   return( res.d );
  496. > #endif GFLOAT
  497. SHAR_EOF
  498. chmod +x 'r_acos.c.diff'
  499. if test -f 'r_asin.c.diff'
  500. then
  501.     echo shar: over-writing existing file "'r_asin.c.diff'"
  502. fi
  503. cat << \SHAR_EOF > 'r_asin.c.diff'
  504. 8a9
  505. > #ifndef GFLOAT
  506. 9a11,17
  507. > #else GFLOAT
  508. > union { double d;
  509. >     float r[2];
  510. >     } res;
  511. >   res.r[0] = asin( *x );
  512. >   return( res.d );
  513. > #endif GFLOAT
  514. SHAR_EOF
  515. chmod +x 'r_asin.c.diff'
  516. if test -f 'r_atan.c.diff'
  517. then
  518.     echo shar: over-writing existing file "'r_atan.c.diff'"
  519. fi
  520. cat << \SHAR_EOF > 'r_atan.c.diff'
  521. 8a9
  522. > #ifndef GFLOAT
  523. 9a11,17
  524. > #else GFLOAT
  525. > union { double d;
  526. >     float r[2];
  527. >     } res;
  528. >   res.r[0] = atan( *x );
  529. >   return( res.d );
  530. > #endif GFLOAT
  531. SHAR_EOF
  532. chmod +x 'r_atan.c.diff'
  533. if test -f 'r_atn2.c.diff'
  534. then
  535.     echo shar: over-writing existing file "'r_atn2.c.diff'"
  536. fi
  537. cat << \SHAR_EOF > 'r_atn2.c.diff'
  538. 8a9
  539. > #ifndef GFLOAT
  540. 9a11,17
  541. > #else GFLOAT
  542. > union { double d;
  543. >     float r[2];
  544. >     } res;
  545. >   res.r[0] = atan2(*x,*y);
  546. >   return( res.d );
  547. > #endif GFLOAT
  548. SHAR_EOF
  549. chmod +x 'r_atn2.c.diff'
  550. if test -f 'r_cos.c.diff'
  551. then
  552.     echo shar: over-writing existing file "'r_cos.c.diff'"
  553. fi
  554. cat << \SHAR_EOF > 'r_cos.c.diff'
  555. 8a9
  556. > #ifndef GFLOAT
  557. 9a11,17
  558. > #else GFLOAT
  559. > union { double d;
  560. >     float r[2];
  561. >     } res;
  562. >   res.r[0] = cos( *x );
  563. >   return( res.d );
  564. > #endif GFLOAT
  565. SHAR_EOF
  566. chmod +x 'r_cos.c.diff'
  567. if test -f 'r_cosh.c.diff'
  568. then
  569.     echo shar: over-writing existing file "'r_cosh.c.diff'"
  570. fi
  571. cat << \SHAR_EOF > 'r_cosh.c.diff'
  572. 8a9
  573. > #ifndef GFLOAT
  574. 9a11,17
  575. > #else GFLOAT
  576. > union { double d;
  577. >     float r[2];
  578. >     } res;
  579. >   res.r[0] = cosh( *x );
  580. >   return( res.d );
  581. > #endif GFLOAT
  582. SHAR_EOF
  583. chmod +x 'r_cosh.c.diff'
  584. if test -f 'r_dim.c.diff'
  585. then
  586.     echo shar: over-writing existing file "'r_dim.c.diff'"
  587. fi
  588. cat << \SHAR_EOF > 'r_dim.c.diff'
  589. 7a8
  590. > #ifndef GFLOAT
  591. 8a10,16
  592. > #else GFLOAT
  593. > union { double d;
  594. >     float r[2];
  595. >     } res;
  596. >   res.r[0] = *a - *b;
  597. >   return( *a > *b ? res.d : 0);
  598. > #endif GFLOAT
  599. SHAR_EOF
  600. chmod +x 'r_dim.c.diff'
  601. if test -f 'r_exp.c.diff'
  602. then
  603.     echo shar: over-writing existing file "'r_exp.c.diff'"
  604. fi
  605. cat << \SHAR_EOF > 'r_exp.c.diff'
  606. 8a9
  607. > #ifndef GFLOAT
  608. 9a11,17
  609. > #else GFLOAT
  610. > union { double d;
  611. >     float r[2];
  612. >     } res;
  613. >   res.r[0] = exp( *x );
  614. >   return( res.d );
  615. > #endif GFLOAT
  616. SHAR_EOF
  617. chmod +x 'r_exp.c.diff'
  618. if test -f 'r_imag.c.diff'
  619. then
  620.     echo shar: over-writing existing file "'r_imag.c.diff'"
  621. fi
  622. cat << \SHAR_EOF > 'r_imag.c.diff'
  623. 9a10
  624. > #ifndef GFLOAT
  625. 10a12,18
  626. > #else GFLOAT
  627. > union { double d;
  628. >     float r[2];
  629. >     } res;
  630. >   res.r[0] = z->imag;
  631. >   return( res.d );
  632. > #endif GFLOAT
  633. SHAR_EOF
  634. chmod +x 'r_imag.c.diff'
  635. if test -f 'r_int.c.diff'
  636. then
  637.     echo shar: over-writing existing file "'r_int.c.diff'"
  638. fi
  639. cat << \SHAR_EOF > 'r_int.c.diff'
  640. 8a9
  641. > #ifndef GFLOAT
  642. 10a12,18
  643. > #else GFLOAT
  644. > union { double d;
  645. >     float r[2];
  646. >     } res;
  647. >   res.r[0] = (*x >= 0) ? floor(*x) : -floor(- *x);
  648. >   return( res.d ); 
  649. > #endif GFLOAT
  650. SHAR_EOF
  651. chmod +x 'r_int.c.diff'
  652. if test -f 'r_lg10.c.diff'
  653. then
  654.     echo shar: over-writing existing file "'r_lg10.c.diff'"
  655. fi
  656. cat << \SHAR_EOF > 'r_lg10.c.diff'
  657. 10a11
  658. > #ifndef GFLOAT
  659. 12a14,20
  660. > #else GFLOAT
  661. > union { double d;
  662. >     float r[2];
  663. >     } res;
  664. >   res.r[0] = log10e * log( *x );
  665. >   return( res.d );
  666. > #endif GFLOAT
  667. SHAR_EOF
  668. chmod +x 'r_lg10.c.diff'
  669. if test -f 'r_log.c.diff'
  670. then
  671.     echo shar: over-writing existing file "'r_log.c.diff'"
  672. fi
  673. cat << \SHAR_EOF > 'r_log.c.diff'
  674. 8a9
  675. > #ifndef GFLOAT
  676. 9a11,17
  677. > #else GFLOAT
  678. > union { double d;
  679. >     float r[2];
  680. >     } res;
  681. >   res.r[0] = log( *x );
  682. >   return( res.d );
  683. > #endif GFLOAT
  684. SHAR_EOF
  685. chmod +x 'r_log.c.diff'
  686. if test -f 'r_mod.c.diff'
  687. then
  688.     echo shar: over-writing existing file "'r_mod.c.diff'"
  689. fi
  690. cat << \SHAR_EOF > 'r_mod.c.diff'
  691. 7a8,12
  692. > #ifdef GFLOAT
  693. > union { double d;
  694. >     float r[2];
  695. >     } res;
  696. > #endif GFLOAT
  697. 12a18
  698. > #ifndef GFLOAT
  699. 13a20,23
  700. > #else GFLOAT
  701. > res.r[0] = *x - (*y) * quotient;
  702. > return( res.d );
  703. > #endif GFLOAT
  704. SHAR_EOF
  705. chmod +x 'r_mod.c.diff'
  706. if test -f 'r_nint.c.diff'
  707. then
  708.     echo shar: over-writing existing file "'r_nint.c.diff'"
  709. fi
  710. cat << \SHAR_EOF > 'r_nint.c.diff'
  711. 8a9,13
  712. > #ifdef GFLOAT
  713. > union { double d;
  714. >     float r[2];
  715. >     } res;
  716. > #endif GFLOAT
  717. 9a15
  718. > #ifndef GFLOAT
  719. 11a18,22
  720. > #else GFLOAT
  721. >   res.r[0] = (*x)>=0 ?
  722. >     floor(*x + .5) : -floor(.5 - *x);
  723. >   return( res.d );
  724. > #endif GFLOAT
  725. SHAR_EOF
  726. chmod +x 'r_nint.c.diff'
  727. if test -f 'r_sign.c.diff'
  728. then
  729.     echo shar: over-writing existing file "'r_sign.c.diff'"
  730. fi
  731. cat << \SHAR_EOF > 'r_sign.c.diff'
  732. 8a9,13
  733. > #ifdef GFLOAT
  734. > union { double d;
  735. >     float r[2];
  736. >     } res;
  737. > #endif GFLOAT
  738. 9a15
  739. > #ifndef GFLOAT
  740. 10a17,20
  741. > #else GFLOAT
  742. > res.r[0] = *b >= 0 ? x : -x;
  743. > return( res.d ); 
  744. > #endif GFLOAT
  745. SHAR_EOF
  746. chmod +x 'r_sign.c.diff'
  747. if test -f 'r_sin.c.diff'
  748. then
  749.     echo shar: over-writing existing file "'r_sin.c.diff'"
  750. fi
  751. cat << \SHAR_EOF > 'r_sin.c.diff'
  752. 8a9
  753. > #ifndef GFLOAT
  754. 9a11,17
  755. > #else GFLOAT
  756. > union { double d;
  757. >     float r[2];
  758. >     } res;
  759. >   res.r[0] = sin( *x );
  760. >   return( res.d );
  761. > #endif GFLOAT
  762. SHAR_EOF
  763. chmod +x 'r_sin.c.diff'
  764. if test -f 'r_sinh.c.diff'
  765. then
  766.     echo shar: over-writing existing file "'r_sinh.c.diff'"
  767. fi
  768. cat << \SHAR_EOF > 'r_sinh.c.diff'
  769. 8a9
  770. > #ifndef GFLOAT
  771. 9a11,17
  772. > #else GFLOAT
  773. > union { double d;
  774. >     float r[2];
  775. >     } res;
  776. >   res.r[0] = sinh( *x );
  777. >   return( res.d );
  778. > #endif GFLOAT
  779. SHAR_EOF
  780. chmod +x 'r_sinh.c.diff'
  781. if test -f 'r_sqrt.c.diff'
  782. then
  783.     echo shar: over-writing existing file "'r_sqrt.c.diff'"
  784. fi
  785. cat << \SHAR_EOF > 'r_sqrt.c.diff'
  786. 8a9
  787. > #ifndef GFLOAT
  788. 9a11,17
  789. > #else GFLOAT
  790. > union { double d;
  791. >     float r[2];
  792. >     } res;
  793. >   res.r[0] = sqrt( *x );
  794. >   return( res.d );
  795. > #endif GFLOAT
  796. SHAR_EOF
  797. chmod +x 'r_sqrt.c.diff'
  798. if test -f 'r_tan.c.diff'
  799. then
  800.     echo shar: over-writing existing file "'r_tan.c.diff'"
  801. fi
  802. cat << \SHAR_EOF > 'r_tan.c.diff'
  803. 8a9
  804. > #ifndef GFLOAT
  805. 9a11,17
  806. > #else GFLOAT
  807. > union { double d;
  808. >     float r[2];
  809. >     } res;
  810. >   res.r[0] = tan( *x );
  811. >   return( res.d );
  812. > #endif GFLOAT
  813. SHAR_EOF
  814. chmod +x 'r_tan.c.diff'
  815. if test -f 'r_tanh.c.diff'
  816. then
  817.     echo shar: over-writing existing file "'r_tanh.c.diff'"
  818. fi
  819. cat << \SHAR_EOF > 'r_tanh.c.diff'
  820. 8a9
  821. > #ifndef GFLOAT
  822. 9a11,17
  823. > #else GFLOAT
  824. > union { double d;
  825. >     float r[2];
  826. >     } res;
  827. >   res.r[0] = tanh( *x );
  828. >   return( res.d );
  829. > #endif GFLOAT
  830. SHAR_EOF
  831. chmod +x 'r_tanh.c.diff'
  832. if test -f 'range.c.diff'
  833. then
  834.     echo shar: over-writing existing file "'range.c.diff'"
  835. fi
  836. cat << \SHAR_EOF > 'range.c.diff'
  837. 77a78,81
  838. > #ifndef GFLOAT
  839. > #else GFLOAT
  840. >     n.j[0] = 0x00000010;
  841. > #endif GFLOAT
  842. 117a122
  843. > #ifndef GFLOAT
  844. 118a124,126
  845. > #else GFLOAT
  846. >     n.j[0] = 0x0000681e;
  847. > #endif GFLOAT
  848. SHAR_EOF
  849. chmod +x 'range.c.diff'
  850. if test -f 'trapov_.c.diff'
  851. then
  852.     echo shar: over-writing existing file "'trapov_.c.diff'"
  853. fi
  854. cat << \SHAR_EOF > 'trapov_.c.diff'
  855. 55a56,58
  856. > #ifdef GFLOAT
  857. > # define G        4
  858. > #endif GFLOAT
  859. 241a245,249
  860. > #ifdef GFLOAT
  861. > /* kludge for Gfloat  */
  862. >     if (operand_type(opcode, o_no)==F && (fetch_byte() & 0xff)==0xfd)
  863. >         opcode = opcode<<8 + 0xfd;
  864. > #endif GFLOAT
  865. 250a259
  866. > #ifndef GFLOAT
  867. 251a261,263
  868. > #else GFLOAT
  869. >     if (opcode == POLYG || opcode == POLYF) {
  870. > #endif GFLOAT
  871. 255a268
  872. > #ifndef GFLOAT
  873. 256a270,272
  874. > #else GFLOAT
  875. >     if (opcode == EMODG || opcode == EMODF) {
  876. > #endif GFLOAT
  877. 266a283
  878. > #ifndef GFLOAT
  879. 267a285,287
  880. > #else GFLOAT
  881. >         if (type != F && type != G) {
  882. > #endif GFLOAT
  883. 272c292
  884. <         /* F or D operand.  Check it out */
  885. ---
  886. >         /* F or D (or G) operand.  Check it out */
  887. 282a303
  888. > #ifndef GFLOAT
  889. 283a305,307
  890. > #else GFLOAT
  891. >         } else if (type == G && opnd->o_long == 0x00008000) {
  892. > #endif GFLOAT
  893. 307a332
  894. > #ifndef GFLOAT
  895. 317a343,354
  896. > #else GFLOAT
  897. >         case ACBG:    case ACBF:    case ADDG2:    case ADDG3:
  898. >         case ADDF2:    case ADDF3:    case CMPG:    case CMPF:
  899. >         case CVTGB:    case CVTGF:    case CVTGL:    case CVTGW:
  900. >         case CVTFB:    case CVTFG:    case CVTFL:    case CVTFW:
  901. >         case CVTRGL:    case CVTRFL:    case DIVG2:    case DIVG3:
  902. >         case DIVF2:    case DIVF3:    case EMODG:    case EMODF:
  903. >         case MNEGG:    case MNEGF:    case MOVG:    case MOVF:
  904. >         case MULG2:    case MULG3:    case MULF2:    case MULF3:
  905. >         case POLYG:    case POLYF:    case SUBG2:    case SUBG3:
  906. >         case SUBF2:    case SUBF3:    case TSTG:    case TSTF:
  907. > #endif GFLOAT
  908. 325c362
  909. <  * got_illegal_poly - handle an illegal POLY[DF] instruction.
  910. ---
  911. >  * got_illegal_poly - handle an illegal POLY[DFG] instruction.
  912. 360a398
  913. > #ifndef GFLOAT
  914. 361a400,402
  915. > #else GFLOAT
  916. >         case ACBG:
  917. > #endif GFLOAT
  918. 364a406
  919. > #ifndef GFLOAT
  920. 366d407
  921. <         case MNEGF:
  922. 368d408
  923. <         case MOVF:
  924. 369a410,416
  925. > #else GFLOAT
  926. >         case MNEGG:
  927. >         case MOVG:
  928. >         case TSTG:
  929. > #endif GFLOAT
  930. >         case MNEGF:
  931. >         case MOVF:
  932. 381c428
  933. <  *    operand_type - is the operand a D or an F?
  934. ---
  935. >  *    operand_type - is the operand a D, F or G?
  936. 391a439,441
  937. > #ifdef GFLOAT
  938. >     if (opcode >= 0x40fd && opcode <= 0x56fd) return G;
  939. > #endif GFLOAT
  940. 636a687
  941. > #ifndef GFLOAT
  942. 638d688
  943. <         case ACBF:     return "ACBF";
  944. 641,642d690
  945. <         case ADDF2:     return "ADDF2";
  946. <         case ADDF3:     return "ADDF3";
  947. 644d691
  948. <         case CMPF:     return "CMPF";
  949. 646a694
  950. >         case CVTFD:     return "CVTFD";
  951. 648a697,735
  952. >         case CVTRDL:     return "CVTRDL";
  953. >         case DIVD2:     return "DIVD2";
  954. >         case DIVD3:     return "DIVD3";
  955. >         case EMODD:     return "EMODD";
  956. >         case MNEGD:     return "MNEGD";
  957. >         case MOVD:     return "MOVD";
  958. >         case MULD2:     return "MULD2";
  959. >         case MULD3:     return "MULD3";
  960. >         case POLYD:     return "POLYD";
  961. >         case SUBD2:     return "SUBD2";
  962. >         case SUBD3:     return "SUBD3";
  963. >         case TSTD:     return "TSTD";
  964. > #else GFLOAT
  965. >         case ACBG:     return "ACBG";
  966. >         case ADDG2:     return "ADDG2";
  967. >         case ADDG3:     return "ADDG3";
  968. >         case CMPG:     return "CMPG";
  969. >         case CVTGB:     return "CVTGB";
  970. >         case CVTGF:     return "CVTGF";
  971. >         case CVTFG:     return "CVTFG";
  972. >         case CVTGL:     return "CVTGL";
  973. >         case CVTGW:     return "CVTGW";
  974. >         case CVTRGL:     return "CVTRGL";
  975. >         case DIVG2:     return "DIVG2";
  976. >         case DIVG3:     return "DIVG3";
  977. >         case EMODG:     return "EMODG";
  978. >         case MNEGG:     return "MNEGG";
  979. >         case MOVG:     return "MOVG";
  980. >         case MULG2:     return "MULG2";
  981. >         case MULG3:     return "MULG3";
  982. >         case POLYG:     return "POLYG";
  983. >         case SUBG2:     return "SUBG2";
  984. >         case SUBG3:     return "SUBG3";
  985. >         case TSTG:     return "TSTG";
  986. > #endif GFLOAT
  987. >         case ACBF:     return "ACBF";
  988. >         case ADDF2:     return "ADDF2";
  989. >         case ADDF3:     return "ADDF3";
  990. >         case CMPF:     return "CMPF";
  991. 650d736
  992. <         case CVTFD:     return "CVTFD";
  993. 653d738
  994. <         case CVTRDL:     return "CVTRDL";
  995. 655,656d739
  996. <         case DIVD2:     return "DIVD2";
  997. <         case DIVD3:     return "DIVD3";
  998. 659d741
  999. <         case EMODD:     return "EMODD";
  1000. 661d742
  1001. <         case MNEGD:     return "MNEGD";
  1002. 663d743
  1003. <         case MOVD:     return "MOVD";
  1004. 665,666d744
  1005. <         case MULD2:     return "MULD2";
  1006. <         case MULD3:     return "MULD3";
  1007. 669d746
  1008. <         case POLYD:     return "POLYD";
  1009. 671,672d747
  1010. <         case SUBD2:     return "SUBD2";
  1011. <         case SUBD3:     return "SUBD3";
  1012. 675d749
  1013. <         case TSTD:     return "TSTD";
  1014. SHAR_EOF
  1015. chmod +x 'trapov_.c.diff'
  1016. if test -f 'trpfpe_.c.diff'
  1017. then
  1018.     echo shar: over-writing existing file "'trpfpe_.c.diff'"
  1019. fi
  1020. cat << \SHAR_EOF > 'trpfpe_.c.diff'
  1021. 403c403,404
  1022. < 
  1023. ---
  1024. > /* This isn't going to work for G-format instructions because
  1025. >  * they are 2 characters long */
  1026. 405a407
  1027. > #ifndef GFLOAT
  1028. 409a412,417
  1029. > #else GFLOAT
  1030. >         case ADDG3:
  1031. >         case DIVG3:
  1032. >         case MULG3:
  1033. >         case SUBG3:
  1034. > #endif GFLOAT
  1035. 412a421
  1036. > #ifndef GFLOAT
  1037. 418a428,435
  1038. > #else GFLOAT
  1039. >         case ADDG2:
  1040. >         case DIVG2:
  1041. >         case MULG2:
  1042. >         case SUBG2:
  1043. >         case MNEGG:
  1044. >         case MOVG:
  1045. > #endif GFLOAT
  1046. 441a459
  1047. > #ifndef GFLOAT
  1048. 442a461,463
  1049. > #else GFLOAT
  1050. >         case CVTGF:
  1051. > #endif GFLOAT
  1052. 447a469
  1053. > #ifndef GFLOAT
  1054. 448a471,473
  1055. > #else GFLOAT
  1056. >         case CVTFG:
  1057. > #endif GFLOAT
  1058. 454a480
  1059. > #ifndef GFLOAT
  1060. 455a482,484
  1061. > #else GFLOAT
  1062. >         case EMODG:
  1063. > #endif GFLOAT
  1064. 459a489
  1065. > #ifndef GFLOAT
  1066. 460a491,493
  1067. > #else GFLOAT
  1068. >         case POLYG:
  1069. > #endif GFLOAT
  1070. 463a497
  1071. > #ifndef GFLOAT
  1072. 464a499,501
  1073. > #else GFLOAT
  1074. >         case ACBG:
  1075. > #endif GFLOAT
  1076. 465a503
  1077. > #ifndef GFLOAT
  1078. 466a505,507
  1079. > #else GFLOAT
  1080. >         case CMPG:
  1081. > #endif GFLOAT
  1082. 467a509
  1083. > #ifndef GFLOAT
  1084. 468a511,513
  1085. > #else GFLOAT
  1086. >         case TSTG:
  1087. > #endif GFLOAT
  1088. 469a515
  1089. > #ifndef GFLOAT
  1090. 472a519,523
  1091. > #else GFLOAT
  1092. >         case CVTGB:
  1093. >         case CVTGL:
  1094. >         case CVTGW:
  1095. > #endif GFLOAT
  1096. 475a527
  1097. > #ifndef GFLOAT
  1098. 476a529,531
  1099. > #else GFLOAT
  1100. >         case CVTRGL:
  1101. > #endif GFLOAT
  1102. SHAR_EOF
  1103. chmod +x 'trpfpe_.c.diff'
  1104. if test -f 'Makefile.diff'
  1105. then
  1106.     echo shar: over-writing existing file "'Makefile.diff'"
  1107. fi
  1108. cat << \SHAR_EOF > 'Makefile.diff'
  1109. 7c7
  1110. < CFLAGS          = -O
  1111. ---
  1112. > CFLAGS          = -O -DGFLOAT
  1113. 161c161
  1114. < OPTIONS          = -DUCBVAX
  1115. ---
  1116. > OPTIONS          = -DUCBVAX -DGFLOAT
  1117. SHAR_EOF
  1118. chmod +x 'Makefile.diff'
  1119. if test -f 'pow_ri.c.diff'
  1120. then
  1121.     echo shar: over-writing existing file "'pow_ri.c.diff'"
  1122. fi
  1123. cat << \SHAR_EOF > 'pow_ri.c.diff'
  1124. 10a11,15
  1125. > #ifdef GFLOAT
  1126. > union { double d;
  1127. >     float r[2];
  1128. >     } res;
  1129. > #endif GFLOAT
  1130. 21a27
  1131. > #ifndef GFLOAT
  1132. 22a29,32
  1133. > #else GFLOAT
  1134. >             res.r[0] = pow;
  1135. >             return(res.d);
  1136. > #endif GFLOAT
  1137. 36a47
  1138. > #ifndef GFLOAT
  1139. 37a49,52
  1140. > #else GFLOAT
  1141. > res.r[0] = pow;
  1142. > return(res.d);
  1143. > #endif GFLOAT
  1144. SHAR_EOF
  1145. chmod +x 'pow_ri.c.diff'
  1146. if test -f 'besj0_.c.diff'
  1147. then
  1148.     echo shar: over-writing existing file "'besj0_.c.diff'"
  1149. fi
  1150. cat << \SHAR_EOF > 'besj0_.c.diff'
  1151. 9a10,16
  1152. > #ifdef GFLOAT
  1153. > union { double d;
  1154. >     float r[2];
  1155. >     } res;
  1156. >     res.r[0] = ((float)j0((double)*x));
  1157. >     return( res.d );
  1158. > #else GFLOAT
  1159. 10a18
  1160. > #endif GFLOAT
  1161. SHAR_EOF
  1162. chmod +x 'besj0_.c.diff'
  1163. if test -f 'besj1_.c.diff'
  1164. then
  1165.     echo shar: over-writing existing file "'besj1_.c.diff'"
  1166. fi
  1167. cat << \SHAR_EOF > 'besj1_.c.diff'
  1168. 9a10,16
  1169. > #ifdef GFLOAT
  1170. > union { double d;
  1171. >     float r[2];
  1172. >     } res;
  1173. >     res.r[0] = ((float)j1((double)*x));
  1174. >     return( res.d );
  1175. > #else GFLOAT
  1176. 10a18
  1177. > #endif GFLOAT
  1178. SHAR_EOF
  1179. chmod +x 'besj1_.c.diff'
  1180. if test -f 'besjn_.c.diff'
  1181. then
  1182.     echo shar: over-writing existing file "'besjn_.c.diff'"
  1183. fi
  1184. cat << \SHAR_EOF > 'besjn_.c.diff'
  1185. 9a10,16
  1186. > #ifdef GFLOAT
  1187. > union { double d;
  1188. >     float r[2];
  1189. >     } res;
  1190. >     res.r[0] = ((float)jn((int)*n, (double)*x));
  1191. >     return( res.d );
  1192. > #else GFLOAT
  1193. 10a18
  1194. > #endif GFLOAT
  1195. SHAR_EOF
  1196. chmod +x 'besjn_.c.diff'
  1197. if test -f 'besy0_.c.diff'
  1198. then
  1199.     echo shar: over-writing existing file "'besy0_.c.diff'"
  1200. fi
  1201. cat << \SHAR_EOF > 'besy0_.c.diff'
  1202. 9a10,16
  1203. > #ifdef GFLOAT
  1204. > union { double d;
  1205. >     float r[2];
  1206. >     } res;
  1207. >     res.r[0] = ((float)y0((double)*x));
  1208. >     return( res.d );
  1209. > #else GFLOAT
  1210. 10a18
  1211. > #endif GFLOAT
  1212. SHAR_EOF
  1213. chmod +x 'besy0_.c.diff'
  1214. if test -f 'besy1_.c.diff'
  1215. then
  1216.     echo shar: over-writing existing file "'besy1_.c.diff'"
  1217. fi
  1218. cat << \SHAR_EOF > 'besy1_.c.diff'
  1219. 9a10,16
  1220. > #ifdef GFLOAT
  1221. > union { double d;
  1222. >     float r[2];
  1223. >     } res;
  1224. >     res.r[0] = ((float)y1((double)*x));
  1225. >     return( res.d );
  1226. > #else GFLOAT
  1227. 10a18
  1228. > #endif GFLOAT
  1229. SHAR_EOF
  1230. chmod +x 'besy1_.c.diff'
  1231. if test -f 'besyn_.c.diff'
  1232. then
  1233.     echo shar: over-writing existing file "'besyn_.c.diff'"
  1234. fi
  1235. cat << \SHAR_EOF > 'besyn_.c.diff'
  1236. 9a10,16
  1237. > #ifdef GFLOAT
  1238. > union { double d;
  1239. >     float r[2];
  1240. >     } res;
  1241. >     res.r[0] = ((float)yn((int)*n, (double)*x));
  1242. >     return( res.d );
  1243. > #else GFLOAT
  1244. 10a18
  1245. > #endif GFLOAT
  1246. SHAR_EOF
  1247. chmod +x 'besyn_.c.diff'
  1248. if test -f 'erf_.c.diff'
  1249. then
  1250.     echo shar: over-writing existing file "'erf_.c.diff'"
  1251. fi
  1252. cat << \SHAR_EOF > 'erf_.c.diff'
  1253. 9c9,15
  1254. < 
  1255. ---
  1256. > #ifdef GFLOAT
  1257. > union { double d;
  1258. >     float r[2];
  1259. >     } res;
  1260. > res.r[0] = erf(*x);
  1261. > return( res.d );
  1262. > #else GFLOAT
  1263. 10a17
  1264. > #endif GFLOAT
  1265. SHAR_EOF
  1266. chmod +x 'erf_.c.diff'
  1267. if test -f 'erfc_.c.diff'
  1268. then
  1269.     echo shar: over-writing existing file "'erfc_.c.diff'"
  1270. fi
  1271. cat << \SHAR_EOF > 'erfc_.c.diff'
  1272. 9c9,15
  1273. < 
  1274. ---
  1275. > #ifdef GFLOAT
  1276. > union { double d;
  1277. >     float r[2];
  1278. >     } res;
  1279. > res.r[0] = erfc(*x);
  1280. > return( res.d );
  1281. > #else GFLOAT
  1282. 10a17
  1283. > #endif GFLOAT
  1284. SHAR_EOF
  1285. chmod +x 'erfc_.c.diff'
  1286. if test -f 'rand_.c.diff'
  1287. then
  1288.     echo shar: over-writing existing file "'rand_.c.diff'"
  1289. fi
  1290. cat << \SHAR_EOF > 'rand_.c.diff'
  1291. 42a43,47
  1292. > #ifdef GFLOAT
  1293. > union { double d;
  1294. >     float r[2];
  1295. >     } res;
  1296. > #endif GFLOAT
  1297. 43a49
  1298. > #ifndef GFLOAT
  1299. 44a51,54
  1300. > #else GFLOAT
  1301. >     res.r[0] = ( (float)(rand())/(float)RANDMAX );
  1302. >     return( res.d );
  1303. > #endif GFLOAT
  1304. SHAR_EOF
  1305. chmod +x 'rand_.c.diff'
  1306. chdir ..
  1307. chdir ..
  1308. #    End of shell archive
  1309. exit 0
  1310.  
  1311.