mirror of https://github.com/Icinga/icinga2.git
Merge pull request #7019 from Icinga/feature/new-json-library
Replace YAJL with nlohmann::json
This commit is contained in:
Michael Friedrich
GitHub
commit
6ace8001d8
|
|
@ -23,7 +23,6 @@ addons:
|
|||
- libpq-dev
|
||||
- libmysqlclient-dev
|
||||
- libedit-dev
|
||||
- libyajl-dev
|
||||
- libwxbase3.0-dev
|
||||
- libwxgtk3.0-dev
|
||||
coverity_scan:
|
||||
|
|
|
|||
|
|
@ -143,15 +143,9 @@ include_directories(${OPENSSL_INCLUDE_DIR})
|
|||
set(base_DEPS ${CMAKE_DL_LIBS} ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES})
|
||||
set(base_OBJS $<TARGET_OBJECTS:mmatch> $<TARGET_OBJECTS:socketpair> $<TARGET_OBJECTS:base>)
|
||||
|
||||
find_package(YAJL)
|
||||
|
||||
if(NOT YAJL_FOUND)
|
||||
include_directories(${icinga2_BINARY_DIR}/third-party/yajl/include)
|
||||
link_directories(${icinga2_BINARY_DIR}/third-party/yajl)
|
||||
list(APPEND base_OBJS $<TARGET_OBJECTS:yajl>)
|
||||
else()
|
||||
list(APPEND base_DEPS ${YAJL_LIBRARIES})
|
||||
endif()
|
||||
# JSON
|
||||
find_package(JSON)
|
||||
include_directories(${JSON_INCLUDE})
|
||||
|
||||
# UTF8CPP
|
||||
find_package(UTF8CPP)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,9 @@
|
|||
FIND_PATH (JSON_INCLUDE json.hpp HINTS "${PROJECT_SOURCE_DIR}/third-party/nlohmann_json")
|
||||
|
||||
if (JSON_INCLUDE)
|
||||
set(JSON_BuildTests OFF CACHE INTERNAL "")
|
||||
|
||||
message(STATUS "Found JSON: ${JSON_INCLUDE}" )
|
||||
else ()
|
||||
message(FATAL_ERROR "Unable to include json.hpp")
|
||||
endif ()
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
# - Try to find libyajl
|
||||
# Once done this will define
|
||||
# YAJL_FOUND - System has YAJL
|
||||
# YAJL_INCLUDE_DIRS - The YAJL include directories
|
||||
# YAJL_LIBRARIES - The libraries needed to use YAJL
|
||||
# YAJL_DEFINITIONS - Compiler switches required for using YAJL
|
||||
|
||||
find_package(PkgConfig)
|
||||
pkg_check_modules(PC_YAJL QUIET yajl)
|
||||
set(YAJL_DEFINITIONS ${PC_YAJL_CFLAGS_OTHER})
|
||||
|
||||
find_path(YAJL_INCLUDE_DIR yajl/yajl_version.h
|
||||
HINTS ${PC_YAJL_INCLUDEDIR} ${PC_YAJL_INCLUDE_DIRS}
|
||||
PATH_SUFFIXES libyajl)
|
||||
|
||||
find_library(YAJL_LIBRARY NAMES yajl libyajl
|
||||
HINTS ${PC_YAJL_LIBDIR} ${PC_YAJL_LIBRARY_DIRS})
|
||||
|
||||
set(YAJL_LIBRARIES ${YAJL_LIBRARY} )
|
||||
set(YAJL_INCLUDE_DIRS ${YAJL_INCLUDE_DIR})
|
||||
|
||||
include(FindPackageHandleStandardArgs)
|
||||
# handle the QUIETLY and REQUIRED arguments and set YAJL_FOUND to TRUE
|
||||
# if all listed variables are TRUE
|
||||
find_package_handle_standard_args(yajl DEFAULT_MSG
|
||||
YAJL_LIBRARY YAJL_INCLUDE_DIR)
|
||||
|
||||
mark_as_advanced(YAJL_INCLUDE_DIR YAJL_LIBRARY)
|
||||
|
|
@ -27,6 +27,18 @@ This affects the following features:
|
|||
* [OpenTsdb](09-object-types.md#objecttype-opentsdbwriter)
|
||||
* [Perfdata](09-object-types.md#objecttype-perfdatawriter) (for PNP)
|
||||
|
||||
### Package Dependencies <a id="upgrading-to-2-11-package-dependencies"></a>
|
||||
|
||||
#### Removed: YAJL
|
||||
|
||||
Our JSON library, namely [YAJL](https://github.com/lloyd/yajl), isn't maintained anymore
|
||||
and may cause [crashes](https://github.com/Icinga/icinga2/issues/6684).
|
||||
|
||||
It is replaced by [JSON for Modern C++](https://github.com/nlohmann/json) by Niels Lohmann
|
||||
and compiled into the binary as header only include. It helps our way to C++11 and allows
|
||||
to fix additional UTF8 issues more easily. Read more about its [design goals](https://github.com/nlohmann/json#design-goals)
|
||||
and [benchmarks](https://github.com/miloyip/nativejson-benchmark#parsing-time).
|
||||
|
||||
## Upgrading to v2.10 <a id="upgrading-to-2-10"></a>
|
||||
|
||||
### Path Constant Changes <a id="upgrading-to-2-10-path-constant-changes"></a>
|
||||
|
|
|
|||
|
|
@ -637,7 +637,7 @@ gdb --args /usr/local/icinga2/lib/icinga2/sbin/icinga2 daemon
|
|||
##### Debian 9 <a id="development-linux-dev-env-debian"></a>
|
||||
|
||||
```
|
||||
apt-get -y install gdb vim git cmake make ccache build-essential libssl-dev libboost-all-dev bison flex default-libmysqlclient-dev libpq-dev libyajl-dev libedit-dev monitoring-plugins
|
||||
apt-get -y install gdb vim git cmake make ccache build-essential libssl-dev libboost-all-dev bison flex default-libmysqlclient-dev libpq-dev libedit-dev monitoring-plugins
|
||||
|
||||
ln -s /usr/bin/ccache /usr/local/bin/gcc
|
||||
ln -s /usr/bin/ccache /usr/local/bin/g++
|
||||
|
|
@ -698,7 +698,7 @@ sudo dseditgroup -o edit -a _www -t user icingaweb2
|
|||
OpenSSL 1.0.x doesn't build anymore, so we're explicitly using 1.1.x here.
|
||||
|
||||
```
|
||||
brew install ccache boost cmake bison flex yajl openssl@1.1 mysql-connector-c++ postgresql libpq
|
||||
brew install ccache boost cmake bison flex openssl@1.1 mysql-connector-c++ postgresql libpq
|
||||
```
|
||||
|
||||
##### ccache
|
||||
|
|
@ -1115,10 +1115,6 @@ Icinga application using a dist tarball (including notes for distributions):
|
|||
- RHEL/Fedora: postgresql-devel
|
||||
- Debian/Ubuntu: libpq-dev
|
||||
- postgresql-dev on Alpine
|
||||
* YAJL (Faster JSON library)
|
||||
- RHEL/Fedora: yajl-devel
|
||||
- Debian: libyajl-dev
|
||||
- Alpine: yajl-dev
|
||||
* libedit (CLI console)
|
||||
- RHEL/Fedora: libedit-devel on CentOS (RHEL requires rhel-7-server-optional-rpms)
|
||||
- Debian/Ubuntu/Alpine: libedit-dev
|
||||
|
|
|
|||
|
|
@ -7,108 +7,180 @@
|
|||
#include "base/array.hpp"
|
||||
#include "base/objectlock.hpp"
|
||||
#include "base/convert.hpp"
|
||||
#include "base/utility.hpp"
|
||||
#include <bitset>
|
||||
#include <boost/exception_ptr.hpp>
|
||||
#include <yajl/yajl_version.h>
|
||||
#include <yajl/yajl_gen.h>
|
||||
#include <yajl/yajl_parse.h>
|
||||
#include <cstdint>
|
||||
#include <json.hpp>
|
||||
#include <stack>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
using namespace icinga;
|
||||
|
||||
static void Encode(yajl_gen handle, const Value& value);
|
||||
|
||||
#if YAJL_MAJOR < 2
|
||||
typedef unsigned int yajl_size;
|
||||
#else /* YAJL_MAJOR */
|
||||
typedef size_t yajl_size;
|
||||
#endif /* YAJL_MAJOR */
|
||||
|
||||
static void EncodeNamespace(yajl_gen handle, const Namespace::Ptr& ns)
|
||||
class JsonSax : public nlohmann::json_sax<nlohmann::json>
|
||||
{
|
||||
yajl_gen_map_open(handle);
|
||||
public:
|
||||
bool null() override;
|
||||
bool boolean(bool val) override;
|
||||
bool number_integer(number_integer_t val) override;
|
||||
bool number_unsigned(number_unsigned_t val) override;
|
||||
bool number_float(number_float_t val, const string_t& s) override;
|
||||
bool string(string_t& val) override;
|
||||
bool start_object(std::size_t elements) override;
|
||||
bool key(string_t& val) override;
|
||||
bool end_object() override;
|
||||
bool start_array(std::size_t elements) override;
|
||||
bool end_array() override;
|
||||
bool parse_error(std::size_t position, const std::string& last_token, const nlohmann::detail::exception& ex) override;
|
||||
|
||||
Value GetResult();
|
||||
|
||||
private:
|
||||
Value m_Root;
|
||||
std::stack<std::pair<Dictionary*, Array*>> m_CurrentSubtree;
|
||||
String m_CurrentKey;
|
||||
|
||||
void FillCurrentTarget(Value value);
|
||||
};
|
||||
|
||||
const char l_Null[] = "null";
|
||||
const char l_False[] = "false";
|
||||
const char l_True[] = "true";
|
||||
const char l_Indent[] = " ";
|
||||
|
||||
// https://github.com/nlohmann/json/issues/1512
|
||||
template<bool prettyPrint>
|
||||
class JsonEncoder
|
||||
{
|
||||
public:
|
||||
void Null();
|
||||
void Boolean(bool value);
|
||||
void NumberFloat(double value);
|
||||
void Strng(String value);
|
||||
void StartObject();
|
||||
void Key(String value);
|
||||
void EndObject();
|
||||
void StartArray();
|
||||
void EndArray();
|
||||
|
||||
String GetResult();
|
||||
|
||||
private:
|
||||
std::vector<char> m_Result;
|
||||
String m_CurrentKey;
|
||||
std::stack<std::bitset<2>> m_CurrentSubtree;
|
||||
|
||||
void AppendChar(char c);
|
||||
|
||||
template<class Iterator>
|
||||
void AppendChars(Iterator begin, Iterator end);
|
||||
|
||||
void AppendJson(nlohmann::json json);
|
||||
|
||||
void BeforeItem();
|
||||
|
||||
void FinishContainer(char terminator);
|
||||
};
|
||||
|
||||
template<bool prettyPrint>
|
||||
void Encode(JsonEncoder<prettyPrint>& stateMachine, const Value& value);
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void EncodeNamespace(JsonEncoder<prettyPrint>& stateMachine, const Namespace::Ptr& ns)
|
||||
{
|
||||
stateMachine.StartObject();
|
||||
|
||||
ObjectLock olock(ns);
|
||||
for (const Namespace::Pair& kv : ns) {
|
||||
yajl_gen_string(handle, reinterpret_cast<const unsigned char *>(kv.first.CStr()), kv.first.GetLength());
|
||||
Encode(handle, kv.second->Get());
|
||||
stateMachine.Key(Utility::ValidateUTF8(kv.first));
|
||||
Encode(stateMachine, kv.second->Get());
|
||||
}
|
||||
|
||||
yajl_gen_map_close(handle);
|
||||
stateMachine.EndObject();
|
||||
}
|
||||
|
||||
static void EncodeDictionary(yajl_gen handle, const Dictionary::Ptr& dict)
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void EncodeDictionary(JsonEncoder<prettyPrint>& stateMachine, const Dictionary::Ptr& dict)
|
||||
{
|
||||
yajl_gen_map_open(handle);
|
||||
stateMachine.StartObject();
|
||||
|
||||
ObjectLock olock(dict);
|
||||
for (const Dictionary::Pair& kv : dict) {
|
||||
yajl_gen_string(handle, reinterpret_cast<const unsigned char *>(kv.first.CStr()), kv.first.GetLength());
|
||||
Encode(handle, kv.second);
|
||||
stateMachine.Key(Utility::ValidateUTF8(kv.first));
|
||||
Encode(stateMachine, kv.second);
|
||||
}
|
||||
|
||||
yajl_gen_map_close(handle);
|
||||
stateMachine.EndObject();
|
||||
}
|
||||
|
||||
static void EncodeArray(yajl_gen handle, const Array::Ptr& arr)
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void EncodeArray(JsonEncoder<prettyPrint>& stateMachine, const Array::Ptr& arr)
|
||||
{
|
||||
yajl_gen_array_open(handle);
|
||||
stateMachine.StartArray();
|
||||
|
||||
ObjectLock olock(arr);
|
||||
for (const Value& value : arr) {
|
||||
Encode(handle, value);
|
||||
Encode(stateMachine, value);
|
||||
}
|
||||
|
||||
yajl_gen_array_close(handle);
|
||||
stateMachine.EndArray();
|
||||
}
|
||||
|
||||
static void Encode(yajl_gen handle, const Value& value)
|
||||
template<bool prettyPrint>
|
||||
void Encode(JsonEncoder<prettyPrint>& stateMachine, const Value& value)
|
||||
{
|
||||
switch (value.GetType()) {
|
||||
case ValueNumber:
|
||||
if (yajl_gen_double(handle, value.Get<double>()) == yajl_gen_invalid_number)
|
||||
yajl_gen_double(handle, 0);
|
||||
|
||||
stateMachine.NumberFloat(value.Get<double>());
|
||||
break;
|
||||
|
||||
case ValueBoolean:
|
||||
yajl_gen_bool(handle, value.ToBool());
|
||||
|
||||
stateMachine.Boolean(value.ToBool());
|
||||
break;
|
||||
|
||||
case ValueString:
|
||||
yajl_gen_string(handle, reinterpret_cast<const unsigned char *>(value.Get<String>().CStr()), value.Get<String>().GetLength());
|
||||
|
||||
stateMachine.Strng(Utility::ValidateUTF8(value.Get<String>()));
|
||||
break;
|
||||
|
||||
case ValueObject:
|
||||
{
|
||||
const Object::Ptr& obj = value.Get<Object::Ptr>();
|
||||
Namespace::Ptr ns = dynamic_pointer_cast<Namespace>(obj);
|
||||
|
||||
if (ns) {
|
||||
EncodeNamespace(handle, ns);
|
||||
break;
|
||||
{
|
||||
Namespace::Ptr ns = dynamic_pointer_cast<Namespace>(obj);
|
||||
if (ns) {
|
||||
EncodeNamespace(stateMachine, ns);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Dictionary::Ptr dict = dynamic_pointer_cast<Dictionary>(obj);
|
||||
|
||||
if (dict) {
|
||||
EncodeDictionary(handle, dict);
|
||||
break;
|
||||
{
|
||||
Dictionary::Ptr dict = dynamic_pointer_cast<Dictionary>(obj);
|
||||
if (dict) {
|
||||
EncodeDictionary(stateMachine, dict);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Array::Ptr arr = dynamic_pointer_cast<Array>(obj);
|
||||
|
||||
if (arr) {
|
||||
EncodeArray(handle, arr);
|
||||
EncodeArray(stateMachine, arr);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
yajl_gen_null(handle);
|
||||
stateMachine.Null();
|
||||
|
||||
break;
|
||||
|
||||
case ValueEmpty:
|
||||
yajl_gen_null(handle);
|
||||
|
||||
stateMachine.Null();
|
||||
break;
|
||||
|
||||
default:
|
||||
VERIFY(!"Invalid variant type.");
|
||||
}
|
||||
|
|
@ -116,254 +188,309 @@ static void Encode(yajl_gen handle, const Value& value)
|
|||
|
||||
String icinga::JsonEncode(const Value& value, bool pretty_print)
|
||||
{
|
||||
#if YAJL_MAJOR < 2
|
||||
yajl_gen_config conf = { pretty_print, "" };
|
||||
yajl_gen handle = yajl_gen_alloc(&conf, nullptr);
|
||||
#else /* YAJL_MAJOR */
|
||||
yajl_gen handle = yajl_gen_alloc(nullptr);
|
||||
if (pretty_print)
|
||||
yajl_gen_config(handle, yajl_gen_beautify, 1);
|
||||
#endif /* YAJL_MAJOR */
|
||||
if (pretty_print) {
|
||||
JsonEncoder<true> stateMachine;
|
||||
|
||||
Encode(handle, value);
|
||||
Encode(stateMachine, value);
|
||||
|
||||
const unsigned char *buf;
|
||||
yajl_size len;
|
||||
return stateMachine.GetResult();
|
||||
} else {
|
||||
JsonEncoder<false> stateMachine;
|
||||
|
||||
yajl_gen_get_buf(handle, &buf, &len);
|
||||
Encode(stateMachine, value);
|
||||
|
||||
String result = String(buf, buf + len);
|
||||
|
||||
yajl_gen_free(handle);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
struct JsonElement
|
||||
{
|
||||
String Key;
|
||||
bool KeySet{false};
|
||||
Value EValue;
|
||||
};
|
||||
|
||||
struct JsonContext
|
||||
{
|
||||
public:
|
||||
void Push(const Value& value)
|
||||
{
|
||||
JsonElement element;
|
||||
element.EValue = value;
|
||||
|
||||
m_Stack.push(element);
|
||||
return stateMachine.GetResult();
|
||||
}
|
||||
|
||||
JsonElement Pop()
|
||||
{
|
||||
JsonElement value = m_Stack.top();
|
||||
m_Stack.pop();
|
||||
return value;
|
||||
}
|
||||
|
||||
void AddValue(const Value& value)
|
||||
{
|
||||
if (m_Stack.empty()) {
|
||||
JsonElement element;
|
||||
element.EValue = value;
|
||||
m_Stack.push(element);
|
||||
return;
|
||||
}
|
||||
|
||||
JsonElement& element = m_Stack.top();
|
||||
|
||||
if (element.EValue.IsObjectType<Dictionary>()) {
|
||||
if (!element.KeySet) {
|
||||
element.Key = value;
|
||||
element.KeySet = true;
|
||||
} else {
|
||||
Dictionary::Ptr dict = element.EValue;
|
||||
dict->Set(element.Key, value);
|
||||
element.KeySet = false;
|
||||
}
|
||||
} else if (element.EValue.IsObjectType<Array>()) {
|
||||
Array::Ptr arr = element.EValue;
|
||||
arr->Add(value);
|
||||
} else {
|
||||
BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot add value to JSON element."));
|
||||
}
|
||||
}
|
||||
|
||||
Value GetValue() const
|
||||
{
|
||||
ASSERT(m_Stack.size() == 1);
|
||||
return m_Stack.top().EValue;
|
||||
}
|
||||
|
||||
void SaveException()
|
||||
{
|
||||
m_Exception = boost::current_exception();
|
||||
}
|
||||
|
||||
void ThrowException() const
|
||||
{
|
||||
if (m_Exception)
|
||||
boost::rethrow_exception(m_Exception);
|
||||
}
|
||||
|
||||
private:
|
||||
std::stack<JsonElement> m_Stack;
|
||||
Value m_Key;
|
||||
boost::exception_ptr m_Exception;
|
||||
};
|
||||
|
||||
static int DecodeNull(void *ctx)
|
||||
{
|
||||
auto *context = static_cast<JsonContext *>(ctx);
|
||||
|
||||
try {
|
||||
context->AddValue(Empty);
|
||||
} catch (...) {
|
||||
context->SaveException();
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int DecodeBoolean(void *ctx, int value)
|
||||
{
|
||||
auto *context = static_cast<JsonContext *>(ctx);
|
||||
|
||||
try {
|
||||
context->AddValue(static_cast<bool>(value));
|
||||
} catch (...) {
|
||||
context->SaveException();
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int DecodeNumber(void *ctx, const char *str, yajl_size len)
|
||||
{
|
||||
auto *context = static_cast<JsonContext *>(ctx);
|
||||
|
||||
try {
|
||||
String jstr = String(str, str + len);
|
||||
context->AddValue(Convert::ToDouble(jstr));
|
||||
} catch (...) {
|
||||
context->SaveException();
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int DecodeString(void *ctx, const unsigned char *str, yajl_size len)
|
||||
{
|
||||
auto *context = static_cast<JsonContext *>(ctx);
|
||||
|
||||
try {
|
||||
context->AddValue(String(str, str + len));
|
||||
} catch (...) {
|
||||
context->SaveException();
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int DecodeStartMap(void *ctx)
|
||||
{
|
||||
auto *context = static_cast<JsonContext *>(ctx);
|
||||
|
||||
try {
|
||||
context->Push(new Dictionary());
|
||||
} catch (...) {
|
||||
context->SaveException();
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int DecodeEndMapOrArray(void *ctx)
|
||||
{
|
||||
auto *context = static_cast<JsonContext *>(ctx);
|
||||
|
||||
try {
|
||||
context->AddValue(context->Pop().EValue);
|
||||
} catch (...) {
|
||||
context->SaveException();
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int DecodeStartArray(void *ctx)
|
||||
{
|
||||
auto *context = static_cast<JsonContext *>(ctx);
|
||||
|
||||
try {
|
||||
context->Push(new Array());
|
||||
} catch (...) {
|
||||
context->SaveException();
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
Value icinga::JsonDecode(const String& data)
|
||||
{
|
||||
static const yajl_callbacks callbacks = {
|
||||
DecodeNull,
|
||||
DecodeBoolean,
|
||||
nullptr,
|
||||
nullptr,
|
||||
DecodeNumber,
|
||||
DecodeString,
|
||||
DecodeStartMap,
|
||||
DecodeString,
|
||||
DecodeEndMapOrArray,
|
||||
DecodeStartArray,
|
||||
DecodeEndMapOrArray
|
||||
};
|
||||
String sanitized (Utility::ValidateUTF8(data));
|
||||
|
||||
yajl_handle handle;
|
||||
#if YAJL_MAJOR < 2
|
||||
yajl_parser_config cfg = { 1, 0 };
|
||||
#endif /* YAJL_MAJOR */
|
||||
JsonContext context;
|
||||
JsonSax stateMachine;
|
||||
|
||||
#if YAJL_MAJOR < 2
|
||||
handle = yajl_alloc(&callbacks, &cfg, nullptr, &context);
|
||||
#else /* YAJL_MAJOR */
|
||||
handle = yajl_alloc(&callbacks, nullptr, &context);
|
||||
yajl_config(handle, yajl_dont_validate_strings, 1);
|
||||
yajl_config(handle, yajl_allow_comments, 1);
|
||||
#endif /* YAJL_MAJOR */
|
||||
nlohmann::json::sax_parse(sanitized.Begin(), sanitized.End(), &stateMachine);
|
||||
|
||||
yajl_parse(handle, reinterpret_cast<const unsigned char *>(data.CStr()), data.GetLength());
|
||||
return stateMachine.GetResult();
|
||||
}
|
||||
|
||||
#if YAJL_MAJOR < 2
|
||||
if (yajl_parse_complete(handle) != yajl_status_ok) {
|
||||
#else /* YAJL_MAJOR */
|
||||
if (yajl_complete_parse(handle) != yajl_status_ok) {
|
||||
#endif /* YAJL_MAJOR */
|
||||
unsigned char *internal_err_str = yajl_get_error(handle, 1, reinterpret_cast<const unsigned char *>(data.CStr()), data.GetLength());
|
||||
String msg = reinterpret_cast<char *>(internal_err_str);
|
||||
yajl_free_error(handle, internal_err_str);
|
||||
inline
|
||||
bool JsonSax::null()
|
||||
{
|
||||
FillCurrentTarget(Value());
|
||||
|
||||
yajl_free(handle);
|
||||
return true;
|
||||
}
|
||||
|
||||
/* throw saved exception (if there is one) */
|
||||
context.ThrowException();
|
||||
inline
|
||||
bool JsonSax::boolean(bool val)
|
||||
{
|
||||
FillCurrentTarget(val);
|
||||
|
||||
BOOST_THROW_EXCEPTION(std::invalid_argument(msg));
|
||||
return true;
|
||||
}
|
||||
|
||||
inline
|
||||
bool JsonSax::number_integer(JsonSax::number_integer_t val)
|
||||
{
|
||||
FillCurrentTarget((double)val);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline
|
||||
bool JsonSax::number_unsigned(JsonSax::number_unsigned_t val)
|
||||
{
|
||||
FillCurrentTarget((double)val);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline
|
||||
bool JsonSax::number_float(JsonSax::number_float_t val, const JsonSax::string_t&)
|
||||
{
|
||||
FillCurrentTarget((double)val);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline
|
||||
bool JsonSax::string(JsonSax::string_t& val)
|
||||
{
|
||||
FillCurrentTarget(String(std::move(val)));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline
|
||||
bool JsonSax::start_object(std::size_t)
|
||||
{
|
||||
auto object (new Dictionary());
|
||||
|
||||
FillCurrentTarget(object);
|
||||
|
||||
m_CurrentSubtree.push({object, nullptr});
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline
|
||||
bool JsonSax::key(JsonSax::string_t& val)
|
||||
{
|
||||
m_CurrentKey = String(std::move(val));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline
|
||||
bool JsonSax::end_object()
|
||||
{
|
||||
m_CurrentSubtree.pop();
|
||||
m_CurrentKey = String();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline
|
||||
bool JsonSax::start_array(std::size_t)
|
||||
{
|
||||
auto array (new Array());
|
||||
|
||||
FillCurrentTarget(array);
|
||||
|
||||
m_CurrentSubtree.push({nullptr, array});
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline
|
||||
bool JsonSax::end_array()
|
||||
{
|
||||
m_CurrentSubtree.pop();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline
|
||||
bool JsonSax::parse_error(std::size_t, const std::string&, const nlohmann::detail::exception& ex)
|
||||
{
|
||||
throw std::invalid_argument(ex.what());
|
||||
}
|
||||
|
||||
inline
|
||||
Value JsonSax::GetResult()
|
||||
{
|
||||
return m_Root;
|
||||
}
|
||||
|
||||
inline
|
||||
void JsonSax::FillCurrentTarget(Value value)
|
||||
{
|
||||
if (m_CurrentSubtree.empty()) {
|
||||
m_Root = value;
|
||||
} else {
|
||||
auto& node (m_CurrentSubtree.top());
|
||||
|
||||
if (node.first) {
|
||||
node.first->Set(m_CurrentKey, value);
|
||||
} else {
|
||||
node.second->Add(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::Null()
|
||||
{
|
||||
BeforeItem();
|
||||
AppendChars((const char*)l_Null, (const char*)l_Null + 4);
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::Boolean(bool value)
|
||||
{
|
||||
BeforeItem();
|
||||
|
||||
if (value) {
|
||||
AppendChars((const char*)l_True, (const char*)l_True + 4);
|
||||
} else {
|
||||
AppendChars((const char*)l_False, (const char*)l_False + 5);
|
||||
}
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::NumberFloat(double value)
|
||||
{
|
||||
BeforeItem();
|
||||
AppendJson(value);
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::Strng(String value)
|
||||
{
|
||||
BeforeItem();
|
||||
AppendJson(std::move(value));
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::StartObject()
|
||||
{
|
||||
BeforeItem();
|
||||
AppendChar('{');
|
||||
|
||||
m_CurrentSubtree.push(2);
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::Key(String value)
|
||||
{
|
||||
m_CurrentKey = std::move(value);
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::EndObject()
|
||||
{
|
||||
FinishContainer('}');
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::StartArray()
|
||||
{
|
||||
BeforeItem();
|
||||
AppendChar('[');
|
||||
|
||||
m_CurrentSubtree.push(0);
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::EndArray()
|
||||
{
|
||||
FinishContainer(']');
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
String JsonEncoder<prettyPrint>::GetResult()
|
||||
{
|
||||
return String(m_Result.begin(), m_Result.end());
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::AppendChar(char c)
|
||||
{
|
||||
m_Result.emplace_back(c);
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
template<class Iterator>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::AppendChars(Iterator begin, Iterator end)
|
||||
{
|
||||
m_Result.insert(m_Result.end(), begin, end);
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::AppendJson(nlohmann::json json)
|
||||
{
|
||||
nlohmann::detail::serializer<nlohmann::json>(nlohmann::detail::output_adapter<char>(m_Result), ' ').dump(std::move(json), prettyPrint, true, 0);
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::BeforeItem()
|
||||
{
|
||||
if (!m_CurrentSubtree.empty()) {
|
||||
auto& node (m_CurrentSubtree.top());
|
||||
|
||||
if (node[0]) {
|
||||
AppendChar(',');
|
||||
} else {
|
||||
node[0] = true;
|
||||
}
|
||||
|
||||
if (prettyPrint) {
|
||||
AppendChar('\n');
|
||||
|
||||
for (auto i (m_CurrentSubtree.size()); i; --i) {
|
||||
AppendChars((const char*)l_Indent, (const char*)l_Indent + 4);
|
||||
}
|
||||
}
|
||||
|
||||
if (node[1]) {
|
||||
AppendJson(std::move(m_CurrentKey));
|
||||
AppendChar(':');
|
||||
|
||||
if (prettyPrint) {
|
||||
AppendChar(' ');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<bool prettyPrint>
|
||||
inline
|
||||
void JsonEncoder<prettyPrint>::FinishContainer(char terminator)
|
||||
{
|
||||
if (prettyPrint && m_CurrentSubtree.top()[0]) {
|
||||
AppendChar('\n');
|
||||
|
||||
for (auto i (m_CurrentSubtree.size() - 1u); i; --i) {
|
||||
AppendChars((const char*)l_Indent, (const char*)l_Indent + 4);
|
||||
}
|
||||
}
|
||||
|
||||
yajl_free(handle);
|
||||
AppendChar(terminator);
|
||||
|
||||
return context.GetValue();
|
||||
m_CurrentSubtree.pop();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -69,6 +69,8 @@ add_boost_test(base
|
|||
base_dictionary/json
|
||||
base_fifo/construct
|
||||
base_fifo/io
|
||||
base_json/encode
|
||||
base_json/decode
|
||||
base_json/invalid1
|
||||
base_object_packer/pack_null
|
||||
base_object_packer/pack_false
|
||||
|
|
|
|||
|
|
@ -1,14 +1,99 @@
|
|||
/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */
|
||||
|
||||
#include "base/dictionary.hpp"
|
||||
#include "base/namespace.hpp"
|
||||
#include "base/array.hpp"
|
||||
#include "base/objectlock.hpp"
|
||||
#include "base/json.hpp"
|
||||
#include <boost/algorithm/string/replace.hpp>
|
||||
#include <BoostTestTargetConfig.h>
|
||||
|
||||
using namespace icinga;
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(base_json)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(encode)
|
||||
{
|
||||
Dictionary::Ptr input (new Dictionary({
|
||||
{ "array", new Array({ new Namespace() }) },
|
||||
{ "false", false },
|
||||
{ "float", -1.25 },
|
||||
{ "int", -42 },
|
||||
{ "null", Value() },
|
||||
{ "string", "LF\nTAB\tAUml\xC3\xA4Ill\xC3" },
|
||||
{ "true", true },
|
||||
{ "uint", 23u }
|
||||
}));
|
||||
|
||||
String output (R"EOF({
|
||||
"array": [
|
||||
{}
|
||||
],
|
||||
"false": false,
|
||||
"float": -1.25,
|
||||
"int": -42.0,
|
||||
"null": null,
|
||||
"string": "LF\nTAB\tAUml\u00e4Ill\ufffd",
|
||||
"true": true,
|
||||
"uint": 23.0
|
||||
})EOF");
|
||||
|
||||
BOOST_CHECK(JsonEncode(input, true) == output);
|
||||
|
||||
boost::algorithm::replace_all(output, " ", "");
|
||||
boost::algorithm::replace_all(output, "\n", "");
|
||||
|
||||
BOOST_CHECK(JsonEncode(input, false) == output);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(decode)
|
||||
{
|
||||
String input (R"EOF({
|
||||
"array": [
|
||||
{}
|
||||
],
|
||||
"false": false,
|
||||
"float": -1.25,
|
||||
"int": -42.0,
|
||||
"null": null,
|
||||
"string": "LF\nTAB\tAUmlIll",
|
||||
"true": true,
|
||||
"uint": 23.0
|
||||
})EOF");
|
||||
|
||||
boost::algorithm::replace_all(input, "AUml", "AUml\xC3\xA4");
|
||||
boost::algorithm::replace_all(input, "Ill", "Ill\xC3");
|
||||
|
||||
auto output ((Dictionary::Ptr)JsonDecode(input));
|
||||
BOOST_CHECK(output->GetKeys() == std::vector<String>({"array", "false", "float", "int", "null", "string", "true", "uint"}));
|
||||
|
||||
auto array ((Array::Ptr)output->Get("array"));
|
||||
BOOST_CHECK(array->GetLength() == 1u);
|
||||
|
||||
auto array0 ((Dictionary::Ptr)array->Get(0));
|
||||
BOOST_CHECK(array0->GetKeys() == std::vector<String>());
|
||||
|
||||
auto fAlse (output->Get("false"));
|
||||
BOOST_CHECK(fAlse.IsBoolean() && !fAlse.ToBool());
|
||||
|
||||
auto fLoat (output->Get("float"));
|
||||
BOOST_CHECK(fLoat.IsNumber() && fLoat.Get<double>() == -1.25);
|
||||
|
||||
auto iNt (output->Get("int"));
|
||||
BOOST_CHECK(iNt.IsNumber() && iNt.Get<double>() == -42.0);
|
||||
|
||||
BOOST_CHECK(output->Get("null").IsEmpty());
|
||||
|
||||
auto string (output->Get("string"));
|
||||
BOOST_CHECK(string.IsString() && string.Get<String>() == "LF\nTAB\tAUml\xC3\xA4Ill\xEF\xBF\xBD");
|
||||
|
||||
auto tRue (output->Get("true"));
|
||||
BOOST_CHECK(tRue.IsBoolean() && tRue.ToBool());
|
||||
|
||||
auto uint (output->Get("uint"));
|
||||
BOOST_CHECK(uint.IsNumber() && uint.Get<double>() == 23.0);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(invalid1)
|
||||
{
|
||||
BOOST_CHECK_THROW(JsonDecode("\"1.7"), std::exception);
|
||||
|
|
|
|||
|
|
@ -2,10 +2,6 @@
|
|||
|
||||
add_subdirectory(mmatch)
|
||||
|
||||
if(NOT YAJL_FOUND)
|
||||
add_subdirectory(yajl)
|
||||
endif()
|
||||
|
||||
if(UNIX OR CYGWIN)
|
||||
add_subdirectory(execvpe)
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -0,0 +1,21 @@
|
|||
MIT License
|
||||
|
||||
Copyright (c) 2013-2018 Niels Lohmann
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,3 +0,0 @@
|
|||
.DS_Store
|
||||
Makefile
|
||||
/build/
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
Short story (If you already have ruby and cmake):
|
||||
|
||||
./configure && make install
|
||||
|
||||
When things go wrong:
|
||||
|
||||
attain CMake (http://www.cmake.org) and ruby (http://ruby-lang.org) and
|
||||
try again.
|
||||
|
||||
OR, attain CMake and build by hand:
|
||||
|
||||
1. mkdir build
|
||||
2. cd build
|
||||
3. cmake ..
|
||||
4. make
|
||||
5. build output left in yajl-X.Y.Z
|
||||
|
||||
NOTE: for 64-bit systems where lib64 is used you can pass the cmake
|
||||
variable LIB_SUFFIX to cause installation into the system's 'lib64'
|
||||
directory.
|
||||
|
||||
best,
|
||||
lloyd
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
YAJL has been successfully built using Visual Studio 8. CMake, a
|
||||
build file generator, is used to build the software. CMake supports
|
||||
several different build environments, so you may either build YAJL
|
||||
using the IDE via the following steps:
|
||||
|
||||
1. acquire cmake (http://www.cmake.org)
|
||||
2. mkdir build
|
||||
3. cd build
|
||||
4. cmake ..
|
||||
5. devenv YetAnotherJSONParser.sln /project ALL_BUILD /build Release
|
||||
6. build output is left in build/yajl-X.Y.Z
|
||||
|
||||
Or you can build from the command line using nmake:
|
||||
|
||||
1. Click Start > Programs > Microsoft Visual Studio > Visual Studio
|
||||
Tools > Visual Studio Command Prompt -- for your version of Visual
|
||||
Studio, which will open a command prompt. You may verify that the
|
||||
compiler is in your path by typing "cl /?" at the prompt.
|
||||
2. cd C:\path\to\yajl\source\
|
||||
3. mkdir build
|
||||
4. cd build
|
||||
5. cmake -G"NMake Makefiles" -DCMAKE_BUILD_TYPE=Release ..
|
||||
6. nmake
|
||||
7. nmake install
|
||||
|
||||
Earlier versions of visual studio and other build generators haven't
|
||||
been thoroughly tested, but should work without any major issues.
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
# Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
#
|
||||
# Permission to use, copy, modify, and/or distribute this software for any
|
||||
# purpose with or without fee is hereby granted, provided that the above
|
||||
# copyright notice and this permission notice appear in all copies.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
|
||||
|
||||
PROJECT(YetAnotherJSONParser C)
|
||||
|
||||
SET (YAJL_MAJOR 2)
|
||||
SET (YAJL_MINOR 1)
|
||||
SET (YAJL_MICRO 0)
|
||||
|
||||
IF (WIN32)
|
||||
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
|
||||
ADD_DEFINITIONS(-DWIN32)
|
||||
|
||||
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4996 /wd4255 /wd4130 /wd4100 /wd4711")
|
||||
SET(CMAKE_C_FLAGS_DEBUG "/D DEBUG /Od /Z7")
|
||||
SET(CMAKE_C_FLAGS_RELEASE "/D NDEBUG /O2")
|
||||
ELSE (WIN32)
|
||||
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
|
||||
IF(CMAKE_COMPILER_IS_GNUCC)
|
||||
INCLUDE(CheckCCompilerFlag)
|
||||
CHECK_C_COMPILER_FLAG(-fvisibility=hidden HAVE_GCC_VISIBILITY)
|
||||
IF(HAVE_GCC_VISIBILITY)
|
||||
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
|
||||
ENDIF(HAVE_GCC_VISIBILITY)
|
||||
ENDIF(CMAKE_COMPILER_IS_GNUCC)
|
||||
SET(CMAKE_C_FLAGS
|
||||
"${CMAKE_C_FLAGS} -std=c99 -pedantic -Wpointer-arith -Wno-format-y2k -Wstrict-prototypes -Wmissing-declarations -Wnested-externs -Wextra -Wundef -Wwrite-strings -Wold-style-definition -Wredundant-decls -Wno-unused-parameter -Wno-sign-compare -Wmissing-prototypes")
|
||||
|
||||
SET(CMAKE_C_FLAGS_DEBUG "-DDEBUG")
|
||||
SET(CMAKE_C_FLAGS_RELEASE "-DNDEBUG -Wuninitialized")
|
||||
ENDIF (WIN32)
|
||||
|
||||
ADD_SUBDIRECTORY(src)
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
copyright notice and this permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
|
@ -1,189 +0,0 @@
|
|||
2.1.0
|
||||
* @nonodename, @patperry - fixed some compiler warnings
|
||||
* @yep, @emaste - documentation improvements
|
||||
* @sgravrock - build fix for NetBSD (and whenever sh != bash)
|
||||
* @rotty, @brimstone3, @lloyd - allow client to reset generator
|
||||
* @sgravrock - remove bash dependencies
|
||||
* @lloyd - add api tests
|
||||
* @rflynn - remove ruby dependency
|
||||
* @cloderic - nmake install works on windows
|
||||
* @shahbag - build fix for qnx
|
||||
* @breese - debugging improvements
|
||||
* @lloyd - json_verify supports -s flag for stream processing
|
||||
* @lloyd - json_reformat supports -s flag for stream processing
|
||||
|
||||
2.0.4
|
||||
* @jcekstrom - additional checking in integer parsing
|
||||
* @jcekstrom - fix a bug in yajl_tree that would cause valid json integersto fail to parse
|
||||
* @plaguemorin - fix a memory leak in yajl_tree (error strings were being leaked)
|
||||
* @7AC - reset errno
|
||||
* @ConradIrwin - include flags to reformatter to allow toggling of escape solidus option
|
||||
|
||||
2.0.3
|
||||
* John Stamp generation of a pkgconfig file at build time.
|
||||
* @robzuber bugfix in yajl_tree_get()
|
||||
* @lloyd - fix for compilation on 64 bit windows
|
||||
|
||||
2.0.2
|
||||
* lth fix typos in yajl_tree.h macros YAJL_IS_INTEGER and YAJL_IS_DOUBLE,
|
||||
contributed by Artem S Vybornov.
|
||||
* lth add #ifdef __cplusplus wrappers to yajl_tree to allow proper
|
||||
usage from many populer C++ compilers.
|
||||
|
||||
2.0.1
|
||||
* lth generator flag to allow client to specify they want
|
||||
escaped solidi '/'. issue #28
|
||||
* lth crash fix when yajl_parse() is never called. issue #27
|
||||
|
||||
2.0.0
|
||||
* lth YAJL is now ISC licensed: http://en.wikipedia.org/wiki/ISC_license
|
||||
* lth 20-35% (osx and linux respectively) parsing performance
|
||||
improvement attained by tweaking string scanning (idea: @michaelrhanson).
|
||||
* Florian Forster & lth - yajl_tree interface introduced as a higher level
|
||||
interface to the parser (eats JSON, poops a memory representation)
|
||||
* lth require a C99 compiler
|
||||
* lth integers are now represented with long long (64bit+) on all platforms.
|
||||
* lth size_t now used throughout to represent buffer lengths, so you can
|
||||
safely manage buffers greater than 4GB.
|
||||
* gno semantic improvements to yajl's API regarding partial value parsing and
|
||||
trailing garbage
|
||||
* lth new configuration mechanism for yajl, see yajl_config() and
|
||||
yajl_gen_config()
|
||||
* gno more allocation checking in more places
|
||||
* gno remove usage of strtol, replace with custom implementation that cares
|
||||
not about your locale.
|
||||
* lth yajl_parse_complete renamed to yajl_complete_parse.
|
||||
* lth add a switch to validate utf8 strings as they are generated.
|
||||
* lth tests are a lot quieter in their output.
|
||||
* lth addition of a little in tree performance benchmark, `perftest` in
|
||||
perf/perftest.c
|
||||
|
||||
1.0.12
|
||||
* Conrad Irwin - Parse null bytes correctly
|
||||
* Mirek Rusin - fix LLVM warnings
|
||||
* gno - Don't generate numbers for keys. closes #13
|
||||
* lth - various win32 fixes, including build documentation improvements
|
||||
* John Stamp - Don't export private symbols.
|
||||
* John Stamp - Install yajl_version.h, not the template.
|
||||
* John Stamp - Don't use -fPIC for static lib. Cmake will automatically add it for the shared.
|
||||
* lth 0 fix paths embedded in dylib upon installation on osx. closes #11
|
||||
|
||||
1.0.11
|
||||
* lth remove -Wno-missing-field-initializers for greater gcc compat (3.4.6)
|
||||
|
||||
1.0.10
|
||||
* Brian Maher - yajl is now buildable without a c++ compiler present
|
||||
* Brian Maher - fix header installation on OSX with cmake 2.8.0 installed
|
||||
* lth & vitali - allow builder to specify alternate lib directory
|
||||
for installation (i.e. lib64)
|
||||
* Vitali Lovich - yajl version number now programatically accessible
|
||||
* lth - prevent cmake from embedding rpaths in binaries. Static linking
|
||||
makes this unneccesary.
|
||||
|
||||
1.0.9
|
||||
* lth - fix inverted logic causing yajl_gen_double() to always fail on
|
||||
win32 (thanks to Fredrik Kihlander for the report)
|
||||
|
||||
1.0.8
|
||||
* Randall E. Barker - move dllexport defnitions so dlls with proper
|
||||
exports can again be generated on windows
|
||||
* lth - add yajl_get_bytes_consumed() which allows the client to
|
||||
determine the offset as an error, as well as determine how
|
||||
many bytes of an input buffer were consumed.
|
||||
* lth - fixes to keep "error offset" up to date (like when the
|
||||
client callback returns 0)
|
||||
* Brian Maher - allow client to specify a printing function in
|
||||
generation
|
||||
|
||||
1.0.7
|
||||
* lth fix win32 build (isinf and isnan)
|
||||
|
||||
1.0.6
|
||||
* lth fix several compiler warnings
|
||||
* lth fix generation of invalid json from yajl_gen_double
|
||||
(NaN is not JSON)
|
||||
* jstamp support for combining short options in tools
|
||||
* jstamp exit properly on errors from tools
|
||||
* octo test success no longer depends on integer size
|
||||
* max fix configure --prefix
|
||||
|
||||
1.0.5
|
||||
* lth several performance improvements related to function
|
||||
inlinin'
|
||||
|
||||
1.0.4
|
||||
* lth fix broken utf8 validation for three & four byte represenations.
|
||||
thanks to http://github.com/brianmario and
|
||||
http://github.com/technoweenie
|
||||
|
||||
1.0.3
|
||||
* lth fix syntax error in cplusplus extern "C" statements for wider
|
||||
compiler support
|
||||
|
||||
1.0.2
|
||||
* lth update doxygen documentation with new sample code, passing NULL
|
||||
for allocation functions added in 1.0.0
|
||||
|
||||
1.0.1
|
||||
* lth resolve crash in json_reformatter due to incorrectly ordered
|
||||
parameters.
|
||||
|
||||
1.0.0
|
||||
* lth add 'make install' rules, thaks to Andrei Soroker for the
|
||||
contribution.
|
||||
* lth client may override allocation routines at generator or parser
|
||||
allocation time
|
||||
* tjw add yajl_parse_complete routine to allow client to explicitly
|
||||
specify end-of-input, solving the "lonely number" case, where
|
||||
json text consists only of an element with no explicit syntactic
|
||||
end.
|
||||
* tjw many new test cases
|
||||
* tjw cleanup of code for symmetry and ease of reading
|
||||
* lth integration of patches from Robert Varga which cleanup
|
||||
compilation warnings on 64 bit linux
|
||||
|
||||
0.4.0
|
||||
* lth buffer overflow bug in yajl_gen_double s/%lf/%g/ - thanks to
|
||||
Eric Bergstrome
|
||||
* lth yajl_number callback to allow passthrough of arbitrary precision
|
||||
numbers to client. Thanks to Hatem Nassrat.
|
||||
* lth yajl_integer now deals in long, instead of long long. This
|
||||
combined with yajl_number improves compiler compatibility while
|
||||
maintaining precision.
|
||||
* lth better ./configure && make experience (still requires cmake and
|
||||
ruby)
|
||||
* lth fix handling of special characters hex 0F and 1F in yajl_encode
|
||||
(thanks to Robert Geiger)
|
||||
* lth allow leading zeros in exponents (thanks to Hatem Nassrat)
|
||||
|
||||
0.3.0
|
||||
* lth doxygen documentation (html & man) generated as part of the
|
||||
build
|
||||
* lth many documentation updates.
|
||||
* lth fix to work with older versions of cmake (don't use LOOSE_LOOP
|
||||
constructs)
|
||||
* lth work around different behavior of freebsd 4 scanf. initialize
|
||||
parameter to scanf to zero.
|
||||
* lth all tests run 32x with ranging buffer sizes to stress stream
|
||||
parsing
|
||||
* lth yajl_test accepts -b option to allow read buffer size to be
|
||||
set
|
||||
* lth option to validate UTF8 added to parser (argument in
|
||||
yajl_parser_cfg)
|
||||
* lth fix buffer overrun when chunk ends inside \u escaped text
|
||||
* lth support client cancelation
|
||||
|
||||
0.2.2
|
||||
* lth on windows build debug with C7 symbols and no pdb files.
|
||||
|
||||
0.2.1
|
||||
* fix yajl_reformat and yajl_verify to work on arbitrarily sized
|
||||
inputs.
|
||||
* fix win32 build break, clean up all errors and warnings.
|
||||
* fix optimized build flags.
|
||||
|
||||
0.2.0
|
||||
* optionally support comments in input text
|
||||
|
||||
0.1.0
|
||||
* Initial release
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
**********************************************************************
|
||||
This is YAJL 2. For the legacy version of YAJL see
|
||||
https://github.com/lloyd/yajl/tree/1.x
|
||||
**********************************************************************
|
||||
|
||||
Welcome to Yet Another JSON Library (YAJL)
|
||||
|
||||
## Why does the world need another C library for parsing JSON?
|
||||
|
||||
Good question. In a review of current C JSON parsing libraries I was
|
||||
unable to find one that satisfies my requirements. Those are,
|
||||
0. written in C
|
||||
1. portable
|
||||
2. robust -- as close to "crash proof" as possible
|
||||
3. data representation independent
|
||||
4. fast
|
||||
5. generates verbose, useful error messages including context of where
|
||||
the error occurs in the input text.
|
||||
6. can parse JSON data off a stream, incrementally
|
||||
7. simple to use
|
||||
8. tiny
|
||||
|
||||
Numbers 3, 5, 6, and 7 were particularly hard to find, and were what
|
||||
caused me to ultimately create YAJL. This document is a tour of some
|
||||
of the more important aspects of YAJL.
|
||||
|
||||
## YAJL is Free.
|
||||
|
||||
Permissive licensing means you can use it in open source and
|
||||
commercial products alike without any fees. My request beyond the
|
||||
licensing is that if you find bugs drop me a email, or better yet,
|
||||
fork and fix.
|
||||
|
||||
Porting YAJL should be trivial, the implementation is ANSI C. If you
|
||||
port to new systems I'd love to hear of it and integrate your patches.
|
||||
|
||||
## YAJL is data representation independent.
|
||||
|
||||
BYODR! Many JSON libraries impose a structure based data representation
|
||||
on you. This is a benefit in some cases and a drawback in others.
|
||||
YAJL uses callbacks to remain agnostic of the in-memory representation.
|
||||
So if you wish to build up an in-memory representation, you may do so
|
||||
using YAJL, but you must bring the code that defines and populates the
|
||||
in memory structure.
|
||||
|
||||
This also means that YAJL can be used by other (higher level) JSON
|
||||
libraries if so desired.
|
||||
|
||||
## YAJL supports stream parsing
|
||||
|
||||
This means you do not need to hold the whole JSON representation in
|
||||
textual form in memory. This makes YAJL ideal for filtering projects,
|
||||
where you're converting YAJL from one form to another (i.e. XML). The
|
||||
included JSON pretty printer is an example of such a filter program.
|
||||
|
||||
## YAJL is fast
|
||||
|
||||
Minimal memory copying is performed. YAJL, when possible, returns
|
||||
pointers into the client provided text (i.e. for strings that have no
|
||||
embedded escape chars, hopefully the common case). I've put a lot of
|
||||
effort into profiling and tuning performance, but I have ignored a
|
||||
couple possible performance improvements to keep the interface clean,
|
||||
small, and flexible. My hope is that YAJL will perform comparably to
|
||||
the fastest JSON parser out there.
|
||||
|
||||
YAJL should impose both minimal CPU and memory requirements on your
|
||||
application.
|
||||
|
||||
## YAJL is tiny.
|
||||
|
||||
Fat free. No whip.
|
||||
|
||||
enjoy,
|
||||
Lloyd - July, 2007
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
* add a test for 0x1F bug
|
||||
* numeric overflow in integers and double
|
||||
* line and char offsets in the lexer and in error messages
|
||||
* testing:
|
||||
a. the permuter
|
||||
b. some performance comparison against json_checker.
|
||||
* investigate pull instead of push parsing
|
||||
* Handle memory allocation failures gracefully
|
||||
* cygwin/msys support on win32
|
||||
|
|
@ -1,56 +0,0 @@
|
|||
# Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
#
|
||||
# Permission to use, copy, modify, and/or distribute this software for any
|
||||
# purpose with or without fee is hereby granted, provided that the above
|
||||
# copyright notice and this permission notice appear in all copies.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
SET (SRCS yajl.c yajl_lex.c yajl_parser.c yajl_buf.c
|
||||
yajl_encode.c yajl_gen.c yajl_alloc.c
|
||||
yajl_tree.c yajl_version.c
|
||||
)
|
||||
SET (HDRS yajl_parser.h yajl_lex.h yajl_buf.h yajl_encode.h yajl_alloc.h)
|
||||
SET (PUB_HDRS api/yajl_parse.h api/yajl_gen.h api/yajl_common.h api/yajl_tree.h)
|
||||
|
||||
# useful when fixing lexer bugs.
|
||||
#ADD_DEFINITIONS(-DYAJL_LEXER_DEBUG)
|
||||
|
||||
# Ensure defined when building YAJL (as opposed to using it from
|
||||
# another project). Used to ensure correct function export when
|
||||
# building win32 DLL.
|
||||
ADD_DEFINITIONS(-DYAJL_BUILD)
|
||||
|
||||
# set up some paths
|
||||
SET (incDir ${CMAKE_CURRENT_BINARY_DIR}/../include/yajl)
|
||||
|
||||
ADD_LIBRARY(yajl OBJECT ${SRCS} ${HDRS} ${PUB_HDRS})
|
||||
|
||||
#### setup shared library version number
|
||||
SET_TARGET_PROPERTIES(yajl
|
||||
PROPERTIES
|
||||
FOLDER Lib
|
||||
)
|
||||
|
||||
#### build up an sdk as a post build step
|
||||
|
||||
# create some directories
|
||||
FILE(MAKE_DIRECTORY ${incDir})
|
||||
|
||||
# generate build-time source
|
||||
CONFIGURE_FILE(api/yajl_version.h.cmake ${incDir}/yajl_version.h)
|
||||
|
||||
# copy public headers to output directory
|
||||
FOREACH (header ${PUB_HDRS})
|
||||
SET (header "${CMAKE_CURRENT_SOURCE_DIR}/${header}")
|
||||
|
||||
EXEC_PROGRAM(${CMAKE_COMMAND} ARGS -E copy_if_different \"${header}\" \"${incDir}\")
|
||||
ENDFOREACH (header ${PUB_HDRS})
|
||||
|
||||
INCLUDE_DIRECTORIES(${incDir}/..)
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef __YAJL_COMMON_H__
|
||||
#define __YAJL_COMMON_H__
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define YAJL_MAX_DEPTH 128
|
||||
|
||||
/* msft dll export gunk. To build a DLL on windows, you
|
||||
* must define WIN32, YAJL_SHARED, and YAJL_BUILD. To use a shared
|
||||
* DLL, you must define YAJL_SHARED and WIN32 */
|
||||
#if (defined(_WIN32) || defined(WIN32)) && defined(YAJL_SHARED)
|
||||
# ifdef YAJL_BUILD
|
||||
# define YAJL_API __declspec(dllexport)
|
||||
# else
|
||||
# define YAJL_API __declspec(dllimport)
|
||||
# endif
|
||||
#else
|
||||
# if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303
|
||||
# define YAJL_API __attribute__ ((visibility("default")))
|
||||
# else
|
||||
# define YAJL_API
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/** pointer to a malloc function, supporting client overriding memory
|
||||
* allocation routines */
|
||||
typedef void * (*yajl_malloc_func)(void *ctx, size_t sz);
|
||||
|
||||
/** pointer to a free function, supporting client overriding memory
|
||||
* allocation routines */
|
||||
typedef void (*yajl_free_func)(void *ctx, void * ptr);
|
||||
|
||||
/** pointer to a realloc function which can resize an allocation. */
|
||||
typedef void * (*yajl_realloc_func)(void *ctx, void * ptr, size_t sz);
|
||||
|
||||
/** A structure which can be passed to yajl_*_alloc routines to allow the
|
||||
* client to specify memory allocation functions to be used. */
|
||||
typedef struct
|
||||
{
|
||||
/** pointer to a function that can allocate uninitialized memory */
|
||||
yajl_malloc_func malloc;
|
||||
/** pointer to a function that can resize memory allocations */
|
||||
yajl_realloc_func realloc;
|
||||
/** pointer to a function that can free memory allocated using
|
||||
* reallocFunction or mallocFunction */
|
||||
yajl_free_func free;
|
||||
/** a context pointer that will be passed to above allocation routines */
|
||||
void * ctx;
|
||||
} yajl_alloc_funcs;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -1,165 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file yajl_gen.h
|
||||
* Interface to YAJL's JSON generation facilities.
|
||||
*/
|
||||
|
||||
#include <yajl/yajl_common.h>
|
||||
|
||||
#ifndef __YAJL_GEN_H__
|
||||
#define __YAJL_GEN_H__
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
/** generator status codes */
|
||||
typedef enum {
|
||||
/** no error */
|
||||
yajl_gen_status_ok = 0,
|
||||
/** at a point where a map key is generated, a function other than
|
||||
* yajl_gen_string was called */
|
||||
yajl_gen_keys_must_be_strings,
|
||||
/** YAJL's maximum generation depth was exceeded. see
|
||||
* YAJL_MAX_DEPTH */
|
||||
yajl_max_depth_exceeded,
|
||||
/** A generator function (yajl_gen_XXX) was called while in an error
|
||||
* state */
|
||||
yajl_gen_in_error_state,
|
||||
/** A complete JSON document has been generated */
|
||||
yajl_gen_generation_complete,
|
||||
/** yajl_gen_double was passed an invalid floating point value
|
||||
* (infinity or NaN). */
|
||||
yajl_gen_invalid_number,
|
||||
/** A print callback was passed in, so there is no internal
|
||||
* buffer to get from */
|
||||
yajl_gen_no_buf,
|
||||
/** returned from yajl_gen_string() when the yajl_gen_validate_utf8
|
||||
* option is enabled and an invalid was passed by client code.
|
||||
*/
|
||||
yajl_gen_invalid_string
|
||||
} yajl_gen_status;
|
||||
|
||||
/** an opaque handle to a generator */
|
||||
typedef struct yajl_gen_t * yajl_gen;
|
||||
|
||||
/** a callback used for "printing" the results. */
|
||||
typedef void (*yajl_print_t)(void * ctx,
|
||||
const char * str,
|
||||
size_t len);
|
||||
|
||||
/** configuration parameters for the parser, these may be passed to
|
||||
* yajl_gen_config() along with option specific argument(s). In general,
|
||||
* all configuration parameters default to *off*. */
|
||||
typedef enum {
|
||||
/** generate indented (beautiful) output */
|
||||
yajl_gen_beautify = 0x01,
|
||||
/**
|
||||
* Set an indent string which is used when yajl_gen_beautify
|
||||
* is enabled. Maybe something like \\t or some number of
|
||||
* spaces. The default is four spaces ' '.
|
||||
*/
|
||||
yajl_gen_indent_string = 0x02,
|
||||
/**
|
||||
* Set a function and context argument that should be used to
|
||||
* output generated json. the function should conform to the
|
||||
* yajl_print_t prototype while the context argument is a
|
||||
* void * of your choosing.
|
||||
*
|
||||
* example:
|
||||
* yajl_gen_config(g, yajl_gen_print_callback, myFunc, myVoidPtr);
|
||||
*/
|
||||
yajl_gen_print_callback = 0x04,
|
||||
/**
|
||||
* Normally the generator does not validate that strings you
|
||||
* pass to it via yajl_gen_string() are valid UTF8. Enabling
|
||||
* this option will cause it to do so.
|
||||
*/
|
||||
yajl_gen_validate_utf8 = 0x08,
|
||||
/**
|
||||
* the forward solidus (slash or '/' in human) is not required to be
|
||||
* escaped in json text. By default, YAJL will not escape it in the
|
||||
* iterest of saving bytes. Setting this flag will cause YAJL to
|
||||
* always escape '/' in generated JSON strings.
|
||||
*/
|
||||
yajl_gen_escape_solidus = 0x10
|
||||
} yajl_gen_option;
|
||||
|
||||
/** allow the modification of generator options subsequent to handle
|
||||
* allocation (via yajl_alloc)
|
||||
* \returns zero in case of errors, non-zero otherwise
|
||||
*/
|
||||
YAJL_API int yajl_gen_config(yajl_gen g, yajl_gen_option opt, ...);
|
||||
|
||||
/** allocate a generator handle
|
||||
* \param allocFuncs an optional pointer to a structure which allows
|
||||
* the client to overide the memory allocation
|
||||
* used by yajl. May be NULL, in which case
|
||||
* malloc/free/realloc will be used.
|
||||
*
|
||||
* \returns an allocated handle on success, NULL on failure (bad params)
|
||||
*/
|
||||
YAJL_API yajl_gen yajl_gen_alloc(const yajl_alloc_funcs * allocFuncs);
|
||||
|
||||
/** free a generator handle */
|
||||
YAJL_API void yajl_gen_free(yajl_gen handle);
|
||||
|
||||
YAJL_API yajl_gen_status yajl_gen_integer(yajl_gen hand, long long int number);
|
||||
/** generate a floating point number. number may not be infinity or
|
||||
* NaN, as these have no representation in JSON. In these cases the
|
||||
* generator will return 'yajl_gen_invalid_number' */
|
||||
YAJL_API yajl_gen_status yajl_gen_double(yajl_gen hand, double number);
|
||||
YAJL_API yajl_gen_status yajl_gen_number(yajl_gen hand,
|
||||
const char * num,
|
||||
size_t len);
|
||||
YAJL_API yajl_gen_status yajl_gen_string(yajl_gen hand,
|
||||
const unsigned char * str,
|
||||
size_t len);
|
||||
YAJL_API yajl_gen_status yajl_gen_null(yajl_gen hand);
|
||||
YAJL_API yajl_gen_status yajl_gen_bool(yajl_gen hand, int boolean);
|
||||
YAJL_API yajl_gen_status yajl_gen_map_open(yajl_gen hand);
|
||||
YAJL_API yajl_gen_status yajl_gen_map_close(yajl_gen hand);
|
||||
YAJL_API yajl_gen_status yajl_gen_array_open(yajl_gen hand);
|
||||
YAJL_API yajl_gen_status yajl_gen_array_close(yajl_gen hand);
|
||||
|
||||
/** access the null terminated generator buffer. If incrementally
|
||||
* outputing JSON, one should call yajl_gen_clear to clear the
|
||||
* buffer. This allows stream generation. */
|
||||
YAJL_API yajl_gen_status yajl_gen_get_buf(yajl_gen hand,
|
||||
const unsigned char ** buf,
|
||||
size_t * len);
|
||||
|
||||
/** clear yajl's output buffer, but maintain all internal generation
|
||||
* state. This function will not "reset" the generator state, and is
|
||||
* intended to enable incremental JSON outputing. */
|
||||
YAJL_API void yajl_gen_clear(yajl_gen hand);
|
||||
|
||||
/** Reset the generator state. Allows a client to generate multiple
|
||||
* json entities in a stream. The "sep" string will be inserted to
|
||||
* separate the previously generated entity from the current,
|
||||
* NULL means *no separation* of entites (clients beware, generating
|
||||
* multiple JSON numbers, for instance, will result in inscrutable
|
||||
* output) */
|
||||
YAJL_API void yajl_gen_reset(yajl_gen hand, const char * sep);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -1,226 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file yajl_parse.h
|
||||
* Interface to YAJL's JSON stream parsing facilities.
|
||||
*/
|
||||
|
||||
#include <yajl/yajl_common.h>
|
||||
|
||||
#ifndef __YAJL_PARSE_H__
|
||||
#define __YAJL_PARSE_H__
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
/** error codes returned from this interface */
|
||||
typedef enum {
|
||||
/** no error was encountered */
|
||||
yajl_status_ok,
|
||||
/** a client callback returned zero, stopping the parse */
|
||||
yajl_status_client_canceled,
|
||||
/** An error occurred during the parse. Call yajl_get_error for
|
||||
* more information about the encountered error */
|
||||
yajl_status_error
|
||||
} yajl_status;
|
||||
|
||||
/** attain a human readable, english, string for an error */
|
||||
YAJL_API const char * yajl_status_to_string(yajl_status code);
|
||||
|
||||
/** an opaque handle to a parser */
|
||||
typedef struct yajl_handle_t * yajl_handle;
|
||||
|
||||
/** yajl is an event driven parser. this means as json elements are
|
||||
* parsed, you are called back to do something with the data. The
|
||||
* functions in this table indicate the various events for which
|
||||
* you will be called back. Each callback accepts a "context"
|
||||
* pointer, this is a void * that is passed into the yajl_parse
|
||||
* function which the client code may use to pass around context.
|
||||
*
|
||||
* All callbacks return an integer. If non-zero, the parse will
|
||||
* continue. If zero, the parse will be canceled and
|
||||
* yajl_status_client_canceled will be returned from the parse.
|
||||
*
|
||||
* \attention {
|
||||
* A note about the handling of numbers:
|
||||
*
|
||||
* yajl will only convert numbers that can be represented in a
|
||||
* double or a 64 bit (long long) int. All other numbers will
|
||||
* be passed to the client in string form using the yajl_number
|
||||
* callback. Furthermore, if yajl_number is not NULL, it will
|
||||
* always be used to return numbers, that is yajl_integer and
|
||||
* yajl_double will be ignored. If yajl_number is NULL but one
|
||||
* of yajl_integer or yajl_double are defined, parsing of a
|
||||
* number larger than is representable in a double or 64 bit
|
||||
* integer will result in a parse error.
|
||||
* }
|
||||
*/
|
||||
typedef struct {
|
||||
int (* yajl_null)(void * ctx);
|
||||
int (* yajl_boolean)(void * ctx, int boolVal);
|
||||
int (* yajl_integer)(void * ctx, long long integerVal);
|
||||
int (* yajl_double)(void * ctx, double doubleVal);
|
||||
/** A callback which passes the string representation of the number
|
||||
* back to the client. Will be used for all numbers when present */
|
||||
int (* yajl_number)(void * ctx, const char * numberVal,
|
||||
size_t numberLen);
|
||||
|
||||
/** strings are returned as pointers into the JSON text when,
|
||||
* possible, as a result, they are _not_ null padded */
|
||||
int (* yajl_string)(void * ctx, const unsigned char * stringVal,
|
||||
size_t stringLen);
|
||||
|
||||
int (* yajl_start_map)(void * ctx);
|
||||
int (* yajl_map_key)(void * ctx, const unsigned char * key,
|
||||
size_t stringLen);
|
||||
int (* yajl_end_map)(void * ctx);
|
||||
|
||||
int (* yajl_start_array)(void * ctx);
|
||||
int (* yajl_end_array)(void * ctx);
|
||||
} yajl_callbacks;
|
||||
|
||||
/** allocate a parser handle
|
||||
* \param callbacks a yajl callbacks structure specifying the
|
||||
* functions to call when different JSON entities
|
||||
* are encountered in the input text. May be NULL,
|
||||
* which is only useful for validation.
|
||||
* \param afs memory allocation functions, may be NULL for to use
|
||||
* C runtime library routines (malloc and friends)
|
||||
* \param ctx a context pointer that will be passed to callbacks.
|
||||
*/
|
||||
YAJL_API yajl_handle yajl_alloc(const yajl_callbacks * callbacks,
|
||||
yajl_alloc_funcs * afs,
|
||||
void * ctx);
|
||||
|
||||
|
||||
/** configuration parameters for the parser, these may be passed to
|
||||
* yajl_config() along with option specific argument(s). In general,
|
||||
* all configuration parameters default to *off*. */
|
||||
typedef enum {
|
||||
/** Ignore javascript style comments present in
|
||||
* JSON input. Non-standard, but rather fun
|
||||
* arguments: toggled off with integer zero, on otherwise.
|
||||
*
|
||||
* example:
|
||||
* yajl_config(h, yajl_allow_comments, 1); // turn comment support on
|
||||
*/
|
||||
yajl_allow_comments = 0x01,
|
||||
/**
|
||||
* When set the parser will verify that all strings in JSON input are
|
||||
* valid UTF8 and will emit a parse error if this is not so. When set,
|
||||
* this option makes parsing slightly more expensive (~7% depending
|
||||
* on processor and compiler in use)
|
||||
*
|
||||
* example:
|
||||
* yajl_config(h, yajl_dont_validate_strings, 1); // disable utf8 checking
|
||||
*/
|
||||
yajl_dont_validate_strings = 0x02,
|
||||
/**
|
||||
* By default, upon calls to yajl_complete_parse(), yajl will
|
||||
* ensure the entire input text was consumed and will raise an error
|
||||
* otherwise. Enabling this flag will cause yajl to disable this
|
||||
* check. This can be useful when parsing json out of a that contains more
|
||||
* than a single JSON document.
|
||||
*/
|
||||
yajl_allow_trailing_garbage = 0x04,
|
||||
/**
|
||||
* Allow multiple values to be parsed by a single handle. The
|
||||
* entire text must be valid JSON, and values can be seperated
|
||||
* by any kind of whitespace. This flag will change the
|
||||
* behavior of the parser, and cause it continue parsing after
|
||||
* a value is parsed, rather than transitioning into a
|
||||
* complete state. This option can be useful when parsing multiple
|
||||
* values from an input stream.
|
||||
*/
|
||||
yajl_allow_multiple_values = 0x08,
|
||||
/**
|
||||
* When yajl_complete_parse() is called the parser will
|
||||
* check that the top level value was completely consumed. I.E.,
|
||||
* if called whilst in the middle of parsing a value
|
||||
* yajl will enter an error state (premature EOF). Setting this
|
||||
* flag suppresses that check and the corresponding error.
|
||||
*/
|
||||
yajl_allow_partial_values = 0x10
|
||||
} yajl_option;
|
||||
|
||||
/** allow the modification of parser options subsequent to handle
|
||||
* allocation (via yajl_alloc)
|
||||
* \returns zero in case of errors, non-zero otherwise
|
||||
*/
|
||||
YAJL_API int yajl_config(yajl_handle h, yajl_option opt, ...);
|
||||
|
||||
/** free a parser handle */
|
||||
YAJL_API void yajl_free(yajl_handle handle);
|
||||
|
||||
/** Parse some json!
|
||||
* \param hand - a handle to the json parser allocated with yajl_alloc
|
||||
* \param jsonText - a pointer to the UTF8 json text to be parsed
|
||||
* \param jsonTextLength - the length, in bytes, of input text
|
||||
*/
|
||||
YAJL_API yajl_status yajl_parse(yajl_handle hand,
|
||||
const unsigned char * jsonText,
|
||||
size_t jsonTextLength);
|
||||
|
||||
/** Parse any remaining buffered json.
|
||||
* Since yajl is a stream-based parser, without an explicit end of
|
||||
* input, yajl sometimes can't decide if content at the end of the
|
||||
* stream is valid or not. For example, if "1" has been fed in,
|
||||
* yajl can't know whether another digit is next or some character
|
||||
* that would terminate the integer token.
|
||||
*
|
||||
* \param hand - a handle to the json parser allocated with yajl_alloc
|
||||
*/
|
||||
YAJL_API yajl_status yajl_complete_parse(yajl_handle hand);
|
||||
|
||||
/** get an error string describing the state of the
|
||||
* parse.
|
||||
*
|
||||
* If verbose is non-zero, the message will include the JSON
|
||||
* text where the error occurred, along with an arrow pointing to
|
||||
* the specific char.
|
||||
*
|
||||
* \returns A dynamically allocated string will be returned which should
|
||||
* be freed with yajl_free_error
|
||||
*/
|
||||
YAJL_API unsigned char * yajl_get_error(yajl_handle hand, int verbose,
|
||||
const unsigned char * jsonText,
|
||||
size_t jsonTextLength);
|
||||
|
||||
/**
|
||||
* get the amount of data consumed from the last chunk passed to YAJL.
|
||||
*
|
||||
* In the case of a successful parse this can help you understand if
|
||||
* the entire buffer was consumed (which will allow you to handle
|
||||
* "junk at end of input").
|
||||
*
|
||||
* In the event an error is encountered during parsing, this function
|
||||
* affords the client a way to get the offset into the most recent
|
||||
* chunk where the error occurred. 0 will be returned if no error
|
||||
* was encountered.
|
||||
*/
|
||||
YAJL_API size_t yajl_get_bytes_consumed(yajl_handle hand);
|
||||
|
||||
/** free an error returned from yajl_get_error */
|
||||
YAJL_API void yajl_free_error(yajl_handle hand, unsigned char * str);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -1,186 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2010-2011 Florian Forster <ff at octo.it>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file yajl_tree.h
|
||||
*
|
||||
* Parses JSON data and returns the data in tree form.
|
||||
*
|
||||
* \author Florian Forster
|
||||
* \date August 2010
|
||||
*
|
||||
* This interface makes quick parsing and extraction of
|
||||
* smallish JSON docs trivial:
|
||||
*
|
||||
* \include example/parse_config.c
|
||||
*/
|
||||
|
||||
#ifndef YAJL_TREE_H
|
||||
#define YAJL_TREE_H 1
|
||||
|
||||
#include <yajl/yajl_common.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** possible data types that a yajl_val_s can hold */
|
||||
typedef enum {
|
||||
yajl_t_string = 1,
|
||||
yajl_t_number = 2,
|
||||
yajl_t_object = 3,
|
||||
yajl_t_array = 4,
|
||||
yajl_t_true = 5,
|
||||
yajl_t_false = 6,
|
||||
yajl_t_null = 7,
|
||||
/** The any type isn't valid for yajl_val_s.type, but can be
|
||||
* used as an argument to routines like yajl_tree_get().
|
||||
*/
|
||||
yajl_t_any = 8
|
||||
} yajl_type;
|
||||
|
||||
#define YAJL_NUMBER_INT_VALID 0x01
|
||||
#define YAJL_NUMBER_DOUBLE_VALID 0x02
|
||||
|
||||
/** A pointer to a node in the parse tree */
|
||||
typedef struct yajl_val_s * yajl_val;
|
||||
|
||||
/**
|
||||
* A JSON value representation capable of holding one of the seven
|
||||
* types above. For "string", "number", "object", and "array"
|
||||
* additional data is available in the union. The "YAJL_IS_*"
|
||||
* and "YAJL_GET_*" macros below allow type checking and convenient
|
||||
* value extraction.
|
||||
*/
|
||||
struct yajl_val_s
|
||||
{
|
||||
/** Type of the value contained. Use the "YAJL_IS_*" macros to check for a
|
||||
* specific type. */
|
||||
yajl_type type;
|
||||
/** Type-specific data. You may use the "YAJL_GET_*" macros to access these
|
||||
* members. */
|
||||
union
|
||||
{
|
||||
char * string;
|
||||
struct {
|
||||
long long i; /*< integer value, if representable. */
|
||||
double d; /*< double value, if representable. */
|
||||
char *r; /*< unparsed number in string form. */
|
||||
/** Signals whether the \em i and \em d members are
|
||||
* valid. See \c YAJL_NUMBER_INT_VALID and
|
||||
* \c YAJL_NUMBER_DOUBLE_VALID. */
|
||||
unsigned int flags;
|
||||
} number;
|
||||
struct {
|
||||
const char **keys; /*< Array of keys */
|
||||
yajl_val *values; /*< Array of values. */
|
||||
size_t len; /*< Number of key-value-pairs. */
|
||||
} object;
|
||||
struct {
|
||||
yajl_val *values; /*< Array of elements. */
|
||||
size_t len; /*< Number of elements. */
|
||||
} array;
|
||||
} u;
|
||||
};
|
||||
|
||||
/**
|
||||
* Parse a string.
|
||||
*
|
||||
* Parses an null-terminated string containing JSON data and returns a pointer
|
||||
* to the top-level value (root of the parse tree).
|
||||
*
|
||||
* \param input Pointer to a null-terminated utf8 string containing
|
||||
* JSON data.
|
||||
* \param error_buffer Pointer to a buffer in which an error message will
|
||||
* be stored if \em yajl_tree_parse fails, or
|
||||
* \c NULL. The buffer will be initialized before
|
||||
* parsing, so its content will be destroyed even if
|
||||
* \em yajl_tree_parse succeeds.
|
||||
* \param error_buffer_size Size of the memory area pointed to by
|
||||
* \em error_buffer_size. If \em error_buffer_size is
|
||||
* \c NULL, this argument is ignored.
|
||||
*
|
||||
* \returns Pointer to the top-level value or \c NULL on error. The memory
|
||||
* pointed to must be freed using \em yajl_tree_free. In case of an error, a
|
||||
* null terminated message describing the error in more detail is stored in
|
||||
* \em error_buffer if it is not \c NULL.
|
||||
*/
|
||||
YAJL_API yajl_val yajl_tree_parse (const char *input,
|
||||
char *error_buffer, size_t error_buffer_size);
|
||||
|
||||
|
||||
/**
|
||||
* Free a parse tree returned by "yajl_tree_parse".
|
||||
*
|
||||
* \param v Pointer to a JSON value returned by "yajl_tree_parse". Passing NULL
|
||||
* is valid and results in a no-op.
|
||||
*/
|
||||
YAJL_API void yajl_tree_free (yajl_val v);
|
||||
|
||||
/**
|
||||
* Access a nested value inside a tree.
|
||||
*
|
||||
* \param parent the node under which you'd like to extract values.
|
||||
* \param path A null terminated array of strings, each the name of an object key
|
||||
* \param type the yajl_type of the object you seek, or yajl_t_any if any will do.
|
||||
*
|
||||
* \returns a pointer to the found value, or NULL if we came up empty.
|
||||
*
|
||||
* Future Ideas: it'd be nice to move path to a string and implement support for
|
||||
* a teeny tiny micro language here, so you can extract array elements, do things
|
||||
* like .first and .last, even .length. Inspiration from JSONPath and css selectors?
|
||||
* No it wouldn't be fast, but that's not what this API is about.
|
||||
*/
|
||||
YAJL_API yajl_val yajl_tree_get(yajl_val parent, const char ** path, yajl_type type);
|
||||
|
||||
/* Various convenience macros to check the type of a `yajl_val` */
|
||||
#define YAJL_IS_STRING(v) (((v) != NULL) && ((v)->type == yajl_t_string))
|
||||
#define YAJL_IS_NUMBER(v) (((v) != NULL) && ((v)->type == yajl_t_number))
|
||||
#define YAJL_IS_INTEGER(v) (YAJL_IS_NUMBER(v) && ((v)->u.number.flags & YAJL_NUMBER_INT_VALID))
|
||||
#define YAJL_IS_DOUBLE(v) (YAJL_IS_NUMBER(v) && ((v)->u.number.flags & YAJL_NUMBER_DOUBLE_VALID))
|
||||
#define YAJL_IS_OBJECT(v) (((v) != NULL) && ((v)->type == yajl_t_object))
|
||||
#define YAJL_IS_ARRAY(v) (((v) != NULL) && ((v)->type == yajl_t_array ))
|
||||
#define YAJL_IS_TRUE(v) (((v) != NULL) && ((v)->type == yajl_t_true ))
|
||||
#define YAJL_IS_FALSE(v) (((v) != NULL) && ((v)->type == yajl_t_false ))
|
||||
#define YAJL_IS_NULL(v) (((v) != NULL) && ((v)->type == yajl_t_null ))
|
||||
|
||||
/** Given a yajl_val_string return a ptr to the bare string it contains,
|
||||
* or NULL if the value is not a string. */
|
||||
#define YAJL_GET_STRING(v) (YAJL_IS_STRING(v) ? (v)->u.string : NULL)
|
||||
|
||||
/** Get the string representation of a number. You should check type first,
|
||||
* perhaps using YAJL_IS_NUMBER */
|
||||
#define YAJL_GET_NUMBER(v) ((v)->u.number.r)
|
||||
|
||||
/** Get the double representation of a number. You should check type first,
|
||||
* perhaps using YAJL_IS_DOUBLE */
|
||||
#define YAJL_GET_DOUBLE(v) ((v)->u.number.d)
|
||||
|
||||
/** Get the 64bit (long long) integer representation of a number. You should
|
||||
* check type first, perhaps using YAJL_IS_INTEGER */
|
||||
#define YAJL_GET_INTEGER(v) ((v)->u.number.i)
|
||||
|
||||
/** Get a pointer to a yajl_val_object or NULL if the value is not an object. */
|
||||
#define YAJL_GET_OBJECT(v) (YAJL_IS_OBJECT(v) ? &(v)->u.object : NULL)
|
||||
|
||||
/** Get a pointer to a yajl_val_array or NULL if the value is not an object. */
|
||||
#define YAJL_GET_ARRAY(v) (YAJL_IS_ARRAY(v) ? &(v)->u.array : NULL)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* YAJL_TREE_H */
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
#ifndef YAJL_VERSION_H_
|
||||
#define YAJL_VERSION_H_
|
||||
|
||||
#include <yajl/yajl_common.h>
|
||||
|
||||
#define YAJL_MAJOR ${YAJL_MAJOR}
|
||||
#define YAJL_MINOR ${YAJL_MINOR}
|
||||
#define YAJL_MICRO ${YAJL_MICRO}
|
||||
|
||||
#define YAJL_VERSION ((YAJL_MAJOR * 10000) + (YAJL_MINOR * 100) + YAJL_MICRO)
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int YAJL_API yajl_version(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* YAJL_VERSION_H_ */
|
||||
|
||||
|
|
@ -1,175 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "api/yajl_parse.h"
|
||||
#include "yajl_lex.h"
|
||||
#include "yajl_parser.h"
|
||||
#include "yajl_alloc.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdarg.h>
|
||||
#include <assert.h>
|
||||
|
||||
const char *
|
||||
yajl_status_to_string(yajl_status stat)
|
||||
{
|
||||
const char * statStr = "unknown";
|
||||
switch (stat) {
|
||||
case yajl_status_ok:
|
||||
statStr = "ok, no error";
|
||||
break;
|
||||
case yajl_status_client_canceled:
|
||||
statStr = "client canceled parse";
|
||||
break;
|
||||
case yajl_status_error:
|
||||
statStr = "parse error";
|
||||
break;
|
||||
}
|
||||
return statStr;
|
||||
}
|
||||
|
||||
yajl_handle
|
||||
yajl_alloc(const yajl_callbacks * callbacks,
|
||||
yajl_alloc_funcs * afs,
|
||||
void * ctx)
|
||||
{
|
||||
yajl_handle hand = NULL;
|
||||
yajl_alloc_funcs afsBuffer;
|
||||
|
||||
/* first order of business is to set up memory allocation routines */
|
||||
if (afs != NULL) {
|
||||
if (afs->malloc == NULL || afs->realloc == NULL || afs->free == NULL)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
} else {
|
||||
yajl_set_default_alloc_funcs(&afsBuffer);
|
||||
afs = &afsBuffer;
|
||||
}
|
||||
|
||||
hand = (yajl_handle) YA_MALLOC(afs, sizeof(struct yajl_handle_t));
|
||||
|
||||
/* copy in pointers to allocation routines */
|
||||
memcpy((void *) &(hand->alloc), (void *) afs, sizeof(yajl_alloc_funcs));
|
||||
|
||||
hand->callbacks = callbacks;
|
||||
hand->ctx = ctx;
|
||||
hand->lexer = NULL;
|
||||
hand->bytesConsumed = 0;
|
||||
hand->decodeBuf = yajl_buf_alloc(&(hand->alloc));
|
||||
hand->flags = 0;
|
||||
yajl_bs_init(hand->stateStack, &(hand->alloc));
|
||||
yajl_bs_push(hand->stateStack, yajl_state_start);
|
||||
|
||||
return hand;
|
||||
}
|
||||
|
||||
int
|
||||
yajl_config(yajl_handle h, yajl_option opt, ...)
|
||||
{
|
||||
int rv = 1;
|
||||
va_list ap;
|
||||
va_start(ap, opt);
|
||||
|
||||
switch(opt) {
|
||||
case yajl_allow_comments:
|
||||
case yajl_dont_validate_strings:
|
||||
case yajl_allow_trailing_garbage:
|
||||
case yajl_allow_multiple_values:
|
||||
case yajl_allow_partial_values:
|
||||
if (va_arg(ap, int)) h->flags |= opt;
|
||||
else h->flags &= ~opt;
|
||||
break;
|
||||
default:
|
||||
rv = 0;
|
||||
}
|
||||
va_end(ap);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
void
|
||||
yajl_free(yajl_handle handle)
|
||||
{
|
||||
yajl_bs_free(handle->stateStack);
|
||||
yajl_buf_free(handle->decodeBuf);
|
||||
if (handle->lexer) {
|
||||
yajl_lex_free(handle->lexer);
|
||||
handle->lexer = NULL;
|
||||
}
|
||||
YA_FREE(&(handle->alloc), handle);
|
||||
}
|
||||
|
||||
yajl_status
|
||||
yajl_parse(yajl_handle hand, const unsigned char * jsonText,
|
||||
size_t jsonTextLen)
|
||||
{
|
||||
yajl_status status;
|
||||
|
||||
/* lazy allocation of the lexer */
|
||||
if (hand->lexer == NULL) {
|
||||
hand->lexer = yajl_lex_alloc(&(hand->alloc),
|
||||
hand->flags & yajl_allow_comments,
|
||||
!(hand->flags & yajl_dont_validate_strings));
|
||||
}
|
||||
|
||||
status = yajl_do_parse(hand, jsonText, jsonTextLen);
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
yajl_status
|
||||
yajl_complete_parse(yajl_handle hand)
|
||||
{
|
||||
/* The lexer is lazy allocated in the first call to parse. if parse is
|
||||
* never called, then no data was provided to parse at all. This is a
|
||||
* "premature EOF" error unless yajl_allow_partial_values is specified.
|
||||
* allocating the lexer now is the simplest possible way to handle this
|
||||
* case while preserving all the other semantics of the parser
|
||||
* (multiple values, partial values, etc). */
|
||||
if (hand->lexer == NULL) {
|
||||
hand->lexer = yajl_lex_alloc(&(hand->alloc),
|
||||
hand->flags & yajl_allow_comments,
|
||||
!(hand->flags & yajl_dont_validate_strings));
|
||||
}
|
||||
|
||||
return yajl_do_finish(hand);
|
||||
}
|
||||
|
||||
unsigned char *
|
||||
yajl_get_error(yajl_handle hand, int verbose,
|
||||
const unsigned char * jsonText, size_t jsonTextLen)
|
||||
{
|
||||
return yajl_render_error_string(hand, jsonText, jsonTextLen, verbose);
|
||||
}
|
||||
|
||||
size_t
|
||||
yajl_get_bytes_consumed(yajl_handle hand)
|
||||
{
|
||||
if (!hand) return 0;
|
||||
else return hand->bytesConsumed;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
yajl_free_error(yajl_handle hand, unsigned char * str)
|
||||
{
|
||||
/* use memory allocation functions if set */
|
||||
YA_FREE(&(hand->alloc), str);
|
||||
}
|
||||
|
||||
/* XXX: add utility routines to parse from file */
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file yajl_alloc.h
|
||||
* default memory allocation routines for yajl which use malloc/realloc and
|
||||
* free
|
||||
*/
|
||||
|
||||
#include "yajl_alloc.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
static void * yajl_internal_malloc(void *ctx, size_t sz)
|
||||
{
|
||||
(void)ctx;
|
||||
return malloc(sz);
|
||||
}
|
||||
|
||||
static void * yajl_internal_realloc(void *ctx, void * previous,
|
||||
size_t sz)
|
||||
{
|
||||
(void)ctx;
|
||||
return realloc(previous, sz);
|
||||
}
|
||||
|
||||
static void yajl_internal_free(void *ctx, void * ptr)
|
||||
{
|
||||
(void)ctx;
|
||||
free(ptr);
|
||||
}
|
||||
|
||||
void yajl_set_default_alloc_funcs(yajl_alloc_funcs * yaf)
|
||||
{
|
||||
yaf->malloc = yajl_internal_malloc;
|
||||
yaf->free = yajl_internal_free;
|
||||
yaf->realloc = yajl_internal_realloc;
|
||||
yaf->ctx = NULL;
|
||||
}
|
||||
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file yajl_alloc.h
|
||||
* default memory allocation routines for yajl which use malloc/realloc and
|
||||
* free
|
||||
*/
|
||||
|
||||
#ifndef __YAJL_ALLOC_H__
|
||||
#define __YAJL_ALLOC_H__
|
||||
|
||||
#include "api/yajl_common.h"
|
||||
|
||||
#define YA_MALLOC(afs, sz) (afs)->malloc((afs)->ctx, (sz))
|
||||
#define YA_FREE(afs, ptr) (afs)->free((afs)->ctx, (ptr))
|
||||
#define YA_REALLOC(afs, ptr, sz) (afs)->realloc((afs)->ctx, (ptr), (sz))
|
||||
|
||||
void yajl_set_default_alloc_funcs(yajl_alloc_funcs * yaf);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,103 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "yajl_buf.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#define YAJL_BUF_INIT_SIZE 2048
|
||||
|
||||
struct yajl_buf_t {
|
||||
size_t len;
|
||||
size_t used;
|
||||
unsigned char * data;
|
||||
yajl_alloc_funcs * alloc;
|
||||
};
|
||||
|
||||
static
|
||||
void yajl_buf_ensure_available(yajl_buf buf, size_t want)
|
||||
{
|
||||
size_t need;
|
||||
|
||||
assert(buf != NULL);
|
||||
|
||||
/* first call */
|
||||
if (buf->data == NULL) {
|
||||
buf->len = YAJL_BUF_INIT_SIZE;
|
||||
buf->data = (unsigned char *) YA_MALLOC(buf->alloc, buf->len);
|
||||
buf->data[0] = 0;
|
||||
}
|
||||
|
||||
need = buf->len;
|
||||
|
||||
while (want >= (need - buf->used)) need <<= 1;
|
||||
|
||||
if (need != buf->len) {
|
||||
buf->data = (unsigned char *) YA_REALLOC(buf->alloc, buf->data, need);
|
||||
buf->len = need;
|
||||
}
|
||||
}
|
||||
|
||||
yajl_buf yajl_buf_alloc(yajl_alloc_funcs * alloc)
|
||||
{
|
||||
yajl_buf b = YA_MALLOC(alloc, sizeof(struct yajl_buf_t));
|
||||
memset((void *) b, 0, sizeof(struct yajl_buf_t));
|
||||
b->alloc = alloc;
|
||||
return b;
|
||||
}
|
||||
|
||||
void yajl_buf_free(yajl_buf buf)
|
||||
{
|
||||
assert(buf != NULL);
|
||||
if (buf->data) YA_FREE(buf->alloc, buf->data);
|
||||
YA_FREE(buf->alloc, buf);
|
||||
}
|
||||
|
||||
void yajl_buf_append(yajl_buf buf, const void * data, size_t len)
|
||||
{
|
||||
yajl_buf_ensure_available(buf, len);
|
||||
if (len > 0) {
|
||||
assert(data != NULL);
|
||||
memcpy(buf->data + buf->used, data, len);
|
||||
buf->used += len;
|
||||
buf->data[buf->used] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void yajl_buf_clear(yajl_buf buf)
|
||||
{
|
||||
buf->used = 0;
|
||||
if (buf->data) buf->data[buf->used] = 0;
|
||||
}
|
||||
|
||||
const unsigned char * yajl_buf_data(yajl_buf buf)
|
||||
{
|
||||
return buf->data;
|
||||
}
|
||||
|
||||
size_t yajl_buf_len(yajl_buf buf)
|
||||
{
|
||||
return buf->used;
|
||||
}
|
||||
|
||||
void
|
||||
yajl_buf_truncate(yajl_buf buf, size_t len)
|
||||
{
|
||||
assert(len <= buf->used);
|
||||
buf->used = len;
|
||||
}
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef __YAJL_BUF_H__
|
||||
#define __YAJL_BUF_H__
|
||||
|
||||
#include "api/yajl_common.h"
|
||||
#include "yajl_alloc.h"
|
||||
|
||||
/*
|
||||
* Implementation/performance notes. If this were moved to a header
|
||||
* only implementation using #define's where possible we might be
|
||||
* able to sqeeze a little performance out of the guy by killing function
|
||||
* call overhead. YMMV.
|
||||
*/
|
||||
|
||||
/**
|
||||
* yajl_buf is a buffer with exponential growth. the buffer ensures that
|
||||
* you are always null padded.
|
||||
*/
|
||||
typedef struct yajl_buf_t * yajl_buf;
|
||||
|
||||
/* allocate a new buffer */
|
||||
yajl_buf yajl_buf_alloc(yajl_alloc_funcs * alloc);
|
||||
|
||||
/* free the buffer */
|
||||
void yajl_buf_free(yajl_buf buf);
|
||||
|
||||
/* append a number of bytes to the buffer */
|
||||
void yajl_buf_append(yajl_buf buf, const void * data, size_t len);
|
||||
|
||||
/* empty the buffer */
|
||||
void yajl_buf_clear(yajl_buf buf);
|
||||
|
||||
/* get a pointer to the beginning of the buffer */
|
||||
const unsigned char * yajl_buf_data(yajl_buf buf);
|
||||
|
||||
/* get the length of the buffer */
|
||||
size_t yajl_buf_len(yajl_buf buf);
|
||||
|
||||
/* truncate the buffer */
|
||||
void yajl_buf_truncate(yajl_buf buf, size_t len);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,69 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* A header only implementation of a simple stack of bytes, used in YAJL
|
||||
* to maintain parse state.
|
||||
*/
|
||||
|
||||
#ifndef __YAJL_BYTESTACK_H__
|
||||
#define __YAJL_BYTESTACK_H__
|
||||
|
||||
#include "api/yajl_common.h"
|
||||
|
||||
#define YAJL_BS_INC 128
|
||||
|
||||
typedef struct yajl_bytestack_t
|
||||
{
|
||||
unsigned char * stack;
|
||||
size_t size;
|
||||
size_t used;
|
||||
yajl_alloc_funcs * yaf;
|
||||
} yajl_bytestack;
|
||||
|
||||
/* initialize a bytestack */
|
||||
#define yajl_bs_init(obs, _yaf) { \
|
||||
(obs).stack = NULL; \
|
||||
(obs).size = 0; \
|
||||
(obs).used = 0; \
|
||||
(obs).yaf = (_yaf); \
|
||||
} \
|
||||
|
||||
|
||||
/* initialize a bytestack */
|
||||
#define yajl_bs_free(obs) \
|
||||
if ((obs).stack) (obs).yaf->free((obs).yaf->ctx, (obs).stack);
|
||||
|
||||
#define yajl_bs_current(obs) \
|
||||
(assert((obs).used > 0), (obs).stack[(obs).used - 1])
|
||||
|
||||
#define yajl_bs_push(obs, byte) { \
|
||||
if (((obs).size - (obs).used) == 0) { \
|
||||
(obs).size += YAJL_BS_INC; \
|
||||
(obs).stack = (obs).yaf->realloc((obs).yaf->ctx,\
|
||||
(void *) (obs).stack, (obs).size);\
|
||||
} \
|
||||
(obs).stack[((obs).used)++] = (byte); \
|
||||
}
|
||||
|
||||
/* removes the top item of the stack, returns nothing */
|
||||
#define yajl_bs_pop(obs) { ((obs).used)--; }
|
||||
|
||||
#define yajl_bs_set(obs, byte) \
|
||||
(obs).stack[((obs).used) - 1] = (byte);
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -1,220 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "yajl_encode.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
static void CharToHex(unsigned char c, char * hexBuf)
|
||||
{
|
||||
const char * hexchar = "0123456789ABCDEF";
|
||||
hexBuf[0] = hexchar[c >> 4];
|
||||
hexBuf[1] = hexchar[c & 0x0F];
|
||||
}
|
||||
|
||||
void
|
||||
yajl_string_encode(const yajl_print_t print,
|
||||
void * ctx,
|
||||
const unsigned char * str,
|
||||
size_t len,
|
||||
int escape_solidus)
|
||||
{
|
||||
size_t beg = 0;
|
||||
size_t end = 0;
|
||||
char hexBuf[7];
|
||||
hexBuf[0] = '\\'; hexBuf[1] = 'u'; hexBuf[2] = '0'; hexBuf[3] = '0';
|
||||
hexBuf[6] = 0;
|
||||
|
||||
while (end < len) {
|
||||
const char * escaped = NULL;
|
||||
switch (str[end]) {
|
||||
case '\r': escaped = "\\r"; break;
|
||||
case '\n': escaped = "\\n"; break;
|
||||
case '\\': escaped = "\\\\"; break;
|
||||
/* it is not required to escape a solidus in JSON:
|
||||
* read sec. 2.5: http://www.ietf.org/rfc/rfc4627.txt
|
||||
* specifically, this production from the grammar:
|
||||
* unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
|
||||
*/
|
||||
case '/': if (escape_solidus) escaped = "\\/"; break;
|
||||
case '"': escaped = "\\\""; break;
|
||||
case '\f': escaped = "\\f"; break;
|
||||
case '\b': escaped = "\\b"; break;
|
||||
case '\t': escaped = "\\t"; break;
|
||||
default:
|
||||
if ((unsigned char) str[end] < 32) {
|
||||
CharToHex(str[end], hexBuf + 4);
|
||||
escaped = hexBuf;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (escaped != NULL) {
|
||||
print(ctx, (const char *) (str + beg), end - beg);
|
||||
print(ctx, escaped, (unsigned int)strlen(escaped));
|
||||
beg = ++end;
|
||||
} else {
|
||||
++end;
|
||||
}
|
||||
}
|
||||
print(ctx, (const char *) (str + beg), end - beg);
|
||||
}
|
||||
|
||||
static void hexToDigit(unsigned int * val, const unsigned char * hex)
|
||||
{
|
||||
unsigned int i;
|
||||
for (i=0;i<4;i++) {
|
||||
unsigned char c = hex[i];
|
||||
if (c >= 'A') c = (c & ~0x20) - 7;
|
||||
c -= '0';
|
||||
assert(!(c & 0xF0));
|
||||
*val = (*val << 4) | c;
|
||||
}
|
||||
}
|
||||
|
||||
static void Utf32toUtf8(unsigned int codepoint, char * utf8Buf)
|
||||
{
|
||||
if (codepoint < 0x80) {
|
||||
utf8Buf[0] = (char) codepoint;
|
||||
utf8Buf[1] = 0;
|
||||
} else if (codepoint < 0x0800) {
|
||||
utf8Buf[0] = (char) ((codepoint >> 6) | 0xC0);
|
||||
utf8Buf[1] = (char) ((codepoint & 0x3F) | 0x80);
|
||||
utf8Buf[2] = 0;
|
||||
} else if (codepoint < 0x10000) {
|
||||
utf8Buf[0] = (char) ((codepoint >> 12) | 0xE0);
|
||||
utf8Buf[1] = (char) (((codepoint >> 6) & 0x3F) | 0x80);
|
||||
utf8Buf[2] = (char) ((codepoint & 0x3F) | 0x80);
|
||||
utf8Buf[3] = 0;
|
||||
} else if (codepoint < 0x200000) {
|
||||
utf8Buf[0] =(char)((codepoint >> 18) | 0xF0);
|
||||
utf8Buf[1] =(char)(((codepoint >> 12) & 0x3F) | 0x80);
|
||||
utf8Buf[2] =(char)(((codepoint >> 6) & 0x3F) | 0x80);
|
||||
utf8Buf[3] =(char)((codepoint & 0x3F) | 0x80);
|
||||
utf8Buf[4] = 0;
|
||||
} else {
|
||||
utf8Buf[0] = '?';
|
||||
utf8Buf[1] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void yajl_string_decode(yajl_buf buf, const unsigned char * str,
|
||||
size_t len)
|
||||
{
|
||||
size_t beg = 0;
|
||||
size_t end = 0;
|
||||
|
||||
while (end < len) {
|
||||
if (str[end] == '\\') {
|
||||
char utf8Buf[5];
|
||||
const char * unescaped = "?";
|
||||
yajl_buf_append(buf, str + beg, end - beg);
|
||||
switch (str[++end]) {
|
||||
case 'r': unescaped = "\r"; break;
|
||||
case 'n': unescaped = "\n"; break;
|
||||
case '\\': unescaped = "\\"; break;
|
||||
case '/': unescaped = "/"; break;
|
||||
case '"': unescaped = "\""; break;
|
||||
case 'f': unescaped = "\f"; break;
|
||||
case 'b': unescaped = "\b"; break;
|
||||
case 't': unescaped = "\t"; break;
|
||||
case 'u': {
|
||||
unsigned int codepoint = 0;
|
||||
hexToDigit(&codepoint, str + ++end);
|
||||
end+=3;
|
||||
/* check if this is a surrogate */
|
||||
if ((codepoint & 0xFC00) == 0xD800) {
|
||||
end++;
|
||||
if (str[end] == '\\' && str[end + 1] == 'u') {
|
||||
unsigned int surrogate = 0;
|
||||
hexToDigit(&surrogate, str + end + 2);
|
||||
codepoint =
|
||||
(((codepoint & 0x3F) << 10) |
|
||||
((((codepoint >> 6) & 0xF) + 1) << 16) |
|
||||
(surrogate & 0x3FF));
|
||||
end += 5;
|
||||
} else {
|
||||
unescaped = "?";
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Utf32toUtf8(codepoint, utf8Buf);
|
||||
unescaped = utf8Buf;
|
||||
|
||||
if (codepoint == 0) {
|
||||
yajl_buf_append(buf, unescaped, 1);
|
||||
beg = ++end;
|
||||
continue;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
default:
|
||||
assert("this should never happen" == NULL);
|
||||
}
|
||||
yajl_buf_append(buf, unescaped, (unsigned int)strlen(unescaped));
|
||||
beg = ++end;
|
||||
} else {
|
||||
end++;
|
||||
}
|
||||
}
|
||||
yajl_buf_append(buf, str + beg, end - beg);
|
||||
}
|
||||
|
||||
#define ADV_PTR s++; if (!(len--)) return 0;
|
||||
|
||||
int yajl_string_validate_utf8(const unsigned char * s, size_t len)
|
||||
{
|
||||
if (!len) return 1;
|
||||
if (!s) return 0;
|
||||
|
||||
while (len--) {
|
||||
/* single byte */
|
||||
if (*s <= 0x7f) {
|
||||
/* noop */
|
||||
}
|
||||
/* two byte */
|
||||
else if ((*s >> 5) == 0x6) {
|
||||
ADV_PTR;
|
||||
if (!((*s >> 6) == 0x2)) return 0;
|
||||
}
|
||||
/* three byte */
|
||||
else if ((*s >> 4) == 0x0e) {
|
||||
ADV_PTR;
|
||||
if (!((*s >> 6) == 0x2)) return 0;
|
||||
ADV_PTR;
|
||||
if (!((*s >> 6) == 0x2)) return 0;
|
||||
}
|
||||
/* four byte */
|
||||
else if ((*s >> 3) == 0x1e) {
|
||||
ADV_PTR;
|
||||
if (!((*s >> 6) == 0x2)) return 0;
|
||||
ADV_PTR;
|
||||
if (!((*s >> 6) == 0x2)) return 0;
|
||||
ADV_PTR;
|
||||
if (!((*s >> 6) == 0x2)) return 0;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
|
||||
s++;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef __YAJL_ENCODE_H__
|
||||
#define __YAJL_ENCODE_H__
|
||||
|
||||
#include "yajl_buf.h"
|
||||
#include "api/yajl_gen.h"
|
||||
|
||||
void yajl_string_encode(const yajl_print_t printer,
|
||||
void * ctx,
|
||||
const unsigned char * str,
|
||||
size_t length,
|
||||
int escape_solidus);
|
||||
|
||||
void yajl_string_decode(yajl_buf buf, const unsigned char * str,
|
||||
size_t length);
|
||||
|
||||
int yajl_string_validate_utf8(const unsigned char * s, size_t len);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,362 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "api/yajl_gen.h"
|
||||
#include "yajl_buf.h"
|
||||
#include "yajl_encode.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
typedef enum {
|
||||
yajl_gen_start,
|
||||
yajl_gen_map_start,
|
||||
yajl_gen_map_key,
|
||||
yajl_gen_map_val,
|
||||
yajl_gen_array_start,
|
||||
yajl_gen_in_array,
|
||||
yajl_gen_complete,
|
||||
yajl_gen_error
|
||||
} yajl_gen_state;
|
||||
|
||||
struct yajl_gen_t
|
||||
{
|
||||
unsigned int flags;
|
||||
unsigned int depth;
|
||||
const char * indentString;
|
||||
yajl_gen_state state[YAJL_MAX_DEPTH];
|
||||
yajl_print_t print;
|
||||
void * ctx; /* yajl_buf */
|
||||
/* memory allocation routines */
|
||||
yajl_alloc_funcs alloc;
|
||||
};
|
||||
|
||||
int
|
||||
yajl_gen_config(yajl_gen g, yajl_gen_option opt, ...)
|
||||
{
|
||||
int rv = 1;
|
||||
va_list ap;
|
||||
va_start(ap, opt);
|
||||
|
||||
switch(opt) {
|
||||
case yajl_gen_beautify:
|
||||
case yajl_gen_validate_utf8:
|
||||
case yajl_gen_escape_solidus:
|
||||
if (va_arg(ap, int)) g->flags |= opt;
|
||||
else g->flags &= ~opt;
|
||||
break;
|
||||
case yajl_gen_indent_string: {
|
||||
const char *indent = va_arg(ap, const char *);
|
||||
g->indentString = indent;
|
||||
for (; *indent; indent++) {
|
||||
if (*indent != '\n'
|
||||
&& *indent != '\v'
|
||||
&& *indent != '\f'
|
||||
&& *indent != '\t'
|
||||
&& *indent != '\r'
|
||||
&& *indent != ' ')
|
||||
{
|
||||
g->indentString = NULL;
|
||||
rv = 0;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case yajl_gen_print_callback:
|
||||
yajl_buf_free(g->ctx);
|
||||
g->print = va_arg(ap, const yajl_print_t);
|
||||
g->ctx = va_arg(ap, void *);
|
||||
break;
|
||||
default:
|
||||
rv = 0;
|
||||
}
|
||||
|
||||
va_end(ap);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
||||
|
||||
yajl_gen
|
||||
yajl_gen_alloc(const yajl_alloc_funcs * afs)
|
||||
{
|
||||
yajl_gen g = NULL;
|
||||
yajl_alloc_funcs afsBuffer;
|
||||
|
||||
/* first order of business is to set up memory allocation routines */
|
||||
if (afs != NULL) {
|
||||
if (afs->malloc == NULL || afs->realloc == NULL || afs->free == NULL)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
} else {
|
||||
yajl_set_default_alloc_funcs(&afsBuffer);
|
||||
afs = &afsBuffer;
|
||||
}
|
||||
|
||||
g = (yajl_gen) YA_MALLOC(afs, sizeof(struct yajl_gen_t));
|
||||
if (!g) return NULL;
|
||||
|
||||
memset((void *) g, 0, sizeof(struct yajl_gen_t));
|
||||
/* copy in pointers to allocation routines */
|
||||
memcpy((void *) &(g->alloc), (void *) afs, sizeof(yajl_alloc_funcs));
|
||||
|
||||
g->print = (yajl_print_t)&yajl_buf_append;
|
||||
g->ctx = yajl_buf_alloc(&(g->alloc));
|
||||
g->indentString = " ";
|
||||
|
||||
return g;
|
||||
}
|
||||
|
||||
void
|
||||
yajl_gen_reset(yajl_gen g, const char * sep)
|
||||
{
|
||||
g->depth = 0;
|
||||
memset((void *) &(g->state), 0, sizeof(g->state));
|
||||
if (sep != NULL) g->print(g->ctx, sep, strlen(sep));
|
||||
}
|
||||
|
||||
void
|
||||
yajl_gen_free(yajl_gen g)
|
||||
{
|
||||
if (g->print == (yajl_print_t)&yajl_buf_append) yajl_buf_free((yajl_buf)g->ctx);
|
||||
YA_FREE(&(g->alloc), g);
|
||||
}
|
||||
|
||||
#define INSERT_SEP \
|
||||
if (g->state[g->depth] == yajl_gen_map_key || \
|
||||
g->state[g->depth] == yajl_gen_in_array) { \
|
||||
g->print(g->ctx, ",", 1); \
|
||||
if ((g->flags & yajl_gen_beautify)) g->print(g->ctx, "\n", 1); \
|
||||
} else if (g->state[g->depth] == yajl_gen_map_val) { \
|
||||
g->print(g->ctx, ":", 1); \
|
||||
if ((g->flags & yajl_gen_beautify)) g->print(g->ctx, " ", 1); \
|
||||
}
|
||||
|
||||
#define INSERT_WHITESPACE \
|
||||
if ((g->flags & yajl_gen_beautify)) { \
|
||||
if (g->state[g->depth] != yajl_gen_map_val) { \
|
||||
unsigned int _i; \
|
||||
for (_i=0;_i<g->depth;_i++) \
|
||||
g->print(g->ctx, \
|
||||
g->indentString, \
|
||||
(unsigned int)strlen(g->indentString)); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define ENSURE_NOT_KEY \
|
||||
if (g->state[g->depth] == yajl_gen_map_key || \
|
||||
g->state[g->depth] == yajl_gen_map_start) { \
|
||||
return yajl_gen_keys_must_be_strings; \
|
||||
} \
|
||||
|
||||
/* check that we're not complete, or in error state. in a valid state
|
||||
* to be generating */
|
||||
#define ENSURE_VALID_STATE \
|
||||
if (g->state[g->depth] == yajl_gen_error) { \
|
||||
return yajl_gen_in_error_state;\
|
||||
} else if (g->state[g->depth] == yajl_gen_complete) { \
|
||||
return yajl_gen_generation_complete; \
|
||||
}
|
||||
|
||||
#define INCREMENT_DEPTH \
|
||||
if (++(g->depth) >= YAJL_MAX_DEPTH) return yajl_max_depth_exceeded;
|
||||
|
||||
#define DECREMENT_DEPTH \
|
||||
if (--(g->depth) >= YAJL_MAX_DEPTH) return yajl_gen_generation_complete;
|
||||
|
||||
#define APPENDED_ATOM \
|
||||
switch (g->state[g->depth]) { \
|
||||
case yajl_gen_start: \
|
||||
g->state[g->depth] = yajl_gen_complete; \
|
||||
break; \
|
||||
case yajl_gen_map_start: \
|
||||
case yajl_gen_map_key: \
|
||||
g->state[g->depth] = yajl_gen_map_val; \
|
||||
break; \
|
||||
case yajl_gen_array_start: \
|
||||
g->state[g->depth] = yajl_gen_in_array; \
|
||||
break; \
|
||||
case yajl_gen_map_val: \
|
||||
g->state[g->depth] = yajl_gen_map_key; \
|
||||
break; \
|
||||
default: \
|
||||
break; \
|
||||
} \
|
||||
|
||||
#define FINAL_NEWLINE \
|
||||
if ((g->flags & yajl_gen_beautify) && g->state[g->depth] == yajl_gen_complete) \
|
||||
g->print(g->ctx, "\n", 1);
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_integer(yajl_gen g, long long int number)
|
||||
{
|
||||
char i[32];
|
||||
ENSURE_VALID_STATE; ENSURE_NOT_KEY; INSERT_SEP; INSERT_WHITESPACE;
|
||||
sprintf(i, "%lld", number);
|
||||
g->print(g->ctx, i, (unsigned int)strlen(i));
|
||||
APPENDED_ATOM;
|
||||
FINAL_NEWLINE;
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
#if defined(_WIN32) || defined(WIN32)
|
||||
#include <float.h>
|
||||
#define isnan _isnan
|
||||
#define isinf !_finite
|
||||
#endif
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_double(yajl_gen g, double number)
|
||||
{
|
||||
char i[32];
|
||||
ENSURE_VALID_STATE; ENSURE_NOT_KEY;
|
||||
if (isnan(number) || isinf(number)) return yajl_gen_invalid_number;
|
||||
INSERT_SEP; INSERT_WHITESPACE;
|
||||
sprintf(i, "%.20g", number);
|
||||
if (strspn(i, "0123456789-") == strlen(i)) {
|
||||
strcat(i, ".0");
|
||||
}
|
||||
g->print(g->ctx, i, (unsigned int)strlen(i));
|
||||
APPENDED_ATOM;
|
||||
FINAL_NEWLINE;
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_number(yajl_gen g, const char * s, size_t l)
|
||||
{
|
||||
ENSURE_VALID_STATE; ENSURE_NOT_KEY; INSERT_SEP; INSERT_WHITESPACE;
|
||||
g->print(g->ctx, s, l);
|
||||
APPENDED_ATOM;
|
||||
FINAL_NEWLINE;
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_string(yajl_gen g, const unsigned char * str,
|
||||
size_t len)
|
||||
{
|
||||
// if validation is enabled, check that the string is valid utf8
|
||||
// XXX: This checking could be done a little faster, in the same pass as
|
||||
// the string encoding
|
||||
if (g->flags & yajl_gen_validate_utf8) {
|
||||
if (!yajl_string_validate_utf8(str, len)) {
|
||||
return yajl_gen_invalid_string;
|
||||
}
|
||||
}
|
||||
ENSURE_VALID_STATE; INSERT_SEP; INSERT_WHITESPACE;
|
||||
g->print(g->ctx, "\"", 1);
|
||||
yajl_string_encode(g->print, g->ctx, str, len, g->flags & yajl_gen_escape_solidus);
|
||||
g->print(g->ctx, "\"", 1);
|
||||
APPENDED_ATOM;
|
||||
FINAL_NEWLINE;
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_null(yajl_gen g)
|
||||
{
|
||||
ENSURE_VALID_STATE; ENSURE_NOT_KEY; INSERT_SEP; INSERT_WHITESPACE;
|
||||
g->print(g->ctx, "null", strlen("null"));
|
||||
APPENDED_ATOM;
|
||||
FINAL_NEWLINE;
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_bool(yajl_gen g, int boolean)
|
||||
{
|
||||
const char * val = boolean ? "true" : "false";
|
||||
|
||||
ENSURE_VALID_STATE; ENSURE_NOT_KEY; INSERT_SEP; INSERT_WHITESPACE;
|
||||
g->print(g->ctx, val, (unsigned int)strlen(val));
|
||||
APPENDED_ATOM;
|
||||
FINAL_NEWLINE;
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_map_open(yajl_gen g)
|
||||
{
|
||||
ENSURE_VALID_STATE; ENSURE_NOT_KEY; INSERT_SEP; INSERT_WHITESPACE;
|
||||
INCREMENT_DEPTH;
|
||||
|
||||
g->state[g->depth] = yajl_gen_map_start;
|
||||
g->print(g->ctx, "{", 1);
|
||||
if ((g->flags & yajl_gen_beautify)) g->print(g->ctx, "\n", 1);
|
||||
FINAL_NEWLINE;
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_map_close(yajl_gen g)
|
||||
{
|
||||
ENSURE_VALID_STATE;
|
||||
DECREMENT_DEPTH;
|
||||
|
||||
if ((g->flags & yajl_gen_beautify)) g->print(g->ctx, "\n", 1);
|
||||
APPENDED_ATOM;
|
||||
INSERT_WHITESPACE;
|
||||
g->print(g->ctx, "}", 1);
|
||||
FINAL_NEWLINE;
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_array_open(yajl_gen g)
|
||||
{
|
||||
ENSURE_VALID_STATE; ENSURE_NOT_KEY; INSERT_SEP; INSERT_WHITESPACE;
|
||||
INCREMENT_DEPTH;
|
||||
g->state[g->depth] = yajl_gen_array_start;
|
||||
g->print(g->ctx, "[", 1);
|
||||
if ((g->flags & yajl_gen_beautify)) g->print(g->ctx, "\n", 1);
|
||||
FINAL_NEWLINE;
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_array_close(yajl_gen g)
|
||||
{
|
||||
ENSURE_VALID_STATE;
|
||||
DECREMENT_DEPTH;
|
||||
if ((g->flags & yajl_gen_beautify)) g->print(g->ctx, "\n", 1);
|
||||
APPENDED_ATOM;
|
||||
INSERT_WHITESPACE;
|
||||
g->print(g->ctx, "]", 1);
|
||||
FINAL_NEWLINE;
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
yajl_gen_status
|
||||
yajl_gen_get_buf(yajl_gen g, const unsigned char ** buf,
|
||||
size_t * len)
|
||||
{
|
||||
if (g->print != (yajl_print_t)&yajl_buf_append) return yajl_gen_no_buf;
|
||||
*buf = yajl_buf_data((yajl_buf)g->ctx);
|
||||
*len = yajl_buf_len((yajl_buf)g->ctx);
|
||||
return yajl_gen_status_ok;
|
||||
}
|
||||
|
||||
void
|
||||
yajl_gen_clear(yajl_gen g)
|
||||
{
|
||||
if (g->print == (yajl_print_t)&yajl_buf_append) yajl_buf_clear((yajl_buf)g->ctx);
|
||||
}
|
||||
|
|
@ -1,763 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "yajl_lex.h"
|
||||
#include "yajl_buf.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifdef YAJL_LEXER_DEBUG
|
||||
static const char *
|
||||
tokToStr(yajl_tok tok)
|
||||
{
|
||||
switch (tok) {
|
||||
case yajl_tok_bool: return "bool";
|
||||
case yajl_tok_colon: return "colon";
|
||||
case yajl_tok_comma: return "comma";
|
||||
case yajl_tok_eof: return "eof";
|
||||
case yajl_tok_error: return "error";
|
||||
case yajl_tok_left_brace: return "brace";
|
||||
case yajl_tok_left_bracket: return "bracket";
|
||||
case yajl_tok_null: return "null";
|
||||
case yajl_tok_integer: return "integer";
|
||||
case yajl_tok_double: return "double";
|
||||
case yajl_tok_right_brace: return "brace";
|
||||
case yajl_tok_right_bracket: return "bracket";
|
||||
case yajl_tok_string: return "string";
|
||||
case yajl_tok_string_with_escapes: return "string_with_escapes";
|
||||
}
|
||||
return "unknown";
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Impact of the stream parsing feature on the lexer:
|
||||
*
|
||||
* YAJL support stream parsing. That is, the ability to parse the first
|
||||
* bits of a chunk of JSON before the last bits are available (still on
|
||||
* the network or disk). This makes the lexer more complex. The
|
||||
* responsibility of the lexer is to handle transparently the case where
|
||||
* a chunk boundary falls in the middle of a token. This is
|
||||
* accomplished is via a buffer and a character reading abstraction.
|
||||
*
|
||||
* Overview of implementation
|
||||
*
|
||||
* When we lex to end of input string before end of token is hit, we
|
||||
* copy all of the input text composing the token into our lexBuf.
|
||||
*
|
||||
* Every time we read a character, we do so through the readChar function.
|
||||
* readChar's responsibility is to handle pulling all chars from the buffer
|
||||
* before pulling chars from input text
|
||||
*/
|
||||
|
||||
struct yajl_lexer_t {
|
||||
/* the overal line and char offset into the data */
|
||||
size_t lineOff;
|
||||
size_t charOff;
|
||||
|
||||
/* error */
|
||||
yajl_lex_error error;
|
||||
|
||||
/* a input buffer to handle the case where a token is spread over
|
||||
* multiple chunks */
|
||||
yajl_buf buf;
|
||||
|
||||
/* in the case where we have data in the lexBuf, bufOff holds
|
||||
* the current offset into the lexBuf. */
|
||||
size_t bufOff;
|
||||
|
||||
/* are we using the lex buf? */
|
||||
unsigned int bufInUse;
|
||||
|
||||
/* shall we allow comments? */
|
||||
unsigned int allowComments;
|
||||
|
||||
/* shall we validate utf8 inside strings? */
|
||||
unsigned int validateUTF8;
|
||||
|
||||
yajl_alloc_funcs * alloc;
|
||||
};
|
||||
|
||||
#define readChar(lxr, txt, off) \
|
||||
(((lxr)->bufInUse && yajl_buf_len((lxr)->buf) && lxr->bufOff < yajl_buf_len((lxr)->buf)) ? \
|
||||
(*((const unsigned char *) yajl_buf_data((lxr)->buf) + ((lxr)->bufOff)++)) : \
|
||||
((txt)[(*(off))++]))
|
||||
|
||||
#define unreadChar(lxr, off) ((*(off) > 0) ? (*(off))-- : ((lxr)->bufOff--))
|
||||
|
||||
yajl_lexer
|
||||
yajl_lex_alloc(yajl_alloc_funcs * alloc,
|
||||
unsigned int allowComments, unsigned int validateUTF8)
|
||||
{
|
||||
yajl_lexer lxr = (yajl_lexer) YA_MALLOC(alloc, sizeof(struct yajl_lexer_t));
|
||||
memset((void *) lxr, 0, sizeof(struct yajl_lexer_t));
|
||||
lxr->buf = yajl_buf_alloc(alloc);
|
||||
lxr->allowComments = allowComments;
|
||||
lxr->validateUTF8 = validateUTF8;
|
||||
lxr->alloc = alloc;
|
||||
return lxr;
|
||||
}
|
||||
|
||||
void
|
||||
yajl_lex_free(yajl_lexer lxr)
|
||||
{
|
||||
yajl_buf_free(lxr->buf);
|
||||
YA_FREE(lxr->alloc, lxr);
|
||||
return;
|
||||
}
|
||||
|
||||
/* a lookup table which lets us quickly determine three things:
|
||||
* VEC - valid escaped control char
|
||||
* note. the solidus '/' may be escaped or not.
|
||||
* IJC - invalid json char
|
||||
* VHC - valid hex char
|
||||
* NFP - needs further processing (from a string scanning perspective)
|
||||
* NUC - needs utf8 checking when enabled (from a string scanning perspective)
|
||||
*/
|
||||
#define VEC 0x01
|
||||
#define IJC 0x02
|
||||
#define VHC 0x04
|
||||
#define NFP 0x08
|
||||
#define NUC 0x10
|
||||
|
||||
static const char charLookupTable[256] =
|
||||
{
|
||||
/*00*/ IJC , IJC , IJC , IJC , IJC , IJC , IJC , IJC ,
|
||||
/*08*/ IJC , IJC , IJC , IJC , IJC , IJC , IJC , IJC ,
|
||||
/*10*/ IJC , IJC , IJC , IJC , IJC , IJC , IJC , IJC ,
|
||||
/*18*/ IJC , IJC , IJC , IJC , IJC , IJC , IJC , IJC ,
|
||||
|
||||
/*20*/ 0 , 0 , NFP|VEC|IJC, 0 , 0 , 0 , 0 , 0 ,
|
||||
/*28*/ 0 , 0 , 0 , 0 , 0 , 0 , 0 , VEC ,
|
||||
/*30*/ VHC , VHC , VHC , VHC , VHC , VHC , VHC , VHC ,
|
||||
/*38*/ VHC , VHC , 0 , 0 , 0 , 0 , 0 , 0 ,
|
||||
|
||||
/*40*/ 0 , VHC , VHC , VHC , VHC , VHC , VHC , 0 ,
|
||||
/*48*/ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,
|
||||
/*50*/ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,
|
||||
/*58*/ 0 , 0 , 0 , 0 , NFP|VEC|IJC, 0 , 0 , 0 ,
|
||||
|
||||
/*60*/ 0 , VHC , VEC|VHC, VHC , VHC , VHC , VEC|VHC, 0 ,
|
||||
/*68*/ 0 , 0 , 0 , 0 , 0 , 0 , VEC , 0 ,
|
||||
/*70*/ 0 , 0 , VEC , 0 , VEC , 0 , 0 , 0 ,
|
||||
/*78*/ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,
|
||||
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC ,
|
||||
NUC , NUC , NUC , NUC , NUC , NUC , NUC , NUC
|
||||
};
|
||||
|
||||
/** process a variable length utf8 encoded codepoint.
|
||||
*
|
||||
* returns:
|
||||
* yajl_tok_string - if valid utf8 char was parsed and offset was
|
||||
* advanced
|
||||
* yajl_tok_eof - if end of input was hit before validation could
|
||||
* complete
|
||||
* yajl_tok_error - if invalid utf8 was encountered
|
||||
*
|
||||
* NOTE: on error the offset will point to the first char of the
|
||||
* invalid utf8 */
|
||||
#define UTF8_CHECK_EOF if (*offset >= jsonTextLen) { return yajl_tok_eof; }
|
||||
|
||||
static yajl_tok
|
||||
yajl_lex_utf8_char(yajl_lexer lexer, const unsigned char * jsonText,
|
||||
size_t jsonTextLen, size_t * offset,
|
||||
unsigned char curChar)
|
||||
{
|
||||
if (curChar <= 0x7f) {
|
||||
/* single byte */
|
||||
return yajl_tok_string;
|
||||
} else if ((curChar >> 5) == 0x6) {
|
||||
/* two byte */
|
||||
UTF8_CHECK_EOF;
|
||||
curChar = readChar(lexer, jsonText, offset);
|
||||
if ((curChar >> 6) == 0x2) return yajl_tok_string;
|
||||
} else if ((curChar >> 4) == 0x0e) {
|
||||
/* three byte */
|
||||
UTF8_CHECK_EOF;
|
||||
curChar = readChar(lexer, jsonText, offset);
|
||||
if ((curChar >> 6) == 0x2) {
|
||||
UTF8_CHECK_EOF;
|
||||
curChar = readChar(lexer, jsonText, offset);
|
||||
if ((curChar >> 6) == 0x2) return yajl_tok_string;
|
||||
}
|
||||
} else if ((curChar >> 3) == 0x1e) {
|
||||
/* four byte */
|
||||
UTF8_CHECK_EOF;
|
||||
curChar = readChar(lexer, jsonText, offset);
|
||||
if ((curChar >> 6) == 0x2) {
|
||||
UTF8_CHECK_EOF;
|
||||
curChar = readChar(lexer, jsonText, offset);
|
||||
if ((curChar >> 6) == 0x2) {
|
||||
UTF8_CHECK_EOF;
|
||||
curChar = readChar(lexer, jsonText, offset);
|
||||
if ((curChar >> 6) == 0x2) return yajl_tok_string;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return yajl_tok_error;
|
||||
}
|
||||
|
||||
/* lex a string. input is the lexer, pointer to beginning of
|
||||
* json text, and start of string (offset).
|
||||
* a token is returned which has the following meanings:
|
||||
* yajl_tok_string: lex of string was successful. offset points to
|
||||
* terminating '"'.
|
||||
* yajl_tok_eof: end of text was encountered before we could complete
|
||||
* the lex.
|
||||
* yajl_tok_error: embedded in the string were unallowable chars. offset
|
||||
* points to the offending char
|
||||
*/
|
||||
#define STR_CHECK_EOF \
|
||||
if (*offset >= jsonTextLen) { \
|
||||
tok = yajl_tok_eof; \
|
||||
goto finish_string_lex; \
|
||||
}
|
||||
|
||||
/** scan a string for interesting characters that might need further
|
||||
* review. return the number of chars that are uninteresting and can
|
||||
* be skipped.
|
||||
* (lth) hi world, any thoughts on how to make this routine faster? */
|
||||
static size_t
|
||||
yajl_string_scan(const unsigned char * buf, size_t len, int utf8check)
|
||||
{
|
||||
unsigned char mask = IJC|NFP|(utf8check ? NUC : 0);
|
||||
size_t skip = 0;
|
||||
while (skip < len && !(charLookupTable[*buf] & mask))
|
||||
{
|
||||
skip++;
|
||||
buf++;
|
||||
}
|
||||
return skip;
|
||||
}
|
||||
|
||||
static yajl_tok
|
||||
yajl_lex_string(yajl_lexer lexer, const unsigned char * jsonText,
|
||||
size_t jsonTextLen, size_t * offset)
|
||||
{
|
||||
yajl_tok tok = yajl_tok_error;
|
||||
int hasEscapes = 0;
|
||||
|
||||
for (;;) {
|
||||
unsigned char curChar;
|
||||
|
||||
/* now jump into a faster scanning routine to skip as much
|
||||
* of the buffers as possible */
|
||||
{
|
||||
const unsigned char * p;
|
||||
size_t len;
|
||||
|
||||
if ((lexer->bufInUse && yajl_buf_len(lexer->buf) &&
|
||||
lexer->bufOff < yajl_buf_len(lexer->buf)))
|
||||
{
|
||||
p = ((const unsigned char *) yajl_buf_data(lexer->buf) +
|
||||
(lexer->bufOff));
|
||||
len = yajl_buf_len(lexer->buf) - lexer->bufOff;
|
||||
lexer->bufOff += yajl_string_scan(p, len, lexer->validateUTF8);
|
||||
}
|
||||
else if (*offset < jsonTextLen)
|
||||
{
|
||||
p = jsonText + *offset;
|
||||
len = jsonTextLen - *offset;
|
||||
*offset += yajl_string_scan(p, len, lexer->validateUTF8);
|
||||
}
|
||||
}
|
||||
|
||||
STR_CHECK_EOF;
|
||||
|
||||
curChar = readChar(lexer, jsonText, offset);
|
||||
|
||||
/* quote terminates */
|
||||
if (curChar == '"') {
|
||||
tok = yajl_tok_string;
|
||||
break;
|
||||
}
|
||||
/* backslash escapes a set of control chars, */
|
||||
else if (curChar == '\\') {
|
||||
hasEscapes = 1;
|
||||
STR_CHECK_EOF;
|
||||
|
||||
/* special case \u */
|
||||
curChar = readChar(lexer, jsonText, offset);
|
||||
if (curChar == 'u') {
|
||||
unsigned int i = 0;
|
||||
|
||||
for (i=0;i<4;i++) {
|
||||
STR_CHECK_EOF;
|
||||
curChar = readChar(lexer, jsonText, offset);
|
||||
if (!(charLookupTable[curChar] & VHC)) {
|
||||
/* back up to offending char */
|
||||
unreadChar(lexer, offset);
|
||||
lexer->error = yajl_lex_string_invalid_hex_char;
|
||||
goto finish_string_lex;
|
||||
}
|
||||
}
|
||||
} else if (!(charLookupTable[curChar] & VEC)) {
|
||||
/* back up to offending char */
|
||||
unreadChar(lexer, offset);
|
||||
lexer->error = yajl_lex_string_invalid_escaped_char;
|
||||
goto finish_string_lex;
|
||||
}
|
||||
}
|
||||
/* when not validating UTF8 it's a simple table lookup to determine
|
||||
* if the present character is invalid */
|
||||
else if(charLookupTable[curChar] & IJC) {
|
||||
/* back up to offending char */
|
||||
unreadChar(lexer, offset);
|
||||
lexer->error = yajl_lex_string_invalid_json_char;
|
||||
goto finish_string_lex;
|
||||
}
|
||||
/* when in validate UTF8 mode we need to do some extra work */
|
||||
else if (lexer->validateUTF8) {
|
||||
yajl_tok t = yajl_lex_utf8_char(lexer, jsonText, jsonTextLen,
|
||||
offset, curChar);
|
||||
|
||||
if (t == yajl_tok_eof) {
|
||||
tok = yajl_tok_eof;
|
||||
goto finish_string_lex;
|
||||
} else if (t == yajl_tok_error) {
|
||||
lexer->error = yajl_lex_string_invalid_utf8;
|
||||
goto finish_string_lex;
|
||||
}
|
||||
}
|
||||
/* accept it, and move on */
|
||||
}
|
||||
finish_string_lex:
|
||||
/* tell our buddy, the parser, wether he needs to process this string
|
||||
* again */
|
||||
if (hasEscapes && tok == yajl_tok_string) {
|
||||
tok = yajl_tok_string_with_escapes;
|
||||
}
|
||||
|
||||
return tok;
|
||||
}
|
||||
|
||||
#define RETURN_IF_EOF if (*offset >= jsonTextLen) return yajl_tok_eof;
|
||||
|
||||
static yajl_tok
|
||||
yajl_lex_number(yajl_lexer lexer, const unsigned char * jsonText,
|
||||
size_t jsonTextLen, size_t * offset)
|
||||
{
|
||||
/** XXX: numbers are the only entities in json that we must lex
|
||||
* _beyond_ in order to know that they are complete. There
|
||||
* is an ambiguous case for integers at EOF. */
|
||||
|
||||
unsigned char c;
|
||||
|
||||
yajl_tok tok = yajl_tok_integer;
|
||||
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
|
||||
/* optional leading minus */
|
||||
if (c == '-') {
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
}
|
||||
|
||||
/* a single zero, or a series of integers */
|
||||
if (c == '0') {
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
} else if (c >= '1' && c <= '9') {
|
||||
do {
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
} while (c >= '0' && c <= '9');
|
||||
} else {
|
||||
unreadChar(lexer, offset);
|
||||
lexer->error = yajl_lex_missing_integer_after_minus;
|
||||
return yajl_tok_error;
|
||||
}
|
||||
|
||||
/* optional fraction (indicates this is floating point) */
|
||||
if (c == '.') {
|
||||
int numRd = 0;
|
||||
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
|
||||
while (c >= '0' && c <= '9') {
|
||||
numRd++;
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
}
|
||||
|
||||
if (!numRd) {
|
||||
unreadChar(lexer, offset);
|
||||
lexer->error = yajl_lex_missing_integer_after_decimal;
|
||||
return yajl_tok_error;
|
||||
}
|
||||
tok = yajl_tok_double;
|
||||
}
|
||||
|
||||
/* optional exponent (indicates this is floating point) */
|
||||
if (c == 'e' || c == 'E') {
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
|
||||
/* optional sign */
|
||||
if (c == '+' || c == '-') {
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
}
|
||||
|
||||
if (c >= '0' && c <= '9') {
|
||||
do {
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
} while (c >= '0' && c <= '9');
|
||||
} else {
|
||||
unreadChar(lexer, offset);
|
||||
lexer->error = yajl_lex_missing_integer_after_exponent;
|
||||
return yajl_tok_error;
|
||||
}
|
||||
tok = yajl_tok_double;
|
||||
}
|
||||
|
||||
/* we always go "one too far" */
|
||||
unreadChar(lexer, offset);
|
||||
|
||||
return tok;
|
||||
}
|
||||
|
||||
static yajl_tok
|
||||
yajl_lex_comment(yajl_lexer lexer, const unsigned char * jsonText,
|
||||
size_t jsonTextLen, size_t * offset)
|
||||
{
|
||||
unsigned char c;
|
||||
|
||||
yajl_tok tok = yajl_tok_comment;
|
||||
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
|
||||
/* either slash or star expected */
|
||||
if (c == '/') {
|
||||
/* now we throw away until end of line */
|
||||
do {
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
} while (c != '\n');
|
||||
} else if (c == '*') {
|
||||
/* now we throw away until end of comment */
|
||||
for (;;) {
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
if (c == '*') {
|
||||
RETURN_IF_EOF;
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
if (c == '/') {
|
||||
break;
|
||||
} else {
|
||||
unreadChar(lexer, offset);
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
lexer->error = yajl_lex_invalid_char;
|
||||
tok = yajl_tok_error;
|
||||
}
|
||||
|
||||
return tok;
|
||||
}
|
||||
|
||||
yajl_tok
|
||||
yajl_lex_lex(yajl_lexer lexer, const unsigned char * jsonText,
|
||||
size_t jsonTextLen, size_t * offset,
|
||||
const unsigned char ** outBuf, size_t * outLen)
|
||||
{
|
||||
yajl_tok tok = yajl_tok_error;
|
||||
unsigned char c;
|
||||
size_t startOffset = *offset;
|
||||
|
||||
*outBuf = NULL;
|
||||
*outLen = 0;
|
||||
|
||||
for (;;) {
|
||||
assert(*offset <= jsonTextLen);
|
||||
|
||||
if (*offset >= jsonTextLen) {
|
||||
tok = yajl_tok_eof;
|
||||
goto lexed;
|
||||
}
|
||||
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
|
||||
switch (c) {
|
||||
case '{':
|
||||
tok = yajl_tok_left_bracket;
|
||||
goto lexed;
|
||||
case '}':
|
||||
tok = yajl_tok_right_bracket;
|
||||
goto lexed;
|
||||
case '[':
|
||||
tok = yajl_tok_left_brace;
|
||||
goto lexed;
|
||||
case ']':
|
||||
tok = yajl_tok_right_brace;
|
||||
goto lexed;
|
||||
case ',':
|
||||
tok = yajl_tok_comma;
|
||||
goto lexed;
|
||||
case ':':
|
||||
tok = yajl_tok_colon;
|
||||
goto lexed;
|
||||
case '\t': case '\n': case '\v': case '\f': case '\r': case ' ':
|
||||
startOffset++;
|
||||
break;
|
||||
case 't': {
|
||||
const char * want = "rue";
|
||||
do {
|
||||
if (*offset >= jsonTextLen) {
|
||||
tok = yajl_tok_eof;
|
||||
goto lexed;
|
||||
}
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
if (c != *want) {
|
||||
unreadChar(lexer, offset);
|
||||
lexer->error = yajl_lex_invalid_string;
|
||||
tok = yajl_tok_error;
|
||||
goto lexed;
|
||||
}
|
||||
} while (*(++want));
|
||||
tok = yajl_tok_bool;
|
||||
goto lexed;
|
||||
}
|
||||
case 'f': {
|
||||
const char * want = "alse";
|
||||
do {
|
||||
if (*offset >= jsonTextLen) {
|
||||
tok = yajl_tok_eof;
|
||||
goto lexed;
|
||||
}
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
if (c != *want) {
|
||||
unreadChar(lexer, offset);
|
||||
lexer->error = yajl_lex_invalid_string;
|
||||
tok = yajl_tok_error;
|
||||
goto lexed;
|
||||
}
|
||||
} while (*(++want));
|
||||
tok = yajl_tok_bool;
|
||||
goto lexed;
|
||||
}
|
||||
case 'n': {
|
||||
const char * want = "ull";
|
||||
do {
|
||||
if (*offset >= jsonTextLen) {
|
||||
tok = yajl_tok_eof;
|
||||
goto lexed;
|
||||
}
|
||||
c = readChar(lexer, jsonText, offset);
|
||||
if (c != *want) {
|
||||
unreadChar(lexer, offset);
|
||||
lexer->error = yajl_lex_invalid_string;
|
||||
tok = yajl_tok_error;
|
||||
goto lexed;
|
||||
}
|
||||
} while (*(++want));
|
||||
tok = yajl_tok_null;
|
||||
goto lexed;
|
||||
}
|
||||
case '"': {
|
||||
tok = yajl_lex_string(lexer, (const unsigned char *) jsonText,
|
||||
jsonTextLen, offset);
|
||||
goto lexed;
|
||||
}
|
||||
case '-':
|
||||
case '0': case '1': case '2': case '3': case '4':
|
||||
case '5': case '6': case '7': case '8': case '9': {
|
||||
/* integer parsing wants to start from the beginning */
|
||||
unreadChar(lexer, offset);
|
||||
tok = yajl_lex_number(lexer, (const unsigned char *) jsonText,
|
||||
jsonTextLen, offset);
|
||||
goto lexed;
|
||||
}
|
||||
case '/':
|
||||
/* hey, look, a probable comment! If comments are disabled
|
||||
* it's an error. */
|
||||
if (!lexer->allowComments) {
|
||||
unreadChar(lexer, offset);
|
||||
lexer->error = yajl_lex_unallowed_comment;
|
||||
tok = yajl_tok_error;
|
||||
goto lexed;
|
||||
}
|
||||
/* if comments are enabled, then we should try to lex
|
||||
* the thing. possible outcomes are
|
||||
* - successful lex (tok_comment, which means continue),
|
||||
* - malformed comment opening (slash not followed by
|
||||
* '*' or '/') (tok_error)
|
||||
* - eof hit. (tok_eof) */
|
||||
tok = yajl_lex_comment(lexer, (const unsigned char *) jsonText,
|
||||
jsonTextLen, offset);
|
||||
if (tok == yajl_tok_comment) {
|
||||
/* "error" is silly, but that's the initial
|
||||
* state of tok. guilty until proven innocent. */
|
||||
tok = yajl_tok_error;
|
||||
yajl_buf_clear(lexer->buf);
|
||||
lexer->bufInUse = 0;
|
||||
startOffset = *offset;
|
||||
break;
|
||||
}
|
||||
/* hit error or eof, bail */
|
||||
goto lexed;
|
||||
default:
|
||||
lexer->error = yajl_lex_invalid_char;
|
||||
tok = yajl_tok_error;
|
||||
goto lexed;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
lexed:
|
||||
/* need to append to buffer if the buffer is in use or
|
||||
* if it's an EOF token */
|
||||
if (tok == yajl_tok_eof || lexer->bufInUse) {
|
||||
if (!lexer->bufInUse) yajl_buf_clear(lexer->buf);
|
||||
lexer->bufInUse = 1;
|
||||
yajl_buf_append(lexer->buf, jsonText + startOffset, *offset - startOffset);
|
||||
lexer->bufOff = 0;
|
||||
|
||||
if (tok != yajl_tok_eof) {
|
||||
*outBuf = yajl_buf_data(lexer->buf);
|
||||
*outLen = yajl_buf_len(lexer->buf);
|
||||
lexer->bufInUse = 0;
|
||||
}
|
||||
} else if (tok != yajl_tok_error) {
|
||||
*outBuf = jsonText + startOffset;
|
||||
*outLen = *offset - startOffset;
|
||||
}
|
||||
|
||||
/* special case for strings. skip the quotes. */
|
||||
if (tok == yajl_tok_string || tok == yajl_tok_string_with_escapes)
|
||||
{
|
||||
assert(*outLen >= 2);
|
||||
(*outBuf)++;
|
||||
*outLen -= 2;
|
||||
}
|
||||
|
||||
|
||||
#ifdef YAJL_LEXER_DEBUG
|
||||
if (tok == yajl_tok_error) {
|
||||
printf("lexical error: %s\n",
|
||||
yajl_lex_error_to_string(yajl_lex_get_error(lexer)));
|
||||
} else if (tok == yajl_tok_eof) {
|
||||
printf("EOF hit\n");
|
||||
} else {
|
||||
printf("lexed %s: '", tokToStr(tok));
|
||||
fwrite(*outBuf, 1, *outLen, stdout);
|
||||
printf("'\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
return tok;
|
||||
}
|
||||
|
||||
const char *
|
||||
yajl_lex_error_to_string(yajl_lex_error error)
|
||||
{
|
||||
switch (error) {
|
||||
case yajl_lex_e_ok:
|
||||
return "ok, no error";
|
||||
case yajl_lex_string_invalid_utf8:
|
||||
return "invalid bytes in UTF8 string.";
|
||||
case yajl_lex_string_invalid_escaped_char:
|
||||
return "inside a string, '\\' occurs before a character "
|
||||
"which it may not.";
|
||||
case yajl_lex_string_invalid_json_char:
|
||||
return "invalid character inside string.";
|
||||
case yajl_lex_string_invalid_hex_char:
|
||||
return "invalid (non-hex) character occurs after '\\u' inside "
|
||||
"string.";
|
||||
case yajl_lex_invalid_char:
|
||||
return "invalid char in json text.";
|
||||
case yajl_lex_invalid_string:
|
||||
return "invalid string in json text.";
|
||||
case yajl_lex_missing_integer_after_exponent:
|
||||
return "malformed number, a digit is required after the exponent.";
|
||||
case yajl_lex_missing_integer_after_decimal:
|
||||
return "malformed number, a digit is required after the "
|
||||
"decimal point.";
|
||||
case yajl_lex_missing_integer_after_minus:
|
||||
return "malformed number, a digit is required after the "
|
||||
"minus sign.";
|
||||
case yajl_lex_unallowed_comment:
|
||||
return "probable comment found in input text, comments are "
|
||||
"not enabled.";
|
||||
}
|
||||
return "unknown error code";
|
||||
}
|
||||
|
||||
|
||||
/** allows access to more specific information about the lexical
|
||||
* error when yajl_lex_lex returns yajl_tok_error. */
|
||||
yajl_lex_error
|
||||
yajl_lex_get_error(yajl_lexer lexer)
|
||||
{
|
||||
if (lexer == NULL) return (yajl_lex_error) -1;
|
||||
return lexer->error;
|
||||
}
|
||||
|
||||
size_t yajl_lex_current_line(yajl_lexer lexer)
|
||||
{
|
||||
return lexer->lineOff;
|
||||
}
|
||||
|
||||
size_t yajl_lex_current_char(yajl_lexer lexer)
|
||||
{
|
||||
return lexer->charOff;
|
||||
}
|
||||
|
||||
yajl_tok yajl_lex_peek(yajl_lexer lexer, const unsigned char * jsonText,
|
||||
size_t jsonTextLen, size_t offset)
|
||||
{
|
||||
const unsigned char * outBuf;
|
||||
size_t outLen;
|
||||
size_t bufLen = yajl_buf_len(lexer->buf);
|
||||
size_t bufOff = lexer->bufOff;
|
||||
unsigned int bufInUse = lexer->bufInUse;
|
||||
yajl_tok tok;
|
||||
|
||||
tok = yajl_lex_lex(lexer, jsonText, jsonTextLen, &offset,
|
||||
&outBuf, &outLen);
|
||||
|
||||
lexer->bufOff = bufOff;
|
||||
lexer->bufInUse = bufInUse;
|
||||
yajl_buf_truncate(lexer->buf, bufLen);
|
||||
|
||||
return tok;
|
||||
}
|
||||
|
|
@ -1,117 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef __YAJL_LEX_H__
|
||||
#define __YAJL_LEX_H__
|
||||
|
||||
#include "api/yajl_common.h"
|
||||
|
||||
typedef enum {
|
||||
yajl_tok_bool,
|
||||
yajl_tok_colon,
|
||||
yajl_tok_comma,
|
||||
yajl_tok_eof,
|
||||
yajl_tok_error,
|
||||
yajl_tok_left_brace,
|
||||
yajl_tok_left_bracket,
|
||||
yajl_tok_null,
|
||||
yajl_tok_right_brace,
|
||||
yajl_tok_right_bracket,
|
||||
|
||||
/* we differentiate between integers and doubles to allow the
|
||||
* parser to interpret the number without re-scanning */
|
||||
yajl_tok_integer,
|
||||
yajl_tok_double,
|
||||
|
||||
/* we differentiate between strings which require further processing,
|
||||
* and strings that do not */
|
||||
yajl_tok_string,
|
||||
yajl_tok_string_with_escapes,
|
||||
|
||||
/* comment tokens are not currently returned to the parser, ever */
|
||||
yajl_tok_comment
|
||||
} yajl_tok;
|
||||
|
||||
typedef struct yajl_lexer_t * yajl_lexer;
|
||||
|
||||
yajl_lexer yajl_lex_alloc(yajl_alloc_funcs * alloc,
|
||||
unsigned int allowComments,
|
||||
unsigned int validateUTF8);
|
||||
|
||||
void yajl_lex_free(yajl_lexer lexer);
|
||||
|
||||
/**
|
||||
* run/continue a lex. "offset" is an input/output parameter.
|
||||
* It should be initialized to zero for a
|
||||
* new chunk of target text, and upon subsetquent calls with the same
|
||||
* target text should passed with the value of the previous invocation.
|
||||
*
|
||||
* the client may be interested in the value of offset when an error is
|
||||
* returned from the lexer. This allows the client to render useful
|
||||
* error messages.
|
||||
*
|
||||
* When you pass the next chunk of data, context should be reinitialized
|
||||
* to zero.
|
||||
*
|
||||
* Finally, the output buffer is usually just a pointer into the jsonText,
|
||||
* however in cases where the entity being lexed spans multiple chunks,
|
||||
* the lexer will buffer the entity and the data returned will be
|
||||
* a pointer into that buffer.
|
||||
*
|
||||
* This behavior is abstracted from client code except for the performance
|
||||
* implications which require that the client choose a reasonable chunk
|
||||
* size to get adequate performance.
|
||||
*/
|
||||
yajl_tok yajl_lex_lex(yajl_lexer lexer, const unsigned char * jsonText,
|
||||
size_t jsonTextLen, size_t * offset,
|
||||
const unsigned char ** outBuf, size_t * outLen);
|
||||
|
||||
/** have a peek at the next token, but don't move the lexer forward */
|
||||
yajl_tok yajl_lex_peek(yajl_lexer lexer, const unsigned char * jsonText,
|
||||
size_t jsonTextLen, size_t offset);
|
||||
|
||||
|
||||
typedef enum {
|
||||
yajl_lex_e_ok = 0,
|
||||
yajl_lex_string_invalid_utf8,
|
||||
yajl_lex_string_invalid_escaped_char,
|
||||
yajl_lex_string_invalid_json_char,
|
||||
yajl_lex_string_invalid_hex_char,
|
||||
yajl_lex_invalid_char,
|
||||
yajl_lex_invalid_string,
|
||||
yajl_lex_missing_integer_after_decimal,
|
||||
yajl_lex_missing_integer_after_exponent,
|
||||
yajl_lex_missing_integer_after_minus,
|
||||
yajl_lex_unallowed_comment
|
||||
} yajl_lex_error;
|
||||
|
||||
const char * yajl_lex_error_to_string(yajl_lex_error error);
|
||||
|
||||
/** allows access to more specific information about the lexical
|
||||
* error when yajl_lex_lex returns yajl_tok_error. */
|
||||
yajl_lex_error yajl_lex_get_error(yajl_lexer lexer);
|
||||
|
||||
/** get the current offset into the most recently lexed json string. */
|
||||
size_t yajl_lex_current_offset(yajl_lexer lexer);
|
||||
|
||||
/** get the number of lines lexed by this lexer instance */
|
||||
size_t yajl_lex_current_line(yajl_lexer lexer);
|
||||
|
||||
/** get the number of chars lexed by this lexer instance since the last
|
||||
* \n or \r */
|
||||
size_t yajl_lex_current_char(yajl_lexer lexer);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,498 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "api/yajl_parse.h"
|
||||
#include "yajl_lex.h"
|
||||
#include "yajl_parser.h"
|
||||
#include "yajl_encode.h"
|
||||
#include "yajl_bytestack.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <assert.h>
|
||||
#include <math.h>
|
||||
|
||||
#define MAX_VALUE_TO_MULTIPLY ((LLONG_MAX / 10) + (LLONG_MAX % 10))
|
||||
|
||||
/* same semantics as strtol */
|
||||
long long
|
||||
yajl_parse_integer(const unsigned char *number, unsigned int length)
|
||||
{
|
||||
long long ret = 0;
|
||||
long sign = 1;
|
||||
const unsigned char *pos = number;
|
||||
if (*pos == '-') { pos++; sign = -1; }
|
||||
if (*pos == '+') { pos++; }
|
||||
|
||||
while (pos < number + length) {
|
||||
if ( ret > MAX_VALUE_TO_MULTIPLY ) {
|
||||
errno = ERANGE;
|
||||
return sign == 1 ? LLONG_MAX : LLONG_MIN;
|
||||
}
|
||||
ret *= 10;
|
||||
if (LLONG_MAX - ret < (*pos - '0')) {
|
||||
errno = ERANGE;
|
||||
return sign == 1 ? LLONG_MAX : LLONG_MIN;
|
||||
}
|
||||
if (*pos < '0' || *pos > '9') {
|
||||
errno = ERANGE;
|
||||
return sign == 1 ? LLONG_MAX : LLONG_MIN;
|
||||
}
|
||||
ret += (*pos++ - '0');
|
||||
}
|
||||
|
||||
return sign * ret;
|
||||
}
|
||||
|
||||
unsigned char *
|
||||
yajl_render_error_string(yajl_handle hand, const unsigned char * jsonText,
|
||||
size_t jsonTextLen, int verbose)
|
||||
{
|
||||
size_t offset = hand->bytesConsumed;
|
||||
unsigned char * str;
|
||||
const char * errorType = NULL;
|
||||
const char * errorText = NULL;
|
||||
char text[72];
|
||||
const char * arrow = " (right here) ------^\n";
|
||||
|
||||
if (yajl_bs_current(hand->stateStack) == yajl_state_parse_error) {
|
||||
errorType = "parse";
|
||||
errorText = hand->parseError;
|
||||
} else if (yajl_bs_current(hand->stateStack) == yajl_state_lexical_error) {
|
||||
errorType = "lexical";
|
||||
errorText = yajl_lex_error_to_string(yajl_lex_get_error(hand->lexer));
|
||||
} else {
|
||||
errorType = "unknown";
|
||||
}
|
||||
|
||||
{
|
||||
size_t memneeded = 0;
|
||||
memneeded += strlen(errorType);
|
||||
memneeded += strlen(" error");
|
||||
if (errorText != NULL) {
|
||||
memneeded += strlen(": ");
|
||||
memneeded += strlen(errorText);
|
||||
}
|
||||
str = (unsigned char *) YA_MALLOC(&(hand->alloc), memneeded + 2);
|
||||
if (!str) return NULL;
|
||||
str[0] = 0;
|
||||
strcat((char *) str, errorType);
|
||||
strcat((char *) str, " error");
|
||||
if (errorText != NULL) {
|
||||
strcat((char *) str, ": ");
|
||||
strcat((char *) str, errorText);
|
||||
}
|
||||
strcat((char *) str, "\n");
|
||||
}
|
||||
|
||||
/* now we append as many spaces as needed to make sure the error
|
||||
* falls at char 41, if verbose was specified */
|
||||
if (verbose) {
|
||||
size_t start, end, i;
|
||||
size_t spacesNeeded;
|
||||
|
||||
spacesNeeded = (offset < 30 ? 40 - offset : 10);
|
||||
start = (offset >= 30 ? offset - 30 : 0);
|
||||
end = (offset + 30 > jsonTextLen ? jsonTextLen : offset + 30);
|
||||
|
||||
for (i=0;i<spacesNeeded;i++) text[i] = ' ';
|
||||
|
||||
for (;start < end;start++, i++) {
|
||||
if (jsonText[start] != '\n' && jsonText[start] != '\r')
|
||||
{
|
||||
text[i] = jsonText[start];
|
||||
}
|
||||
else
|
||||
{
|
||||
text[i] = ' ';
|
||||
}
|
||||
}
|
||||
assert(i <= 71);
|
||||
text[i++] = '\n';
|
||||
text[i] = 0;
|
||||
{
|
||||
char * newStr = (char *)
|
||||
YA_MALLOC(&(hand->alloc), (unsigned int)(strlen((char *) str) +
|
||||
strlen((char *) text) +
|
||||
strlen(arrow) + 1));
|
||||
if (newStr) {
|
||||
newStr[0] = 0;
|
||||
strcat((char *) newStr, (char *) str);
|
||||
strcat((char *) newStr, text);
|
||||
strcat((char *) newStr, arrow);
|
||||
}
|
||||
YA_FREE(&(hand->alloc), str);
|
||||
str = (unsigned char *) newStr;
|
||||
}
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
/* check for client cancelation */
|
||||
#define _CC_CHK(x) \
|
||||
if (!(x)) { \
|
||||
yajl_bs_set(hand->stateStack, yajl_state_parse_error); \
|
||||
hand->parseError = \
|
||||
"client cancelled parse via callback return value"; \
|
||||
return yajl_status_client_canceled; \
|
||||
}
|
||||
|
||||
|
||||
yajl_status
|
||||
yajl_do_finish(yajl_handle hand)
|
||||
{
|
||||
yajl_status stat;
|
||||
stat = yajl_do_parse(hand,(const unsigned char *) " ",1);
|
||||
|
||||
if (stat != yajl_status_ok) return stat;
|
||||
|
||||
switch(yajl_bs_current(hand->stateStack))
|
||||
{
|
||||
case yajl_state_parse_error:
|
||||
case yajl_state_lexical_error:
|
||||
return yajl_status_error;
|
||||
case yajl_state_got_value:
|
||||
case yajl_state_parse_complete:
|
||||
return yajl_status_ok;
|
||||
default:
|
||||
if (!(hand->flags & yajl_allow_partial_values))
|
||||
{
|
||||
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
|
||||
hand->parseError = "premature EOF";
|
||||
return yajl_status_error;
|
||||
}
|
||||
return yajl_status_ok;
|
||||
}
|
||||
}
|
||||
|
||||
yajl_status
|
||||
yajl_do_parse(yajl_handle hand, const unsigned char * jsonText,
|
||||
size_t jsonTextLen)
|
||||
{
|
||||
yajl_tok tok;
|
||||
const unsigned char * buf;
|
||||
size_t bufLen;
|
||||
size_t * offset = &(hand->bytesConsumed);
|
||||
|
||||
*offset = 0;
|
||||
|
||||
around_again:
|
||||
switch (yajl_bs_current(hand->stateStack)) {
|
||||
case yajl_state_parse_complete:
|
||||
if (hand->flags & yajl_allow_multiple_values) {
|
||||
yajl_bs_set(hand->stateStack, yajl_state_got_value);
|
||||
goto around_again;
|
||||
}
|
||||
if (!(hand->flags & yajl_allow_trailing_garbage)) {
|
||||
if (*offset != jsonTextLen) {
|
||||
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
|
||||
offset, &buf, &bufLen);
|
||||
if (tok != yajl_tok_eof) {
|
||||
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
|
||||
hand->parseError = "trailing garbage";
|
||||
}
|
||||
goto around_again;
|
||||
}
|
||||
}
|
||||
return yajl_status_ok;
|
||||
case yajl_state_lexical_error:
|
||||
case yajl_state_parse_error:
|
||||
return yajl_status_error;
|
||||
case yajl_state_start:
|
||||
case yajl_state_got_value:
|
||||
case yajl_state_map_need_val:
|
||||
case yajl_state_array_need_val:
|
||||
case yajl_state_array_start: {
|
||||
/* for arrays and maps, we advance the state for this
|
||||
* depth, then push the state of the next depth.
|
||||
* If an error occurs during the parsing of the nesting
|
||||
* enitity, the state at this level will not matter.
|
||||
* a state that needs pushing will be anything other
|
||||
* than state_start */
|
||||
|
||||
yajl_state stateToPush = yajl_state_start;
|
||||
|
||||
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
|
||||
offset, &buf, &bufLen);
|
||||
|
||||
switch (tok) {
|
||||
case yajl_tok_eof:
|
||||
return yajl_status_ok;
|
||||
case yajl_tok_error:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_lexical_error);
|
||||
goto around_again;
|
||||
case yajl_tok_string:
|
||||
if (hand->callbacks && hand->callbacks->yajl_string) {
|
||||
_CC_CHK(hand->callbacks->yajl_string(hand->ctx,
|
||||
buf, bufLen));
|
||||
}
|
||||
break;
|
||||
case yajl_tok_string_with_escapes:
|
||||
if (hand->callbacks && hand->callbacks->yajl_string) {
|
||||
yajl_buf_clear(hand->decodeBuf);
|
||||
yajl_string_decode(hand->decodeBuf, buf, bufLen);
|
||||
_CC_CHK(hand->callbacks->yajl_string(
|
||||
hand->ctx, yajl_buf_data(hand->decodeBuf),
|
||||
yajl_buf_len(hand->decodeBuf)));
|
||||
}
|
||||
break;
|
||||
case yajl_tok_bool:
|
||||
if (hand->callbacks && hand->callbacks->yajl_boolean) {
|
||||
_CC_CHK(hand->callbacks->yajl_boolean(hand->ctx,
|
||||
*buf == 't'));
|
||||
}
|
||||
break;
|
||||
case yajl_tok_null:
|
||||
if (hand->callbacks && hand->callbacks->yajl_null) {
|
||||
_CC_CHK(hand->callbacks->yajl_null(hand->ctx));
|
||||
}
|
||||
break;
|
||||
case yajl_tok_left_bracket:
|
||||
if (hand->callbacks && hand->callbacks->yajl_start_map) {
|
||||
_CC_CHK(hand->callbacks->yajl_start_map(hand->ctx));
|
||||
}
|
||||
stateToPush = yajl_state_map_start;
|
||||
break;
|
||||
case yajl_tok_left_brace:
|
||||
if (hand->callbacks && hand->callbacks->yajl_start_array) {
|
||||
_CC_CHK(hand->callbacks->yajl_start_array(hand->ctx));
|
||||
}
|
||||
stateToPush = yajl_state_array_start;
|
||||
break;
|
||||
case yajl_tok_integer:
|
||||
if (hand->callbacks) {
|
||||
if (hand->callbacks->yajl_number) {
|
||||
_CC_CHK(hand->callbacks->yajl_number(
|
||||
hand->ctx,(const char *) buf, bufLen));
|
||||
} else if (hand->callbacks->yajl_integer) {
|
||||
long long int i = 0;
|
||||
errno = 0;
|
||||
i = yajl_parse_integer(buf, bufLen);
|
||||
if ((i == LLONG_MIN || i == LLONG_MAX) &&
|
||||
errno == ERANGE)
|
||||
{
|
||||
yajl_bs_set(hand->stateStack,
|
||||
yajl_state_parse_error);
|
||||
hand->parseError = "integer overflow" ;
|
||||
/* try to restore error offset */
|
||||
if (*offset >= bufLen) *offset -= bufLen;
|
||||
else *offset = 0;
|
||||
goto around_again;
|
||||
}
|
||||
_CC_CHK(hand->callbacks->yajl_integer(hand->ctx,
|
||||
i));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case yajl_tok_double:
|
||||
if (hand->callbacks) {
|
||||
if (hand->callbacks->yajl_number) {
|
||||
_CC_CHK(hand->callbacks->yajl_number(
|
||||
hand->ctx, (const char *) buf, bufLen));
|
||||
} else if (hand->callbacks->yajl_double) {
|
||||
double d = 0.0;
|
||||
yajl_buf_clear(hand->decodeBuf);
|
||||
yajl_buf_append(hand->decodeBuf, buf, bufLen);
|
||||
buf = yajl_buf_data(hand->decodeBuf);
|
||||
errno = 0;
|
||||
d = strtod((char *) buf, NULL);
|
||||
if ((d == HUGE_VAL || d == -HUGE_VAL) &&
|
||||
errno == ERANGE)
|
||||
{
|
||||
yajl_bs_set(hand->stateStack,
|
||||
yajl_state_parse_error);
|
||||
hand->parseError = "numeric (floating point) "
|
||||
"overflow";
|
||||
/* try to restore error offset */
|
||||
if (*offset >= bufLen) *offset -= bufLen;
|
||||
else *offset = 0;
|
||||
goto around_again;
|
||||
}
|
||||
_CC_CHK(hand->callbacks->yajl_double(hand->ctx,
|
||||
d));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case yajl_tok_right_brace: {
|
||||
if (yajl_bs_current(hand->stateStack) ==
|
||||
yajl_state_array_start)
|
||||
{
|
||||
if (hand->callbacks &&
|
||||
hand->callbacks->yajl_end_array)
|
||||
{
|
||||
_CC_CHK(hand->callbacks->yajl_end_array(hand->ctx));
|
||||
}
|
||||
yajl_bs_pop(hand->stateStack);
|
||||
goto around_again;
|
||||
}
|
||||
/* intentional fall-through */
|
||||
}
|
||||
case yajl_tok_colon:
|
||||
case yajl_tok_comma:
|
||||
case yajl_tok_right_bracket:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
|
||||
hand->parseError =
|
||||
"unallowed token at this point in JSON text";
|
||||
goto around_again;
|
||||
default:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
|
||||
hand->parseError = "invalid token, internal error";
|
||||
goto around_again;
|
||||
}
|
||||
/* got a value. transition depends on the state we're in. */
|
||||
{
|
||||
yajl_state s = yajl_bs_current(hand->stateStack);
|
||||
if (s == yajl_state_start || s == yajl_state_got_value) {
|
||||
yajl_bs_set(hand->stateStack, yajl_state_parse_complete);
|
||||
} else if (s == yajl_state_map_need_val) {
|
||||
yajl_bs_set(hand->stateStack, yajl_state_map_got_val);
|
||||
} else {
|
||||
yajl_bs_set(hand->stateStack, yajl_state_array_got_val);
|
||||
}
|
||||
}
|
||||
if (stateToPush != yajl_state_start) {
|
||||
yajl_bs_push(hand->stateStack, stateToPush);
|
||||
}
|
||||
|
||||
goto around_again;
|
||||
}
|
||||
case yajl_state_map_start:
|
||||
case yajl_state_map_need_key: {
|
||||
/* only difference between these two states is that in
|
||||
* start '}' is valid, whereas in need_key, we've parsed
|
||||
* a comma, and a string key _must_ follow */
|
||||
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
|
||||
offset, &buf, &bufLen);
|
||||
switch (tok) {
|
||||
case yajl_tok_eof:
|
||||
return yajl_status_ok;
|
||||
case yajl_tok_error:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_lexical_error);
|
||||
goto around_again;
|
||||
case yajl_tok_string_with_escapes:
|
||||
if (hand->callbacks && hand->callbacks->yajl_map_key) {
|
||||
yajl_buf_clear(hand->decodeBuf);
|
||||
yajl_string_decode(hand->decodeBuf, buf, bufLen);
|
||||
buf = yajl_buf_data(hand->decodeBuf);
|
||||
bufLen = yajl_buf_len(hand->decodeBuf);
|
||||
}
|
||||
/* intentional fall-through */
|
||||
case yajl_tok_string:
|
||||
if (hand->callbacks && hand->callbacks->yajl_map_key) {
|
||||
_CC_CHK(hand->callbacks->yajl_map_key(hand->ctx, buf,
|
||||
bufLen));
|
||||
}
|
||||
yajl_bs_set(hand->stateStack, yajl_state_map_sep);
|
||||
goto around_again;
|
||||
case yajl_tok_right_bracket:
|
||||
if (yajl_bs_current(hand->stateStack) ==
|
||||
yajl_state_map_start)
|
||||
{
|
||||
if (hand->callbacks && hand->callbacks->yajl_end_map) {
|
||||
_CC_CHK(hand->callbacks->yajl_end_map(hand->ctx));
|
||||
}
|
||||
yajl_bs_pop(hand->stateStack);
|
||||
goto around_again;
|
||||
}
|
||||
default:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
|
||||
hand->parseError =
|
||||
"invalid object key (must be a string)";
|
||||
goto around_again;
|
||||
}
|
||||
}
|
||||
case yajl_state_map_sep: {
|
||||
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
|
||||
offset, &buf, &bufLen);
|
||||
switch (tok) {
|
||||
case yajl_tok_colon:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_map_need_val);
|
||||
goto around_again;
|
||||
case yajl_tok_eof:
|
||||
return yajl_status_ok;
|
||||
case yajl_tok_error:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_lexical_error);
|
||||
goto around_again;
|
||||
default:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
|
||||
hand->parseError = "object key and value must "
|
||||
"be separated by a colon (':')";
|
||||
goto around_again;
|
||||
}
|
||||
}
|
||||
case yajl_state_map_got_val: {
|
||||
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
|
||||
offset, &buf, &bufLen);
|
||||
switch (tok) {
|
||||
case yajl_tok_right_bracket:
|
||||
if (hand->callbacks && hand->callbacks->yajl_end_map) {
|
||||
_CC_CHK(hand->callbacks->yajl_end_map(hand->ctx));
|
||||
}
|
||||
yajl_bs_pop(hand->stateStack);
|
||||
goto around_again;
|
||||
case yajl_tok_comma:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_map_need_key);
|
||||
goto around_again;
|
||||
case yajl_tok_eof:
|
||||
return yajl_status_ok;
|
||||
case yajl_tok_error:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_lexical_error);
|
||||
goto around_again;
|
||||
default:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
|
||||
hand->parseError = "after key and value, inside map, "
|
||||
"I expect ',' or '}'";
|
||||
/* try to restore error offset */
|
||||
if (*offset >= bufLen) *offset -= bufLen;
|
||||
else *offset = 0;
|
||||
goto around_again;
|
||||
}
|
||||
}
|
||||
case yajl_state_array_got_val: {
|
||||
tok = yajl_lex_lex(hand->lexer, jsonText, jsonTextLen,
|
||||
offset, &buf, &bufLen);
|
||||
switch (tok) {
|
||||
case yajl_tok_right_brace:
|
||||
if (hand->callbacks && hand->callbacks->yajl_end_array) {
|
||||
_CC_CHK(hand->callbacks->yajl_end_array(hand->ctx));
|
||||
}
|
||||
yajl_bs_pop(hand->stateStack);
|
||||
goto around_again;
|
||||
case yajl_tok_comma:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_array_need_val);
|
||||
goto around_again;
|
||||
case yajl_tok_eof:
|
||||
return yajl_status_ok;
|
||||
case yajl_tok_error:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_lexical_error);
|
||||
goto around_again;
|
||||
default:
|
||||
yajl_bs_set(hand->stateStack, yajl_state_parse_error);
|
||||
hand->parseError =
|
||||
"after array element, I expect ',' or ']'";
|
||||
goto around_again;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
abort();
|
||||
return yajl_status_error;
|
||||
}
|
||||
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef __YAJL_PARSER_H__
|
||||
#define __YAJL_PARSER_H__
|
||||
|
||||
#include "api/yajl_parse.h"
|
||||
#include "yajl_bytestack.h"
|
||||
#include "yajl_buf.h"
|
||||
#include "yajl_lex.h"
|
||||
|
||||
|
||||
typedef enum {
|
||||
yajl_state_start = 0,
|
||||
yajl_state_parse_complete,
|
||||
yajl_state_parse_error,
|
||||
yajl_state_lexical_error,
|
||||
yajl_state_map_start,
|
||||
yajl_state_map_sep,
|
||||
yajl_state_map_need_val,
|
||||
yajl_state_map_got_val,
|
||||
yajl_state_map_need_key,
|
||||
yajl_state_array_start,
|
||||
yajl_state_array_got_val,
|
||||
yajl_state_array_need_val,
|
||||
yajl_state_got_value,
|
||||
} yajl_state;
|
||||
|
||||
struct yajl_handle_t {
|
||||
const yajl_callbacks * callbacks;
|
||||
void * ctx;
|
||||
yajl_lexer lexer;
|
||||
const char * parseError;
|
||||
/* the number of bytes consumed from the last client buffer,
|
||||
* in the case of an error this will be an error offset, in the
|
||||
* case of an error this can be used as the error offset */
|
||||
size_t bytesConsumed;
|
||||
/* temporary storage for decoded strings */
|
||||
yajl_buf decodeBuf;
|
||||
/* a stack of states. access with yajl_state_XXX routines */
|
||||
yajl_bytestack stateStack;
|
||||
/* memory allocation routines */
|
||||
yajl_alloc_funcs alloc;
|
||||
/* bitfield */
|
||||
unsigned int flags;
|
||||
};
|
||||
|
||||
yajl_status
|
||||
yajl_do_parse(yajl_handle handle, const unsigned char * jsonText,
|
||||
size_t jsonTextLen);
|
||||
|
||||
yajl_status
|
||||
yajl_do_finish(yajl_handle handle);
|
||||
|
||||
unsigned char *
|
||||
yajl_render_error_string(yajl_handle hand, const unsigned char * jsonText,
|
||||
size_t jsonTextLen, int verbose);
|
||||
|
||||
/* A little built in integer parsing routine with the same semantics as strtol
|
||||
* that's unaffected by LOCALE. */
|
||||
long long
|
||||
yajl_parse_integer(const unsigned char *number, unsigned int length);
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -1,503 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2010-2011 Florian Forster <ff at octo.it>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "api/yajl_tree.h"
|
||||
#include "api/yajl_parse.h"
|
||||
|
||||
#include "yajl_parser.h"
|
||||
|
||||
#if defined(_WIN32) || defined(WIN32)
|
||||
#define snprintf sprintf_s
|
||||
#endif
|
||||
|
||||
#define STATUS_CONTINUE 1
|
||||
#define STATUS_ABORT 0
|
||||
|
||||
struct stack_elem_s;
|
||||
typedef struct stack_elem_s stack_elem_t;
|
||||
struct stack_elem_s
|
||||
{
|
||||
char * key;
|
||||
yajl_val value;
|
||||
stack_elem_t *next;
|
||||
};
|
||||
|
||||
struct context_s
|
||||
{
|
||||
stack_elem_t *stack;
|
||||
yajl_val root;
|
||||
char *errbuf;
|
||||
size_t errbuf_size;
|
||||
};
|
||||
typedef struct context_s context_t;
|
||||
|
||||
#define RETURN_ERROR(ctx,retval,...) { \
|
||||
if ((ctx)->errbuf != NULL) \
|
||||
snprintf ((ctx)->errbuf, (ctx)->errbuf_size, __VA_ARGS__); \
|
||||
return (retval); \
|
||||
}
|
||||
|
||||
static yajl_val value_alloc (yajl_type type)
|
||||
{
|
||||
yajl_val v;
|
||||
|
||||
v = malloc (sizeof (*v));
|
||||
if (v == NULL) return (NULL);
|
||||
memset (v, 0, sizeof (*v));
|
||||
v->type = type;
|
||||
|
||||
return (v);
|
||||
}
|
||||
|
||||
static void yajl_object_free (yajl_val v)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
if (!YAJL_IS_OBJECT(v)) return;
|
||||
|
||||
for (i = 0; i < v->u.object.len; i++)
|
||||
{
|
||||
free((char *) v->u.object.keys[i]);
|
||||
v->u.object.keys[i] = NULL;
|
||||
yajl_tree_free (v->u.object.values[i]);
|
||||
v->u.object.values[i] = NULL;
|
||||
}
|
||||
|
||||
free((void*) v->u.object.keys);
|
||||
free(v->u.object.values);
|
||||
free(v);
|
||||
}
|
||||
|
||||
static void yajl_array_free (yajl_val v)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
if (!YAJL_IS_ARRAY(v)) return;
|
||||
|
||||
for (i = 0; i < v->u.array.len; i++)
|
||||
{
|
||||
yajl_tree_free (v->u.array.values[i]);
|
||||
v->u.array.values[i] = NULL;
|
||||
}
|
||||
|
||||
free(v->u.array.values);
|
||||
free(v);
|
||||
}
|
||||
|
||||
/*
|
||||
* Parsing nested objects and arrays is implemented using a stack. When a new
|
||||
* object or array starts (a curly or a square opening bracket is read), an
|
||||
* appropriate value is pushed on the stack. When the end of the object is
|
||||
* reached (an appropriate closing bracket has been read), the value is popped
|
||||
* off the stack and added to the enclosing object using "context_add_value".
|
||||
*/
|
||||
static int context_push(context_t *ctx, yajl_val v)
|
||||
{
|
||||
stack_elem_t *stack;
|
||||
|
||||
stack = malloc (sizeof (*stack));
|
||||
if (stack == NULL)
|
||||
RETURN_ERROR (ctx, ENOMEM, "Out of memory");
|
||||
memset (stack, 0, sizeof (*stack));
|
||||
|
||||
assert ((ctx->stack == NULL)
|
||||
|| YAJL_IS_OBJECT (v)
|
||||
|| YAJL_IS_ARRAY (v));
|
||||
|
||||
stack->value = v;
|
||||
stack->next = ctx->stack;
|
||||
ctx->stack = stack;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
static yajl_val context_pop(context_t *ctx)
|
||||
{
|
||||
stack_elem_t *stack;
|
||||
yajl_val v;
|
||||
|
||||
if (ctx->stack == NULL)
|
||||
RETURN_ERROR (ctx, NULL, "context_pop: "
|
||||
"Bottom of stack reached prematurely");
|
||||
|
||||
stack = ctx->stack;
|
||||
ctx->stack = stack->next;
|
||||
|
||||
v = stack->value;
|
||||
|
||||
free (stack);
|
||||
|
||||
return (v);
|
||||
}
|
||||
|
||||
static int object_add_keyval(context_t *ctx,
|
||||
yajl_val obj, char *key, yajl_val value)
|
||||
{
|
||||
const char **tmpk;
|
||||
yajl_val *tmpv;
|
||||
|
||||
/* We're checking for NULL in "context_add_value" or its callers. */
|
||||
assert (ctx != NULL);
|
||||
assert (obj != NULL);
|
||||
assert (key != NULL);
|
||||
assert (value != NULL);
|
||||
|
||||
/* We're assuring that "obj" is an object in "context_add_value". */
|
||||
assert(YAJL_IS_OBJECT(obj));
|
||||
|
||||
tmpk = realloc((void *) obj->u.object.keys, sizeof(*(obj->u.object.keys)) * (obj->u.object.len + 1));
|
||||
if (tmpk == NULL)
|
||||
RETURN_ERROR(ctx, ENOMEM, "Out of memory");
|
||||
obj->u.object.keys = tmpk;
|
||||
|
||||
tmpv = realloc(obj->u.object.values, sizeof (*obj->u.object.values) * (obj->u.object.len + 1));
|
||||
if (tmpv == NULL)
|
||||
RETURN_ERROR(ctx, ENOMEM, "Out of memory");
|
||||
obj->u.object.values = tmpv;
|
||||
|
||||
obj->u.object.keys[obj->u.object.len] = key;
|
||||
obj->u.object.values[obj->u.object.len] = value;
|
||||
obj->u.object.len++;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int array_add_value (context_t *ctx,
|
||||
yajl_val array, yajl_val value)
|
||||
{
|
||||
yajl_val *tmp;
|
||||
|
||||
/* We're checking for NULL pointers in "context_add_value" or its
|
||||
* callers. */
|
||||
assert (ctx != NULL);
|
||||
assert (array != NULL);
|
||||
assert (value != NULL);
|
||||
|
||||
/* "context_add_value" will only call us with array values. */
|
||||
assert(YAJL_IS_ARRAY(array));
|
||||
|
||||
tmp = realloc(array->u.array.values,
|
||||
sizeof(*(array->u.array.values)) * (array->u.array.len + 1));
|
||||
if (tmp == NULL)
|
||||
RETURN_ERROR(ctx, ENOMEM, "Out of memory");
|
||||
array->u.array.values = tmp;
|
||||
array->u.array.values[array->u.array.len] = value;
|
||||
array->u.array.len++;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Add a value to the value on top of the stack or the "root" member in the
|
||||
* context if the end of the parsing process is reached.
|
||||
*/
|
||||
static int context_add_value (context_t *ctx, yajl_val v)
|
||||
{
|
||||
/* We're checking for NULL values in all the calling functions. */
|
||||
assert (ctx != NULL);
|
||||
assert (v != NULL);
|
||||
|
||||
/*
|
||||
* There are three valid states in which this function may be called:
|
||||
* - There is no value on the stack => This is the only value. This is the
|
||||
* last step done when parsing a document. We assign the value to the
|
||||
* "root" member and return.
|
||||
* - The value on the stack is an object. In this case store the key on the
|
||||
* stack or, if the key has already been read, add key and value to the
|
||||
* object.
|
||||
* - The value on the stack is an array. In this case simply add the value
|
||||
* and return.
|
||||
*/
|
||||
if (ctx->stack == NULL)
|
||||
{
|
||||
assert (ctx->root == NULL);
|
||||
ctx->root = v;
|
||||
return (0);
|
||||
}
|
||||
else if (YAJL_IS_OBJECT (ctx->stack->value))
|
||||
{
|
||||
if (ctx->stack->key == NULL)
|
||||
{
|
||||
if (!YAJL_IS_STRING (v))
|
||||
RETURN_ERROR (ctx, EINVAL, "context_add_value: "
|
||||
"Object key is not a string (%#04x)",
|
||||
v->type);
|
||||
|
||||
ctx->stack->key = v->u.string;
|
||||
v->u.string = NULL;
|
||||
free(v);
|
||||
return (0);
|
||||
}
|
||||
else /* if (ctx->key != NULL) */
|
||||
{
|
||||
char * key;
|
||||
|
||||
key = ctx->stack->key;
|
||||
ctx->stack->key = NULL;
|
||||
return (object_add_keyval (ctx, ctx->stack->value, key, v));
|
||||
}
|
||||
}
|
||||
else if (YAJL_IS_ARRAY (ctx->stack->value))
|
||||
{
|
||||
return (array_add_value (ctx, ctx->stack->value, v));
|
||||
}
|
||||
else
|
||||
{
|
||||
RETURN_ERROR (ctx, EINVAL, "context_add_value: Cannot add value to "
|
||||
"a value of type %#04x (not a composite type)",
|
||||
ctx->stack->value->type);
|
||||
}
|
||||
}
|
||||
|
||||
static int handle_string (void *ctx,
|
||||
const unsigned char *string, size_t string_length)
|
||||
{
|
||||
yajl_val v;
|
||||
|
||||
v = value_alloc (yajl_t_string);
|
||||
if (v == NULL)
|
||||
RETURN_ERROR ((context_t *) ctx, STATUS_ABORT, "Out of memory");
|
||||
|
||||
v->u.string = malloc (string_length + 1);
|
||||
if (v->u.string == NULL)
|
||||
{
|
||||
free (v);
|
||||
RETURN_ERROR ((context_t *) ctx, STATUS_ABORT, "Out of memory");
|
||||
}
|
||||
memcpy(v->u.string, string, string_length);
|
||||
v->u.string[string_length] = 0;
|
||||
|
||||
return ((context_add_value (ctx, v) == 0) ? STATUS_CONTINUE : STATUS_ABORT);
|
||||
}
|
||||
|
||||
static int handle_number (void *ctx, const char *string, size_t string_length)
|
||||
{
|
||||
yajl_val v;
|
||||
char *endptr;
|
||||
|
||||
v = value_alloc(yajl_t_number);
|
||||
if (v == NULL)
|
||||
RETURN_ERROR((context_t *) ctx, STATUS_ABORT, "Out of memory");
|
||||
|
||||
v->u.number.r = malloc(string_length + 1);
|
||||
if (v->u.number.r == NULL)
|
||||
{
|
||||
free(v);
|
||||
RETURN_ERROR((context_t *) ctx, STATUS_ABORT, "Out of memory");
|
||||
}
|
||||
memcpy(v->u.number.r, string, string_length);
|
||||
v->u.number.r[string_length] = 0;
|
||||
|
||||
v->u.number.flags = 0;
|
||||
|
||||
errno = 0;
|
||||
v->u.number.i = yajl_parse_integer((const unsigned char *) v->u.number.r,
|
||||
strlen(v->u.number.r));
|
||||
if (errno == 0)
|
||||
v->u.number.flags |= YAJL_NUMBER_INT_VALID;
|
||||
|
||||
endptr = NULL;
|
||||
errno = 0;
|
||||
v->u.number.d = strtod(v->u.number.r, &endptr);
|
||||
if ((errno == 0) && (endptr != NULL) && (*endptr == 0))
|
||||
v->u.number.flags |= YAJL_NUMBER_DOUBLE_VALID;
|
||||
|
||||
return ((context_add_value(ctx, v) == 0) ? STATUS_CONTINUE : STATUS_ABORT);
|
||||
}
|
||||
|
||||
static int handle_start_map (void *ctx)
|
||||
{
|
||||
yajl_val v;
|
||||
|
||||
v = value_alloc(yajl_t_object);
|
||||
if (v == NULL)
|
||||
RETURN_ERROR ((context_t *) ctx, STATUS_ABORT, "Out of memory");
|
||||
|
||||
v->u.object.keys = NULL;
|
||||
v->u.object.values = NULL;
|
||||
v->u.object.len = 0;
|
||||
|
||||
return ((context_push (ctx, v) == 0) ? STATUS_CONTINUE : STATUS_ABORT);
|
||||
}
|
||||
|
||||
static int handle_end_map (void *ctx)
|
||||
{
|
||||
yajl_val v;
|
||||
|
||||
v = context_pop (ctx);
|
||||
if (v == NULL)
|
||||
return (STATUS_ABORT);
|
||||
|
||||
return ((context_add_value (ctx, v) == 0) ? STATUS_CONTINUE : STATUS_ABORT);
|
||||
}
|
||||
|
||||
static int handle_start_array (void *ctx)
|
||||
{
|
||||
yajl_val v;
|
||||
|
||||
v = value_alloc(yajl_t_array);
|
||||
if (v == NULL)
|
||||
RETURN_ERROR ((context_t *) ctx, STATUS_ABORT, "Out of memory");
|
||||
|
||||
v->u.array.values = NULL;
|
||||
v->u.array.len = 0;
|
||||
|
||||
return ((context_push (ctx, v) == 0) ? STATUS_CONTINUE : STATUS_ABORT);
|
||||
}
|
||||
|
||||
static int handle_end_array (void *ctx)
|
||||
{
|
||||
yajl_val v;
|
||||
|
||||
v = context_pop (ctx);
|
||||
if (v == NULL)
|
||||
return (STATUS_ABORT);
|
||||
|
||||
return ((context_add_value (ctx, v) == 0) ? STATUS_CONTINUE : STATUS_ABORT);
|
||||
}
|
||||
|
||||
static int handle_boolean (void *ctx, int boolean_value)
|
||||
{
|
||||
yajl_val v;
|
||||
|
||||
v = value_alloc (boolean_value ? yajl_t_true : yajl_t_false);
|
||||
if (v == NULL)
|
||||
RETURN_ERROR ((context_t *) ctx, STATUS_ABORT, "Out of memory");
|
||||
|
||||
return ((context_add_value (ctx, v) == 0) ? STATUS_CONTINUE : STATUS_ABORT);
|
||||
}
|
||||
|
||||
static int handle_null (void *ctx)
|
||||
{
|
||||
yajl_val v;
|
||||
|
||||
v = value_alloc (yajl_t_null);
|
||||
if (v == NULL)
|
||||
RETURN_ERROR ((context_t *) ctx, STATUS_ABORT, "Out of memory");
|
||||
|
||||
return ((context_add_value (ctx, v) == 0) ? STATUS_CONTINUE : STATUS_ABORT);
|
||||
}
|
||||
|
||||
/*
|
||||
* Public functions
|
||||
*/
|
||||
yajl_val yajl_tree_parse (const char *input,
|
||||
char *error_buffer, size_t error_buffer_size)
|
||||
{
|
||||
static const yajl_callbacks callbacks =
|
||||
{
|
||||
/* null = */ handle_null,
|
||||
/* boolean = */ handle_boolean,
|
||||
/* integer = */ NULL,
|
||||
/* double = */ NULL,
|
||||
/* number = */ handle_number,
|
||||
/* string = */ handle_string,
|
||||
/* start map = */ handle_start_map,
|
||||
/* map key = */ handle_string,
|
||||
/* end map = */ handle_end_map,
|
||||
/* start array = */ handle_start_array,
|
||||
/* end array = */ handle_end_array
|
||||
};
|
||||
|
||||
yajl_handle handle;
|
||||
yajl_status status;
|
||||
char * internal_err_str;
|
||||
context_t ctx = { NULL, NULL, NULL, 0 };
|
||||
|
||||
ctx.errbuf = error_buffer;
|
||||
ctx.errbuf_size = error_buffer_size;
|
||||
|
||||
if (error_buffer != NULL)
|
||||
memset (error_buffer, 0, error_buffer_size);
|
||||
|
||||
handle = yajl_alloc (&callbacks, NULL, &ctx);
|
||||
yajl_config(handle, yajl_allow_comments, 1);
|
||||
|
||||
status = yajl_parse(handle,
|
||||
(unsigned char *) input,
|
||||
strlen (input));
|
||||
status = yajl_complete_parse (handle);
|
||||
if (status != yajl_status_ok) {
|
||||
if (error_buffer != NULL && error_buffer_size > 0) {
|
||||
internal_err_str = (char *) yajl_get_error(handle, 1,
|
||||
(const unsigned char *) input,
|
||||
strlen(input));
|
||||
snprintf(error_buffer, error_buffer_size, "%s", internal_err_str);
|
||||
YA_FREE(&(handle->alloc), internal_err_str);
|
||||
}
|
||||
yajl_free (handle);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
yajl_free (handle);
|
||||
return (ctx.root);
|
||||
}
|
||||
|
||||
yajl_val yajl_tree_get(yajl_val n, const char ** path, yajl_type type)
|
||||
{
|
||||
if (!path) return NULL;
|
||||
while (n && *path) {
|
||||
size_t i;
|
||||
size_t len;
|
||||
|
||||
if (n->type != yajl_t_object) return NULL;
|
||||
len = n->u.object.len;
|
||||
for (i = 0; i < len; i++) {
|
||||
if (!strcmp(*path, n->u.object.keys[i])) {
|
||||
n = n->u.object.values[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i == len) return NULL;
|
||||
path++;
|
||||
}
|
||||
if (n && type != yajl_t_any && type != n->type) n = NULL;
|
||||
return n;
|
||||
}
|
||||
|
||||
void yajl_tree_free (yajl_val v)
|
||||
{
|
||||
if (v == NULL) return;
|
||||
|
||||
if (YAJL_IS_STRING(v))
|
||||
{
|
||||
free(v->u.string);
|
||||
free(v);
|
||||
}
|
||||
else if (YAJL_IS_NUMBER(v))
|
||||
{
|
||||
free(v->u.number.r);
|
||||
free(v);
|
||||
}
|
||||
else if (YAJL_GET_OBJECT(v))
|
||||
{
|
||||
yajl_object_free(v);
|
||||
}
|
||||
else if (YAJL_GET_ARRAY(v))
|
||||
{
|
||||
yajl_array_free(v);
|
||||
}
|
||||
else /* if (yajl_t_true or yajl_t_false or yajl_t_null) */
|
||||
{
|
||||
free(v);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
#include <yajl/yajl_version.h>
|
||||
|
||||
int yajl_version(void)
|
||||
{
|
||||
return YAJL_VERSION;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue