676 lines
17 KiB
Ragel
676 lines
17 KiB
Ragel
/*
|
|
* This file is part of libgim.
|
|
*
|
|
* libgim is free software: you can redistribute it and/or modify it under the
|
|
* terms of the GNU General Public License as published by the Free Software
|
|
* Foundation, either version 3 of the License, or (at your option) any later
|
|
* version.
|
|
*
|
|
* libgim is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with libgim. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Copyright 2010-2015 Danny Robson <danny@nerdcruft.net>
|
|
*/
|
|
|
|
|
|
#include "json.hpp"
|
|
|
|
#include "debug.hpp"
|
|
#include "io.hpp"
|
|
#include "maths.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <cstdlib>
|
|
#include <deque>
|
|
#include <iomanip>
|
|
#include <sstream>
|
|
#include <stdexcept>
|
|
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
|
|
|
|
using namespace std;
|
|
using namespace util;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
%%{
|
|
# JSON (rfc7159)
|
|
machine json;
|
|
|
|
action trace { if (false) std::cerr << *p; }
|
|
action success { __success = true; }
|
|
action failure { }
|
|
|
|
action new_line { ++line; }
|
|
|
|
action first { parsed.push_back ({ type::UNKNOWN, p, p}); }
|
|
action last { parsed.back ().last = p; }
|
|
|
|
action tag_nul { parsed.back ().tag = type::NUL; }
|
|
action tag_boolean { parsed.back ().tag = type::BOOLEAN; }
|
|
action tag_string { parsed.back ().tag = type::STRING; }
|
|
action tag_integer { parsed.back ().tag = type::INTEGER; }
|
|
action tag_real { parsed.back ().tag = type::REAL; }
|
|
|
|
action tag_object_begin { parsed.push_back ({ type::OBJECT_BEGIN, p, p + 1 }); }
|
|
action tag_object_end { parsed.push_back ({ type::OBJECT_END, p, p + 1 }); }
|
|
action tag_array_begin { parsed.push_back ({ type::ARRAY_BEGIN, p, p + 1 }); }
|
|
action tag_array_end { parsed.push_back ({ type::ARRAY_END, p, p + 1 }); }
|
|
|
|
# Line counter
|
|
lines = (
|
|
any | '\n' @new_line
|
|
)*;
|
|
|
|
# UTF-8 (rfc3629)
|
|
utf8_tail = 0x80..0xbf;
|
|
|
|
utf8_1 = 0x00..0x7f;
|
|
utf8_2 = 0xc2..0xdf utf8_tail;
|
|
utf8_3 = 0xe0 0xa0..0xbf utf8_tail |
|
|
0xe1..0xec utf8_tail{2} |
|
|
0xed 0x80..0x9f utf8_tail |
|
|
0xee..0xef utf8_tail{2};
|
|
utf8_4 = 0xf0 0x90..0xbf utf8_tail{2} |
|
|
0xf1..0xf3 utf8_tail{3} |
|
|
0xf4 0x80..0x8f utf8_tail{2};
|
|
|
|
|
|
utf8 = utf8_1 | utf8_2 | utf8_3 | utf8_4;
|
|
|
|
# Utility
|
|
ws = 0x20 | 0x09 | 0x0A | 0x0D;
|
|
array_start = '[';
|
|
array_end = ']';
|
|
object_start = '{';
|
|
object_end = '}';
|
|
|
|
# Strings
|
|
char =
|
|
(utf8 - ["\\])
|
|
| "\\" (
|
|
[\\"/bfnrt]
|
|
| "u" xdigit{4}
|
|
)
|
|
;
|
|
|
|
string = ('"' char* '"') >first >tag_string %*last;
|
|
|
|
# numbers
|
|
int = '0' | [1-9] digit*;
|
|
|
|
frac = '.' digit+;
|
|
e = 'e'i[+\-]?;
|
|
exp = e digit+;
|
|
|
|
number = (
|
|
'-'?
|
|
int
|
|
(frac >tag_real)?
|
|
exp?
|
|
) >tag_integer;
|
|
|
|
# wrapper types
|
|
array = array_start @{ fhold; fcall array_members; } array_end;
|
|
object = object_start @{ fhold; fcall object_members; } object_end;
|
|
|
|
# simple types; case sensitive literals
|
|
bool = ("true" | "false") >tag_boolean;
|
|
nul = "null" >tag_nul;
|
|
literal = bool | nul;
|
|
|
|
value = object | array | (number | string | literal) >first %last;
|
|
|
|
# Complex
|
|
member = string ws* ':' ws* value;
|
|
|
|
array_members := ((
|
|
array_start >tag_array_begin ws* (value ws* (',' ws* value ws*)*)? array_end >tag_array_end
|
|
) & lines)
|
|
@{ fhold; fret; } $trace $!failure;
|
|
|
|
object_members := ((
|
|
object_start >tag_object_begin ws* (member ws* (',' ws* member ws*)*)? object_end >tag_object_end
|
|
) & lines)
|
|
@{ fhold; fret; } $trace $!failure;
|
|
|
|
# meta types
|
|
document := ((ws* value ws*) & lines)
|
|
%success
|
|
$!failure
|
|
$trace;
|
|
|
|
variable stack ragelstack;
|
|
prepush { ragelstack.push_back (0); }
|
|
postpop { ragelstack.pop_back (); }
|
|
|
|
write data;
|
|
}%%
|
|
|
|
|
|
std::ostream& operator<< (std::ostream &os, json::flat::type);
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
std::vector<json::flat::item>
|
|
json::flat::parse (const char *first, const char *last)
|
|
{
|
|
const char *p = first;
|
|
const char *pe = last;
|
|
const char *eof = pe;
|
|
|
|
std::deque<int> ragelstack;
|
|
std::vector<item> parsed;
|
|
|
|
size_t line = 0;
|
|
int cs, top;
|
|
bool __success = false;
|
|
|
|
%%write init;
|
|
%%write exec;
|
|
|
|
if (!__success)
|
|
throw parse_error (line, "parse error");
|
|
|
|
return parsed;
|
|
}
|
|
|
|
|
|
std::vector<json::flat::item>
|
|
json::flat::parse (const boost::filesystem::path &path)
|
|
{
|
|
util::mapped_file f (path);
|
|
return parse ((const char *)f.cbegin (), (const char*)f.cend ());
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// External support
|
|
|
|
template <>
|
|
bool
|
|
is_integer (const json::tree::number &node)
|
|
{
|
|
return is_integer (node.native ());
|
|
}
|
|
|
|
|
|
template <>
|
|
bool
|
|
is_integer (const json::tree::node &node)
|
|
{
|
|
return node.is_number () &&
|
|
is_integer (node.as_number ());
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Node
|
|
static std::vector<json::flat::item>::const_iterator
|
|
parse (std::vector<json::flat::item>::const_iterator first,
|
|
std::vector<json::flat::item>::const_iterator last,
|
|
std::unique_ptr<json::tree::node> &output);
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static std::vector<json::flat::item>::const_iterator
|
|
parse (std::vector<json::flat::item>::const_iterator first,
|
|
std::vector<json::flat::item>::const_iterator last,
|
|
json::tree::array &parent)
|
|
{
|
|
for (auto cursor = first; cursor != last; ) {
|
|
if (cursor->tag == json::flat::type::ARRAY_END)
|
|
return cursor + 1;
|
|
|
|
std::unique_ptr<json::tree::node> value;
|
|
cursor = ::parse (cursor, last, value);
|
|
parent.insert (std::move (value));
|
|
}
|
|
|
|
unreachable ();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static std::vector<json::flat::item>::const_iterator
|
|
parse (std::vector<json::flat::item>::const_iterator first,
|
|
std::vector<json::flat::item>::const_iterator last,
|
|
json::tree::object &parent)
|
|
{
|
|
for (auto cursor = first; cursor != last; ) {
|
|
if (cursor->tag == json::flat::type::OBJECT_END)
|
|
return cursor + 1;
|
|
|
|
CHECK_EQ (cursor->tag, json::flat::type::STRING);
|
|
|
|
std::string key (cursor->first + 1, cursor->last - 1);
|
|
++cursor;
|
|
|
|
std::unique_ptr<json::tree::node> val;
|
|
cursor = ::parse (cursor, last, val);
|
|
|
|
parent.insert (key, std::move (val));
|
|
}
|
|
|
|
unreachable ();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static std::vector<json::flat::item>::const_iterator
|
|
parse (std::vector<json::flat::item>::const_iterator first,
|
|
std::vector<json::flat::item>::const_iterator last,
|
|
std::unique_ptr<json::tree::node> &output)
|
|
{
|
|
CHECK (first != last);
|
|
CHECK (output.get () == nullptr);
|
|
|
|
switch (first->tag) {
|
|
case json::flat::type::NUL:
|
|
output.reset (new json::tree::null ());
|
|
return first + 1;
|
|
|
|
case json::flat::type::BOOLEAN:
|
|
CHECK (*first->first == 't' || *first->first == 'f');
|
|
output.reset (new json::tree::boolean (*first->first == 't'));
|
|
return first + 1;
|
|
|
|
case json::flat::type::STRING:
|
|
CHECK_NEQ (first->first, first->last);
|
|
output.reset (new json::tree::string (first->first + 1, first->last - 1));
|
|
return first + 1;
|
|
|
|
case json::flat::type::INTEGER:
|
|
case json::flat::type::REAL:
|
|
output.reset (new json::tree::number (std::atof (first->first)));
|
|
return first + 1;
|
|
|
|
case json::flat::type::ARRAY_BEGIN: {
|
|
auto value = std::make_unique<json::tree::array> ();
|
|
auto cursor = ::parse (first + 1, last, *value);
|
|
output = std::move (value);
|
|
return cursor;
|
|
}
|
|
|
|
case json::flat::type::OBJECT_BEGIN: {
|
|
auto value = std::make_unique<json::tree::object> ();
|
|
auto cursor = ::parse (first + 1, last, *value);
|
|
output = std::move (value);
|
|
return cursor;
|
|
}
|
|
|
|
default:
|
|
unreachable ();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
std::unique_ptr<json::tree::node>
|
|
json::tree::parse (const boost::filesystem::path &path)
|
|
{
|
|
util::mapped_file f (path);
|
|
return parse ((const char*)f.cbegin (), (const char*)f.cend ());
|
|
}
|
|
|
|
|
|
std::unique_ptr<json::tree::node>
|
|
json::tree::parse (const std::string &path)
|
|
{ return parse (path.c_str (), path.c_str () + path.size ()); }
|
|
|
|
|
|
std::unique_ptr<json::tree::node>
|
|
json::tree::parse (const char *start)
|
|
{ return parse (start, start + strlen (start)); }
|
|
|
|
|
|
void
|
|
json::tree::write (const json::tree::node &node, std::ostream &os)
|
|
{ node.write (os); }
|
|
|
|
|
|
std::unique_ptr<json::tree::node>
|
|
json::tree::parse (const char *first, const char *last)
|
|
{
|
|
std::unique_ptr<json::tree::node> output;
|
|
auto data = json::flat::parse (first, last);
|
|
auto end = ::parse (data.cbegin (), data.cend (), output);
|
|
|
|
CHECK (end == data.cend ());
|
|
(void)end;
|
|
|
|
return output;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Type conversion
|
|
|
|
const json::tree::object&
|
|
json::tree::node::as_object (void) const
|
|
{ throw type_error ("node is not an object"); }
|
|
|
|
|
|
const json::tree::array&
|
|
json::tree::node::as_array (void) const
|
|
{ throw type_error ("node is not an array"); }
|
|
|
|
|
|
const json::tree::string&
|
|
json::tree::node::as_string (void) const
|
|
{ throw type_error ("node is not a string"); }
|
|
|
|
|
|
const json::tree::number&
|
|
json::tree::node::as_number (void) const
|
|
{ throw type_error ("node is not a number"); }
|
|
|
|
|
|
const json::tree::boolean&
|
|
json::tree::node::as_boolean (void) const
|
|
{ throw type_error ("node is not a boolean"); }
|
|
|
|
|
|
const json::tree::null&
|
|
json::tree::node::as_null (void) const
|
|
{ throw type_error ("node is not a null"); }
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Global operatoers
|
|
|
|
bool
|
|
json::tree::node::operator!= (const node &rhs) const
|
|
{ return !(*this == rhs); }
|
|
|
|
|
|
bool json::tree::node::operator==(const char *rhs) const {
|
|
try {
|
|
return as_string ().native () == rhs;
|
|
} catch (const json::tree::type_error&) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
const json::tree::node&
|
|
json::tree::node::operator[] (const std::string &key) const
|
|
{ return as_object ()[key]; }
|
|
|
|
|
|
const json::tree::node&
|
|
json::tree::node::operator[] (unsigned int idx) const
|
|
{ return as_array()[idx]; }
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Object
|
|
|
|
json::tree::object::~object ()
|
|
{ ; }
|
|
|
|
|
|
bool
|
|
json::tree::object::operator ==(const json::tree::object &rhs) const {
|
|
for (auto i = rhs.m_values.begin (), j = m_values.begin ();
|
|
i != rhs.m_values.end () && j != m_values.end ();
|
|
++i, ++j)
|
|
{
|
|
if (i->first != j->first)
|
|
return false;
|
|
if ((*i->second) != (*j->second))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void
|
|
json::tree::object::insert (const std::string &_key, unique_ptr<json::tree::node> &&value)
|
|
{ m_values[_key] = move(value); }
|
|
|
|
|
|
const json::tree::node&
|
|
json::tree::object::operator[](const std::string &key) const {
|
|
auto value = m_values.find (key);
|
|
if (value == m_values.end ()) {
|
|
ostringstream ss;
|
|
ss << "no key: " << key;
|
|
throw json::tree::error (ss.str());
|
|
}
|
|
|
|
return *value->second;
|
|
}
|
|
|
|
|
|
bool
|
|
json::tree::object::has (const std::string &key) const {
|
|
return m_values.find (key) != m_values.end ();
|
|
}
|
|
|
|
|
|
void
|
|
json::tree::object::clear (void)
|
|
{ m_values.clear (); }
|
|
|
|
|
|
void
|
|
json::tree::object::erase (const std::string &key) {
|
|
auto pos = m_values.find (key);
|
|
if (pos == m_values.end ())
|
|
throw json::tree::error ("erasing invalid key");
|
|
|
|
m_values.erase (key);
|
|
}
|
|
|
|
|
|
json::tree::object::const_iterator
|
|
json::tree::object::begin (void) const
|
|
{ return m_values.begin (); }
|
|
|
|
|
|
json::tree::object::const_iterator
|
|
json::tree::object::end (void) const
|
|
{ return m_values.end (); }
|
|
|
|
|
|
std::ostream&
|
|
json::tree::object::write (std::ostream &os) const {
|
|
os << "{\n";
|
|
{
|
|
indenter raii(os);
|
|
|
|
for (auto i = m_values.begin (); i != m_values.end ();) {
|
|
os << '"' << i->first << "\" : " << *i->second;
|
|
|
|
if (++i != m_values.end ())
|
|
os << ",\n";
|
|
}
|
|
}
|
|
|
|
os << "\n}";
|
|
return os;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Array
|
|
|
|
json::tree::array::~array()
|
|
{
|
|
m_values.clear ();
|
|
}
|
|
|
|
|
|
void
|
|
json::tree::array::insert (unique_ptr<json::tree::node> &&_value)
|
|
{
|
|
m_values.push_back (move (_value));
|
|
}
|
|
|
|
|
|
bool
|
|
json::tree::array::operator ==(const json::tree::array &rhs) const {
|
|
for (auto i = rhs.m_values.begin (), j = m_values.begin ();
|
|
i != rhs.m_values.end () && j != m_values.end ();
|
|
++i, ++j)
|
|
{ if ((**i) != (**j)) return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
std::ostream&
|
|
json::tree::array::write (std::ostream &os) const {
|
|
os << "[\n";
|
|
{
|
|
indenter raii(os);
|
|
|
|
for (auto i = m_values.begin (); i != m_values.end (); ++i) {
|
|
(*i)->write (os);
|
|
|
|
if (i != m_values.end () - 1)
|
|
os << ",\n";
|
|
}
|
|
}
|
|
os << "\n]";
|
|
return os;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// String
|
|
|
|
std::ostream&
|
|
json::tree::string::write (std::ostream &os) const {
|
|
os << '"' << m_value << '"';
|
|
return os;
|
|
}
|
|
|
|
|
|
bool
|
|
json::tree::string::operator ==(const json::tree::string &rhs) const
|
|
{ return rhs.m_value == m_value; }
|
|
|
|
|
|
bool
|
|
json::tree::string::operator ==(const char *rhs) const
|
|
{ return rhs == m_value; }
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Number
|
|
|
|
std::ostream&
|
|
json::tree::number::write (std::ostream &os) const {
|
|
os << setprecision (numeric_limits<double>::digits10) << m_value;
|
|
return os;
|
|
}
|
|
|
|
|
|
bool
|
|
json::tree::number::operator ==(const json::tree::number &rhs) const
|
|
{ return almost_equal (rhs.m_value, m_value); }
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Boolean
|
|
|
|
std::ostream&
|
|
json::tree::boolean::write (std::ostream &os) const {
|
|
os << (m_value ? "true" : "false");
|
|
return os;
|
|
}
|
|
|
|
bool
|
|
json::tree::boolean::operator ==(const json::tree::boolean &rhs) const
|
|
{ return rhs.m_value == m_value; }
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Null
|
|
|
|
std::ostream&
|
|
json::tree::null::write (std::ostream &os) const {
|
|
os << "null";
|
|
return os;
|
|
}
|
|
|
|
ostream&
|
|
json::tree::operator <<(ostream &os, const json::tree::node &n)
|
|
{ return n.write (os); }
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// to_json
|
|
|
|
namespace json { namespace tree {
|
|
template <>
|
|
std::unique_ptr<node>
|
|
io<bool>::serialise (const bool &b) {
|
|
return std::unique_ptr<node> (new boolean (b));
|
|
}
|
|
|
|
template <>
|
|
std::unique_ptr<node>
|
|
io<nullptr_t>::serialise (const nullptr_t &) {
|
|
return std::unique_ptr<node> (new null ());
|
|
}
|
|
|
|
template <>
|
|
std::unique_ptr<node>
|
|
io<std::string>::serialise (const std::string &s) {
|
|
return std::unique_ptr<node> (new string (s));
|
|
}
|
|
|
|
template <>
|
|
std::unique_ptr<node>
|
|
io<int>::serialise (const int &i) {
|
|
return std::unique_ptr<node> (new number (i));
|
|
}
|
|
|
|
template <>
|
|
std::unique_ptr<node>
|
|
io<size_t>::serialise (const size_t &i) {
|
|
return std::unique_ptr<node> (new number (i));
|
|
}
|
|
|
|
template <>
|
|
std::unique_ptr<node>
|
|
io<float>::serialise (const float &f) {
|
|
return std::unique_ptr<node> (new number (f));
|
|
}
|
|
} }
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
std::ostream&
|
|
operator<< (std::ostream &os, json::flat::type t)
|
|
{
|
|
switch (t) {
|
|
case json::flat::type::STRING: os << "STRING"; break;
|
|
case json::flat::type::NUL: os << "NUL"; break;
|
|
case json::flat::type::BOOLEAN: os << "BOOLEAN"; break;
|
|
case json::flat::type::INTEGER: os << "INTEGER"; break;
|
|
case json::flat::type::REAL: os << "REAL"; break;
|
|
|
|
case json::flat::type::OBJECT_BEGIN: os << "OBJECT_BEGIN"; break;
|
|
case json::flat::type::OBJECT_END: os << "OBJECT_END"; break;
|
|
case json::flat::type::ARRAY_BEGIN: os << "ARRAY_BEGIN"; break;
|
|
case json::flat::type::ARRAY_END: os << "ARRAY_END"; break;
|
|
|
|
default:
|
|
unreachable ();
|
|
}
|
|
|
|
return os;
|
|
}
|