sources-request@panda.UUCP (11/08/85)
Mod.sources: Volume 3, Issue 37 Submitted by: J.D.Aplevich <watmath!watdcsu!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 <file> 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
sources-request@panda.UUCP (11/11/85)
Mod.sources: Volume 3, Issue 38 Submitted by: J.D.Aplevich <decvax!watmath!watdcsu!aplevich> #!/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:29:25 1985 export PATH; PATH=/bin:$PATH if test ! -d 'gfloat' then mkdir 'gfloat' fi cd 'gfloat' if test ! -d 'f77' then mkdir 'f77' fi cd 'f77' if test ! -d 'src' then mkdir 'src' fi cd 'src' if test ! -d 'f1' then mkdir 'f1' fi cd 'f1' if test -f 'local2.c.diff' then echo shar: over-writing existing file "'local2.c.diff'" fi cat << \SHAR_EOF > 'local2.c.diff' *** ../f77/src/f1/local2.c.orig Tue Oct 29 15:16:24 1985 --- ../f77/src/f1/local2.c Tue Oct 29 15:21:37 1985 *************** *** 77,82 printf( "%s", q->opstring ); /* tbl if( f == 'F' ) printf( "e" ); else if( f == 'D' ) printf( "d" ); tbl */ /* tbl */ --- 77,83 ----- printf( "%s", q->opstring ); /* tbl if( f == 'F' ) printf( "e" ); + #ifndef GFLOAT else if( f == 'D' ) printf( "d" ); #else GFLOAT else if( f == 'D' ) printf( "g" ); *************** *** 78,83 /* tbl if( f == 'F' ) printf( "e" ); else if( f == 'D' ) printf( "d" ); tbl */ /* tbl */ switch( f ) { --- 79,87 ----- if( f == 'F' ) printf( "e" ); #ifndef GFLOAT else if( f == 'D' ) printf( "d" ); + #else GFLOAT + else if( f == 'D' ) printf( "g" ); + #endif GFLOAT tbl */ /* tbl */ switch( f ) { *************** *** 84,89 case 'L': case 'W': case 'B': case 'D': case 'F': printf("%c", tolower(f)); --- 88,97 ----- case 'L': case 'W': case 'B': + #ifdef GFLOAT + printf("%c", tolower(f)); + break; + #endif GFLOAT case 'D': #ifdef GFLOAT printf("g"); *************** *** 85,90 case 'W': case 'B': case 'D': case 'F': printf("%c", tolower(f)); break; --- 93,102 ----- break; #endif GFLOAT case 'D': + #ifdef GFLOAT + printf("g"); + break; + #endif GFLOAT case 'F': printf("%c", tolower(f)); break; *************** *** 143,148 tp = p->in.type; tq = q->in.type; return( (tp==FLOAT || tp==DOUBLE) != (tq==FLOAT || tq==DOUBLE) ); } --- 155,161 ----- tp = p->in.type; tq = q->in.type; + #ifndef GFLOAT return( (tp==FLOAT || tp==DOUBLE) != (tq==FLOAT || tq==DOUBLE) ); #else GFLOAT *************** *** 145,150 return( (tp==FLOAT || tp==DOUBLE) != (tq==FLOAT || tq==DOUBLE) ); } prtype(n) NODE *n; --- 158,167 ----- #ifndef GFLOAT return( (tp==FLOAT || tp==DOUBLE) != (tq==FLOAT || tq==DOUBLE) ); + #else GFLOAT + return( ((tp==FLOAT || tp==DOUBLE) != (tq==FLOAT || tq==DOUBLE)) || + (tp==FLOAT && tq==DOUBLE) || (tp==DOUBLE && tq==FLOAT) ); + #endif GFLOAT } prtype(n) NODE *n; *************** *** 152,157 switch (n->in.type) { case DOUBLE: printf("d"); return; --- 169,175 ----- switch (n->in.type) { case DOUBLE: + #ifndef GFLOAT printf("d"); #else GFLOAT printf("g"); *************** *** 153,158 { case DOUBLE: printf("d"); return; case FLOAT: --- 171,179 ----- case DOUBLE: #ifndef GFLOAT printf("d"); + #else GFLOAT + printf("g"); + #endif GFLOAT return; case FLOAT: *************** *** 386,391 if (xdebug) printf("->%d<-", ty); if ( ty==DOUBLE) printf("d"); else if ( ty==FLOAT ) printf("f"); else printf("l"); --- 407,413 ----- if (xdebug) printf("->%d<-", ty); + #ifndef GFLOAT if ( ty==DOUBLE) printf("d"); #else GFLOAT if ( ty==DOUBLE) printf("g"); *************** *** 387,392 if (xdebug) printf("->%d<-", ty); if ( ty==DOUBLE) printf("d"); else if ( ty==FLOAT ) printf("f"); else printf("l"); return; --- 409,417 ----- #ifndef GFLOAT if ( ty==DOUBLE) printf("d"); + #else GFLOAT + if ( ty==DOUBLE) printf("g"); + #endif GFLOAT else if ( ty==FLOAT ) printf("f"); else printf("l"); return; *************** *** 483,488 rmove( rt, rs, t ){ printf( " %s %s,%s\n", (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")), rnames[rs], rnames[rt] ); } --- 508,514 ----- rmove( rt, rs, t ){ printf( " %s %s,%s\n", + #ifndef GFLOAT (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")), #else GFLOAT (t==FLOAT ? "movf" : (t==DOUBLE ? "movg" : "movl")), *************** *** 484,489 rmove( rt, rs, t ){ printf( " %s %s,%s\n", (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")), rnames[rs], rnames[rt] ); } --- 510,518 ----- printf( " %s %s,%s\n", #ifndef GFLOAT (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")), + #else GFLOAT + (t==FLOAT ? "movf" : (t==DOUBLE ? "movg" : "movl")), + #endif GFLOAT rnames[rs], rnames[rt] ); } SHAR_EOF chmod +x 'local2.c.diff' if test -f 'otable.c.diff' then echo shar: over-writing existing file "'otable.c.diff'" fi cat << \SHAR_EOF > 'otable.c.diff' *** ../f77/src/f1/otable.c.orig Tue Oct 29 15:16:27 1985 --- ../f77/src/f1/otable.c Tue Oct 29 15:21:44 1985 *************** *** 45,50 SAREG|AWD, TDOUBLE, SANY, TFLOAT, NAREG|NASL, RESC1|RESCC, " cvtdf AL,A1\n", SCONV, INTAREG|FORCC, --- 45,51 ----- SAREG|AWD, TDOUBLE, SANY, TFLOAT, NAREG|NASL, RESC1|RESCC, + #ifndef GFLOAT " cvtdf AL,A1\n", #else GFLOAT " cvtgf AL,A1\n", *************** *** 46,51 SANY, TFLOAT, NAREG|NASL, RESC1|RESCC, " cvtdf AL,A1\n", SCONV, INTAREG|FORCC, SAREG|AWD, ANYSIGNED|TUNSIGNED|TULONG|TFLOAT, --- 47,55 ----- NAREG|NASL, RESC1|RESCC, #ifndef GFLOAT " cvtdf AL,A1\n", + #else GFLOAT + " cvtgf AL,A1\n", + #endif GFLOAT SCONV, INTAREG|FORCC, SAREG|AWD, ANYSIGNED|TUNSIGNED|TULONG|TFLOAT, *************** *** 70,75 SAREG|AWD, TUCHAR|TUSHORT, SANY, TFLOAT|TDOUBLE, NAREG|NASL, RESC1|RESCC, " movzZLl AL,A1\n cvtld A1,A1\n", SCONV, INTAREG|FORCC, --- 74,80 ----- SAREG|AWD, TUCHAR|TUSHORT, SANY, TFLOAT|TDOUBLE, NAREG|NASL, RESC1|RESCC, + #ifndef GFLOAT " movzZLl AL,A1\n cvtld A1,A1\n", #else GFLOAT " movzZLl AL,A1\n cvtlg A1,A1\n", *************** *** 71,76 SANY, TFLOAT|TDOUBLE, NAREG|NASL, RESC1|RESCC, " movzZLl AL,A1\n cvtld A1,A1\n", SCONV, INTAREG|FORCC, SAREG|AWD, TFLOAT|TDOUBLE, --- 76,84 ----- NAREG|NASL, RESC1|RESCC, #ifndef GFLOAT " movzZLl AL,A1\n cvtld A1,A1\n", + #else GFLOAT + " movzZLl AL,A1\n cvtlg A1,A1\n", + #endif GFLOAT SCONV, INTAREG|FORCC, SAREG|AWD, TFLOAT|TDOUBLE, *************** *** 229,234 SAREG|AWD, TDOUBLE, SAREG|AWD, TDOUBLE, 0, RESCC, " cmpd AL,AR\nZP", OPLOG, FORCC, --- 237,243 ----- SAREG|AWD, TDOUBLE, SAREG|AWD, TDOUBLE, 0, RESCC, + #ifndef GFLOAT " cmpd AL,AR\nZP", #else GFLOAT " cmpg AL,AR\nZP", *************** *** 230,235 SAREG|AWD, TDOUBLE, 0, RESCC, " cmpd AL,AR\nZP", OPLOG, FORCC, SAREG|AWD, TDOUBLE, --- 239,247 ----- 0, RESCC, #ifndef GFLOAT " cmpd AL,AR\nZP", + #else GFLOAT + " cmpg AL,AR\nZP", + #endif GFLOAT OPLOG, FORCC, SAREG|AWD, TDOUBLE, *************** *** 235,240 SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG|NASR, RESCC, " cvtfd AR,A1\n cmpd AL,A1\nZP", OPLOG, FORCC, --- 247,253 ----- SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG|NASR, RESCC, + #ifndef GFLOAT " cvtfd AR,A1\n cmpd AL,A1\nZP", #else GFLOAT " cvtfg AR,A1\n cmpg AL,A1\nZP", *************** *** 236,241 SAREG|AWD, TFLOAT, NAREG|NASR, RESCC, " cvtfd AR,A1\n cmpd AL,A1\nZP", OPLOG, FORCC, SAREG|AWD, TFLOAT, --- 249,257 ----- NAREG|NASR, RESCC, #ifndef GFLOAT " cvtfd AR,A1\n cmpd AL,A1\nZP", + #else GFLOAT + " cvtfg AR,A1\n cmpg AL,A1\nZP", + #endif GFLOAT OPLOG, FORCC, SAREG|AWD, TFLOAT, *************** *** 241,246 SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG|NASL, RESCC, " cvtfd AL,A1\n cmpd A1,AR\nZP", OPLOG, FORCC, --- 257,263 ----- SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG|NASL, RESCC, + #ifndef GFLOAT " cvtfd AL,A1\n cmpd A1,AR\nZP", #else GFLOAT " cvtfg AL,A1\n cmpg A1,AR\nZP", *************** *** 242,247 SAREG|AWD, TDOUBLE, NAREG|NASL, RESCC, " cvtfd AL,A1\n cmpd A1,AR\nZP", OPLOG, FORCC, SAREG|AWD, TFLOAT, --- 259,267 ----- NAREG|NASL, RESCC, #ifndef GFLOAT " cvtfd AL,A1\n cmpd A1,AR\nZP", + #else GFLOAT + " cvtfg AL,A1\n cmpg A1,AR\nZP", + #endif GFLOAT OPLOG, FORCC, SAREG|AWD, TFLOAT, *************** *** 260,265 SCON, TANY, SANY, TFLOAT, NAREG|NASL, RESC1, " calls ZC,CL\n cvtdf r0,r0\n", UNARY CALL, INTAREG, --- 280,286 ----- SCON, TANY, SANY, TFLOAT, NAREG|NASL, RESC1, + #ifndef GFLOAT " calls ZC,CL\n cvtdf r0,r0\n", #else GFLOAT " calls ZC,CL\n cvtgf r0,r0\n", *************** *** 261,266 SANY, TFLOAT, NAREG|NASL, RESC1, " calls ZC,CL\n cvtdf r0,r0\n", UNARY CALL, INTAREG, SCON, TANY, --- 282,290 ----- NAREG|NASL, RESC1, #ifndef GFLOAT " calls ZC,CL\n cvtdf r0,r0\n", + #else GFLOAT + " calls ZC,CL\n cvtgf r0,r0\n", + #endif GFLOAT UNARY CALL, INTAREG, SCON, TANY, *************** *** 440,445 SANY, TANY, SAREG, TDOUBLE, 2*NTEMP, RESC1, " movd AR,A1\n", REG, INTEMP, --- 464,470 ----- SANY, TANY, SAREG, TDOUBLE, 2*NTEMP, RESC1, + #ifndef GFLOAT " movd AR,A1\n", #else GFLOAT " movg AR,A1\n", *************** *** 441,446 SAREG, TDOUBLE, 2*NTEMP, RESC1, " movd AR,A1\n", REG, INTEMP, SANY, TANY, --- 466,474 ----- 2*NTEMP, RESC1, #ifndef GFLOAT " movd AR,A1\n", + #else GFLOAT + " movg AR,A1\n", + #endif GFLOAT REG, INTEMP, SANY, TANY, *************** *** 453,458 SANY, TANY, SAREG, TFLOAT, 0, RNULL, " cvtfd AR,-(sp)\n", REG, FORARG, --- 481,487 ----- SANY, TANY, SAREG, TFLOAT, 0, RNULL, + #ifndef GFLOAT " cvtfd AR,-(sp)\n", #else GFLOAT " cvtfg AR,-(sp)\n", *************** *** 454,459 SAREG, TFLOAT, 0, RNULL, " cvtfd AR,-(sp)\n", REG, FORARG, SANY, TANY, --- 483,491 ----- 0, RNULL, #ifndef GFLOAT " cvtfd AR,-(sp)\n", + #else GFLOAT + " cvtfg AR,-(sp)\n", + #endif GFLOAT REG, FORARG, SANY, TANY, *************** *** 508,513 SANY, TANY, SANY, TDOUBLE, 0, RNULL, " movd AR,-(sp)\n", OPLTYPE, FORARG, --- 540,546 ----- SANY, TANY, SANY, TDOUBLE, 0, RNULL, + #ifndef GFLOAT " movd AR,-(sp)\n", #else GFLOAT " movg AR,-(sp)\n", *************** *** 509,514 SANY, TDOUBLE, 0, RNULL, " movd AR,-(sp)\n", OPLTYPE, FORARG, SANY, TANY, --- 542,550 ----- 0, RNULL, #ifndef GFLOAT " movd AR,-(sp)\n", + #else GFLOAT + " movg AR,-(sp)\n", + #endif GFLOAT OPLTYPE, FORARG, SANY, TANY, *************** *** 514,519 SANY, TANY, SANY, TFLOAT, 0, RNULL, " cvtfd AR,-(sp)\n", #ifdef FORT --- 550,556 ----- SANY, TANY, SANY, TFLOAT, 0, RNULL, + #ifndef GFLOAT " cvtfd AR,-(sp)\n", #else GFLOAT " cvtfg AR,-(sp)\n", *************** *** 515,520 SANY, TFLOAT, 0, RNULL, " cvtfd AR,-(sp)\n", #ifdef FORT UNARY MINUS, INTAREG|FORCC, --- 552,560 ----- 0, RNULL, #ifndef GFLOAT " cvtfd AR,-(sp)\n", + #else GFLOAT + " cvtfg AR,-(sp)\n", + #endif GFLOAT #ifdef FORT UNARY MINUS, INTAREG|FORCC, *************** *** 770,775 SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG, RLEFT|RESCC, " cvtfd AR,A1\n OD2 A1,AL\n", ASG OPFLOAT, INAREG|INTAREG|FOREFF|FORCC, --- 810,816 ----- SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG, RLEFT|RESCC, + #ifndef GFLOAT " cvtfd AR,A1\n OD2 A1,AL\n", #else GFLOAT " cvtfg AR,A1\n OD2 A1,AL\n", *************** *** 771,776 SAREG|AWD, TFLOAT, NAREG, RLEFT|RESCC, " cvtfd AR,A1\n OD2 A1,AL\n", ASG OPFLOAT, INAREG|INTAREG|FOREFF|FORCC, SAREG|AWD, TFLOAT, --- 812,820 ----- NAREG, RLEFT|RESCC, #ifndef GFLOAT " cvtfd AR,A1\n OD2 A1,AL\n", + #else GFLOAT + " cvtfg AR,A1\n OD2 A1,AL\n", + #endif GFLOAT ASG OPFLOAT, INAREG|INTAREG|FOREFF|FORCC, SAREG|AWD, TFLOAT, *************** *** 776,781 SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG, RLEFT|RESC1|RESCC, " cvtfd AL,A1\n OD2 AR,A1\n cvtdf A1,AL\n", OPFLOAT, INAREG|INTAREG|FORCC, --- 820,826 ----- SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG, RLEFT|RESC1|RESCC, + #ifndef GFLOAT " cvtfd AL,A1\n OD2 AR,A1\n cvtdf A1,AL\n", #else GFLOAT " cvtfg AL,A1\n OD2 AR,A1\n cvtgf A1,AL\n", *************** *** 777,782 SAREG|AWD, TDOUBLE, NAREG, RLEFT|RESC1|RESCC, " cvtfd AL,A1\n OD2 AR,A1\n cvtdf A1,AL\n", OPFLOAT, INAREG|INTAREG|FORCC, STAREG, TDOUBLE, --- 822,830 ----- NAREG, RLEFT|RESC1|RESCC, #ifndef GFLOAT " cvtfd AL,A1\n OD2 AR,A1\n cvtdf A1,AL\n", + #else GFLOAT + " cvtfg AL,A1\n OD2 AR,A1\n cvtgf A1,AL\n", + #endif GFLOAT OPFLOAT, INAREG|INTAREG|FORCC, STAREG, TDOUBLE, *************** *** 794,799 SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG|NASL, RESC1|RESCC, " cvtfd AL,A1\n OD2 AR,A1\n", OPFLOAT, INAREG|INTAREG|FORCC, --- 842,848 ----- SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG|NASL, RESC1|RESCC, + #ifndef GFLOAT " cvtfd AL,A1\n OD2 AR,A1\n", #else GFLOAT " cvtfg AL,A1\n OD2 AR,A1\n", *************** *** 795,800 SAREG|AWD, TDOUBLE, NAREG|NASL, RESC1|RESCC, " cvtfd AL,A1\n OD2 AR,A1\n", OPFLOAT, INAREG|INTAREG|FORCC, SAREG|AWD, TDOUBLE, --- 844,852 ----- NAREG|NASL, RESC1|RESCC, #ifndef GFLOAT " cvtfd AL,A1\n OD2 AR,A1\n", + #else GFLOAT + " cvtfg AL,A1\n OD2 AR,A1\n", + #endif GFLOAT OPFLOAT, INAREG|INTAREG|FORCC, SAREG|AWD, TDOUBLE, *************** *** 800,805 SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG|NASR, RESC1|RESCC, " cvtfd AR,A1\n OD3 A1,AL,A1\n", #ifdef FORT --- 852,858 ----- SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG|NASR, RESC1|RESCC, + #ifndef GFLOAT " cvtfd AR,A1\n OD3 A1,AL,A1\n", #else GFLOAT " cvtfg AR,A1\n OD3 A1,AL,A1\n", *************** *** 801,806 SAREG|AWD, TFLOAT, NAREG|NASR, RESC1|RESCC, " cvtfd AR,A1\n OD3 A1,AL,A1\n", #ifdef FORT OPFLOAT, INAREG|INTAREG|FORCC, --- 854,862 ----- NAREG|NASR, RESC1|RESCC, #ifndef GFLOAT " cvtfd AR,A1\n OD3 A1,AL,A1\n", + #else GFLOAT + " cvtfg AR,A1\n OD3 A1,AL,A1\n", + #endif GFLOAT #ifdef FORT OPFLOAT, INAREG|INTAREG|FORCC, *************** *** 820,825 SAREG|AWD, TFLOAT, SAREG|AWD, TFLOAT, NAREG|NASL|NASR, RESC1|RESCC, " OF3 AR,AL,A1\n cvtfd A1,A1\n", #endif --- 876,882 ----- SAREG|AWD, TFLOAT, SAREG|AWD, TFLOAT, NAREG|NASL|NASR, RESC1|RESCC, + #ifndef GFLOAT " OF3 AR,AL,A1\n cvtfd A1,A1\n", #else GFLOAT " OF3 AR,AL,A1\n cvtfg A1,A1\n", *************** *** 821,826 SAREG|AWD, TFLOAT, NAREG|NASL|NASR, RESC1|RESCC, " OF3 AR,AL,A1\n cvtfd A1,A1\n", #endif /* Default actions for hard trees ... */ --- 878,886 ----- NAREG|NASL|NASR, RESC1|RESCC, #ifndef GFLOAT " OF3 AR,AL,A1\n cvtfd A1,A1\n", + #else GFLOAT + " OF3 AR,AL,A1\n cvtfg A1,A1\n", + #endif GFLOAT #endif /* Default actions for hard trees ... */ SHAR_EOF chmod +x 'otable.c.diff' if test -f 'Makefile.diff' then echo shar: over-writing existing file "'Makefile.diff'" fi cat << \SHAR_EOF > 'Makefile.diff' *** ../f77/src/f1/Makefile.orig Tue Oct 29 15:16:21 1985 --- ../f77/src/f1/Makefile Tue Oct 29 15:21:54 1985 *************** *** 2,8 # CFLAGS = -O -DASSTRINGS -DSTABDOT -DLCOMM -DBUFSTDERR -DFLEXNAMES \ ! -I$M -I. DEST = $(DESTROOT)/lib --- 2,8 ----- # CFLAGS = -O -DASSTRINGS -DSTABDOT -DLCOMM -DBUFSTDERR -DFLEXNAMES \ ! -DGFLOAT -I$M -I. DEST = $(DESTROOT)/lib SHAR_EOF chmod +x 'Makefile.diff' if test -f 'table.c.diff' then echo shar: over-writing existing file "'table.c.diff'" fi cat << \SHAR_EOF > 'table.c.diff' *** ../f77/src/f1/table.c.orig Tue Oct 29 15:16:28 1985 --- ../f77/src/f1/table.c Tue Oct 29 15:21:50 1985 *************** *** 89,94 SAREG|AWD, TDOUBLE, SANY, TFLOAT, NAREG|NASL, RESC1|RESCC, " cvtdf AL,A1\n", SCONV, INTAREG|FORCC, --- 89,95 ----- SAREG|AWD, TDOUBLE, SANY, TFLOAT, NAREG|NASL, RESC1|RESCC, + #ifndef GFLOAT " cvtdf AL,A1\n", #else GFLOAT " cvtgf AL,A1\n", *************** *** 90,95 SANY, TFLOAT, NAREG|NASL, RESC1|RESCC, " cvtdf AL,A1\n", SCONV, INTAREG|FORCC, SAREG|AWD, ANYSIGNED|TUNSIGNED|TULONG|TFLOAT, --- 91,99 ----- NAREG|NASL, RESC1|RESCC, #ifndef GFLOAT " cvtdf AL,A1\n", + #else GFLOAT + " cvtgf AL,A1\n", + #endif GFLOAT SCONV, INTAREG|FORCC, SAREG|AWD, ANYSIGNED|TUNSIGNED|TULONG|TFLOAT, *************** *** 108,113 SAREG|AWD, ANYSIGNED|TUNSIGNED|TULONG|TFLOAT, SANY, TFLOAT|TDOUBLE, NAREG|NASL, RESC1|RESCC, " cvtZLd AL,A1\n", SCONV, INTAREG|FORCC, --- 112,118 ----- SAREG|AWD, ANYSIGNED|TUNSIGNED|TULONG|TFLOAT, SANY, TFLOAT|TDOUBLE, NAREG|NASL, RESC1|RESCC, + #ifndef GFLOAT " cvtZLd AL,A1\n", #else GFLOAT " cvtZLg AL,A1\n", *************** *** 109,114 SANY, TFLOAT|TDOUBLE, NAREG|NASL, RESC1|RESCC, " cvtZLd AL,A1\n", SCONV, INTAREG|FORCC, SAREG|AWD, TUCHAR|TUSHORT, --- 114,122 ----- NAREG|NASL, RESC1|RESCC, #ifndef GFLOAT " cvtZLd AL,A1\n", + #else GFLOAT + " cvtZLg AL,A1\n", + #endif GFLOAT SCONV, INTAREG|FORCC, SAREG|AWD, TUCHAR|TUSHORT, *************** *** 114,119 SAREG|AWD, TUCHAR|TUSHORT, SANY, TFLOAT|TDOUBLE, NAREG|NASL, RESC1|RESCC, " movzZLl AL,A1\n cvtld A1,A1\n", SCONV, INTAREG|FORCC, --- 122,128 ----- SAREG|AWD, TUCHAR|TUSHORT, SANY, TFLOAT|TDOUBLE, NAREG|NASL, RESC1|RESCC, + #ifndef GFLOAT " movzZLl AL,A1\n cvtld A1,A1\n", #else GFLOAT " movzZLl AL,A1\n cvtlg A1,A1\n", *************** *** 115,120 SANY, TFLOAT|TDOUBLE, NAREG|NASL, RESC1|RESCC, " movzZLl AL,A1\n cvtld A1,A1\n", SCONV, INTAREG|FORCC, SAREG|AWD, TFLOAT|TDOUBLE, --- 124,132 ----- NAREG|NASL, RESC1|RESCC, #ifndef GFLOAT " movzZLl AL,A1\n cvtld A1,A1\n", + #else GFLOAT + " movzZLl AL,A1\n cvtlg A1,A1\n", + #endif GFLOAT SCONV, INTAREG|FORCC, SAREG|AWD, TFLOAT|TDOUBLE, *************** *** 273,278 SAREG|AWD, TDOUBLE, SAREG|AWD, TDOUBLE, 0, RESCC, " cmpd AL,AR\nZP", OPLOG, FORCC, --- 285,291 ----- SAREG|AWD, TDOUBLE, SAREG|AWD, TDOUBLE, 0, RESCC, + #ifndef GFLOAT " cmpd AL,AR\nZP", #else GFLOAT " cmpg AL,AR\nZP", *************** *** 274,279 SAREG|AWD, TDOUBLE, 0, RESCC, " cmpd AL,AR\nZP", OPLOG, FORCC, SAREG|AWD, TDOUBLE, --- 287,295 ----- 0, RESCC, #ifndef GFLOAT " cmpd AL,AR\nZP", + #else GFLOAT + " cmpg AL,AR\nZP", + #endif GFLOAT OPLOG, FORCC, SAREG|AWD, TDOUBLE, *************** *** 279,284 SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG|NASR, RESCC, " cvtfd AR,A1\n cmpd AL,A1\nZP", OPLOG, FORCC, --- 295,301 ----- SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG|NASR, RESCC, + #ifndef GFLOAT " cvtfd AR,A1\n cmpd AL,A1\nZP", #else GFLOAT " cvtfg AR,A1\n cmpg AL,A1\nZP", *************** *** 280,285 SAREG|AWD, TFLOAT, NAREG|NASR, RESCC, " cvtfd AR,A1\n cmpd AL,A1\nZP", OPLOG, FORCC, SAREG|AWD, TFLOAT, --- 297,305 ----- NAREG|NASR, RESCC, #ifndef GFLOAT " cvtfd AR,A1\n cmpd AL,A1\nZP", + #else GFLOAT + " cvtfg AR,A1\n cmpg AL,A1\nZP", + #endif GFLOAT OPLOG, FORCC, SAREG|AWD, TFLOAT, *************** *** 285,290 SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG|NASL, RESCC, " cvtfd AL,A1\n cmpd A1,AR\nZP", OPLOG, FORCC, --- 305,311 ----- SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG|NASL, RESCC, + #ifndef GFLOAT " cvtfd AL,A1\n cmpd A1,AR\nZP", #else GFLOAT " cvtfg AL,A1\n cmpg A1,AR\nZP", *************** *** 286,291 SAREG|AWD, TDOUBLE, NAREG|NASL, RESCC, " cvtfd AL,A1\n cmpd A1,AR\nZP", OPLOG, FORCC, SAREG|AWD, TFLOAT, --- 307,315 ----- NAREG|NASL, RESCC, #ifndef GFLOAT " cvtfd AL,A1\n cmpd A1,AR\nZP", + #else GFLOAT + " cvtfg AL,A1\n cmpg A1,AR\nZP", + #endif GFLOAT OPLOG, FORCC, SAREG|AWD, TFLOAT, *************** *** 484,489 SANY, TANY, SAREG, TDOUBLE, 2*NTEMP, RESC1, " movd AR,A1\n", REG, INTEMP, --- 508,514 ----- SANY, TANY, SAREG, TDOUBLE, 2*NTEMP, RESC1, + #ifndef GFLOAT " movd AR,A1\n", #else GFLOAT " movg AR,A1\n", *************** *** 485,490 SAREG, TDOUBLE, 2*NTEMP, RESC1, " movd AR,A1\n", REG, INTEMP, SANY, TANY, --- 510,518 ----- 2*NTEMP, RESC1, #ifndef GFLOAT " movd AR,A1\n", + #else GFLOAT + " movg AR,A1\n", + #endif GFLOAT REG, INTEMP, SANY, TANY, *************** *** 497,502 SANY, TANY, SAREG, TFLOAT, 0, RNULL, " cvtfd AR,-(sp)\n", REG, FORARG, --- 525,531 ----- SANY, TANY, SAREG, TFLOAT, 0, RNULL, + #ifndef GFLOAT " cvtfd AR,-(sp)\n", #else GFLOAT " cvtfg AR,-(sp)\n", *************** *** 498,503 SAREG, TFLOAT, 0, RNULL, " cvtfd AR,-(sp)\n", REG, FORARG, SANY, TANY, --- 527,535 ----- 0, RNULL, #ifndef GFLOAT " cvtfd AR,-(sp)\n", + #else GFLOAT + " cvtfg AR,-(sp)\n", + #endif GFLOAT REG, FORARG, SANY, TANY, *************** *** 552,557 SANY, TANY, SANY, TDOUBLE, 0, RNULL, " movd AR,-(sp)\n", OPLTYPE, FORARG, --- 584,590 ----- SANY, TANY, SANY, TDOUBLE, 0, RNULL, + #ifndef GFLOAT " movd AR,-(sp)\n", #else GFLOAT " movg AR,-(sp)\n", *************** *** 553,558 SANY, TDOUBLE, 0, RNULL, " movd AR,-(sp)\n", OPLTYPE, FORARG, SANY, TANY, --- 586,594 ----- 0, RNULL, #ifndef GFLOAT " movd AR,-(sp)\n", + #else GFLOAT + " movg AR,-(sp)\n", + #endif GFLOAT OPLTYPE, FORARG, SANY, TANY, *************** *** 558,563 SANY, TANY, SANY, TFLOAT, 0, RNULL, " cvtfd AR,-(sp)\n", #ifdef FORT --- 594,600 ----- SANY, TANY, SANY, TFLOAT, 0, RNULL, + #ifndef GFLOAT " cvtfd AR,-(sp)\n", #else GFLOAT " cvtfg AR,-(sp)\n", *************** *** 559,564 SANY, TFLOAT, 0, RNULL, " cvtfd AR,-(sp)\n", #ifdef FORT UNARY MINUS, INTAREG|FORCC, --- 596,604 ----- 0, RNULL, #ifndef GFLOAT " cvtfd AR,-(sp)\n", + #else GFLOAT + " cvtfg AR,-(sp)\n", + #endif GFLOAT #ifdef FORT UNARY MINUS, INTAREG|FORCC, *************** *** 814,819 SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG, RLEFT|RESCC, " cvtfd AR,A1\n OD2 A1,AL\n", ASG OPFLOAT, INAREG|INTAREG|FOREFF|FORCC, --- 854,860 ----- SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG, RLEFT|RESCC, + #ifndef GFLOAT " cvtfd AR,A1\n OD2 A1,AL\n", #else GFLOAT " cvtfg AR,A1\n OD2 A1,AL\n", *************** *** 815,820 SAREG|AWD, TFLOAT, NAREG, RLEFT|RESCC, " cvtfd AR,A1\n OD2 A1,AL\n", ASG OPFLOAT, INAREG|INTAREG|FOREFF|FORCC, SAREG|AWD, TFLOAT, --- 856,864 ----- NAREG, RLEFT|RESCC, #ifndef GFLOAT " cvtfd AR,A1\n OD2 A1,AL\n", + #else GFLOAT + " cvtfg AR,A1\n OD2 A1,AL\n", + #endif GFLOAT ASG OPFLOAT, INAREG|INTAREG|FOREFF|FORCC, SAREG|AWD, TFLOAT, *************** *** 820,825 SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG, RLEFT|RESC1|RESCC, " cvtfd AL,A1\n OD2 AR,A1\n cvtdf A1,AL\n", OPFLOAT, INAREG|INTAREG|FORCC, --- 864,870 ----- SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG, RLEFT|RESC1|RESCC, + #ifndef GFLOAT " cvtfd AL,A1\n OD2 AR,A1\n cvtdf A1,AL\n", #else GFLOAT " cvtfg AL,A1\n OD2 AR,A1\n cvtgf A1,AL\n", *************** *** 821,826 SAREG|AWD, TDOUBLE, NAREG, RLEFT|RESC1|RESCC, " cvtfd AL,A1\n OD2 AR,A1\n cvtdf A1,AL\n", OPFLOAT, INAREG|INTAREG|FORCC, STAREG, TDOUBLE, --- 866,874 ----- NAREG, RLEFT|RESC1|RESCC, #ifndef GFLOAT " cvtfd AL,A1\n OD2 AR,A1\n cvtdf A1,AL\n", + #else GFLOAT + " cvtfg AL,A1\n OD2 AR,A1\n cvtgf A1,AL\n", + #endif GFLOAT OPFLOAT, INAREG|INTAREG|FORCC, STAREG, TDOUBLE, *************** *** 838,843 SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG|NASL, RESC1|RESCC, " cvtfd AL,A1\n OD2 AR,A1\n", OPFLOAT, INAREG|INTAREG|FORCC, --- 886,892 ----- SAREG|AWD, TFLOAT, SAREG|AWD, TDOUBLE, NAREG|NASL, RESC1|RESCC, + #ifndef GFLOAT " cvtfd AL,A1\n OD2 AR,A1\n", #else GFLOAT " cvtfg AL,A1\n OD2 AR,A1\n", *************** *** 839,844 SAREG|AWD, TDOUBLE, NAREG|NASL, RESC1|RESCC, " cvtfd AL,A1\n OD2 AR,A1\n", OPFLOAT, INAREG|INTAREG|FORCC, SAREG|AWD, TDOUBLE, --- 888,896 ----- NAREG|NASL, RESC1|RESCC, #ifndef GFLOAT " cvtfd AL,A1\n OD2 AR,A1\n", + #else GFLOAT + " cvtfg AL,A1\n OD2 AR,A1\n", + #endif GFLOAT OPFLOAT, INAREG|INTAREG|FORCC, SAREG|AWD, TDOUBLE, *************** *** 844,849 SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG|NASR, RESC1|RESCC, " cvtfd AR,A1\n OD3 A1,AL,A1\n", #ifdef FORT --- 896,902 ----- SAREG|AWD, TDOUBLE, SAREG|AWD, TFLOAT, NAREG|NASR, RESC1|RESCC, + #ifndef GFLOAT " cvtfd AR,A1\n OD3 A1,AL,A1\n", #else GFLOAT " cvtfg AR,A1\n OD3 A1,AL,A1\n", *************** *** 845,850 SAREG|AWD, TFLOAT, NAREG|NASR, RESC1|RESCC, " cvtfd AR,A1\n OD3 A1,AL,A1\n", #ifdef FORT OPFLOAT, INAREG|INTAREG|FORCC, --- 898,906 ----- NAREG|NASR, RESC1|RESCC, #ifndef GFLOAT " cvtfd AR,A1\n OD3 A1,AL,A1\n", + #else GFLOAT + " cvtfg AR,A1\n OD3 A1,AL,A1\n", + #endif GFLOAT #ifdef FORT OPFLOAT, INAREG|INTAREG|FORCC, *************** *** 864,869 SAREG|AWD, TFLOAT, SAREG|AWD, TFLOAT, NAREG|NASL|NASR, RESC1|RESCC, " OF3 AR,AL,A1\n cvtfd A1,A1\n", #endif --- 920,926 ----- SAREG|AWD, TFLOAT, SAREG|AWD, TFLOAT, NAREG|NASL|NASR, RESC1|RESCC, + #ifndef GFLOAT " OF3 AR,AL,A1\n cvtfd A1,A1\n", #else GFLOAT " OF3 AR,AL,A1\n cvtfg A1,A1\n", *************** *** 865,870 SAREG|AWD, TFLOAT, NAREG|NASL|NASR, RESC1|RESCC, " OF3 AR,AL,A1\n cvtfd A1,A1\n", #endif /* Default actions for hard trees ... */ --- 922,930 ----- NAREG|NASL|NASR, RESC1|RESCC, #ifndef GFLOAT " OF3 AR,AL,A1\n cvtfd A1,A1\n", + #else GFLOAT + " OF3 AR,AL,A1\n cvtfg A1,A1\n", + #endif GFLOAT #endif /* Default actions for hard trees ... */ SHAR_EOF chmod +x 'table.c.diff' chdir .. if test ! -d 'f2' then mkdir 'f2' fi cd 'f2' if test -f 'c22.c.diff' then echo shar: over-writing existing file "'c22.c.diff'" fi cat << \SHAR_EOF > 'c22.c.diff' 35a36 > #ifndef GFLOAT 36a38,40 > #else GFLOAT > "acbg",T(ACB,DOUBLE), > #endif GFLOAT 41a46 > #ifndef GFLOAT 43a49,52 > #else GFLOAT > "addg2",T(ADD,U(DOUBLE,OP2)), > "addg3",T(ADD,U(DOUBLE,OP3)), > #endif GFLOAT 102a112 > #ifndef GFLOAT 103a114,116 > #else GFLOAT > "clrg",T(CLR,DOUBLE), > #endif GFLOAT 108a122 > #ifndef GFLOAT 109a124,126 > #else GFLOAT > "cmpg",T(CMP,DOUBLE), > #endif GFLOAT 112a130 > #ifndef GFLOAT 113a132,134 > #else GFLOAT > "cvtbg",T(CVT,U(BYTE,DOUBLE)), > #endif GFLOAT 116a138 > #ifndef GFLOAT 120a143,148 > #else GFLOAT > "cvtgb",T(CVT,U(DOUBLE,BYTE)), > "cvtgf",T(CVT,U(DOUBLE,FLOAT)), > "cvtgl",T(CVT,U(DOUBLE,LONG)), > "cvtgw",T(CVT,U(DOUBLE,WORD)), > #endif GFLOAT 121a150 > #ifndef GFLOAT 122a152,154 > #else GFLOAT > "cvtfg",T(CVT,U(FLOAT,DOUBLE)), > #endif GFLOAT 125a158 > #ifndef GFLOAT 126a160,162 > #else GFLOAT > "cvtlg",T(CVT,U(LONG,DOUBLE)), > #endif GFLOAT 128a165 > #ifndef GFLOAT 129a167,169 > #else GFLOAT > "cvtrgl",T(CVT,U(DOUBLE,LONG)), > #endif GFLOAT 131a172 > #ifndef GFLOAT 132a174,176 > #else GFLOAT > "cvtwg",T(CVT,U(WORD,DOUBLE)), > #endif GFLOAT 139a184 > #ifndef GFLOAT 141a187,190 > #else GFLOAT > "divg2",T(DIV,U(DOUBLE,OP2)), > "divg3",T(DIV,U(DOUBLE,OP3)), > #endif GFLOAT 158a208 > #ifndef GFLOAT 159a210,212 > #else GFLOAT > "mnegg",T(NEG,DOUBLE), > #endif GFLOAT 163a217 > #ifndef GFLOAT 164a219,221 > #else GFLOAT > "movag",T(MOVA,DOUBLE), > #endif GFLOAT 169a227 > #ifndef GFLOAT 170a229,231 > #else GFLOAT > "movg",T(MOV,DOUBLE), > #endif GFLOAT 179a241 > #ifndef GFLOAT 181a244,247 > #else GFLOAT > "mulg2",T(MUL,U(DOUBLE,OP2)), > "mulg3",T(MUL,U(DOUBLE,OP3)), > #endif GFLOAT 188a255 > #ifndef GFLOAT 189a257,259 > #else GFLOAT > "pushag",T(PUSHA,DOUBLE), > #endif GFLOAT 199a270 > #ifndef GFLOAT 201a273,276 > #else GFLOAT > "subg2",T(SUB,U(DOUBLE,OP2)), > "subg3",T(SUB,U(DOUBLE,OP3)), > #endif GFLOAT 208a284 > #ifndef GFLOAT 209a286,288 > #else GFLOAT > "tstg",T(TST,DOUBLE), > #endif GFLOAT 266a346 > #ifndef GFLOAT 267a348,350 > #else GFLOAT > "emodg",0, > #endif GFLOAT 284a368 > #ifndef GFLOAT 285a370,372 > #else GFLOAT > "polyg",0, > #endif GFLOAT SHAR_EOF chmod +x 'c22.c.diff' if test -f 'Makefile.diff' then echo shar: over-writing existing file "'Makefile.diff'" fi cat << \SHAR_EOF > 'Makefile.diff' 4c4 < CFLAGS = -w -DCOPYCODE --- > CFLAGS = -w -DCOPYCODE -DGFLOAT SHAR_EOF chmod +x 'Makefile.diff' chdir .. chdir .. chdir .. chdir .. # End of shell archive exit 0
sources-request@panda.UUCP (11/11/85)
Mod.sources: Volume 3, Issue 39 Submitted by: J.D.Aplevich <decvax!watmath!watdcsu!aplevich> #!/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: Wed Oct 30 10:33:37 1985 export PATH; PATH=/bin:$PATH if test ! -d 'gfloat' then mkdir 'gfloat' fi cd 'gfloat' if test ! -d 'f77' then mkdir 'f77' fi cd 'f77' if test ! -d 'src' then mkdir 'src' fi cd 'src' if test ! -d 'f77pass1' then mkdir 'f77pass1' fi cd 'f77pass1' if test -f 'bb.c.diff' then echo shar: over-writing existing file "'bb.c.diff'" fi cat << \SHAR_EOF > 'bb.c.diff' *** ../f77/src/f77pass1/bb.c.orig Tue Oct 29 15:15:44 1985 --- ../f77/src/f77pass1/bb.c Tue Oct 29 15:22:15 1985 *************** *** 717,722 } else if( ISINT(type) ) fprintf(diagfile," ci= %d\n",p->constblock.const.ci); else if( ISREAL(type) ) fprintf(diagfile," cd[0]= %e\n",p->constblock.const.cd[0]); else fprintf(diagfile," cd[0]= %e cd[1]= %e\n", --- 717,726 ----- } else if( ISINT(type) ) fprintf(diagfile," ci= %d\n",p->constblock.const.ci); + #ifdef GFLOAT + else if( ISREAL(type) && type==TYREAL) + fprintf(diagfile," cr[0]= %e\n",p->constblock.const.cr[0]); + #endif GFLOAT else if( ISREAL(type) ) fprintf(diagfile," cd[0]= %e\n",p->constblock.const.cd[0]); else fprintf(diagfile," cd[0]= %e cd[1]= %e\n", SHAR_EOF chmod +x 'bb.c.diff' if test -f 'conv.c.diff' then echo shar: over-writing existing file "'conv.c.diff'" fi cat << \SHAR_EOF > 'conv.c.diff' *** ../f77/src/f77pass1/conv.c.orig Tue Oct 29 15:15:46 1985 --- ../f77/src/f77pass1/conv.c Tue Oct 29 15:22:23 1985 *************** *** 53,59 /* The following constants are used to check the limits of */ ! /* conversions. Dmaxword is the largest double precision */ /* number which can be converted to a two-byte integer */ /* without overflow. Dminword is the smallest double */ /* precision value which can be converted to a two-byte */ --- 53,61 ----- /* The following constants are used to check the limits of */ ! /* conversions. */ ! ! /* Dmaxword is the largest double precision */ /* number which can be converted to a two-byte integer */ /* without overflow. Dminword is the smallest double */ /* precision value which can be converted to a two-byte */ *************** *** 57,66 /* number which can be converted to a two-byte integer */ /* without overflow. Dminword is the smallest double */ /* precision value which can be converted to a two-byte */ ! /* integer without overflow. Dmaxint and dminint are the */ ! /* analogous values for four-byte integers. */ ! ! LOCAL long dmaxword[] = { 0xfeff47ff, 0xffffffff }; LOCAL long dminword[] = { 0x00ffc800, 0xffffffff }; --- 59,66 ----- /* number which can be converted to a two-byte integer */ /* without overflow. Dminword is the smallest double */ /* precision value which can be converted to a two-byte */ ! /* integer without overflow. */ ! #ifndef GFLOAT LOCAL long dmaxword[] = { 0xfeff47ff, 0xffffffff }; LOCAL long dminword[] = { 0x00ffc800, 0xffffffff }; #else GFLOAT *************** *** 63,68 LOCAL long dmaxword[] = { 0xfeff47ff, 0xffffffff }; LOCAL long dminword[] = { 0x00ffc800, 0xffffffff }; LOCAL long dmaxint[] = { 0xffff4fff, 0xfffffeff }; LOCAL long dminint[] = { 0x0000d000, 0xffff00ff }; --- 63,72 ----- #ifndef GFLOAT LOCAL long dmaxword[] = { 0xfeff47ff, 0xffffffff }; LOCAL long dminword[] = { 0x00ffc800, 0xffffffff }; + #else GFLOAT + LOCAL long dmaxword[] = { 0xffdf40ff, 0xffffffff }; + LOCAL long dminword[] = { 0x0010c100, 0x00000000 }; + #endif GFLOAT /* Dmaxint and dminint are the limits for double values */ /* converted to four-byte integers. */ *************** *** 64,69 LOCAL long dmaxword[] = { 0xfeff47ff, 0xffffffff }; LOCAL long dminword[] = { 0x00ffc800, 0xffffffff }; LOCAL long dmaxint[] = { 0xffff4fff, 0xfffffeff }; LOCAL long dminint[] = { 0x0000d000, 0xffff00ff }; --- 68,79 ----- LOCAL long dminword[] = { 0x0010c100, 0x00000000 }; #endif GFLOAT + /* Dmaxint and dminint are the limits for double values */ + /* converted to four-byte integers. */ + #ifdef GFLOAT + LOCAL long dmaxint[] = { 0xffff41ff, 0xffffffdf }; + LOCAL long dminint[] = { 0x0000c200, 0xffff0010 }; + #else GFLOAT LOCAL long dmaxint[] = { 0xffff4fff, 0xfffffeff }; LOCAL long dminint[] = { 0x0000d000, 0xffff00ff }; #endif GFLOAT *************** *** 66,71 LOCAL long dmaxint[] = { 0xffff4fff, 0xfffffeff }; LOCAL long dminint[] = { 0x0000d000, 0xffff00ff }; LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff }; LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff }; --- 76,82 ----- #else GFLOAT LOCAL long dmaxint[] = { 0xffff4fff, 0xfffffeff }; LOCAL long dminint[] = { 0x0000d000, 0xffff00ff }; + #endif GFLOAT #ifndef GFLOAT LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff }; *************** *** 67,72 LOCAL long dmaxint[] = { 0xffff4fff, 0xfffffeff }; LOCAL long dminint[] = { 0x0000d000, 0xffff00ff }; LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff }; LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff }; --- 78,84 ----- LOCAL long dminint[] = { 0x0000d000, 0xffff00ff }; #endif GFLOAT + #ifndef GFLOAT LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff }; LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff }; #else GFLOAT *************** *** 69,74 LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff }; LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff }; --- 81,89 ----- #ifndef GFLOAT LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff }; LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff }; + #else GFLOAT + LOCAL long dmaxreal[] = { 0xffff47f7, 0xffffffff }; + LOCAL long dminreal[] = { 0xffffc7f7, 0xffffffff }; /* Fmaxword and fminword are limits for float to short. */ LOCAL long fmaxword[] = { 0xff7f47ff }; *************** *** 70,75 LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff }; LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff }; /* The routines which follow are used to convert */ --- 85,98 ----- LOCAL long dmaxreal[] = { 0xffff47f7, 0xffffffff }; LOCAL long dminreal[] = { 0xffffc7f7, 0xffffffff }; + /* Fmaxword and fminword are limits for float to short. */ + LOCAL long fmaxword[] = { 0xff7f47ff }; + LOCAL long fminword[] = { 0x00ffc800 }; + + /* Fmaxint and fminint are the limits for float to int. */ + LOCAL long fmaxint[] = { 0xffff4fff }; + LOCAL long fminint[] = { 0x0000d000 }; + #endif GFLOAT /* The routines which follow are used to convert */ *************** *** 188,193 register long *rp; register double *minp; register double *maxp; realvalue x; switch (cp->vtype) --- 211,220 ----- register long *rp; register double *minp; register double *maxp; + #ifdef GFLOAT + register float *minpf; + register float *maxpf; + #endif GFLOAT realvalue x; switch (cp->vtype) *************** *** 222,227 break; case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: --- 249,255 ----- break; case TYREAL: + #ifndef GFLOAT case TYDREAL: #endif GFLOAT case TYCOMPLEX: *************** *** 223,228 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: minp = (double *) dminword; --- 251,257 ----- case TYREAL: #ifndef GFLOAT case TYDREAL: + #endif GFLOAT case TYCOMPLEX: #ifdef GFLOAT minpf = (float *) fminword; *************** *** 224,229 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: minp = (double *) dminword; maxp = (double *) dmaxword; --- 253,290 ----- case TYDREAL: #endif GFLOAT case TYCOMPLEX: + #ifdef GFLOAT + minpf = (float *) fminword; + maxpf = (float *) fmaxword; + rp = (long *) &(cp->const.cr[0]); + x.q.word1 = rp[0]; + if (x.f.sign == 1 && x.f.exp == 0) + { + if (badvalue <= 1) + { + badvalue = 2; + err(reserved); + } + p = errnode(); + } + else if ((float) x.q.word1 >= *minpf && (float) x.q.word1 <= *maxpf) + { + p = (expptr) mkconst(TYSHORT); + p->constblock.const.ci = x.q.word1; + } + else + { + if (badvalue <= 1) + { + badvalue = 2; + err(toobig); + } + p = errnode(); + } + break; + + case TYDREAL: + #endif GFLOAT case TYDCOMPLEX: minp = (double *) dminword; maxp = (double *) dmaxword; *************** *** 230,235 rp = (long *) &(cp->const.cd[0]); x.q.word1 = rp[0]; x.q.word2 = rp[1]; if (x.f.sign == 1 && x.f.exp == 0) { if (badvalue <= 1) --- 291,297 ----- rp = (long *) &(cp->const.cd[0]); x.q.word1 = rp[0]; x.q.word2 = rp[1]; + #ifndef GFLOAT if (x.f.sign == 1 && x.f.exp == 0) #else GFLOAT if (x.g.sign == 1 && x.g.exp == 0) *************** *** 231,236 x.q.word1 = rp[0]; x.q.word2 = rp[1]; if (x.f.sign == 1 && x.f.exp == 0) { if (badvalue <= 1) { --- 293,301 ----- x.q.word2 = rp[1]; #ifndef GFLOAT if (x.f.sign == 1 && x.f.exp == 0) + #else GFLOAT + if (x.g.sign == 1 && x.g.exp == 0) + #endif GFLOAT { if (badvalue <= 1) { *************** *** 302,307 register long *rp; register double *minp; register double *maxp; realvalue x; switch (cp->vtype) --- 367,376 ----- register long *rp; register double *minp; register double *maxp; + #ifdef GFLOAT + register float *minpf; + register float *maxpf; + #endif GFLOAT realvalue x; switch (cp->vtype) *************** *** 323,328 break; case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: --- 392,398 ----- break; case TYREAL: + #ifndef GFLOAT case TYDREAL: #endif GFLOAT case TYCOMPLEX: *************** *** 324,329 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: minp = (double *) dminint; --- 394,400 ----- case TYREAL: #ifndef GFLOAT case TYDREAL: + #endif GFLOAT case TYCOMPLEX: #ifdef GFLOAT minpf = (float *) fminint; *************** *** 325,330 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: minp = (double *) dminint; maxp = (double *) dmaxint; --- 396,432 ----- case TYDREAL: #endif GFLOAT case TYCOMPLEX: + #ifdef GFLOAT + minpf = (float *) fminint; + maxpf = (float *) fmaxint; + x.q.word1 = *((long *) &cp->const.cr[0]); + if (x.f.sign == 1 && x.f.exp == 0) + { + if (badvalue <= 1) + { + badvalue = 2; + err(reserved); + } + p = errnode(); + } + else if (cp->const.cr[0] >= *minpf && cp->const.cr[0] <= *maxpf) + { + p = (expptr) mkconst(TYLONG); + p->constblock.const.ci = cp->const.cr[0]; + } + else + { + if (badvalue <= 1) + { + badvalue = 2; + err(toobig); + } + p = errnode(); + } + break; + + case TYDREAL: + #endif GFLOAT case TYDCOMPLEX: minp = (double *) dminint; maxp = (double *) dmaxint; *************** *** 331,336 rp = (long *) &(cp->const.cd[0]); x.q.word1 = rp[0]; x.q.word2 = rp[1]; if (x.f.sign == 1 && x.f.exp == 0) { if (badvalue <= 1) --- 433,439 ----- rp = (long *) &(cp->const.cd[0]); x.q.word1 = rp[0]; x.q.word2 = rp[1]; + #ifndef GFLOAT if (x.f.sign == 1 && x.f.exp == 0) #else GFLOAT if (x.g.sign == 1 && x.g.exp == 0) *************** *** 332,337 x.q.word1 = rp[0]; x.q.word2 = rp[1]; if (x.f.sign == 1 && x.f.exp == 0) { if (badvalue <= 1) { --- 435,443 ----- x.q.word2 = rp[1]; #ifndef GFLOAT if (x.f.sign == 1 && x.f.exp == 0) + #else GFLOAT + if (x.g.sign == 1 && x.g.exp == 0) + #endif GFLOAT { if (badvalue <= 1) { *************** *** 403,408 register double *minp; register double *maxp; realvalue x; float y; switch (cp->vtype) --- 509,515 ----- register double *minp; register double *maxp; realvalue x; + #ifndef GFLOAT float y; #endif GFLOAT *************** *** 404,409 register double *maxp; realvalue x; float y; switch (cp->vtype) { --- 511,517 ----- realvalue x; #ifndef GFLOAT float y; + #endif GFLOAT switch (cp->vtype) { *************** *** 418,423 case TYSHORT: case TYLONG: p = (expptr) mkconst(TYREAL); p->constblock.const.cd[0] = cp->const.ci; break; --- 526,532 ----- case TYSHORT: case TYLONG: p = (expptr) mkconst(TYREAL); + #ifndef GFLOAT p->constblock.const.cd[0] = cp->const.ci; #else GFLOAT p->constblock.const.cr[0] = cp->const.ci; *************** *** 419,424 case TYLONG: p = (expptr) mkconst(TYREAL); p->constblock.const.cd[0] = cp->const.ci; break; case TYREAL: --- 528,536 ----- p = (expptr) mkconst(TYREAL); #ifndef GFLOAT p->constblock.const.cd[0] = cp->const.ci; + #else GFLOAT + p->constblock.const.cr[0] = cp->const.ci; + #endif GFLOAT break; case TYREAL: *************** *** 422,427 break; case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: --- 534,540 ----- break; case TYREAL: + #ifndef GFLOAT case TYDREAL: #endif GFLOAT case TYCOMPLEX: *************** *** 423,428 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: minp = (double *) dminreal; --- 536,542 ----- case TYREAL: #ifndef GFLOAT case TYDREAL: + #endif GFLOAT case TYCOMPLEX: #ifdef GFLOAT p = (expptr) mkconst(TYREAL); *************** *** 424,429 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: minp = (double *) dminreal; maxp = (double *) dmaxreal; --- 538,550 ----- case TYDREAL: #endif GFLOAT case TYCOMPLEX: + #ifdef GFLOAT + p = (expptr) mkconst(TYREAL); + p->constblock.const.cr[0] = cp->const.cr[0]; + break; + + case TYDREAL: + #endif GFLOAT case TYDCOMPLEX: minp = (double *) dminreal; maxp = (double *) dmaxreal; *************** *** 430,435 rp = (long *) &(cp->const.cd[0]); x.q.word1 = rp[0]; x.q.word2 = rp[1]; if (x.f.sign == 1 && x.f.exp == 0) { p = (expptr) mkconst(TYREAL); --- 551,557 ----- rp = (long *) &(cp->const.cd[0]); x.q.word1 = rp[0]; x.q.word2 = rp[1]; + #ifndef GFLOAT if (x.f.sign == 1 && x.f.exp == 0) #else GFLOAT if (x.g.sign == 1 && x.g.exp == 0) *************** *** 431,436 x.q.word1 = rp[0]; x.q.word2 = rp[1]; if (x.f.sign == 1 && x.f.exp == 0) { p = (expptr) mkconst(TYREAL); rp = (long *) &(p->constblock.const.cd[0]); --- 553,561 ----- x.q.word2 = rp[1]; #ifndef GFLOAT if (x.f.sign == 1 && x.f.exp == 0) + #else GFLOAT + if (x.g.sign == 1 && x.g.exp == 0) + #endif GFLOAT { p = (expptr) mkconst(TYREAL); #ifndef GFLOAT *************** *** 433,438 if (x.f.sign == 1 && x.f.exp == 0) { p = (expptr) mkconst(TYREAL); rp = (long *) &(p->constblock.const.cd[0]); rp[0] = x.q.word1; } --- 558,564 ----- #endif GFLOAT { p = (expptr) mkconst(TYREAL); + #ifndef GFLOAT rp = (long *) &(p->constblock.const.cd[0]); rp[0] = x.q.word1; #else GFLOAT *************** *** 435,440 p = (expptr) mkconst(TYREAL); rp = (long *) &(p->constblock.const.cd[0]); rp[0] = x.q.word1; } else if (x.d >= *minp && x.d <= *maxp) { --- 561,570 ----- #ifndef GFLOAT rp = (long *) &(p->constblock.const.cd[0]); rp[0] = x.q.word1; + #else GFLOAT + /* Gfloat: Assume that IEEE standard hardware handles exceptions */ + p->constblock.const.cr[0] = x.d; + #endif GFLOAT } else if (x.d >= *minp && x.d <= *maxp) { *************** *** 439,444 else if (x.d >= *minp && x.d <= *maxp) { p = (expptr) mkconst(TYREAL); y = x.d; p->constblock.const.cd[0] = y; } --- 569,575 ----- else if (x.d >= *minp && x.d <= *maxp) { p = (expptr) mkconst(TYREAL); + #ifndef GFLOAT y = x.d; p->constblock.const.cd[0] = y; #else GFLOAT *************** *** 441,446 p = (expptr) mkconst(TYREAL); y = x.d; p->constblock.const.cd[0] = y; } else { --- 572,580 ----- #ifndef GFLOAT y = x.d; p->constblock.const.cd[0] = y; + #else GFLOAT + p->constblock.const.cr[0] = x.d; + #endif GFLOAT } else { *************** *** 517,522 p->constblock.const.cd[0] = cp->const.ci; break; case TYREAL: case TYDREAL: case TYCOMPLEX: --- 651,657 ----- p->constblock.const.cd[0] = cp->const.ci; break; + #ifndef GFLOAT case TYREAL: case TYCOMPLEX: #endif GFLOAT *************** *** 518,524 break; case TYREAL: - case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: p = (expptr) mkconst(TYDREAL); --- 653,658 ----- #ifndef GFLOAT case TYREAL: case TYCOMPLEX: #endif GFLOAT case TYDREAL: *************** *** 520,525 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: p = (expptr) mkconst(TYDREAL); longp = (long *) &(cp->const.cd[0]); --- 654,661 ----- #ifndef GFLOAT case TYREAL: case TYCOMPLEX: + #endif GFLOAT + case TYDREAL: case TYDCOMPLEX: p = (expptr) mkconst(TYDREAL); #ifndef GFLOAT *************** *** 522,527 case TYCOMPLEX: case TYDCOMPLEX: p = (expptr) mkconst(TYDREAL); longp = (long *) &(cp->const.cd[0]); rp = (long *) &(p->constblock.const.cd[0]); rp[0] = longp[0]; --- 658,664 ----- case TYDREAL: case TYDCOMPLEX: p = (expptr) mkconst(TYDREAL); + #ifndef GFLOAT longp = (long *) &(cp->const.cd[0]); rp = (long *) &(p->constblock.const.cd[0]); rp[0] = longp[0]; *************** *** 526,531 rp = (long *) &(p->constblock.const.cd[0]); rp[0] = longp[0]; rp[1] = longp[1]; break; case TYLOGICAL: --- 663,671 ----- rp = (long *) &(p->constblock.const.cd[0]); rp[0] = longp[0]; rp[1] = longp[1]; + #else GFLOAT + p->constblock.const.cd[0] = cp->const.cd[0]; + #endif GFLOAT break; #ifdef GFLOAT *************** *** 528,533 rp[1] = longp[1]; break; case TYLOGICAL: if (badvalue <= 1) { --- 668,681 ----- #endif GFLOAT break; + #ifdef GFLOAT + case TYREAL: + case TYCOMPLEX: + p = (expptr) mkconst(TYDREAL); + p->constblock.const.cd[0] = cp->const.cr[0]; + break; + + #endif GFLOAT case TYLOGICAL: if (badvalue <= 1) { *************** *** 576,581 register long *rp; register double *minp; register double *maxp; realvalue re, im; int overflow; float x; --- 724,733 ----- register long *rp; register double *minp; register double *maxp; + #ifdef GFLOAT + register float *minpf; + register float *maxpf; + #endif GFLOAT realvalue re, im; int overflow; float x; *************** *** 598,603 break; case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: --- 750,756 ----- break; case TYREAL: + #ifndef GFLOAT case TYDREAL: #endif GFLOAT case TYCOMPLEX: *************** *** 599,604 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: overflow = 0; --- 752,758 ----- case TYREAL: #ifndef GFLOAT case TYDREAL: + #endif GFLOAT case TYCOMPLEX: #ifdef GFLOAT overflow = 0; *************** *** 600,605 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: overflow = 0; minp = (double *) dminreal; --- 754,768 ----- case TYDREAL: #endif GFLOAT case TYCOMPLEX: + #ifdef GFLOAT + overflow = 0; + p = (expptr) mkconst(TYCOMPLEX); + p->constblock.const.cr[0] = cp->const.cr[0]; + p->constblock.const.cr[1] = cp->const.cr[1]; + break; + + case TYDREAL: + #endif GFLOAT case TYDCOMPLEX: overflow = 0; minp = (double *) dminreal; *************** *** 609,614 re.q.word2 = rp[1]; im.q.word1 = rp[2]; im.q.word2 = rp[3]; if (((re.f.sign == 0 || re.f.exp != 0) && (re.d < *minp || re.d > *maxp)) || ((im.f.sign == 0 || re.f.exp != 0) && --- 772,778 ----- re.q.word2 = rp[1]; im.q.word1 = rp[2]; im.q.word2 = rp[3]; + #ifndef GFLOAT if (((re.f.sign == 0 || re.f.exp != 0) && #else GFLOAT if (((re.g.sign == 0 || re.g.exp != 0) && *************** *** 610,615 im.q.word1 = rp[2]; im.q.word2 = rp[3]; if (((re.f.sign == 0 || re.f.exp != 0) && (re.d < *minp || re.d > *maxp)) || ((im.f.sign == 0 || re.f.exp != 0) && (im.d < *minp || re.d > *maxp))) --- 774,782 ----- im.q.word2 = rp[3]; #ifndef GFLOAT if (((re.f.sign == 0 || re.f.exp != 0) && + #else GFLOAT + if (((re.g.sign == 0 || re.g.exp != 0) && + #endif GFLOAT (re.d < *minp || re.d > *maxp)) || #ifndef GFLOAT ((im.f.sign == 0 || re.f.exp != 0) && *************** *** 611,616 im.q.word2 = rp[3]; if (((re.f.sign == 0 || re.f.exp != 0) && (re.d < *minp || re.d > *maxp)) || ((im.f.sign == 0 || re.f.exp != 0) && (im.d < *minp || re.d > *maxp))) { --- 778,784 ----- if (((re.g.sign == 0 || re.g.exp != 0) && #endif GFLOAT (re.d < *minp || re.d > *maxp)) || + #ifndef GFLOAT ((im.f.sign == 0 || re.f.exp != 0) && #else GFLOAT ((im.g.sign == 0 || re.g.exp != 0) && *************** *** 612,617 if (((re.f.sign == 0 || re.f.exp != 0) && (re.d < *minp || re.d > *maxp)) || ((im.f.sign == 0 || re.f.exp != 0) && (im.d < *minp || re.d > *maxp))) { if (badvalue <= 1) --- 780,788 ----- (re.d < *minp || re.d > *maxp)) || #ifndef GFLOAT ((im.f.sign == 0 || re.f.exp != 0) && + #else GFLOAT + ((im.g.sign == 0 || re.g.exp != 0) && + #endif GFLOAT (im.d < *minp || re.d > *maxp))) { if (badvalue <= 1) *************** *** 624,629 else { p = (expptr) mkconst(TYCOMPLEX); if (re.f.sign == 1 && re.f.exp == 0) re.q.word2 = 0; else --- 795,801 ----- else { p = (expptr) mkconst(TYCOMPLEX); + #ifndef GFLOAT if (re.f.sign == 1 && re.f.exp == 0) re.q.word2 = 0; else *************** *** 643,648 rp[1] = re.q.word2; rp[2] = im.q.word1; rp[3] = im.q.word2; } break; --- 815,824 ----- rp[1] = re.q.word2; rp[2] = im.q.word1; rp[3] = im.q.word2; + #else GFLOAT + p->constblock.const.cr[0] = cp->const.cd[0]; + p->constblock.const.cr[0] = cp->const.cd[1]; + #endif GFLOAT } break; *************** *** 711,716 break; case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: --- 887,893 ----- break; case TYREAL: + #ifndef GFLOAT case TYDREAL: #endif GFLOAT case TYCOMPLEX: *************** *** 712,717 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: p = (expptr) mkconst(TYDCOMPLEX); --- 889,895 ----- case TYREAL: #ifndef GFLOAT case TYDREAL: + #endif GFLOAT case TYCOMPLEX: #ifdef GFLOAT p = (expptr) mkconst(TYDCOMPLEX); *************** *** 713,718 case TYREAL: case TYDREAL: case TYCOMPLEX: case TYDCOMPLEX: p = (expptr) mkconst(TYDCOMPLEX); longp = (long *) &(cp->const.cd[0]); --- 891,904 ----- case TYDREAL: #endif GFLOAT case TYCOMPLEX: + #ifdef GFLOAT + p = (expptr) mkconst(TYDCOMPLEX); + p->constblock.const.cd[0] = cp->const.cr[0]; + p->constblock.const.cd[1] = cp->const.cr[1]; + break; + + case TYDREAL: + #endif GFLOAT case TYDCOMPLEX: p = (expptr) mkconst(TYDCOMPLEX); #ifndef GFLOAT *************** *** 715,720 case TYCOMPLEX: case TYDCOMPLEX: p = (expptr) mkconst(TYDCOMPLEX); longp = (long *) &(cp->const.cd[0]); rp = (long *) &(p->constblock.const.cd[0]); rp[0] = longp[0]; --- 901,907 ----- #endif GFLOAT case TYDCOMPLEX: p = (expptr) mkconst(TYDCOMPLEX); + #ifndef GFLOAT longp = (long *) &(cp->const.cd[0]); rp = (long *) &(p->constblock.const.cd[0]); rp[0] = longp[0]; *************** *** 721,726 rp[1] = longp[1]; rp[2] = longp[2]; rp[3] = longp[3]; break; case TYLOGICAL: --- 908,917 ----- rp[1] = longp[1]; rp[2] = longp[2]; rp[3] = longp[3]; + #else GFLOAT + p->constblock.const.cd[0] = cp->const.cd[0]; + p->constblock.const.cd[1] = cp->const.cd[1]; + #endif GFLOAT break; case TYLOGICAL: SHAR_EOF chmod +x 'conv.c.diff' if test -f 'expr.c.diff' then echo shar: over-writing existing file "'expr.c.diff'" fi cat << \SHAR_EOF > 'expr.c.diff' *** ../f77/src/f77pass1/expr.c.orig Tue Oct 29 15:15:54 1985 --- ../f77/src/f77pass1/expr.c Tue Oct 29 15:22:42 1985 *************** *** 151,157 register Constp p; p = mkconst(t); ! p->const.cd[0] = d; return( (expptr) p ); } --- 151,162 ----- register Constp p; p = mkconst(t); ! #ifdef GFLOAT ! if (t==TYREAL) ! p->const.cr[0] = d; ! else ! #endif GFLOAT ! p->const.cd[0] = d; return( (expptr) p ); } *************** *** 241,246 p = mkconst( (rtype==TYDREAL||itype==TYDREAL) ? TYDCOMPLEX : TYCOMPLEX); if( ISINT(rtype) ) p->const.cd[0] = realp->constblock.const.ci; else p->const.cd[0] = realp->constblock.const.cd[0]; if( ISINT(itype) ) p->const.cd[1] = imagp->constblock.const.ci; --- 246,255 ----- p = mkconst( (rtype==TYDREAL||itype==TYDREAL) ? TYDCOMPLEX : TYCOMPLEX); if( ISINT(rtype) ) p->const.cd[0] = realp->constblock.const.ci; + #ifdef GFLOAT + else if (rtype==TYREAL || itype==TYREAL) + p->const.cr[0] = realp->constblock.const.cr[0]; + #endif GFLOAT else p->const.cd[0] = realp->constblock.const.cd[0]; if( ISINT(itype) ) p->const.cd[1] = imagp->constblock.const.ci; *************** *** 244,249 else p->const.cd[0] = realp->constblock.const.cd[0]; if( ISINT(itype) ) p->const.cd[1] = imagp->constblock.const.ci; else p->const.cd[1] = imagp->constblock.const.cd[0]; } else --- 253,262 ----- else p->const.cd[0] = realp->constblock.const.cd[0]; if( ISINT(itype) ) p->const.cd[1] = imagp->constblock.const.ci; + #ifdef GFLOAT + else if (rtype==TYREAL || itype==TYREAL) + p->const.cr[1] = imagp->constblock.const.cr[0]; + #endif GFLOAT else p->const.cd[1] = imagp->constblock.const.cd[0]; } else *************** *** 2255,2261 lv->ci = rv->ccp[0]; else if( ISINT(rt) ) lv->ci = rv->ci; ! else lv->ci = rv->cd[0]; break; case TYCOMPLEX: --- 2268,2278 ----- lv->ci = rv->ccp[0]; else if( ISINT(rt) ) lv->ci = rv->ci; ! #ifdef GFLOAT ! else if (rt==TYREAL || rt==TYCOMPLEX) ! lv->ci = rv->cr[0]; /* should test */ ! #endif GFLOAT ! else lv->ci = rv->cd[0]; break; case TYCOMPLEX: *************** *** 2258,2264 else lv->ci = rv->cd[0]; break; ! case TYCOMPLEX: case TYDCOMPLEX: switch(rt) { --- 2275,2305 ----- else lv->ci = rv->cd[0]; break; ! case TYCOMPLEX: ! #ifdef GFLOAT ! switch(rt) ! { ! case TYSHORT: ! case TYLONG: ! /* fall through and do real assignment of ! first element */ ! case TYREAL: ! case TYDREAL: ! lv->cr[1] = 0; break; ! case TYCOMPLEX: ! lv->cr[1] = rv->cr[1]; break; ! case TYDCOMPLEX: /* should check range here */ ! lv->cr[1] = rv->cd[1]; break; ! } ! case TYREAL: ! if( ISINT(rt) ) ! lv->cr[0] = rv->ci; ! else if (rt==TYREAL || rt==TYCOMPLEX) ! lv->cr[0] = rv->cr[0]; ! else lv->cr[0] = rv->cd[0]; /* should test range */ ! break; ! ! #endif GFLOAT case TYDCOMPLEX: switch(rt) { *************** *** 2270,2276 case TYREAL: case TYDREAL: lv->cd[1] = 0; break; ! case TYCOMPLEX: case TYDCOMPLEX: lv->cd[1] = rv->cd[1]; break; } --- 2311,2320 ----- case TYREAL: case TYDREAL: lv->cd[1] = 0; break; ! case TYCOMPLEX: ! #ifdef GFLOAT ! lv->cd[1] = rv->cr[1]; break; ! #endif GFLOAT case TYDCOMPLEX: lv->cd[1] = rv->cd[1]; break; } *************** *** 2274,2280 case TYDCOMPLEX: lv->cd[1] = rv->cd[1]; break; } ! case TYREAL: case TYDREAL: if( ISINT(rt) ) --- 2318,2324 ----- case TYDCOMPLEX: lv->cd[1] = rv->cd[1]; break; } ! #ifndef GFLOAT case TYREAL: #endif GFLOAT case TYDREAL: *************** *** 2276,2281 } case TYREAL: case TYDREAL: if( ISINT(rt) ) lv->cd[0] = rv->ci; --- 2320,2326 ----- } #ifndef GFLOAT case TYREAL: + #endif GFLOAT case TYDREAL: if( ISINT(rt) ) lv->cd[0] = rv->ci; *************** *** 2279,2284 case TYDREAL: if( ISINT(rt) ) lv->cd[0] = rv->ci; else lv->cd[0] = rv->cd[0]; break; --- 2324,2333 ----- case TYDREAL: if( ISINT(rt) ) lv->cd[0] = rv->ci; + #ifdef GFLOAT + else if (rt==TYREAL || rt==TYCOMPLEX) + lv->cd[0] = rv->cr[0]; + #endif GFLOAT else lv->cd[0] = rv->cd[0]; break; *************** *** 2300,2306 p->const.ci = - p->const.ci; break; ! case TYCOMPLEX: case TYDCOMPLEX: p->const.cd[1] = - p->const.cd[1]; /* fall through and do the real parts */ --- 2349,2362 ----- p->const.ci = - p->const.ci; break; ! case TYCOMPLEX: ! #ifdef GFLOAT ! p->const.cr[1] = - p->const.cr[1]; ! /* fall through and do the real parts */ ! case TYREAL: ! p->const.cr[0] = - p->const.cr[0]; ! break; ! #endif GFLOAT case TYDCOMPLEX: p->const.cd[1] = - p->const.cd[1]; /* fall through and do the real parts */ *************** *** 2304,2309 case TYDCOMPLEX: p->const.cd[1] = - p->const.cd[1]; /* fall through and do the real parts */ case TYREAL: case TYDREAL: p->const.cd[0] = - p->const.cd[0]; --- 2360,2366 ----- case TYDCOMPLEX: p->const.cd[1] = - p->const.cd[1]; /* fall through and do the real parts */ + #ifndef GFLOAT case TYREAL: #endif GFLOAT case TYDREAL: *************** *** 2305,2310 p->const.cd[1] = - p->const.cd[1]; /* fall through and do the real parts */ case TYREAL: case TYDREAL: p->const.cd[0] = - p->const.cd[0]; break; --- 2362,2368 ----- /* fall through and do the real parts */ #ifndef GFLOAT case TYREAL: + #endif GFLOAT case TYDREAL: p->const.cd[0] = - p->const.cd[0]; break; *************** *** 2329,2335 case TYLONG: powp->ci = 1; break; ! case TYCOMPLEX: case TYDCOMPLEX: powp->cd[1] = 0; case TYREAL: --- 2387,2399 ----- case TYLONG: powp->ci = 1; break; ! case TYCOMPLEX: ! #ifdef GFLOAT ! powp->cr[1] = 0; ! case TYREAL: ! powp->cr[0] = 1; ! break; ! #endif GFLOAT case TYDCOMPLEX: powp->cd[1] = 0; #ifndef GFLOAT *************** *** 2332,2337 case TYCOMPLEX: case TYDCOMPLEX: powp->cd[1] = 0; case TYREAL: case TYDREAL: powp->cd[0] = 1; --- 2396,2402 ----- #endif GFLOAT case TYDCOMPLEX: powp->cd[1] = 0; + #ifndef GFLOAT case TYREAL: #endif GFLOAT case TYDREAL: *************** *** 2333,2338 case TYDCOMPLEX: powp->cd[1] = 0; case TYREAL: case TYDREAL: powp->cd[0] = 1; break; --- 2398,2404 ----- powp->cd[1] = 0; #ifndef GFLOAT case TYREAL: + #endif GFLOAT case TYDREAL: powp->cd[0] = 1; break; *************** *** 2383,2388 /* do constant operation cp = a op b */ LOCAL consbinop(opcode, type, cp, ap, bp) int opcode, type; --- 2449,2457 ----- /* do constant operation cp = a op b */ + #ifdef GFLOAT + struct rcomplex { double real, imag; }; + #endif GFLOAT LOCAL consbinop(opcode, type, cp, ap, bp) int opcode, type; *************** *** 2390,2395 { int k; double temp; switch(opcode) { --- 2459,2467 ----- { int k; double temp; + #ifdef GFLOAT + struct rcomplex fr, ar, br; + #endif GFLOAT switch(opcode) { *************** *** 2401,2406 cp->ci = ap->ci + bp->ci; break; case TYCOMPLEX: case TYDCOMPLEX: cp->cd[1] = ap->cd[1] + bp->cd[1]; case TYREAL: --- 2473,2484 ----- cp->ci = ap->ci + bp->ci; break; case TYCOMPLEX: + #ifdef GFLOAT + cp->cr[1] = ap->cr[1] + bp->cr[1]; + case TYREAL: + cp->cr[0] = ap->cr[0] + bp->cr[0]; + break; + #endif GFLOAT case TYDCOMPLEX: cp->cd[1] = ap->cd[1] + bp->cd[1]; #ifndef GFLOAT *************** *** 2403,2408 case TYCOMPLEX: case TYDCOMPLEX: cp->cd[1] = ap->cd[1] + bp->cd[1]; case TYREAL: case TYDREAL: cp->cd[0] = ap->cd[0] + bp->cd[0]; --- 2481,2487 ----- #endif GFLOAT case TYDCOMPLEX: cp->cd[1] = ap->cd[1] + bp->cd[1]; + #ifndef GFLOAT case TYREAL: #endif GFLOAT case TYDREAL: *************** *** 2404,2409 case TYDCOMPLEX: cp->cd[1] = ap->cd[1] + bp->cd[1]; case TYREAL: case TYDREAL: cp->cd[0] = ap->cd[0] + bp->cd[0]; break; --- 2483,2489 ----- cp->cd[1] = ap->cd[1] + bp->cd[1]; #ifndef GFLOAT case TYREAL: + #endif GFLOAT case TYDREAL: cp->cd[0] = ap->cd[0] + bp->cd[0]; break; *************** *** 2417,2423 case TYLONG: cp->ci = ap->ci - bp->ci; break; ! case TYCOMPLEX: case TYDCOMPLEX: cp->cd[1] = ap->cd[1] - bp->cd[1]; case TYREAL: --- 2497,2509 ----- case TYLONG: cp->ci = ap->ci - bp->ci; break; ! case TYCOMPLEX: ! #ifdef GFLOAT ! cp->cr[1] = ap->cr[1] - bp->cr[1]; ! case TYREAL: ! cp->cr[0] = ap->cr[0] - bp->cr[0]; ! break; ! #endif GFLOAT case TYDCOMPLEX: cp->cd[1] = ap->cd[1] - bp->cd[1]; #ifndef GFLOAT *************** *** 2420,2425 case TYCOMPLEX: case TYDCOMPLEX: cp->cd[1] = ap->cd[1] - bp->cd[1]; case TYREAL: case TYDREAL: cp->cd[0] = ap->cd[0] - bp->cd[0]; --- 2506,2512 ----- #endif GFLOAT case TYDCOMPLEX: cp->cd[1] = ap->cd[1] - bp->cd[1]; + #ifndef GFLOAT case TYREAL: #endif GFLOAT case TYDREAL: *************** *** 2421,2426 case TYDCOMPLEX: cp->cd[1] = ap->cd[1] - bp->cd[1]; case TYREAL: case TYDREAL: cp->cd[0] = ap->cd[0] - bp->cd[0]; break; --- 2508,2514 ----- cp->cd[1] = ap->cd[1] - bp->cd[1]; #ifndef GFLOAT case TYREAL: + #endif GFLOAT case TYDREAL: cp->cd[0] = ap->cd[0] - bp->cd[0]; break; *************** *** 2434,2440 case TYLONG: cp->ci = ap->ci * bp->ci; break; ! case TYREAL: case TYDREAL: cp->cd[0] = ap->cd[0] * bp->cd[0]; break; --- 2522,2532 ----- case TYLONG: cp->ci = ap->ci * bp->ci; break; ! case TYREAL: ! #ifdef GFLOAT ! cp->cr[0] = ap->cr[0] * bp->cr[0]; ! break; ! #endif GFLOAT case TYDREAL: cp->cd[0] = ap->cd[0] * bp->cd[0]; break; *************** *** 2439,2444 cp->cd[0] = ap->cd[0] * bp->cd[0]; break; case TYCOMPLEX: case TYDCOMPLEX: temp = ap->cd[0] * bp->cd[0] - ap->cd[1] * bp->cd[1] ; --- 2531,2544 ----- cp->cd[0] = ap->cd[0] * bp->cd[0]; break; case TYCOMPLEX: + #ifdef GFLOAT + temp = ap->cr[0] * bp->cr[0] - + ap->cr[1] * bp->cr[1] ; + cp->cr[1] = ap->cr[0] * bp->cr[1] + + ap->cr[1] * bp->cr[0] ; + cp->cr[0] = temp; + break; + #endif GFLOAT case TYDCOMPLEX: temp = ap->cd[0] * bp->cd[0] - ap->cd[1] * bp->cd[1] ; *************** *** 2455,2461 case TYLONG: cp->ci = ap->ci / bp->ci; break; ! case TYREAL: case TYDREAL: cp->cd[0] = ap->cd[0] / bp->cd[0]; break; --- 2555,2565 ----- case TYLONG: cp->ci = ap->ci / bp->ci; break; ! case TYREAL: ! #ifdef GFLOAT ! cp->cr[0] = ap->cr[0] / bp->cr[0]; ! break; ! #endif GFLOAT case TYDREAL: cp->cd[0] = ap->cd[0] / bp->cd[0]; break; *************** *** 2460,2465 cp->cd[0] = ap->cd[0] / bp->cd[0]; break; case TYCOMPLEX: case TYDCOMPLEX: zdiv(cp,ap,bp); break; --- 2564,2579 ----- cp->cd[0] = ap->cd[0] / bp->cd[0]; break; case TYCOMPLEX: + #ifdef GFLOAT + ar.real = ap->cr[0]; + ar.imag = ap->cr[1]; + br.real = bp->cr[0]; + br.imag = bp->cr[1]; + zdiv(fr,ar,br); + cp->cr[0] = fr.real; /* should test */ + cp->cr[1] = fr.imag; + break; + #endif GFLOAT case TYDCOMPLEX: zdiv(cp,ap,bp); break; *************** *** 2486,2492 k = 0; else k = 1; break; ! case TYREAL: case TYDREAL: if(ap->cd[0] < bp->cd[0]) k = -1; --- 2600,2606 ----- k = 0; else k = 1; break; ! case TYREAL: /*assume this works for G format floats */ case TYDREAL: if(ap->cd[0] < bp->cd[0]) k = -1; *************** *** 2494,2500 k = 0; else k = 1; break; ! case TYCOMPLEX: case TYDCOMPLEX: if(ap->cd[0] == bp->cd[0] && ap->cd[1] == bp->cd[1] ) --- 2608,2621 ----- k = 0; else k = 1; break; ! case TYCOMPLEX: ! #ifdef GFLOAT ! if(ap->cr[0] == bp->cr[0] && ! ap->cr[1] == bp->cr[1] ) ! k = 0; ! else k = 1; ! break; ! #endif GFLOAT case TYDCOMPLEX: if(ap->cd[0] == bp->cd[0] && ap->cd[1] == bp->cd[1] ) *************** *** 2547,2553 if(p->constblock.const.ci < 0) return(-1); return(0); ! case TYREAL: case TYDREAL: if(p->constblock.const.cd[0] > 0) return(1); if(p->constblock.const.cd[0] < 0) return(-1); --- 2668,2679 ----- if(p->constblock.const.ci < 0) return(-1); return(0); ! case TYREAL: ! #ifdef GFLOAT ! if(p->constblock.const.cr[0] > 0) return(1); ! if(p->constblock.const.cr[0] < 0) return(-1); ! return(0); ! #endif GFLOAT case TYDREAL: if(p->constblock.const.cd[0] > 0) return(1); if(p->constblock.const.cd[0] < 0) return(-1); *************** *** 2553,2559 if(p->constblock.const.cd[0] < 0) return(-1); return(0); ! case TYCOMPLEX: case TYDCOMPLEX: return(p->constblock.const.cd[0]!=0 || p->constblock.const.cd[1]!=0); --- 2679,2687 ----- if(p->constblock.const.cd[0] < 0) return(-1); return(0); ! case TYCOMPLEX: ! #ifdef GFLOAT ! return(p->constblock.const.cr[0]!=0 || p->constblock.const.cr[1]!=0); case TYDCOMPLEX: return(p->constblock.const.cd[0]!=0 || p->constblock.const.cd[1]!=0); #else GFLOAT *************** *** 2555,2561 case TYCOMPLEX: case TYDCOMPLEX: ! return(p->constblock.const.cd[0]!=0 || p->constblock.const.cd[1]!=0); default: badtype( "conssgn", p->constblock.vtype); --- 2683,2693 ----- #ifdef GFLOAT return(p->constblock.const.cr[0]!=0 || p->constblock.const.cr[1]!=0); case TYDCOMPLEX: ! return(p->constblock.const.cd[0]!=0 || p->constblock.const.cd[1]!=0); ! #else GFLOAT ! case TYDCOMPLEX: ! return(p->constblock.const.cd[0]!=0 || p->constblock.const.cd[1]!=0); ! #endif GFLOAT default: badtype( "conssgn", p->constblock.vtype); SHAR_EOF chmod +x 'expr.c.diff' if test -f 'defs.h.diff' then echo shar: over-writing existing file "'defs.h.diff'" fi cat << \SHAR_EOF > 'defs.h.diff' *** ../f77/src/f77pass1/defs.h.orig Tue Oct 29 15:15:49 1985 --- ../f77/src/f77pass1/defs.h Tue Oct 29 15:22:31 1985 *************** *** 367,372 char *ccp; ftnint ci; double cd[2]; }; struct Constblock --- 367,375 ----- char *ccp; ftnint ci; double cd[2]; + #ifdef GFLOAT + float cr[4]; + #endif GFLOAT }; struct Constblock SHAR_EOF chmod +x 'defs.h.diff' chdir .. chdir .. chdir .. chdir .. # End of shell archive exit 0
sources-request@panda.UUCP (11/11/85)
Mod.sources: Volume 3, Issue 40 Submitted by: J.D.Aplevich <decvax!watmath!watdcsu!aplevich> #!/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: Wed Oct 30 20:44:40 1985 export PATH; PATH=/bin:$PATH if test ! -d 'gfloat' then mkdir 'gfloat' fi cd 'gfloat' if test ! -d 'f77' then mkdir 'f77' fi cd 'f77' if test ! -d 'src' then mkdir 'src' fi cd 'src' if test ! -d 'f77pass1' then mkdir 'f77pass1' fi cd 'f77pass1' if test -f 'intr.c.diff' then echo shar: over-writing existing file "'intr.c.diff'" fi cat << \SHAR_EOF > 'intr.c.diff' *** ../f77/src/f77pass1/intr.c.orig Tue Oct 29 15:16:01 1985 --- ../f77/src/f77pass1/intr.c Tue Oct 29 15:22:50 1985 *************** *** 237,242 { TYCOMPLEX,TYCOMPLEX,1,"r_cnjg" }, { TYDCOMPLEX,TYDCOMPLEX,1,"d_cnjg" }, { TYREAL,TYREAL,1,"r_sqrt", 1 }, { TYDREAL,TYDREAL,1,"d_sqrt", 1 }, { TYCOMPLEX,TYCOMPLEX,1,"c_sqrt" }, --- 237,243 ----- { TYCOMPLEX,TYCOMPLEX,1,"r_cnjg" }, { TYDCOMPLEX,TYDCOMPLEX,1,"d_cnjg" }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_sqrt", 1 }, #else GFLOAT { TYREAL,TYREAL,1,"r_sqrt" }, *************** *** 238,243 { TYDCOMPLEX,TYDCOMPLEX,1,"d_cnjg" }, { TYREAL,TYREAL,1,"r_sqrt", 1 }, { TYDREAL,TYDREAL,1,"d_sqrt", 1 }, { TYCOMPLEX,TYCOMPLEX,1,"c_sqrt" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_sqrt" }, --- 239,247 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_sqrt", 1 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_sqrt" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_sqrt", 1 }, { TYCOMPLEX,TYCOMPLEX,1,"c_sqrt" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_sqrt" }, *************** *** 242,247 { TYCOMPLEX,TYCOMPLEX,1,"c_sqrt" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_sqrt" }, { TYREAL,TYREAL,1,"r_exp", 2 }, { TYDREAL,TYDREAL,1,"d_exp", 2 }, { TYCOMPLEX,TYCOMPLEX,1,"c_exp" }, --- 246,252 ----- { TYCOMPLEX,TYCOMPLEX,1,"c_sqrt" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_sqrt" }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_exp", 2 }, #else GFLOAT { TYREAL,TYREAL,1,"r_exp" }, *************** *** 243,248 { TYDCOMPLEX,TYDCOMPLEX,1,"z_sqrt" }, { TYREAL,TYREAL,1,"r_exp", 2 }, { TYDREAL,TYDREAL,1,"d_exp", 2 }, { TYCOMPLEX,TYCOMPLEX,1,"c_exp" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_exp" }, --- 248,256 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_exp", 2 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_exp" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_exp", 2 }, { TYCOMPLEX,TYCOMPLEX,1,"c_exp" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_exp" }, *************** *** 247,252 { TYCOMPLEX,TYCOMPLEX,1,"c_exp" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_exp" }, { TYREAL,TYREAL,1,"r_log", 3 }, { TYDREAL,TYDREAL,1,"d_log", 3 }, { TYCOMPLEX,TYCOMPLEX,1,"c_log" }, --- 255,261 ----- { TYCOMPLEX,TYCOMPLEX,1,"c_exp" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_exp" }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_log", 3 }, #else GFLOAT { TYREAL,TYREAL,1,"r_log" }, *************** *** 248,253 { TYDCOMPLEX,TYDCOMPLEX,1,"z_exp" }, { TYREAL,TYREAL,1,"r_log", 3 }, { TYDREAL,TYDREAL,1,"d_log", 3 }, { TYCOMPLEX,TYCOMPLEX,1,"c_log" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_log" }, --- 257,265 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_log", 3 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_log" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_log", 3 }, { TYCOMPLEX,TYCOMPLEX,1,"c_log" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_log" }, *************** *** 255,260 { TYREAL,TYREAL,1,"r_lg10" }, { TYDREAL,TYDREAL,1,"d_lg10" }, { TYREAL,TYREAL,1,"r_sin", 4 }, { TYDREAL,TYDREAL,1,"d_sin", 4 }, { TYCOMPLEX,TYCOMPLEX,1,"c_sin" }, --- 267,273 ----- { TYREAL,TYREAL,1,"r_lg10" }, { TYDREAL,TYDREAL,1,"d_lg10" }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_sin", 4 }, #else GFLOAT { TYREAL,TYREAL,1,"r_sin" }, *************** *** 256,261 { TYDREAL,TYDREAL,1,"d_lg10" }, { TYREAL,TYREAL,1,"r_sin", 4 }, { TYDREAL,TYDREAL,1,"d_sin", 4 }, { TYCOMPLEX,TYCOMPLEX,1,"c_sin" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_sin" }, --- 269,277 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_sin", 4 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_sin" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_sin", 4 }, { TYCOMPLEX,TYCOMPLEX,1,"c_sin" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_sin" }, *************** *** 260,265 { TYCOMPLEX,TYCOMPLEX,1,"c_sin" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_sin" }, { TYREAL,TYREAL,1,"r_cos", 5 }, { TYDREAL,TYDREAL,1,"d_cos", 5 }, { TYCOMPLEX,TYCOMPLEX,1,"c_cos" }, --- 276,282 ----- { TYCOMPLEX,TYCOMPLEX,1,"c_sin" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_sin" }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_cos", 5 }, #else GFLOAT { TYREAL,TYREAL,1,"r_cos" }, *************** *** 261,266 { TYDCOMPLEX,TYDCOMPLEX,1,"z_sin" }, { TYREAL,TYREAL,1,"r_cos", 5 }, { TYDREAL,TYDREAL,1,"d_cos", 5 }, { TYCOMPLEX,TYCOMPLEX,1,"c_cos" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_cos" }, --- 278,286 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_cos", 5 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_cos" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_cos", 5 }, { TYCOMPLEX,TYCOMPLEX,1,"c_cos" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_cos" }, *************** *** 265,270 { TYCOMPLEX,TYCOMPLEX,1,"c_cos" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_cos" }, { TYREAL,TYREAL,1,"r_tan", 6 }, { TYDREAL,TYDREAL,1,"d_tan", 6 }, --- 285,291 ----- { TYCOMPLEX,TYCOMPLEX,1,"c_cos" }, { TYDCOMPLEX,TYDCOMPLEX,1,"z_cos" }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_tan", 6 }, #else GFLOAT { TYREAL,TYREAL,1,"r_tan" }, *************** *** 266,271 { TYDCOMPLEX,TYDCOMPLEX,1,"z_cos" }, { TYREAL,TYREAL,1,"r_tan", 6 }, { TYDREAL,TYDREAL,1,"d_tan", 6 }, { TYREAL,TYREAL,1,"r_asin", 7 }, --- 287,295 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_tan", 6 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_tan" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_tan", 6 }, #ifndef GFLOAT *************** *** 268,273 { TYREAL,TYREAL,1,"r_tan", 6 }, { TYDREAL,TYDREAL,1,"d_tan", 6 }, { TYREAL,TYREAL,1,"r_asin", 7 }, { TYDREAL,TYDREAL,1,"d_asin", 7 }, --- 292,298 ----- #endif GFLOAT { TYDREAL,TYDREAL,1,"d_tan", 6 }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_asin", 7 }, #else GFLOAT { TYREAL,TYREAL,1,"r_asin" }, *************** *** 269,274 { TYDREAL,TYDREAL,1,"d_tan", 6 }, { TYREAL,TYREAL,1,"r_asin", 7 }, { TYDREAL,TYDREAL,1,"d_asin", 7 }, { TYREAL,TYREAL,1,"r_acos", 8 }, --- 294,302 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_asin", 7 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_asin" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_asin", 7 }, #ifndef GFLOAT *************** *** 271,276 { TYREAL,TYREAL,1,"r_asin", 7 }, { TYDREAL,TYDREAL,1,"d_asin", 7 }, { TYREAL,TYREAL,1,"r_acos", 8 }, { TYDREAL,TYDREAL,1,"d_acos", 8 }, --- 299,305 ----- #endif GFLOAT { TYDREAL,TYDREAL,1,"d_asin", 7 }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_acos", 8 }, #else GFLOAT { TYREAL,TYREAL,1,"r_acos" }, *************** *** 272,277 { TYDREAL,TYDREAL,1,"d_asin", 7 }, { TYREAL,TYREAL,1,"r_acos", 8 }, { TYDREAL,TYDREAL,1,"d_acos", 8 }, { TYREAL,TYREAL,1,"r_atan", 9 }, --- 301,309 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_acos", 8 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_acos" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_acos", 8 }, #ifndef GFLOAT *************** *** 274,279 { TYREAL,TYREAL,1,"r_acos", 8 }, { TYDREAL,TYDREAL,1,"d_acos", 8 }, { TYREAL,TYREAL,1,"r_atan", 9 }, { TYDREAL,TYDREAL,1,"d_atan", 9 }, --- 306,312 ----- #endif GFLOAT { TYDREAL,TYDREAL,1,"d_acos", 8 }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_atan", 9 }, #else GFLOAT { TYREAL,TYREAL,1,"r_atan" }, *************** *** 275,280 { TYDREAL,TYDREAL,1,"d_acos", 8 }, { TYREAL,TYREAL,1,"r_atan", 9 }, { TYDREAL,TYDREAL,1,"d_atan", 9 }, { TYREAL,TYREAL,2,"r_atn2", 10 }, --- 308,316 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_atan", 9 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_atan" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_atan", 9 }, #ifndef GFLOAT *************** *** 277,282 { TYREAL,TYREAL,1,"r_atan", 9 }, { TYDREAL,TYDREAL,1,"d_atan", 9 }, { TYREAL,TYREAL,2,"r_atn2", 10 }, { TYDREAL,TYDREAL,2,"d_atn2", 10 }, --- 313,319 ----- #endif GFLOAT { TYDREAL,TYDREAL,1,"d_atan", 9 }, + #ifndef GFLOAT { TYREAL,TYREAL,2,"r_atn2", 10 }, #else GFLOAT { TYREAL,TYREAL,2,"r_atn2" }, *************** *** 278,283 { TYDREAL,TYDREAL,1,"d_atan", 9 }, { TYREAL,TYREAL,2,"r_atn2", 10 }, { TYDREAL,TYDREAL,2,"d_atn2", 10 }, { TYREAL,TYREAL,1,"r_sinh", 11 }, --- 315,323 ----- #ifndef GFLOAT { TYREAL,TYREAL,2,"r_atn2", 10 }, + #else GFLOAT + { TYREAL,TYREAL,2,"r_atn2" }, + #endif GFLOAT { TYDREAL,TYDREAL,2,"d_atn2", 10 }, #ifndef GFLOAT *************** *** 280,285 { TYREAL,TYREAL,2,"r_atn2", 10 }, { TYDREAL,TYDREAL,2,"d_atn2", 10 }, { TYREAL,TYREAL,1,"r_sinh", 11 }, { TYDREAL,TYDREAL,1,"d_sinh", 11 }, --- 320,326 ----- #endif GFLOAT { TYDREAL,TYDREAL,2,"d_atn2", 10 }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_sinh", 11 }, #else GFLOAT { TYREAL,TYREAL,1,"r_sinh" }, *************** *** 281,286 { TYDREAL,TYDREAL,2,"d_atn2", 10 }, { TYREAL,TYREAL,1,"r_sinh", 11 }, { TYDREAL,TYDREAL,1,"d_sinh", 11 }, { TYREAL,TYREAL,1,"r_cosh", 12 }, --- 322,330 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_sinh", 11 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_sinh" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_sinh", 11 }, #ifndef GFLOAT *************** *** 283,288 { TYREAL,TYREAL,1,"r_sinh", 11 }, { TYDREAL,TYDREAL,1,"d_sinh", 11 }, { TYREAL,TYREAL,1,"r_cosh", 12 }, { TYDREAL,TYDREAL,1,"d_cosh", 12 }, --- 327,333 ----- #endif GFLOAT { TYDREAL,TYDREAL,1,"d_sinh", 11 }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_cosh", 12 }, #else GFLOAT { TYREAL,TYREAL,1,"r_cosh" }, *************** *** 284,289 { TYDREAL,TYDREAL,1,"d_sinh", 11 }, { TYREAL,TYREAL,1,"r_cosh", 12 }, { TYDREAL,TYDREAL,1,"d_cosh", 12 }, { TYREAL,TYREAL,1,"r_tanh", 13 }, --- 329,337 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_cosh", 12 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_cosh" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_cosh", 12 }, #ifndef GFLOAT *************** *** 286,291 { TYREAL,TYREAL,1,"r_cosh", 12 }, { TYDREAL,TYDREAL,1,"d_cosh", 12 }, { TYREAL,TYREAL,1,"r_tanh", 13 }, { TYDREAL,TYDREAL,1,"d_tanh", 13 }, --- 334,340 ----- #endif GFLOAT { TYDREAL,TYDREAL,1,"d_cosh", 12 }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_tanh", 13 }, #else GFLOAT { TYREAL,TYREAL,1,"r_tanh" }, *************** *** 287,292 { TYDREAL,TYDREAL,1,"d_cosh", 12 }, { TYREAL,TYREAL,1,"r_tanh", 13 }, { TYDREAL,TYDREAL,1,"d_tanh", 13 }, { TYCHAR,TYLOGICAL,2,"hl_ge" }, --- 336,344 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_tanh", 13 }, + #else GFLOAT + { TYREAL,TYREAL,1,"r_tanh" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_tanh", 13 }, { TYCHAR,TYLOGICAL,2,"hl_ge" }, *************** *** 306,311 { TYDREAL,TYSHORT,1,"hd_expn" }, { TYDREAL,TYLONG,1,"id_expn" }, { TYREAL,TYREAL,1,"r_absp" }, { TYDREAL,TYDREAL,1,"d_absp" }, --- 358,364 ----- { TYDREAL,TYSHORT,1,"hd_expn" }, { TYDREAL,TYLONG,1,"id_expn" }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_absp" }, #else GFLOAT { TYREAL,TYDREAL,1,"r_absp" }, *************** *** 307,312 { TYDREAL,TYLONG,1,"id_expn" }, { TYREAL,TYREAL,1,"r_absp" }, { TYDREAL,TYDREAL,1,"d_absp" }, { TYREAL,TYDREAL,1,"r_rrsp" }, --- 360,368 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_absp" }, + #else GFLOAT + { TYREAL,TYDREAL,1,"r_absp" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_absp" }, { TYREAL,TYDREAL,1,"r_rrsp" }, *************** *** 312,317 { TYREAL,TYDREAL,1,"r_rrsp" }, { TYDREAL,TYDREAL,1,"d_rrsp" }, { TYREAL,TYREAL,1,"r_frac" }, { TYDREAL,TYDREAL,1,"d_frac" }, --- 368,374 ----- { TYREAL,TYDREAL,1,"r_rrsp" }, { TYDREAL,TYDREAL,1,"d_rrsp" }, + #ifndef GFLOAT { TYREAL,TYREAL,1,"r_frac" }, #else GFLOAT { TYREAL,TYDREAL,1,"r_frac" }, *************** *** 313,318 { TYDREAL,TYDREAL,1,"d_rrsp" }, { TYREAL,TYREAL,1,"r_frac" }, { TYDREAL,TYDREAL,1,"d_frac" }, { TYREAL,TYREAL,2,"r_make" }, --- 370,378 ----- #ifndef GFLOAT { TYREAL,TYREAL,1,"r_frac" }, + #else GFLOAT + { TYREAL,TYDREAL,1,"r_frac" }, + #endif GFLOAT { TYDREAL,TYDREAL,1,"d_frac" }, #ifndef GFLOAT *************** *** 315,320 { TYREAL,TYREAL,1,"r_frac" }, { TYDREAL,TYDREAL,1,"d_frac" }, { TYREAL,TYREAL,2,"r_make" }, { TYDREAL,TYDREAL,2,"d_make" }, --- 375,381 ----- #endif GFLOAT { TYDREAL,TYDREAL,1,"d_frac" }, + #ifndef GFLOAT { TYREAL,TYREAL,2,"r_make" }, #else GFLOAT { TYREAL,TYDREAL,2,"r_make" }, *************** *** 316,321 { TYDREAL,TYDREAL,1,"d_frac" }, { TYREAL,TYREAL,2,"r_make" }, { TYDREAL,TYDREAL,2,"d_make" }, { TYREAL,TYREAL,2,"r_scal" }, --- 377,385 ----- #ifndef GFLOAT { TYREAL,TYREAL,2,"r_make" }, + #else GFLOAT + { TYREAL,TYDREAL,2,"r_make" }, + #endif GFLOAT { TYDREAL,TYDREAL,2,"d_make" }, #ifndef GFLOAT *************** *** 318,323 { TYREAL,TYREAL,2,"r_make" }, { TYDREAL,TYDREAL,2,"d_make" }, { TYREAL,TYREAL,2,"r_scal" }, { TYDREAL,TYDREAL,2,"d_scal" } } ; --- 382,388 ----- #endif GFLOAT { TYDREAL,TYDREAL,2,"d_make" }, + #ifndef GFLOAT { TYREAL,TYREAL,2,"r_scal" }, #else GFLOAT { TYREAL,TYDREAL,2,"r_scal" }, *************** *** 319,324 { TYDREAL,TYDREAL,2,"d_make" }, { TYREAL,TYREAL,2,"r_scal" }, { TYDREAL,TYDREAL,2,"d_scal" } } ; --- 384,392 ----- #ifndef GFLOAT { TYREAL,TYREAL,2,"r_scal" }, + #else GFLOAT + { TYREAL,TYDREAL,2,"r_scal" }, + #endif GFLOAT { TYDREAL,TYDREAL,2,"d_scal" } } ; SHAR_EOF chmod +x 'intr.c.diff' if test -f 'optcse.c.diff' then echo shar: over-writing existing file "'optcse.c.diff'" fi cat << \SHAR_EOF > 'optcse.c.diff' *** ../f77/src/f77pass1/optcse.c.orig Tue Oct 29 15:16:07 1985 --- ../f77/src/f77pass1/optcse.c Tue Oct 29 15:22:56 1985 *************** *** 477,483 case TYLONG: if(ap->ci == bp->ci) return(TRUE); break; ! case TYREAL: case TYDREAL: if(ap->cd[0] == bp->cd[0]) return(TRUE); break; --- 477,487 ----- case TYLONG: if(ap->ci == bp->ci) return(TRUE); break; ! case TYREAL: ! #ifdef GFLOAT ! if(ap->cr[0] == bp->cr[0]) return(TRUE); ! break; ! #endif GFLOAT case TYDREAL: if(ap->cd[0] == bp->cd[0]) return(TRUE); break; *************** *** 482,487 if(ap->cd[0] == bp->cd[0]) return(TRUE); break; case TYCOMPLEX: case TYDCOMPLEX: if(ap->cd[0] == bp->cd[0] && ap->cd[1] == bp->cd[1] ) --- 486,497 ----- if(ap->cd[0] == bp->cd[0]) return(TRUE); break; case TYCOMPLEX: + #ifdef GFLOAT + if(ap->cr[0] == bp->cr[0] && + ap->cr[1] == bp->cr[1] ) + return(TRUE); + break; + #endif GFLOAT case TYDCOMPLEX: if(ap->cd[0] == bp->cd[0] && ap->cd[1] == bp->cd[1] ) SHAR_EOF chmod +x 'optcse.c.diff' if test -f 'optloop.c.diff' then echo shar: over-writing existing file "'optloop.c.diff'" fi cat << \SHAR_EOF > 'optloop.c.diff' *** ../f77/src/f77pass1/optloop.c.orig Tue Oct 29 15:16:09 1985 --- ../f77/src/f77pass1/optloop.c Wed Oct 30 20:26:44 1985 *************** *** 660,665 return YES; if (ISREAL(p->constblock.vtype)) if (abs(p->constblock.const.cd[0]) <= 1.0) return YES; --- 660,666 ----- return YES; if (ISREAL(p->constblock.vtype)) + #ifndef GFLOAT if (abs(p->constblock.const.cd[0]) <= 1.0) #else GFLOAT if (p->constblock.vtype==TYREAL) { *************** *** 661,666 if (ISREAL(p->constblock.vtype)) if (abs(p->constblock.const.cd[0]) <= 1.0) return YES; return NO; --- 662,673 ----- if (ISREAL(p->constblock.vtype)) #ifndef GFLOAT if (abs(p->constblock.const.cd[0]) <= 1.0) + #else GFLOAT + if (p->constblock.vtype==TYREAL) { + if (abs(p->constblock.const.cr[0]) <= 1.0) return YES; + } + else if (abs(p->constblock.const.cd[0]) <= 1.0) + #endif GFLOAT return YES; return NO; SHAR_EOF chmod +x 'optloop.c.diff' if test -f 'put.c.diff' then echo shar: over-writing existing file "'put.c.diff'" fi cat << \SHAR_EOF > 'put.c.diff' *** ../f77/src/f77pass1/put.c.orig Tue Oct 29 15:16:12 1985 --- ../f77/src/f77pass1/put.c Tue Oct 29 15:23:07 1985 *************** *** 169,174 if (ISCONST(p)) { if (ISCOMPLEX(p->constblock.vtype)) return(mkrealcon(p->constblock.vtype == TYCOMPLEX ? TYREAL : TYDREAL, --- 169,175 ----- if (ISCONST(p)) { + #ifndef GFLOAT if (ISCOMPLEX(p->constblock.vtype)) return(mkrealcon(p->constblock.vtype == TYCOMPLEX ? TYREAL : TYDREAL, *************** *** 173,178 return(mkrealcon(p->constblock.vtype == TYCOMPLEX ? TYREAL : TYDREAL, p->constblock.const.cd[1])); else if (p->constblock.vtype == TYDREAL) return(mkrealcon(TYDREAL, 0.0)); else --- 174,186 ----- return(mkrealcon(p->constblock.vtype == TYCOMPLEX ? TYREAL : TYDREAL, p->constblock.const.cd[1])); + #else GFLOAT + if (p->constblock.vtype == TYCOMPLEX) + return(mkrealcon( TYREAL, + (double) p->constblock.const.cr[1])); + else if (p->constblock.vtype == TYDCOMPLEX) + return(mkrealcon( TYDREAL, p->constblock.const.cd[1])); + #endif GFLOAT else if (p->constblock.vtype == TYDREAL) return(mkrealcon(TYDREAL, 0.0)); else *************** *** 340,345 k = 2; case TYREAL: type = TYREAL; goto flpt; case TYDCOMPLEX: --- 348,354 ----- k = 2; case TYREAL: type = TYREAL; + #ifndef GFLOAT goto flpt; #else GFLOAT for(i = 0 ; i < k ; ++i) *************** *** 341,346 case TYREAL: type = TYREAL; goto flpt; case TYDCOMPLEX: k = 2; --- 350,360 ----- type = TYREAL; #ifndef GFLOAT goto flpt; + #else GFLOAT + for(i = 0 ; i < k ; ++i) + prconr(asmfile, type, &p->const.cr[i]); + break; + #endif GFLOAT case TYDCOMPLEX: k = 2; *************** *** 346,351 k = 2; case TYDREAL: type = TYDREAL; flpt: for(i = 0 ; i < k ; ++i) --- 360,366 ----- k = 2; case TYDREAL: type = TYDREAL; + #ifndef GFLOAT flpt: #endif GFLOAT *************** *** 348,353 type = TYDREAL; flpt: for(i = 0 ; i < k ; ++i) prconr(asmfile, type, p->const.cd[i]); break; --- 363,369 ----- #ifndef GFLOAT flpt: + #endif GFLOAT for(i = 0 ; i < k ; ++i) #ifndef GFLOAT prconr(asmfile, type, p->const.cd[i]); *************** *** 349,354 flpt: for(i = 0 ; i < k ; ++i) prconr(asmfile, type, p->const.cd[i]); break; --- 365,371 ----- flpt: #endif GFLOAT for(i = 0 ; i < k ; ++i) + #ifndef GFLOAT prconr(asmfile, type, p->const.cd[i]); #else GFLOAT prconr(asmfile, type, &p->const.cd[i]); *************** *** 350,355 flpt: for(i = 0 ; i < k ; ++i) prconr(asmfile, type, p->const.cd[i]); break; case TYCHAR: --- 367,375 ----- for(i = 0 ; i < k ; ++i) #ifndef GFLOAT prconr(asmfile, type, p->const.cd[i]); + #else GFLOAT + prconr(asmfile, type, &p->const.cd[i]); + #endif GFLOAT break; case TYCHAR: SHAR_EOF chmod +x 'put.c.diff' if test -f 'vax.c.diff' then echo shar: over-writing existing file "'vax.c.diff'" fi cat << \SHAR_EOF > 'vax.c.diff' *** ../f77/src/f77pass1/vax.c.orig Tue Oct 29 15:16:18 1985 --- ../f77/src/f77pass1/vax.c Tue Oct 29 15:23:13 1985 *************** *** 69,74 ftnint intcon[14] = { 2, 2, 2, 2, 15, 31, 24, 56, -128, -128, 127, 127, 32767, 2147483647 }; --- 69,75 ----- ftnint intcon[14] = { 2, 2, 2, 2, + #ifndef GFLOAT 15, 31, 24, 56, -128, -128, 127, 127, #else GFLOAT *************** *** 71,76 { 2, 2, 2, 2, 15, 31, 24, 56, -128, -128, 127, 127, 32767, 2147483647 }; #if HERE == VAX --- 72,81 ----- #ifndef GFLOAT 15, 31, 24, 56, -128, -128, 127, 127, + #else GFLOAT + 15, 31, 24, 53, + -128, -1024, 127, 1023, + #endif GFLOAT 32767, 2147483647 }; #if HERE == VAX *************** *** 78,83 long realcon[6][2] = { { 0200, 0 }, { 0200, 0 }, { 037777677777, 0 }, { 037777677777, 037777777777 }, --- 83,89 ----- long realcon[6][2] = { { 0200, 0 }, + #ifndef GFLOAT { 0200, 0 }, #else GFLOAT { 0020, 0 }, *************** *** 79,84 { { 0200, 0 }, { 0200, 0 }, { 037777677777, 0 }, { 037777677777, 037777777777 }, { 032200, 0 }, --- 85,93 ----- { 0200, 0 }, #ifndef GFLOAT { 0200, 0 }, + #else GFLOAT + { 0020, 0 }, + #endif GFLOAT { 037777677777, 0 }, #ifndef GFLOAT { 037777677777, 037777777777 }, *************** *** 80,85 { 0200, 0 }, { 0200, 0 }, { 037777677777, 0 }, { 037777677777, 037777777777 }, { 032200, 0 }, { 022200, 0 } --- 89,95 ----- { 0020, 0 }, #endif GFLOAT { 037777677777, 0 }, + #ifndef GFLOAT { 037777677777, 037777777777 }, #else GFLOAT { 037777677777, 037777777777 }, *************** *** 81,86 { 0200, 0 }, { 037777677777, 0 }, { 037777677777, 037777777777 }, { 032200, 0 }, { 022200, 0 } }; --- 91,99 ----- { 037777677777, 0 }, #ifndef GFLOAT { 037777677777, 037777777777 }, + #else GFLOAT + { 037777677777, 037777777777 }, + #endif GFLOAT { 032200, 0 }, #ifndef GFLOAT { 022200, 0 } *************** *** 82,87 { 037777677777, 0 }, { 037777677777, 037777777777 }, { 032200, 0 }, { 022200, 0 } }; #else --- 95,101 ----- { 037777677777, 037777777777 }, #endif GFLOAT { 032200, 0 }, + #ifndef GFLOAT { 022200, 0 } #else GFLOAT { 036320, 0 } *************** *** 83,88 { 037777677777, 037777777777 }, { 032200, 0 }, { 022200, 0 } }; #else double realcon[6] = --- 97,105 ----- { 032200, 0 }, #ifndef GFLOAT { 022200, 0 } + #else GFLOAT + { 036320, 0 } + #endif GFLOAT }; #else double realcon[6] = *************** *** 197,202 prconr(fp, type, x) FILEP fp; int type; float x; { fprintf(fp, "\t%s\t0f%e\n", (type==TYREAL ? ".float" : ".double"), x); --- 214,220 ----- prconr(fp, type, x) FILEP fp; int type; + #ifndef GFLOAT float x; #else GFLOAT float *x; *************** *** 198,203 FILEP fp; int type; float x; { fprintf(fp, "\t%s\t0f%e\n", (type==TYREAL ? ".float" : ".double"), x); } --- 216,224 ----- int type; #ifndef GFLOAT float x; + #else GFLOAT + float *x; + #endif GFLOAT { #ifndef GFLOAT fprintf(fp, "\t%s\t0f%e\n", (type==TYREAL ? ".float" : ".double"), x); *************** *** 199,204 int type; float x; { fprintf(fp, "\t%s\t0f%e\n", (type==TYREAL ? ".float" : ".double"), x); } #endif --- 220,226 ----- float *x; #endif GFLOAT { + #ifndef GFLOAT fprintf(fp, "\t%s\t0f%e\n", (type==TYREAL ? ".float" : ".double"), x); #else GFLOAT fprintf(fp, "\t%s\t0f%e\n", (type==TYREAL ? ".float" : ".double"), *x); *************** *** 200,205 float x; { fprintf(fp, "\t%s\t0f%e\n", (type==TYREAL ? ".float" : ".double"), x); } #endif --- 222,230 ----- { #ifndef GFLOAT fprintf(fp, "\t%s\t0f%e\n", (type==TYREAL ? ".float" : ".double"), x); + #else GFLOAT + fprintf(fp, "\t%s\t0f%e\n", (type==TYREAL ? ".float" : ".double"), *x); + #endif GFLOAT } #endif *************** *** 207,212 prconr(fp, type, x) FILEP fp; int type; double x; { /* non-portable cheat to preserve bit patterns */ --- 232,238 ----- prconr(fp, type, x) FILEP fp; int type; + #ifndef GFLOAT double x; { /* non-portable cheat to preserve bit patterns */ *************** *** 226,231 fprintf(fp, "\t.long\t0x%X,0x%X\n", cheat.xl[0], cheat.xl[1]); i = SZDOUBLE; } if(fp == initfile) i_offset += i; else --- 252,274 ----- fprintf(fp, "\t.long\t0x%X,0x%X\n", cheat.xl[0], cheat.xl[1]); i = SZDOUBLE; } + #else GFLOAT + /* This assumes two longs make a double */ + long *x; + { + register int i; + + if(type == TYREAL) + { + fprintf(fp, "\t.long\t0x%X\n", *x ); + i = SZFLOAT; + } + else + { + fprintf(fp, "\t.long\t0x%X,0x%X\n", *x, *(x+1) ); + i = SZDOUBLE; + } + #endif GFLOAT if(fp == initfile) i_offset += i; else *************** *** 369,374 else if (type == TYSHORT) p2pass("\ttstw\tr0"); else p2pass("\ttstd\tr0"); p2pi("\tjlss\tL%d", neg); p2pi("\tjeql\tL%d", zer); --- 412,418 ----- else if (type == TYSHORT) p2pass("\ttstw\tr0"); else + #ifndef GFLOAT p2pass("\ttstd\tr0"); #else GFLOAT p2pass("\ttstg\tr0"); *************** *** 370,375 p2pass("\ttstw\tr0"); else p2pass("\ttstd\tr0"); p2pi("\tjlss\tL%d", neg); p2pi("\tjeql\tL%d", zer); p2pi("\tjbr\tL%d", pos); --- 414,422 ----- else #ifndef GFLOAT p2pass("\ttstd\tr0"); + #else GFLOAT + p2pass("\ttstg\tr0"); + #endif GFLOAT p2pi("\tjlss\tL%d", neg); p2pi("\tjeql\tL%d", zer); p2pi("\tjbr\tL%d", pos); SHAR_EOF chmod +x 'vax.c.diff' if test -f 'Makefile.diff' then echo shar: over-writing existing file "'Makefile.diff'" fi cat << \SHAR_EOF > 'Makefile.diff' *** ../f77/src/f77pass1/Makefile.orig Tue Oct 29 15:16:19 1985 --- ../f77/src/f77pass1/Makefile Tue Oct 29 15:23:17 1985 *************** *** 2,8 # CFLAGS = -O -DHERE=VAX -DTARGET=VAX -DFAMILY=PCC -DUCBVAXASM -DUCBPASS2 \ ! -I../../include DEST = $(DESTROOT)/usr/lib --- 2,8 ----- # CFLAGS = -O -DHERE=VAX -DTARGET=VAX -DFAMILY=PCC -DUCBVAXASM -DUCBPASS2 \ ! -DGFLOAT -I../../include DEST = $(DESTROOT)/usr/lib SHAR_EOF chmod +x 'Makefile.diff' if test -f 'conv.h.diff' then echo shar: over-writing existing file "'conv.h.diff'" fi cat << \SHAR_EOF > 'conv.h.diff' *** ../f77/src/f77pass1/conv.h.orig Tue Oct 29 15:15:46 1985 --- ../f77/src/f77pass1/conv.h Tue Oct 29 15:22:26 1985 *************** *** 20,25 #define MINWORD -32768 typedef struct Dreal { unsigned fract1: 7; --- 20,26 ----- #define MINWORD -32768 typedef + #ifndef GFLOAT struct Dreal { unsigned fract1: 7; *************** *** 24,29 { unsigned fract1: 7; unsigned exp: 8; unsigned sign: 1; unsigned fract2: 16; unsigned fract3: 16; --- 25,36 ----- { unsigned fract1: 7; unsigned exp: 8; + #else GFLOAT + struct Greal + { + unsigned fract1: 4; + unsigned exp: 11; + #endif GFLOAT unsigned sign: 1; unsigned fract2: 16; unsigned fract3: 16; *************** *** 29,34 unsigned fract3: 16; unsigned fract4: 16; } dreal; typedef --- 36,42 ----- unsigned fract3: 16; unsigned fract4: 16; } + #ifndef GFLOAT dreal; #else GFLOAT greal; *************** *** 30,35 unsigned fract4: 16; } dreal; typedef struct Quad --- 38,46 ----- } #ifndef GFLOAT dreal; + #else GFLOAT + greal; + #endif GFLOAT typedef struct Quad *************** *** 40,45 quad; typedef union RealValue { double d; --- 51,69 ----- quad; typedef + #ifdef GFLOAT + struct Freal + { + unsigned fract1: 7; + unsigned exp: 8; + unsigned sign: 1; + unsigned fract2: 16; + unsigned fract3: 16; + unsigned fract4: 16; + } + freal; + typedef + #endif GFLOAT union RealValue { double d; *************** *** 44,49 { double d; quad q; dreal f; } realvalue; --- 68,74 ----- { double d; quad q; + #ifndef GFLOAT dreal f; #else GFLOAT freal f; *************** *** 45,49 double d; quad q; dreal f; } realvalue; --- 70,78 ----- quad q; #ifndef GFLOAT dreal f; + #else GFLOAT + freal f; + greal g; + #endif GFLOAT } realvalue; SHAR_EOF chmod +x 'conv.h.diff' chdir .. chdir .. chdir .. if test -f 'modf.s' then echo shar: over-writing existing file "'modf.s'" fi cat << \SHAR_EOF > 'modf.s' /* modf.s 4.1 83/06/27 */ /* NOTE (Apr. 1985): wrtfmt.o calls ecvt in libc.a which calls modf. This is a modified source that works only for G-format. */ /* * double modf (value, iptr) * double value, *iptr; * * Modf returns the fractional part of "value", * and stores the integer part indirectly through "iptr". */ /* #include "DEFS.h" */ #define ENTRY(x) .globl _/**/x; .align 2; _/**/x: .word 0 ENTRY(modf) emodg 4(ap),$0,$0g1.0,r2,r0 jvs 1f # integer overflow cvtlg r2,*12(ap) ret 1: subg3 r0,4(ap),*12(ap) ret SHAR_EOF chmod +x 'modf.s' if test -f 'NOTE' then echo shar: over-writing existing file "'NOTE'" fi cat << \SHAR_EOF > 'NOTE' NOTE (UW, Apr. 1985): wrtfmt.o calls ecvt in libc.a which calls modf. Modf must be replaced by a version corrected for G-format uVaxes. A source that works is included in this directory. The f77 built-in functions (sin(x), etc) use the C math library and are subject to the bugs in it. As a beginning, re-compile sin.c without optimization. SHAR_EOF chmod +x 'NOTE' if test ! -d 'libU77' then mkdir 'libU77' fi cd 'libU77' if test -f 'dtime_.c.diff' then echo shar: over-writing existing file "'dtime_.c.diff'" fi cat << \SHAR_EOF > 'dtime_.c.diff' 29a30,34 > #ifdef GFLOAT > union { double d; > float r[2]; > } res; > #endif GFLOAT 35a41,44 > #ifdef GFLOAT > res.r[0] = (dt->usrtime + dt->systime); > return( res.d ); > #else GFLOAT 36a46 > #endif GFLOAT SHAR_EOF chmod +x 'dtime_.c.diff' if test -f 'Makefile.diff' then echo shar: over-writing existing file "'Makefile.diff'" fi cat << \SHAR_EOF > 'Makefile.diff' 6c6 < CFLAGS = -O --- > CFLAGS = -O -DGFLOAT SHAR_EOF chmod +x 'Makefile.diff' chdir .. if test ! -d 'f77.gfloat' then mkdir 'f77.gfloat' fi cd 'f77.gfloat' if test -f 'Makefile' then echo shar: over-writing existing file "'Makefile'" fi cat << \SHAR_EOF > 'Makefile' PROGRAMS = f77 f77pass1 f1 f2 fpr fsplit libF77.a libI66.a libI77.a \ libU77.a modf.o install: $(PROGRAMS) @echo Installing f77 in /usr/bin install f77 /usr/bin @echo Installing f77pass1 in /usr/lib install f77pass1 /usr/lib @echo Installing f1 in /lib @install f1 /lib @echo Installing f2 in /lib @install f2 /lib @echo Installing fpr in /usr/ucb @install fpr /usr/ucb @echo Installing fsplit in /usr/ucb @install fsplit /usr/ucb @echo Installing libF77.a in /usr/lib install -m 644 libF77.a /usr/lib ranlib /usr/lib/libF77.a @echo Installing libI77.a in /usr/lib install -m 644 libI77.a /usr/lib ranlib /usr/lib/libI77.a @echo Installing libU77.a in /usr/lib install -m 644 libU77.a /usr/lib ranlib /usr/lib/libU77.a @echo Installing libI66.a in /usr/lib install -m 644 libI66.a /usr/lib @echo Fixing modf.o in /lib/libc.a mv modf.o /lib ar r /lib/libc.a /lib/modf.o ranlib /lib/libc.a rm /lib/modf.o collect: cp /usr/bin/f77 . cp /usr/lib/f77pass1 . cp /lib/f1 . cp /lib/f2 . cp /usr/ucb/fpr . cp /usr/ucb/fsplit . cp /usr/lib/libF77.a . cp /usr/lib/libI77.a . cp /usr/lib/libU77.a . cp /usr/lib/libI66.a . ar x /lib/libc.a modf.o 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 the modified executable code and libraries for f77 to run on a G-float Vax, such as the majority of early microvaxes. It also contains a modified modf.o for /lib/libc.a, which contains a bug in Ultrix 1.0. 1. Log on or su as root, and copy this directory to the G-format machine. 2. Type make install from this directory. 3. Stand well back. 4. NOTE that the contents of this directory will be moved to the appropriate places, and will no longer exist here. 5. NOTE ALSO that the f77 built-in math functions access the C math library, and the bugs therein. SHAR_EOF chmod +x 'READ_ME' chdir .. if test -f 'tog.p' then echo shar: over-writing existing file "'tog.p'" fi cat << \SHAR_EOF > 'tog.p' program torig( input, output ); { This Pascal program will convert #ifdef GFLOAT files to pure g-float files. There is no pretense of efficiency.} const buflen=133; type bufstr=packed array[1..buflen] of char; var buf: bufstr; linlen: integer; procedure rdbuf; begin linlen := 0; if not eof then while not eoln do begin linlen := linlen+1; read( buf[linlen] ) end; if not eof then readln end; procedure wrtbuf; begin if linlen=0 then writeln else writeln( buf:linlen ) end; function match( strng: bufstr; len: integer ): boolean; var ok: boolean; i: integer; begin i := 1; ok := true; while ok and (i<=len) do begin ok := (strng[i]=buf[i]); i := i+1 end; match := ok end; begin { torig } while not eof do begin rdbuf; if match('#ifdef GFLOAT',13) then repeat rdbuf; if match('#else GFLOAT',12) then repeat rdbuf until match('#endif GFLOAT',13) else if not match('#endif GFLOAT',13) then wrtbuf until match('#endif GFLOAT',13) else if match('#ifndef GFLOAT',14) then repeat rdbuf; if match('#else GFLOAT',12) then begin rdbuf; while not match('#endif GFLOAT',13) do begin wrtbuf; rdbuf end end until match('#endif GFLOAT',13) else wrtbuf end end. SHAR_EOF chmod +x 'tog.p' chdir .. # End of shell archive exit 0