// -*- coding: utf-8 -*-

// :Project: python-rapidjson -- Python extension module

// :Author: Ken Robbins <ken@kenrobbins.com>

// :License: MIT License

// :Copyright: © 2015 Ken Robbins

// :Copyright: © 2015, 2016, 2017, 2018, 2019, 2020 Lele Gaifax

//

#include <Python.h>

#include <datetime.h>

#include <structmember.h>

#include <algorithm>

#include <cmath>

#include <string>

#include <vector>

#include "rapidjson/reader.h"

#include "rapidjson/schema.h"

#include "rapidjson/stringbuffer.h"

#include "rapidjson/writer.h"

#include "rapidjson/prettywriter.h"

#include "rapidjson/error/en.h"

using namespace rapidjson;

/* Python < 3.6 compatibility */

#ifndef Py_SETREF

#define Py_SETREF(op, op2) \

do { \

PyObject* _py_tmp = (PyObject*) (op); \

(op) = (op2); \

Py_DECREF(_py_tmp); \

} while (0)

#endif

/* On some MacOS combo, using Py_IS_XXX() macros does not work (see

https://github.com/python-rapidjson/python-rapidjson/issues/78).

OTOH, MSVC < 2015 does not have std::isxxx() (see

https://stackoverflow.com/questions/38441740/where-is-isnan-in-msvc-2010).

Oh well... */

#if defined (_MSC_VER) && (_MSC_VER < 1900)

#define IS_NAN(x) Py_IS_NAN(x)

#define IS_INF(x) Py_IS_INFINITY(x)

#else

#define IS_NAN(x) std::isnan(x)

#define IS_INF(x) std::isinf(x)

#endif

static PyObject* decimal_type = NULL;

static PyObject* timezone_type = NULL;

static PyObject* timezone_utc = NULL;

static PyObject* uuid_type = NULL;

static PyObject* validation_error = NULL;

static PyObject* decode_error = NULL;

/* These are the names of oftenly used methods or literal values, interned in the module

initialization function, to avoid repeated creation/destruction of PyUnicode values

from plain C strings.

We cannot use _Py_IDENTIFIER() because that upsets the GNU C++ compiler in -pedantic

mode. */

static PyObject* astimezone_name = NULL;

static PyObject* hex_name = NULL;

static PyObject* timestamp_name = NULL;

static PyObject* total_seconds_name = NULL;

static PyObject* utcoffset_name = NULL;

static PyObject* is_infinite_name = NULL;

static PyObject* is_nan_name = NULL;

static PyObject* start_object_name = NULL;

static PyObject* end_object_name = NULL;

static PyObject* default_name = NULL;

static PyObject* end_array_name = NULL;

static PyObject* string_name = NULL;

static PyObject* read_name = NULL;

static PyObject* write_name = NULL;

static PyObject* encoding_name = NULL;

static PyObject* minus_inf_string_value = NULL;

static PyObject* nan_string_value = NULL;

static PyObject* plus_inf_string_value = NULL;

struct HandlerContext {

PyObject* object;

const char* key;

SizeType keyLength;

bool isObject;

bool copiedKey;

};

enum DatetimeMode {

DM_NONE = 0,

// Formats

DM_ISO8601 = 1<<0, // Bidirectional ISO8601 for datetimes, dates and times

DM_UNIX_TIME = 1<<1, // Serialization only, "Unix epoch"-based number of seconds

// Options

DM_ONLY_SECONDS = 1<<4, // Truncate values to the whole second, ignoring micro seconds

DM_IGNORE_TZ = 1<<5, // Ignore timezones

DM_NAIVE_IS_UTC = 1<<6, // Assume naive datetime are in UTC timezone

DM_SHIFT_TO_UTC = 1<<7 // Shift to/from UTC

};

#define DATETIME_MODE_FORMATS_MASK 0x0f // 0b00001111 in C++14

static inline int

datetime_mode_format(DatetimeMode mode) {

return mode & DATETIME_MODE_FORMATS_MASK;

}

static inline bool

valid_datetime_mode(int mode) {

return (mode >= 0

&& ((mode & DATETIME_MODE_FORMATS_MASK) <= DM_UNIX_TIME)

&& (mode == 0 || (mode & DATETIME_MODE_FORMATS_MASK) != 0));

}

