[libyaml.git] / src / api.c


#if HAVE_CONFIG_H
#include <config.h>
#endif

#include <yaml/yaml.h>

#include <assert.h>

/*
 * Allocate a dynamic memory block.
 */

YAML_DECLARE(void *)
yaml_malloc(size_t size)
{
    return malloc(size ? size : 1);
}

/*
 * Reallocate a dynamic memory block.
 */

YAML_DECLARE(void *)
yaml_realloc(void *ptr, size_t size)
{
    return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
}

/*
 * Free a dynamic memory block.
 */

YAML_DECLARE(void)
yaml_free(void *ptr)
{
    if (ptr) free(ptr);
}

/*
 * Create a new parser object.
 */

YAML_DECLARE(yaml_parser_t *)
yaml_parser_new(void)
{
    yaml_parser_t *parser;

    /* Allocate the parser structure. */

    parser = yaml_malloc(sizeof(yaml_parser_t));
    if (!parser) return NULL;

    memset(parser, 0, sizeof(yaml_parser_t));

    /* Allocate the raw buffer. */

    parser->raw_buffer = yaml_malloc(YAML_RAW_BUFFER_SIZE);
    if (!parser->raw_buffer) {
        yaml_free(parser);
        return NULL;
    }
    parser->raw_pointer = parser->raw_buffer;
    parser->raw_unread = 0;

    /* Allocate the character buffer. */

    parser->buffer = yaml_malloc(YAML_BUFFER_SIZE);
    if (!parser->buffer) {
        yaml_free(parser->raw_buffer);
        yaml_free(parser);
        return NULL;
    }
    parser->buffer_end = parser->buffer;
    parser->pointer = parser->buffer;
    parser->unread = 0;

    return parser;
}

/*
 * Destroy a parser object.
 */

YAML_DECLARE(void)
yaml_parser_delete(yaml_parser_t *parser)
{
    assert(parser); /* Non-NULL parser object expected. */

    yaml_free(parser->buffer);
    yaml_free(parser->raw_buffer);

    memset(parser, 0, sizeof(yaml_parser_t));

    yaml_free(parser);
}

/*
 * String read handler.
 */

static int
yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
        size_t *size_read)
{
    yaml_string_input_t *input = data;

    if (input->current == input->end) {
        *size_read = 0;
        return 1;
    }

    if (size > (input->end - input->current)) {
        size = input->end - input->current;
    }

    memcpy(buffer, input->current, size);
    input->current += size;
    *size_read = size;
    return 1;
}

/*
 * File read handler.
 */

static int
yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
        size_t *size_read)
{
    *size_read = fread(buffer, 1, size, (FILE *)data);
    return !ferror((FILE *)data);
}

/*
 * Set a string input.
 */

YAML_DECLARE(void)
yaml_parser_set_input_string(yaml_parser_t *parser,
        unsigned char *input, size_t size)
{
    assert(parser); /* Non-NULL parser object expected. */
    assert(!parser->read_handler);  /* You can set the source only once. */
    assert(input);  /* Non-NULL input string expected. */

    parser->string_input.start = input;
    parser->string_input.current = input;
    parser->string_input.end = input+size;

    parser->read_handler = yaml_string_read_handler;
    parser->read_handler_data = &parser->string_input;
}

/*
 * Set a file input.
 */

YAML_DECLARE(void)
yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
{
    assert(parser); /* Non-NULL parser object expected. */
    assert(!parser->read_handler);  /* You can set the source only once. */
    assert(file);   /* Non-NULL file object expected. */

    parser->read_handler = yaml_file_read_handler;
    parser->read_handler_data = file;
}

/*
 * Set a generic input.
 */

YAML_DECLARE(void)
yaml_parser_set_input(yaml_parser_t *parser,
        yaml_read_handler_t *handler, void *data)
{
    assert(parser); /* Non-NULL parser object expected. */
    assert(!parser->read_handler);  /* You can set the source only once. */
    assert(handler);    /* Non-NULL read handler expected. */

    parser->read_handler = handler;
    parser->read_handler_data = data;
}

/*
 * Set the source encoding.
 */

YAML_DECLARE(void)
yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
{
    assert(parser); /* Non-NULL parser object expected. */
    assert(!parser->encoding); /* Encoding is already set or detected. */

    parser->encoding = encoding;
}

/*
 * Create a token.
 */

