1181834Sroberto/* 2181834Sroberto * ntp_types.h - defines how int32 and u_int32 are treated. 3181834Sroberto * For 64 bit systems like the DEC Alpha, they have to be defined 4181834Sroberto * as int and u_int. 5181834Sroberto * For 32 bit systems, define them as long and u_long 6181834Sroberto */ 7181834Sroberto#define SIZEOF_INT 4 8181834Sroberto 9181834Sroberto/* 10181834Sroberto * Set up for prototyping 11181834Sroberto */ 12181834Sroberto#ifndef P 13181834Sroberto#if defined(__STDC__) || defined(HAVE_PROTOTYPES) 14181834Sroberto#define P(x) x 15181834Sroberto#else /* not __STDC__ and not HAVE_PROTOTYPES */ 16181834Sroberto#define P(x) () 17181834Sroberto#endif /* not __STDC__ and HAVE_PROTOTYPES */ 18181834Sroberto#endif /* P */ 19181834Sroberto 20181834Sroberto/* 21181834Sroberto * VMS DECC (v4.1), {u_char,u_short,u_long} are only in SOCKET.H, 22181834Sroberto * and u_int isn't defined anywhere 23181834Sroberto */ 24181834Sroberto#if defined(VMS) 25181834Sroberto#include <socket.h> 26181834Srobertotypedef unsigned int u_int; 27181834Sroberto/* 28181834Sroberto * Note: VMS DECC has long == int (even on __alpha), 29181834Sroberto * so the distinction below doesn't matter 30181834Sroberto */ 31181834Sroberto#endif /* VMS */ 32181834Sroberto 33181834Sroberto#if (SIZEOF_INT == 4) 34181834Sroberto# ifndef int32 35181834Sroberto# define int32 int 36181834Sroberto# endif 37181834Sroberto# ifndef u_int32 38181834Sroberto# define u_int32 unsigned int 39181834Sroberto# endif 40181834Sroberto#else /* not sizeof(int) == 4 */ 41181834Sroberto# if (SIZEOF_LONG == 4) 42181834Sroberto# else /* not sizeof(long) == 4 */ 43181834Sroberto# ifndef int32 44181834Sroberto# define int32 long 45181834Sroberto# endif 46181834Sroberto# ifndef u_int32 47181834Sroberto# define u_int32 unsigned long 48181834Sroberto# endif 49181834Sroberto# endif /* not sizeof(long) == 4 */ 50181834Sroberto# include "Bletch: what's 32 bits on this machine?" 51181834Sroberto#endif /* not sizeof(int) == 4 */ 52181834Sroberto 53181834Srobertotypedef unsigned short associd_t; /* association ID */ 54181834Srobertotypedef u_int32 keyid_t; /* cryptographic key ID */ 55181834Srobertotypedef u_int32 tstamp_t; /* NTP seconds timestamp */ 56181834Sroberto 57181834Sroberto/* 58181834Sroberto * NTP uses two fixed point formats. The first (l_fp) is the "long" 59181834Sroberto * format and is 64 bits long with the decimal between bits 31 and 32. 60181834Sroberto * This is used for time stamps in the NTP packet header (in network 61181834Sroberto * byte order) and for internal computations of offsets (in local host 62181834Sroberto * byte order). We use the same structure for both signed and unsigned 63181834Sroberto * values, which is a big hack but saves rewriting all the operators 64181834Sroberto * twice. Just to confuse this, we also sometimes just carry the 65181834Sroberto * fractional part in calculations, in both signed and unsigned forms. 66181834Sroberto * Anyway, an l_fp looks like: 67181834Sroberto * 68181834Sroberto * 0 1 2 3 69181834Sroberto * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 70181834Sroberto * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 71181834Sroberto * | Integral Part | 72181834Sroberto * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 73181834Sroberto * | Fractional Part | 74181834Sroberto * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 75181834Sroberto * 76181834Sroberto */ 77181834Srobertotypedef struct { 78181834Sroberto union { 79181834Sroberto u_int32 Xl_ui; 80181834Sroberto int32 Xl_i; 81181834Sroberto } Ul_i; 82181834Sroberto union { 83181834Sroberto u_int32 Xl_uf; 84181834Sroberto int32 Xl_f; 85181834Sroberto } Ul_f; 86181834Sroberto} l_fp; 87181834Sroberto 88181834Sroberto#define l_ui Ul_i.Xl_ui /* unsigned integral part */ 89181834Sroberto#define l_i Ul_i.Xl_i /* signed integral part */ 90181834Sroberto#define l_uf Ul_f.Xl_uf /* unsigned fractional part */ 91181834Sroberto#define l_f Ul_f.Xl_f /* signed fractional part */ 92181834Sroberto 93181834Sroberto/* 94181834Sroberto * Fractional precision (of an l_fp) is actually the number of 95181834Sroberto * bits in a long. 96181834Sroberto */ 97181834Sroberto#define FRACTION_PREC (32) 98181834Sroberto 99181834Sroberto 100181834Sroberto/* 101181834Sroberto * The second fixed point format is 32 bits, with the decimal between 102181834Sroberto * bits 15 and 16. There is a signed version (s_fp) and an unsigned 103181834Sroberto * version (u_fp). This is used to represent synchronizing distance 104181834Sroberto * and synchronizing dispersion in the NTP packet header (again, in 105181834Sroberto * network byte order) and internally to hold both distance and 106181834Sroberto * dispersion values (in local byte order). In network byte order 107181834Sroberto * it looks like: 108181834Sroberto * 109181834Sroberto * 0 1 2 3 110181834Sroberto * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 111181834Sroberto * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 112181834Sroberto * | Integer Part | Fraction Part | 113181834Sroberto * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 114181834Sroberto * 115181834Sroberto */ 116181834Srobertotypedef int32 s_fp; 117181834Srobertotypedef u_int32 u_fp; 118181834Sroberto 119181834Sroberto/* 120181834Sroberto * A unit second in fp format. Actually 2**(half_the_bits_in_a_long) 121181834Sroberto */ 122181834Sroberto#define FP_SECOND (0x10000) 123181834Sroberto 124181834Sroberto/* 125181834Sroberto * Byte order conversions 126181834Sroberto */ 127181834Sroberto#define HTONS_FP(x) (htonl(x)) 128181834Sroberto#define HTONL_FP(h, n) do { (n)->l_ui = htonl((h)->l_ui); \ 129181834Sroberto (n)->l_uf = htonl((h)->l_uf); } while (0) 130181834Sroberto#define NTOHS_FP(x) (ntohl(x)) 131181834Sroberto#define NTOHL_FP(n, h) do { (h)->l_ui = ntohl((n)->l_ui); \ 132181834Sroberto (h)->l_uf = ntohl((n)->l_uf); } while (0) 133181834Sroberto#define NTOHL_MFP(ni, nf, hi, hf) \ 134181834Sroberto do { (hi) = ntohl(ni); (hf) = ntohl(nf); } while (0) 135181834Sroberto#define HTONL_MFP(hi, hf, ni, nf) \ 136181834Sroberto do { (ni) = ntohl(hi); (nf) = ntohl(hf); } while (0) 137181834Sroberto 138181834Sroberto/* funny ones. Converts ts fractions to net order ts */ 139181834Sroberto#define HTONL_UF(uf, nts) \ 140181834Sroberto do { (nts)->l_ui = 0; (nts)->l_uf = htonl(uf); } while (0) 141181834Sroberto#define HTONL_F(f, nts) do { (nts)->l_uf = htonl(f); \ 142181834Sroberto if ((f) & 0x80000000) \ 143181834Sroberto (nts)->l_i = -1; \ 144181834Sroberto else \ 145181834Sroberto (nts)->l_i = 0; \ 146181834Sroberto } while (0) 147181834Sroberto 148181834Sroberto/* 149181834Sroberto * Conversions between the two fixed point types 150181834Sroberto */ 151181834Sroberto#define MFPTOFP(x_i, x_f) (((x_i) >= 0x00010000) ? 0x7fffffff : \ 152181834Sroberto (((x_i) <= -0x00010000) ? 0x80000000 : \ 153181834Sroberto (((x_i)<<16) | (((x_f)>>16)&0xffff)))) 154181834Sroberto#define LFPTOFP(v) MFPTOFP((v)->l_i, (v)->l_f) 155181834Sroberto 156181834Sroberto#define UFPTOLFP(x, v) ((v)->l_ui = (u_fp)(x)>>16, (v)->l_uf = (x)<<16) 157181834Sroberto#define FPTOLFP(x, v) (UFPTOLFP((x), (v)), (x) < 0 ? (v)->l_ui -= 0x10000 : 0) 158181834Sroberto 159181834Sroberto#define MAXLFP(v) ((v)->l_ui = 0x7fffffff, (v)->l_uf = 0xffffffff) 160181834Sroberto#define MINLFP(v) ((v)->l_ui = 0x80000000, (v)->l_uf = 0) 161181834Sroberto 162181834Sroberto/* 163181834Sroberto * Primitive operations on long fixed point values. If these are 164181834Sroberto * reminiscent of assembler op codes it's only because some may 165181834Sroberto * be replaced by inline assembler for particular machines someday. 166181834Sroberto * These are the (kind of inefficient) run-anywhere versions. 167181834Sroberto */ 168181834Sroberto#define M_NEG(v_i, v_f) /* v = -v */ \ 169181834Sroberto do { \ 170181834Sroberto if ((v_f) == 0) \ 171181834Sroberto (v_i) = -((s_fp)(v_i)); \ 172181834Sroberto else { \ 173181834Sroberto (v_f) = -((s_fp)(v_f)); \ 174181834Sroberto (v_i) = ~(v_i); \ 175181834Sroberto } \ 176181834Sroberto } while(0) 177181834Sroberto 178181834Sroberto#define M_NEGM(r_i, r_f, a_i, a_f) /* r = -a */ \ 179181834Sroberto do { \ 180181834Sroberto if ((a_f) == 0) { \ 181181834Sroberto (r_f) = 0; \ 182181834Sroberto (r_i) = -(a_i); \ 183181834Sroberto } else { \ 184181834Sroberto (r_f) = -(a_f); \ 185181834Sroberto (r_i) = ~(a_i); \ 186181834Sroberto } \ 187181834Sroberto } while(0) 188181834Sroberto 189181834Sroberto#define M_ADD(r_i, r_f, a_i, a_f) /* r += a */ \ 190181834Sroberto do { \ 191181834Sroberto register u_int32 lo_tmp; \ 192181834Sroberto register u_int32 hi_tmp; \ 193181834Sroberto \ 194181834Sroberto lo_tmp = ((r_f) & 0xffff) + ((a_f) & 0xffff); \ 195181834Sroberto hi_tmp = (((r_f) >> 16) & 0xffff) + (((a_f) >> 16) & 0xffff); \ 196181834Sroberto if (lo_tmp & 0x10000) \ 197181834Sroberto hi_tmp++; \ 198181834Sroberto (r_f) = ((hi_tmp & 0xffff) << 16) | (lo_tmp & 0xffff); \ 199181834Sroberto \ 200181834Sroberto (r_i) += (a_i); \ 201181834Sroberto if (hi_tmp & 0x10000) \ 202181834Sroberto (r_i)++; \ 203181834Sroberto } while (0) 204181834Sroberto 205181834Sroberto#define M_ADD3(r_ovr, r_i, r_f, a_ovr, a_i, a_f) /* r += a, three word */ \ 206181834Sroberto do { \ 207181834Sroberto register u_int32 lo_tmp; \ 208181834Sroberto register u_int32 hi_tmp; \ 209181834Sroberto \ 210181834Sroberto lo_tmp = ((r_f) & 0xffff) + ((a_f) & 0xffff); \ 211181834Sroberto hi_tmp = (((r_f) >> 16) & 0xffff) + (((a_f) >> 16) & 0xffff); \ 212181834Sroberto if (lo_tmp & 0x10000) \ 213181834Sroberto hi_tmp++; \ 214181834Sroberto (r_f) = ((hi_tmp & 0xffff) << 16) | (lo_tmp & 0xffff); \ 215181834Sroberto \ 216181834Sroberto lo_tmp = ((r_i) & 0xffff) + ((a_i) & 0xffff); \ 217181834Sroberto if (hi_tmp & 0x10000) \ 218181834Sroberto lo_tmp++; \ 219181834Sroberto hi_tmp = (((r_i) >> 16) & 0xffff) + (((a_i) >> 16) & 0xffff); \ 220181834Sroberto if (lo_tmp & 0x10000) \ 221181834Sroberto hi_tmp++; \ 222181834Sroberto (r_i) = ((hi_tmp & 0xffff) << 16) | (lo_tmp & 0xffff); \ 223181834Sroberto \ 224181834Sroberto (r_ovr) += (a_ovr); \ 225181834Sroberto if (hi_tmp & 0x10000) \ 226181834Sroberto (r_ovr)++; \ 227181834Sroberto } while (0) 228181834Sroberto 229181834Sroberto#define M_SUB(r_i, r_f, a_i, a_f) /* r -= a */ \ 230181834Sroberto do { \ 231181834Sroberto register u_int32 lo_tmp; \ 232181834Sroberto register u_int32 hi_tmp; \ 233181834Sroberto \ 234181834Sroberto if ((a_f) == 0) { \ 235181834Sroberto (r_i) -= (a_i); \ 236181834Sroberto } else { \ 237181834Sroberto lo_tmp = ((r_f) & 0xffff) + ((-((s_fp)(a_f))) & 0xffff); \ 238181834Sroberto hi_tmp = (((r_f) >> 16) & 0xffff) \ 239181834Sroberto + (((-((s_fp)(a_f))) >> 16) & 0xffff); \ 240181834Sroberto if (lo_tmp & 0x10000) \ 241181834Sroberto hi_tmp++; \ 242181834Sroberto (r_f) = ((hi_tmp & 0xffff) << 16) | (lo_tmp & 0xffff); \ 243181834Sroberto \ 244181834Sroberto (r_i) += ~(a_i); \ 245181834Sroberto if (hi_tmp & 0x10000) \ 246181834Sroberto (r_i)++; \ 247181834Sroberto } \ 248181834Sroberto } while (0) 249181834Sroberto 250181834Sroberto#define M_RSHIFTU(v_i, v_f) /* v >>= 1, v is unsigned */ \ 251181834Sroberto do { \ 252181834Sroberto (v_f) = (u_int32)(v_f) >> 1; \ 253181834Sroberto if ((v_i) & 01) \ 254181834Sroberto (v_f) |= 0x80000000; \ 255181834Sroberto (v_i) = (u_int32)(v_i) >> 1; \ 256181834Sroberto } while (0) 257181834Sroberto 258181834Sroberto#define M_RSHIFT(v_i, v_f) /* v >>= 1, v is signed */ \ 259181834Sroberto do { \ 260181834Sroberto (v_f) = (u_int32)(v_f) >> 1; \ 261181834Sroberto if ((v_i) & 01) \ 262181834Sroberto (v_f) |= 0x80000000; \ 263181834Sroberto if ((v_i) & 0x80000000) \ 264181834Sroberto (v_i) = ((v_i) >> 1) | 0x80000000; \ 265181834Sroberto else \ 266181834Sroberto (v_i) = (v_i) >> 1; \ 267181834Sroberto } while (0) 268181834Sroberto 269181834Sroberto#define M_LSHIFT(v_i, v_f) /* v <<= 1 */ \ 270181834Sroberto do { \ 271181834Sroberto (v_i) <<= 1; \ 272181834Sroberto if ((v_f) & 0x80000000) \ 273181834Sroberto (v_i) |= 0x1; \ 274181834Sroberto (v_f) <<= 1; \ 275181834Sroberto } while (0) 276181834Sroberto 277181834Sroberto#define M_LSHIFT3(v_ovr, v_i, v_f) /* v <<= 1, with overflow */ \ 278181834Sroberto do { \ 279181834Sroberto (v_ovr) <<= 1; \ 280181834Sroberto if ((v_i) & 0x80000000) \ 281181834Sroberto (v_ovr) |= 0x1; \ 282181834Sroberto (v_i) <<= 1; \ 283181834Sroberto if ((v_f) & 0x80000000) \ 284181834Sroberto (v_i) |= 0x1; \ 285181834Sroberto (v_f) <<= 1; \ 286181834Sroberto } while (0) 287181834Sroberto 288181834Sroberto#define M_ADDUF(r_i, r_f, uf) /* r += uf, uf is u_int32 fraction */ \ 289181834Sroberto M_ADD((r_i), (r_f), 0, (uf)) /* let optimizer worry about it */ 290181834Sroberto 291181834Sroberto#define M_SUBUF(r_i, r_f, uf) /* r -= uf, uf is u_int32 fraction */ \ 292181834Sroberto M_SUB((r_i), (r_f), 0, (uf)) /* let optimizer worry about it */ 293181834Sroberto 294181834Sroberto#define M_ADDF(r_i, r_f, f) /* r += f, f is a int32 fraction */ \ 295181834Sroberto do { \ 296181834Sroberto if ((f) > 0) \ 297181834Sroberto M_ADD((r_i), (r_f), 0, (f)); \ 298181834Sroberto else if ((f) < 0) \ 299181834Sroberto M_ADD((r_i), (r_f), (-1), (f));\ 300181834Sroberto } while(0) 301181834Sroberto 302181834Sroberto#define M_ISNEG(v_i, v_f) /* v < 0 */ \ 303181834Sroberto (((v_i) & 0x80000000) != 0) 304181834Sroberto 305181834Sroberto#define M_ISHIS(a_i, a_f, b_i, b_f) /* a >= b unsigned */ \ 306181834Sroberto (((u_int32)(a_i)) > ((u_int32)(b_i)) || \ 307181834Sroberto ((a_i) == (b_i) && ((u_int32)(a_f)) >= ((u_int32)(b_f)))) 308181834Sroberto 309181834Sroberto#define M_ISGEQ(a_i, a_f, b_i, b_f) /* a >= b signed */ \ 310181834Sroberto (((int32)(a_i)) > ((int32)(b_i)) || \ 311181834Sroberto ((a_i) == (b_i) && ((u_int32)(a_f)) >= ((u_int32)(b_f)))) 312181834Sroberto 313181834Sroberto#define M_ISEQU(a_i, a_f, b_i, b_f) /* a == b unsigned */ \ 314181834Sroberto ((a_i) == (b_i) && (a_f) == (b_f)) 315181834Sroberto 316181834Sroberto/* 317181834Sroberto * Operations on the long fp format 318181834Sroberto */ 319181834Sroberto#define L_ADD(r, a) M_ADD((r)->l_ui, (r)->l_uf, (a)->l_ui, (a)->l_uf) 320181834Sroberto#define L_SUB(r, a) M_SUB((r)->l_ui, (r)->l_uf, (a)->l_ui, (a)->l_uf) 321181834Sroberto#define L_NEG(v) M_NEG((v)->l_ui, (v)->l_uf) 322181834Sroberto#define L_ADDUF(r, uf) M_ADDUF((r)->l_ui, (r)->l_uf, (uf)) 323181834Sroberto#define L_SUBUF(r, uf) M_SUBUF((r)->l_ui, (r)->l_uf, (uf)) 324181834Sroberto#define L_ADDF(r, f) M_ADDF((r)->l_ui, (r)->l_uf, (f)) 325181834Sroberto#define L_RSHIFT(v) M_RSHIFT((v)->l_i, (v)->l_uf) 326181834Sroberto#define L_RSHIFTU(v) M_RSHIFT((v)->l_ui, (v)->l_uf) 327181834Sroberto#define L_LSHIFT(v) M_LSHIFT((v)->l_ui, (v)->l_uf) 328181834Sroberto#define L_CLR(v) ((v)->l_ui = (v)->l_uf = 0) 329181834Sroberto 330181834Sroberto#define L_ISNEG(v) (((v)->l_ui & 0x80000000) != 0) 331181834Sroberto#define L_ISZERO(v) ((v)->l_ui == 0 && (v)->l_uf == 0) 332181834Sroberto#define L_ISHIS(a, b) ((a)->l_ui > (b)->l_ui || \ 333181834Sroberto ((a)->l_ui == (b)->l_ui && (a)->l_uf >= (b)->l_uf)) 334181834Sroberto#define L_ISGEQ(a, b) ((a)->l_i > (b)->l_i || \ 335181834Sroberto ((a)->l_i == (b)->l_i && (a)->l_uf >= (b)->l_uf)) 336181834Sroberto#define L_ISEQU(a, b) M_ISEQU((a)->l_ui, (a)->l_uf, (b)->l_ui, (b)->l_uf) 337181834Sroberto 338181834Sroberto/* 339181834Sroberto * s_fp/double and u_fp/double conversions 340181834Sroberto */ 341181834Sroberto#define FRIC 65536. /* 2^16 as a double */ 342181834Sroberto#define DTOFP(r) ((s_fp)((r) * FRIC)) 343181834Sroberto#define DTOUFP(r) ((u_fp)((r) * FRIC)) 344181834Sroberto#define FPTOD(r) ((double)(r) / FRIC) 345181834Sroberto 346181834Sroberto/* 347181834Sroberto * l_fp/double conversions 348181834Sroberto */ 349181834Sroberto#define FRAC 4294967296. /* 2^32 as a double */ 350181834Sroberto#define M_DTOLFP(d, r_i, r_uf) /* double to l_fp */ \ 351181834Sroberto do { \ 352181834Sroberto register double d_tmp; \ 353181834Sroberto \ 354181834Sroberto d_tmp = (d); \ 355181834Sroberto if (d_tmp < 0) { \ 356181834Sroberto d_tmp = -d_tmp; \ 357181834Sroberto (r_i) = (int32)(d_tmp); \ 358181834Sroberto (r_uf) = (u_int32)(((d_tmp) - (double)(r_i)) * FRAC); \ 359181834Sroberto M_NEG((r_i), (r_uf)); \ 360181834Sroberto } else { \ 361181834Sroberto (r_i) = (int32)(d_tmp); \ 362181834Sroberto (r_uf) = (u_int32)(((d_tmp) - (double)(r_i)) * FRAC); \ 363181834Sroberto } \ 364181834Sroberto } while (0) 365181834Sroberto#define M_LFPTOD(r_i, r_uf, d) /* l_fp to double */ \ 366181834Sroberto do { \ 367181834Sroberto register l_fp l_tmp; \ 368181834Sroberto \ 369181834Sroberto l_tmp.l_i = (r_i); \ 370181834Sroberto l_tmp.l_f = (r_uf); \ 371181834Sroberto if (l_tmp.l_i < 0) { \ 372181834Sroberto M_NEG(l_tmp.l_i, l_tmp.l_uf); \ 373181834Sroberto (d) = -((double)l_tmp.l_i + ((double)l_tmp.l_uf) / FRAC); \ 374181834Sroberto } else { \ 375181834Sroberto (d) = (double)l_tmp.l_i + ((double)l_tmp.l_uf) / FRAC; \ 376181834Sroberto } \ 377181834Sroberto } while (0) 378181834Sroberto#define DTOLFP(d, v) M_DTOLFP((d), (v)->l_ui, (v)->l_uf) 379181834Sroberto#define LFPTOD(v, d) M_LFPTOD((v)->l_ui, (v)->l_uf, (d)) 380181834Sroberto 381181834Sroberto/* 382181834Sroberto * Prototypes 383181834Sroberto */ 384181834Sroberto#if 0 385181834Srobertoextern char * dofptoa P((u_fp, int, short, int)); 386181834Srobertoextern char * dolfptoa P((u_long, u_long, int, short, int)); 387181834Sroberto#endif 388181834Sroberto 389181834Srobertoextern int atolfp P((const char *, l_fp *)); 390181834Srobertoextern int buftvtots P((const char *, l_fp *)); 391181834Srobertoextern char * fptoa P((s_fp, short)); 392181834Srobertoextern char * fptoms P((s_fp, short)); 393181834Srobertoextern int hextolfp P((const char *, l_fp *)); 394181834Srobertoextern void gpstolfp P((int, int, unsigned long, l_fp *)); 395181834Srobertoextern int mstolfp P((const char *, l_fp *)); 396181834Srobertoextern char * prettydate P((l_fp *)); 397181834Srobertoextern char * gmprettydate P((l_fp *)); 398181834Srobertoextern char * uglydate P((l_fp *)); 399181834Srobertoextern void mfp_mul P((int32 *, u_int32 *, int32, u_int32, int32, u_int32)); 400181834Sroberto 401181834Srobertoextern void get_systime P((l_fp *)); 402181834Srobertoextern int step_systime P((double)); 403181834Srobertoextern int adj_systime P((double)); 404181834Sroberto 405181834Sroberto#define lfptoa(_fpv, _ndec) mfptoa((_fpv)->l_ui, (_fpv)->l_uf, (_ndec)) 406181834Sroberto#define lfptoms(_fpv, _ndec) mfptoms((_fpv)->l_ui, (_fpv)->l_uf, (_ndec)) 407181834Sroberto 408181834Sroberto#define ufptoa(_fpv, _ndec) dofptoa((_fpv), 0, (_ndec), 0) 409181834Sroberto#define ufptoms(_fpv, _ndec) dofptoa((_fpv), 0, (_ndec), 1) 410181834Sroberto#define ulfptoa(_fpv, _ndec) dolfptoa((_fpv)->l_ui, (_fpv)->l_uf, 0, (_ndec), 0) 411181834Sroberto#define ulfptoms(_fpv, _ndec) dolfptoa((_fpv)->l_ui, (_fpv)->l_uf, 0, (_ndec), 1) 412181834Sroberto#define umfptoa(_fpi, _fpf, _ndec) dolfptoa((_fpi), (_fpf), 0, (_ndec), 0) 413