static int

days_per_month(int year, int month) {

assert(month >= 1);

assert(month <= 12);

if (month == 1 || month == 3 || month == 5 || month == 7

|| month == 8 || month == 10 || month == 12) {

return 31;

} else if (month == 4 || month == 6 || month == 9 || month == 11) {

return 30;

} else if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) {

return 29;

} else {

return 28;

}

}

enum UuidMode {

UM_NONE = 0,

UM_CANONICAL = 1<<0, // 4-dashed 32 hex chars: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

UM_HEX = 1<<1 // canonical OR 32 hex chars in a row

};

enum NumberMode {

NM_NONE = 0,

NM_NAN = 1<<0, // allow "not-a-number" values

NM_DECIMAL = 1<<1, // serialize Decimal instances, deserialize floats as Decimal

NM_NATIVE = 1<<2 // use faster native C library number handling

};

enum BytesMode {

BM_NONE = 0,

BM_UTF8 = 1<<0 // try to convert to UTF-8

};

enum ParseMode {

PM_NONE = 0,

PM_COMMENTS = 1<<0, // Allow one-line // ... and multi-line /* ... */ comments

PM_TRAILING_COMMAS = 1<<1 // allow trailing commas at the end of objects and arrays

};

enum WriteMode {

WM_COMPACT = 0,

WM_PRETTY = 1<<0, // Use PrettyWriter

WM_SINGLE_LINE_ARRAY = 1<<1 // Format arrays on a single line

};

//////////////////////////

// Forward declarations //

//////////////////////////

static PyObject* do_decode(PyObject* decoder,

const char* jsonStr, Py_ssize_t jsonStrlen,

PyObject* jsonStream, size_t chunkSize,

PyObject* objectHook,

NumberMode numberMode, DatetimeMode datetimeMode,

UuidMode uuidMode, ParseMode parseMode);

static PyObject* decoder_call(PyObject* self, PyObject* args, PyObject* kwargs);

static PyObject* decoder_new(PyTypeObject* type, PyObject* args, PyObject* kwargs);

static PyObject* do_encode(PyObject* value, bool skipInvalidKeys, PyObject* defaultFn,

bool sortKeys, bool ensureAscii, WriteMode writeMode,

char indentChar, unsigned indentCount, NumberMode numberMode,

DatetimeMode datetimeMode, UuidMode uuidMode,

BytesMode bytesMode);

static PyObject* do_stream_encode(PyObject* value, PyObject* stream, size_t chunkSize,

bool skipInvalidKeys, PyObject* defaultFn,

bool sortKeys, bool ensureAscii, WriteMode writeMode,

char indentChar, unsigned indentCount,

NumberMode numberMode, DatetimeMode datetimeMode,

UuidMode uuidMode, BytesMode bytesMode);

static PyObject* encoder_call(PyObject* self, PyObject* args, PyObject* kwargs);

static PyObject* encoder_new(PyTypeObject* type, PyObject* args, PyObject* kwargs);

static PyObject* validator_call(PyObject* self, PyObject* args, PyObject* kwargs);

static void validator_dealloc(PyObject* self);

static PyObject* validator_new(PyTypeObject* type, PyObject* args, PyObject* kwargs);

///////////////////////////////////////////////////

// Stream wrapper around Python file-like object //

///////////////////////////////////////////////////