YAML_DECLARE(yaml_token_t *)
yaml_token_new(yaml_token_type_t type,
        yaml_mark_t start_mark, yaml_mark_t end_mark)
{
    yaml_token_t *token = yaml_malloc(sizeof(yaml_token_t));

    if (!token) return NULL;

    memset(token, 0, sizeof(yaml_token_t));

    token->type = type;
    token->start_mark = start_mark;
    token->end_mark = end_mark;

    return token;
}

/*
 * Create a STREAM-START token.
 */

YAML_DECLARE(yaml_token_t *)
yaml_stream_start_token(yaml_encoding_t encoding,
        yaml_mark_t start_mark, yaml_mark_t end_mark)
{
    yaml_token_t *token = yaml_token_new(YAML_STREAM_START_TOKEN,
            start_mark, end_mark);

    if (!token) return NULL;

    token->data.encoding = encoding;

    return token;
}

/*
 * Create a STREAM-END token.
 */

YAML_DECLARE(yaml_token_t *)
yaml_stream_end_token(yaml_mark_t start_mark, yaml_mark_t end_mark)
{
    yaml_token_t *token = yaml_token_new(YAML_STREAM_END_TOKEN,
            start_mark, end_mark);

    if (!token) return NULL;

    return token;
}

/*
 * Create a VERSION-DIRECTIVE token.
 */

YAML_DECLARE(yaml_token_t *)
yaml_version_directive_token_new(int major, int minor,
        yaml_mark_t start_mark, yaml_mark_t end_mark)
{
    yaml_token_t *token = yaml_token_new(YAML_VERSION_DIRECTIVE_TOKEN,
            start_mark, end_mark);

    if (!token) return NULL;

    token->data.version_directive.major = major;
    token->data.version_directive.minor = minor;

    return token;
}

/*
 * Create a TAG-DIRECTIVE token.
 */

YAML_DECLARE(yaml_token_t *)
yaml_tag_directive_token_new(yaml_char_t *handle, yaml_char_t *prefix,
        yaml_mark_t start_mark, yaml_mark_t end_mark)
{
    yaml_token_t *token = yaml_token_new(YAML_TAG_DIRECTIVE_TOKEN,
            start_mark, end_mark);

    if (!token) return NULL;

    token->data.tag_directive.handle = handle;
    token->data.tag_directive.prefix = prefix;

    return token;
}

/*
 * Create an ALIAS token.
 */

YAML_DECLARE(yaml_token_t *)
yaml_alias_token_new(yaml_char_t *anchor,
        yaml_mark_t start_mark, yaml_mark_t end_mark)
{
    yaml_token_t *token = yaml_token_new(YAML_ALIAS_TOKEN,
            start_mark, end_mark);

    if (!token) return NULL;

    token->data.anchor = anchor;

    return token;
}

/*
 * Create an ANCHOR token.
 */

YAML_DECLARE(yaml_token_t *)
yaml_anchor_token_new(yaml_char_t *anchor,
        yaml_mark_t start_mark, yaml_mark_t end_mark)
{
    yaml_token_t *token = yaml_token_new(YAML_ANCHOR_TOKEN,
            start_mark, end_mark);

    if (!token) return NULL;

    token->data.anchor = anchor;

    return token;
}

/*
 * Create a TAG token.
 */

YAML_DECLARE(yaml_token_t *)
yaml_tag_token_new(yaml_char_t *handle, yaml_char_t *suffix,
        yaml_mark_t start_mark, yaml_mark_t end_mark)
{
    yaml_token_t *token = yaml_token_new(YAML_TAG_TOKEN,
            start_mark, end_mark);

    if (!token) return NULL;

    token->data.tag.handle = handle;
    token->data.tag.suffix = suffix;

    return token;
}

/*
 * Create a SCALAR token.
 */

YAML_DECLARE(yaml_token_t *)
yaml_scalar_token_new(yaml_char_t *value, size_t length,
        yaml_scalar_style_t style,
        yaml_mark_t start_mark, yaml_mark_t end_mark)
{
    yaml_token_t *token = yaml_token_new(YAML_SCALAR_TOKEN,
            start_mark, end_mark);

    if (!token) return NULL;

    token->data.scalar.value = value;
    token->data.scalar.length = length;
    token->data.scalar.style = style;

    return token;
}

/*
 * Destroy a token object.
 */

