The R Project SVN – R-packages – /trunk/RJSONIO/src/libjson/Source/JSONPreparse.cpp

/*
 *  JSONPreparse.cpp
 *  TestSuite
 *
 *  Created by Wallace on 4/13/11.
 *  Copyright 2011 Streamwide. All rights reserved.
 *
 */

#include "JSONPreparse.h"

#if (defined(JSON_PREPARSE) && defined(JSON_READ_PRIORITY))

#ifdef JSON_COMMENTS
    json_string extractComment(json_string::const_iterator & ptr, json_string::const_iterator & end);
    json_string extractComment(json_string::const_iterator & ptr, json_string::const_iterator & end){
        json_string::const_iterator start;
        json_string result;
looplabel:
        if (json_unlikely(((ptr != end) && (*ptr == JSON_TEMP_COMMENT_IDENTIFIER)))){
            start = ++ptr;
            for(; (ptr != end) && (*(ptr) != JSON_TEMP_COMMENT_IDENTIFIER); ++ptr){}
            result += json_string(start, ptr);
            if (json_unlikely(ptr == end)) return result;
            ++ptr;
            if (json_unlikely(((ptr != end) && (*ptr == JSON_TEMP_COMMENT_IDENTIFIER)))){
                result += JSON_TEXT('\n');
                goto looplabel;
            }
        }
        return result;
    }
    #define GET_COMMENT(x, y, name) json_string name = extractComment(x, y)
    #define RETURN_NODE(node, name){\
        JSONNode res = node;\
        res.set_comment(name);\
        return res;\
    }
    #define RETURN_NODE_NOCOPY(node, name){\
        node.set_comment(name);\
        return node;\
    }
    #define SET_COMMENT(node, name) node.set_comment(name)
    #define COMMENT_ARG(name) ,name
#else
    #define GET_COMMENT(x, y, name) (void)0
    #define RETURN_NODE(node, name) return node
    #define RETURN_NODE_NOCOPY(node, name) return node
    #define SET_COMMENT(node, name) (void)0
    #define COMMENT_ARG(name)
#endif

inline bool isHex(json_char c) json_pure;
inline bool isHex(json_char c) json_nothrow {
    return (((c >= JSON_TEXT('0')) && (c <= JSON_TEXT('9'))) ||
          ((c >= JSON_TEXT('A')) && (c <= JSON_TEXT('F'))) ||
          ((c >= JSON_TEXT('a')) && (c <= JSON_TEXT('f'))));
}

#ifdef JSON_STRICT
    #include "NumberToString.h"
#endif

json_number FetchNumber(const json_string & _string) json_nothrow;
json_number FetchNumber(const json_string & _string) json_nothrow {
    #ifdef JSON_STRICT
       return NumberToString::_atof(_string.c_str());
    #else
       #ifdef JSON_UNICODE
          const size_t len = _string.length();
          #if defined(_MSC_VER) && defined(JSON_SAFE)
             const size_t bytes = (len * (sizeof(json_char) / sizeof(char))) + 1;
             json_auto<char> temp(bytes);
             size_t res;
             errno_t err = std::wcstombs_s(&res, temp.ptr, bytes, _string.c_str(), len);
             if (err != 0){
                return (json_number)0.0;
             }
          #elif defined(JSON_SAFE)
             const size_t bytes = (len * (sizeof(json_char) / sizeof(char))) + 1;
             json_auto<char> temp(bytes);
             size_t res = std::wcstombs(temp.ptr, _string.c_str(), len);
             if (res == (size_t)-1){  //-1 is error code for this function
                return (json_number)0.0;
             }
          #else
             json_auto<char> temp(len + 1);
             size_t res = std::wcstombs(temp.ptr, _string.c_str(), len);
          #endif
          temp.ptr[res] = JSON_TEXT('\0');
          return (json_number)std::atof(temp.ptr);
       #else
          return (json_number)std::atof(_string.c_str());
       #endif
    #endif
}

