./asvax/mi/old/assyms.c
		case STABFLOATING:	return("stabfloating");
			yyerror("Illegal Relocation of floating or large int number.");

./asvax/mi/old/bignum2.c
Bignum floatconvert(number, convto)
	default:	panic("Bad floating point conversion?");
			 *	floating point unpacked: 0.{1}111111111
		printf(" == %10.8e", number.num_num.numFf_float.Ff_value);
		printf(" == %20.17e", number.num_num.numFd_float.Fd_value);
		OVF_F,		"F float",
		OVF_D,		"D float",
		OVF_G,		"G float",
		OVF_H,		"H float",

./asvax/mi/ascode.c
 *	float: TYPF, TYPD, TYPG, TYPH
 *	argtype		float	quad	int
 *	float		slitflt	slitflt	slitflt

./asvax/mi/asexpr.c
	IFFLOAT,	DIRECT,	".ffloat",
	IDFLOAT,	DIRECT,	".dfloat",
	IGFLOAT,	DIRECT,	".gfloat",
	IHFLOAT,	DIRECT,	".hfloat",

./asvax/mi/asjxxx.c
		if (tag >= OKTOBUMP)	/*only bump labels and jxxxes and floating stabs*/

./asvax/mi/asmain.c
		yywarning("Caution: G or H format floating point numbers");
		yywarning("Caution: G or H format floating point operators");

