GONEC_NEW
/
JSON
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Init

This commit is contained in:
cfif 2025-05-26 14:41:46 +03:00
commit 4d4ee8bcb4
8 changed files with 1919 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Inc/cvt.h Normal file
View File

@ -0,0 +1,10 @@
//
// Created by cfif on 26.10.22.
//
#ifndef ARTERY_PROJECT_CVT_H
#define ARTERY_PROJECT_CVT_H
char *fromFloat(char *bufFloat, float *value);
#endif //ARTERY_PROJECT_CVT_H

54
Inc/mtojson.h Normal file
View File

@ -0,0 +1,54 @@
/*
SPDX-License-Identifier: BSD-2-Clause
This file is Copyright (c) 2020, 2021 by Rene Kita
*/
#ifndef RKTA_MTOJSON_H
#define RKTA_MTOJSON_H
#include <stddef.h>
#include <inttypes.h>
enum json_to_type {
t_to_primitive,
t_to_array,
t_to_boolean,
t_to_hex,
t_to_hex_u8,
t_to_hex_u16,
t_to_hex_u32,
t_to_hex_u64,
t_to_int,
t_to_int8_t,
t_to_int16_t,
t_to_int32_t,
t_to_int64_t,
t_to_long,
t_to_longlong,
t_to_null,
t_to_object,
t_to_string,
t_to_uint,
t_to_uint8_t,
t_to_uint16_t,
t_to_uint32_t,
t_to_uint64_t,
t_to_ulong,
t_to_ulonglong,
t_to_value,
t_to_float,
};
struct to_json {
const char *name;
const void *value;
const uint8_t *lenStr;
const size_t *count; // Number of elements in a C array
size_t len;
enum json_to_type stype; // Type of the struct
enum json_to_type vtype; // Type of '.value'
};
/* Returns the length of the generated JSON text or 0 in case of an error. */
size_t json_generate(char *out, const struct to_json *tjs, size_t len);
#endif

176
Inc/tiny-json.h Normal file
View File

@ -0,0 +1,176 @@
/*
<https://github.com/rafagafe/tiny-json>
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
SPDX-License-Identifier: MIT
Copyright (c) 2016-2018 Rafa Garcia <rafagarcia77@gmail.com>.
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.
*/
#ifndef _TINY_JSON_H_
#define _TINY_JSON_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stddef.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#define json_containerOf( ptr, type, member ) \
((type*)( (char*)ptr - offsetof( type, member ) ))
/** @defgroup tinyJson Tiny JSON parser.
* @{ */
/** Enumeration of codes of supported JSON properties types. */
typedef enum {
JSON_OBJ, JSON_ARRAY, JSON_TEXT, JSON_BOOLEAN,
JSON_INTEGER, JSON_REAL, JSON_NULL
} jsonType_t;
/** Structure to handle JSON properties. */
typedef struct json_s {
struct json_s* sibling;
char const* name;
union {
char const* value;
struct {
struct json_s* child;
struct json_s* last_child;
} c;
} u;
jsonType_t type;
} json_t;
/** Parse a string to get a json.
* @param str String pointer with a JSON object. It will be modified.
* @param mem Array of json properties to allocate.
* @param qty Number of elements of mem.
* @retval Null pointer if any was wrong in the parse process.
* @retval If the parser process was successfully a valid handler of a json.
* This property is always unnamed and its type is JSON_OBJ. */
json_t const* json_create( char* str, json_t mem[], unsigned int qty );
/** Get the name of a json property.
* @param json A valid handler of a json property.
* @retval Pointer to null-terminated if property has name.
* @retval Null pointer if the property is unnamed. */
static inline char const* json_getName( json_t const* json ) {
return json->name;
}
/** Get the value of a json property.
* The type of property cannot be JSON_OBJ or JSON_ARRAY.
* @param property A valid handler of a json property.
* @return Pointer to null-terminated string with the value. */
static inline char const* json_getValue( json_t const* property ) {
return property->u.value;
}
/** Get the type of a json property.
* @param json A valid handler of a json property.
* @return The code of type.*/
static inline jsonType_t json_getType( json_t const* json ) {
return json->type;
}
/** Get the next sibling of a JSON property that is within a JSON object or array.
* @param json A valid handler of a json property.
* @retval The handler of the next sibling if found.
* @retval Null pointer if the json property is the last one. */
static inline json_t const* json_getSibling( json_t const* json ) {
return json->sibling;
}
/** Search a property by its name in a JSON object.
* @param obj A valid handler of a json object. Its type must be JSON_OBJ.
* @param property The name of property to get.
* @retval The handler of the json property if found.
* @retval Null pointer if not found. */
json_t const* json_getProperty( json_t const* obj, char const* property );
/** Search a property by its name in a JSON object and return its value.
* @param obj A valid handler of a json object. Its type must be JSON_OBJ.
* @param property The name of property to get.
* @retval If found a pointer to null-terminated string with the value.
* @retval Null pointer if not found or it is an array or an object. */
char const* json_getPropertyValue( json_t const* obj, char const* property );
/** Get the first property of a JSON object or array.
* @param json A valid handler of a json property.
* Its type must be JSON_OBJ or JSON_ARRAY.
* @retval The handler of the first property if there is.
* @retval Null pointer if the json object has not properties. */
static inline json_t const* json_getChild( json_t const* json ) {
return json->u.c.child;
}
/** Get the value of a json boolean property.
* @param property A valid handler of a json object. Its type must be JSON_BOOLEAN.
* @return The value stdbool. */
static inline bool json_getBoolean( json_t const* property ) {
return *property->u.value == 't';
}
/** Get the value of a json integer property.
* @param property A valid handler of a json object. Its type must be JSON_INTEGER.
* @return The value stdint. */
static inline int64_t json_getInteger( json_t const* property ) {
return strtoll( property->u.value,(char**)NULL, 10);
}
/** Get the value of a json real property.
* @param property A valid handler of a json object. Its type must be JSON_REAL.
* @return The value. */
static inline double json_getReal( json_t const* property ) {
return strtod( property->u.value,(char**)NULL );
}
/** Structure to handle a heap of JSON properties. */
typedef struct jsonPool_s jsonPool_t;
struct jsonPool_s {
json_t* (*init)( jsonPool_t* pool );
json_t* (*alloc)( jsonPool_t* pool );
};
/** Parse a string to get a json.
* @param str String pointer with a JSON object. It will be modified.
* @param pool Custom json pool pointer.
* @retval Null pointer if any was wrong in the parse process.
* @retval If the parser process was successfully a valid handler of a json.
* This property is always unnamed and its type is JSON_OBJ. */
json_t const* json_createWithPool( char* str, jsonPool_t* pool );
/** @ } */
#ifdef __cplusplus
}
#endif
#endif /* _TINY_JSON_H_ */