class PyReadStreamWrapper {

public:

typedef char Ch;

PyReadStreamWrapper(PyObject* stream, size_t size)

: stream(stream) {

Py_INCREF(stream);

chunkSize = PyLong_FromUnsignedLong(size);

buffer = NULL;

chunk = NULL;

chunkLen = 0;

pos = 0;

offset = 0;

eof = false;

}

~PyReadStreamWrapper() {

Py_CLEAR(stream);

Py_CLEAR(chunkSize);

Py_CLEAR(chunk);

}

Ch Peek() {

if (!eof && pos == chunkLen) {

Read();

}

return eof ? '\0' : buffer[pos];

}

Ch Take() {

if (!eof && pos == chunkLen) {

Read();

}

return eof ? '\0' : buffer[pos++];

}

size_t Tell() const {

return offset + pos;

}

void Flush() {

assert(false);

}

void Put(Ch c) {

assert(false);

}

Ch* PutBegin() {

assert(false);

return 0;

}

size_t PutEnd(Ch* begin) {

assert(false);

return 0;

}

private:

void Read() {

Py_CLEAR(chunk);

chunk = PyObject_CallMethodObjArgs(stream, read_name, chunkSize, NULL);

if (chunk == NULL) {

eof = true;

} else {

Py_ssize_t len;

if (PyBytes_Check(chunk)) {

len = PyBytes_GET_SIZE(chunk);

buffer = PyBytes_AS_STRING(chunk);

} else {

buffer = PyUnicode_AsUTF8AndSize(chunk, &len);

if (buffer == NULL) {

len = 0;

}

}

if (len == 0) {

eof = true;

} else {

offset += chunkLen;

chunkLen = len;

pos = 0;

}

}

}

PyObject* stream;

PyObject* chunkSize;

PyObject* chunk;

const Ch* buffer;

size_t chunkLen;

size_t pos;

size_t offset;

bool eof;

};

class PyWriteStreamWrapper {

public:

typedef char Ch;

PyWriteStreamWrapper(PyObject* stream, size_t size)

: stream(stream) {

Py_INCREF(stream);

buffer = (char*) PyMem_Malloc(size);

assert(buffer);

bufferEnd = buffer + size;

cursor = buffer;

multiByteChar = NULL;

isBinary = !PyObject_HasAttr(stream, encoding_name);

}

~PyWriteStreamWrapper() {

Py_CLEAR(stream);

PyMem_Free(buffer);

}

Ch Peek() {

assert(false);

return 0;

}

Ch Take() {

assert(false);

return 0;

}

size_t Tell() const {

assert(false);

return 0;

}

void Flush() {

PyObject* c;

if (isBinary) {

c = PyBytes_FromStringAndSize(buffer, (size_t)(cursor - buffer));

cursor = buffer;

} else {

if (multiByteChar == NULL) {

c = PyUnicode_FromStringAndSize(buffer, (size_t)(cursor - buffer));

cursor = buffer;

} else {

size_t complete = (size_t)(multiByteChar - buffer);

c = PyUnicode_FromStringAndSize(buffer, complete);

size_t remaining = (size_t)(cursor - multiByteChar);

if (RAPIDJSON_LIKELY(remaining < complete))

memcpy(buffer, multiByteChar, remaining);

else

std::memmove(buffer, multiByteChar, remaining);

cursor = buffer + remaining;

multiByteChar = NULL;

}

}

if (c == NULL) {

// Propagate the error state, it will be catched by dumps_internal()

} else {

PyObject* res = PyObject_CallMethodObjArgs(stream, write_name, c, NULL);

if (res == NULL) {

// Likewise

} else {

Py_DECREF(res);

}

Py_DECREF(c);

}

}

void Put(Ch c) {

if (cursor == bufferEnd)

Flush();

if (!isBinary) {

if ((c & 0x80) == 0) {

multiByteChar = NULL;

} else if (c & 0x40) {

multiByteChar = cursor;

}

}

*cursor++ = c;

}

Ch* PutBegin() {

assert(false);

return 0;

}

size_t PutEnd(Ch* begin) {

assert(false);

return 0;

}

private:

PyObject* stream;

Ch* buffer;

Ch* bufferEnd;

Ch* cursor;

Ch* multiByteChar;

bool isBinary;

};

inline void PutUnsafe(PyWriteStreamWrapper& stream, char c) {

stream.Put(c);

}

/////////////

// RawJSON //

/////////////

typedef struct {

PyObject_HEAD

PyObject* value;

} RawJSON;

static void

RawJSON_dealloc(RawJSON* self)

{

Py_XDECREF(self->value);

Py_TYPE(self)->tp_free((PyObject*) self);

}

static PyObject*

RawJSON_new(PyTypeObject* type, PyObject* args, PyObject* kwds)

{

PyObject* self = type->tp_alloc(type, 0);

static char const* kwlist[] = {

"value",

NULL

};

PyObject* value = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "U", (char**) kwlist, &value))

return NULL;

((RawJSON*) self)->value = value;

