admin/mlib
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move internal functions to internal namespace

Browse Source
This commit is contained in:
Patrick Pelissier committed 2022-03-20 11:50:05 +01:00
1 parent 5e001fdd9d
commit f3376b6f0e
2 files changed
+244 -233
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

m-serial-bin.h
+72 -61
View File
@@ -32,12 +32,17 @@
M_BEGIN_PROTECTED_CODE
/********************************************************************************/
/************************** FILE / WRITE / BIN *******************************/
/********************************************************************************/
/* Internal service:
* Write size_t in the stream in a compact form to reduce consumption
* (and I/O bandwidth)
*/
static inline bool
m_serial_bin_write_size(FILE *f, const size_t size)
m_ser1al_bin_write_size(FILE *f, const size_t size)
{
bool b;
if (M_LIKELY(size < 253))
@@ -84,7 +89,7 @@ m_serial_bin_write_size(FILE *f, const size_t size)
* (and I/O bandwidth)
*/
static inline bool
m_serial_bin_read_size(FILE *f, size_t *size)
m_ser1al_bin_read_size(FILE *f, size_t *size)
{
int c;
c = fgetc(f);
@@ -107,7 +112,7 @@ m_serial_bin_read_size(FILE *f, size_t *size)
/* Write the boolean 'data' into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_boolean(m_serial_write_t serial, const bool data)
m_ser1al_bin_write_boolean(m_serial_write_t serial, const bool data)
{
FILE *f = (FILE *)serial->data[0].p;
size_t n = fwrite (M_ASSIGN_CAST(const void*, &data), sizeof (bool), 1, f);
@@ -117,7 +122,7 @@ m_serial_bin_write_boolean(m_serial_write_t serial, const bool data)
/* Write the integer 'data' of 'size_of_type' bytes into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_integer(m_serial_write_t serial,const long long data, const size_t size_of_type)
m_ser1al_bin_write_integer(m_serial_write_t serial,const long long data, const size_t size_of_type)
{
int8_t i8;
int16_t i16;
@@ -153,7 +158,7 @@ m_serial_bin_write_integer(m_serial_write_t serial,const long long data, const s
/* Write the float 'data' of 'size_of_type' bytes into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
m_ser1al_bin_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
{
float f1;
double f2;
@@ -179,13 +184,13 @@ m_serial_bin_write_float(m_serial_write_t serial, const long double data, const
/* Write the null-terminated string 'data'into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_string(m_serial_write_t serial, const char data[], size_t length)
m_ser1al_bin_write_string(m_serial_write_t serial, const char data[], size_t length)
{
M_ASSERT_SLOW(length == strlen(data) );
FILE *f = (FILE *)serial->data[0].p;
M_ASSERT(f != NULL && data != NULL);
// Write first the number of (non null) characters
if (m_serial_bin_write_size(f, length) != true) return m_core_serial_fail();
if (m_ser1al_bin_write_size(f, length) != true) return m_core_serial_fail();
// Write the characters (excluding the final null char)
// NOTE: fwrite supports length == 0.
size_t n = fwrite (M_ASSIGN_CAST(const void*, data), 1, length, f);
@@ -199,7 +204,7 @@ m_serial_bin_write_string(m_serial_write_t serial, const char data[], size_t len
(local is an unique serialization object of the array).
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
m_ser1al_bin_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
{
FILE *f = (FILE *)serial->data[0].p;
size_t n = fwrite (M_ASSIGN_CAST(const void*, &number_of_elements), sizeof number_of_elements, 1, f);
@@ -210,7 +215,7 @@ m_serial_bin_write_array_start(m_serial_local_t local, m_serial_write_t serial,
/* Write an array separator between elements of an array into the serial stream 'serial' if needed.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_array_next(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_bin_write_array_next(m_serial_local_t local, m_serial_write_t serial)
{
FILE *f = (FILE *)serial->data[0].p;
// Need separator if we don't know the real size
@@ -226,7 +231,7 @@ m_serial_bin_write_array_next(m_serial_local_t local, m_serial_write_t serial)
/* End the writing of an array into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_array_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_bin_write_array_end(m_serial_local_t local, m_serial_write_t serial)
{
FILE *f = (FILE *)serial->data[0].p;
// Need mark if we don't know the real size
@@ -242,7 +247,7 @@ m_serial_bin_write_array_end(m_serial_local_t local, m_serial_write_t serial)
/* Write a value separator between element of the same pair of a map into the serial stream 'serial' if needed.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_map_value(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_bin_write_map_value(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
(void) serial;
@@ -254,7 +259,7 @@ m_serial_bin_write_map_value(m_serial_local_t local, m_serial_write_t serial)
(local is an unique serialization object of the tuple).
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_bin_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
(void) serial;
@@ -264,7 +269,7 @@ m_serial_bin_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
/* Start writing the field named field_name[index] of a tuple into the serial stream 'serial'.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
m_ser1al_bin_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
{
(void) local; // argument not used
(void) serial;
@@ -277,7 +282,7 @@ m_serial_bin_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, con
/* End the write of a tuple into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_bin_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
(void) serial;
@@ -290,7 +295,7 @@ m_serial_bin_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
Otherwise, the field 'field_name[index]' will be filled.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_variant_start(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
m_ser1al_bin_write_variant_start(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
{
(void) field_name;
(void) max;
@@ -303,7 +308,7 @@ m_serial_bin_write_variant_start(m_serial_local_t local, m_serial_write_t serial
/* End Writing a variant into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_bin_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
(void) serial;
@@ -311,28 +316,28 @@ m_serial_bin_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
}
/* The exported interface. */
static const m_serial_write_interface_t m_serial_write_bin_interface = {
m_serial_bin_write_boolean,
m_serial_bin_write_integer,
m_serial_bin_write_float,
m_serial_bin_write_string,
m_serial_bin_write_array_start,
m_serial_bin_write_array_next,
m_serial_bin_write_array_end,
m_serial_bin_write_array_start,
m_serial_bin_write_map_value,
m_serial_bin_write_array_next,
m_serial_bin_write_array_end,
m_serial_bin_write_tuple_start,
m_serial_bin_write_tuple_id,
m_serial_bin_write_tuple_end,
m_serial_bin_write_variant_start,
m_serial_bin_write_variant_end
static const m_serial_write_interface_t m_ser1al_bin_write_interface = {
m_ser1al_bin_write_boolean,
m_ser1al_bin_write_integer,
m_ser1al_bin_write_float,
m_ser1al_bin_write_string,
m_ser1al_bin_write_array_start,
m_ser1al_bin_write_array_next,
m_ser1al_bin_write_array_end,
m_ser1al_bin_write_array_start,
m_ser1al_bin_write_map_value,
m_ser1al_bin_write_array_next,
m_ser1al_bin_write_array_end,
m_ser1al_bin_write_tuple_start,
m_ser1al_bin_write_tuple_id,
m_ser1al_bin_write_tuple_end,
m_ser1al_bin_write_variant_start,
m_ser1al_bin_write_variant_end
};
static inline void m_serial_bin_write_init(m_serial_write_t serial, FILE *f)
{
serial->m_interface = &m_serial_write_bin_interface;
serial->m_interface = &m_ser1al_bin_write_interface;
serial->data[0].p = M_ASSIGN_CAST(void*, f);
}
@@ -344,16 +349,22 @@ static inline void m_serial_bin_write_clear(m_serial_write_t serial)
/* Define a synonym of m_serial_read_t to the BIN serializer with its proper OPLIST */
typedef m_serial_write_t m_serial_bin_write_t;
#define M_OPL_m_serial_bin_write_t() \
(INIT_WITH(m_serial_bin_write_init), CLEAR(m_serial_bin_write_clear), \
TYPE(m_serial_bin_write_t), PROPERTIES(( LET_AS_INIT_WITH(1) )) )
/********************************************************************************/
/************************** FILE / READ / BIN *******************************/
/********************************************************************************/
/* Read from the stream 'serial' a boolean.
Set '*b' with the boolean value if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_boolean(m_serial_read_t serial, bool *b){
m_ser1al_bin_read_boolean(m_serial_read_t serial, bool *b){
FILE *f = (FILE*) serial->data[0].p;
size_t n = fread (M_ASSIGN_CAST(void*, b), sizeof (bool), 1, f);
return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
@@ -363,7 +374,7 @@ m_serial_bin_read_boolean(m_serial_read_t serial, bool *b){
Set '*i' with the integer value if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
m_ser1al_bin_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
int8_t i8;
int16_t i16;
int32_t i32;
@@ -398,7 +409,7 @@ m_serial_bin_read_integer(m_serial_read_t serial, long long *i, const size_t siz
Set '*r' with the boolean value if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
m_ser1al_bin_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
float f1;
double f2;
long double f3;
@@ -423,12 +434,12 @@ m_serial_bin_read_float(m_serial_read_t serial, long double *r, const size_t siz
Set 's' with the string if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_string(m_serial_read_t serial, struct string_s *s){
m_ser1al_bin_read_string(m_serial_read_t serial, struct string_s *s){
FILE *f = (FILE*) serial->data[0].p;
M_ASSERT(f != NULL && s != NULL);
// First read the number of non null characters
size_t length;
if (m_serial_bin_read_size(f, &length) != true) return m_core_serial_fail();
if (m_ser1al_bin_read_size(f, &length) != true) return m_core_serial_fail();
// Use of internal string interface to dimension the string
char *p = m_str1ng_fit2size(s, length + 1);
m_str1ng_set_size(s, length);
@@ -448,7 +459,7 @@ m_serial_bin_read_string(m_serial_read_t serial, struct string_s *s){
M_SERIAL_OK_DONE if it succeeds and the array ends (the array is empty),
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
m_ser1al_bin_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
{
FILE *f = (FILE*) serial->data[0].p;
size_t n = fread (M_ASSIGN_CAST(void*, num), sizeof *num, 1, f);
@@ -472,7 +483,7 @@ m_serial_bin_read_array_start(m_serial_local_t local, m_serial_read_t serial, si
M_SERIAL_OK_DONE if it succeeds and the array ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_array_next(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_bin_read_array_next(m_serial_local_t local, m_serial_read_t serial)
{
FILE *f = (FILE*) serial->data[0].p;
if (local->data[0].b) {
@@ -494,7 +505,7 @@ m_serial_bin_read_array_next(m_serial_local_t local, m_serial_read_t serial)
Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_map_value(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_bin_read_map_value(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
(void) serial;
@@ -505,7 +516,7 @@ m_serial_bin_read_map_value(m_serial_local_t local, m_serial_read_t serial)
Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_bin_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
{
(void) serial;
local->data[1].i = 0;
@@ -519,7 +530,7 @@ m_serial_bin_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
Return M_SERIAL_OK_DONE if it succeeds and the tuple ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
m_ser1al_bin_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
{
(void) serial;
(void) field_name;
@@ -536,7 +547,7 @@ m_serial_bin_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const
Return M_SERIAL_OK_DONE if it succeeds and the variant ends(variant is empty),
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
m_ser1al_bin_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
{
(void) field_name;
(void) max;
@@ -550,32 +561,32 @@ m_serial_bin_read_variant_start(m_serial_local_t local, m_serial_read_t serial,
Return M_SERIAL_OK_DONE if it succeeds and the variant ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_bin_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_bin_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
(void) serial;
return M_SERIAL_OK_DONE;
}
static const m_serial_read_interface_t m_serial_bin_read_interface = {
m_serial_bin_read_boolean,
m_serial_bin_read_integer,
m_serial_bin_read_float,
m_serial_bin_read_string,
m_serial_bin_read_array_start,
m_serial_bin_read_array_next,
m_serial_bin_read_array_start,
m_serial_bin_read_map_value,
m_serial_bin_read_array_next,
m_serial_bin_read_tuple_start,
m_serial_bin_read_tuple_id,
m_serial_bin_read_variant_start,
m_serial_bin_read_variant_end
static const m_serial_read_interface_t m_ser1al_bin_read_interface = {
m_ser1al_bin_read_boolean,
m_ser1al_bin_read_integer,
m_ser1al_bin_read_float,
m_ser1al_bin_read_string,
m_ser1al_bin_read_array_start,
m_ser1al_bin_read_array_next,
m_ser1al_bin_read_array_start,
m_ser1al_bin_read_map_value,
m_ser1al_bin_read_array_next,
m_ser1al_bin_read_tuple_start,
m_ser1al_bin_read_tuple_id,
m_ser1al_bin_read_variant_start,
m_ser1al_bin_read_variant_end
};
static inline void m_serial_bin_read_init(m_serial_read_t serial, FILE *f)
{
serial->m_interface = &m_serial_bin_read_interface;
serial->m_interface = &m_ser1al_bin_read_interface;
serial->data[0].p = M_ASSIGN_CAST(void*, f);
}
m-serial-json.h
+172 -172
View File
@@ -37,7 +37,7 @@ M_BEGIN_PROTECTED_CODE
/* Write the boolean 'data' into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_boolean(m_serial_write_t serial, const bool data)
m_ser1al_json_write_boolean(m_serial_write_t serial, const bool data)
{
FILE *f = (FILE *)serial->data[0].p;
int n = fprintf(f, "%s", data ? "true" : "false");
@@ -47,7 +47,7 @@ m_serial_json_write_boolean(m_serial_write_t serial, const bool data)
/* Write the integer 'data' of 'size_of_type' bytes into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_integer(m_serial_write_t serial,const long long data, const size_t size_of_type)
m_ser1al_json_write_integer(m_serial_write_t serial,const long long data, const size_t size_of_type)
{
(void) size_of_type; // Ignored
FILE *f = (FILE *)serial->data[0].p;
@@ -58,7 +58,7 @@ m_serial_json_write_integer(m_serial_write_t serial,const long long data, const
/* Write the float 'data' of 'size_of_type' bytes into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
m_ser1al_json_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
{
(void) size_of_type; // Ignored
FILE *f = (FILE *)serial->data[0].p;
@@ -69,7 +69,7 @@ m_serial_json_write_float(m_serial_write_t serial, const long double data, const
/* Write the null-terminated string 'data'into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_string(m_serial_write_t serial, const char data[], size_t length)
m_ser1al_json_write_string(m_serial_write_t serial, const char data[], size_t length)
{
M_ASSERT_SLOW(length == strlen(data) );
FILE *f = (FILE *)serial->data[0].p;
@@ -91,7 +91,7 @@ m_serial_json_write_string(m_serial_write_t serial, const char data[], size_t le
(local is an unique serialization object of the array).
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
m_ser1al_json_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
{
(void) local; // argument not used
(void) number_of_elements; // Ignored
@@ -103,7 +103,7 @@ m_serial_json_write_array_start(m_serial_local_t local, m_serial_write_t serial,
/* Write an array separator between elements of an array into the serial stream 'serial' if needed.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_array_next(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_json_write_array_next(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
FILE *f = (FILE *)serial->data[0].p;
@@ -114,7 +114,7 @@ m_serial_json_write_array_next(m_serial_local_t local, m_serial_write_t serial)
/* End the writing of an array into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_array_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_json_write_array_end(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
FILE *f = (FILE *)serial->data[0].p;
@@ -129,7 +129,7 @@ m_serial_json_write_array_end(m_serial_local_t local, m_serial_write_t serial)
(local is an unique serialization object of the map).
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_map_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
m_ser1al_json_write_map_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
{
(void) local; // argument not used
(void) number_of_elements; // Ignored
@@ -141,7 +141,7 @@ m_serial_json_write_map_start(m_serial_local_t local, m_serial_write_t serial, c
/* Write a value separator between element of the same pair of a map into the serial stream 'serial' if needed.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_map_value(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_json_write_map_value(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
FILE *f = (FILE *)serial->data[0].p;
@@ -152,7 +152,7 @@ m_serial_json_write_map_value(m_serial_local_t local, m_serial_write_t serial)
/* Write a map separator between elements of a map into the serial stream 'serial' if needed.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_map_next(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_json_write_map_next(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
FILE *f = (FILE *)serial->data[0].p;
@@ -163,7 +163,7 @@ m_serial_json_write_map_next(m_serial_local_t local, m_serial_write_t serial)
/* End the writing of a map into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_map_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_json_write_map_end(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
FILE *f = (FILE *)serial->data[0].p;
@@ -176,7 +176,7 @@ m_serial_json_write_map_end(m_serial_local_t local, m_serial_write_t serial)
(local is an unique serialization object of the tuple).
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_json_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
FILE *f = (FILE *)serial->data[0].p;
@@ -187,7 +187,7 @@ m_serial_json_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
/* Start writing the field named field_name[index] of a tuple into the serial stream 'serial'.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
m_ser1al_json_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
{
(void) local; // argument not used
(void) max; // Ignored
@@ -199,7 +199,7 @@ m_serial_json_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, co
/* End the write of a tuple into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_json_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
FILE *f = (FILE *)serial->data[0].p;
@@ -213,7 +213,7 @@ m_serial_json_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
Otherwise, the field 'field_name[index]' will be filled.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_variant_start(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
m_ser1al_json_write_variant_start(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
{
(void) local; // argument not used
(void) max; // argument not used
@@ -232,7 +232,7 @@ m_serial_json_write_variant_start(m_serial_local_t local, m_serial_write_t seria
/* End Writing a variant into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_json_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
FILE *f = (FILE *)serial->data[0].p;
@@ -242,29 +242,29 @@ m_serial_json_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
/* The internal exported interface of m_serial_write_json
If it is not used, it will be optimized away by the compiler. */
static const m_serial_write_interface_t m_serial_write_json_interface = {
m_serial_json_write_boolean,
m_serial_json_write_integer,
m_serial_json_write_float,
m_serial_json_write_string,
m_serial_json_write_array_start,
m_serial_json_write_array_next,
m_serial_json_write_array_end,
m_serial_json_write_map_start,
m_serial_json_write_map_value,
m_serial_json_write_map_next,
m_serial_json_write_map_end,
m_serial_json_write_tuple_start,
m_serial_json_write_tuple_id,
m_serial_json_write_tuple_end,
m_serial_json_write_variant_start,
m_serial_json_write_variant_end
static const m_serial_write_interface_t m_ser1al_json_write_interface = {
m_ser1al_json_write_boolean,
m_ser1al_json_write_integer,
m_ser1al_json_write_float,
m_ser1al_json_write_string,
m_ser1al_json_write_array_start,
m_ser1al_json_write_array_next,
m_ser1al_json_write_array_end,
m_ser1al_json_write_map_start,
m_ser1al_json_write_map_value,
m_ser1al_json_write_map_next,
m_ser1al_json_write_map_end,
m_ser1al_json_write_tuple_start,
m_ser1al_json_write_tuple_id,
m_ser1al_json_write_tuple_end,
m_ser1al_json_write_variant_start,
m_ser1al_json_write_variant_end
};
/* Initialize the JSON serial object for writing any object to JSON format in the given FILE */
static inline void m_serial_json_write_init(m_serial_write_t serial, FILE *f)
{
serial->m_interface = &m_serial_write_json_interface;
serial->m_interface = &m_ser1al_json_write_interface;
serial->data[0].p = M_ASSIGN_CAST(void*, f);
}
@@ -289,7 +289,7 @@ typedef m_serial_write_t m_serial_json_write_t;
/* Helper function to skip a space */
static inline int
m_serial_json_read_skip (FILE *f)
m_ser1al_json_read_skip (FILE *f)
{
int c;
do {
@@ -302,9 +302,9 @@ m_serial_json_read_skip (FILE *f)
Set '*b' with the boolean value if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_boolean(m_serial_read_t serial, bool *b){
m_ser1al_json_read_boolean(m_serial_read_t serial, bool *b){
FILE *f = (FILE*) serial->data[0].p;
int c = m_serial_json_read_skip(f);
int c = m_ser1al_json_read_skip(f);
if (c == 't') {
*b = true;
c = fgetc(f);
@@ -334,7 +334,7 @@ m_serial_json_read_boolean(m_serial_read_t serial, bool *b){
Set '*i' with the integer value if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
m_ser1al_json_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
(void) size_of_type; // Ignored
FILE *f = (FILE*) serial->data[0].p;
return m_core_fscanf(f, " %lld", i) == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
@@ -344,7 +344,7 @@ m_serial_json_read_integer(m_serial_read_t serial, long long *i, const size_t si
Set '*r' with the boolean value if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
m_ser1al_json_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
(void) size_of_type; // Ignored
FILE *f = (FILE*) serial->data[0].p;
return m_core_fscanf(f, " %Lf", r) == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
@@ -354,7 +354,7 @@ m_serial_json_read_float(m_serial_read_t serial, long double *r, const size_t si
Set 's' with the string if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_string(m_serial_read_t serial, struct string_s *s){
m_ser1al_json_read_string(m_serial_read_t serial, struct string_s *s){
FILE *f = (FILE*) serial->data[0].p;
int n = m_core_fscanf(f, " "); // Skip any leading spaces.
(void) n; // Unused return value.
@@ -369,7 +369,7 @@ m_serial_json_read_string(m_serial_read_t serial, struct string_s *s){
M_SERIAL_OK_DONE if it succeeds and the array ends (the array is empty),
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
m_ser1al_json_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
{
(void) local; // argument not used
FILE *f = (FILE*) serial->data[0].p;
@@ -387,7 +387,7 @@ m_serial_json_read_array_start(m_serial_local_t local, m_serial_read_t serial, s
M_SERIAL_OK_DONE if it succeeds and the array ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_array_next(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_json_read_array_next(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
FILE *f = (FILE*) serial->data[0].p;
@@ -405,7 +405,7 @@ m_serial_json_read_array_next(m_serial_local_t local, m_serial_read_t serial)
M_SERIAL_OK_DONE if it succeeds and the map ends (the map is empty),
m_core_serial_fail() otherwise */
static inline m_serial_return_code_t
m_serial_json_read_map_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
m_ser1al_json_read_map_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
{
(void) local; // argument not used
FILE *f = (FILE*) serial->data[0].p;
@@ -422,7 +422,7 @@ m_serial_json_read_map_start(m_serial_local_t local, m_serial_read_t serial, siz
Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_map_value(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_json_read_map_value(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
FILE *f = (FILE*) serial->data[0].p;
@@ -437,7 +437,7 @@ m_serial_json_read_map_value(m_serial_local_t local, m_serial_read_t serial)
M_SERIAL_OK_DONE if it succeeds and the map ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_map_next(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_json_read_map_next(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
FILE *f = (FILE*) serial->data[0].p;
@@ -451,7 +451,7 @@ m_serial_json_read_map_next(m_serial_local_t local, m_serial_read_t serial)
Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_json_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
FILE *f = (FILE*) serial->data[0].p;
@@ -468,11 +468,11 @@ m_serial_json_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
Return M_SERIAL_OK_DONE if it succeeds and the tuple ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
m_ser1al_json_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
{
(void) local; // argument not used
FILE *f = (FILE*) serial->data[0].p;
int c = m_serial_json_read_skip(f);
int c = m_ser1al_json_read_skip(f);
if (c == EOF) return m_core_serial_fail();
if (c == '}') return M_SERIAL_OK_DONE;
if (c == ',') {
@@ -507,7 +507,7 @@ m_serial_json_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, cons
Return M_SERIAL_OK_DONE if it succeeds and the variant ends(variant is empty),
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
m_ser1al_json_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
{
(void) local; // argument not used
FILE *f = (FILE*) serial->data[0].p;
@@ -542,7 +542,7 @@ m_serial_json_read_variant_start(m_serial_local_t local, m_serial_read_t serial,
Return M_SERIAL_OK_DONE if it succeeds and the variant ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_json_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_json_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
FILE *f = (FILE*) serial->data[0].p;
@@ -552,26 +552,26 @@ m_serial_json_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
return final > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
}
static const m_serial_read_interface_t m_serial_json_read_interface = {
m_serial_json_read_boolean,
m_serial_json_read_integer,
m_serial_json_read_float,
m_serial_json_read_string,
m_serial_json_read_array_start,
m_serial_json_read_array_next,
m_serial_json_read_map_start,
m_serial_json_read_map_value,
m_serial_json_read_map_next,
m_serial_json_read_tuple_start,
m_serial_json_read_tuple_id,
m_serial_json_read_variant_start,
m_serial_json_read_variant_end
static const m_serial_read_interface_t m_ser1al_json_read_interface = {
m_ser1al_json_read_boolean,
m_ser1al_json_read_integer,
m_ser1al_json_read_float,
m_ser1al_json_read_string,
m_ser1al_json_read_array_start,
m_ser1al_json_read_array_next,
m_ser1al_json_read_map_start,
m_ser1al_json_read_map_value,
m_ser1al_json_read_map_next,
m_ser1al_json_read_tuple_start,
m_ser1al_json_read_tuple_id,
m_ser1al_json_read_variant_start,
m_ser1al_json_read_variant_end
};
/* Initialize the JSON serial object for reading any object from JSON format in the given FILE */
static inline void m_serial_json_read_init(m_serial_read_t serial, FILE *f)
{
serial->m_interface = &m_serial_json_read_interface;
serial->m_interface = &m_ser1al_json_read_interface;
serial->data[0].p = M_ASSIGN_CAST(void*, f);
}
@@ -597,7 +597,7 @@ typedef m_serial_read_t m_serial_json_read_t;
/* Write the boolean 'data' into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_boolean(m_serial_write_t serial, const bool data)
m_ser1al_str_json_write_boolean(m_serial_write_t serial, const bool data)
{
struct string_s *f = (struct string_s *)serial->data[0].p;
int n = string_cat_printf(f, "%s", data ? "true" : "false");
@@ -607,7 +607,7 @@ m_serial_str_json_write_boolean(m_serial_write_t serial, const bool data)
/* Write the integer 'data' of 'size_of_type' bytes into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_integer(m_serial_write_t serial,const long long data, const size_t size_of_type)
m_ser1al_str_json_write_integer(m_serial_write_t serial,const long long data, const size_t size_of_type)
{
(void) size_of_type; // Ignored
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -618,7 +618,7 @@ m_serial_str_json_write_integer(m_serial_write_t serial,const long long data, co
/* Write the float 'data' of 'size_of_type' bytes into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
m_ser1al_str_json_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
{
(void) size_of_type; // Ignored
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -629,7 +629,7 @@ m_serial_str_json_write_float(m_serial_write_t serial, const long double data, c
/* Write the null-terminated string 'data'into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_string(m_serial_write_t serial, const char data[], size_t length)
m_ser1al_str_json_write_string(m_serial_write_t serial, const char data[], size_t length)
{
M_ASSERT_SLOW(length == strlen(data) );
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -651,7 +651,7 @@ m_serial_str_json_write_string(m_serial_write_t serial, const char data[], size_
(local is an unique serialization object of the array).
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
m_ser1al_str_json_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
{
(void) local; // argument not used
(void) number_of_elements; // Ignored
@@ -663,7 +663,7 @@ m_serial_str_json_write_array_start(m_serial_local_t local, m_serial_write_t ser
/* Write an array separator between elements of an array into the serial stream 'serial' if needed.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_array_next(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_str_json_write_array_next(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -674,7 +674,7 @@ m_serial_str_json_write_array_next(m_serial_local_t local, m_serial_write_t seri
/* End the writing of an array into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_array_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_str_json_write_array_end(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -689,7 +689,7 @@ m_serial_str_json_write_array_end(m_serial_local_t local, m_serial_write_t seria
(local is an unique serialization object of the map).
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_map_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
m_ser1al_str_json_write_map_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
{
(void) local; // argument not used
(void) number_of_elements; // Ignored
@@ -701,7 +701,7 @@ m_serial_str_json_write_map_start(m_serial_local_t local, m_serial_write_t seria
/* Write a value separator between element of the same pair of a map into the serial stream 'serial' if needed.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_map_value(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_str_json_write_map_value(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -712,7 +712,7 @@ m_serial_str_json_write_map_value(m_serial_local_t local, m_serial_write_t seria
/* Write a map separator between elements of a map into the serial stream 'serial' if needed.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_map_next(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_str_json_write_map_next(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -723,7 +723,7 @@ m_serial_str_json_write_map_next(m_serial_local_t local, m_serial_write_t serial
/* End the writing of a map into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_map_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_str_json_write_map_end(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -736,7 +736,7 @@ m_serial_str_json_write_map_end(m_serial_local_t local, m_serial_write_t serial)
(local is an unique serialization object of the tuple).
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_str_json_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -747,7 +747,7 @@ m_serial_str_json_write_tuple_start(m_serial_local_t local, m_serial_write_t ser
/* Start writing the field named field_name[index] of a tuple into the serial stream 'serial'.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
m_ser1al_str_json_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
{
(void) local; // argument not used
(void) max; // Ignored
@@ -759,7 +759,7 @@ m_serial_str_json_write_tuple_id(m_serial_local_t local, m_serial_write_t serial
/* End the write of a tuple into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_str_json_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -773,7 +773,7 @@ m_serial_str_json_write_tuple_end(m_serial_local_t local, m_serial_write_t seria
Otherwise, the field 'field_name[index]' will be filled.
Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_variant_start(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
m_ser1al_str_json_write_variant_start(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
{
(void) local; // argument not used
(void) max; // argument not used
@@ -792,7 +792,7 @@ m_serial_str_json_write_variant_start(m_serial_local_t local, m_serial_write_t s
/* End Writing a variant into the serial stream 'serial'.
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
m_ser1al_str_json_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
{
(void) local; // argument not used
struct string_s *f = (struct string_s *)serial->data[0].p;
@@ -801,29 +801,29 @@ m_serial_str_json_write_variant_end(m_serial_local_t local, m_serial_write_t ser
}
/* The internal exported interface of m_serial_write_json. */
static const m_serial_write_interface_t m_serial_str_json_write_interface = {
m_serial_str_json_write_boolean,
m_serial_str_json_write_integer,
m_serial_str_json_write_float,
m_serial_str_json_write_string,
m_serial_str_json_write_array_start,
m_serial_str_json_write_array_next,
m_serial_str_json_write_array_end,
m_serial_str_json_write_map_start,
m_serial_str_json_write_map_value,
m_serial_str_json_write_map_next,
m_serial_str_json_write_map_end,
m_serial_str_json_write_tuple_start,
m_serial_str_json_write_tuple_id,
m_serial_str_json_write_tuple_end,
m_serial_str_json_write_variant_start,
m_serial_str_json_write_variant_end
static const m_serial_write_interface_t m_ser1al_str_json_write_interface = {
m_ser1al_str_json_write_boolean,
m_ser1al_str_json_write_integer,
m_ser1al_str_json_write_float,
m_ser1al_str_json_write_string,
m_ser1al_str_json_write_array_start,
m_ser1al_str_json_write_array_next,
m_ser1al_str_json_write_array_end,
m_ser1al_str_json_write_map_start,
m_ser1al_str_json_write_map_value,
m_ser1al_str_json_write_map_next,
m_ser1al_str_json_write_map_end,
m_ser1al_str_json_write_tuple_start,
m_ser1al_str_json_write_tuple_id,
m_ser1al_str_json_write_tuple_end,
m_ser1al_str_json_write_variant_start,
m_ser1al_str_json_write_variant_end
};
/* Initialize the JSON serial object for writing any object to JSON format in the given FILE */
static inline void m_serial_str_json_write_init(m_serial_write_t serial, string_t s)
{
serial->m_interface = &m_serial_str_json_write_interface;
serial->m_interface = &m_ser1al_str_json_write_interface;
serial->data[0].p = M_ASSIGN_CAST(struct string_s *, s);
}
@@ -847,7 +847,7 @@ typedef m_serial_write_t m_serial_str_json_write_t;
/* Helper function to read a character and advance the stream */
static inline char
m_serial_str_json_getc(const char **p)
m_ser1al_str_json_getc(const char **p)
{
char c = **p;
// Once it reaches the end of string character (== 0), stop advancing the stream.
@@ -857,7 +857,7 @@ m_serial_str_json_getc(const char **p)
/* Helper function to skip space(s) */
static inline void
m_serial_str_json_skip (const char **p)
m_ser1al_str_json_skip (const char **p)
{
while (isspace (**p)) {
(*p)++;
@@ -866,7 +866,7 @@ m_serial_str_json_skip (const char **p)
/* Helper function to read a string with characters not present in reject */
static inline void
m_serial_str_json_gets(size_t alloc, char field[], const char reject[], const char **s)
m_ser1al_str_json_gets(size_t alloc, char field[], const char reject[], const char **s)
{
M_ASSERT (alloc > 0);
size_t length = strcspn(*s, reject);
@@ -881,28 +881,28 @@ m_serial_str_json_gets(size_t alloc, char field[], const char reject[], const ch
Set '*b' with the boolean value if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_boolean(m_serial_read_t serial, bool *b){
m_ser1al_str_json_read_boolean(m_serial_read_t serial, bool *b){
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
char c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
char c = m_ser1al_str_json_getc(f);
if (c == 't') {
*b = true;
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY(c != 'r')) return m_core_serial_fail();
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY(c != 'u')) return m_core_serial_fail();
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY(c != 'e')) return m_core_serial_fail();
return M_SERIAL_OK_DONE;
} else if (M_LIKELY(c == 'f')) {
*b = false;
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY(c != 'a')) return m_core_serial_fail();
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY(c != 'l')) return m_core_serial_fail();
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY(c != 's')) return m_core_serial_fail();
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY(c != 'e')) return m_core_serial_fail();
return M_SERIAL_OK_DONE;
} else {
@@ -914,7 +914,7 @@ m_serial_str_json_read_boolean(m_serial_read_t serial, bool *b){
Set '*i' with the integer value if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
m_ser1al_str_json_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
(void) size_of_type; // Ignored
const char **f = &serial->data[0].cstr;
char *e;
@@ -928,7 +928,7 @@ m_serial_str_json_read_integer(m_serial_read_t serial, long long *i, const size_
Set '*r' with the boolean value if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
m_ser1al_str_json_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
(void) size_of_type; // Ignored
const char **f = &serial->data[0].cstr;
char *e;
@@ -942,9 +942,9 @@ m_serial_str_json_read_float(m_serial_read_t serial, long double *r, const size_
Set 's' with the string if succeeds
Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_string(m_serial_read_t serial, struct string_s *s){
m_ser1al_str_json_read_string(m_serial_read_t serial, struct string_s *s){
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
m_ser1al_str_json_skip(f);
const char *e;
bool b = string_parse_str(s, *f, &e);
serial->data[0].cstr = e;
@@ -959,19 +959,19 @@ m_serial_str_json_read_string(m_serial_read_t serial, struct string_s *s){
M_SERIAL_OK_DONE if it succeeds and the array ends (the array is empty),
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
m_ser1al_str_json_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
{
(void) local; // argument not used
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
char c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
char c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY(c != '[')) {
return m_core_serial_fail();
}
*num = 0; // Don't know the size of the array.
m_serial_str_json_skip(f);
m_ser1al_str_json_skip(f);
if (M_UNLIKELY (**f == ']')) {
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
return M_SERIAL_OK_DONE;
} else {
return M_SERIAL_OK_CONTINUE;
@@ -983,12 +983,12 @@ m_serial_str_json_read_array_start(m_serial_local_t local, m_serial_read_t seria
M_SERIAL_OK_DONE if it succeeds and the array ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_array_next(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_str_json_read_array_next(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
char c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
char c = m_ser1al_str_json_getc(f);
return c == ',' ? M_SERIAL_OK_CONTINUE : c == ']' ? M_SERIAL_OK_DONE : m_core_serial_fail();
}
@@ -1000,19 +1000,19 @@ m_serial_str_json_read_array_next(m_serial_local_t local, m_serial_read_t serial
M_SERIAL_OK_DONE if it succeeds and the map ends (the map is empty),
m_core_serial_fail() otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_map_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
m_ser1al_str_json_read_map_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
{
(void) local; // argument not used
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
char c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
char c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY(c != '{')) {
return m_core_serial_fail();
}
*num = 0; // Don't know the size of the map
m_serial_str_json_skip(f);
m_ser1al_str_json_skip(f);
if (M_UNLIKELY (**f == '}')) {
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
return M_SERIAL_OK_DONE;
} else {
return M_SERIAL_OK_CONTINUE;
@@ -1023,12 +1023,12 @@ m_serial_str_json_read_map_start(m_serial_local_t local, m_serial_read_t serial,
Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_map_value(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_str_json_read_map_value(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
char c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
char c = m_ser1al_str_json_getc(f);
return c ==':' ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
}
@@ -1037,12 +1037,12 @@ m_serial_str_json_read_map_value(m_serial_local_t local, m_serial_read_t serial)
M_SERIAL_OK_DONE if it succeeds and the map ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_map_next(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_str_json_read_map_next(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
char c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
char c = m_ser1al_str_json_getc(f);
return c == ',' ? M_SERIAL_OK_CONTINUE : c == '}' ? M_SERIAL_OK_DONE : m_core_serial_fail();
}
@@ -1050,12 +1050,12 @@ m_serial_str_json_read_map_next(m_serial_local_t local, m_serial_read_t serial)
Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_str_json_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
char c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
char c = m_ser1al_str_json_getc(f);
return c == '{' ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
}
@@ -1066,28 +1066,28 @@ m_serial_str_json_read_tuple_start(m_serial_local_t local, m_serial_read_t seria
Return M_SERIAL_OK_DONE if it succeeds and the tuple ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
m_ser1al_str_json_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
{
(void) local; // argument not used
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
char c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
char c = m_ser1al_str_json_getc(f);
if (c == 0) return m_core_serial_fail();
if (c == '}') return M_SERIAL_OK_DONE;
if (c == ',') {
// If first call of read_tuple_id, it is a failure
if (M_UNLIKELY (*id == -1)) return m_core_serial_fail();
m_serial_str_json_skip(f);
c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
c = m_ser1al_str_json_getc(f);
}
/* Read the field in the JSON */
char field[M_USE_IDENTIFIER_ALLOC+1];
if (M_UNLIKELY(c != '"')) return m_core_serial_fail();
m_serial_str_json_gets(M_USE_IDENTIFIER_ALLOC+1, field, " \t\n\"", f);
c = m_serial_str_json_getc(f);
m_ser1al_str_json_gets(M_USE_IDENTIFIER_ALLOC+1, field, " \t\n\"", f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY (c != '"')) return m_core_serial_fail();
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY (c != ':')) return m_core_serial_fail();
/* Search for field in field_name */
@@ -1107,26 +1107,26 @@ m_serial_str_json_read_tuple_id(m_serial_local_t local, m_serial_read_t serial,
Return M_SERIAL_OK_DONE if it succeeds and the variant ends(variant is empty),
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
m_ser1al_str_json_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
{
(void) local; // argument not used
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
int c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
int c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY (c != '{'))
// TODO: Accept 'null' as empty variant?
return m_core_serial_fail();
m_serial_str_json_skip(f);
c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY (c == '}')) return M_SERIAL_OK_DONE; // Empty variant
/* Read the field in the JSON */
char field[M_USE_IDENTIFIER_ALLOC+1];
if (M_UNLIKELY(c != '"')) return m_core_serial_fail();
m_serial_str_json_gets(M_USE_IDENTIFIER_ALLOC+1, field, " \t\n\"", f);
c = m_serial_str_json_getc(f);
m_ser1al_str_json_gets(M_USE_IDENTIFIER_ALLOC+1, field, " \t\n\"", f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY (c != '"')) return m_core_serial_fail();
c = m_serial_str_json_getc(f);
c = m_ser1al_str_json_getc(f);
if (M_UNLIKELY (c != ':')) return m_core_serial_fail();
/* Linear Search for field in field_name */
@@ -1144,35 +1144,35 @@ m_serial_str_json_read_variant_start(m_serial_local_t local, m_serial_read_t ser
Return M_SERIAL_OK_DONE if it succeeds and the variant ends,
M_SERIAL_FAIL otherwise */
static inline m_serial_return_code_t
m_serial_str_json_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
m_ser1al_str_json_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
{
(void) local; // argument not used
const char **f = &serial->data[0].cstr;
m_serial_str_json_skip(f);
int c = m_serial_str_json_getc(f);
m_ser1al_str_json_skip(f);
int c = m_ser1al_str_json_getc(f);
return (M_UNLIKELY (c != '}')) ? m_core_serial_fail() : M_SERIAL_OK_DONE;
}
static const m_serial_read_interface_t m_serial_str_json_read_interface = {
m_serial_str_json_read_boolean,
m_serial_str_json_read_integer,
m_serial_str_json_read_float,
m_serial_str_json_read_string,
m_serial_str_json_read_array_start,
m_serial_str_json_read_array_next,
m_serial_str_json_read_map_start,
m_serial_str_json_read_map_value,
m_serial_str_json_read_map_next,
m_serial_str_json_read_tuple_start,
m_serial_str_json_read_tuple_id,
m_serial_str_json_read_variant_start,
m_serial_str_json_read_variant_end
static const m_serial_read_interface_t m_ser1al_str_json_read_interface = {
m_ser1al_str_json_read_boolean,
m_ser1al_str_json_read_integer,
m_ser1al_str_json_read_float,
m_ser1al_str_json_read_string,
m_ser1al_str_json_read_array_start,
m_ser1al_str_json_read_array_next,
m_ser1al_str_json_read_map_start,
m_ser1al_str_json_read_map_value,
m_ser1al_str_json_read_map_next,
m_ser1al_str_json_read_tuple_start,
m_ser1al_str_json_read_tuple_id,
m_ser1al_str_json_read_variant_start,
m_ser1al_str_json_read_variant_end
};
/* Initialize the JSON serial object for reading any object from JSON format in the given const string */
static inline void m_serial_str_json_read_init(m_serial_read_t serial, const char str[])
{
serial->m_interface = &m_serial_str_json_read_interface;
serial->m_interface = &m_ser1al_str_json_read_interface;
serial->data[0].cstr = str;
}