Relay-Version: version B 2.10.3 4.3bsd-beta 6/6/85; site seismo.CSS.GOV Posting-Version: version B 2.10.2 9/3/84; site panda.UUCP Path: seismo!harvard!talcott!panda!sources-request From: sources-request@panda.UUCP Newsgroups: mod.sources Subject: G-format compilers for Ultrix/Unix Vaxes (1 of 4) Message-ID: <1079@panda.UUCP> Date: 8 Nov 85 19:17:00 GMT Sender: jpn@panda.UUCP Lines: 1304 Approved: jpn@panda.UUCP Mod.sources: Volume 3, Issue 37 Submitted by: J.D.Aplevich This and three following files contain patches for convert- ing the source for the Ultrix/BSD4.2 f77 compiler to run on and to produce code for G-format Vaxes. On a G (IEEE standard) format Vax, a "double" floating-point number is represented by 1 sign bit, 11 exponent bits, and 52 bit significand, whereas on D-format machines a double is represented by 1 sign bit, 7 exponent bits, and 56 bit sig- nificand. Thus the numerical consequences of G-format are increased dynamic range at the expense of 4 bits of preci- sion. In both formats a "float" is the same as the left 32 bits of the D-format double, and consequently on a G-format machine, any code will fail that explicitly requires a float to be the top half of a double, as it is on the older D-format machines. Examples are the Unix C and f77 compilers, and code produced by them. Some G-format machines are: certain versions of the MicroVax I, (which also emulates D-format instructions, with loss of precision), and the MicroVax II, which supports both representations, as do larger Vaxes with microcode options. DEC does not supply either f77 or Pascal G-format compilers for Ultrix. If one is equipped with a source license, it is possible to produce the patches required for converting the Ultrix (or BSD 4.2) compiler to G-format. It is also necessary to have G-format system libraries (libc, libm) as in G-format Ul- trix, (but these are NOT included here). Because f77 is a moving target, some of these patches are context diffs, rather than ordinary diffs. They convert f77 source files to versions containing #ifdef GFLOAT switches although it would also be simple to have G-format as a com- piler option, as in Ultrix C. The widely-used patch program from L. Wall is recommended to handle the details. It would have made sense to include its source here but that would have increased the size of the distribution by 50Kb. The shar archives are of the directory `gfloat', which contains patches to routines from f77/src/f1, f77/src/f2, f77/src/f77pass1, libF77, and libU77. A makefile is includ- ed to handle most of the details, as are fixes for a couple of libc.a and libm.a routines. CAVEAT COMPUTOR: The code that results from these patches is, of course, not guaranteed to be bug-free, but has been tested by use on ap- plications programs. It may be that we have not exercised code in which bugs exist. ACKNOWLEDGMENT: This material is a by-product of a project undertaken with the support of WATDEC, a University of Waterloo, Digital Equipment of Canada research contract. SPECIAL BONUS OFFER: pc (Pascal)! Once f77 works, it is very simple to get a usable pc working on a G-format machine. Some strings in /usr/lib/pc0 and /usr/lib/pc2 have to be changed using adb. In the version we have, in pc0 we change `double 0d' at location 18284 to `gfloat 0g' and in pc2, we change `cvtrdl' at location 100e to `cvtrgl', `cvtdl' at location 102a to `cvtgl', `cvtld' at location 197f to `cvtlg', `divd2' at location 198b to `divg2', `0d2.' at location 1993 to `0g2.' It might be necessary to locate these strings using `od -s 0x0' . -------------- cut here -------------------------------------------- #!/bin/sh # This is a shell archive, meaning: # 1. Remove everything above the #!/bin/sh line. # 2. Save the resulting text in a file. # 3. Execute the file with /bin/sh (not csh) to create the files: # gfloat # This archive created: Tue Oct 29 20:28:27 1985 export PATH; PATH=/bin:$PATH if test ! -d 'gfloat' then mkdir 'gfloat' fi cd 'gfloat' if test -f 'Makefile' then echo shar: over-writing existing file "'Makefile'" fi cat << \SHAR_EOF > 'Makefile' # Files changed in G-float code. f1FILES = local2.c otable.c table.c Makefile f2FILES = c22.c Makefile pass1FILES = bb.c\ conv.c\ conv.h\ defs.h\ expr.c\ intr.c\ optcse.c\ optloop.c\ put.c\ vax.c\ Makefile libF77FILES = \ opcodes.h\ besj0_.c\ besj1_.c\ besjn_.c\ besy0_.c\ besy1_.c\ besyn_.c\ c_abs.c\ erf_.c\ erfc_.c\ pow_ri.c\ r_abs.c\ r_acos.c\ r_asin.c\ r_atan.c\ r_atn2.c\ r_cos.c\ r_cosh.c\ r_dim.c\ r_exp.c\ r_imag.c\ r_int.c\ r_lg10.c\ r_log.c\ r_mod.c\ r_nint.c\ r_sign.c\ r_sin.c\ r_sinh.c\ r_sqrt.c\ r_tan.c\ r_tanh.c\ rand_.c\ range.c\ trapov_.c\ trpfpe_.c\ Makefile libU77FILES =\ dtime_.c\ Makefile LIB = FILES = DFLG = # Generate diffs between original source and G-float switched source. # Diffs are put into the local diff directories only. diffs: f1diffs f2diffs pass1diffs libFdiffs libUdiffs cdiffs: @make DFLG="-c" diffs netdiffs: @make DFLG="-c" f1diffs @make f2diffs @make DFLG="-c" pass1diffs @make libFdiffs @make libUdiffs f1diffs: @make FILES="$(f1FILES)" LIB=f77/src/f1 DFLG="$(DFLG)" mkdiffs f2diffs: @make FILES="$(f2FILES)" LIB=f77/src/f2 DFLG="$(DFLG)" mkdiffs pass1diffs: @make FILES="$(pass1FILES)" LIB=f77/src/f77pass1 DFLG="$(DFLG)" mkdiffs libFdiffs: @make FILES="$(libF77FILES)" LIB=libF77 DFLG="$(DFLG)" mkdiffs libUdiffs: @make FILES="$(libU77FILES)" LIB=libU77 DFLG="$(DFLG)" mkdiffs mkdiffs: @-for i in ${FILES} ; do echo $(LIB)/$$i.diff ; \ diff $(DFLG) ../$(LIB)/$$i.orig ../$(LIB)/$$i > $(LIB)/$$i.diff ; done # Remove local diff files. cleandiffs: rm -f f77/src/f1/*.diff rm -f f77/src/f2/*.diff rm -f f77/src/f77pass1/*.diff rm -f libF77/*.diff rm -f libU77/*.diff reallyclean: make orig (cd ../f77/src/f77; rm -f *.o mkvers Version Version.c) (cd ../f77/src/f1; rm -f *.o mkvers Version Version.c) (cd ../f77/src/f2; rm -f *.o mkvers Version Version.c) (cd ../f77/src/f77pass1; rm -f *.o mkvers Version Version.c \ tokdefs.h gram.in gram.c) (cd ../libF77; rm -f *.o mkvers Version Version.c *.a mkindx) (cd ../libF77/profiled; rm -f *.o mkvers Version Version.c) (cd ../libI77; rm -f *.o mkvers Version Version.c *.a mkindx) (cd ../libI77/profiled; rm -f *.o mkvers Version Version.c) (cd ../libU77; rm -f *.o mkvers Version Version.c *.a mkindx) (cd ../libU77/profiled; rm -f *.o mkvers Version Version.c) all: make mods (cd ../f77; make install) (cd ../libF77; make install) (cd ../libI77; make install) (cd ../libU77; make install) # Apply local diff files to local source, moving source to *.orig. mods: f1mods f2mods pass1mods libFmods libUmods f1mods: @make FILES="$(f1FILES)" LIB=f77/src/f1 makemod f2mods: @make FILES="$(f2FILES)" LIB=f77/src/f2 makemod pass1mods: @make FILES="$(pass1FILES)" LIB=f77/src/f77pass1 makemod libFmods: @make FILES="$(libF77FILES)" LIB=libF77 makemod libUmods: @make FILES="$(libU77FILES)" LIB=libU77 makemod makemod: @-for i in ${FILES} ; do if test ! -f ../$(LIB)/$$i.orig ; then \ echo $(LIB)/$$i ; patch ../$(LIB)/$$i $(LIB)/$$i.diff ; \ fi done # Move *.orig files back in place, restoring source to original condition. orig: f1orig f2orig pass1orig libForig libUorig f1orig: @make FILES="$(f1FILES)" LIB=f77/src/f1 makeorig f2orig: @make FILES="$(f2FILES)" LIB=f77/src/f2 makeorig pass1orig: @make FILES="$(pass1FILES)" LIB=f77/src/f77pass1 makeorig libForig: @make FILES="$(libF77FILES)" LIB=libF77 makeorig libUorig: @make FILES="$(libU77FILES)" LIB=libU77 makeorig makeorig: @-for i in $(FILES); do if test -f $(LIB)/$$i.diff ; then \ mv ../$(LIB)/$$i.orig ../$(LIB)/$$i; fi done SHAR_EOF chmod +x 'Makefile' if test -f 'READ_ME' then echo shar: over-writing existing file "'READ_ME'" fi cat << \SHAR_EOF > 'READ_ME' This directory contains a makefile for handling the differences between the f77 compiler source and the modified source with G-float switches in it. An original f77 source is kept, along with a directory tree in gfloat (this directory) containing diff(1) files for constructing a source containing `#ifdef GFLOAT' switches. 1. To make a source containing the G-float switches, put this (gfloat) directory into the new source directory at the same level as the libF77, LibU77, and f77 source directories (or links to them). That is, the command `lc' should give something like Directories: f77 gfloat libF77 libI77 libU77 Now in gfloat, type `make mods'. In each directory, original files will be copied into *.orig before being replaced by modified files of the original name, so you need write permission everywhere. To help avoid blunders, if a *.orig file already exists, the file modification is silently ignored. If the source is not identical to the source from which the diff files were made and context diffs were not used, patch may fail. In this case, the following may be tried: a) Apply `make mods' to the original source from which the diffs were obtained (if you have it, of course). b) Type `make cdiffs' to create context diff files (see 3. below), copy the resulting gfloat direc- tory as before into the directory of the new source, and try `make mods' again. This time patch is using context diffs, and should have more success. Correct patches are of course not guaranteed, but gross failures are detected. They have to be corrected by hand. 2. To restore the source directory to original form, type `make orig', which moves the *.orig files back into place. To help avoid losing modified files obtained at much sweat, the move is ignored if an appropriate .diff file does not exist. However the time of last modifi- cation is not checked. 3. To compile and install the G-float code, do step 1 above, then in f77, libF77, libI77, and libU77 type `make' or `make install' in the usual way, since the relevant Makefiles are modified to include the -DGFLOAT CFLAG. If you are really optimistic, type `make all' from here and come back in about 3 hours. 4. To compute the diff files, use make diffs Which con- structs the diff files from the *.c and *.c.orig files. Note that diff(1) correctly returns Error code 1 mes- sages. Directories containing changed files are: f77/src/f1 f77/src/f2 f77/src/f77pass1 libF77 libU77 If more files have to be modified, be sure to copy the original into *.orig first, and include the file name in the appropriate place in Makefile. Because the f77 source is a moving target, context diffs may be required, and this is where the patch pro- gram comes in handy. To make context diffs, use `make cdiffs'. 5. The Ultrix G-float C compiler contains a bug. For example, a call to the modified libF77/r_sin.c routine float r_sin(x) float *x; { double sin(); return( sin(*x) ); } returns a $#?!!*#@ double (NOT a float) in register 0. Refer to section 9.10 of "The C Programming Language - Reference Manual" by Dennis M. Ritchie. This is invisible when programming in C because the compiler has another bug that treats the returned value of a float function as a double. The bug becomes visible when we interface assembly language to C, or as here, hack a compiler to produce assembly language which calls functions written and compiled in C. An ugly union has had to be used to force a float return in a bunch of library functions, since accepting it as dou- ble would coerce the fortran expression containing the function reference to be double precision. SHAR_EOF chmod +x 'READ_ME' if test ! -d 'libF77' then mkdir 'libF77' fi cd 'libF77' if test -f 'c_abs.c.diff' then echo shar: over-writing existing file "'c_abs.c.diff'" fi cat << \SHAR_EOF > 'c_abs.c.diff' 11c11,17 < --- > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = cabs( z->real, z->imag ); > return( res.d ); > #else GFLOAT 12a19 > #endif GFLOAT SHAR_EOF chmod +x 'c_abs.c.diff' if test -f 'opcodes.h.diff' then echo shar: over-writing existing file "'opcodes.h.diff'" fi cat << \SHAR_EOF > 'opcodes.h.diff' 2c2 < * "@(#)opcodes.h 1.1" Vax op codes defined here --- > * "@(#)opcodes.h 1.2" Vax op codes defined here 7a8 > # define ACBG 0x4ffd 9a11 > # define ADDG2 0x40fd 10a13 > # define ADDG3 0x41fd 13a17 > # define CMPG 0x51fd 14a19 > # define CVTBG 0x4cfd 15a21 > # define CVTGB 0x48fd 16a23 > # define CVTGF 0x33fd 17a25 > # define CVTGL 0x4afd 18a27 > # define CVTGW 0x49fd 20a30 > # define CVTFG 0x56fd 23a34 > # define CVTRGL 0x4bfd 25a37 > # define DIVG2 0x46fd 26a39 > # define DIVG3 0x47fd 29a43 > # define EMODG 0x54fd 31a46 > # define MNEGG 0x52fd 33a49 > # define MOVG 0x50fd 35a52 > # define MULG2 0x44fd 36a54 > # define MULG3 0x45fd 39a58 > # define POLYG 0x55fd 41a61 > # define SUBG2 0x42fd 42a63 > # define SUBG3 0x43fd 45a67 > # define TSTG 0x53fd SHAR_EOF chmod +x 'opcodes.h.diff' if test -f 'r_abs.c.diff' then echo shar: over-writing existing file "'r_abs.c.diff'" fi cat << \SHAR_EOF > 'r_abs.c.diff' 7a8 > #ifndef GFLOAT 10a12,20 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = *x; > if(*x >= 0) > return( res.d ); > return( -res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_abs.c.diff' if test -f 'r_acos.c.diff' then echo shar: over-writing existing file "'r_acos.c.diff'" fi cat << \SHAR_EOF > 'r_acos.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = acos( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_acos.c.diff' if test -f 'r_asin.c.diff' then echo shar: over-writing existing file "'r_asin.c.diff'" fi cat << \SHAR_EOF > 'r_asin.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = asin( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_asin.c.diff' if test -f 'r_atan.c.diff' then echo shar: over-writing existing file "'r_atan.c.diff'" fi cat << \SHAR_EOF > 'r_atan.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = atan( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_atan.c.diff' if test -f 'r_atn2.c.diff' then echo shar: over-writing existing file "'r_atn2.c.diff'" fi cat << \SHAR_EOF > 'r_atn2.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = atan2(*x,*y); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_atn2.c.diff' if test -f 'r_cos.c.diff' then echo shar: over-writing existing file "'r_cos.c.diff'" fi cat << \SHAR_EOF > 'r_cos.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = cos( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_cos.c.diff' if test -f 'r_cosh.c.diff' then echo shar: over-writing existing file "'r_cosh.c.diff'" fi cat << \SHAR_EOF > 'r_cosh.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = cosh( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_cosh.c.diff' if test -f 'r_dim.c.diff' then echo shar: over-writing existing file "'r_dim.c.diff'" fi cat << \SHAR_EOF > 'r_dim.c.diff' 7a8 > #ifndef GFLOAT 8a10,16 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = *a - *b; > return( *a > *b ? res.d : 0); > #endif GFLOAT SHAR_EOF chmod +x 'r_dim.c.diff' if test -f 'r_exp.c.diff' then echo shar: over-writing existing file "'r_exp.c.diff'" fi cat << \SHAR_EOF > 'r_exp.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = exp( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_exp.c.diff' if test -f 'r_imag.c.diff' then echo shar: over-writing existing file "'r_imag.c.diff'" fi cat << \SHAR_EOF > 'r_imag.c.diff' 9a10 > #ifndef GFLOAT 10a12,18 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = z->imag; > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_imag.c.diff' if test -f 'r_int.c.diff' then echo shar: over-writing existing file "'r_int.c.diff'" fi cat << \SHAR_EOF > 'r_int.c.diff' 8a9 > #ifndef GFLOAT 10a12,18 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = (*x >= 0) ? floor(*x) : -floor(- *x); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_int.c.diff' if test -f 'r_lg10.c.diff' then echo shar: over-writing existing file "'r_lg10.c.diff'" fi cat << \SHAR_EOF > 'r_lg10.c.diff' 10a11 > #ifndef GFLOAT 12a14,20 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = log10e * log( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_lg10.c.diff' if test -f 'r_log.c.diff' then echo shar: over-writing existing file "'r_log.c.diff'" fi cat << \SHAR_EOF > 'r_log.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = log( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_log.c.diff' if test -f 'r_mod.c.diff' then echo shar: over-writing existing file "'r_mod.c.diff'" fi cat << \SHAR_EOF > 'r_mod.c.diff' 7a8,12 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > #endif GFLOAT 12a18 > #ifndef GFLOAT 13a20,23 > #else GFLOAT > res.r[0] = *x - (*y) * quotient; > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_mod.c.diff' if test -f 'r_nint.c.diff' then echo shar: over-writing existing file "'r_nint.c.diff'" fi cat << \SHAR_EOF > 'r_nint.c.diff' 8a9,13 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > #endif GFLOAT 9a15 > #ifndef GFLOAT 11a18,22 > #else GFLOAT > res.r[0] = (*x)>=0 ? > floor(*x + .5) : -floor(.5 - *x); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_nint.c.diff' if test -f 'r_sign.c.diff' then echo shar: over-writing existing file "'r_sign.c.diff'" fi cat << \SHAR_EOF > 'r_sign.c.diff' 8a9,13 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > #endif GFLOAT 9a15 > #ifndef GFLOAT 10a17,20 > #else GFLOAT > res.r[0] = *b >= 0 ? x : -x; > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_sign.c.diff' if test -f 'r_sin.c.diff' then echo shar: over-writing existing file "'r_sin.c.diff'" fi cat << \SHAR_EOF > 'r_sin.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = sin( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_sin.c.diff' if test -f 'r_sinh.c.diff' then echo shar: over-writing existing file "'r_sinh.c.diff'" fi cat << \SHAR_EOF > 'r_sinh.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = sinh( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_sinh.c.diff' if test -f 'r_sqrt.c.diff' then echo shar: over-writing existing file "'r_sqrt.c.diff'" fi cat << \SHAR_EOF > 'r_sqrt.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = sqrt( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_sqrt.c.diff' if test -f 'r_tan.c.diff' then echo shar: over-writing existing file "'r_tan.c.diff'" fi cat << \SHAR_EOF > 'r_tan.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = tan( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_tan.c.diff' if test -f 'r_tanh.c.diff' then echo shar: over-writing existing file "'r_tanh.c.diff'" fi cat << \SHAR_EOF > 'r_tanh.c.diff' 8a9 > #ifndef GFLOAT 9a11,17 > #else GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = tanh( *x ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'r_tanh.c.diff' if test -f 'range.c.diff' then echo shar: over-writing existing file "'range.c.diff'" fi cat << \SHAR_EOF > 'range.c.diff' 77a78,81 > #ifndef GFLOAT > #else GFLOAT > n.j[0] = 0x00000010; > #endif GFLOAT 117a122 > #ifndef GFLOAT 118a124,126 > #else GFLOAT > n.j[0] = 0x0000681e; > #endif GFLOAT SHAR_EOF chmod +x 'range.c.diff' if test -f 'trapov_.c.diff' then echo shar: over-writing existing file "'trapov_.c.diff'" fi cat << \SHAR_EOF > 'trapov_.c.diff' 55a56,58 > #ifdef GFLOAT > # define G 4 > #endif GFLOAT 241a245,249 > #ifdef GFLOAT > /* kludge for Gfloat */ > if (operand_type(opcode, o_no)==F && (fetch_byte() & 0xff)==0xfd) > opcode = opcode<<8 + 0xfd; > #endif GFLOAT 250a259 > #ifndef GFLOAT 251a261,263 > #else GFLOAT > if (opcode == POLYG || opcode == POLYF) { > #endif GFLOAT 255a268 > #ifndef GFLOAT 256a270,272 > #else GFLOAT > if (opcode == EMODG || opcode == EMODF) { > #endif GFLOAT 266a283 > #ifndef GFLOAT 267a285,287 > #else GFLOAT > if (type != F && type != G) { > #endif GFLOAT 272c292 < /* F or D operand. Check it out */ --- > /* F or D (or G) operand. Check it out */ 282a303 > #ifndef GFLOAT 283a305,307 > #else GFLOAT > } else if (type == G && opnd->o_long == 0x00008000) { > #endif GFLOAT 307a332 > #ifndef GFLOAT 317a343,354 > #else GFLOAT > case ACBG: case ACBF: case ADDG2: case ADDG3: > case ADDF2: case ADDF3: case CMPG: case CMPF: > case CVTGB: case CVTGF: case CVTGL: case CVTGW: > case CVTFB: case CVTFG: case CVTFL: case CVTFW: > case CVTRGL: case CVTRFL: case DIVG2: case DIVG3: > case DIVF2: case DIVF3: case EMODG: case EMODF: > case MNEGG: case MNEGF: case MOVG: case MOVF: > case MULG2: case MULG3: case MULF2: case MULF3: > case POLYG: case POLYF: case SUBG2: case SUBG3: > case SUBF2: case SUBF3: case TSTG: case TSTF: > #endif GFLOAT 325c362 < * got_illegal_poly - handle an illegal POLY[DF] instruction. --- > * got_illegal_poly - handle an illegal POLY[DFG] instruction. 360a398 > #ifndef GFLOAT 361a400,402 > #else GFLOAT > case ACBG: > #endif GFLOAT 364a406 > #ifndef GFLOAT 366d407 < case MNEGF: 368d408 < case MOVF: 369a410,416 > #else GFLOAT > case MNEGG: > case MOVG: > case TSTG: > #endif GFLOAT > case MNEGF: > case MOVF: 381c428 < * operand_type - is the operand a D or an F? --- > * operand_type - is the operand a D, F or G? 391a439,441 > #ifdef GFLOAT > if (opcode >= 0x40fd && opcode <= 0x56fd) return G; > #endif GFLOAT 636a687 > #ifndef GFLOAT 638d688 < case ACBF: return "ACBF"; 641,642d690 < case ADDF2: return "ADDF2"; < case ADDF3: return "ADDF3"; 644d691 < case CMPF: return "CMPF"; 646a694 > case CVTFD: return "CVTFD"; 648a697,735 > case CVTRDL: return "CVTRDL"; > case DIVD2: return "DIVD2"; > case DIVD3: return "DIVD3"; > case EMODD: return "EMODD"; > case MNEGD: return "MNEGD"; > case MOVD: return "MOVD"; > case MULD2: return "MULD2"; > case MULD3: return "MULD3"; > case POLYD: return "POLYD"; > case SUBD2: return "SUBD2"; > case SUBD3: return "SUBD3"; > case TSTD: return "TSTD"; > #else GFLOAT > case ACBG: return "ACBG"; > case ADDG2: return "ADDG2"; > case ADDG3: return "ADDG3"; > case CMPG: return "CMPG"; > case CVTGB: return "CVTGB"; > case CVTGF: return "CVTGF"; > case CVTFG: return "CVTFG"; > case CVTGL: return "CVTGL"; > case CVTGW: return "CVTGW"; > case CVTRGL: return "CVTRGL"; > case DIVG2: return "DIVG2"; > case DIVG3: return "DIVG3"; > case EMODG: return "EMODG"; > case MNEGG: return "MNEGG"; > case MOVG: return "MOVG"; > case MULG2: return "MULG2"; > case MULG3: return "MULG3"; > case POLYG: return "POLYG"; > case SUBG2: return "SUBG2"; > case SUBG3: return "SUBG3"; > case TSTG: return "TSTG"; > #endif GFLOAT > case ACBF: return "ACBF"; > case ADDF2: return "ADDF2"; > case ADDF3: return "ADDF3"; > case CMPF: return "CMPF"; 650d736 < case CVTFD: return "CVTFD"; 653d738 < case CVTRDL: return "CVTRDL"; 655,656d739 < case DIVD2: return "DIVD2"; < case DIVD3: return "DIVD3"; 659d741 < case EMODD: return "EMODD"; 661d742 < case MNEGD: return "MNEGD"; 663d743 < case MOVD: return "MOVD"; 665,666d744 < case MULD2: return "MULD2"; < case MULD3: return "MULD3"; 669d746 < case POLYD: return "POLYD"; 671,672d747 < case SUBD2: return "SUBD2"; < case SUBD3: return "SUBD3"; 675d749 < case TSTD: return "TSTD"; SHAR_EOF chmod +x 'trapov_.c.diff' if test -f 'trpfpe_.c.diff' then echo shar: over-writing existing file "'trpfpe_.c.diff'" fi cat << \SHAR_EOF > 'trpfpe_.c.diff' 403c403,404 < --- > /* This isn't going to work for G-format instructions because > * they are 2 characters long */ 405a407 > #ifndef GFLOAT 409a412,417 > #else GFLOAT > case ADDG3: > case DIVG3: > case MULG3: > case SUBG3: > #endif GFLOAT 412a421 > #ifndef GFLOAT 418a428,435 > #else GFLOAT > case ADDG2: > case DIVG2: > case MULG2: > case SUBG2: > case MNEGG: > case MOVG: > #endif GFLOAT 441a459 > #ifndef GFLOAT 442a461,463 > #else GFLOAT > case CVTGF: > #endif GFLOAT 447a469 > #ifndef GFLOAT 448a471,473 > #else GFLOAT > case CVTFG: > #endif GFLOAT 454a480 > #ifndef GFLOAT 455a482,484 > #else GFLOAT > case EMODG: > #endif GFLOAT 459a489 > #ifndef GFLOAT 460a491,493 > #else GFLOAT > case POLYG: > #endif GFLOAT 463a497 > #ifndef GFLOAT 464a499,501 > #else GFLOAT > case ACBG: > #endif GFLOAT 465a503 > #ifndef GFLOAT 466a505,507 > #else GFLOAT > case CMPG: > #endif GFLOAT 467a509 > #ifndef GFLOAT 468a511,513 > #else GFLOAT > case TSTG: > #endif GFLOAT 469a515 > #ifndef GFLOAT 472a519,523 > #else GFLOAT > case CVTGB: > case CVTGL: > case CVTGW: > #endif GFLOAT 475a527 > #ifndef GFLOAT 476a529,531 > #else GFLOAT > case CVTRGL: > #endif GFLOAT SHAR_EOF chmod +x 'trpfpe_.c.diff' if test -f 'Makefile.diff' then echo shar: over-writing existing file "'Makefile.diff'" fi cat << \SHAR_EOF > 'Makefile.diff' 7c7 < CFLAGS = -O --- > CFLAGS = -O -DGFLOAT 161c161 < OPTIONS = -DUCBVAX --- > OPTIONS = -DUCBVAX -DGFLOAT SHAR_EOF chmod +x 'Makefile.diff' if test -f 'pow_ri.c.diff' then echo shar: over-writing existing file "'pow_ri.c.diff'" fi cat << \SHAR_EOF > 'pow_ri.c.diff' 10a11,15 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > #endif GFLOAT 21a27 > #ifndef GFLOAT 22a29,32 > #else GFLOAT > res.r[0] = pow; > return(res.d); > #endif GFLOAT 36a47 > #ifndef GFLOAT 37a49,52 > #else GFLOAT > res.r[0] = pow; > return(res.d); > #endif GFLOAT SHAR_EOF chmod +x 'pow_ri.c.diff' if test -f 'besj0_.c.diff' then echo shar: over-writing existing file "'besj0_.c.diff'" fi cat << \SHAR_EOF > 'besj0_.c.diff' 9a10,16 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = ((float)j0((double)*x)); > return( res.d ); > #else GFLOAT 10a18 > #endif GFLOAT SHAR_EOF chmod +x 'besj0_.c.diff' if test -f 'besj1_.c.diff' then echo shar: over-writing existing file "'besj1_.c.diff'" fi cat << \SHAR_EOF > 'besj1_.c.diff' 9a10,16 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = ((float)j1((double)*x)); > return( res.d ); > #else GFLOAT 10a18 > #endif GFLOAT SHAR_EOF chmod +x 'besj1_.c.diff' if test -f 'besjn_.c.diff' then echo shar: over-writing existing file "'besjn_.c.diff'" fi cat << \SHAR_EOF > 'besjn_.c.diff' 9a10,16 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = ((float)jn((int)*n, (double)*x)); > return( res.d ); > #else GFLOAT 10a18 > #endif GFLOAT SHAR_EOF chmod +x 'besjn_.c.diff' if test -f 'besy0_.c.diff' then echo shar: over-writing existing file "'besy0_.c.diff'" fi cat << \SHAR_EOF > 'besy0_.c.diff' 9a10,16 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = ((float)y0((double)*x)); > return( res.d ); > #else GFLOAT 10a18 > #endif GFLOAT SHAR_EOF chmod +x 'besy0_.c.diff' if test -f 'besy1_.c.diff' then echo shar: over-writing existing file "'besy1_.c.diff'" fi cat << \SHAR_EOF > 'besy1_.c.diff' 9a10,16 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = ((float)y1((double)*x)); > return( res.d ); > #else GFLOAT 10a18 > #endif GFLOAT SHAR_EOF chmod +x 'besy1_.c.diff' if test -f 'besyn_.c.diff' then echo shar: over-writing existing file "'besyn_.c.diff'" fi cat << \SHAR_EOF > 'besyn_.c.diff' 9a10,16 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = ((float)yn((int)*n, (double)*x)); > return( res.d ); > #else GFLOAT 10a18 > #endif GFLOAT SHAR_EOF chmod +x 'besyn_.c.diff' if test -f 'erf_.c.diff' then echo shar: over-writing existing file "'erf_.c.diff'" fi cat << \SHAR_EOF > 'erf_.c.diff' 9c9,15 < --- > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = erf(*x); > return( res.d ); > #else GFLOAT 10a17 > #endif GFLOAT SHAR_EOF chmod +x 'erf_.c.diff' if test -f 'erfc_.c.diff' then echo shar: over-writing existing file "'erfc_.c.diff'" fi cat << \SHAR_EOF > 'erfc_.c.diff' 9c9,15 < --- > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > res.r[0] = erfc(*x); > return( res.d ); > #else GFLOAT 10a17 > #endif GFLOAT SHAR_EOF chmod +x 'erfc_.c.diff' if test -f 'rand_.c.diff' then echo shar: over-writing existing file "'rand_.c.diff'" fi cat << \SHAR_EOF > 'rand_.c.diff' 42a43,47 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > #endif GFLOAT 43a49 > #ifndef GFLOAT 44a51,54 > #else GFLOAT > res.r[0] = ( (float)(rand())/(float)RANDMAX ); > return( res.d ); > #endif GFLOAT SHAR_EOF chmod +x 'rand_.c.diff' chdir .. chdir .. # End of shell archive exit 0