Py_INCREF(value);

return self;

}

static PyMemberDef RawJSON_members[] = {

{"value",

T_OBJECT_EX, offsetof(RawJSON, value), READONLY,

"string representing a serialized JSON object"},

{NULL} /* Sentinel */

};

PyDoc_STRVAR(rawjson_doc,

"Raw (preserialized) JSON object\n"

"\n"

"When rapidjson tries to serialize instances of this class, it will"

" use their literal `value`. For instance:\n"

">>> rapidjson.dumps(RawJSON('{\"already\": \"serialized\"}'))\n"

"'{\"already\": \"serialized\"}'");

static PyTypeObject RawJSON_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"rapidjson.RawJSON", /* tp_name */

sizeof(RawJSON), /* tp_basicsize */

0, /* tp_itemsize */

(destructor) RawJSON_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT, /* tp_flags */

rawjson_doc, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

RawJSON_members, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

RawJSON_new, /* tp_new */

};

/////////////

// Decoder //

/////////////

/* Adapted from CPython's Objects/floatobject.c::float_from_string_inner() */

static PyObject*

float_from_string(const char* s, Py_ssize_t len)

{

double x;

const char* end;

/* We don't care about overflow or underflow. If the platform

* supports them, infinities and signed zeroes (on underflow) are

* fine. */

x = PyOS_string_to_double(s, (char **) &end, NULL);

if (end != s + len) {

return NULL;

} else if (x == -1.0 && PyErr_Occurred()) {

return NULL;

} else {

return PyFloat_FromDouble(x);

}

}