317
Src/cvt.c Normal file
View File

@ -0,0 +1,317 @@
//
// Created by cfif on 26.10.22.
//
#include <math.h>
static unsigned char *
cvtround (double fract, int *exp, unsigned char *start, unsigned char *end, unsigned char ch,
unsigned char *negp)
{
double tmp;
if (fract) {
modf (fract * 10, &tmp);
} else {
tmp = ch - '0';
}
if (tmp > 4) {
for (;; --end) {
if (*end == '.') {
--end;
}
if (++*end <= '9') {
break;
}
*end = '0';
if (end == start) {
if (exp) { /* e/E; increment exponent */
*end = '1';
++*exp;
} else { /* f; add extra digit */
*--end = '1';
--start;
}
break;
}
}
} else if (*negp) {
/*
* ``"%.3f", (double)-0.0004'' gives you a negative 0.
*/
for (;; --end) {
if (*end == '.') {
--end;
}
if (*end != '0') {
break;
}
if (end == start) {
*negp = 0;
}
}
}
return start;
}
static unsigned char *
exponent (unsigned char *p, int exp, unsigned char fmtch)
{
unsigned char expbuf [8], *t;
*p++ = fmtch;
if (exp < 0) {
exp = -exp;
*p++ = '-';
} else {
*p++ = '+';
}
t = expbuf + sizeof(expbuf);
if (exp > 9) {
do {
*--t = exp % 10 + '0';
} while ((exp /= 10) > 9);
*--t = exp + '0';
for (; t < expbuf + sizeof(expbuf); *p++ = *t++)
continue;
} else {
*p++ = '0';
*p++ = exp + '0';
}
return p;
}
static int
cvt (double number, int prec, int sharpflag, unsigned char *negp, unsigned char fmtch,
unsigned char *startp, unsigned char *endp)
{
unsigned char *p, *t;
double fract;
int dotrim, expcnt, gformat;
double integer, tmp;
expcnt = 0;
dotrim = expcnt = gformat = 0;
fract = modf (number, &integer);
/*
* get an extra slot for rounding
*/
t = ++startp;
/*
* get integer portion of number; put into the end of the buffer; the
* .01 is added for modf (356.0 / 10, &integer) returning .59999999...
*/
for (p = endp - 1; integer; ++expcnt) {
tmp = modf (integer / 10, &integer);
*p-- = (int) ((tmp + .01) * 10) + '0';
}
switch (fmtch) {
case 'f':
/* reverse integer into beginning of buffer */
if (expcnt) {
for (; ++p < endp; *t++ = *p);
} else {
*t++ = '0';
}
/*
* if precision required or alternate flag set, add in a
* decimal point.
*/
if (prec || sharpflag) {
*t++ = '.';
}
/*
* if requires more precision and some fraction left
*/
if (fract) {
if (prec) {
do {
fract = modf (fract * 10, &tmp);
*t++ = (int)tmp + '0';
} while (--prec && fract);
}
if (fract) {
startp = cvtround (fract, 0, startp,
t - 1, '0', negp);
}
}
for (; prec--; *t++ = '0');
break;
case 'e':
case 'E':
eformat: if (expcnt) {
*t++ = *++p;
if (prec || sharpflag) {
*t++ = '.';
}
/*
* if requires more precision and some integer left
*/
for (; prec && ++p < endp; --prec) {
*t++ = *p;
}
/*
* if done precision and more of the integer component,
* round using it; adjust fract so we don't re-round
* later.
*/
if (! prec && ++p < endp) {
fract = 0;
startp = cvtround (0, &expcnt, startp,
t - 1, *p, negp);
}
/*
* adjust expcnt for digit in front of decimal
*/
--expcnt;
}
/*
* until first fractional digit, decrement exponent
*/
else if (fract) {
/*
* adjust expcnt for digit in front of decimal
*/
for (expcnt = -1;; --expcnt) {
fract = modf (fract * 10, &tmp);
if (tmp) {
break;
}
}
*t++ = (int)tmp + '0';
if (prec || sharpflag) {
*t++ = '.';
}
} else {
*t++ = '0';
if (prec || sharpflag) {
*t++ = '.';
}
}
/*
* if requires more precision and some fraction left
*/
if (fract) {
if (prec) {
do {
fract = modf (fract * 10, &tmp);
*t++ = (int)tmp + '0';
} while (--prec && fract);
}
if (fract) {
startp = cvtround (fract, &expcnt, startp,
t - 1, '0', negp);
}
}
/*
* if requires more precision
*/
for (; prec--; *t++ = '0');
/*
* unless alternate flag, trim any g/G format trailing 0's
*/
if (gformat && ! sharpflag) {
while (t > startp && *--t == '0');
if (*t == '.') {
--t;
}
++t;
}
t = exponent (t, expcnt, fmtch);
break;
case 'g':
case 'G':
/*
* a precision of 0 is treated as a precision of 1
*/
if (!prec) {
++prec;
}
/*
* ``The style used depends on the value converted; style e
* will be used only if the exponent resulting from the
* conversion is less than -4 or greater than the precision.''
* -- ANSI X3J11
*/
if (expcnt > prec || (! expcnt && fract && fract < .0001)) {
/*
* g/G format counts "significant digits, not digits of
* precision; for the e/E format, this just causes an
* off-by-one problem, i.e. g/G considers the digit
* before the decimal point significant and e/E doesn't
* count it as precision.
*/
--prec;
fmtch -= 2; /* G->E, g->e */
gformat = 1;
goto eformat;
}
/*
* reverse integer into beginning of buffer,
* note, decrement precision
*/
if (expcnt) {
for (; ++p < endp; *t++ = *p, --prec);
} else {
*t++ = '0';
}
/*
* if precision required or alternate flag set, add in a
* decimal point. If no digits yet, add in leading 0.
*/
if (prec || sharpflag) {
dotrim = 1;
*t++ = '.';
} else {
dotrim = 0;
}
/*
* if requires more precision and some fraction left
*/
while (prec && fract) {
fract = modf (fract * 10, &tmp);
*t++ = (int)tmp + '0';
prec--;
}
if (fract) {
startp = cvtround (fract, 0, startp, t - 1, '0', negp);
}
/*
* alternate format, adds 0's for precision, else trim 0's
*/
if (sharpflag) {
for (; prec--; *t++ = '0');
} else if (dotrim) {
while (t > startp && *--t == '0');
if (*t != '.') {
++t;
}
}
}
return(t - startp);
}
char *fromFloat(char *bufFloat, float *value) {
int flag = 0;
if (*value < 0) {
flag = 1;
*value *= -1;
}
cvt(*value, 6, 1, bufFloat, 'f',&bufFloat[0], &bufFloat[24]);
if (flag) {
bufFloat[0] = '-';
} else {
bufFloat[0] = ' ';
}
return bufFloat;
}