./asvax/mi/asparse.c
 *	A stab that is tagged floating will be bumped during
				ERROR(ty_float[toconv]
				   ? "floating number expected"

./asvax/mi/asscan4.c
		Bignum	floatnumber();
		case 'F': ch = 'f';	goto floatnum;
		case 'D': ch = 'd';	goto floatnum;
		case 'H': ch = 'h';	goto floatnum;
		case 'G': ch = 'g';	goto floatnum;
  floatnum: ;
	yybignum = floatnumber(ch);
Bignum floatnumber(fltradix)
		 *	overflow is set on floating overflow.
		yyerror("Badly formatted floating point number.");

./asvax/mi/assizetab.c
 *	Convert TYP[BWLQOFDGH] into {1 if a floating point number}
int	ty_float[] = {
	"f_float",	/* TYPF */
	"d_float",	/* TYPD */
	"g_float",	/* TYPG */
	"h_float",	/* TYPH */

./asvax/mi/assyms.c
		case STABFLOATING:	return("stabfloating");
			yyerror("Illegal Relocation of floating or large int number.");

./asvax/mi/bignum1.c
 *	Construct a floating point number
		number.num_num.numFd_float.Fd_value = atof(numbuf);
 *	Determine if floating point numbers are
	if (!ty_float[argtype])
	assert(ovf == 0, "overflow in unpacking floating #!?");
 *	(for example .float, .double), or from the operand size
 *	patterns for floating point numbers.
 *	If the number is one of the floating types and the conversion
		number = floatconvert(number, toconv);

./asvax/mi/bignum2.c
Bignum floatconvert(number, convto)
	default:	panic("Bad floating point conversion?");
			 *	floating point unpacked: 0.{1}111111111
		printf(" == %10.8e", number.num_num.numFf_float.Ff_value);
		printf(" == %20.17e", number.num_num.numFd_float.Fd_value);
		OVF_F,		"F float",
		OVF_D,		"D float",
		OVF_G,		"G float",
		OVF_H,		"H float",

./asvax/mi/floattab.c
static char sccsid[] = "@(#)floattab.c 4.3 2/14/82";
cfloattab()
		extern	int	ty_float[];
		if (!ty_float[i])

./asvax/mi/natof.c
	 *	We now must convert the number to standard format floating

./bits/mi/fontio.c
float DesignSize = 10.0;
float TFMscaling = InitTFMscaling;
    float ratio;
    float oldTFMscaling = TFMscaling;

./build/mi/files.c
static  umatch (s, p)		/* unanchored (floating) match of p in string s

./build/mi/ident.c
2.16		Removed references to double floats and macro HAVELONGS;

./c2vax/mi/c21.c
				 * However, if the CVT is from a float or

./cc68/ccom/mi/allo.c
	/* p gives the type, if floating */

./cc68/ccom/mi/local.c
isitfloat( s ) char *s; {

./cc68/ccom/mi/local2.c
	 * MMT - replaced fltused by floatUsed to resolve a naming collision.
	if( floatUsed ) {
		floatUsed = 0;
/* do fix and float conversions */
	strcpy( q->in.name, m ? "float" : "fix" );
	q->in.name = m ? "float" : "fix";
floatconv( p )
	 * The following valiant attempt at optimizing floating
	 * compares depends on the floating representation to be
	if ( floatconv(p->in.left) && floatconv(p->in.right) )

./cc68/ccom/mi/order.c
int floatUsed = 0;		/* MMT - fltused -> floatUsed because of a
	/* zap Sethi-Ullman number for chars, longs, floats */
		++floatUsed;

./cc68/ccom/mi/scan.c
				return( isitfloat( yytext ) );
			/* look for a dot: if followed by a digit, floating point */
	"float",	AR_TY,	FLOAT,

./cc68/ccom/mi/stab.c
    maketype("float", builtintype(FLOAT), t_int, 4L, 0L);

./cc68/ccom/mi/trees.c
		if any float or doubles, make double

./ccvax/mi/ccvax.c
int	floatflag = 0;	/* use G floating point? */
			/* pass -XF to ccom, use G floating point */
				floatflag++;
				floatflag = -1; /* HACK */
		floatflag++;
		if (floatflag) /* Schuster */

./checkers/mi/treetop.c
     *	         count*(sizeof(float)))) != OK)

./debug/vax/disasm.c
    FFLTTYPE,   4,      /* TYPF F float */
    DFLTTYPE,   8,      /* TYPD D float */
    GFLTTYPE,   8,      /* TYPG G float */
    HFLTTYPE,   16,     /* TYPH H float */
    type = ot->oper_type;   /* Type of operand (eg byte, d_float) */
		/* Until GetMem is modified to deal with floating point... */
				but is only temporary until floating point
		    strput("(floating number)");

./demo/condense.c
    float x,y,z;

./demo/datsun.c
    float x,y;

./draw/mi/load.c
    int getfloat();
    int getfloat();
		pptr[i].x=getfloat(fp)+ALTO_LEFT_MARGIN;
		pptr[i].y=getfloat(fp)+ALTO_BOTTOM_MARGIN;
 * get a BCPL packed floating point number from standard input and return
int getfloat(fp)

./draw/mi/menu.c
    float xsize,ysize;

./draw/mi/nouns.c
	/* Calculate the angles needed, using (groan) floating point */

./draw/mi/spline.c
 *  floating point computation can be avoided as much as possible at

./draw/mi/splinedefs.c
 *  and then multiplied by 1<<16 to avoid floating calculations.

./draw/mi/writepsm.c
float *xsize,*ysize;

./freemem/mi/freemem.c
	float   mem[75];
	float   memlevel;
	float   oldlevel;

./hack/mi/hack.do.c
		pline("You're floating high above the stairs.");

./hack/mi/hack.do_wear.c
		if(!oldprop) float_up();
		if(!Levitation) {	/* no longer floating */
			float_down();

./hack/mi/hack.fight.c
	      pline("You are frozen by the floating eye's gaze!");
	      pline("The blinded floating eye cannot defend itself.");

./hack/mi/hack.monst.c
	{ "floating eye",	'E',2,1,9,0,0,0 },

./hack/mi/hack.potion.c
extern int float_down();
			float_up();
		u.uprops[PROP(RIN_LEVITATION)].p_tofn = float_down;

./hack/mi/hack.trap.c
				pline("You float over a bear trap.");
			/* there should be a mtmp/data -> floating */
float_up(){
			pline("You float up, out of the pit!");
			pline("You float up, only your leg is still stuck.");
		pline("You start to float in the air!");
float_down(){
	pline("You float gently to the ground.");
		pline("You float gently down to earth.");

./emacs/mi/TrmTERM.c
static float BaudFactor;
float   f; {

./emacs/misc/Support/loadst.c
	float   avenrun[3];

./olddraw/create.c
	    /* Calculate the angles needed, using (groan) floating point */

./olddraw/load.c
    int getfloat();
    int getfloat();
		pptr[i].x=getfloat(fp)+ALTO_LEFT_MARGIN;
		pptr[i].y=getfloat(fp)+ALTO_BOTTOM_MARGIN;
 * get a BCPL packed floating point number from standard input and return
int getfloat(fp)

./olddraw/spline.c
 *  floating point computation can be avoided as much as possible at

./olddraw/splinedefs.c
 *  and then multiplied by 1<<16 to avoid floating calculations.

./pccmip/mi/allo.c
	/* p gives the type, if floating */

./pccmip/mi/scan.c
				return( isitfloat( yytext ) );
			/* look for a dot: if followed by a digit, floating point */
	"float",	AR_TY,	FLOAT,

./pccmip/mi/trees.c
		if any float or doubles, make double

./pccvax/mi/local.c
	printf("	%s	0%c%.20e\n", sz == SZDOUBLE ? ".double" : ".float",
isitfloat( s ) char *s; {

./pccvax/mi/order.c
	p->in.su = szty( p->in.type );   /* 2 for float or double, else 1 */;

./pccvax/mi/stab.c
    maketype("float", builtintype(FLOAT), t_int, 4L, 0L);

./show/mi/bcpl.c
 *	BCPLtoCfloat	- convert floating point numbers
/* BCPLtoCfloat(bfl):
 * 	into a VAX C float.
float BCPLtoCfloat(bfl)
    /* mantissa / 2**23 is the true floating point fraction */
    return ((float) (power * (((float) mantissa) / ((float) 0x00800000L))));
  } /* BCPLtoCfloat */

./show/mi/fonts.c
		fnt->scaleFactor = sizeInMicas*PointsPerMica*(float)(1<<16);

./show/mi/press.c
        float BCPLtoCfloat();	/* for DrawCurve arguments */
                                c1.x = BCPLtoCfloat(GetDouble());
                                c1.y = BCPLtoCfloat(GetDouble());
                                c2.x = BCPLtoCfloat(GetDouble());
                                c2.y = BCPLtoCfloat(GetDouble());
                                c3.x = BCPLtoCfloat(GetDouble());
                                c3.y = BCPLtoCfloat(GetDouble());

./show/mi/show.c
float TrueConv;
struct MagTextField { char fmt[15]; float mag}

./swatch/mi/memwatch.c
    float mem[75] ;

./swatch/mi/mon.c
    float mem[75] ;
    float proc[75] ;
    float factor ;

./swatch/mi/procwatch.c
    float proc[75] ;
    float factor ;

./team1/mi/small.c
 * 6/83 Marvin Theimer - Added additional Dummy defns. to insure that float.c
Dummy(float)

