nrn_vsscanf.cpp

Go to the documentation of this file.

/* modified for use for NrnFILEWrap */
/* now included by nrnfilewrap.cpp */
/*
 * libslack - http://libslack.org/
 *
 * Copyright (C) 1999-2010 raf <raf@raf.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * or visit http://www.gnu.org/copyleft/gpl.html
 *
 * 20100612 raf <raf@raf.org>
 */
 
/*
 
=head1 NAME
 
I<vsscanf(3)> - I<sscanf(3)> with a I<va_list> parameter
 
=head1 SYNOPSIS
 
    #include <slack/std.h>
    #ifndef HAVE_VSSCANF
    #include <slack/vsscanf.h>
    #endif
 
    int vsscanf(const char *str, const char *format, va_list args);
 
=head1 DESCRIPTION
 
Similar to I<sscanf(3)> with the variable argument list specified directly
as for I<vprintf(3)>.
 
Note that this may not be identical in behaviour to the I<sscanf(3)> on your
system because this was implemented from scratch for systems that lack
I<vsscanf(3)>. So your I<sscanf(3)> and this I<vsscanf(3)> share no common
code. Your I<sscanf(3)> may support extensions that I<vsscanf(3)> does not
support. I<vsscanf(3)> complies with all of the relevant ISO C requirements
for I<sscanf(3)> except:
 
=over 4
 
=item *
 
C<format> may not be a multibyte character string; and
 
=item *
 
Scanning a pointer (C<"%p">) may not exactly match the format that your
I<printf(3)> uses to print pointers on your system. This version accepts
pointers as a hexadecimal number with or without a preceding C<0x>.
 
=back
 
=head1 MT-Level
 
MT-Safe if and only if no thread calls I<setlocale(3)>. Since locales are
inherently non-threadsafe as they are currently defined, this shouldn't be a
problem. Just call C<setlocale(LC_ALL, "")> once after program
initialisation and never again (at least not after creating any threads). If
it is a problem, just change C<localeconv()-E<gt>decimal_point[0]> in the source
to C<'.'> and it will be MT-Safe at the expense of losing locale support.
 
=head1 EXAMPLE
 
    #include <slack/std.h>
    #ifndef HAVE_VSSCANF
    #include <slack/vsscanf.h>
    #endif
 
    int fdscanf(int fd, const char *format, ...)
    {
        va_list args;
        char buf[BUFSIZ];
        ssize_t bytes;
        int rc;
 
        if ((bytes = read(fd, buf, BUFSIZ)) <= 0)
            return bytes;
 
        buf[bytes] = '\0';
 
        va_start(args, format);
        rc = vsscanf(buf, format, args);
        va_end(args);
 
        return rc;
    }
 
    int main()
    {
        int rc, a = 0, b = 0;
 
        rc = fdscanf(STDIN_FILENO, "%d %d", &a, &b);
        printf("rc = %d a = %d b = %d\n", rc, a, b);
 
        return (rc == 2) ? EXIT_SUCCESS : EXIT_FAILURE;
    }
 
=head1 NOTE
 
I<gcc(1)> warns that:
 
    warning: ANSI C does not support the `L' length modifier
    warning: use of `l' length character with `e' type character
 
However, the ANSI C standard (Section 7.9.6.2) states that:
 
"Finally, the conversion specifiers C<e>, C<f>, and C<g> shall be preceded
by C<l> if the corresponding argument is a pointer to I<double> rather than
a pointer to C<float>, or by C<L> if it is a pointer to I<long double>."
 
I have chosen to disregard the I<gcc(1)> warnings in favour of the standard.
If you see the above warnings when compiling the unit tests for
I<vsscanf(3)>, just ignore them.
 
=head1 SEE ALSO
 
I<libslack(3)>,
I<sscanf(3)>
 
=head1 AUTHOR
 
20100612 raf <raf@raf.org>
 
=cut
 
*/
 
#if USE_NRNFILEWRAP
#else
#include "config.h"
#include "std.h"
 
#include <locale.h>
#endif
 