759
Src/mtojson.c Normal file
View File

@ -0,0 +1,759 @@
/*
SPDX-License-Identifier: BSD-2-Clause
This file is Copyright (c) 2020, 2021 by Rene Kita
*/
#include "mtojson.h"
#include "cvt.h"
#include <stdint.h>
#include <string.h>
static char* gen_array(char *, const void *);
static char* gen_boolean(char *, const void *);
static char* gen_c_array(char *, const void *);
static char* gen_hex(char *, const void *);
static char* gen_hex_u8(char *, const void *);
static char* gen_hex_u16(char *, const void *);
static char* gen_hex_u32(char *, const void *);
static char* gen_hex_u64(char *, const void *);
static char* gen_int(char *, const void *);
static char* gen_int8_t(char *, const void *);
static char* gen_int16_t(char *, const void *);
static char* gen_int32_t(char *, const void *);
static char* gen_int64_t(char *, const void *);
static char* gen_long(char *, const void *);
static char* gen_longlong(char *, const void *);
static char* gen_null(char *, const void *);
static char* gen_object(char *, const void *);
static char* gen_primitive(char *, const void *);
static char* gen_string(char *, const void *);
static char* gen_uint(char *, const void *);
static char* gen_uint8_t(char *, const void *);
static char* gen_uint16_t(char *, const void *);
static char* gen_uint32_t(char *, const void *);
static char* gen_uint64_t(char *, const void *);
static char* gen_ulong(char *, const void *);
static char* gen_ulonglong(char *, const void *);
static char* gen_value(char *, const void *);
static char* gen_float(char *, const void *);
static char* (* const gen_functions[])(char *, const void *) = {
gen_primitive,
gen_array,
gen_boolean,
gen_hex,
gen_hex_u8,
gen_hex_u16,
gen_hex_u32,
gen_hex_u64,
gen_int,
gen_int8_t,
gen_int16_t,
gen_int32_t,
gen_int64_t,
gen_long,
gen_longlong,
gen_null,
gen_object,
gen_string,
gen_uint,
gen_uint8_t,
gen_uint16_t,
gen_uint32_t,
gen_uint64_t,
gen_ulong,
gen_ulonglong,
gen_value,
gen_float
};
static char* strcpy_val(char *out, const char *val, size_t len);
extern char bufFloat[20];
static char*
gen_float(char *out, const void *val)
{
char bufFloat[32];
memset(bufFloat, 0, sizeof(bufFloat));
if (!val)
return gen_null(out, val);
fromFloat(bufFloat, val);
return strcpy_val(out, &bufFloat[0], strlen(bufFloat));
}
static size_t remaining_length;
static int
reduce_rem_len(size_t len)
{
if (remaining_length < len)
return 0;
remaining_length -= len;
return 1;
}
static char*
strcpy_val(char *out, const char *val, size_t len)
{
if (!reduce_rem_len(len))
return NULL;
memcpy(out, val, len);
return out + len;
}
static char*
gen_null(char *out, const void *val)
{
(void)val;
return strcpy_val(out, "null", 4);
}
static char*
gen_boolean(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
if (*(_Bool*)val)
return strcpy_val(out, "true", 4);
else
return strcpy_val(out, "false", 5);
}
static char*
gen_string(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
if (!reduce_rem_len(2)) // 2 -> ""
return NULL;
char chars_to_escape[] = "\"\\";
const char *begin = (const char*)val;
const char *end = begin + strlen(begin);
*out++ = '"';
char *esc;
do {
esc = NULL;
for (int i = 0; i < 2; i++) {
char *tmp;
if ((tmp = strchr(begin, chars_to_escape[i]))) {
if (!esc)
esc = tmp;
else
esc = esc < tmp ? esc : tmp;
}
}
size_t len = esc ? (size_t)(esc - begin) : (size_t)(end - begin);
if (!(out = strcpy_val(out, begin, len)))
return NULL;
if (esc) {
char s[2];
s[0] = '\\';
s[1] = *esc;
if (!(out = strcpy_val(out, s, 2)))
return NULL;
begin = esc + 1;
}
} while (esc && *begin);
*out++ = '"';
return out;
}
static char*
utoa(char *dst, unsigned n, unsigned base)
{
char *s = dst;
char *e;
for (unsigned m = n; m >= base; m /= base)
s++;
e = s + 1;
size_t len = (size_t)(e - dst);
if (!reduce_rem_len(len))
return NULL;
for ( ; s >= dst; s--, n /= base)
*s = "0123456789ABCDEF"[n % base];
return e;
}
static char*
ultoa(char *dst, unsigned long n, unsigned base)
{
char *s = dst;
char *e;
for (unsigned long m = n; m >= base; m /= base)
s++;
e = s + 1;
size_t len = (size_t)(e - dst);
if (!reduce_rem_len(len))
return NULL;
for ( ; s >= dst; s--, n /= base)
*s = "0123456789ABCDEF"[n % base];
return e;
}
static char*
ulltoa(char *dst, unsigned long long n, unsigned base)
{
char *s = dst;
char *e;
for (unsigned long long m = n; m >= base; m /= base)
s++;
e = s + 1;
size_t len = (size_t)(e - dst);
if (!reduce_rem_len(len))
return NULL;
for ( ; s >= dst; s--, n /= base)
*s = "0123456789ABCDEF"[n % base];
return e;
}
static char*
gen_hex(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
if (!reduce_rem_len(2)) // 2 -> ""
return NULL;
*out++ = '"';
if (!(out = utoa(out, *(unsigned*)val, 16)))
return NULL;
*out++ = '"';
return out;
}
static char*
gen_hex_u8(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
if (!reduce_rem_len(2)) // 2 -> ""
return NULL;
*out++ = '"';
if (!(out = utoa(out, *(uint8_t*)val, 16)))
return NULL;
*out++ = '"';
return out;
}
static char*
gen_hex_u16(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
if (!reduce_rem_len(2)) // 2 -> ""
return NULL;
*out++ = '"';
if (!(out = utoa(out, *(uint16_t*)val, 16)))
return NULL;
*out++ = '"';
return out;
}
static char*
gen_hex_u32(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
if (!reduce_rem_len(2)) // 2 -> ""
return NULL;
*out++ = '"';
if (!(out = ultoa(out, *(uint32_t*)val, 16)))
return NULL;
*out++ = '"';
return out;
}
static char*
gen_hex_u64(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
if (!reduce_rem_len(2)) // 2 -> ""
return NULL;
*out++ = '"';
if (!(out = ulltoa(out, *(uint64_t*)val, 16)))
return NULL;
*out++ = '"';
return out;
}
static char*
gen_int(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
int n = *(int*)val;
unsigned u = (unsigned)n;
if (n < 0){
if (!reduce_rem_len(1))
return NULL;
*out++ = '-';
u = -(unsigned)n;
}
if (!(out = utoa(out, u, 10)))
return NULL;
return out;
}
static char*
gen_int8_t(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
int n = *(int8_t*)val;
unsigned u = (unsigned)n;
if (n < 0){
if (!reduce_rem_len(1))
return NULL;
*out++ = '-';
u = -(unsigned)n;
}
if (!(out = utoa(out, u, 10)))
return NULL;
return out;
}
static char*
gen_int16_t(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
int n = *(int16_t*)val;
unsigned u = (unsigned)n;
if (n < 0){
if (!reduce_rem_len(1))
return NULL;
*out++ = '-';
u = -(unsigned)n;
}
if (!(out = utoa(out, u, 10)))
return NULL;
return out;
}
static char*
gen_int32_t(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
int n = *(int*)val;
unsigned u = (unsigned)n;
if (n < 0){
if (!reduce_rem_len(1))
return NULL;
*out++ = '-';
u = -(unsigned)n;
}
if (!(out = utoa(out, u, 10)))
return NULL;
return out;
}
static char*
gen_int64_t(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
int64_t n = *(int64_t*)val;
uint64_t u = (uint64_t)n;
if (n < 0){
if (!reduce_rem_len(1))
return NULL;
*out++ = '-';
u = -(uint64_t)n;
}
if (!(out = ulltoa(out, u, 10)))
return NULL;
return out;
}
static char*
gen_uint(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
return utoa(out, *(unsigned*)val, 10);
}
static char*
gen_uint8_t(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
return utoa(out, *(uint8_t*)val, 10);
}
static char*
gen_uint16_t(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
return utoa(out, *(uint16_t*)val, 10);
}
static char*
gen_uint32_t(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
return ultoa(out, *(uint32_t*)val, 10);
}
static char*
gen_uint64_t(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
return ulltoa(out, *(uint64_t*)val, 10);
}
static char*
gen_long(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
long n = *(long*)val;
unsigned long u = (unsigned long)n;
if (n < 0){
if (!reduce_rem_len(1))
return NULL;
*out++ = '-';
u = -(unsigned long)n;
}
if (!(out = ultoa(out, u, 10)))
return NULL;
return out;
}
static char*
gen_longlong(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
long long n = *(long long*)val;
unsigned long long u = (unsigned long long)n;
if (n < 0){
if (!reduce_rem_len(1))
return NULL;
*out++ = '-';
u = -(unsigned long long)n;
}
if (!(out = ulltoa(out, u, 10)))
return NULL;
return out;
}
static char*
gen_ulong(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
return ultoa(out, *(unsigned long*)val, 10);
}
static char*
gen_ulonglong(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
return ulltoa(out, *(unsigned long long*)val, 10);
}
static char*
gen_value(char *out, const void *val)
{
return strcpy_val(out, (const char*)val, strlen((const char*)val));
}
static char*
gen_c_array(char *out, const void *val)
{
const struct to_json *tjs = (const struct to_json*)val;
if (!reduce_rem_len(2)) // 2 -> []
return NULL;
*out++ = '[';
if (*tjs->count == 0){
*out++ = ']';
return out;
}
size_t incr = 0;
char* (*func)(char *, const void *) = gen_functions[tjs->vtype];
switch (tjs->vtype) {
case t_to_boolean:
incr = sizeof(_Bool);
break;
case t_to_int:
incr = sizeof(int);
break;
case t_to_int8_t:
incr = sizeof(int8_t);
break;
case t_to_int16_t:
incr = sizeof(int16_t);
break;
case t_to_int32_t:
incr = sizeof(int32_t);
break;
case t_to_float:
incr = sizeof(float);
break;
case t_to_int64_t:
incr = sizeof(int64_t);
break;
case t_to_long:
incr = sizeof(unsigned long);
break;
case t_to_longlong:
incr = sizeof(unsigned long long);
break;
case t_to_object:
incr = sizeof(struct to_json);
break;
case t_to_hex:
case t_to_uint:
incr = sizeof(unsigned);
break;
case t_to_hex_u8:
case t_to_uint8_t:
incr = sizeof(uint8_t);
break;
case t_to_hex_u16:
case t_to_uint16_t:
incr = sizeof(uint16_t);
break;
case t_to_hex_u32:
case t_to_uint32_t:
incr = sizeof(uint32_t);
break;
case t_to_hex_u64:
case t_to_uint64_t:
incr = sizeof(uint64_t);
break;
case t_to_ulong:
incr = sizeof(unsigned long);
break;
case t_to_ulonglong:
incr = sizeof(unsigned long long);
break;
case t_to_array:
case t_to_null:
case t_to_primitive:
case t_to_string:
case t_to_value:
return NULL;
}
const char *p = tjs->value;
for (size_t i = 0; i < *tjs->count - 1; i++){
if (!(out = (*func)(out, p)))
return NULL;
if (!reduce_rem_len(1))
return NULL;
*out++ = ',';
p += incr;
}
if (!(out = (*func)(out, p)))
return NULL;
*out++ = ']';
return out;
}
static char*
gen_array(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
const struct to_json *tjs = (const struct to_json*)val;
if (!reduce_rem_len(2)) // 2 -> []
return NULL;
*out++ = '[';
while (tjs->value){
if (tjs->count)
out = gen_c_array(out, tjs);
else
out = gen_functions[tjs->vtype](out, tjs->value);
if (!out)
return NULL;
tjs++;
if (tjs->value){
if (!reduce_rem_len(1))
return NULL;
*out++ = ',';
}
}
*out++ = ']';
return out;
}
static char*
gen_object(char *out, const void *val)
{
if (!val)
return gen_null(out, val);
const struct to_json *tjs = (const struct to_json*)val;
if (!reduce_rem_len(2)) // 2 -> {}
return NULL;
*out++ = '{';
while (tjs->name){
const char *name = tjs->name;
size_t len = strlen(name) ;
if (!reduce_rem_len(len + 3)) // 3 -> "":
return NULL;
*out++ = '"';
memcpy(out, name, len);
out += len;
*out++ = '"';
*out++ = ':';
if (tjs->count)
out = gen_c_array(out, tjs);
else
out = gen_functions[tjs->vtype](out, tjs->value);
if (!out)
return NULL;
tjs++;
if (tjs->name){
if (!reduce_rem_len(1))
return NULL;
*out++ = ',';
}
}
*out++ = '}';
return out;
}
static char*
gen_primitive(char *out, const void *to_json)
{
const struct to_json *tjs = (const struct to_json *)to_json;
if (tjs->count)
return gen_c_array(out, tjs);
return gen_functions[tjs->vtype](out, tjs->value);
}
size_t
json_generate(char *out, const struct to_json *tjs, size_t len)
{
const char *start = out;
remaining_length = len;
if (!reduce_rem_len(1)) // \0
return 0;
switch (tjs->stype) {
case t_to_array:
out = gen_array(out, tjs);
break;
case t_to_object:
out = gen_object(out, tjs);
break;
case t_to_primitive:
out = gen_primitive(out, tjs);
break;
/* These are not valid ctypes */
case t_to_boolean:
case t_to_int:
case t_to_null:
case t_to_string:
case t_to_uint:
case t_to_value:
default:
return 0;
}
if (!out)
return 0;
*out = '\0';
return (size_t)(out - start);
}

