sscanf.c

Go to the documentation of this file.

// =============================================
// Copyright © 2003 - 2016 Mike Gore, Waterloo, ON N2L 5N4, Canada
//
// Permission is hereby granted to use this Software for any purpose
// including combining with commercial products, creating derivative
// works, and redistribution of source or binary code, without
// limitation or consideration. Any redistributed copies of this
// Software must include the above Copyright Notice.
//
// THIS SOFTWARE IS PROVIDED "AS IS". THE AUTHOR MAKES NO
// WARRANTIES REGARDING THIS SOFTWARE, EXPRESS OR IMPLIED, AS TO ITS
// SUITABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
// =============================================
// History
// Written:  2 April 2003   Mike Gore <magore@icr1.uwater.loo.ca>
// April 2 - April 8th extesive edits
// April 8 Alpha Release
// 12 Oct 2016
// =============================================
// =============================================
// Note:!!!!
// Use TAB STOPS to 4 or this document will look wrong
// =============================================

#include "user_config.h"

#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>

#include "mathio.h"

#ifdef SMALL_SSCANF

// =============================================
//
//
// WRITTEN by MIKE GORE JUN 1999
//
// SCANF without multiplies!
// Work in progress

int sscanf(const char *strp, const char *fmt, ...)
{
    va_list ap;
    int SIGN = 0;
    uint8_t SIZE;
    int args = 0; // Arguments
    uint8_t width;
    uint8_t base;
    uint8_t shift;
    uint8_t ch;
    uint8_t spec;
    unsigned long num;

    va_start(ap,fmt);

    while ( (spec = *fmt++) )
    {


// FIXME match all non format spec components with input string HERE
//  - Of course the format spec includes the width spec, etc
//  - For now we discard any non % qualified format characters 
//    up to the % character and then the rest of the code eats whats 
//    left in processing the spec later on. In other words we KNOW that 
//    all characters up to a % are unused in the spec itself but really 
//    should be matched with the input to be correct - othersise could cause 
//    parse errors - if present. For now we skip spaces and commas
//    to avoid the most common issues
//   

//
// Skip non format characters - for now
        if (spec != '%') 
        {
            if(spec == *strp)
                ++strp;
            continue;
        }

        // we had a '%'
        spec = *fmt;


// Sync up input string to current argument we want in format spec
// Skip white space and commas in input string - for now KLUDGE
//
        while ( (ch = *strp) ) {
            if(ch == '\t' || ch == ' ' || ch == ',') {
                ++strp;
                continue;
            }
            break;
        }

        width = 0;      // Init width

        while( (spec = *fmt) ) {    // spec and fmt point past %
            if(!(spec >= '0' && spec <= '9'))
                break;
            base = width;       // width *= 10, base is just a temp here
            width <<=2;
            width += base;
            width <<=1;

            width += (spec - '0');
            ++fmt;
        }

// Init numeric control flags in case we have a number to process

        SIZE = sizeof(int);     // Long/Short/Tiny flag, int is default
        base = 0;       // If base gets set below we have a number!
        shift = 0;      // Used for fast multiply

// Handle LARGE numbers
//

        if (spec == 'l') {  // Large
            SIZE = sizeof(long);
            spec = *fmt++;
        }
        if (spec == 't') {  // tiny
            SIZE = sizeof(char);
            spec = *fmt++;
        }
        
// spec has our format specifier!
        switch (spec)
        {
            case '%':
                break;
            case 'c':
                {
                    unsigned char *c;
                    c = va_arg(ap,unsigned char *);
                    *c = *strp;
                    ++strp;
                }
                break;
            case 's':
                {
                    unsigned char *p;
                    unsigned char c;
                    p = va_arg(ap,unsigned char *);
                    while (width) 
                    {
                        c = *strp;
                        if (!c || c == ' ' || c == '\t')
                            break;
                        *p = c;
                        ++p;
                        ++strp;
                        --width;
                    }
                    *p = 0;
                }
                break;
            case 'B':
                    SIZE = sizeof(long);
            case 'b':
                base = 2;
                shift = 1;
                break;
            case 'O':
                    SIZE = sizeof(long);
            case 'o':
                base = 8;
                shift = 3;
                break;
            case 'X':
                    SIZE = sizeof(long);
            case 'x':
                base = 16;
                shift = 4;
                break;
            case 'U':
            case 'D':
                    SIZE = sizeof(long);
            case 'u':
            case 'd':
                base = 10;
//printf("sscanf: sizeof(long) = %d\n", sizeof(long));
//printf("sscanf: sizeof(int) = %d\n", sizeof(int));
//printf("sscanf: size = %d, base = %d\n", (int)SIZE, (int)base);
//printf("sscanf strp:%s\n", strp);
                break;
            case 'f':
                    SIZE = sizeof(double);
                break;
            default:
                break;
        }
// IF base is non zero we have some kind of number to process

        if(base) {
            num = 0;
            SIGN = 0;
            if (!width)
                width = strlen(strp);

            ch = *strp;
            if (ch == '-')
            {
                SIGN = 1;
                ++strp;
            }
            else if(ch == '+')
            {
                ++strp;
            }

            while (width && (ch = *strp)) {
                if (ch < '0')
                    break;

                if (ch >= 'a') 
                    ch -= ('a' - 10);
                else if (ch >= 'A')
                    ch -= ('A' - 10);
                else
                    ch -= '0';

                if (ch >= base)
                    break;

                if(base == 10) {
                    unsigned long temp;
                    num <<= 1;
                    temp = num;
                    num <<= 2;
                    num += temp;
                }
                else {
                    num <<= shift;
                }
                num += ch;
                ++strp;
                --width;
//printf("sscanf: %ld\n",num);
            }               // END WHILE
            if(SIZE == sizeof(long)) {
                unsigned long *c;
                c = va_arg(ap,unsigned long *);
                if(SIGN)
                    *c = (unsigned long) -num;
                else
                    *c = (unsigned long) num;
            }
            else if(SIZE == sizeof(int)) {
                unsigned int *c;
                c = va_arg(ap,unsigned int *);
                if(SIGN)
                    *c = (unsigned int) -num;
                else
                    *c = (unsigned int) num;
            }
            else {
                unsigned char *c;
                c = va_arg(ap,uint8_t *);
                if(SIGN)
                    *c = (unsigned char) -num;
                else
                    *c = (unsigned char) num;
            }
        }               // END IF(base && width)
        else if(SIZE = sizeof(double))
        {
            // FIXME width
            double *d = va_arg(ap,double *);
            char *ptr,*endp;
            int len = strlen(strp);
            if(!width)
                width = len;
            if(width > len)
                width = len;
            ptr = stralloc((char *)strp);
            *d = strtod(ptr, &endp);
            free(ptr);
            strp += (endp - ptr);
        }
        ++args;
    }                   // END WHILE
    return (args);
}

#endif // ifdef SMALL_SSCANF