varnish-cache/lib/libvarnish/vnum.c
0
/*-
1
 * Copyright (c) 2008-2009 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright
14
 *    notice, this list of conditions and the following disclaimer in the
15
 *    documentation and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 *
29
 * Deal with numbers.
30
 *
31
 */
32
33
#include "config.h"
34
35
#include <sys/types.h>
36
37
#include <limits.h>
38
#include <math.h>
39
#include <stdint.h>
40
#include <stdio.h>
41
#include <stdlib.h>
42
#include <string.h>
43
44
#include "vdef.h"
45
46
#include "vnum.h"
47
#include "vas.h"
48
#include "vct.h"
49
50
/* The distinction between these two is used internally */
51
static const char err_invalid_num[] = "Invalid number";
52
static const char err_no_digits[] = "Invalid number";
53
54
static const char err_fatnum[] = "Too many digits";
55
56
static const char err_unknown_bytes[] =
57
    "Unknown BYTES unit of measurement ([KMGTP][B])";
58
59
static const char err_fractional_bytes[] = "Fractional BYTES not allowed";
60
61
#define BAIL(txt)                                               \
62
        do {                                                    \
63
                if (errtxt != NULL)                             \
64
                        *errtxt = (txt);                        \
65
                errno = EINVAL;                                 \
66
                return (retval);                                \
67
        } while (0)
68
69
/*
70
 * Internal function for parsing an integer with a limited
71
 * number of digits.
72
 */
73
74
static int64_t
75 8625744
sf_parse_int(const char **ipp, const char **errtxt, int *sign, int maxdig)
76
{
77 8625744
        int64_t retval = 0;
78 8625744
        int ndig = 0;
79
80 8625744
        AN(ipp);
81 8625744
        AN(*ipp);
82 8625744
        if (errtxt != NULL)
83 8625743
                *errtxt = NULL;
84 8625744
        *sign = 1;
85 8625744
        errno = 0;
86 8626640
        while (vct_isows(*(*ipp)))
87 896
                (*ipp)++;
88 8625742
        if(*(*ipp) == '-') {
89 1652
                *sign = -1;
90 1652
                (*ipp)++;
91 1652
        }
92 26000779
        while (vct_isdigit(*(*ipp))) {
93 17375345
                ndig++;
94 17375345
                if (ndig > maxdig)
95 308
                        BAIL(err_fatnum);
96 17375037
                retval *= 10;
97 17375037
                retval += *(*ipp)++ - 0x30;
98
        }
99 8625434
        if (ndig == 0)
100 63224
                BAIL(err_no_digits);
101 8562462
        while (vct_isows(*(*ipp)))
102 252
                (*ipp)++;
103 8562210
        return (retval);
104 8625742
}
105
106
/**********************************************************************
107
 * Parse a RFC8941 `sf-integer`.
108
 *
109
 * If `errno` is non-zero the conversion failed.
110
 * If `errtxt` is provided it summarily tells why.
111
 * The input argument points to the first character not consumed.
112
 */
113
114
int64_t
115 644
SF_Parse_Integer(const char **ipp, const char **errtxt)
116
{
117
        int64_t retval;
118
        int sign;
119
120 644
        retval = sf_parse_int(ipp, errtxt, &sign, 15);
121 644
        return (retval * sign);
122
}
123
124
/**********************************************************************
125
 * Parse either a RFC8941 `sf-integer` or `sf-decimal`.
126
 *
127
 * If `errno` is non-zero the conversion failed.
128
 * If `errtxt` is provided it summarily tells why.
129
 * The input argument points to the first character not consumed.
130
 */