132
Src/testJson.c Normal file
View File

@ -0,0 +1,132 @@
//
// Created by cfif on 27.10.22.
//
#include <string.h>
#include "tiny-json.h"
#include "mtojson.h"
typedef struct {
float param1;
char param2[16];
uint32_t param3;
uint32_t param4;
uint32_t param5;
} com1;
typedef struct {
uint32_t param1;
uint32_t param2;
uint32_t param3;
uint32_t param4;
uint32_t param5;
} com2;
com1 dataCom1 = {1.123456, "qwerty", 3, 4, 5};
com2 dataCom2 = {6, 7,8, 9, 0};
const char *listComName[] = {"com1", "com2"};
const void *listComStruct[] = { &dataCom1, &dataCom2};
const int countListCom = sizeof(listComStruct) / 4;
const struct to_json jsonDataArray1[] = {
{.value = &dataCom1.param1, .vtype = t_to_float, .stype = t_to_array},
{.value = &dataCom1.param2, .vtype = t_to_string,},
{.value = &dataCom1.param3, .vtype = t_to_uint32_t,},
{.value = &dataCom1.param4, .vtype = t_to_uint32_t,},
{.value = &dataCom1.param5, .vtype = t_to_uint32_t,},
{NULL}
};
const struct to_json jsonDataArray2[] = {
{.value = &dataCom2.param1, .vtype = t_to_uint32_t, .stype = t_to_array},
{.value = &dataCom2.param2, .vtype = t_to_uint32_t,},
{.value = &dataCom2.param3, .vtype = t_to_uint32_t,},
{.value = &dataCom2.param4, .vtype = t_to_uint32_t,},
{.value = &dataCom2.param5, .vtype = t_to_uint32_t,},
{NULL}
};
const struct to_json jsonCom1 = {.name = "com1", .value = &jsonDataArray1, .vtype = t_to_array, .stype = t_to_object};
const struct to_json jsonCom2 = {.name = "com2", .value = &jsonDataArray2, .vtype = t_to_array, .stype = t_to_object};
enum { MAX_STRING_LEN = 1000 };
char json_text[MAX_STRING_LEN] = {0};
void testJson() {
const struct to_json jsonDataObject[] = {
jsonCom1,
jsonCom2,
{NULL}
};
size_t json_len = json_generate(&json_text[0], jsonDataObject, MAX_STRING_LEN);
dataCom1.param1 = 0;
strcpy(dataCom1.param2, "qaz");
dataCom1.param3 = 0;
dataCom1.param4 = 0;
dataCom1.param5 = 0;
dataCom2.param1 = 0;
dataCom2.param2 = 0;
dataCom2.param3 = 0;
dataCom2.param4 = 0;
dataCom2.param5 = 0;
json_t pool[1000];
unsigned const qty = sizeof pool / sizeof *pool;
char comName[20];
//char str[] = "{\"com1\":[ 11.12345, \"qwertyuiop\", 13, 14, 15 ], \"com2\":[ 16, 17, 18, 19, 20 ]}";
json_t const *json = json_create(json_text, pool, qty);
json_t const *elementRoot = json_getChild(json);
while (elementRoot != 0) {
strcpy(comName, json_getName(elementRoot));
void *data_p = NULL;
for (int i = 0; i < countListCom; ++i) {
if (strncmp(comName, listComName[i], strlen(listComName[i])) == 0) {
data_p = listComStruct[i];
break;
}
}
if (data_p == NULL)
continue;
json_t const *array = json_getProperty(json, comName);
json_t const *element = json_getChild(array);
while (element != 0) {
if (json_getType(element) == JSON_REAL) {
((float *) data_p)[0] = (float) json_getReal(element);
data_p += 4;
}
if (json_getType(element) == JSON_INTEGER) {
((uint32_t *) data_p)[0] = json_getInteger(element);
data_p += 4;
}
if (json_getType(element) == JSON_TEXT) {
strcpy(data_p, json_getValue(element));
data_p += 16;
}
element = json_getSibling(element);
}
elementRoot = json_getSibling(elementRoot);
}
dataCom2.param5 = 0;
}