JSONNode JSONPreparse::isValidNumber(json_string::const_iterator & ptr, json_string::const_iterator & end){
    //ptr points at the first character in the number
    //ptr will end up past the last character
    json_string::const_iterator start = ptr;
    bool decimal = false;
    bool scientific = false;
    
    //first letter is weird
    switch(*ptr){
       #ifndef JSON_STRICT
       case JSON_TEXT('.'):
          decimal = true;
          break;
       case JSON_TEXT('+'):
       #endif
          
       case JSON_TEXT('-'):
       case JSON_TEXT('1'):
       case JSON_TEXT('2'):
       case JSON_TEXT('3'):
       case JSON_TEXT('4'):
       case JSON_TEXT('5'):
       case JSON_TEXT('6'):
       case JSON_TEXT('7'):
       case JSON_TEXT('8'):
       case JSON_TEXT('9'):
          break;
       case JSON_TEXT('0'):
          ++ptr;
          switch(*ptr){
             case JSON_TEXT('.'):
                decimal = true;
                break;
             case JSON_TEXT('e'):
             case JSON_TEXT('E'):
                scientific = true;
                ++ptr;
                if (ptr == end) throw false;
                switch(*ptr){
                    case JSON_TEXT('-'):
                    case JSON_TEXT('+'):
                    case JSON_TEXT('0'):
                    case JSON_TEXT('1'):
                    case JSON_TEXT('2'):
                    case JSON_TEXT('3'):
                    case JSON_TEXT('4'):
                    case JSON_TEXT('5'):
                    case JSON_TEXT('6'):
                    case JSON_TEXT('7'):
                    case JSON_TEXT('8'):
                    case JSON_TEXT('9'):
                       break;
                    default:
                       throw false;
                }
                break;
                
             #ifndef JSON_STRICT
             case JSON_TEXT('x'):
                while(isHex(*++ptr)){};
                return JSONNode(json_global(EMPTY_JSON_STRING), FetchNumber(json_string(start, end - 1)));
             #ifdef JSON_OCTAL
             #ifdef __GNUC__
                case JSON_TEXT('0') ... JSON_TEXT('7'):  //octal
             #else
                case JSON_TEXT('0'):
                case JSON_TEXT('1'):
                case JSON_TEXT('2'):
                case JSON_TEXT('3'):
                case JSON_TEXT('4'):
                case JSON_TEXT('5'):
                case JSON_TEXT('6'):
                case JSON_TEXT('7'):
             #endif
                while((*++ptr >= JSON_TEXT('0')) && (*ptr <= JSON_TEXT('7'))){};
                if ((*ptr != JSON_TEXT('8')) && (*ptr != JSON_TEXT('9'))){
                    return JSONNode(json_global(EMPTY_JSON_STRING), FetchNumber(json_string(start, ptr - 1)));
                } 
                throw false;
             case JSON_TEXT('8'):
             case JSON_TEXT('9'):
                break;
             #else
             #ifdef __GNUC__
                case JSON_TEXT('0') ... JSON_TEXT('9'):
             #else
                case JSON_TEXT('0'):
                case JSON_TEXT('1'):
                case JSON_TEXT('2'):
                case JSON_TEXT('3'):
                case JSON_TEXT('4'):
                case JSON_TEXT('5'):
                case JSON_TEXT('6'):
                case JSON_TEXT('7'):
                case JSON_TEXT('8'):
                case JSON_TEXT('9'):
             #endif
                break;
             #endif
             #else
             #ifdef __GNUC__
                case JSON_TEXT('0') ... JSON_TEXT('9'):
             #else
                case JSON_TEXT('0'):
                case JSON_TEXT('1'):
                case JSON_TEXT('2'):
                case JSON_TEXT('3'):
                case JSON_TEXT('4'):
                case JSON_TEXT('5'):
                case JSON_TEXT('6'):
                case JSON_TEXT('7'):
                case JSON_TEXT('8'):
                case JSON_TEXT('9'):
             #endif
                break;
             #endif
             default:  //just a 0
                return JSONNode(json_global(EMPTY_JSON_STRING), FetchNumber(json_string(start, ptr - 1)));;
          }
          break;
       default:
          throw false;
    }
    ++ptr;
    
    //next digits
    while (true){
       switch(*ptr){
          case JSON_TEXT('.'):
             if (json_unlikely(decimal)) throw false; //multiple decimals
             if (json_unlikely(scientific)) throw false;
             decimal = true;
             break;
          case JSON_TEXT('e'):
          case JSON_TEXT('E'):
             if (json_likely(scientific)) throw false;
             scientific = true;
             ++ptr;
             switch(*ptr){
                case JSON_TEXT('-'):
                case JSON_TEXT('+'):
                #ifdef __GNUC__
                case JSON_TEXT('0') ... JSON_TEXT('9'):
                #else
                case JSON_TEXT('0'):
                case JSON_TEXT('1'):
                case JSON_TEXT('2'):
                case JSON_TEXT('3'):
                case JSON_TEXT('4'):
                case JSON_TEXT('5'):
                case JSON_TEXT('6'):
                case JSON_TEXT('7'):
                case JSON_TEXT('8'):
                case JSON_TEXT('9'):
                #endif
                    break;
                default:
                    throw false;
             }
             break;
          #ifdef __GNUC__
          case JSON_TEXT('0') ... JSON_TEXT('9'):
          #else
          case JSON_TEXT('0'):
          case JSON_TEXT('1'):
          case JSON_TEXT('2'):
          case JSON_TEXT('3'):
          case JSON_TEXT('4'):
          case JSON_TEXT('5'):
          case JSON_TEXT('6'):
          case JSON_TEXT('7'):
          case JSON_TEXT('8'):
          case JSON_TEXT('9'):
          #endif
             break;
          default:
             return JSONNode(json_global(EMPTY_JSON_STRING), FetchNumber(json_string(start, ptr)));;
       }
       ++ptr;
    }
    throw false;
}

