1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/*
* Copyright (C) 1996-2024 The Squid Software Foundation and contributors
*
* Squid software is distributed under GPLv2+ license and includes
* contributions from numerous individuals and organizations.
* Please see the COPYING and CONTRIBUTORS files for details.
*/
#define _etext etext
#include "squid.h"
#include "util.h"
#if HAVE_STRING_H
#include <string.h>
#endif
#if HAVE_CTYPE_H
#include <ctype.h>
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_MATH_H
#include <math.h>
#endif
void
Tolower(char *q)
{
char *s = q;
while (*s) {
*s = xtolower(*s);
s++;
}
}
/* somewhat safer calculation of %s */
double
xpercent(double part, double whole)
{
return xdiv(100 * part, whole);
}
int
xpercentInt(double part, double whole)
{
return (int) rint(xpercent(part, whole));
}
/* somewhat safer division */
double
xdiv(double nom, double denom)
{
return (denom != 0.0) ? nom / denom : -1.0;
}
/* integer to string */
const char *
xitoa(int num)
{
static char buf[24]; /* 2^64 = 18446744073709551616 */
snprintf(buf, sizeof(buf), "%d", num);
return buf;
}
/* int64_t to string */
const char *
xint64toa(int64_t num)
{
static char buf[24]; /* 2^64 = 18446744073709551616 */
snprintf(buf, sizeof(buf), "%" PRId64, num);
return buf;
}
void
gb_flush(gb_t * g)
{
g->gb += (g->bytes >> 30);
g->bytes &= (1 << 30) - 1;
}
double
gb_to_double(const gb_t * g)
{
return ((double) g->gb) * ((double) (1 << 30)) + ((double) g->bytes);
}
const char *
double_to_str(char *buf, int buf_size, double value)
{
/* select format */
if (value < 1e9)
snprintf(buf, buf_size, "%.2f MB", value / 1e6);
else if (value < 1e12)
snprintf(buf, buf_size, "%.3f GB", value / 1e9);
else
snprintf(buf, buf_size, "%.4f TB", value / 1e12);
return buf;
}
const char *
gb_to_str(const gb_t * g)
{
/*
* it is often convenient to call gb_to_str several times for _one_ printf
*/
#define max_cc_calls 5
typedef char GbBuf[32];
static GbBuf bufs[max_cc_calls];
static int call_id = 0;
double value = gb_to_double(g);
char *buf = bufs[call_id++];
if (call_id >= max_cc_calls)
call_id = 0;
/* select format */
if (value < 1e9)
snprintf(buf, sizeof(GbBuf), "%.2f MB", value / 1e6);
else if (value < 1e12)
snprintf(buf, sizeof(GbBuf), "%.2f GB", value / 1e9);
else
snprintf(buf, sizeof(GbBuf), "%.2f TB", value / 1e12);
return buf;
}
/**
* rounds num to the next upper integer multiple of what
*/
unsigned int RoundTo(const unsigned int num, const unsigned int what)
{
return what * ((num + what -1)/what);
}
|