#if USE_NRNFILEWRAP
int nrn_vsscanf(const char* str, const char** rs, const char* format, va_list args)
#else
int vsscanf(const char* str, const char* format, va_list args)
#endif
{
    const char *f, *s;
#if USE_NRNFILEWRAP
    const char point = '.';
#else
    const char point = localeconv()->decimal_point[0];
#endif
    int cnv = 0;
 
    for (s = str, f = format; *f; ++f) {
        if (*f == '%') {
            int size = 0;
            int width = 0;
            int do_cnv = 1;
 
            if (*++f == '*')
                ++f, do_cnv = 0;
 
            for (; isdigit((int) (unsigned int) *f); ++f)
                width *= 10, width += *f - '0';
 
            if (*f == 'h' || *f == 'l' || *f == 'L')
                size = *f++;
 
            if (*f != '[' && *f != 'c' && *f != 'n')
                while (isspace((int) (unsigned int) *s))
                    ++s;
 
#define COPY *b++ = *s++, --width
#define MATCH(cond)      \
    if (width && (cond)) \
        COPY;
#define MATCH_ACTION(cond, action) \
    if (width && (cond)) {         \
        COPY;                      \
        action;                    \
    }
#define MATCHES_ACTION(cond, action) \
    while (width && (cond)) {        \
        COPY;                        \
        action;                      \
    }
#define FAIL (cnv) ? cnv : EOF
            switch (*f) {
            case 'd':
            case 'i':
            case 'o':
            case 'u':
            case 'x':
            case 'X':
            case 'p': {
                static const char types[] = "diouxXp";
                static const int bases[] = {10, 0, 8, 10, 16, 16, 16};
                static const char digitset[] = "0123456789abcdefABCDEF";
                static const int setsizes[] = {
                    10, 0, 0, 0, 0, 0, 0, 0, 8, 0, 10, 0, 0, 0, 0, 0, 22};
                int base = bases[strchr(types, *f) - types];
                int setsize;
                char buf[513];
                char* b = buf;
                int digit = 0;
                if (width <= 0 || width > 512)
                    width = 512;
                MATCH(*s == '+' || *s == '-')
                MATCH_ACTION(*s == '0', digit = 1;
                             MATCH_ACTION((*s == 'x' || *s == 'X') && (base == 0 || base == 16),
                                          base = 16) else base = 8;)
                setsize = setsizes[base];
                MATCHES_ACTION(memchr(digitset, *s, setsize), digit = 1)
                if (!digit) {
                    *rs = s;
                    return FAIL;
                }
                *b = '\0';
                if (do_cnv) {
                    if (*f == 'd' || *f == 'i') {
                        long data = strtol(buf, NULL, base);
                        if (size == 'h')
                            *va_arg(args, short*) = (short) data;
                        else if (size == 'l')
                            *va_arg(args, long*) = data;
                        else
                            *va_arg(args, int*) = (int) data;
                    } else {
                        unsigned long data = strtoul(buf, NULL, base);
                        if (size == 'p')
                            *va_arg(args, void**) = (void*) data;
                        else if (size == 'h')
                            *va_arg(args, unsigned short*) = (unsigned short) data;
                        else if (size == 'l')
                            *va_arg(args, unsigned long*) = data;
                        else
                            *va_arg(args, unsigned int*) = (unsigned int) data;
                    }
                    ++cnv;
                }
                break;
            }
 
            case 'e':
            case 'E':
            case 'f':
            case 'g':
            case 'G': {
                char buf[513];
                char* b = buf;
                int digit = 0;
                if (width <= 0 || width > 512)
                    width = 512;
                MATCH(*s == '+' || *s == '-')
                MATCHES_ACTION(isdigit((int) (unsigned int) *s), digit = 1)
                MATCH(*s == point)
                MATCHES_ACTION(isdigit((int) (unsigned int) *s), digit = 1)
                MATCHES_ACTION(digit && (*s == 'e' || *s == 'E'),
                               MATCH(*s == '+' || *s == '-') digit = 0;
                               MATCHES_ACTION(isdigit((int) (unsigned int) *s), digit = 1))
                if (!digit) {
                    *rs = s;
                    return FAIL;
                }
                *b = '\0';
                if (do_cnv) {
                    double data = strtod(buf, NULL);
                    if (size == 'l')
                        *va_arg(args, double*) = data;
                    else if (size == 'L')
                        *va_arg(args, long double*) = (long double) data;
                    else
                        *va_arg(args, float*) = (float) data;
                    ++cnv;
                }
                break;
            }
 
            case 's': {
                char* arg = va_arg(args, char*);
                if (width <= 0)
                    width = INT_MAX;
                while (width-- && *s && !isspace((int) (unsigned int) *s))
                    if (do_cnv)
                        *arg++ = *s++;
                if (do_cnv)
                    *arg = '\0', ++cnv;
                break;
            }
 
            case '[': {
                char* arg = va_arg(args, char*);
                int setcomp = 0;
                size_t setsize;
                const char* end;
                if (width <= 0)
                    width = INT_MAX;
                if (*++f == '^')
                    setcomp = 1, ++f;
                end = strchr((*f == ']') ? f + 1 : f, ']');
                if (!end) {
                    *rs = s;
                    return FAIL;
                }                  /* Could be cnv to match glibc-2.2 */
                setsize = end - f; /* But FAIL matches the C standard */
                while (width-- && *s) {
                    if (!setcomp && !memchr(f, *s, setsize))
                        break;
                    if (setcomp && memchr(f, *s, setsize))
                        break;
                    if (do_cnv)
                        *arg++ = *s++;
                }
                if (do_cnv)
                    *arg = '\0', ++cnv;
                f = end;
                break;
            }
 
            case 'c': {
                char* arg = va_arg(args, char*);
                if (width <= 0)
                    width = 1;
                while (width--) {
                    if (!*s) {
                        *rs = s;
                        return FAIL;
                    }
                    if (do_cnv)
                        *arg++ = *s++;
                }
                if (do_cnv)
                    ++cnv;
                break;
            }
 
            case 'n': {
                if (size == 'h')
                    *va_arg(args, short*) = (short) (s - str);
                else if (size == 'l')
                    *va_arg(args, long*) = (long) (s - str);
                else
                    *va_arg(args, int*) = (int) (s - str);
                break;
            }
 
            case '%': {
                if (*s++ != '%') {
                    *rs = s;
                    return cnv;
                }
                break;
            }
 
            default:
                *rs = s;
                return FAIL;
            }
        } else if (isspace((int) (unsigned int) *f)) {
            while (isspace((int) (unsigned int) f[1]))
                ++f;
            while (isspace((int) (unsigned int) *s))
                ++s;
        } else {
            if (*s++ != *f) {
                *rs = s;
                return cnv;
            }
        }
    }
 
    *rs = s;
    return cnv;
}
 