131
132
double
133 8624763
SF_Parse_Number(const char **ipp, int strict, const char **errtxt)
134
{
135 8624763
        double retval, scale = 1;
136
        int sign, ndig;
137
138 8624763
        retval = (double)sf_parse_int(ipp, errtxt, &sign, 15);
139 8624763
        if (strict && errno)
140 224
                return (0);
141 8624539
        if (*(*ipp) != '.')
142 5266713
                return (retval * sign);
143 3357826
        if (retval < VRT_DECIMAL_MIN || retval > VRT_DECIMAL_MAX)
144 32
                BAIL(err_fatnum);
145 3357798
        if (*errtxt == err_no_digits && (!vct_isdigit((*ipp)[1])))
146 84
                BAIL(err_no_digits);
147 3357714
        *errtxt = NULL;
148 3357714
        errno = 0;
149 3357714
        do {
150 3357714
                (*ipp)++;
151 12737104
                for(ndig = 0; ndig < 3; ndig++) {
152 9953562
                        scale *= .1;
153 9953562
                        if (!vct_isdigit(*(*ipp)))
154 574172
                                break;
155 9379390
                        retval += scale * (*(*ipp)++ - 0x30);
156 9379390
                }
157 3357714
                if (strict && ndig == 0)
158 56
                        BAIL(err_invalid_num);
159 3357658
                if (strict && vct_isdigit(*(*ipp)))
160 84
                        BAIL(err_fatnum);
161 3358078
                while (vct_isdigit(*(*ipp)))
162 504
                        (*ipp)++;
163 3357574
        } while (0);
164 3358190
        while (vct_isows(*(*ipp)))
165 616
                (*ipp)++;
166 3357574
        return (retval * sign);
167 8624763
}
168
169
/**********************************************************************
170
 * Parse a RFC8941 `sf-decimal`.
171
 *
172
 * If `errno` is non-zero the conversion failed.
173
 * If `errtxt` is provided it summarily tells why.
174
 * The input argument points to the first character not consumed.
175
 */
176
177
double
178 4816112
SF_Parse_Decimal(const char **ipp, int strict, const char **errtxt)
179
{
180
        double retval;
181
182 4816112
        retval = SF_Parse_Number(ipp, strict, errtxt);
183 4816112
        if (errno)
184 168
                return (retval);
185 4815944
        if (retval < VRT_DECIMAL_MIN || retval > VRT_DECIMAL_MAX)
186 0
                BAIL(err_fatnum);
187 4815944
        return (retval);
188 4816112
}
189
190
/**********************************************************************
191
 * Parse a "Varnish number".
192
 *
193
 * Varnish numbers are the union of RFC8941 sf-integer and sf-decimal.
194
 * If `errno` is non-zero the conversion failed and NAN is returned.
195
 */
196
197
double
198 24298
VNUM(const char *p)
199
{
200
        const char *t;
201
        double r;
202
203 24298
        r = SF_Parse_Number(&p, 0, &t);
204 24298
        if (errno || *p != '\0')
205 1820
                r = nan("");
206 24298
        return (r);
207
}
208
209
/**********************************************************************/
210
211
vtim_dur
212 232120
VNUM_duration_unit(vtim_dur r, const char *b, const char *e)
213
{
214
        double sc;
215
216 232120
        if (e == NULL)
217 81844
                e = strchr(b, '\0');
218
219 232120
        while (b < e && vct_issp(*b))
220 0
                b++;
221 232120
        if (b == e)
222 84
                return (nan(""));
223
224 232036
        switch (*b++) {
225
        case 's':
226 202328
                sc = 1.0;
227 202328
                break;
228
        case 'm':
229 28196
                if (b < e && *b == 's') {
230 420
                        sc = 1e-3;
231 420
                        b++;
232 420
                } else
233 27776
                        sc = 60.0;
234 28196
                break;
235
        case 'h':
236 532
                sc = 60.0 * 60.0;
237 532
                break;
238
        case 'd':
239 420
                sc = 60.0 * 60.0 * 24.0;
240 420
                break;
241
        case 'w':
242 224
                sc = 60.0 * 60.0 * 24.0 * 7.0;
243 224
                break;
244
        case 'y':
245 140
                sc = 60.0 * 60.0 * 24.0 * 365.0;
246 140
                break;
247
        default:
248 196
                return (nan(""));
249
        }
250
251 231896
        while (b < e && vct_issp(*b))
252 56
                b++;
253
254 231840
        if (b < e)
255 56
                return (nan(""));
256
257 231784
        return (r * sc);
258 232120
}
259
260
vtim_dur
261 1932
VNUM_duration(const char *p)
262
{
263
        const char *t;
264
        vtim_dur r;
265
266 1932
        if (p == NULL)
267 280
                return (nan(""));
268
269 1652
        r = SF_Parse_Number(&p, 0, &t);
270
271 1652
        if (errno)
272 56
                return (nan(""));
273
274 1596
        return (VNUM_duration_unit(r, p, NULL));
275 1932
}
276
277
/**********************************************************************/
278
279
int64_t
280 3777561
VNUM_bytes_unit(double r, const char *b, const char *e, uintmax_t rel,
281
    const char **errtxt)