#ifndef JSON_STRICT
    #define LETTERCASE(x, y)\
       case JSON_TEXT(x):\
       case JSON_TEXT(y)
    #define LETTERCHECK(x, y)\
       if (json_unlikely((*++ptr != JSON_TEXT(x)) && (*ptr != JSON_TEXT(y)))) throw false
#else
    #define LETTERCASE(x, y)\
       case JSON_TEXT(x)
    #define LETTERCHECK(x, y)\
       if (json_unlikely(*++ptr != JSON_TEXT(x))) throw false
#endif
JSONNode JSONPreparse::isValidMember(json_string::const_iterator & ptr, json_string::const_iterator & end){
    //ptr is on the first character of the member
    //ptr will end up immediately after the last character in the member
    if (ptr == end) throw false;
    
    switch(*ptr){
       case JSON_TEXT('\"'):{
           return JSONNode::stringType(isValidString(++ptr, end));
       }
       case JSON_TEXT('{'):
          return isValidObject(++ptr, end);
       case JSON_TEXT('['):
          return isValidArray(++ptr, end);
       LETTERCASE('t', 'T'):
       LETTERCHECK('r', 'R');
       LETTERCHECK('u', 'U');
       LETTERCHECK('e', 'E');
          ++ptr;
          return JSONNode(json_global(EMPTY_JSON_STRING), true);
       LETTERCASE('f', 'F'):
       LETTERCHECK('a', 'A');
       LETTERCHECK('l', 'L');
       LETTERCHECK('s', 'S');
       LETTERCHECK('e', 'E');
          ++ptr;
          return JSONNode(json_global(EMPTY_JSON_STRING), false);
       LETTERCASE('n', 'N'):
       LETTERCHECK('u', 'U');
       LETTERCHECK('l', 'L');
       LETTERCHECK('l', 'L');
          ++ptr;
          return JSONNode(JSON_NULL);
       #ifndef JSON_STRICT
          case JSON_TEXT('}'):  //null in libjson
          case JSON_TEXT(']'):  //null in libjson
          case JSON_TEXT(','):  //null in libjson
             return JSONNode(JSON_NULL);
       #endif
    }
    //a number
    return isValidNumber(ptr, end);
}

json_string JSONPreparse::isValidString(json_string::const_iterator & ptr, json_string::const_iterator & end){
    //ptr is pointing to the first character after the quote
    //ptr will end up behind the closing "
    json_string::const_iterator start = ptr;
    
    while(ptr != end){
       switch(*ptr){
          case JSON_TEXT('\\'):
             switch(*(++ptr)){
                case JSON_TEXT('\"'):
                case JSON_TEXT('\\'):
                case JSON_TEXT('/'):
                case JSON_TEXT('b'):
                case JSON_TEXT('f'):
                case JSON_TEXT('n'):
                case JSON_TEXT('r'):
                case JSON_TEXT('t'):
                    break;
                case JSON_TEXT('u'):
                    if (json_unlikely(!isHex(*++ptr))) throw false;
                    if (json_unlikely(!isHex(*++ptr))) throw false;
                    //fallthrough to \x
                #ifndef JSON_STRICT
                    case JSON_TEXT('x'):  //hex
                #endif
                    if (json_unlikely(!isHex(*++ptr))) throw false;
                    if (json_unlikely(!isHex(*++ptr))) throw false;
                    break;
                #ifndef JSON_OCTAL
                    #ifdef __GNUC__
                       case JSON_TEXT('0') ... JSON_TEXT('7'):  //octal
                    #else
                       case JSON_TEXT('0'):
                       case JSON_TEXT('1'):
                       case JSON_TEXT('2'):
                       case JSON_TEXT('3'):
                       case JSON_TEXT('4'):
                       case JSON_TEXT('5'):
                       case JSON_TEXT('6'):
                       case JSON_TEXT('7'):
                    #endif
                    if (json_unlikely((*++ptr < JSON_TEXT('0')) || (*ptr > JSON_TEXT('7')))) throw false;
                    if (json_unlikely((*++ptr < JSON_TEXT('0')) || (*ptr > JSON_TEXT('7')))) throw false;
                    break;
                #endif
                default:
                    throw false;
             }
             break;
          case JSON_TEXT('\"'):
             return json_string(start, ptr++);
       }
       ++ptr;
    }
    throw false;
}