YAML_DECLARE(void)
yaml_token_delete(yaml_token_t *token)
{
    assert(token);  /* Non-NULL token object expected. */

    switch (token->type)
    {
        case YAML_TAG_DIRECTIVE_TOKEN:
            yaml_free(token->data.tag_directive.handle);
            yaml_free(token->data.tag_directive.prefix);
            break;

        case YAML_ALIAS_TOKEN:
        case YAML_ANCHOR_TOKEN:
            yaml_free(token->data.anchor);
            break;

        case YAML_TAG_TOKEN:
            yaml_free(token->data.tag.handle);
            yaml_free(token->data.tag.suffix);
            break;

        case YAML_SCALAR_TOKEN:
            yaml_free(token->data.scalar.value);
            break;
    }

    memset(token, 0, sizeof(yaml_token_t));

    yaml_free(token);
}
Commit	Line	Data
a51447c9 KS	1
	2	#if HAVE_CONFIG_H
	3	#include <config.h>
	4	#endif
	5
	6	#include <yaml/yaml.h>
	7
95b98ba9 KS	8	#include <assert.h>
	9
	10	/*
	11	* Allocate a dynamic memory block.
	12	*/
	13
f642fd11	14	YAML_DECLARE(void *)
95b98ba9 KS	15	yaml_malloc(size_t size)
	16	{
	17	return malloc(size ? size : 1);
	18	}
	19
	20	/*
	21	* Reallocate a dynamic memory block.
	22	*/
	23
f642fd11	24	YAML_DECLARE(void *)
95b98ba9 KS	25	yaml_realloc(void *ptr, size_t size)
	26	{
	27	return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
	28	}
	29
a51447c9	30	/*
95b98ba9 KS	31	* Free a dynamic memory block.
	32	*/
	33
f642fd11	34	YAML_DECLARE(void)
95b98ba9 KS	35	yaml_free(void *ptr)
	36	{
	37	if (ptr) free(ptr);
	38	}
	39
	40	/*
	41	* Create a new parser object.
a51447c9 KS	42	*/
a51447c9 KS	43
f642fd11	44	YAML_DECLARE(yaml_parser_t *)
a51447c9 KS	45	yaml_parser_new(void)
	46	{
	47	yaml_parser_t *parser;
	48
6eb1ded4 KS	49	/* Allocate the parser structure. */
6eb1ded4 KS	50
95b98ba9	51	parser = yaml_malloc(sizeof(yaml_parser_t));
a51447c9 KS	52	if (!parser) return NULL;
	53
	54	memset(parser, 0, sizeof(yaml_parser_t));
	55
6eb1ded4 KS	56	/* Allocate the raw buffer. */
	57
	58	parser->raw_buffer = yaml_malloc(YAML_RAW_BUFFER_SIZE);
	59	if (!parser->raw_buffer) {
	60	yaml_free(parser);
	61	return NULL;
	62	}
	63	parser->raw_pointer = parser->raw_buffer;
	64	parser->raw_unread = 0;
	65
	66	/* Allocate the character buffer. */
	67
	68	parser->buffer = yaml_malloc(YAML_BUFFER_SIZE);
	69	if (!parser->buffer) {
	70	yaml_free(parser->raw_buffer);
	71	yaml_free(parser);
	72	return NULL;
	73	}
	74	parser->buffer_end = parser->buffer;
	75	parser->pointer = parser->buffer;
	76	parser->unread = 0;
	77
a51447c9 KS	78	return parser;
	79	}
	80
	81	/*
	82	* Destroy a parser object.
	83	*/
	84
f642fd11	85	YAML_DECLARE(void)
a51447c9 KS	86	yaml_parser_delete(yaml_parser_t *parser)
a51447c9 KS	87	{
95b98ba9 KS	88	assert(parser); /* Non-NULL parser object expected. */
	89
	90	yaml_free(parser->buffer);
6eb1ded4	91	yaml_free(parser->raw_buffer);
95b98ba9 KS	92
	93	memset(parser, 0, sizeof(yaml_parser_t));
	94
	95	yaml_free(parser);
	96	}
	97
	98	/*
6eb1ded4	99	* String read handler.
95b98ba9 KS	100	*/
	101
	102	static int
	103	yaml_string_read_handler(void data, unsigned char buffer, size_t size,
	104	size_t *size_read)
	105	{
6eb1ded4 KS	106	yaml_string_input_t *input = data;
	107
	108	if (input->current == input->end) {
	109	*size_read = 0;
	110	return 1;
	111	}
	112
	113	if (size > (input->end - input->current)) {
	114	size = input->end - input->current;
	115	}
	116
	117	memcpy(buffer, input->current, size);
	118	input->current += size;
	119	*size_read = size;
95b98ba9 KS	120	return 1;
	121	}
	122
	123	/*
	124	* File read handler.
	125	*/
	126
	127	static int
	128	yaml_file_read_handler(void data, unsigned char buffer, size_t size,
	129	size_t *size_read)
	130	{
6eb1ded4 KS	131	size_read = fread(buffer, 1, size, (FILE )data);
6eb1ded4 KS	132	return !ferror((FILE *)data);
95b98ba9 KS	133	}
	134
	135	/*
	136	* Set a string input.
	137	*/
	138