461
Src/tiny-json.c Normal file
View File

@ -0,0 +1,461 @@
/*
<https://github.com/rafagafe/tiny-json>
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
SPDX-License-Identifier: MIT
Copyright (c) 2016-2018 Rafa Garcia <rafagarcia77@gmail.com>.
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.
*/
#include <string.h>
#include <ctype.h>
#include "tiny-json.h"
/** Structure to handle a heap of JSON properties. */
typedef struct jsonStaticPool_s {
json_t* mem; /**< Pointer to array of json properties. */
unsigned int qty; /**< Length of the array of json properties. */
unsigned int nextFree; /**< The index of the next free json property. */
jsonPool_t pool;
} jsonStaticPool_t;
/* Search a property by its name in a JSON object. */
json_t const* json_getProperty( json_t const* obj, char const* property ) {
json_t const* sibling;
for( sibling = obj->u.c.child; sibling; sibling = sibling->sibling )
if ( sibling->name && !strcmp( sibling->name, property ) )
return sibling;
return 0;
}
/* Search a property by its name in a JSON object and return its value. */
char const* json_getPropertyValue( json_t const* obj, char const* property ) {
json_t const* field = json_getProperty( obj, property );
if ( !field ) return 0;
jsonType_t type = json_getType( field );
if ( JSON_ARRAY >= type ) return 0;
return json_getValue( field );
}
/* Internal prototypes: */
static char* goBlank( char* str );
static char* goNum( char* str );
static json_t* poolInit( jsonPool_t* pool );
static json_t* poolAlloc( jsonPool_t* pool );
static char* objValue( char* ptr, json_t* obj, jsonPool_t* pool );
static char* setToNull( char* ch );
static bool isEndOfPrimitive( char ch );
/* Parse a string to get a json. */
json_t const* json_createWithPool( char *str, jsonPool_t *pool ) {
char* ptr = goBlank( str );
if ( !ptr || (*ptr != '{' && *ptr != '[') ) return 0;
json_t* obj = pool->init( pool );
obj->name = 0;
obj->sibling = 0;
obj->u.c.child = 0;
ptr = objValue( ptr, obj, pool );
if ( !ptr ) return 0;
return obj;
}
/* Parse a string to get a json. */
json_t const* json_create( char* str, json_t mem[], unsigned int qty ) {
jsonStaticPool_t spool;
spool.mem = mem;
spool.qty = qty;
spool.pool.init = poolInit;
spool.pool.alloc = poolAlloc;
return json_createWithPool( str, &spool.pool );
}
/** Get a special character with its escape character. Examples:
* 'b' -> '\\b', 'n' -> '\\n', 't' -> '\\t'
* @param ch The escape character.
* @retval The character code. */
static char getEscape( char ch ) {
static struct { char ch; char code; } const pair[] = {
{ '\"', '\"' }, { '\\', '\\' },
{ '/', '/' }, { 'b', '\b' },
{ 'f', '\f' }, { 'n', '\n' },
{ 'r', '\r' }, { 't', '\t' },
};
unsigned int i;
for( i = 0; i < sizeof pair / sizeof *pair; ++i )
if ( pair[i].ch == ch )
return pair[i].code;
return '\0';
}
/** Parse 4 characters.
* @param str Pointer to first digit.
* @retval '?' If the four characters are hexadecimal digits.
* @retval '\0' In other cases. */
static unsigned char getCharFromUnicode( unsigned char const* str ) {
unsigned int i;
for( i = 0; i < 4; ++i )
if ( !isxdigit( str[i] ) )
return '\0';
return '?';
}
/** Parse a string and replace the scape characters by their meaning characters.
* This parser stops when finds the character '\"'. Then replaces '\"' by '\0'.
* @param str Pointer to first character.
* @retval Pointer to first non white space after the string. If success.
* @retval Null pointer if any error occur. */
static char* parseString( char* str ) {
unsigned char* head = (unsigned char*)str;
unsigned char* tail = (unsigned char*)str;
for( ; *head; ++head, ++tail ) {
if ( *head == '\"' ) {
*tail = '\0';
return (char*)++head;
}
if ( *head == '\\' ) {
if ( *++head == 'u' ) {
char const ch = getCharFromUnicode( ++head );
if ( ch == '\0' ) return 0;
*tail = ch;
head += 3;
}
else {
char const esc = getEscape( *head );
if ( esc == '\0' ) return 0;
*tail = esc;
}
}
else *tail = *head;
}
return 0;
}
/** Parse a string to get the name of a property.
* @param ptr Pointer to first character.
* @param property The property to assign the name.
* @retval Pointer to first of property value. If success.
* @retval Null pointer if any error occur. */
static char* propertyName( char* ptr, json_t* property ) {
property->name = ++ptr;
ptr = parseString( ptr );
if ( !ptr ) return 0;
ptr = goBlank( ptr );
if ( !ptr ) return 0;
if ( *ptr++ != ':' ) return 0;
return goBlank( ptr );
}
/** Parse a string to get the value of a property when its type is JSON_TEXT.
* @param ptr Pointer to first character ('\"').
* @param property The property to assign the name.
* @retval Pointer to first non white space after the string. If success.
* @retval Null pointer if any error occur. */
static char* textValue( char* ptr, json_t* property ) {
++property->u.value;
ptr = parseString( ++ptr );
if ( !ptr ) return 0;
property->type = JSON_TEXT;
return ptr;
}
/** Compare two strings until get the null character in the second one.
* @param ptr sub string
* @param str main string
* @retval Pointer to next character.
* @retval Null pointer if any error occur. */
static char* checkStr( char* ptr, char const* str ) {
while( *str )
if ( *ptr++ != *str++ )
return 0;
return ptr;
}
/** Parser a string to get a primitive value.
* If the first character after the value is different of '}' or ']' is set to '\0'.
* @param ptr Pointer to first character.
* @param property Property handler to set the value and the type, (true, false or null).
* @param value String with the primitive literal.
* @param type The code of the type. ( JSON_BOOLEAN or JSON_NULL )
* @retval Pointer to first non white space after the string. If success.
* @retval Null pointer if any error occur. */
static char* primitiveValue( char* ptr, json_t* property, char const* value, jsonType_t type ) {
ptr = checkStr( ptr, value );
if ( !ptr || !isEndOfPrimitive( *ptr ) ) return 0;
ptr = setToNull( ptr );
property->type = type;
return ptr;
}
/** Parser a string to get a true value.
* If the first character after the value is different of '}' or ']' is set to '\0'.
* @param ptr Pointer to first character.
* @param property Property handler to set the value and the type, (true, false or null).
* @retval Pointer to first non white space after the string. If success.
* @retval Null pointer if any error occur. */
static char* trueValue( char* ptr, json_t* property ) {
return primitiveValue( ptr, property, "true", JSON_BOOLEAN );
}
/** Parser a string to get a false value.
* If the first character after the value is different of '}' or ']' is set to '\0'.
* @param ptr Pointer to first character.
* @param property Property handler to set the value and the type, (true, false or null).
* @retval Pointer to first non white space after the string. If success.
* @retval Null pointer if any error occur. */
static char* falseValue( char* ptr, json_t* property ) {
return primitiveValue( ptr, property, "false", JSON_BOOLEAN );
}
/** Parser a string to get a null value.
* If the first character after the value is different of '}' or ']' is set to '\0'.
* @param ptr Pointer to first character.
* @param property Property handler to set the value and the type, (true, false or null).
* @retval Pointer to first non white space after the string. If success.
* @retval Null pointer if any error occur. */
static char* nullValue( char* ptr, json_t* property ) {
return primitiveValue( ptr, property, "null", JSON_NULL );
}
/** Analyze the exponential part of a real number.
* @param ptr Pointer to first character.
* @retval Pointer to first non numerical after the string. If success.
* @retval Null pointer if any error occur. */
static char* expValue( char* ptr ) {
if ( *ptr == '-' || *ptr == '+' ) ++ptr;
if ( !isdigit( (int)(*ptr) ) ) return 0;
ptr = goNum( ++ptr );
return ptr;
}
/** Analyze the decimal part of a real number.
* @param ptr Pointer to first character.
* @retval Pointer to first non numerical after the string. If success.
* @retval Null pointer if any error occur. */
static char* fraqValue( char* ptr ) {
if ( !isdigit( (int)(*ptr) ) ) return 0;
ptr = goNum( ++ptr );
if ( !ptr ) return 0;
return ptr;
}
/** Parser a string to get a numerical value.
* If the first character after the value is different of '}' or ']' is set to '\0'.
* @param ptr Pointer to first character.
* @param property Property handler to set the value and the type: JSON_REAL or JSON_INTEGER.
* @retval Pointer to first non white space after the string. If success.
* @retval Null pointer if any error occur. */
static char* numValue( char* ptr, json_t* property ) {
if ( *ptr == '-' ) ++ptr;
if ( !isdigit( (int)(*ptr) ) ) return 0;
if ( *ptr != '0' ) {
ptr = goNum( ptr );
if ( !ptr ) return 0;
}
else if ( isdigit( (int)(*++ptr) ) ) return 0;
property->type = JSON_INTEGER;
if ( *ptr == '.' ) {
ptr = fraqValue( ++ptr );
if ( !ptr ) return 0;
property->type = JSON_REAL;
}
if ( *ptr == 'e' || *ptr == 'E' ) {
ptr = expValue( ++ptr );
if ( !ptr ) return 0;
property->type = JSON_REAL;
}
if ( !isEndOfPrimitive( *ptr ) ) return 0;
if ( JSON_INTEGER == property->type ) {
char const* value = property->u.value;
bool const negative = *value == '-';
static char const min[] = "-9223372036854775808";
static char const max[] = "9223372036854775807";
unsigned int const maxdigits = ( negative? sizeof min: sizeof max ) - 1;
unsigned int const len = ( unsigned int const ) ( ptr - value );
if ( len > maxdigits ) return 0;
if ( len == maxdigits ) {
char const tmp = *ptr;
*ptr = '\0';
char const* const threshold = negative ? min: max;
if ( 0 > strcmp( threshold, value ) ) return 0;
*ptr = tmp;
}
}
ptr = setToNull( ptr );
return ptr;
}
/** Add a property to a JSON object or array.
* @param obj The handler of the JSON object or array.
* @param property The handler of the property to be added. */
static void add( json_t* obj, json_t* property ) {
property->sibling = 0;
if ( !obj->u.c.child ){
obj->u.c.child = property;
obj->u.c.last_child = property;
} else {
obj->u.c.last_child->sibling = property;
obj->u.c.last_child = property;
}
}
/** Parser a string to get a json object value.
* @param ptr Pointer to first character.
* @param obj The handler of the JSON root object or array.
* @param pool The handler of a json pool for creating json instances.
* @retval Pointer to first character after the value. If success.
* @retval Null pointer if any error occur. */
static char* objValue( char* ptr, json_t* obj, jsonPool_t* pool ) {
obj->type = *ptr == '{' ? JSON_OBJ : JSON_ARRAY;
obj->u.c.child = 0;
obj->sibling = 0;
ptr++;
for(;;) {
ptr = goBlank( ptr );
if ( !ptr ) return 0;
if ( *ptr == ',' ) {
++ptr;
continue;
}
char const endchar = ( obj->type == JSON_OBJ )? '}': ']';
if ( *ptr == endchar ) {
*ptr = '\0';
json_t* parentObj = obj->sibling;
if ( !parentObj ) return ++ptr;
obj->sibling = 0;
obj = parentObj;
++ptr;
continue;
}
json_t* property = pool->alloc( pool );
if ( !property ) return 0;
if( obj->type != JSON_ARRAY ) {
if ( *ptr != '\"' ) return 0;
ptr = propertyName( ptr, property );
if ( !ptr ) return 0;
}
else property->name = 0;
add( obj, property );
property->u.value = ptr;
switch( *ptr ) {
case '{':
property->type = JSON_OBJ;
property->u.c.child = 0;
property->sibling = obj;
obj = property;
++ptr;
break;
case '[':
property->type = JSON_ARRAY;
property->u.c.child = 0;
property->sibling = obj;
obj = property;
++ptr;
break;
case '\"': ptr = textValue( ptr, property ); break;
case 't': ptr = trueValue( ptr, property ); break;
case 'f': ptr = falseValue( ptr, property ); break;
case 'n': ptr = nullValue( ptr, property ); break;
default: ptr = numValue( ptr, property ); break;
}
if ( !ptr ) return 0;
}
}
/** Initialize a json pool.
* @param pool The handler of the pool.
* @return a instance of a json. */
static json_t* poolInit( jsonPool_t* pool ) {
jsonStaticPool_t *spool = json_containerOf( pool, jsonStaticPool_t, pool );
spool->nextFree = 1;
return spool->mem;
}
/** Create an instance of a json from a pool.
* @param pool The handler of the pool.
* @retval The handler of the new instance if success.
* @retval Null pointer if the pool was empty. */
static json_t* poolAlloc( jsonPool_t* pool ) {
jsonStaticPool_t *spool = json_containerOf( pool, jsonStaticPool_t, pool );
if ( spool->nextFree >= spool->qty ) return 0;
return spool->mem + spool->nextFree++;
}
/** Checks whether an character belongs to set.
* @param ch Character value to be checked.
* @param set Set of characters. It is just a null-terminated string.
* @return true or false there is membership or not. */
static bool isOneOfThem( char ch, char const* set ) {
while( *set != '\0' )
if ( ch == *set++ )
return true;
return false;
}
/** Increases a pointer while it points to a character that belongs to a set.
* @param str The initial pointer value.
* @param set Set of characters. It is just a null-terminated string.
* @return The final pointer value or null pointer if the null character was found. */
static char* goWhile( char* str, char const* set ) {
for(; *str != '\0'; ++str ) {
if ( !isOneOfThem( *str, set ) )
return str;
}
return 0;
}
/** Set of characters that defines a blank. */
static char const* const blank = " \n\r\t\f";
/** Increases a pointer while it points to a white space character.
* @param str The initial pointer value.
* @return The final pointer value or null pointer if the null character was found. */
static char* goBlank( char* str ) {
return goWhile( str, blank );
}
/** Increases a pointer while it points to a decimal digit character.
* @param str The initial pointer value.
* @return The final pointer value or null pointer if the null character was found. */
static char* goNum( char* str ) {
for( ; *str != '\0'; ++str ) {
if ( !isdigit( (int)(*str) ) )
return str;
}
return 0;
}
/** Set of characters that defines the end of an array or a JSON object. */
static char const* const endofblock = "}]";
/** Set a char to '\0' and increase its pointer if the char is different to '}' or ']'.
* @param ch Pointer to character.
* @return Final value pointer. */
static char* setToNull( char* ch ) {
if ( !isOneOfThem( *ch, endofblock ) ) *ch++ = '\0';
return ch;
}
/** Indicate if a character is the end of a primitive value. */
static bool isEndOfPrimitive( char ch ) {
return ch == ',' || isOneOfThem( ch, blank ) || isOneOfThem( ch, endofblock );
}

10
modular.json Normal file
View File

@ -0,0 +1,10 @@
{
"cmake": {
"inc_dirs": [
"Inc"
],
"srcs": [
"Src/**.c"
]
}
}