开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
util.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：15k
源码类别：

代理服务器

开发平台：

Unix_Linux

util.c：源码内容
  2. /*
  3.  * $Id: util.c,v 1.65.2.1 1999/02/12 19:38:16 wessels Exp $
  4.  *
  5.  * DEBUG: 
  6.  * AUTHOR: Harvest Derived
  7.  *
  8.  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
  9.  * ----------------------------------------------------------
  10.  *
  11.  *  Squid is the result of efforts by numerous individuals from the
  12.  *  Internet community.  Development is led by Duane Wessels of the
  13.  *  National Laboratory for Applied Network Research and funded by the
  14.  *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
  15.  *  Duane Wessels and the University of California San Diego.  Please
  16.  *  see the COPYRIGHT file for full details.  Squid incorporates
  17.  *  software developed and/or copyrighted by other sources.  Please see
  18.  *  the CREDITS file for full details.
  19.  *
  20.  *  This program is free software; you can redistribute it and/or modify
  21.  *  it under the terms of the GNU General Public License as published by
  22.  *  the Free Software Foundation; either version 2 of the License, or
  23.  *  (at your option) any later version.
  24.  *  
  25.  *  This program is distributed in the hope that it will be useful,
  26.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.  *  GNU General Public License for more details.
  29.  *  
  30.  *  You should have received a copy of the GNU General Public License
  31.  *  along with this program; if not, write to the Free Software
  32.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33.  *
  34.  */
  36. #define _etext etext
  38. #include "config.h"
  40. #if HAVE_STDIO_H
  41. #include <stdio.h>
  42. #endif
  43. #if HAVE_STDLIB_H
  44. #include <stdlib.h>
  45. #endif
  46. #if HAVE_STRING_H
  47. #include <string.h>
  48. #endif
  49. #if HAVE_CTYPE_H
  50. #include <ctype.h>
  51. #endif
  52. #if HAVE_UNISTD_H
  53. #include <unistd.h>
  54. #endif
  55. #if HAVE_GNUMALLLOC_H
  56. #include <gnumalloc.h>
  57. #elif HAVE_MALLOC_H && !defined(_SQUID_FREEBSD_) && !defined(_SQUID_NEXT_)
  58. #include <malloc.h>
  59. #endif
  60. #if HAVE_ERRNO_H
  61. #include <errno.h>
  62. #endif
  63. #if HAVE_MATH_H
  64. #include <math.h>
  65. #endif
  66. #if HAVE_ASSERT_H
  67. #include <assert.h>
  68. #endif
  70. #include "util.h"
  71. #include "snprintf.h"
  73. void (*failure_notify) (const char *) = NULL;
  74. static char msg[128];
  76. extern int sys_nerr;
  78. #if MEM_GEN_TRACE
  80. static FILE *tracefp = NULL;
  82. void
  83. log_trace_init(char *fn)
  84. {
  85.     tracefp = fopen(fn, "a+");
  86.     if (!tracefp) {
  87. perror("log_trace_init");
  88. exit(1);
  89.     }
  90. }
  92. void
  93. log_trace_done()
  94. {
  95.     fclose(tracefp);
  96.     tracefp = NULL;
  97. }
  99. #endif
  101. #if XMALLOC_STATISTICS
  102. #define DBG_MAXSIZE   (1024*1024)
  103. #define DBG_GRAIN     (16)
  104. #define DBG_MAXINDEX  (DBG_MAXSIZE/DBG_GRAIN)
  105. #define DBG_INDEX(sz) (sz<DBG_MAXSIZE?(sz+DBG_GRAIN-1)/DBG_GRAIN:DBG_MAXINDEX)
  106. static int malloc_sizes[DBG_MAXINDEX + 1];
  107. static int dbg_stat_init = 0;
  110. static void
  111. stat_init(void)
  112. {
  113.     int i;
  114.     for (i = 0; i <= DBG_MAXINDEX; i++)
  115. malloc_sizes[i] = 0;
  116.     dbg_stat_init = 1;
  117. }
  119. static int
  120. malloc_stat(int sz)
  121. {
  122.     if (!dbg_stat_init)
  123. stat_init();
  124.     return malloc_sizes[DBG_INDEX(sz)] += 1;
  125. }
  127. void
  128. malloc_statistics(void (*func) (int, int, void *), void *data)
  129. {
  130.     int i;
  131.     for (i = 0; i <= DBG_MAXSIZE; i += DBG_GRAIN)
  132. func(i, malloc_sizes[DBG_INDEX(i)], data);
  133. }
  134. #endif /* XMALLOC_STATISTICS */
  138. #if XMALLOC_TRACE
  139. char *xmalloc_file = "";
  140. int xmalloc_line = 0;
  141. char *xmalloc_func = "";
  142. static int xmalloc_count = 0;
  143. int xmalloc_trace = 0; /* Enable with -m option */
  144. size_t xmalloc_total = 0;
  145. #undef xmalloc
  146. #undef xfree
  147. #undef xxfree
  148. #undef xrealloc
  149. #undef xcalloc
  150. #undef xstrdup
  151. #endif
  153. #if XMALLOC_DEBUG
  154. #define DBG_ARRY_SZ (1<<10)
  155. #define DBG_ARRY_BKTS (1<<8)
  156. static void *(*malloc_ptrs)[DBG_ARRY_SZ];
  157. static int malloc_size[DBG_ARRY_BKTS][DBG_ARRY_SZ];
  158. #if XMALLOC_TRACE
  159. static char *malloc_file[DBG_ARRY_BKTS][DBG_ARRY_SZ];
  160. static short malloc_line[DBG_ARRY_BKTS][DBG_ARRY_SZ];
  161. static int malloc_count[DBG_ARRY_BKTS][DBG_ARRY_SZ];
  162. #endif
  163. static int dbg_initd = 0;
  165. #define DBG_HASH_BUCKET(ptr)   (((((int)ptr)>>4)+(((int)ptr)>>12)+(((int)ptr)>>20))&0xFF)
  167. static void
  168. check_init(void)
  169. {
  170.     int B = 0, I = 0;
  171.     /* calloc the ptrs so that we don't see them when hunting lost memory */
  172.     malloc_ptrs = calloc(DBG_ARRY_BKTS, sizeof(*malloc_ptrs));
  173.     for (B = 0; B < DBG_ARRY_BKTS; B++) {
  174. for (I = 0; I < DBG_ARRY_SZ; I++) {
  175.     malloc_ptrs[B][I] = NULL;
  176.     malloc_size[B][I] = 0;
  177. #if XMALLOC_TRACE
  178.     malloc_file[B][I] = NULL;
  179.     malloc_line[B][I] = 0;
  180.     malloc_count[B][I] = 0;
  181. #endif
  182. }
  183.     }
  184.     dbg_initd = 1;
  185. }
  187. static void
  188. check_free(void *s)
  189. {
  190.     int B, I;
  191.     B = DBG_HASH_BUCKET(s);
  192.     for (I = 0; I < DBG_ARRY_SZ; I++) {
  193. if (malloc_ptrs[B][I] != s)
  194.     continue;
  195. malloc_ptrs[B][I] = NULL;
  196. malloc_size[B][I] = 0;
  197. #if XMALLOC_TRACE
  198. malloc_file[B][I] = NULL;
  199. malloc_line[B][I] = 0;
  200. malloc_count[B][I] = 0;
  201. #endif
  202. break;
  203.     }
  204.     if (I == DBG_ARRY_SZ) {
  205. snprintf(msg, 128, "xfree: ERROR: s=%p not found!", s);
  206. (*failure_notify) (msg);
  207.     }
  208. }
  210. static void
  211. check_malloc(void *p, size_t sz)
  212. {
  213.     void *P, *Q;
  214.     int B, I;
  215.     if (!dbg_initd)
  216. check_init();
  217.     B = DBG_HASH_BUCKET(p);
  218.     for (I = 0; I < DBG_ARRY_SZ; I++) {
  219. if (!(P = malloc_ptrs[B][I]))
  220.     continue;
  221. Q = P + malloc_size[B][I];
  222. if (P <= p && p < Q) {
  223.     snprintf(msg, 128, "xmalloc: ERROR: p=%p falls in P=%p+%d",
  224. p, P, malloc_size[B][I]);
  225.     (*failure_notify) (msg);
  226. }
  227.     }
  228.     for (I = 0; I < DBG_ARRY_SZ; I++) {
  229. if (malloc_ptrs[B][I])
  230.     continue;
  231. malloc_ptrs[B][I] = p;
  232. malloc_size[B][I] = (int) sz;
  233. #if XMALLOC_TRACE
  234. malloc_file[B][I] = xmalloc_file;
  235. malloc_line[B][I] = xmalloc_line;
  236. malloc_count[B][I] = xmalloc_count;
  237. #endif
  238. break;
  239.     }
  240.     if (I == DBG_ARRY_SZ)
  241. (*failure_notify) ("xmalloc: debug out of array space!");
  242. }
  243. #endif
  245. #if XMALLOC_TRACE && !HAVE_MALLOCBLKSIZE
  246. size_t
  247. xmallocblksize(void *p)
  248. {
  249.     int B, I;
  250.     B = DBG_HASH_BUCKET(p);
  251.     for (I = 0; I < DBG_ARRY_SZ; I++) {
  252. if (malloc_ptrs[B][I] == p)
  253.     return malloc_size[B][I];
  254.     }
  255.     return 0;
  256. }
  257. #endif
  259. #ifdef XMALLOC_TRACE
  260. static char *
  261. malloc_file_name(void *p)
  262. {
  263.     int B, I;
  264.     B = DBG_HASH_BUCKET(p);
  265.     for (I = 0; I < DBG_ARRY_SZ; I++) {
  266. if (malloc_ptrs[B][I] == p)
  267.     return malloc_file[B][I];
  268.     }
  269.     return 0;
  270. }
  271. int
  272. malloc_line_number(void *p)
  273. {
  274.     int B, I;
  275.     B = DBG_HASH_BUCKET(p);
  276.     for (I = 0; I < DBG_ARRY_SZ; I++) {
  277. if (malloc_ptrs[B][I] == p)
  278.     return malloc_line[B][I];
  279.     }
  280.     return 0;
  281. }
  282. int
  283. malloc_number(void *p)
  284. {
  285.     int B, I;
  286.     B = DBG_HASH_BUCKET(p);
  287.     for (I = 0; I < DBG_ARRY_SZ; I++) {
  288. if (malloc_ptrs[B][I] == p)
  289.     return malloc_count[B][I];
  290.     }
  291.     return 0;
  292. }
  293. static void
  294. xmalloc_show_trace(void *p, int sign)
  295. {
  296.     int statMemoryAccounted();
  297.     static size_t last_total = 0, last_accounted = 0, last_mallinfo = 0;
  298.     size_t accounted = statMemoryAccounted();
  299.     size_t mi = 0;
  300.     size_t sz;
  301. #if HAVE_MALLINFO
  302.     struct mallinfo mp = mallinfo();
  303.     mi = mp.uordblks + mp.usmblks + mp.hblkhd;
  304. #endif
  305.     sz = xmallocblksize(p) * sign;
  306.     xmalloc_total += sz;
  307.     xmalloc_count += sign > 0;
  308.     if (xmalloc_trace) {
  309. fprintf(stderr, "%c%8p size=%5d/%d acc=%5d/%d mallinfo=%5d/%d %s:%d %s",
  310.     sign > 0 ? '+' : '-', p,
  311.     (int) xmalloc_total - last_total, (int) xmalloc_total,
  312.     (int) accounted - last_accounted, (int) accounted,
  313.     (int) mi - last_mallinfo, (int) mi,
  314.     xmalloc_file, xmalloc_line, xmalloc_func);
  315. if (sign < 0)
  316.     fprintf(stderr, " (%d %s:%d)n", malloc_number(p), malloc_file_name(p), malloc_line_number(p));
  317. else
  318.     fprintf(stderr, " %dn", xmalloc_count);
  319.     }
  320.     last_total = xmalloc_total;
  321.     last_accounted = accounted;
  322.     last_mallinfo = mi;
  323. }
  325. short malloc_refs[DBG_ARRY_BKTS][DBG_ARRY_SZ];
  326. #define XMALLOC_LEAK_ALIGN (4)
  327. static void
  328. xmalloc_scan_region(void *start, int size, int depth)
  329. {
  330.     int B, I;
  331.     char *ptr = start;
  332.     char *end = ptr + size - XMALLOC_LEAK_ALIGN;
  333.     static int sum = 0;
  334.     while (ptr <= end) {
  335. void *p = *(void **) ptr;
  336. if (p && p != start) {
  337.     B = DBG_HASH_BUCKET(p);
  338.     for (I = 0; I < DBG_ARRY_SZ; I++) {
  339. if (malloc_ptrs[B][I] == p) {
  340.     if (!malloc_refs[B][I]++) {
  341. /* A new reference */
  342. fprintf(stderr, "%*s%p %s:%d size %d allocation %dn",
  343.     depth, "",
  344.     malloc_ptrs[B][I], malloc_file[B][I],
  345.     malloc_line[B][I], malloc_size[B][I],
  346.     malloc_count[B][I]);
  347. sum += malloc_size[B][I];
  348. xmalloc_scan_region(malloc_ptrs[B][I], malloc_size[B][I], depth + 1);
  349. if (depth == 0) {
  350.     if (sum != malloc_size[B][I])
  351. fprintf(stderr, "=== %d bytesn", sum);
  352.     sum = 0;
  353. }
  354. #if XMALLOC_SHOW_ALL_REFERENCES
  355.     } else {
  356. /* We have already scanned this pointer... */
  357. fprintf(stderr, "%*s%p %s:%d size %d allocation %d ... (%d)n",
  358.     depth * 2, "",
  359.     malloc_ptrs[B][I], malloc_file[B][I],
  360.     malloc_line[B][I], malloc_size[B][I],
  361.     malloc_count[B][I], malloc_refs[B][I]);
  362. #endif
  363.     }
  364. }
  365.     }
  366. }
  367. ptr += XMALLOC_LEAK_ALIGN;
  368.     }
  369. }
  371. void
  372. xmalloc_find_leaks(void)
  373. {
  374.     int B, I;
  375.     int leak_sum = 0;
  377.     extern void _etext;
  378.     fprintf(stderr, "----- Memory map ----n");
  379.     xmalloc_scan_region(&_etext, (void *) sbrk(0) - (void *) &_etext, 0);
  380.     for (B = 0; B < DBG_ARRY_BKTS; B++) {
  381. for (I = 0; I < DBG_ARRY_SZ; I++) {
  382.     if (malloc_ptrs[B][I] && malloc_refs[B][I] == 0) {
  383. /* Found a leak... */
  384. fprintf(stderr, "Leak found: %p", malloc_ptrs[B][I]);
  385. fprintf(stderr, " %s", malloc_file[B][I]);
  386. fprintf(stderr, ":%d", malloc_line[B][I]);
  387. fprintf(stderr, " size %d", malloc_size[B][I]);
  388. fprintf(stderr, " allocation %dn", malloc_count[B][I]);
  389. leak_sum += malloc_size[B][I];
  390.     }
  391. }
  392.     }
  393.     if (leak_sum) {
  394. fprintf(stderr, "Total leaked memory: %dn", leak_sum);
  395.     } else {
  396. fprintf(stderr, "No memory leaks detectedn");
  397.     }
  398.     fprintf(stderr, "----------------------n");
  399. }
  400. #endif /* XMALLOC_TRACE */
  402. /*
  403.  *  xmalloc() - same as malloc(3).  Used for portability.
  404.  *  Never returns NULL; fatal on error.
  405.  */
  406. void *
  407. xmalloc(size_t sz)
  408. {
  409.     void *p;
  411.     if (sz < 1)
  412. sz = 1;
  414.     if ((p = malloc(sz)) == NULL) {
  415. if (failure_notify) {
  416.     snprintf(msg, 128, "xmalloc: Unable to allocate %d bytes!n",
  417. (int) sz);
  418.     (*failure_notify) (msg);
  419. } else {
  420.     perror("malloc");
  421. }
  422. exit(1);
  423.     }
  424. #if XMALLOC_DEBUG
  425.     check_malloc(p, sz);
  426. #endif
  427. #if XMALLOC_STATISTICS
  428.     malloc_stat(sz);
  429. #endif
  430. #if XMALLOC_TRACE
  431.     xmalloc_show_trace(p, 1);
  432. #endif
  433. #if MEM_GEN_TRACE
  434.     if (tracefp)
  435. fprintf(tracefp, "m:%d:%pn", sz, p);
  436. #endif
  437.     return (p);
  438. }
  440. /*
  441.  *  xfree() - same as free(3).  Will not call free(3) if s == NULL.
  442.  */
  443. void
  444. xfree(void *s)
  445. {
  446. #if XMALLOC_TRACE
  447.     xmalloc_show_trace(s, -1);
  448. #endif
  450. #if XMALLOC_DEBUG
  451.     check_free(s);
  452. #endif
  453.     if (s != NULL)
  454. free(s);
  455. #if MEM_GEN_TRACE
  456.     if (tracefp && s)
  457. fprintf(tracefp, "f:%pn", s);
  458. #endif
  459. }
  461. /* xxfree() - like xfree(), but we already know s != NULL */
  462. void
  463. xxfree(void *s)
  464. {
  465. #if XMALLOC_TRACE
  466.     xmalloc_show_trace(s, -1);
  467. #endif
  468. #if XMALLOC_DEBUG
  469.     check_free(s);
  470. #endif
  471.     free(s);
  472. #if MEM_GEN_TRACE
  473.     if (tracefp && s)
  474. fprintf(tracefp, "f:%pn", s);
  475. #endif
  476. }
  478. /*
  479.  *  xrealloc() - same as realloc(3). Used for portability.
  480.  *  Never returns NULL; fatal on error.
  481.  */
  482. void *
  483. xrealloc(void *s, size_t sz)
  484. {
  485.     void *p;
  487. #if XMALLOC_TRACE
  488.     xmalloc_show_trace(s, -1);
  489. #endif
  491.     if (sz < 1)
  492. sz = 1;
  493. #if XMALLOC_DEBUG
  494.     if (s != NULL)
  495. check_free(s);
  496. #endif
  497.     if ((p = realloc(s, sz)) == NULL) {
  498. if (failure_notify) {
  499.     snprintf(msg, 128, "xrealloc: Unable to reallocate %d bytes!n",
  500. (int) sz);
  501.     (*failure_notify) (msg);
  502. } else {
  503.     perror("realloc");
  504. }
  505. exit(1);
  506.     }
  507. #if XMALLOC_DEBUG
  508.     check_malloc(p, sz);
  509. #endif
  510. #if XMALLOC_STATISTICS
  511.     malloc_stat(sz);
  512. #endif
  513. #if XMALLOC_TRACE
  514.     xmalloc_show_trace(p, 1);
  515. #endif
  516. #if MEM_GEN_TRACE
  517.     if (tracefp) /* new ptr, old ptr, new size */
  518. fprintf(tracefp, "r:%p:%p:%dn", p, s, sz);
  519. #endif
  520.     return (p);
  521. }
  523. /*
  524.  *  xcalloc() - same as calloc(3).  Used for portability.
  525.  *  Never returns NULL; fatal on error.
  526.  */
  527. void *
  528. xcalloc(int n, size_t sz)
  529. {
  530.     void *p;
  532.     if (n < 1)
  533. n = 1;
  534.     if (sz < 1)
  535. sz = 1;
  536.     if ((p = calloc(n, sz)) == NULL) {
  537. if (failure_notify) {
  538.     snprintf(msg, 128, "xcalloc: Unable to allocate %d blocks of %d bytes!n",
  539. (int) n, (int) sz);
  540.     (*failure_notify) (msg);
  541. } else {
  542.     perror("xcalloc");
  543. }
  544. exit(1);
  545.     }
  546. #if XMALLOC_DEBUG
  547.     check_malloc(p, sz * n);
  548. #endif
  549. #if XMALLOC_STATISTICS
  550.     malloc_stat(sz);
  551. #endif
  552. #if XMALLOC_TRACE
  553.     xmalloc_show_trace(p, 1);
  554. #endif
  555. #if MEM_GEN_TRACE
  556.     if (tracefp)
  557. fprintf(tracefp, "c:%d:%d:%pn", n, sz, p);
  558. #endif
  559.     return (p);
  560. }
  562. /*
  563.  *  xstrdup() - same as strdup(3).  Used for portability.
  564.  *  Never returns NULL; fatal on error.
  565.  */
  566. char *
  567. xstrdup(const char *s)
  568. {
  569.     size_t sz;
  570.     if (s == NULL) {
  571. if (failure_notify) {
  572.     (*failure_notify) ("xstrdup: tried to dup a NULL pointer!n");
  573. } else {
  574.     fprintf(stderr, "xstrdup: tried to dup a NULL pointer!n");
  575. }
  576. exit(1);
  577.     }
  578.     /* copy string, including terminating character */
  579.     sz = strlen(s) + 1;
  580.     return memcpy(xmalloc(sz), s, sz);
  581. }
  583. /*
  584.  *  xstrndup() - string dup with length limit.
  585.  */
  586. char *
  587. xstrndup(const char *s, size_t n)
  588. {
  589.     size_t sz;
  590.     assert(s);
  591.     assert(n);
  592.     sz = strlen(s) + 1;
  593.     if (sz > n)
  594. sz = n;
  595.     return xstrncpy(xmalloc(sz), s, sz);
  596. }
  598. /*
  599.  * xstrerror() - strerror() wrapper
  600.  */
  601. const char *
  602. xstrerror(void)
  603. {
  604.     static char xstrerror_buf[BUFSIZ];
  605.     if (errno < 0 || errno >= sys_nerr)
  606. return ("Unknown");
  607.     snprintf(xstrerror_buf, BUFSIZ, "(%d) %s", errno, strerror(errno));
  608.     return xstrerror_buf;
  609. }
  611. #if NOT_NEEDED
  612. /*
  613.  * xbstrerror with argument for late notification */
  615. const char *
  616. xbstrerror(int err)
  617. {
  618.     static char xbstrerror_buf[BUFSIZ];
  619.     if (err < 0 || err >= sys_nerr)
  620. return ("Unknown");
  621.     snprintf(xbstrerror_buf, BUFSIZ, "(%d) %s", err, strerror(err));
  622.     return xbstrerror_buf;
  623. }
  624. #endif
  626. void
  627. Tolower(char *q)
  628. {
  629.     char *s = q;
  630.     while (*s) {
  631. *s = tolower((unsigned char) *s);
  632. s++;
  633.     }
  634. }
  636. int
  637. tvSubMsec(struct timeval t1, struct timeval t2)
  638. {
  639.     return (t2.tv_sec - t1.tv_sec) * 1000 +
  640. (t2.tv_usec - t1.tv_usec) / 1000;
  641. }
  643. int
  644. tvSubUsec(struct timeval t1, struct timeval t2)
  645. {
  646.     return (t2.tv_sec - t1.tv_sec) * 1000000 +
  647. (t2.tv_usec - t1.tv_usec);
  648. }
  650. double
  651. tvSubDsec(struct timeval t1, struct timeval t2)
  652. {
  653.     return (double) (t2.tv_sec - t1.tv_sec) +
  654. (double) (t2.tv_usec - t1.tv_usec) / 1000000.0;
  655. }
  657. /*
  658.  *  xstrncpy() - similar to strncpy(3) but terminates string
  659.  *  always with '' if (n != 0 and dst != NULL), 
  660.  *  and doesn't do padding
  661.  */
  662. char *
  663. xstrncpy(char *dst, const char *src, size_t n)
  664. {
  665.     char *r = dst;
  666.     if (!n || !dst)
  667. return dst;
  668.     if (src)
  669. while (--n != 0 && *src != '')
  670.     *dst++ = *src++;
  671.     *dst = '';
  672.     return r;
  673. }
  675. /* returns the number of leading white spaces in str; handy in skipping ws */
  676. size_t
  677. xcountws(const char *str)
  678. {
  679.     size_t count = 0;
  680.     if (str) {
  681. while (xisspace(*str)) {
  682.     str++;
  683.     count++;
  684. }
  685.     }
  686.     return count;
  687. }
  689. /* somewhat safer calculation of %s */
  690. double
  691. xpercent(double part, double whole)
  692. {
  693.     return xdiv(100 * part, whole);
  694. }
  696. int
  697. xpercentInt(double part, double whole)
  698. {
  699. #if HAVE_RINT
  700.     return (int) rint(xpercent(part, whole));
  701. #else
  702.     /* SCO 3.2v4.2 doesn't have rint() -- mauri@mbp.ee */
  703.     return (int) floor(xpercent(part, whole)+0.5);
  704. #endif
  705. }
  707. /* somewhat safer division */
  708. double
  709. xdiv(double nom, double denom)
  710. {
  711.     return (denom != 0.0) ? nom / denom : -1.0;
  712. }
  714. /* integer to string */
  715. const char *
  716. xitoa(int num)
  717. {
  718.     static char buf[24]; /* 2^64 = 18446744073709551616 */
  719.     snprintf(buf, sizeof(buf), "%d", num);
  720.     return buf;
  721. }