/**
* MR_BITMASK type saving handler. Look up type descriptor and save as
* stringified bitmask value or as integer otherwise.
* @param ptrdes descriptor of the saved field
* @param bitmask_or_delimiter delimiter for OR statement
* @return stringified enum value
*/
char *
mr_stringify_bitmask (mr_ptrdes_t * ptrdes, char * bitmask_or_delimiter)
{
int i, count;
uint64_t value = 0;
char * str = NULL;
mr_td_t * tdp = mr_get_td_by_name (ptrdes->fd.type); /* look up for type descriptor */
/* check whether type descriptor was found */
if (NULL == tdp)
{
MR_MESSAGE (MR_LL_WARN, MR_MESSAGE_NO_TYPE_DESCRIPTOR, ptrdes->fd.type);
return (mr_stringify_uint (ptrdes));
}
if (MR_TYPE_ENUM != tdp->mr_type)
{
MR_MESSAGE (MR_LL_WARN, MR_MESSAGE_TYPE_NOT_ENUM, ptrdes->fd.type);
return (mr_stringify_uint (ptrdes));
}
value = mr_get_enum_value (tdp, ptrdes->data);
if (0 == value)
{
mr_fd_t * fdp = mr_get_enum_by_value (tdp, value);
return (MR_STRDUP (fdp && fdp->name.str ? fdp->name.str : "0"));
}
/* decompose value on bitmask */
count = tdp->fields.size / sizeof (tdp->fields.data[0]);
for (i = 0; i < count; ++i)
{
mr_fd_t * fdp = tdp->fields.data[i].fdp;
if ((value & fdp->param.enum_value) && !(~value & fdp->param.enum_value))
{
if (NULL == str)
str = MR_STRDUP (fdp->name.str);
else
str = mr_decompose_bitmask_add (str, bitmask_or_delimiter, fdp->name.str);
if (NULL == str)
break;
value &= ~fdp->param.enum_value;
}
if (0 == value)
break;
}
if (value != 0)
{
/* save non-matched part as integer */
mr_ptrdes_t ptrdes = { .data = &value, };
char * number = mr_stringify_uint64_t (&ptrdes);
if (number != NULL)
{
str = mr_decompose_bitmask_add (str, bitmask_or_delimiter, number);
MR_FREE (number);
}
MR_MESSAGE (MR_LL_WARN, MR_MESSAGE_SAVE_BITMASK, value);
}
void
mr_object_host_free(mr_object_t object)
{
if (!HAS_GC_HEADER(object)) return;
mr_gc_header_t gc = MR_TO_GC_HEADER(object);
if (gc->gc_status == GC_STATUS_HOST)
{
gc->type->free(gc->type, object);
MR_FREE(gc);
}
}
static char *
mr_decompose_bitmask_add (char * str, char * bitmask_or_delimiter, char * token)
{
char * str_ = MR_REALLOC (str, strlen (str) + strlen (bitmask_or_delimiter) + strlen (token) + 1);
if (NULL == str_)
{
MR_MESSAGE (MR_LL_FATAL, MR_MESSAGE_OUT_OF_MEMORY);
MR_FREE (str);
}
else
{
strcat (str_, bitmask_or_delimiter);
strcat (str_, token);
}
return (str_);
}
/**
* MR_BITMASK type saving handler. Look up type descriptor and save as
* stringified bitmask value or as integer otherwise.
* @param idx an index of node in ptrs
* @param ptrs resizeable array with pointers descriptors
* @return stringified enum value
*/
static char *
scm_save_bitmask (int idx, mr_ra_mr_ptrdes_t * ptrs)
{
char * str = mr_stringify_bitmask (&ptrs->ra.data[idx], MR_SCM_BITMASK_OR_DELIMITER);
if (str)
{
char * str_ = MR_MALLOC ((sizeof (MR_SCM_BITMASK_TEMPLATE) - 1) + (strlen (str) - 2) + 1);
if (NULL == str_)
{
MR_MESSAGE (MR_LL_FATAL, MR_MESSAGE_OUT_OF_MEMORY);
return (NULL);
}
sprintf (str_, MR_SCM_BITMASK_TEMPLATE, str);
MR_FREE (str);
str = str_;
}
return (str);
}
int main ()
{
int x = 1234;
int y = 4321;
int_pointer_t x_ptr = { &x };
int_dbl_pointer_t idp = { &x_ptr, &y };
char * xml = MR_SAVE_XML (int_dbl_pointer_t, &idp);
if (NULL == xml)
printf ("Serialization failed\n");
else
{
printf ("%s", xml);
MR_FREE (xml);
}
return (EXIT_SUCCESS);
}
int main ()
{
char type[] = "example_t";
mr_td_t * td = mr_get_td_by_name (type);
if (NULL == td)
printf ("error: can't obtain type information for type '%s'\n", type);
else
{
char * td_serialized = MR_SAVE_CINIT (mr_td_t, td);
if (NULL == td_serialized)
printf ("error: can't serialize desciptor for type '%s'\n", type);
else
{
printf ("Type desciptor for type '%s' is\n%s\n", type, td_serialized);
MR_FREE (td_serialized);
}
}
return (EXIT_SUCCESS);
}
static void
mr_value_id (mr_value_t * value)
{
if (MR_VT_ID != value->value_type)
return;
value->value_type = MR_VT_INT;
if (NULL == value->vt_string)
value->vt_int = 0;
else
{
mr_fd_t * fdp = mr_get_enum_by_name (value->vt_string);
__typeof__ (value->vt_int) vt_int = 0;
if (NULL == fdp)
MR_MESSAGE (MR_LL_WARN, MR_MESSAGE_UNKNOWN_ENUM, value->vt_string);
else
vt_int = fdp->param.enum_value;
MR_FREE (value->vt_string);
value->vt_int = vt_int;
}
}
int
mr_io_cs_parse_token(mr_io_char_stream_in_f in, void *stream, char **buf, unsigned int *size)
{
int type;
char *token_buf;
unsigned int token_len;
unsigned int token_buf_alloc = 0;
type = -1;
token_buf = NULL;
token_len = 0;
#define EXPAND_TOKEN \
while (token_buf_alloc < token_len) \
{ \
token_buf_alloc = (token_buf_alloc << 1) + 1; \
if (token_buf == NULL) \
token_buf = (char *)MR_MALLOC(sizeof(char) * token_buf_alloc); \
else token_buf = (char *)MR_REALLOC(token_buf, sizeof(char) * token_buf_alloc); \
if (token_buf == NULL) return -1; \
}
while (1)
{
int now = in(stream, MR_IO_CS_IN_PEEK);
if (now < 0)
{
if (token_len > 0)
type = MR_TOKEN_SYMBOL;
else type = MR_TOKEN_EOF;
break;
}
if (MR_CHAR_IS_SEPARATOR(now))
{
while (1)
{
in(stream, MR_IO_CS_IN_ADVANCE);
now = in(stream, MR_IO_CS_IN_PEEK);
if (MR_CHAR_IS_SEPARATOR(now)) continue;
break;
}
if (token_len > 0)
{
type = MR_TOKEN_SYMBOL;
break;
}
else if (now < 0) break;
}
if (now == MR_TOKEN_CHAR_LC || now == MR_TOKEN_CHAR_RC)
{
if (token_len > 0)
{
type = MR_TOKEN_SYMBOL;
break;
}
else
{
in(stream, MR_IO_CS_IN_ADVANCE);
if (now == MR_TOKEN_CHAR_LC)
type = MR_TOKEN_LC;
else type = MR_TOKEN_RC;
break;
}
}
if (now == MR_TOKEN_CHAR_COMMENT)
{
in(stream, MR_IO_CS_IN_ADVANCE);
while (1)
{
now = in(stream, MR_IO_CS_IN_PEEK);
if (now < 0 || MR_CHAR_IS_NEWLINE(now))
{
while (1)
{
now = in(stream, MR_IO_CS_IN_PEEK);
if (now < 0 || !MR_CHAR_IS_NEWLINE(now))
break;
else in(stream, MR_IO_CS_IN_ADVANCE);
}
break;
}
else in(stream, MR_IO_CS_IN_ADVANCE);
}
continue;
}
if (now == MR_TOKEN_CHAR_QUOTE)
{
if (token_len > 0)
{
type = MR_TOKEN_SYMBOL;
break;
}
else
{
in(stream, MR_IO_CS_IN_ADVANCE);
type = MR_TOKEN_STRING;
while (1)
{
now = in(stream, MR_IO_CS_IN_ADVANCE);
if (now < 0 || now == MR_TOKEN_CHAR_QUOTE)
{
break;
}
else if (now == MR_TOKEN_CHAR_ESCAPE)
{
now = in(stream, MR_IO_CS_IN_ADVANCE);
if (now < 0)
{
break;
}
++ token_len;
EXPAND_TOKEN;
switch (now)
{
case 'n':
token_buf[token_len - 1] = '\n';
break;
case 'r':
token_buf[token_len - 1] = '\r';
break;
default:
token_buf[token_len - 1] = now;
break;
}
}
else
{
++ token_len;
EXPAND_TOKEN;
token_buf[token_len - 1] = now;
}
}
break;
}
}
++ token_len;
EXPAND_TOKEN;
token_buf[token_len - 1] = now;
in(stream, MR_IO_CS_IN_ADVANCE);
}
#undef EXPAND_TOKEN
if ((*size = token_len) > 0)
{
*buf = (char *)MR_REALLOC(token_buf, token_len);
}
else if (token_buf != NULL)
MR_FREE(token_buf);
return type;
}
