static json_t *parse_value(stream_t *stream, size_t flags, json_error_t *error)
{
json_t *result = NULL;
char *string;
int c = stream_peek(stream);
switch (c) {
case 'd':
result = parse_dict(stream, flags, error);
break;
case 'l':
result = parse_list(stream, flags, error);
break;
case 'i':
stream_getc(stream);
result = parse_integer(stream, flags, error);
break;
case EOF:
error_set(error, stream, "unexpected EOF");
break;
default:
if (json_isdigit(c)) {
string = parse_string(stream, flags, error);
if (string) {
result = json_string_nocheck(string);
jsonp_free(string);
}
} else {
error_set(error, stream, "invalid character: %c", c);
}
}
return result;
}
/**
* \brief parse the root node of the playlist
*/
static bool parse_plist_node( demux_t *p_demux, input_item_node_t *p_input_node,
track_elem_t *p_track, xml_reader_t *p_xml_reader,
const char *psz_element,
xml_elem_hnd_t *p_handlers )
{
VLC_UNUSED(p_track); VLC_UNUSED(psz_element);
const char *attr, *value;
bool b_version_found = false;
/* read all playlist attributes */
while( (attr = xml_ReaderNextAttr( p_xml_reader, &value )) != NULL )
{
/* attribute: version */
if( !strcmp( attr, "version" ) )
{
b_version_found = true;
if( strcmp( value, "1.0" ) )
msg_Warn( p_demux, "unsupported iTunes Media Library version" );
}
/* unknown attribute */
else
msg_Warn( p_demux, "invalid <plist> attribute:\"%s\"", attr );
}
/* attribute version is mandatory !!! */
if( !b_version_found )
msg_Warn( p_demux, "<plist> requires \"version\" attribute" );
return parse_dict( p_demux, p_input_node, NULL, p_xml_reader,
"plist", p_handlers );
}
int main()
{
parse_ifo_file();
parse_idx();
parse_dict();
return 0;
}
static heim_object_t
parse_value(struct parse_ctx *ctx)
{
size_t len;
heim_object_t o;
if (white_spaces(ctx))
return NULL;
if (*ctx->p == '"') {
return parse_string(ctx);
} else if (*ctx->p == '{') {
if (ctx->depth-- == 1) {
ctx->error = heim_error_create(EINVAL, "JSON object too deep");
return NULL;
}
o = parse_dict(ctx);
ctx->depth++;
return o;
} else if (*ctx->p == '[') {
if (ctx->depth-- == 1) {
ctx->error = heim_error_create(EINVAL, "JSON object too deep");
return NULL;
}
o = parse_array(ctx);
ctx->depth++;
return o;
} else if (is_number(*ctx->p) || *ctx->p == '-') {
return parse_number(ctx);
}
len = ctx->pend - ctx->p;
if ((ctx->flags & HEIM_JSON_F_NO_C_NULL) == 0 &&
len >= 6 && memcmp(ctx->p, "<NULL>", 6) == 0) {
ctx->p += 6;
return heim_null_create();
} else if (len >= 4 && memcmp(ctx->p, "null", 4) == 0) {
ctx->p += 4;
return heim_null_create();
} else if (len >= 4 && strncasecmp((char *)ctx->p, "true", 4) == 0) {
ctx->p += 4;
return heim_bool_create(1);
} else if (len >= 5 && strncasecmp((char *)ctx->p, "false", 5) == 0) {
ctx->p += 5;
return heim_bool_create(0);
}
ctx->error = heim_error_create(EINVAL, "unknown char %c at %lu line %lu",
(char)*ctx->p,
(unsigned long)(ctx->p - ctx->pstart),
ctx->lineno);
return NULL;
}
static bool parse_track_dict( demux_t *p_demux, input_item_node_t *p_input_node,
track_elem_t *p_track, xml_reader_t *p_xml_reader,
const char *psz_element,
xml_elem_hnd_t *p_handlers )
{
VLC_UNUSED(psz_element); VLC_UNUSED(p_handlers);
input_item_t *p_new_input = NULL;
int i_ret;
p_track = new_track();
xml_elem_hnd_t track_elements[] =
// sunqueen modify start
// { {"array", COMPLEX_CONTENT, {.cmplx = skip_element} },
// {"key", SIMPLE_CONTENT, {.smpl = save_data} },
// {"integer", SIMPLE_CONTENT, {.smpl = save_data} },
// {"string", SIMPLE_CONTENT, {.smpl = save_data} },
// {"date", SIMPLE_CONTENT, {.smpl = save_data} },
{ {"array", COMPLEX_CONTENT, {(bool (__cdecl *)(track_elem_t *,const char *,char *))skip_element} },
{"key", SIMPLE_CONTENT, {save_data} },
{"integer", SIMPLE_CONTENT, {save_data} },
{"string", SIMPLE_CONTENT, {save_data} },
{"date", SIMPLE_CONTENT, {save_data} },
// sunqueen modify end
{"true", SIMPLE_CONTENT, {NULL} },
{"false", SIMPLE_CONTENT, {NULL} },
{NULL, UNKNOWN_CONTENT, {NULL} }
};
i_ret = parse_dict( p_demux, p_input_node, p_track,
p_xml_reader, "dict", track_elements );
msg_Dbg( p_demux, "name: %s, artist: %s, album: %s, genre: %s, trackNum: %s, location: %s",
p_track->name, p_track->artist, p_track->album, p_track->genre, p_track->trackNum, p_track->location );
if( !p_track->location )
{
msg_Err( p_demux, "Track needs Location" );
free_track( p_track );
return false;
}
msg_Info( p_demux, "Adding '%s'", p_track->location );
p_new_input = input_item_New( p_track->location, NULL );
input_item_node_AppendItem( p_input_node, p_new_input );
/* add meta info */
add_meta( p_new_input, p_track );
vlc_gc_decref( p_new_input );
p_demux->p_sys->i_ntracks++;
free_track( p_track );
return i_ret;
}
bool AgentMCTS::Node::from_s(std::string s) {
auto dict = parse_dict(s, ", ", " ");
if(dict.size() == 8){
move = Move(dict["move"]);
exp = ExpPair(dict["exp"]);
know = from_str<int>(dict["know"]);
outcome = Outcome(from_str<int>(dict["outcome"]));
proofdepth = from_str<int>(dict["depth"]);
bestmove = Move(dict["best"]);
// ignore children
return true;
}
return false;
}
struct hdp_application *hdp_get_app_config(DBusMessageIter *iter, GError **err)
{
struct hdp_application *app;
app = g_new0(struct hdp_application, 1);
app->ref = 1;
if (!parse_dict(dict_parser, iter, err, app))
goto fail;
if (!app->data_type_set || !app->role_set) {
g_set_error(err, HDP_ERROR, HDP_DIC_PARSE_ERROR,
"Mandatory fields aren't set");
goto fail;
}
return app;
fail:
hdp_application_unref(app);
return NULL;
}
static bool parse_tracks_dict( demux_t *p_demux, input_item_node_t *p_input_node,
track_elem_t *p_track, xml_reader_t *p_xml_reader,
const char *psz_element,
xml_elem_hnd_t *p_handlers )
{
VLC_UNUSED(p_track); VLC_UNUSED(psz_element); VLC_UNUSED(p_handlers);
xml_elem_hnd_t tracks_elements[] =
// { {"dict", COMPLEX_CONTENT, {.cmplx = parse_track_dict} },
{ {"dict", COMPLEX_CONTENT, {(bool (__cdecl *)(track_elem_t *,const char *,char *))parse_track_dict} }, // sunqueen modify
{"key", SIMPLE_CONTENT, {NULL} },
{NULL, UNKNOWN_CONTENT, {NULL} }
};
parse_dict( p_demux, p_input_node, NULL, p_xml_reader,
"dict", tracks_elements );
msg_Info( p_demux, "added %i tracks successfully",
p_demux->p_sys->i_ntracks );
return true;
}
pdfout_data *
pdfout_page_labels_get (fz_context *ctx, pdf_document *doc)
{
pdf_obj *trailer = pdf_trailer (ctx, doc);
pdf_obj *labels_obj = pdf_dict_getp (ctx, trailer, "Root/PageLabels");
pdf_obj *array = pdf_dict_gets (ctx, labels_obj, "Nums");
if (array && pdf_is_array (ctx, array) == false)
pdfout_throw (ctx, "Nums is not an array");
int length = pdf_array_len (ctx, array);
pdfout_data *labels = pdfout_data_array_new (ctx);
for (int i = 0; i < length / 2; ++i)
{
pdf_obj *object = pdf_array_get (ctx, array, 2 * i);
if (pdf_is_int (ctx, object) == false)
pdfout_throw (ctx, "key in number tree not an int");
pdfout_data *hash = pdfout_data_hash_new (ctx);
int page = pdf_to_int (ctx, object);
if (page < 0)
pdfout_throw (ctx, "key in number tree is < 0");
push_int_key (ctx, hash, "page", page);
pdf_obj *dict = pdf_array_get (ctx, array, 2 * i + 1);
if (pdf_is_dict (ctx, dict) == false)
pdfout_throw (ctx, "value in number tree not a dict");
parse_dict (ctx, dict, hash);
pdfout_data_array_push (ctx, labels, hash);
}
return labels;
}
static bool parse_plist_dict( demux_t *p_demux, input_item_node_t *p_input_node,
track_elem_t *p_track, xml_reader_t *p_xml_reader,
const char *psz_element,
xml_elem_hnd_t *p_handlers )
{
VLC_UNUSED(p_track); VLC_UNUSED(psz_element); VLC_UNUSED(p_handlers);
xml_elem_hnd_t pl_elements[] =
// { {"dict", COMPLEX_CONTENT, {.cmplx = parse_tracks_dict} },
{ {"dict", COMPLEX_CONTENT, {(bool (__cdecl *)(track_elem_t *,const char *,char *))parse_tracks_dict} }, // sunqueen modify
{"array", SIMPLE_CONTENT, {NULL} },
{"key", SIMPLE_CONTENT, {NULL} },
{"integer", SIMPLE_CONTENT, {NULL} },
{"string", SIMPLE_CONTENT, {NULL} },
{"date", SIMPLE_CONTENT, {NULL} },
{"true", SIMPLE_CONTENT, {NULL} },
{"false", SIMPLE_CONTENT, {NULL} },
{NULL, UNKNOWN_CONTENT, {NULL} }
};
return parse_dict( p_demux, p_input_node, NULL, p_xml_reader,
"dict", pl_elements );
}
static heim_object_t
parse_value(struct parse_ctx *ctx)
{
size_t len;
if (white_spaces(ctx))
return NULL;
if (*ctx->p == '"') {
return parse_string(ctx);
} else if (*ctx->p == '{') {
return parse_dict(ctx);
} else if (*ctx->p == '[') {
return parse_array(ctx);
} else if (is_number(*ctx->p) || *ctx->p == '-') {
return parse_number(ctx);
}
len = ctx->pend - ctx->p;
if (len >= 4 && memcmp(ctx->p, "null", 4) == 0) {
ctx->p += 4;
return heim_null_create();
} else if (len >= 4 && strncasecmp((char *)ctx->p, "true", 4) == 0) {
ctx->p += 4;
return heim_bool_create(1);
} else if (len >= 5 && strncasecmp((char *)ctx->p, "false", 5) == 0) {
ctx->p += 5;
return heim_bool_create(0);
}
ctx->error = heim_error_create(EINVAL, "unknown char %c at %lu line %lu",
(char)*ctx->p,
(unsigned long)(ctx->p - ctx->pstart),
ctx->lineno);
return NULL;
}