f642fd11	139	YAML_DECLARE(void)
95b98ba9 KS	140	yaml_parser_set_input_string(yaml_parser_t *parser,
	141	unsigned char *input, size_t size)
	142	{
	143	assert(parser); /* Non-NULL parser object expected. */
6eb1ded4	144	assert(!parser->read_handler); /* You can set the source only once. */
95b98ba9 KS	145	assert(input); /* Non-NULL input string expected. */
95b98ba9 KS	146
6eb1ded4 KS	147	parser->string_input.start = input;
	148	parser->string_input.current = input;
	149	parser->string_input.end = input+size;
95b98ba9	150
6eb1ded4 KS	151	parser->read_handler = yaml_string_read_handler;
6eb1ded4 KS	152	parser->read_handler_data = &parser->string_input;
95b98ba9 KS	153	}
	154
	155	/*
	156	* Set a file input.
	157	*/
	158
f642fd11	159	YAML_DECLARE(void)
95b98ba9 KS	160	yaml_parser_set_input_file(yaml_parser_t parser, FILE file)
	161	{
	162	assert(parser); /* Non-NULL parser object expected. */
6eb1ded4	163	assert(!parser->read_handler); /* You can set the source only once. */
95b98ba9 KS	164	assert(file); /* Non-NULL file object expected. */
	165
	166	parser->read_handler = yaml_file_read_handler;
	167	parser->read_handler_data = file;
	168	}
	169
	170	/*
	171	* Set a generic input.
	172	*/
	173
f642fd11	174	YAML_DECLARE(void)
95b98ba9 KS	175	yaml_parser_set_input(yaml_parser_t *parser,
	176	yaml_read_handler_t handler, void data)
	177	{
	178	assert(parser); /* Non-NULL parser object expected. */
6eb1ded4	179	assert(!parser->read_handler); /* You can set the source only once. */
95b98ba9 KS	180	assert(handler); /* Non-NULL read handler expected. */
	181
	182	parser->read_handler = handler;
6eb1ded4	183	parser->read_handler_data = data;
95b98ba9 KS	184	}
	185
	186	/*
	187	* Set the source encoding.
	188	*/
	189
