binScanf.cpp

Go to the documentation of this file.

/* $Id: scanf.c,v 1.2 2002/08/09 20:56:57 pefo Exp $ */

/*
 * Copyright (c) 2000-2002 Opsycon AB  (www.opsycon.se)
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by Opsycon AB.
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <vector>
#include "sick_scan/binScanf.hpp"

#define MAXLN (10 * 1024)

#define ISSPACE " \t\n\r\f\v"

int binIsspace(int val)
{
        if (val < 0) // characters >= 80
        {
                val = (int)(val & 0xFF);
        }
        int ret = isspace(val);
        return(ret);
}
static char *
_binGetbase(char *p, int *basep)
{
        if (p[0] == '0') {
                switch (p[1]) {
                case 'x':
                        *basep = 16;
                        break;
                case 't': case 'n':
                        *basep = 10;
                        break;
                case 'o':
                        *basep = 8;
                        break;
                default:
                        *basep = 10;
                        return (p);
                }
                return (p + 2);
        }
        *basep = 10;
        return (p);
}
static int
_binAtob(unsigned long *vp, char *p, int base)
{
        unsigned long value, v1, v2;
        char *q, tmp[20];
        int digit;

        if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
                base = 16;
                p += 2;
        }

        if (base == 16 && (q = strchr(p, '.')) != 0) {
                if (q - p > sizeof(tmp) - 1)
                        return (0);

                strncpy(tmp, p, q - p);
                tmp[q - p] = '\0';
                if (!_binAtob(&v1, tmp, 16))
                        return (0);

                q++;
                if (strchr(q, '.'))
                        return (0);

                if (!_binAtob(&v2, q, 16))
                        return (0);
                *vp = (v1 << 16) + v2;
                return (1);
        }

        value = *vp = 0;
        for (; *p; p++) {
                if (*p >= '0' && *p <= '9')
                        digit = *p - '0';
                else if (*p >= 'a' && *p <= 'f')
                        digit = *p - 'a' + 10;
                else if (*p >= 'A' && *p <= 'F')
                        digit = *p - 'A' + 10;
                else
                        return (0);

                if (digit >= base)
                        return (0);
                value *= base;
                value += digit;
        }
        *vp = value;
        return (1);
}

/*
*  atob(vp,p,base)
*      converts p to binary result in vp, rtn 1 on success
*/
int binAtob(unsigned long*vp, char *p, int base)
{

        unsigned long  v;

        if (base == 0)
                p = _binGetbase(p, &base);
        if (_binAtob(&v, p, base)) {
                *vp = v;
                return (1);
        }
        return (0);
}



/*
 *  scanf(fmt,va_alist)
 */
int
binSscanf(const char *fmt, ...)
{
        int            count;
        va_list ap;

        va_start(ap, fmt);
        count = vfscanf(stdin, fmt, ap);
        va_end(ap);
        return (count);
}

/*
 *  fscanf(fp,fmt,va_alist)
 */
int
binFscanf(FILE *fp, const char *fmt, ...)
{
        int             count;
        va_list ap;

        va_start(ap, fmt);
        count = vfscanf(fp, fmt, ap);
        va_end(ap);
        return (count);
}

/*
 *  sscanf(buf,fmt,va_alist)
 */
int
binSscanf(const char *buf, const char *fmt, ...)
{
        int             count;
        va_list ap;

        va_start(ap, fmt);
        count = vsscanf(buf, fmt, ap);
        va_end(ap);
        return (count);
}

/*
 *  vfscanf(fp,fmt,ap)
 */
static int
binVfscanf(FILE *fp, const char *fmt, va_list ap)
{
        int             count;
        char            buf[MAXLN + 1];

        if (fgets(buf, MAXLN, fp) == 0)
                return (-1);
        count = vsscanf(buf, fmt, ap);
        return (count);
}


