Refacter the bits.c stuff to eliminate ugly globals...

...and be more explicit about operand sizes.

All regressuion tests [ass, code splints clean.

8 files changed, 172 insertions, 146 deletions

diff --git a/bits.c b/bits.c
index d700daac..e6938501 100644
--- a/bits.c
+++ b/bits.c
@@ -73,6 +73,59 @@ int64_t sbits(char buf[], unsigned int start, unsigned int width, bool le)
     /*@ -relaxtypes */
 }
 
+union int_float {
+    int32_t i;
+    float f;
+};
+
+union long_double {
+    int64_t l;
+    double d;
+};
+
+float getlef32(const char *buf, int off)
+{
+    union int_float i_f;
+
+    i_f.i = getles32(buf, off);
+    return i_f.f;
+}
+ 
+double getled64(const char *buf, int off)
+{
+    union long_double l_d;
+
+    l_d.l = getles64(buf, off);
+    return l_d.d;
+}
+
+float getbef32(const char *buf, int off)
+{
+    union int_float i_f;
+
+    i_f.i = getbes32(buf, off);
+    return i_f.f;
+}
+
+double getbed64(const char *buf, int off)
+{
+    union long_double l_d;
+
+    l_d.l = getbes64(buf, off);
+    return l_d.d;
+}
+
+/*@-shiftimplementation@*/
+void putbef32(char *buf, int off, float val)
+{
+    union int_float i_f;
+
+    i_f.f = val;
+    /* this would be a putbe32 call if not for a signedness issue */ 
+    buf[off] = (char)(((i_f.i) >> 16) >> 8);
+}
+/*@+shiftimplementation@*/
+
 #ifdef __UNUSED__
 // cppcheck-suppress unusedFunction
 u_int16_t swap_u16(u_int16_t i)
@@ -85,7 +138,7 @@ u_int16_t swap_u16(u_int16_t i)
  
     return (c1 << 8) + c2;
 }
- 
+
 // cppcheck-suppress unusedFunction
 u_int32_t swap_u32(u_int32_t i) 
 /* byte-swap a 32-bit unsigned int */
diff --git a/bits.h b/bits.h
index a9534142..858a72f1 100644
--- a/bits.h
+++ b/bits.h
@@ -16,16 +16,6 @@
 
 #include <stdint.h>
 
-union int_float {
-    int32_t i;
-    float f;
-};
-
-union long_double {
-    int64_t l;
-    double d;
-};
-
 /* these are independent of byte order */
 #define getsb(buf, off)	((int8_t)buf[off])
 #define getub(buf, off)	((uint8_t)buf[off])