#if 0
#ifdef TEST
 
#undef _ISOC9X_SOURCE
#undef __USE_ISOC9X
#include <math.h>
#include <float.h>
 
int test_sscanf(const char *str, const char *format, ...)
{
    int rc;
    va_list args;
    va_start(args, format);
    rc = vsscanf(str, format, args);
    va_end(args);
    return rc;
}
 
int main(int ac, char **av)
{
    int errors = 0;
    short si1, si2;
    int i1, i2;
    long li1, li2;
    float f1, f2;
    double d1, d2;
    long double ld1, ld2;
    void *p1, *p2;
    char b1[128], b2[128];
    char c1[128], c2[128];
    char s1[128], s2[128];
    short sn1, sn2;
    int in1, in2;
    long ln1, ln2;
    unsigned short su1, su2;
    unsigned int u1, u2;
    unsigned long lu1, lu2;
    char str[512];
    int rc1, rc2;
 
    if (ac == 2 && !strcmp(av[1], "help"))
    {
        printf("usage: %s [show]\n", *av);
        return EXIT_SUCCESS;
    }
 
    printf("Testing: %s\n", "vsscanf");
 
    /* Test one of everything */
 
    sprintf(str, " abc -12 37 101 3.4e-1 12.34 102.23 xyz %p def ghi jkl %% ",
        p1 = (void *)0xdeadbeef
    );
 
    if (ac >= 2 && !strcmp(av[1], "show"))
        printf("%s\n", str);
 
    rc1 = sscanf(str,
        " abc %hd %d %ld %e %le %Le xyz %p %[^abc ] %3c %s%hn %n%% %ln",
        &si1, &i1, &li1, &f1, &d1, &ld1, &p1, b1, c1, s1, &sn1, &in1, &ln1
    );
 
    rc2 = test_sscanf(str,
        " abc %hd %d %ld %e %le %Le xyz %p %[^abc ] %3c %s%hn %n%% %ln",
        &si2, &i2, &li2, &f2, &d2, &ld2, &p2, b2, c2, s2, &sn2, &in2, &ln2
    );
 
    if (rc1 != rc2)
        ++errors, printf("Test1: failed (returned %d, not %d)\n", rc2, rc1);
    if (si1 != si2)
        ++errors, printf("Test2: failed (%%hd scanned %hd, not %hd)\n", si2, si1);
    if (i1 != i2)
        ++errors, printf("Test3: failed (%%d scanned %d, not %d)\n", i2, i1);
    if (li1 != li2)
        ++errors, printf("Test4: failed (%%ld scanned %ld, not %ld)\n", li2, li1);
    if (fabs(f2 - 3.4e-1) / 3.4e-1 >= 4 * FLT_EPSILON)
        ++errors, printf("Test5: failed (%%e scanned %e, not %e)\n", f2, f1);
    if (fabs(d2 - 12.34) / 12.34 >= 4 * DBL_EPSILON)
        ++errors, printf("Test6: failed (%%le scanned %le, not %le)\n", d2, d1);
    if (fabs(ld2 - 102.23) / 102.23 >= 4 * LDBL_EPSILON)
        ++errors, printf("Test7: failed (%%Le scanned %Le, not %Le)\n", ld2, ld1);
    if (p1 != p2)
        ++errors, printf("Test8: failed (%%p scanned %p, not %p)\n", p2, p1);
    if (strcmp(b1, b2))
        ++errors, printf("Test9: failed (%%[^abc ] scanned \"%s\", not \"%s\")\n", b2, b1);
    if (memcmp(c1, c2, 3))
        ++errors, printf("Test10: failed (%%3c scanned \"%3.3s\", not \"%3.3s\")\n", c2, c1);
    if (strcmp(s1, s2))
        ++errors, printf("Test11: failed (%%s scanned \"%s\", not \"%s\")\n", s2, s1);
    if (sn1 != sn2)
        ++errors, printf("Test12: failed (%%hn scanned %hd, not %hd)\n", sn2, sn1);
    if (in1 != in2)
        ++errors, printf("Test13: failed (%%n scanned %d, not %d)\n", in2, in1);
    if (ln1 != ln2)
        ++errors, printf("Test14: failed (%%ln scanned %ld, not %ld)\n", ln2, ln1);
 
    /* Test different numeric bases */
 
#define TEST_NUM(i, var, tst, str, format)                                                        \
    rc1 = sscanf(str, format, &s##var##1, &var##1, &l##var##1);                                   \
    rc2 = test_sscanf(str, format, &s##var##2, &var##2, &l##var##2);                              \
    if (rc1 != rc2)                                                                               \
        ++errors, printf("Test%d: failed (returned %d, not %d)\n", (i), rc2, rc1);                \
    if (s##var##1 != s##var##2)                                                                   \
        ++errors, printf("Test%d: failed (%%h%c scanned %hd, not %hd)\n",                         \
                         (i),                                                                     \
                         tst,                                                                     \
                         s##var##2,                                                               \
                         s##var##1);                                                              \
    if (var##1 != var##2)                                                                         \
        ++errors, printf("Test%d: failed (%%%c scanned %d, not %d)\n", (i), tst, var##2, var##1); \
    if (l##var##1 != l##var##2)                                                                   \
    ++errors,                                                                                     \
        printf("Test%d: failed (%%l%c scanned %ld, not %ld)\n", (i), tst, l##var##2, l##var##1)
 
#define TEST_STR(i, len, str, format)                                                          \
    rc1 = sscanf(str, format, b1, c1, s1);                                                     \
    rc2 = test_sscanf(str, format, b2, c2, s2);                                                \
    if (rc1 != rc2)                                                                            \
        ++errors, printf("Test%d: failed (returned %d, not %d)\n", (i), rc2, rc1);             \
    if (strcmp(b1, b2))                                                                        \
        ++errors,                                                                              \
            printf("Test%d: failed (%%%d[ scanned \"%s\", not \"%s\")\n", (i), (len), b2, b1); \
    if (memcmp(c1, c2, len))                                                                   \
        ++errors, printf("Test%d: failed (%%%dc scanned \"%*.*s\", not \"%*.*s\")\n",          \
                         (i),                                                                  \
                         (len),                                                                \
                         (len),                                                                \
                         (len),                                                                \
                         c2,                                                                   \
                         (len),                                                                \
                         (len),                                                                \
                         c1);                                                                  \
    if (strcmp(s1, s2))                                                                        \
    ++errors, printf("Test%d: failed (%%%ds scanned \"%s\", not \"%s\")\n", (i), (len), s2, s1)
 
    TEST_NUM(15, i, 'i', "37 21 53", "%hi %i %li");
    TEST_NUM(16, i, 'i', "037 021 053", "%hi %i %li");
    TEST_NUM(17, i, 'i', "0x37 0x21 0x53", "%hi %i %li");
    TEST_NUM(18, u, 'o', "037 021 053", "%ho %o %lo");
    TEST_NUM(19, u, 'u', "37 21 53", "%hu %u %lu");
    TEST_NUM(20, u, 'x', "0x37 0x21 0x53", "%hx %x %lx");
    TEST_NUM(21, u, 'X', "0x37 0x21 0x53", "%hx %x %lx");
 
    /* Test field width handling */
 
    TEST_NUM(22, i, 'd', "123456789", "%3hd %2d %4ld");
    TEST_NUM(23, i, 'i', "123456789", "%3hi %2i %4li");
    TEST_NUM(24, i, 'i', "012340789", "%3hi %2i %4li");
    TEST_NUM(25, i, 'x', "123456789", "%3hi %2i %4li");
    TEST_NUM(26, u, 'o', "012340789", "%3ho %2o %4lo");
    TEST_NUM(27, u, 'u', "123456789", "%3hu %2u %4lu");
    TEST_NUM(28, u, 'x', "123456789", "%3hx %2x %4lx");
    TEST_NUM(29, u, 'X', "123456789", "%3hx %2X %4lX");
    TEST_STR(30, 1, "abcd", "%1[a]%c%1s");
 
    TEST_STR(31, 5, "abc\001d e f g h i", "%5[][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@#$%^&*()_=+\\|{};':\",./<>?   -]%5c%5s");
    TEST_STR(32, 3, "abc\001d e f g h i", "%3[][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@#$%^&*()_=+\\|{};':\",./<>?   -]%3c%3s");
    TEST_STR(33, 7, "abc\001d e f g h i", "%7[][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@#$%^&*()_=+\\|{};':\",./<>?   -]%7c%7s");
    TEST_STR(34, 2, "abc\001d e f g h i", "%2[][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@#$%^&*()_=+\\|{};':\",./<>?   -]%2c%2s");
 
    /* Test error reporting */
 
#define TEST_ERR(i, str, format)    \
    rc1 = sscanf(str, format);      \
    rc2 = test_sscanf(str, format); \
    if (rc1 != rc2)                 \
    ++errors, printf("Test%d: failed (returned %d, not %d)\n", (i), rc2, rc1)
 
#define TEST_ERR_ARG(i, str, format, var)    \
    rc1 = sscanf(str, format, &var##1);      \
    rc2 = test_sscanf(str, format, &var##1); \
    if (rc1 != rc2)                          \
    ++errors, printf("Test%d: failed (returned %d, not %d)\n", (i), rc2, rc1)
 
    TEST_ERR_ARG(35, "", "%d", i);
    TEST_ERR_ARG(36, "", "%i", i);
    TEST_ERR_ARG(37, "", "%o", u);
    TEST_ERR_ARG(38, "", "%u", u);
    TEST_ERR_ARG(39, "", "%x", u);
    TEST_ERR_ARG(40, "", "%X", u);
    TEST_ERR_ARG(41, "", "%p", p);
    TEST_ERR_ARG(42, "", "%e", f);
    TEST_ERR_ARG(43, "", "%E", f);
    TEST_ERR_ARG(44, "", "%f", f);
    TEST_ERR_ARG(45, "", "%g", f);
    TEST_ERR_ARG(46, "", "%G", f);
    TEST_ERR_ARG(47, "", "%[^]", *b);
    TEST_ERR_ARG(48, "", "%c", *c);
    TEST_ERR(49, "a", "%%");
    TEST_ERR(50, "a", "b");
 
    if (errors)
        printf("%d/50 tests failed (This system's sscanf(3) is probably wrong)\n", errors);
    else
        printf("All tests passed\n");
 
    return (errors == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
 
#endif
#endif
 
/* vi:set ts=4 sw=4: */