static int
binVsscanf(const char *bufOrg, const char *s, va_list ap, int bufLen)
{
        int             count, noassign, base, lflag;
        unsigned long   width;
  const char     *tc;
        char           *t, tmp[MAXLN];
        const char *buf;
        const char *bufEnd;
        buf = bufOrg;
        bufEnd = buf + bufLen;

        count = noassign = width = lflag = base = 0;
        // Parse Inputbuffer buf
        while (*s && (buf < bufEnd))
        {
                while (binIsspace(*s)) // skipping blanks
                        s++;
                if (*s == '%') { // maybe a format identifier
                        s++;
                        for (; *s; s++) {
                                if (strchr("dibouxycsefg%", *s)) // check allowed format identifier
                                        break;
                                if (*s == '*')  // length identifier
                                        noassign = 1;
                                else if (*s == 'l' || *s == 'L') // long flag
                                        lflag = 1;
                                else if (*s >= '1' && *s <= '9') {  // length of argument
                                        for (tc = s; isdigit(*s); s++);
                                        strncpy(tmp, tc, s - tc);
                                        tmp[s - tc] = '\0';
                                        binAtob((unsigned long *)&width, tmp, 10);
                                        s--;
                                }
                        }
                        if (*s == 's') 
                        {
                                while (binIsspace((int)(0xFF & *buf)))   // must be done to handle data >= 0x80
                                {
                                        buf++;
                                }
                                if (!width)
                                        width = (int)strcspn(buf, ISSPACE);
                                if (!noassign) {
                                        strncpy(t = va_arg(ap, char *), buf, width);
                                        t[width] = '\0';
                                }
                                buf += width;
                        }
                        else if (*s == 'c') {
                                if (!width)
                                        width = 1;
                                if (!noassign) {
                                        strncpy(t = va_arg(ap, char *), buf, width);
                                        t[width] = '\0';
                                }
                                buf += width;
                        }
                        else if (strchr("dobxyu", *s)) {
                                while (binIsspace((int)(0xFF & *buf)))   // must be done to handle data >= 0x80
                                {
                                        buf++;
                                }
                                if (*s == 'd' || *s == 'u')
                                        base = 10;
                                else if (*s == 'x')
                                        base = 16;
                                else if (*s == 'o')
                                        base = 8;
                                else if (*s == 'b')
                                        base = 2;
                                else if (*s == 'y')
                                        base = 1; // use as marker for binary scan
                                if (!width) {
                                        if (binIsspace(*(s + 1)) || *(s + 1) == 0)
                                                width = (int)strcspn(buf, ISSPACE);
                                        else
                                                width = (int)(strchr(buf, *(s + 1)) - buf);
                                }
                                if (base == 1)  // binary data - plain copy without string function
                                {
                                        memcpy(tmp, buf, width);
                                        unsigned char *destAdr = va_arg(ap, unsigned char *);
                                        unsigned long destVal = 0;
                                        for (int i = 0; i < width; i++)  // Big Endian - MSB first - convention for SOPAS-Binary
                                        {
                                                destVal <<= 8;
                                                destVal |= (unsigned char)(0xFF & tmp[i]);
                                        }
          for (int i = 0; i < width; i++)  // Big Endian - MSB first - convention for SOPAS-Binary
          {
            unsigned char val = (unsigned char)(0xFF & (destVal >> (i * 8)));
            destAdr[i] = val;
          }
                                }
                                else
                                {
                                        strncpy(tmp, buf, width);
                                        tmp[width] = '\0';
                                        if (!noassign)
                                                binAtob(va_arg(ap, unsigned long *), tmp, base);
                                }
                                buf += width;
                        }
                        if (!noassign)
                                count++;
                        width = noassign = lflag = 0;
                        s++;
                }
                else {
                        while (binIsspace(*buf))
                                buf++;
                        if (*s != *buf)
                                break;
                        else
                                s++, buf++;
                }
        }
        return (count);
}

/*
*  scanf(fmt,va_alist)
*/
int
binScanfVec(const std::vector<unsigned char> *vec, const char *fmt, ...)
{
        if (vec->size() == 0)
        {
                return(0);
        }
        const char *buf = (const char *)(&(*vec)[0]);
        int             count;
        int bufLen = (int)vec->size();
        if (0 == bufLen)
        {
                return(0);
        }
        va_list ap;

        va_start(ap, fmt);
        count = binVsscanf(buf, fmt, ap, bufLen);
        va_end(ap);
        return (count);
}

int binScanfGuessDataLenFromMask(const char *scanfMask)
{
        int retLen = 0;
        int noassign = 0;
        int lflag = 0;
        char tmp[20];
        int width;
        if (scanfMask == NULL)
        {
        }
        else
        {
                const char *s = scanfMask;
                const char *tc = NULL;
                while (*s)
                {
                        while (binIsspace(*s))
                        {
                                s++;
                                retLen++;
                        }
                        if (*s == '%') {
                                s++;
                                for (; *s; s++) {
                                        if (strchr("dibouxycsefg%", *s))
                                                break;
                                        if (*s == '*')
                                                noassign = 1;
                                        else if (*s == 'l' || *s == 'L')
                                                lflag = 1;
                                        else if (*s >= '1' && *s <= '9') {
                                                for (tc = s; isdigit(*s); s++);
                                                strncpy(tmp, tc, s - tc);
                                                tmp[s - tc] = '\0';
                                                sscanf(tmp,"%d", &width);
                                                retLen += width;
                                        }
                                }
                        }
                        else
                        {
                                s++;
                                retLen++;
                        }
                }

        }
        return(retLen);
}