@@ -42,10 +32,9 @@ union long_double {
 #define getles64(buf, off)	((int64_t)(((uint64_t)getleu32(buf, (off)+4) << 32) | getleu32(buf, (off))))
 #define getleu64(buf, off)	((uint64_t)(((uint64_t)getleu32(buf, (off)+4) << 32) | getleu32(buf, (off))))
 
-#define getlef(buf, off)	(i_f.i = getles32(buf, off), i_f.f)
-#define getled(buf, off)	(l_d.l = getles64(buf, off), l_d.d)
+extern float getlef32(const char *, int); 
+extern double getled64(const char *, int);
 
-/* SiRF and most other GPS protocols use big-endian (network byte order) */
 #define getbes16(buf, off)	((int16_t)(((uint16_t)getub(buf, (off)) << 8) | (uint16_t)getub(buf, (off)+1)))
 #define getbeu16(buf, off)	((uint16_t)(((uint16_t)getub(buf, (off)) << 8) | (uint16_t)getub(buf, (off)+1)))
 #define getbes32(buf, off)	((int32_t)(((uint16_t)getbeu16(buf, (off)) << 16) | getbeu16(buf, (off)+2)))
@@ -56,8 +45,10 @@ union long_double {
 #define putbe16(buf,off,w) do {putbyte(buf, (off), (w) >> 8); putbyte(buf, (off)+1, (w));} while (0)
 #define putbe32(buf,off,l) do {putbe16(buf, (off), (l) >> 16); putbe16(buf, (off)+2, (l));} while (0)
 
-#define getbef(buf, off)	(i_f.i = getbes32(buf, off), i_f.f)
-#define getbed(buf, off)	(l_d.l = getbes64(buf, off), l_d.d)
+extern float getbef32(const char *, int); 
+extern double getbed64(const char *, int);
+
+extern void putbef32(char *, int, float);
 
 /* bitfield extraction */
 extern uint64_t ubits(char buf[], unsigned int, unsigned int, bool);
diff --git a/driver_geostar.c b/driver_geostar.c
index 12660194..2a3d7e88 100644
--- a/driver_geostar.c
+++ b/driver_geostar.c
@@ -126,7 +126,6 @@ static gps_mask_t geostar_analyze(struct gps_device_t *session)
     uint16_t uw1, uw2;
     uint32_t ul1, ul2, ul3, ul4, ul5;
     double d1, d2, d3, d4, d5;
-    union long_double l_d;
     unsigned char buf[BUFSIZ];
     char buf2[BUFSIZ];
 
@@ -172,29 +171,29 @@ static gps_mask_t geostar_analyze(struct gps_device_t *session)
 	gpsd_report(LOG_INF, "GLONASS sub-frame data\n");
 	break;
     case 0x13:
-	d1 = getled(buf, OFFSET(1));
-	d2 = getled(buf, OFFSET(3));
-	d3 = getled(buf, OFFSET(5));
-	d4 = getled(buf, OFFSET(29)); /* GPS time */
-	d5 = getled(buf, OFFSET(31)); /* GLONASS time */
+	d1 = getled64(buf, OFFSET(1));
+	d2 = getled64(buf, OFFSET(3));
+	d3 = getled64(buf, OFFSET(5));
+	d4 = getled64(buf, OFFSET(29)); /* GPS time */
+	d5 = getled64(buf, OFFSET(31)); /* GLONASS time */
 	gpsd_report(LOG_INF, "ECEF coordinates %g %g %g %f %f\n", d1, d2, d3, d4, d5);
 	break;
     case 0x20:
-	d1 = getled(buf, OFFSET(1)); /* time */
+	d1 = getled64(buf, OFFSET(1)); /* time */
 
 	session->newdata.time = d1 + JAN_2008;
-	session->newdata.latitude = getled(buf, OFFSET(3)) * RAD_2_DEG;
-	session->newdata.longitude = getled(buf, OFFSET(5)) * RAD_2_DEG;
-	session->newdata.altitude = getled(buf, OFFSET(7));
-	session->gpsdata.separation = getled(buf, OFFSET(9));
+	session->newdata.latitude = getled64(buf, OFFSET(3)) * RAD_2_DEG;
+	session->newdata.longitude = getled64(buf, OFFSET(5)) * RAD_2_DEG;
+	session->newdata.altitude = getled64(buf, OFFSET(7));
+	session->gpsdata.separation = getled64(buf, OFFSET(9));
 	session->gpsdata.satellites_used = (int)getles32(buf, OFFSET(11));
-	session->gpsdata.dop.gdop = getled(buf, OFFSET(13));
-	session->gpsdata.dop.pdop = getled(buf, OFFSET(15));
-	session->gpsdata.dop.tdop = getled(buf, OFFSET(17));
-	session->gpsdata.dop.hdop = getled(buf, OFFSET(19));
-	session->gpsdata.dop.vdop = getled(buf, OFFSET(21));
-	session->newdata.speed = getled(buf, OFFSET(31));
-	session->newdata.track = getled(buf, OFFSET(33)) * RAD_2_DEG;
+	session->gpsdata.dop.gdop = getled64(buf, OFFSET(13));
+	session->gpsdata.dop.pdop = getled64(buf, OFFSET(15));
+	session->gpsdata.dop.tdop = getled64(buf, OFFSET(17));
+	session->gpsdata.dop.hdop = getled64(buf, OFFSET(19));
+	session->gpsdata.dop.vdop = getled64(buf, OFFSET(21));
+	session->newdata.speed = getled64(buf, OFFSET(31));
+	session->newdata.track = getled64(buf, OFFSET(33)) * RAD_2_DEG;
 
 	ul1 = getleu32(buf, OFFSET(29)); /* status */
 
@@ -369,9 +368,9 @@ static gps_mask_t geostar_analyze(struct gps_device_t *session)
 	gpsd_report(LOG_INF, "Response to Query GPS ephemerides\n");
 	break;
     case 0x8b:
-	d1 = getled(buf, OFFSET(23));
-	d2 = getled(buf, OFFSET(25));
-	d3 = getled(buf, OFFSET(27));
+	d1 = getled64(buf, OFFSET(23));
+	d2 = getled64(buf, OFFSET(25));
+	d3 = getled64(buf, OFFSET(27));
 	gpsd_report(LOG_INF, "Response to Query GLONASS ephemerides %g %g %g\n",
 		    d1, d2, d3);
 	break;
diff --git a/driver_italk.c b/driver_italk.c
index 0fdf863b..e9fac792 100644
--- a/driver_italk.c
+++ b/driver_italk.c
@@ -233,7 +233,6 @@ static gps_mask_t decode_itk_pseudo(struct gps_device_t *session,
 				      unsigned char *buf, size_t len)
 {
     unsigned short flags, n, i;
-    union long_double l_d;
 
     n = (ushort) getleu16(buf, 7 + 4);
     if ((n < 1) || (n > MAXCHANNELS)){
@@ -260,8 +259,8 @@ static gps_mask_t decode_itk_pseudo(struct gps_device_t *session,
 	session->gpsdata.PRN[i] = getleu16(buf, 7 + 26 + (i*36)) & 0xff;
 	session->gpsdata.ss[i] = getleu16(buf, 7 + 26 + (i*36 + 2)) & 0x3f;
 	session->gpsdata.raw.satstat[i] = getleu32(buf, 7 + 26 + (i*36 + 4));
-	session->gpsdata.raw.pseudorange[i] = getled(buf, 7 + 26 + (i*36 + 8));
-	session->gpsdata.raw.doppler[i] = getled(buf, 7 + 26 + (i*36 + 16));
+	session->gpsdata.raw.pseudorange[i] = getled64(buf, 7 + 26 + (i*36 + 8));
+	session->gpsdata.raw.doppler[i] = getled64(buf, 7 + 26 + (i*36 + 16));
 	session->gpsdata.raw.carrierphase[i] = getleu16(buf, 7 + 26 + (i*36 + 28));
 
 	session->gpsdata.raw.mtime[i] = session->newdata.time;
diff --git a/driver_navcom.c b/driver_navcom.c
index 655c745c..f9c601a8 100644
--- a/driver_navcom.c
+++ b/driver_navcom.c
@@ -888,22 +888,21 @@ static gps_mask_t handle_0xb5(struct gps_device_t *session)
 {
     if (sizeof(double) == 8) {
 	gps_mask_t mask = TIME_SET;
-	union long_double l_d;
-	unsigned char *buf = session->packet.outbuffer + 3;
+	char *buf = (char *)session->packet.outbuffer + 3;
 	uint16_t week = getleu16(buf, 3);
 	uint32_t tow = getleu32(buf, 5);
-	double rms = getled(buf, 9);
+	double rms = getled64(buf, 9);
 #ifdef __UNUSED__
 	/* Reason why it's unused is these figures do not agree
 	 * with those obtained from the PVT report (handle_0xb1).
 	 * The figures from 0xb1 do agree with the values reported
 	 * by Navcom's PC utility */
-	//double ellips_maj = getled(buf, 17);
-	//double ellips_min = getled(buf, 25);
-	//double ellips_azm = getled(buf, 33);
-	double lat_sd = getled(buf, 41);
-	double lon_sd = getled(buf, 49);
-	double alt_sd = getled(buf, 57);
+	//double ellips_maj = getled64(buf, 17);
+	//double ellips_min = getled64(buf, 25);
+	//double ellips_azm = getled64(buf, 33);
+	double lat_sd = getled64(buf, 41);
+	double lon_sd = getled64(buf, 49);
+	double alt_sd = getled64(buf, 57);
 	double hrms = sqrt(pow(lat_sd, 2) + pow(lon_sd, 2));
 #endif /*  __UNUSED__ */
 	session->gpsdata.epe = rms * 1.96;
@@ -1082,20 +1081,18 @@ static gps_mask_t handle_0xef(struct gps_device_t *session)
     //uint32_t tow = getleu32(buf, 5);
     int8_t osc_temp = getsb(buf, 9);
     uint8_t nav_status = getub(buf, 10);
-    union long_double l_d;
     double nav_clock_offset;
-    union int_float i_f;
     float nav_clock_drift;
     float osc_filter_drift_est;
     int32_t time_slew = (int32_t) getles32(buf, 27);
     if (sizeof(double) == 8) {
-	nav_clock_offset = getled(buf, 11);
+	nav_clock_offset = getled64((char *)buf, 11);
     } else {
 	nav_clock_offset = NAN;
     }
     if (sizeof(float) == 4) {
-	nav_clock_drift = getlef(buf, 19);
-	osc_filter_drift_est = getlef(buf, 23);
+	nav_clock_drift = getlef32((char *)buf, 19);
+	osc_filter_drift_est = getlef32((char *)buf, 23);
     } else {
 	nav_clock_drift = NAN;
 	osc_filter_drift_est = NAN;
diff --git a/driver_superstar2.c b/driver_superstar2.c
index ad174fc0..b92340e2 100644
--- a/driver_superstar2.c
+++ b/driver_superstar2.c
@@ -74,8 +74,6 @@ superstar2_msg_navsol_lla(struct gps_device_t *session,
 {
     gps_mask_t mask;
     unsigned char flags;
-    union int_float i_f;
-    union long_double l_d;
     double d;
     struct tm tm;
 
@@ -95,7 +93,7 @@ superstar2_msg_navsol_lla(struct gps_device_t *session,
     (void)memset(&tm, '\0', sizeof(tm));
     tm.tm_hour = (int)getub(buf, 4) & 0x1f;
     tm.tm_min = (int)getub(buf, 5);
-    d = getled(buf, 6);
+    d = getled64((char *)buf, 6);
     tm.tm_sec = (int)d;
     tm.tm_mday = (int)getub(buf, 14);
     tm.tm_mon = (int)getub(buf, 15) - 1;
@@ -104,12 +102,12 @@ superstar2_msg_navsol_lla(struct gps_device_t *session,
     mask |= TIME_SET | PPSTIME_IS;
 
     /* extract the local tangential plane (ENU) solution */
-    session->newdata.latitude = getled(buf, 18) * RAD_2_DEG;
-    session->newdata.longitude = getled(buf, 26) * RAD_2_DEG;
-    session->newdata.altitude = getlef(buf, 34);
-    session->newdata.speed = getlef(buf, 38);
-    session->newdata.track = getlef(buf, 42) * RAD_2_DEG;
-    session->newdata.climb = getlef(buf, 54);
+    session->newdata.latitude = getled64((char *)buf, 18) * RAD_2_DEG;
+    session->newdata.longitude = getled64((char *)buf, 26) * RAD_2_DEG;
+    session->newdata.altitude = getlef32((char *)buf, 34);
+    session->newdata.speed = getlef32((char *)buf, 38);
+    session->newdata.track = getlef32((char *)buf, 42) * RAD_2_DEG;
+    session->newdata.climb = getlef32((char *)buf, 54);
     mask |= LATLON_SET | ALTITUDE_SET | SPEED_SET | TRACK_SET | CLIMB_SET;
 
     session->gpsdata.satellites_used = (int)getub(buf, 71) & 0x0f;
@@ -244,7 +242,6 @@ superstar2_msg_timing(struct gps_device_t *session, unsigned char *buf,
 		      size_t data_len)
 {
     gps_mask_t mask;
-    union long_double l_d;
     struct tm tm;
 
     if (data_len != 65)
@@ -265,7 +262,7 @@ superstar2_msg_timing(struct gps_device_t *session, unsigned char *buf,
 
 	tm.tm_hour = (int)getsb(buf, 41);
 	tm.tm_min = (int)getsb(buf, 42);
-	d = getled(buf, 43);
+	d = getled64((char *)buf, 43);
 	tm.tm_sec = (int)d;
 	session->newdata.time = (timestamp_t)timegm(&tm);
 	session->context->leap_seconds = (int)getsb(buf, 20);
@@ -287,7 +284,6 @@ superstar2_msg_measurement(struct gps_device_t *session, unsigned char *buf,
     int i, n;
     unsigned long ul;
     double t;
-    union long_double l_d;
 
     gpsd_report(LOG_PROG, "superstar2 #23 - measurement block\n");
 
@@ -296,7 +292,7 @@ superstar2_msg_measurement(struct gps_device_t *session, unsigned char *buf,
 	gpsd_report(LOG_INF, "too many measurements\n");
 	return 0;
     }
-    t = getled(buf, 7);		/* measurement time */
+    t = getled64((char *)buf, 7);		/* measurement time */
     for (i = 0; i < n; i++) {
 	session->gpsdata.raw.mtime[i] = t;
 	session->gpsdata.PRN[i] = (int)getub(buf, 11 * i + 15) & 0x1f;
diff --git a/driver_tsip.c b/driver_tsip.c
index 74d795f5..34910ebe 100644
--- a/driver_tsip.c
+++ b/driver_tsip.c
@@ -125,8 +125,6 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
     uint32_t ul1, ul2;
     float f1, f2, f3, f4, f5;
     double d1, d2, d3, d4, d5;
-    union int_float i_f;
-    union long_double l_d;
     time_t now;
     unsigned char buf[BUFSIZ];
     char buf2[BUFSIZ];
@@ -185,9 +183,9 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
 	if (len != 10)
 	    break;
 	session->driver.tsip.last_41 = now;	/* keep timestamp for request */
-	f1 = getbef(buf, 0);	/* gpstime */
+	f1 = getbef32(buf, 0);	/* gpstime */
 	s1 = getbes16(buf, 4);	/* week */
-	f2 = getbef(buf, 6);	/* leap seconds */
+	f2 = getbef32(buf, 6);	/* leap seconds */
 	if (f1 >= 0.0 && f2 > 10.0) {
 	    session->context->leap_seconds = (int)round(f2);
 	    session->context->valid |= LEAP_SECOND_VALID;
@@ -200,21 +198,21 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
     case 0x42:			/* Single-Precision Position Fix, XYZ ECEF */
 	if (len != 16)
 	    break;
-	f1 = getbef(buf, 0);	/* X */
-	f2 = getbef(buf, 4);	/* Y */
-	f3 = getbef(buf, 8);	/* Z */
-	f4 = getbef(buf, 12);	/* time-of-fix */
+	f1 = getbef32(buf, 0);	/* X */
+	f2 = getbef32(buf, 4);	/* Y */
+	f3 = getbef32(buf, 8);	/* Z */
+	f4 = getbef32(buf, 12);	/* time-of-fix */
 	gpsd_report(LOG_INF, "GPS Position XYZ %f %f %f %f\n", f1, f2, f3,
 		    f4);
 	break;
     case 0x43:			/* Velocity Fix, XYZ ECEF */
 	if (len != 20)
 	    break;
-	f1 = getbef(buf, 0);	/* X velocity */
-	f2 = getbef(buf, 4);	/* Y velocity */
-	f3 = getbef(buf, 8);	/* Z velocity */
-	f4 = getbef(buf, 12);	/* bias rate */
-	f5 = getbef(buf, 16);	/* time-of-fix */
+	f1 = getbef32(buf, 0);	/* X velocity */
+	f2 = getbef32(buf, 4);	/* Y velocity */
+	f3 = getbef32(buf, 8);	/* Z velocity */
+	f4 = getbef32(buf, 12);	/* bias rate */
+	f5 = getbef32(buf, 16);	/* time-of-fix */
 	gpsd_report(LOG_INF, "GPS Velocity XYZ %f %f %f %f %f\n", f1, f2, f3,
 		    f4, f5);
 	break;
@@ -258,7 +256,7 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
 	buf2[0] = '\0';
 	for (i = 0; i < count; i++) {
 	    u1 = getub(buf, 5 * i + 1);
-	    if ((f1 = getbef(buf, 5 * i + 2)) < 0)
+	    if ((f1 = getbef32(buf, 5 * i + 2)) < 0)
 		f1 = 0.0;
 	    for (j = 0; j < TSIP_CHANNELS; j++)
 		if (session->gpsdata.PRN[j] == (int)u1) {
@@ -280,11 +278,11 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
     case 0x4a:			/* Single-Precision Position LLA */
 	if (len != 20)
 	    break;
-	session->newdata.latitude = getbef(buf, 0) * RAD_2_DEG;
-	session->newdata.longitude = getbef(buf, 4) * RAD_2_DEG;
-	session->newdata.altitude = getbef(buf, 8);
-	//f1 = getbef(buf, 12);	clock bias */
-	f2 = getbef(buf, 16);	/* time-of-fix */
+	session->newdata.latitude = getbef32(buf, 0) * RAD_2_DEG;
+	session->newdata.longitude = getbef32(buf, 4) * RAD_2_DEG;
+	session->newdata.altitude = getbef32(buf, 8);
+	//f1 = getbef32(buf, 12);	clock bias */
+	f2 = getbef32(buf, 16);	/* time-of-fix */
 	if ((session->context->valid & GPS_TIME_VALID)!=0) {
 	    session->newdata.time = 
 		gpsd_gpstime_resolve(session,
@@ -352,11 +350,11 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
     case 0x56:			/* Velocity Fix, East-North-Up (ENU) */
 	if (len != 20)
 	    break;
-	f1 = getbef(buf, 0);	/* East velocity */
-	f2 = getbef(buf, 4);	/* North velocity */
-	f3 = getbef(buf, 8);	/* Up velocity */
-	f4 = getbef(buf, 12);	/* clock bias rate */
-	f5 = getbef(buf, 16);	/* time-of-fix */
+	f1 = getbef32(buf, 0);	/* East velocity */
+	f2 = getbef32(buf, 4);	/* North velocity */
+	f3 = getbef32(buf, 8);	/* Up velocity */
+	f4 = getbef32(buf, 12);	/* clock bias rate */
+	f5 = getbef32(buf, 16);	/* time-of-fix */
 	session->newdata.climb = f3;
 	/*@ -evalorder @*/
 	session->newdata.speed = sqrt(pow(f2, 2) + pow(f1, 2));
@@ -378,7 +376,7 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
 	    break;
 	u1 = getub(buf, 0);	/* Source of information */
 	u2 = getub(buf, 1);	/* Mfg. diagnostic */
-	f1 = getbef(buf, 2);	/* gps_time */
+	f1 = getbef32(buf, 2);	/* gps_time */
 	s1 = getbes16(buf, 6);	/* tsip.gps_week */
 	/*@ +charint @*/
 	if (getub(buf, 0) == 0x01)	/* good current fix? */
@@ -393,10 +391,10 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
     case 0x5a:			/* Raw Measurement Data */
 	if (len != 29)
 	    break;
-	f1 = getbef(buf, 5);	/* Signal Level */
-	f2 = getbef(buf, 9);	/* Code phase */
-	f3 = getbef(buf, 13);	/* Doppler */
-	d1 = getbed(buf, 17);	/* Time of Measurement */
+	f1 = getbef32(buf, 5);	/* Signal Level */
+	f2 = getbef32(buf, 9);	/* Code phase */
+	f3 = getbef32(buf, 13);	/* Doppler */
+	d1 = getbed64(buf, 17);	/* Time of Measurement */
 	gpsd_report(LOG_PROG, "Raw Measurement Data %d %f %f %f %f\n",
 		    getub(buf, 0), f1, f2, f3, d1);
 	break;
@@ -409,10 +407,10 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
 	u2 = getub(buf, 1);	/* chan */
 	u3 = getub(buf, 2);	/* Acquisition flag */
 	u4 = getub(buf, 3);	/* Ephemeris flag */
-	f1 = getbef(buf, 4);	/* Signal level */
-	f2 = getbef(buf, 8);	/* time of Last measurement */
-	d1 = getbef(buf, 12) * RAD_2_DEG;	/* Elevation */
-	d2 = getbef(buf, 16) * RAD_2_DEG;	/* Azimuth */
+	f1 = getbef32(buf, 4);	/* Signal level */
+	f2 = getbef32(buf, 8);	/* time of Last measurement */
+	d1 = getbef32(buf, 12) * RAD_2_DEG;	/* Elevation */
+	d2 = getbef32(buf, 16) * RAD_2_DEG;	/* Azimuth */
 	i = (int)(u2 >> 3);	/* channel number */
 	gpsd_report(LOG_INF,
 		    "Satellite Tracking Status: Ch %2d PRN %3d Res %d Acq %d Eph %2d SNR %4.1f LMT %.04f El %4.1f Az %5.1f\n",
@@ -470,10 +468,10 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
 	mask |= MODE_SET;
 #endif /* __UNUSED__ */
 	session->gpsdata.satellites_used = count;
-	session->gpsdata.dop.pdop = getbef(buf, 1);
-	session->gpsdata.dop.hdop = getbef(buf, 5);
-	session->gpsdata.dop.vdop = getbef(buf, 9);
-	session->gpsdata.dop.tdop = getbef(buf, 13);
+	session->gpsdata.dop.pdop = getbef32(buf, 1);
+	session->gpsdata.dop.hdop = getbef32(buf, 5);
+	session->gpsdata.dop.vdop = getbef32(buf, 9);
+	session->gpsdata.dop.tdop = getbef32(buf, 13);
 	/*@ -evalorder @*/
 	session->gpsdata.dop.gdop =
 	    sqrt(pow(session->gpsdata.dop.pdop, 2) +
@@ -531,22 +529,22 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
     case 0x83:			/* Double-Precision XYZ Position Fix and Bias Information */
 	if (len != 36)
 	    break;
-	d1 = getbed(buf, 0);	/* X */
-	d2 = getbed(buf, 8);	/* Y */
-	d3 = getbed(buf, 16);	/* Z */
-	d4 = getbed(buf, 24);	/* clock bias */
-	f1 = getbef(buf, 32);	/* time-of-fix */
+	d1 = getbed64(buf, 0);	/* X */
+	d2 = getbed64(buf, 8);	/* Y */
+	d3 = getbed64(buf, 16);	/* Z */
+	d4 = getbed64(buf, 24);	/* clock bias */
+	f1 = getbef32(buf, 32);	/* time-of-fix */
 	gpsd_report(LOG_INF, "GPS Position XYZ %f %f %f %f %f\n", d1, d2, d3,
 		    d4, f1);
 	break;
     case 0x84:			/* Double-Precision LLA Position Fix and Bias Information */
 	if (len != 36)
 	    break;
-	session->newdata.latitude = getbed(buf, 0) * RAD_2_DEG;
-	session->newdata.longitude = getbed(buf, 8) * RAD_2_DEG;
-	session->newdata.altitude = getbed(buf, 16);
-	//d1 = getbed(buf, 24);	clock bias */
-	f1 = getbef(buf, 32);	/* time-of-fix */
+	session->newdata.latitude = getbed64(buf, 0) * RAD_2_DEG;
+	session->newdata.longitude = getbed64(buf, 8) * RAD_2_DEG;
+	session->newdata.altitude = getbed64(buf, 16);
+	//d1 = getbed64(buf, 24);	clock bias */
+	f1 = getbef32(buf, 32);	/* time-of-fix */
 	if ((session->context->valid & GPS_TIME_VALID)!=0) {
 	    session->newdata.time =
 		gpsd_gpstime_resolve(session,
@@ -578,11 +576,11 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
 	    if (len != 43)
 		break;
 	    s1 = getbes16(buf, 1);	/* Datum Index */
-	    d1 = getbed(buf, 3);	/* DX */
-	    d2 = getbed(buf, 11);	/* DY */
-	    d3 = getbed(buf, 19);	/* DZ */
-	    d4 = getbed(buf, 27);	/* A-axis */
-	    d5 = getbed(buf, 35);	/* Eccentricity Squared */
+	    d1 = getbed64(buf, 3);	/* DX */
+	    d2 = getbed64(buf, 11);	/* DY */
+	    d3 = getbed64(buf, 19);	/* DZ */
+	    d4 = getbed64(buf, 27);	/* A-axis */
+	    d5 = getbed64(buf, 35);	/* Eccentricity Squared */
 	    gpsd_report(LOG_INF, "Current Datum %d %f %f %f %f %f\n", s1, d1,
 			d2, d3, d4, d5);
 	    break;
@@ -763,10 +761,10 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
 
 		break;
 	    }
-	    session->newdata.latitude = getbed(buf, 36) * RAD_2_DEG;
-	    session->newdata.longitude = getbed(buf, 44) * RAD_2_DEG;
-	    session->newdata.altitude = getbed(buf, 52);
-	    //f1 = getbef(buf, 16);    clock bias */
+	    session->newdata.latitude = getbed64(buf, 36) * RAD_2_DEG;
+	    session->newdata.longitude = getbed64(buf, 44) * RAD_2_DEG;
+	    session->newdata.altitude = getbed64(buf, 52);
+	    //f1 = getbef32(buf, 16);    clock bias */
 
 	    u1 = getub(buf, 12);	/* GPS Decoding Status */
 	    u2 = getub(buf, 1);	/* Receiver Mode */
@@ -845,10 +843,10 @@ static gps_mask_t tsip_analyze(struct gps_device_t *session)
 	u2 = getub(buf, 1);	/* Operating Dimension */
 	u3 = getub(buf, 2);	/* DGPS Mode */
 	u4 = getub(buf, 3);	/* Dynamics Code */
-	f1 = getbef(buf, 5);	/* Elevation Mask */
-	f2 = getbef(buf, 9);	/* AMU Mask */
-	f3 = getbef(buf, 13);	/* DOP Mask */
-	f4 = getbef(buf, 17);	/* DOP Switch */
+	f1 = getbef32(buf, 5);	/* Elevation Mask */
+	f2 = getbef32(buf, 9);	/* AMU Mask */
+	f3 = getbef32(buf, 13);	/* DOP Mask */
+	f4 = getbef32(buf, 17);	/* DOP Switch */
 	u5 = getub(buf, 21);	/* DGPS Age Limit */
 	gpsd_report(LOG_INF,
 		    "Navigation Configuration %u %u %u %u %f %f %f %f %u\n",
@@ -971,7 +969,6 @@ static void tsip_event_hook(struct gps_device_t *session, event_t event)
     }
     if (event == event_configure) {
 	unsigned char buf[100];
-	union int_float i_f;
 
 	switch (session->packet.counter) {
 	case 0:
@@ -998,17 +995,13 @@ static void tsip_event_hook(struct gps_device_t *session, event_t event)
 	    /* - dynamic code: land */
 	    putbyte(buf, 0, 0x01);
 	    /* - elevation mask */
-	    i_f.f = 5.0 * DEG_2_RAD;
-	    putbe32(buf, 1, i_f.i);
+	    putbef32(buf, 1, 5.0 * DEG_2_RAD);
 	    /* - signal level mask */
-	    i_f.f = 6.0;
-	    putbe32(buf, 5, i_f.i);
+	    putbef32(buf, 5, 06.0);
 	    /* - PDOP mask */
-	    i_f.f = 8.0;
-	    putbe32(buf, 9, i_f.i);
+	    putbef32(buf, 9, 8.0);
 	    /* - PDOP switch */
-	    i_f.f = 6.0;
-	    putbe32(buf, 13, i_f.i);
+	    putbef32(buf, 13, 6.0);
 	    /*@ +shiftimplementation @*/
 	    (void)tsip_write(session, 0x2c, buf, 17);
 	    /* Set Position Fix Mode (auto 2D/3D) */
diff --git a/test_bits.c b/test_bits.c
index 0a99d739..5e371ba1 100644
--- a/test_bits.c
+++ b/test_bits.c
@@ -14,8 +14,6 @@
 
 /*@ -duplicatequals -formattype */
 static unsigned char buf[80];
-static union int_float i_f;
-static union long_double l_d;
 static char sb1, sb2;
 static unsigned char ub1, ub2;
 static short sw1, sw2;
@@ -70,8 +68,8 @@ static void bedumpall(void)
     (void)printf("getbeu64: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 "\n",
 		 (uint64_t) uL1, (uint64_t) uL2,
 		 (uint64_t) getbeu64(buf, 0), (uint64_t) getbeu64(buf, 8));
-    (void)printf("getbef: %f %f\n", f1, getbef(buf, 24));
-    (void)printf("getbed: %.16f %.16f\n", d1, getbed(buf, 16));
+    (void)printf("getbef32: %f %f\n", f1, getbef32(buf, 24));
+    (void)printf("getbed64: %.16f %.16f\n", d1, getbed64(buf, 16));
 }
 
 static void ledumpall(void)
@@ -100,8 +98,8 @@ static void ledumpall(void)
     (void)printf("getleu64: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 "\n",
 		 (uint64_t) uL1, (uint64_t) uL2,
 		 (uint64_t) getleu64(buf, 0), (uint64_t) getleu64(buf, 8));
-    (void)printf("getlef: %f %f\n", f1, getlef(buf, 24));
-    (void)printf("getled: %.16f %.16f\n", d1, getled(buf, 16));
+    (void)printf("getlef32: %f %f\n", f1, getlef32(buf, 24));
+    (void)printf("getled64: %.16f %.16f\n", d1, getled64(buf, 16));
 }
 
 struct unsigned_test
@@ -170,8 +168,8 @@ int main(int argc, char *argv[])
 	sL2 = getbes64(buf, 8);
 	uL1 = getbeu64(buf, 0);
 	uL2 = getbeu64(buf, 8);
-	f1 = getbef(buf, 24);
-	d1 = getbed(buf, 16);
+	f1 = getbef32(buf, 24);
+	d1 = getbed64(buf, 16);
 	/*@+type@*/
 	bedumpall();
 
@@ -194,8 +192,8 @@ int main(int argc, char *argv[])
 	sL2 = getles64(buf, 8);
 	uL1 = getleu64(buf, 0);
 	uL2 = getleu64(buf, 8);
-	f1 = getlef(buf, 24);
-	d1 = getled(buf, 16);
+	f1 = getlef32(buf, 24);
+	d1 = getled64(buf, 16);
 	/*@+type@*/
 	ledumpall();
     }