void JSONPreparse::isValidNamedObject(json_string::const_iterator & ptr, json_string::const_iterator & end, JSONNode & parent COMMENT_PARAM(comment)) {
    //ptr should be right before the string name
    {
       json_string _name = isValidString(++ptr, end);
       if (json_unlikely(*ptr++ != JSON_TEXT(':'))) throw false;
       JSONNode res = isValidMember(ptr, end);
       res.set_name_(_name);
        SET_COMMENT(res, comment);
        #ifdef JSON_LIBRARY
            parent.push_back(&res);
        #else
            parent.push_back(res);
        #endif
    }
    if (ptr == end) throw false;
    switch(*ptr){
       case JSON_TEXT(','):
            ++ptr;
            {
                GET_COMMENT(ptr, end, nextcomment);
                isValidNamedObject(ptr, end, parent COMMENT_ARG(nextcomment));  //will handle all of them
            }
            return;
       case JSON_TEXT('}'):
          ++ptr;
          return;
       default:
          throw false;
    }
}

JSONNode JSONPreparse::isValidObject(json_string::const_iterator & ptr, json_string::const_iterator & end) {
    //ptr should currently be pointing past the {, so this must be the start of a name, or the closing }
    //ptr will end up past the last }
    JSONNode res(JSON_NODE);
    GET_COMMENT(ptr, end, comment);
    switch(*ptr){
      case JSON_TEXT('\"'):
         isValidNamedObject(ptr, end, res COMMENT_ARG(comment));
         return res;
      case JSON_TEXT('}'):
         ++ptr;
         return res;
      default:
         throw false;
    }
}

void pushArrayMember(JSONNode & res, json_string::const_iterator & ptr, json_string::const_iterator & end);
void pushArrayMember(JSONNode & res, json_string::const_iterator & ptr, json_string::const_iterator & end){
    GET_COMMENT(ptr, end, comment);
    JSONNode temp = JSONPreparse::isValidMember(ptr, end);
    SET_COMMENT(temp, comment);
    #ifdef JSON_LIBRARY
        res.push_back(&temp);
    #else
        res.push_back(temp);
    #endif
}

JSONNode JSONPreparse::isValidArray(json_string::const_iterator & ptr, json_string::const_iterator & end) {
    //ptr should currently be pointing past the [, so this must be the start of a member, or the closing ]
    //ptr will end up past the last ]
    JSONNode res(JSON_ARRAY);
    do{
       switch(*ptr){
          case JSON_TEXT(']'):
             ++ptr;
               return res;
          default:
             pushArrayMember(res, ptr, end);
             switch(*ptr){
                case JSON_TEXT(','):
                    break;
                case JSON_TEXT(']'):
                    ++ptr;
                    return res;
                default:
                    throw false;
             }
             break;
       }
    } while (++ptr != end);
    throw false;
}

JSONNode JSONPreparse::isValidRoot(const json_string & json) json_throws(std::invalid_argument) {
    json_string::const_iterator it = json.begin();
    json_string::const_iterator end = json.end();
    try {
        GET_COMMENT(it, end, comment);
       switch(*it){
          case JSON_TEXT('{'):
               RETURN_NODE(isValidObject(++it, end), comment);
           case JSON_TEXT('['):
               RETURN_NODE(isValidArray(++it, end), comment);
       }
    } catch (...){}
    
    #ifndef JSON_NO_EXCEPTIONS
       throw std::invalid_argument(json_global(EMPTY_STD_STRING));
    #else
       return JSONNode(JSON_NULL);
    #endif
}

#endif
The R Project SVN R-packages

(root)/trunk/RJSONIO/src/libjson/Source/JSONPreparse.cpp – Rev 7747