f642fd11	190	YAML_DECLARE(void)
95b98ba9 KS	191	yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
	192	{
	193	assert(parser); /* Non-NULL parser object expected. */
	194	assert(!parser->encoding); /* Encoding is already set or detected. */
	195
	196	parser->encoding = encoding;
a51447c9 KS	197	}
a51447c9 KS	198
f642fd11 KS	199	/*
	200	* Create a token.
	201	*/
	202
	203	YAML_DECLARE(yaml_token_t *)
	204	yaml_token_new(yaml_token_type_t type,
	205	yaml_mark_t start_mark, yaml_mark_t end_mark)
	206	{
	207	yaml_token_t *token = yaml_malloc(sizeof(yaml_token_t));
	208
	209	if (!token) return NULL;
	210
	211	memset(token, 0, sizeof(yaml_token_t));
	212
	213	token->type = type;
	214	token->start_mark = start_mark;
	215	token->end_mark = end_mark;
	216
	217	return token;
	218	}
	219
	220	/*
	221	* Create a STREAM-START token.
	222	*/
	223
	224	YAML_DECLARE(yaml_token_t *)
	225	yaml_stream_start_token(yaml_encoding_t encoding,
	226	yaml_mark_t start_mark, yaml_mark_t end_mark)
	227	{
	228	yaml_token_t *token = yaml_token_new(YAML_STREAM_START_TOKEN,
	229	start_mark, end_mark);
	230
	231	if (!token) return NULL;
	232
	233	token->data.encoding = encoding;
	234
	235	return token;
	236	}
	237
	238	/*
	239	* Create a STREAM-END token.
	240	*/
	241
	242	YAML_DECLARE(yaml_token_t *)
	243	yaml_stream_end_token(yaml_mark_t start_mark, yaml_mark_t end_mark)
	244	{
	245	yaml_token_t *token = yaml_token_new(YAML_STREAM_END_TOKEN,
	246	start_mark, end_mark);
	247
	248	if (!token) return NULL;
	249
	250	return token;
	251	}
	252
	253	/*
	254	* Create a VERSION-DIRECTIVE token.
	255	*/
	256
	257	YAML_DECLARE(yaml_token_t *)
	258	yaml_version_directive_token_new(int major, int minor,
	259	yaml_mark_t start_mark, yaml_mark_t end_mark)
	260	{
	261	yaml_token_t *token = yaml_token_new(YAML_VERSION_DIRECTIVE_TOKEN,
	262	start_mark, end_mark);
263
264	if (!token) return NULL;
265
266	token->data.version_directive.major = major;
267	token->data.version_directive.minor = minor;
268
269	return token;
270	}
271
272	/*
273	* Create a TAG-DIRECTIVE token.
274	*/
275
276	YAML_DECLARE(yaml_token_t *)
277	yaml_tag_directive_token_new(yaml_char_t handle, yaml_char_t prefix,
278	yaml_mark_t start_mark, yaml_mark_t end_mark)
279	{
280	yaml_token_t *token = yaml_token_new(YAML_TAG_DIRECTIVE_TOKEN,
281	start_mark, end_mark);
282
283	if (!token) return NULL;
284
285	token->data.tag_directive.handle = handle;
286	token->data.tag_directive.prefix = prefix;
287
288	return token;
289	}
290
291	/*
292	* Create an ALIAS token.
293	*/
294
295	YAML_DECLARE(yaml_token_t *)
296	yaml_alias_token_new(yaml_char_t *anchor,
297	yaml_mark_t start_mark, yaml_mark_t end_mark)
298	{
299	yaml_token_t *token = yaml_token_new(YAML_ALIAS_TOKEN,
300	start_mark, end_mark);
301
302	if (!token) return NULL;
303
304	token->data.anchor = anchor;
305
306	return token;
307	}
308
309	/*
310	* Create an ANCHOR token.
311	*/
312
313	YAML_DECLARE(yaml_token_t *)
314	yaml_anchor_token_new(yaml_char_t *anchor,
315	yaml_mark_t start_mark, yaml_mark_t end_mark)
316	{
317	yaml_token_t *token = yaml_token_new(YAML_ANCHOR_TOKEN,
318	start_mark, end_mark);
319
320	if (!token) return NULL;
321
322	token->data.anchor = anchor;
323
324	return token;
325	}
326
327	/*
328	* Create a TAG token.
329	*/
330
331	YAML_DECLARE(yaml_token_t *)
332	yaml_tag_token_new(yaml_char_t handle, yaml_char_t suffix,
333	yaml_mark_t start_mark, yaml_mark_t end_mark)
334	{
335	yaml_token_t *token = yaml_token_new(YAML_TAG_TOKEN,
336	start_mark, end_mark);
337
338	if (!token) return NULL;
339
340	token->data.tag.handle = handle;
341	token->data.tag.suffix = suffix;
342
343	return token;
344	}
345
346	/*
347	* Create a SCALAR token.
348	*/
349
350	YAML_DECLARE(yaml_token_t *)
351	yaml_scalar_token_new(yaml_char_t *value, size_t length,
352	yaml_scalar_style_t style,
353	yaml_mark_t start_mark, yaml_mark_t end_mark)
354	{
355	yaml_token_t *token = yaml_token_new(YAML_SCALAR_TOKEN,
356	start_mark, end_mark);
357
358	if (!token) return NULL;
359
360	token->data.scalar.value = value;
361	token->data.scalar.length = length;
362	token->data.scalar.style = style;
363
364	return token;
365	}
366
367	/*
368	* Destroy a token object.
369	*/
370
371	YAML_DECLARE(void)
372	yaml_token_delete(yaml_token_t *token)
373	{
374	assert(token); /* Non-NULL token object expected. */
375
376	switch (token->type)
377	{
378	case YAML_TAG_DIRECTIVE_TOKEN:
379	yaml_free(token->data.tag_directive.handle);
380	yaml_free(token->data.tag_directive.prefix);
381	break;
382
383	case YAML_ALIAS_TOKEN:
384	case YAML_ANCHOR_TOKEN:
385	yaml_free(token->data.anchor);
386	break;
387
388	case YAML_TAG_TOKEN:
389	yaml_free(token->data.tag.handle);
390	yaml_free(token->data.tag.suffix);
391	break;
392
393	case YAML_SCALAR_TOKEN:
394	yaml_free(token->data.scalar.value);
395	break;
396	}
397
398	memset(token, 0, sizeof(yaml_token_t));
399
400	yaml_free(token);
401	}
402