282
{
283 3777561
        double sc = 1.0, tmp;
284
285 3777561
        AN(b);
286 3777561
        AN(errtxt);
287 3777561
        errno = 0;
288 3777561
        if (e == NULL)
289 3776273
                e = strchr(b, '\0');
290
291 3777561
        while (b < e && vct_issp(*b))
292 0
                b++;
293 3777561
        if (b == e) {
294 187880
                if (modf(r, &tmp) != 0.0) {
295 28
                        *errtxt = err_fractional_bytes;
296 28
                        errno = EINVAL;
297 28
                }
298 187880
                return ((int64_t)trunc(sc * r));
299
        }
300
301 3589681
        if (rel != 0 && *b == '%') {
302 112
                r *= rel * 0.01;
303 112
                b++;
304 112
        } else {
305 3589569
                switch (*b) {
306 1388996
                case 'k': case 'K': sc = exp2(10); b++; break;
307 392053
                case 'm': case 'M': sc = exp2(20); b++; break;
308 396676
                case 'g': case 'G': sc = exp2(30); b++; break;
309 168
                case 't': case 'T': sc = exp2(40); b++; break;
310 112
                case 'p': case 'P': sc = exp2(50); b++; break;
311
                case 'b': case 'B':
312 1411396
                        if (modf(r, &tmp) != 0.0) {
313 56
                                *errtxt = err_fractional_bytes;
314 56
                                errno = EINVAL;
315 56
                                return (0);
316
                        }
317 1411340
                        break;
318
                default:
319 168
                        *errtxt = err_unknown_bytes;
320 168
                        errno = EINVAL;
321 168
                        return (0);
322
                }
323 3589345
                if (b < e && (*b == 'b' || *b == 'B'))
324 1412264
                        b++;
325
        }
326 3589513
        while (b < e && vct_issp(*b))
327 56
                b++;
328 3589457
        if (b < e) {
329 0
                *errtxt = err_unknown_bytes;
330 0
                errno = EINVAL;
331 0
                return (0);
332
        }
333 3589457
        return ((int64_t)trunc(sc * r));
334 3777561
}
335
336
const char *
337 3776777
VNUM_2bytes(const char *p, uintmax_t *r, uintmax_t rel)
338
{
339
        double fval;
340
        const char *errtxt;
341
342 3776777
        if (p == NULL || *p == '\0')
343 308
                return (err_invalid_num);
344
345 3776469
        fval = SF_Parse_Number(&p, 1, &errtxt);
346 3776469
        if (errno)
347 168
                return (errtxt);
348 3776301
        if (fval < 0)
349 28
                return (err_invalid_num);
350
351 3776273
        fval = VNUM_bytes_unit(fval, p, NULL, rel, &errtxt);
352 3776273
        if (errno)
353 224
                return (errtxt);
354 3776049
        *r = (uintmax_t)round(fval);
355 3776049
        return (NULL);
356 3776777
}
357
358
/**********************************************************************/
359
360
static const uint8_t hex_table[] = {
361
        0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
362
        127, 127, 127, 127, 127, 127, 127, 10,  11,  12,
363
        13,  14,  15,  127, 127, 127, 127, 127, 127, 127,
364
        127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
365
        127, 127, 127, 127, 127, 127, 127, 127, 127, 10,
366
        11,  12,  13,  14,  15
367
};
368
369
static ssize_t
370 178955
vnum_uint(const char *b, const char *e, const char **p, unsigned base)
371
{
372
        ssize_t u;
373
        unsigned n;
374
375 178955
        AN(b);
376 178955
        AN(p);
377 178955
        if (e == NULL)
378 172431
                e = strchr(b, '\0');
379
380 178955
        u = 0;
381 178955
        if (!vct_ishex(*b) || hex_table[*b - '0'] >= base) {
382 394
                *p = b;
383 394
                return (-1);
384
        }
385
386 456663
        for (; b < e && vct_ishex(*b) && hex_table[*b - '0'] < base; b++) {
387 278130
                if (u > (SSIZE_MAX / base)) {
388 0
                        u = -2;
389 0
                        break;
390
                }
391 278130
                u *= base;
392 278130
                n = hex_table[*b - '0'];
393 278130
                if (u > (SSIZE_MAX - n)) {
394 28
                        u = -2;
395 28
                        break;
396
                }
397 278102
                u += n;
398 278102
        }
399
400 178561
        *p = b;
401 178561
        return (u);
402 178955
}
403
404
ssize_t
405 172431
VNUM_uint(const char *b, const char *e, const char **p)
406
{
407
408 172431
        return (vnum_uint(b, e, p, 10));
409
}
410
411
ssize_t
412 6524
VNUM_hex(const char *b, const char *e, const char **p)
413
{
414
415 6524
        return (vnum_uint(b, e, p, 16));
416
}
417
418
#ifdef NUM_C_TEST
419
/*
420
 * Compile with:
421
 *     cc -o foo -DNUM_C_TEST -DTEST_VERBOSE \
422
 *         -I../.. -I../../include vnum.c vas.c vct.c -lm
423
 */