struct PyHandler {

PyObject* decoderStartObject;

PyObject* decoderEndObject;

PyObject* decoderEndArray;

PyObject* decoderString;

PyObject* root;

PyObject* objectHook;

DatetimeMode datetimeMode;

UuidMode uuidMode;

NumberMode numberMode;

std::vector<HandlerContext> stack;

PyHandler(PyObject* decoder,

PyObject* hook,

DatetimeMode dm,

UuidMode um,

NumberMode nm)

: decoderStartObject(NULL),

decoderEndObject(NULL),

decoderEndArray(NULL),

decoderString(NULL),

root(NULL),

objectHook(hook),

datetimeMode(dm),

uuidMode(um),

numberMode(nm)

{

stack.reserve(128);

if (decoder != NULL) {

assert(!objectHook);

if (PyObject_HasAttr(decoder, start_object_name)) {

decoderStartObject = PyObject_GetAttr(decoder, start_object_name);

}

if (PyObject_HasAttr(decoder, end_object_name)) {

decoderEndObject = PyObject_GetAttr(decoder, end_object_name);

}

if (PyObject_HasAttr(decoder, end_array_name)) {

decoderEndArray = PyObject_GetAttr(decoder, end_array_name);

}

if (PyObject_HasAttr(decoder, string_name)) {

decoderString = PyObject_GetAttr(decoder, string_name);

}

}

}

~PyHandler() {

while (!stack.empty()) {

const HandlerContext& ctx = stack.back();

if (ctx.copiedKey)

PyMem_Free((void*) ctx.key);

stack.pop_back();

}

Py_CLEAR(decoderStartObject);

Py_CLEAR(decoderEndObject);

Py_CLEAR(decoderEndArray);

Py_CLEAR(decoderString);

}

bool Handle(PyObject* value) {

if (root) {

const HandlerContext& current = stack.back();

if (current.isObject) {

PyObject* key = PyUnicode_FromStringAndSize(current.key,

current.keyLength);

if (key == NULL) {

Py_DECREF(value);

return false;

}

int rc;

if (PyDict_CheckExact(current.object))

// If it's a standard dictionary, this is +20% faster

rc = PyDict_SetItem(current.object, key, value);

else

rc = PyObject_SetItem(current.object, key, value);

Py_DECREF(key);

Py_DECREF(value);

if (rc == -1) {

return false;

}

} else {

PyList_Append(current.object, value);

Py_DECREF(value);

}

} else {

root = value;

}

return true;

}

bool Key(const char* str, SizeType length, bool copy) {

HandlerContext& current = stack.back();

// This happens when operating in stream mode and kParseInsituFlag is not set: we

// must copy the incoming string in the context, and destroy the duplicate when

// the context gets reused for the next dictionary key

if (current.key && current.copiedKey) {

PyMem_Free((void*) current.key);

current.key = NULL;

}

if (copy) {

char* copied_str = (char*) PyMem_Malloc(length+1);

if (copied_str == NULL)

return false;

memcpy(copied_str, str, length+1);

str = copied_str;

assert(!current.key);

}

current.key = str;

current.keyLength = length;

current.copiedKey = copy;

return true;

}

bool StartObject() {

PyObject* mapping;

if (decoderStartObject != NULL) {

mapping = PyObject_CallFunctionObjArgs(decoderStartObject, NULL);

if (mapping == NULL)

return false;

if (!PyMapping_Check(mapping)) {

Py_DECREF(mapping);

PyErr_SetString(PyExc_ValueError,

"start_object() must return a mapping instance");

return false;

}

} else {

mapping = PyDict_New();

if (mapping == NULL) {

return false;

}

}

if (!Handle(mapping)) {

return false;

}

HandlerContext ctx;

ctx.isObject = true;

ctx.object = mapping;

ctx.key = NULL;

ctx.copiedKey = false;

Py_INCREF(mapping);

stack.push_back(ctx);

return true;

}

bool EndObject(SizeType member_count) {

const HandlerContext& ctx = stack.back();

if (ctx.copiedKey)

PyMem_Free((void*) ctx.key);

PyObject* mapping = ctx.object;

stack.pop_back();

if (objectHook == NULL && decoderEndObject == NULL) {

Py_DECREF(mapping);

return true;

}

PyObject* replacement;

if (decoderEndObject != NULL) {

replacement = PyObject_CallFunctionObjArgs(decoderEndObject, mapping, NULL);

} else /* if (objectHook != NULL) */ {

replacement = PyObject_CallFunctionObjArgs(objectHook, mapping, NULL);

}

Py_DECREF(mapping);

if (replacement == NULL)

return false;

if (!stack.empty()) {

const HandlerContext& current = stack.back();

if (current.isObject) {

PyObject* key = PyUnicode_FromStringAndSize(current.key,

current.keyLength);

if (key == NULL) {

Py_DECREF(replacement);

return false;

}

int rc;

if (PyDict_Check(current.object))

// If it's a standard dictionary, this is +20% faster

rc = PyDict_SetItem(current.object, key, replacement);

else

rc = PyObject_SetItem(current.object, key, replacement);

Py_DECREF(key);

Py_DECREF(replacement);

if (rc == -1) {

return false;

}

} else {

// Change these to PySequence_Size() and PySequence_SetItem(),

// should we implement Decoder.start_array()

Py_ssize_t listLen = PyList_GET_SIZE(current.object);

int rc = PyList_SetItem(current.object, listLen - 1, replacement);

// NB: PyList_SetItem() steals a reference on the replacement, so it must

// not be DECREFed when the operation succeeds

if (rc == -1) {

Py_DECREF(replacement);

return false;

}

}

} else {

Py_SETREF(root, replacement);

}

return true;

}

bool StartArray() {

PyObject* list = PyList_New(0);

if (list == NULL) {

return false;

}

if (!Handle(list)) {

return false;

}

HandlerContext ctx;

ctx.isObject = false;

ctx.object = list;

ctx.key = NULL;

ctx.copiedKey = false;

Py_INCREF(list);

stack.push_back(ctx);

return true;

}

bool EndArray(SizeType elementCount) {

const HandlerContext& ctx = stack.back();

if (ctx.copiedKey)

PyMem_Free((void*) ctx.key);

PyObject* sequence = ctx.object;

stack.pop_back();

if (decoderEndArray == NULL) {

Py_DECREF(sequence);

return true;

}

PyObject* replacement = PyObject_CallFunctionObjArgs(decoderEndArray, sequence,

NULL);

Py_DECREF(sequence);

if (replacement == NULL)

return false;

if (!stack.empty()) {

const HandlerContext& current = stack.back();

if (current.isObject) {

PyObject* key = PyUnicode_FromStringAndSize(current.key,

current.keyLength);

if (key == NULL) {

Py_DECREF(replacement);

return false;

}

int rc;

if (PyDict_Check(current.object))

// If it's a standard dictionary, this is +20% faster

rc = PyDict_SetItem(current.object, key, replacement);

else

rc = PyObject_SetItem(current.object, key, replacement);

Py_DECREF(key);

if (rc == -1) {

Py_DECREF(replacement);

return false;

}

} else {

// Change these to PySequence_Size() and PySequence_SetItem(),

// should we implement Decoder.start_array()

Py_ssize_t listLen = PyList_GET_SIZE(current.object);

int rc = PyList_SetItem(current.object, listLen - 1, replacement);

if (rc == -1) {

Py_DECREF(replacement);

return false;

}

}

} else {

Py_SETREF(root, replacement);

}

return true;

}

bool NaN() {

if (!(numberMode & NM_NAN)) {

PyErr_SetString(PyExc_ValueError,

"Out of range float values are not JSON compliant");

return false;

}

PyObject* value;

if (numberMode & NM_DECIMAL) {

value = PyObject_CallFunctionObjArgs(decimal_type, nan_string_value, NULL);

} else {

value = PyFloat_FromString(nan_string_value);

}

if (value == NULL)

return false;

return Handle(value);

}

bool Infinity(bool minus) {

if (!(numberMode & NM_NAN)) {

PyErr_SetString(PyExc_ValueError,

"Out of range float values are not JSON compliant");

return false;

}

PyObject* value;

if (numberMode & NM_DECIMAL) {

value = PyObject_CallFunctionObjArgs(decimal_type,

minus

? minus_inf_string_value

: plus_inf_string_value, NULL);

} else {

value = PyFloat_FromString(minus

? minus_inf_string_value

: plus_inf_string_value);

}

if (value == NULL)

return false;

return Handle(value);

}

bool Null() {

PyObject* value = Py_None;

Py_INCREF(value);

return Handle(value);

}

bool Bool(bool b) {

PyObject* value = b ? Py_True : Py_False;

Py_INCREF(value);

return Handle(value);

}

bool Int(int i) {

PyObject* value = PyLong_FromLong(i);

return Handle(value);

}

bool Uint(unsigned i) {

PyObject* value = PyLong_FromUnsignedLong(i);

return Handle(value);

}

bool Int64(int64_t i) {

PyObject* value = PyLong_FromLongLong(i);

return Handle(value);

}

bool Uint64(uint64_t i) {

PyObject* value = PyLong_FromUnsignedLongLong(i);

return Handle(value);

}

bool Double(double d) {

PyObject* value = PyFloat_FromDouble(d);

return Handle(value);

}

bool RawNumber(const char* str, SizeType length, bool copy) {

PyObject* value;

bool isFloat = false;

for (int i = length - 1; i >= 0; --i) {

// consider it a float if there is at least one non-digit character,

// it may be either a decimal number or +-infinity or nan

if (!isdigit(str[i]) && str[i] != '-') {

isFloat = true;

break;

}

}

if (isFloat) {

if (numberMode & NM_DECIMAL) {

PyObject* pystr = PyUnicode_FromStringAndSize(str, length);

if (pystr == NULL)

return false;

value = PyObject_CallFunctionObjArgs(decimal_type, pystr, NULL);

Py_DECREF(pystr);

} else {

std::string zstr(str, length);

value = float_from_string(zstr.c_str(), length);

}

} else {

std::string zstr(str, length);

value = PyLong_FromString(zstr.c_str(), NULL, 10);

}

if (value == NULL) {

PyErr_SetString(PyExc_ValueError,

isFloat

? "Invalid float value"

: "Invalid integer value");

return false;

} else {

return Handle(value);

}

}

#define digit(idx) (str[idx] - '0')

bool IsIso8601Date(const char* str, int& year, int& month, int& day) {

// we've already checked that str is a valid length and that 5 and 8 are '-'

if (!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2]) || !isdigit(str[3])

|| !isdigit(str[5]) || !isdigit(str[6])

|| !isdigit(str[8]) || !isdigit(str[9])) return false;

year = digit(0)*1000 + digit(1)*100 + digit(2)*10 + digit(3);

month = digit(5)*10 + digit(6);

day = digit(8)*10 + digit(9);