// Dump data with pointers
static void
_rdumpData (FILE* file, Obj* obj, int indent)
{
Data* data = (Data*)obj;
fprintf (file, "Data\n");
indent_fprintf (indent, file, "{ tag = 0x%06x\n", _getObjTag (obj));
indent_fprintf (indent, file, ", arity = %d\n", data ->arity);
for (uint32_t i = 0; i < data->arity; i++) {
indent_fprintf (indent, file, ", a[%2d] = ", i);
_rdumpObj (file, data->a[i], indent + 14);
}
indent_fprintf (indent, file, "}\n");
}
// Dump mixed pointer / non-pointer data
static void
_rdumpDataM (FILE* file, Obj* obj, int indent)
{
DataM* data = (DataM*)obj;
fprintf (file, "DataM\n");
indent_fprintf (indent, file, " { tag = 0x%06x\n", _getObjTag (obj));
indent_fprintf (indent, file, " , size = %d\n", data ->size);
indent_fprintf (indent, file, " , ptrCount = %d\n", data ->ptrCount);
// print out obj pointers.
Obj** payloadObj = (Obj**) &(data ->payload);
for (uint32_t i = 0; i < data ->ptrCount; i++)
fprintf (file, " , a[%2d] = %p\n", i, payloadObj[i]);
fprintf (file, " }\n");
}
// Dump small raw data
static void
_rdumpDataRS (FILE* file, Obj* obj, int indent)
{
DataRS* data = (DataRS*)obj;
fprintf (file, "DataRS\n");
indent_fprintf (indent, file, " { tag = 0x%06x\n", _getObjTag (obj));
indent_fprintf (indent, file, " , payload = [");
size_t payloadSize
= _getObjArg (obj) * 4;
for (uint32_t i = 0; i < payloadSize; i++)
fprintf (file, " %02x", data ->payload[i]);
fprintf (file, " ]\n");
indent_fprintf (indent, file, " }\n");
}
// Dupm a suspension
static void
_rdumpSusp (FILE* file, Obj* obj, int indent)
{
SuspIndir* susp = (SuspIndir*)obj;
fprintf (file, "Susp\n");
indent_fprintf (indent, file, " { tag = 0x%06x (%s)\n"
, _getObjTag (obj)
, (_getObjTag (obj) == _tagSusp) ? "susp" : "indir");
indent_fprintf (indent, file, " , obj = ");
_rdumpObj (file, susp->obj, indent + 14);
indent_fprintf (indent, file, " , airity = %d\n", susp ->arity);
for (uint32_t i = 0; i < susp->arity; i++) {
indent_fprintf (indent, file, " , a[%2d] = ", i);
_rdumpObj (file, susp->a[i], indent + 14);
}
indent_fprintf (indent, file, " }\n");
}
// Dump a thunk
static void
_rdumpThunk (FILE* file, Obj* obj, int indent)
{
Thunk* thunk = (Thunk*)obj;
fprintf (file, "Thunk\n");
indent_fprintf (indent, file, " { tag = 0x%06x\n", _getObjTag (obj));
indent_fprintf (indent, file, " , flags = 0x%02x\n", _getObjFlags (obj));
indent_fprintf (indent, file, " , func = %p\n", thunk ->func);
indent_fprintf (indent, file, " , arity = %d\n", thunk ->arity);
indent_fprintf (indent, file, " , args = %d\n", thunk ->args);
for (uint32_t i = 0; i < thunk ->args; i++)
indent_fprintf (indent, file, "%*c , a[%2d] = %p\n", i, thunk ->a[i]);
indent_fprintf (indent, file, " }\n");
}
static void
gval_write(FILE *file, GhbValue *gval)
{
static gint indent = 0;
gint ii;
GhbType gtype;
if (gval == NULL) return;
gtype = ghb_value_type(gval);
if (gtype == GHB_ARRAY)
{
GhbValue *val;
gint count;
indent_fprintf(file, indent, "<array>\n");
indent++;
count = ghb_array_len(gval);
for (ii = 0; ii < count; ii++)
{
val = ghb_array_get(gval, ii);
gval_write(file, val);
}
indent--;
indent_fprintf(file, indent, "</array>\n");
}
else if (gtype == GHB_DICT)
{
const char *key;
GhbValue *val;
GhbDictIter iter;
indent_fprintf(file, indent, "<dict>\n");
indent++;
iter = ghb_dict_iter_init(gval);
while (ghb_dict_iter_next(gval, &iter, &key, &val))
{
indent_fprintf(file, indent, "<key>%s</key>\n", key);
gval_write(file, val);
}
indent--;
indent_fprintf(file, indent, "</dict>\n");
}
else if (gtype == GHB_BOOL)
{
gchar *tag;
if (ghb_value_get_bool(gval))
{
tag = "true";
}
else
{
tag = "false";
}
indent_fprintf(file, indent, "<%s />\n", tag);
}
else if (gtype == GHB_DOUBLE)
{
gdouble val = ghb_value_get_double(gval);
indent_fprintf(file, indent, "<real>%.17g</real>\n", val);
}
else if (gtype == GHB_INT)
{
gint64 val = ghb_value_get_int(gval);
indent_fprintf(file, indent, "<integer>%"PRId64"</integer>\n", val);
}
else if (gtype == GHB_STRING)
{
const gchar *str = ghb_value_get_string(gval);
gchar *esc = g_markup_escape_text(str, -1);
indent_fprintf(file, indent, "<string>%s</string>\n", esc);
g_free(esc);
}
else
{
// Try to make anything thats unrecognized into a string
g_warning("Unhandled data type %d", gtype);
}
}
static void
gval_write(FILE *file, GValue *gval)
{
static gint indent = 0;
gint ii;
GType gtype;
if (gval == NULL) return;
gtype = G_VALUE_TYPE(gval);
if (gtype == ghb_array_get_type())
{
GValue *val;
gint count;
indent_fprintf(file, indent, "<array>\n");
indent++;
count = ghb_array_len(gval);
for (ii = 0; ii < count; ii++)
{
val = ghb_array_get_nth(gval, ii);
gval_write(file, val);
}
indent--;
indent_fprintf(file, indent, "</array>\n");
}
else if (gtype == ghb_dict_get_type())
{
GValue *val;
GHashTable *dict = g_value_get_boxed(gval);
GList *link, *keys;
keys = g_hash_table_get_keys(dict);
// Sort the dictionary. Not really necessray, but it makes
// finding things easier
keys = g_list_sort(keys, key_cmp);
link = keys;
indent_fprintf(file, indent, "<dict>\n");
indent++;
while (link)
{
gchar *key = (gchar*)link->data;
val = g_hash_table_lookup(dict, key);
indent_fprintf(file, indent, "<key>%s</key>\n", key);
gval_write(file, val);
link = link->next;
}
indent--;
indent_fprintf(file, indent, "</dict>\n");
g_list_free(keys);
}
else if (gtype == G_TYPE_BOOLEAN)
{
gchar *tag;
if (g_value_get_boolean(gval))
{
tag = "true";
}
else
{
tag = "false";
}
indent_fprintf(file, indent, "<%s />\n", tag);
}
else if (gtype == g_date_get_type())
{
GDate *date;
date = g_value_get_boxed(gval);
indent_fprintf(file, indent, "<date>%d-%d-%d</date>\n",
g_date_get_year(date),
g_date_get_month(date),
g_date_get_day(date)
);
}
else if (gtype == ghb_rawdata_get_type())
{
ghb_rawdata_t *data;
gchar *base64;
data = g_value_get_boxed(gval);
base64 = g_base64_encode(data->data, data->size);
indent_fprintf(file, indent, "<data>\n");
indent_fprintf(file, 0, "%s\n", base64);
indent_fprintf(file, indent, "</data>\n");
g_free(base64);
}
else if (gtype == G_TYPE_DOUBLE)
{
gdouble val = g_value_get_double(gval);
indent_fprintf(file, indent, "<real>%.17g</real>\n", val);
}
else if (gtype == G_TYPE_INT64)
{
gint val = g_value_get_int64(gval);
indent_fprintf(file, indent, "<integer>%d</integer>\n", val);
}
else if (gtype == G_TYPE_INT)
{
gint val = g_value_get_int(gval);
indent_fprintf(file, indent, "<integer>%d</integer>\n", val);
}
else if (gtype == G_TYPE_STRING)
{
const gchar *str = g_value_get_string(gval);
gchar *esc = g_markup_escape_text(str, -1);
indent_fprintf(file, indent, "<string>%s</string>\n", esc);
g_free(esc);
}
else
{
// Try to make anything thats unrecognized into a string
const gchar *str;
GValue val = {0,};
g_value_init(&val, G_TYPE_STRING);
if (g_value_transform(gval, &val))
{
str = g_value_get_string(&val);
gchar *esc = g_markup_escape_text(str, -1);
indent_fprintf(file, indent, "<string>%s</string>\n", esc);
g_free(esc);
}
else
{
g_message("failed to transform");
}
g_value_unset(&val);
}
}
static void
gval_write(FILE *file, hb_value_t *gval)
{
static int indent = 0;
int ii;
hb_value_type_t gtype;
if (gval == NULL) return;
gtype = hb_value_type(gval);
if (gtype == HB_VALUE_TYPE_ARRAY)
{
hb_value_t *val;
int count;
indent_fprintf(file, indent, "<array>\n");
indent++;
count = hb_value_array_len(gval);
for (ii = 0; ii < count; ii++)
{
val = hb_value_array_get(gval, ii);
gval_write(file, val);
}
indent--;
indent_fprintf(file, indent, "</array>\n");
}
else if (gtype == HB_VALUE_TYPE_DICT)
{
const char *key;
hb_value_t *val;
hb_dict_iter_t iter;
indent_fprintf(file, indent, "<dict>\n");
indent++;
for (iter = hb_dict_iter_init(gval);
iter != HB_DICT_ITER_DONE;
iter = hb_dict_iter_next(gval, iter))
{
key = hb_dict_iter_key(iter);
val = hb_dict_iter_value(iter);
indent_fprintf(file, indent, "<key>%s</key>\n", key);
gval_write(file, val);
}
indent--;
indent_fprintf(file, indent, "</dict>\n");
}
else if (gtype == HB_VALUE_TYPE_BOOL)
{
char *tag;
if (hb_value_get_bool(gval))
{
tag = "true";
}
else
{
tag = "false";
}
indent_fprintf(file, indent, "<%s />\n", tag);
}
else if (gtype == HB_VALUE_TYPE_DOUBLE)
{
double val = hb_value_get_double(gval);
indent_fprintf(file, indent, "<real>%.17g</real>\n", val);
}
else if (gtype == HB_VALUE_TYPE_INT)
{
int64_t val = hb_value_get_int(gval);
indent_fprintf(file, indent, "<integer>%"PRId64"</integer>\n", val);
}
else if (gtype == HB_VALUE_TYPE_STRING)
{
const char *str = hb_value_get_string(gval);
char *esc = markup_escape_text(str);
indent_fprintf(file, indent, "<string>%s</string>\n", esc);
free(esc);
}
else
{
// Try to make anything thats unrecognized into a string
hb_error("Unhandled data type %d", gtype);
}
}