424
425
static const struct test_sf_parse_int {
426
        const char *input;
427
        int maxdig;
428
        int64_t retval;
429
        int consumed;
430
        int sign;
431
        const char *errtxt;
432
} test_sf_parse_int[] = {
433
        { "1234",       3,  123, 3,  1, err_fatnum },
434
        { "1234",       4, 1234, 4,  1, NULL },
435
        { "1234",       5, 1234, 4,  1, NULL },
436
        { "-",          5,    0, 1, -1, err_no_digits },
437
        { "  ",         5,    0, 2,  1, err_no_digits },
438
        { "-1234",      3,  123, 4, -1, err_fatnum },
439
        { "-1234",      4, 1234, 5, -1, NULL },
440
        { "-1234",      5, 1234, 5, -1, NULL },
441
        { " -1234",     5, 1234, 6, -1, NULL },
442
        { " -1234 ",    5, 1234, 7, -1, NULL },
443
        { " -12 34 ",   5,   12, 5, -1, NULL },
444
        { " - 12 34 ",  5,    0, 2, -1, err_no_digits },
445
        { NULL},
446
};
447
448
static const struct test_sf_parse_number {
449
        const char *input;
450
        int strict;
451
        double retval;
452
        int consumed;
453
        const char *errtxt;
454
} test_sf_parse_number[] = {
455
        { "1234",               1,          1234.000,  4, NULL },
456
        { " 1234",              1,          1234.000,  5, NULL },
457
        { " 1234 ",             1,          1234.000,  6, NULL },
458
        { " 1234. ",            1,          1234.000,  6, err_invalid_num },
459
        { " 123456789012.0 ",   1,  123456789012.000, 16, NULL },
460
        { " 1234567890123.0 ",  1, 1234567890123.000, 14, err_fatnum },
461
        { " 123456789012.123 ", 1,  123456789012.123, 18, NULL },
462
        { " 123456789012.1234 ",1,  123456789012.123, 17, err_fatnum },
463
        { " -0.123456 ",        1,              .123,  7, err_fatnum },
464
        { " -.123456 ",         1,             0.,     2, err_no_digits },
465
        { " .123456 ",          1,             0.,     1, err_no_digits },
466
        { " 0. ",               1,             0.,     3, err_invalid_num },
467
        { " .0 ",               1,             0.,     1, err_no_digits },
468
469
        { " 123456789012.1234 ",0,  123456789012.123, 19, NULL },
470
        { " -0.123456 ",        0,             -.123, 11, NULL },
471
        { " -.123456 ",         0,             -.123, 10, NULL },
472
        { " .123456 ",          0,              .123,  9, NULL },
473
        { " 0. ",               0,             0.,     4, NULL },
474
        { " .0 ",               0,             0.,     4, NULL },
475
        { " -0. ",              0,            -0.,     5, NULL },
476
        { " -.0 ",              0,            -0.,     5, NULL },
477
        { " - ",                0,            -0.,     2, err_no_digits },
478
        { " -. ",               0,             0.,     2, err_no_digits },
479
        { " . ",                0,             0.,     1, err_no_digits },
480
        { NULL},
481
};
482
483
static struct test_case {
484
        const char *str;
485
        uintmax_t rel;
486
        uintmax_t val;
487
        const char *err;
488
} test_cases[] = {
489
        { "1",                  (uintmax_t)0,   (uintmax_t)1 },
490
        { "1B",                 (uintmax_t)0,   (uintmax_t)1<<0 },
491
        { "1 B",                (uintmax_t)0,   (uintmax_t)1<<0 },
492
        { "1.3B",               0,      0,      err_fractional_bytes },
493
        { "1.7B",               0,      0,      err_fractional_bytes },
494
495
        { "1024",               (uintmax_t)0,   (uintmax_t)1024 },
496
        { "1k",                 (uintmax_t)0,   (uintmax_t)1<<10 },
497
        { "1kB",                (uintmax_t)0,   (uintmax_t)1<<10 },
498
        { "0.75kB",             (uintmax_t)0,   (uintmax_t)768 },
499
        { "1.3kB",              (uintmax_t)0,   (uintmax_t)1331 },
500
        { "1.70kB",             (uintmax_t)0,   (uintmax_t)1740 },
501
502
        { "1048576",            (uintmax_t)0,   (uintmax_t)1048576 },
503
        { "1M",                 (uintmax_t)0,   (uintmax_t)1<<20 },
504
        { "1MB",                (uintmax_t)0,   (uintmax_t)1<<20 },
505
        { "1.3MB",              (uintmax_t)0,   (uintmax_t)1363148 },
506
        { "1.700MB",            (uintmax_t)0,   (uintmax_t)1782579 },
507
508
        { "1073741824",         (uintmax_t)0,   (uintmax_t)1073741824 },
509
        { "1G",                 (uintmax_t)0,   (uintmax_t)1<<30 },
510
        { "1GB",                (uintmax_t)0,   (uintmax_t)1<<30 },
511
        { "1.3GB",              (uintmax_t)0,   (uintmax_t)1395864371 },
512
        { "1.7GB",              (uintmax_t)0,   (uintmax_t)1825361100 },
513
514
        { "1099511627776",      (uintmax_t)0,   (uintmax_t)1099511627776ULL },
515
        { "1T",                 (uintmax_t)0,   (uintmax_t)1<<40 },
516
        { "1TB",                (uintmax_t)0,   (uintmax_t)1<<40 },
517
        { "1.3TB",              (uintmax_t)0,   (uintmax_t)1429365116108ULL },
518
        { "1.7\tTB",            (uintmax_t)0,   (uintmax_t)1869169767219ULL },
519
520
        { "999999999999999",    (uintmax_t)0,   (uintmax_t)999999999999999ULL},
521
522
        { "1125899906842624",   0,      0,      err_fatnum },
523
        { "1P\t",               (uintmax_t)0,   (uintmax_t)1125899906842624ULL},
524
        { "1PB ",               (uintmax_t)0,   (uintmax_t)1125899906842624ULL},
525
        { "1.3 PB",             (uintmax_t)0,   (uintmax_t)1463669878895411ULL},
526
527
        { "1.5%",               (uintmax_t)1024,        (uintmax_t)15 },
528
        { "1.501%",             (uintmax_t)1024,        (uintmax_t)15 },
529
        { "2%",                 (uintmax_t)1024,        (uintmax_t)20 },
530
        { "3%",                 (uintmax_t)1024,        (uintmax_t)30 },
531
532
        /* Check the error checks */
533
        { "",                   0,      0,      err_invalid_num },
534
        { "-1",                 0,      0,      err_invalid_num },
535
        { "1.3",                0,      0,      err_fractional_bytes},
536
        { "1.5011%",            0,      0,      err_fatnum },
537
        { "-",                  0,      0,      err_no_digits },
538
        { "m",                  0,      0,      err_no_digits },
539
        { "4%",                 0,      0,      err_unknown_bytes },
540
        { "3*",                 0,      0,      err_unknown_bytes },
541
542
        /* TODO: add more */
543
544
        { 0, 0, 0 },
545
};
546
547
static const char *vec[] = {
548
        " 1",
549
        " 12",
550
        " 12.",
551
        " 12.3",
552
        " 12.34",
553
        "N12.34e-3",
554
        "N12.34e3",
555
        "N12.34e+3",
556
        "N+12.34e-3",
557
        "N-12.34e3",
558
        "N.",
559
        "N.12.",
560
        "N12..",
561
        "N12.,",
562
        "N12e,",
563
        "N12e+,",
564
        "N12ee,",
565
        "N1..2",
566
        "NA",
567
        "N1A",
568
        "Ne-3",
569
        NULL
570
};
571
572
int
573 28
main(int argc, char *argv[])
574
{
575 28
        int ec = 0;
576
        struct test_case *tc;
577
        uintmax_t val;
578
        const char **p;
579
        const char *e;
580
        double d1, d2;
581
        const struct test_sf_parse_int *tspi;
582
        const struct test_sf_parse_number *tspn;
583
        int64_t i64;
584
        volatile double dbl;
585
        int sign, consumed;
586
        const char *errtxt;
587
        const char *input;
588
        char buf1[30];
589
        char buf2[30];
590
591 28
        (void)argc;
592
593 28
        setbuf(stdout, NULL);
594 28
        setbuf(stderr, NULL);
595
596 364
        for (tspi = test_sf_parse_int; tspi->input != NULL; tspi++) {
597 336
                errtxt = "(unset)";
598 336
                input = tspi->input;
599 336
                i64 = sf_parse_int(&input, &errtxt, &sign, tspi->maxdig);
600 336
                consumed = input - tspi->input;
601 672
                if (i64 != tspi->retval ||
602 336
                    sign != tspi->sign ||
603 336
                    consumed != tspi->consumed ||
604 336
                    errtxt != tspi->errtxt) {
605 0
                        ec++;
606 0
                        printf("sf_parse_int(%s, maxdig=%d) failed\n",
607 0
                            tspi->input, tspi->maxdig);
608
#ifdef TEST_VERBOSE
609
                        printf("    retval\texpected %jd\tgot %jd\n",
610
                            (intmax_t)tspi->retval, (intmax_t)i64);
611
                        printf("    sign\texpected %d\tgot %d\n",
612
                            tspi->sign, sign);
613
                        printf("    consumed\texpected %d\tgot %d\n",
614
                            tspi->consumed, consumed);
615
                        printf("    errtxt\texpected %p\tgot %p\n",
616
                            tspi->errtxt, errtxt);
617
                        printf("    errtxt\texpected %s\tgot %s\n",
618
                            tspi->errtxt, errtxt);
619
#endif
620 0
                }
621 336
        }
622
623 700
        for (tspn = test_sf_parse_number; tspn->input != NULL; tspn++) {
624 672
                errtxt = "(unset)";
625 672
                input = tspn->input;
626 672
                dbl = SF_Parse_Number(&input, tspn->strict, &errtxt);
627 672
                consumed = input - tspn->input;
628 672
                bprintf(buf1, "%.4f", dbl);
629 672
                bprintf(buf2, "%.4f", tspn->retval);
630 1344
                if (strcmp(buf1, buf2) ||
631 672
                    consumed != tspn->consumed ||
632 672
                    errtxt != tspn->errtxt) {
633 0
                        ec++;
634 0
                        printf("sf_parse_number(%s, strict=%d) failed\n",
635 0
                            tspn->input, tspn->strict);
636
#ifdef TEST_VERBOSE
637
                        printf("    retval\texpected %.4f\tgot %.4f\t(%e)\n",
638
                            tspn->retval, dbl, dbl - tspn->retval);
639
                        printf("    retval\texpected %a\tgot %a\n",
640
                            tspn->retval, dbl);
641
                        printf("    retval\texpected %s\tgot %s\n",
642
                            buf2, buf1);
643
                        printf("    retval\tdelta %e\n",
644
                            dbl - tspn->retval);
645
                        printf("    consumed\texpected %d\tgot %d\n",
646
                            tspn->consumed, consumed);
647
                        printf("    errtxt\texpected %p\tgot %p\n",
648
                            tspn->errtxt, errtxt);
649
                        printf("    errtxt\texpected %s\tgot %s\n",
650
                            tspn->errtxt, errtxt);
651
#endif
652 0
                }
653 672
        }
654
655 616
        for (p = vec; *p != NULL; p++) {
656 588
                e = *p;
657 588
                d1 = VNUM(e + 1);
658 588
                if (*e == 'N') {
659 448
                        if (!isnan(d1)) {
660 0
                                ec++;
661 0
                                printf("VNUM(%s) not NAN (%g)\n", e + 1, d1);
662 0
                        }
663 448
                } else {
664 140
                        d2 = atof(e + 1);
665 140
                        if (isnan(d1)) {
666 0
                                printf("VNUM(%s) is NAN (%g)\n", e + 1, d1);
667 0
                                ec++;
668 140
                        } else if (fabs((d1 - d2) / d2) > 1e-15) {
669 0
                                printf("VNUM(%s) differs from atof() (%g)\n",
670 0
                                    e + 1, d1);
671 0
                                ec++;
672 0
                        }
673
                }
674 588
        }
675
676 1232
        for (tc = test_cases; tc->str; ++tc) {
677 1204
                e = VNUM_2bytes(tc->str, &val, tc->rel);
678 1204
                if (e != NULL)
679 308
                        val = 0;
680 1204
                if (e == tc->err && val == tc->val)
681 1204
                        continue;
682 0
                ++ec;
683 0
                printf("%s: VNUM_2bytes(\"%s\", %ju)\n",
684 0
                   *argv, tc->str, tc->rel);
685 0
                printf("\tExpected:\tstatus %s - value %ju\n",
686 0
                    tc->err ? tc->err : "Success", tc->val);
687 0
                printf("\tGot:\t\tstatus %s - value %ju\n",
688 0
                    e ? e : "Success", val);
689 0
        }
690 28
        if (!isnan(VNUM_duration(NULL))) {
691 0
                printf("%s: VNUM_Duration(NULL) fail\n", *argv);
692 0
                ++ec;
693 0
        }
694 28
        d1 = VNUM_duration(" 365.24219d ");
695 28
        d2 = 31556908.8;
696 28
        if (fabs(d1 - d2) > VNUM_EPSILON) {
697 0
                printf("%s: VNUM_Duration() wrong, %.3f delta = %e\n",
698 0
                    *argv, d1, d1 - d2);
699 0
                ++ec;
700 0
        }
701
        /* TODO: test invalid strings */
702 28
        if (!ec)
703 28
                printf("OK\n");
704 28
        return (ec > 0);
705
}
706
#endif