Пример #1
0
static PyObject *
_internal_load_ucl (char *uclstr)
{
	PyObject *ret;
	struct ucl_parser *parser = ucl_parser_new (UCL_PARSER_NO_TIME);
	bool r = ucl_parser_add_string(parser, uclstr, 0);

	if (r) {
		if (ucl_parser_get_error (parser)) {
			PyErr_SetString(PyExc_ValueError, ucl_parser_get_error(parser));
			ucl_parser_free(parser);
			ret = NULL;
			goto return_with_parser;
		} else {
			ucl_object_t *uclobj = ucl_parser_get_object(parser);
			ret = _iterate_valid_ucl(uclobj);
			ucl_object_unref(uclobj);
			goto return_with_parser;
		}
	}
	else {
		PyErr_SetString(PyExc_ValueError, ucl_parser_get_error (parser));
		ret = NULL;
		goto return_with_parser;
	}

return_with_parser:
	ucl_parser_free(parser);
	return ret;
}
Пример #2
0
int
main (int argc, char **argv)
{
    char inbuf[8192], *test_in = NULL;
    struct ucl_parser *parser = NULL, *parser2 = NULL;
    ucl_object_t *obj;
    FILE *in, *out;
    unsigned char *emitted = NULL;
    const char *fname_in = NULL, *fname_out = NULL;
    int ret = 0, inlen, opt, json = 0, compact = 0, yaml = 0;

    while ((opt = getopt(argc, argv, "jcy")) != -1) {
        switch (opt) {
        case 'j':
            json = 1;
            break;
        case 'c':
            compact = 1;
            break;
        case 'y':
            yaml = 1;
            break;
        default: /* '?' */
            fprintf (stderr, "Usage: %s [-jcy] [in] [out]\n",
                     argv[0]);
            exit (EXIT_FAILURE);
        }
    }

    argc -= optind;
    argv += optind;

    switch (argc) {
    case 1:
        fname_in = argv[0];
        break;
    case 2:
        fname_in = argv[0];
        fname_out = argv[1];
        break;
    }

    if (fname_in != NULL) {
        in = fopen (fname_in, "r");
        if (in == NULL) {
            exit (-errno);
        }
    }
    else {
        in = stdin;
    }
    parser = ucl_parser_new (UCL_PARSER_KEY_LOWERCASE);
    ucl_parser_register_variable (parser, "ABI", "unknown");

    if (fname_in != NULL) {
        ucl_parser_set_filevars (parser, fname_in, true);
    }

    while (!feof (in)) {
        memset (inbuf, 0, sizeof (inbuf));
        if (fread (inbuf, 1, sizeof (inbuf) - 1, in) == 0) {
            break;
        }
        inlen = strlen (inbuf);
        test_in = malloc (inlen);
        memcpy (test_in, inbuf, inlen);
        ucl_parser_add_chunk (parser, test_in, inlen);
    }
    fclose (in);

    if (fname_out != NULL) {
        out = fopen (fname_out, "w");
        if (out == NULL) {
            exit (-errno);
        }
    }
    else {
        out = stdout;
    }
    if (ucl_parser_get_error (parser) != NULL) {
        fprintf (out, "Error occurred: %s\n", ucl_parser_get_error(parser));
        ret = 1;
        goto end;
    }
    obj = ucl_parser_get_object (parser);
    if (json) {
        if (compact) {
            emitted = ucl_object_emit (obj, UCL_EMIT_JSON_COMPACT);
        }
        else {
            emitted = ucl_object_emit (obj, UCL_EMIT_JSON);
        }
    }
    else if (yaml) {
        emitted = ucl_object_emit (obj, UCL_EMIT_YAML);
    }
    else {
        emitted = ucl_object_emit (obj, UCL_EMIT_CONFIG);
    }
    ucl_parser_free (parser);
    ucl_object_unref (obj);
    parser2 = ucl_parser_new (UCL_PARSER_KEY_LOWERCASE);
    ucl_parser_add_string (parser2, emitted, 0);

    if (ucl_parser_get_error(parser2) != NULL) {
        fprintf (out, "Error occurred: %s\n", ucl_parser_get_error(parser2));
        fprintf (out, "%s\n", emitted);
        ret = 1;
        goto end;
    }
    if (emitted != NULL) {
        free (emitted);
    }
    obj = ucl_parser_get_object (parser2);
    if (json) {
        if (compact) {
            emitted = ucl_object_emit (obj, UCL_EMIT_JSON_COMPACT);
        }
        else {
            emitted = ucl_object_emit (obj, UCL_EMIT_JSON);
        }
    }
    else if (yaml) {
        emitted = ucl_object_emit (obj, UCL_EMIT_YAML);
    }
    else {
        emitted = ucl_object_emit (obj, UCL_EMIT_CONFIG);
    }

    fprintf (out, "%s\n", emitted);
    ucl_object_unref (obj);

end:
    if (emitted != NULL) {
        free (emitted);
    }
    if (parser2 != NULL) {
        ucl_parser_free (parser2);
    }
    if (test_in != NULL) {
        free (test_in);
    }

    fclose (out);

    return ret;
}