yaml_string_extend(yaml_char_t **start,
yaml_char_t **pointer, yaml_char_t **end)
{
- yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2);
+ yaml_char_t *new_start = (yaml_char_t *)yaml_realloc((void*)*start, (*end - *start)*2);
if (!new_start) return 0;
YAML_DECLARE(int)
yaml_string_join(
yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
- yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end)
+ yaml_char_t **b_start, yaml_char_t **b_pointer, SHIM(yaml_char_t **b_end))
{
+ UNUSED_PARAM(b_end)
if (*b_start == *b_pointer)
return 1;
goto error;
if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
goto error;
- if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE))
+ if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE, yaml_token_t*))
goto error;
- if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(parser, parser->indents, int*))
goto error;
- if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(parser, parser->simple_keys, yaml_simple_key_t*))
goto error;
- if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(parser, parser->states, yaml_parser_state_t*))
goto error;
- if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(parser, parser->marks, yaml_mark_t*))
goto error;
- if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(parser, parser->tag_directives, yaml_tag_directive_t*))
goto error;
return 1;
yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
size_t *size_read)
{
- yaml_parser_t *parser = data;
+ yaml_parser_t *parser = (yaml_parser_t *)data;
if (parser->input.string.current == parser->input.string.end) {
*size_read = 0;
yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
size_t *size_read)
{
- yaml_parser_t *parser = data;
+ yaml_parser_t *parser = (yaml_parser_t *)data;
*size_read = fread(buffer, 1, size, parser->input.file);
return !ferror(parser->input.file);
goto error;
if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
goto error;
- if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(emitter, emitter->states, yaml_emitter_state_t*))
goto error;
- if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE))
+ if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE, yaml_event_t*))
goto error;
- if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(emitter, emitter->indents, int*))
goto error;
- if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(emitter, emitter->tag_directives, yaml_tag_directive_t*))
goto error;
return 1;
static int
yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
{
- yaml_emitter_t *emitter = data;
+ yaml_emitter_t *emitter = (yaml_emitter_t *)data;
if (emitter->output.string.size - *emitter->output.string.size_written
< size) {
static int
yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
{
- yaml_emitter_t *emitter = data;
+ yaml_emitter_t *emitter = (yaml_emitter_t *)data;
return (fwrite(buffer, 1, size, emitter->output.file) == size);
}
/* Valid tag directives are expected. */
if (version_directive) {
- version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
+ version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
if (!version_directive_copy) goto error;
version_directive_copy->major = version_directive->major;
version_directive_copy->minor = version_directive->minor;
if (tag_directives_start != tag_directives_end) {
yaml_tag_directive_t *tag_directive;
- if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
goto error;
for (tag_directive = tag_directives_start;
tag_directive != tag_directives_end; tag_directive ++) {
}
if (!yaml_check_utf8(value, length)) goto error;
- value_copy = yaml_malloc(length+1);
+ value_copy = YAML_MALLOC(length+1);
if (!value_copy) goto error;
memcpy(value_copy, value, length);
value_copy[length] = '\0';
(tag_directives_start == tag_directives_end));
/* Valid tag directives are expected. */
- if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error;
+ if (!STACK_INIT(&context, nodes, yaml_node_t*)) goto error;
if (version_directive) {
- version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
+ version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
if (!version_directive_copy) goto error;
version_directive_copy->major = version_directive->major;
version_directive_copy->minor = version_directive->minor;
if (tag_directives_start != tag_directives_end) {
yaml_tag_directive_t *tag_directive;
- if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
goto error;
for (tag_directive = tag_directives_start;
tag_directive != tag_directives_end; tag_directive ++) {
}
if (!yaml_check_utf8(value, length)) goto error;
- value_copy = yaml_malloc(length+1);
+ value_copy = YAML_MALLOC(length+1);
if (!value_copy) goto error;
memcpy(value_copy, value, length);
value_copy[length] = '\0';
tag_copy = yaml_strdup(tag);
if (!tag_copy) goto error;
- if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error;
+ if (!STACK_INIT(&context, items, yaml_node_item_t*)) goto error;
SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
style, mark, mark);
tag_copy = yaml_strdup(tag);
if (!tag_copy) goto error;
- if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error;
+ if (!STACK_INIT(&context, pairs, yaml_node_pair_t*)) goto error;
MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
style, mark, mark);
#define ANCHOR_TEMPLATE_LENGTH 16
static yaml_char_t *
-yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id)
+yaml_emitter_generate_anchor(SHIM(yaml_emitter_t *emitter), int anchor_id)
{
- yaml_char_t *anchor = yaml_malloc(ANCHOR_TEMPLATE_LENGTH);
+ yaml_char_t *anchor = YAML_MALLOC(ANCHOR_TEMPLATE_LENGTH);
if (!anchor) return NULL;
*/
static int
-yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event)
+yaml_emitter_emit_alias(yaml_emitter_t *emitter, SHIM(yaml_event_t *event))
{
if (!yaml_emitter_process_anchor(emitter))
return 0;
*/
static int
-yaml_emitter_check_empty_document(yaml_emitter_t *emitter)
+yaml_emitter_check_empty_document(SHIM(yaml_emitter_t *emitter))
{
return 0;
}
assert(document); /* Non-NULL document object is expected. */
memset(document, 0, sizeof(yaml_document_t));
- if (!STACK_INIT(parser, document->nodes, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(parser, document->nodes, yaml_node_t*))
goto error;
if (!parser->stream_start_produced) {
return 1;
}
- if (!STACK_INIT(parser, parser->aliases, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(parser, parser->aliases, yaml_alias_data_t*))
goto error;
parser->document = document;
if (!tag) goto error;
}
- if (!STACK_INIT(parser, items, INITIAL_STACK_SIZE)) goto error;
+ if (!STACK_INIT(parser, items, yaml_node_item_t*)) goto error;
SEQUENCE_NODE_INIT(node, tag, items.start, items.end,
first_event->data.sequence_start.style,
if (!tag) goto error;
}
- if (!STACK_INIT(parser, pairs, INITIAL_STACK_SIZE)) goto error;
+ if (!STACK_INIT(parser, pairs, yaml_node_pair_t*)) goto error;
MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end,
first_event->data.mapping_start.style,
if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {
size_t prefix_len = strlen((char *)tag_directive->prefix);
size_t suffix_len = strlen((char *)tag_suffix);
- tag = yaml_malloc(prefix_len+suffix_len+1);
+ tag = YAML_MALLOC(prefix_len+suffix_len+1);
if (!tag) {
parser->error = YAML_MEMORY_ERROR;
goto error;
return 1;
}
else if (anchor || tag) {
- yaml_char_t *value = yaml_malloc(1);
+ yaml_char_t *value = YAML_MALLOC(1);
if (!value) {
parser->error = YAML_MEMORY_ERROR;
goto error;
else if (token->type == YAML_BLOCK_END_TOKEN)
{
- yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
parser->state = POP(parser, parser->states);
- dummy_mark = POP(parser, parser->marks);
+ (void)POP(parser, parser->marks);
SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
SKIP_TOKEN(parser);
return 1;
else if (token->type == YAML_BLOCK_END_TOKEN)
{
- yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
parser->state = POP(parser, parser->states);
- dummy_mark = POP(parser, parser->marks);
+ (void)POP(parser, parser->marks);
MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
SKIP_TOKEN(parser);
return 1;
yaml_event_t *event, int first)
{
yaml_token_t *token;
- yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
if (first) {
token = PEEK_TOKEN(parser);
}
parser->state = POP(parser, parser->states);
- dummy_mark = POP(parser, parser->marks);
+ (void)POP(parser, parser->marks);
SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
SKIP_TOKEN(parser);
return 1;
yaml_event_t *event, int first)
{
yaml_token_t *token;
- yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
if (first) {
token = PEEK_TOKEN(parser);
}
parser->state = POP(parser, parser->states);
- dummy_mark = POP(parser, parser->marks);
+ (void)POP(parser, parser->marks);
MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
SKIP_TOKEN(parser);
return 1;
{
yaml_char_t *value;
- value = yaml_malloc(1);
+ value = YAML_MALLOC(1);
if (!value) {
parser->error = YAML_MEMORY_ERROR;
return 0;
} tag_directives = { NULL, NULL, NULL };
yaml_token_t *token;
- if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE))
+ if (!STACK_INIT(parser, tag_directives, yaml_tag_directive_t*))
goto error;
token = PEEK_TOKEN(parser);
"found incompatible YAML document", token->start_mark);
goto error;
}
- version_directive = yaml_malloc(sizeof(yaml_version_directive_t));
+ version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t);
if (!version_directive) {
parser->error = YAML_MEMORY_ERROR;
goto error;
static int
yaml_parser_decrease_flow_level(yaml_parser_t *parser)
{
- yaml_simple_key_t dummy_key; /* Used to eliminate a compiler warning. */
-
if (parser->flow_level) {
parser->flow_level --;
- dummy_key = POP(parser, parser->simple_keys);
+ (void)POP(parser, parser->simple_keys);
}
return 1;
{
/* Set the handle to '' */
- handle = yaml_malloc(1);
+ handle = YAML_MALLOC(1);
if (!handle) goto error;
handle[0] = '\0';
/* Set the handle to '!'. */
yaml_free(handle);
- handle = yaml_malloc(2);
+ handle = YAML_MALLOC(2);
if (!handle) goto error;
handle[0] = '!';
handle[1] = '\0';
*/
#define BUFFER_INIT(context,buffer,size) \
- (((buffer).start = yaml_malloc(size)) ? \
+ (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \
((buffer).last = (buffer).pointer = (buffer).start, \
(buffer).end = (buffer).start+(size), \
1) : \
(value).pointer = (string))
#define STRING_INIT(context,string,size) \
- (((string).start = yaml_malloc(size)) ? \
+ (((string).start = YAML_MALLOC(size)) ? \
((string).pointer = (string).start, \
(string).end = (string).start+(size), \
memset((string).start, 0, (size)), \
YAML_DECLARE(int)
yaml_queue_extend(void **start, void **head, void **tail, void **end);
-#define STACK_INIT(context,stack,size) \
- (((stack).start = yaml_malloc((size)*sizeof(*(stack).start))) ? \
+#define STACK_INIT(context,stack,type) \
+ (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \
((stack).top = (stack).start, \
- (stack).end = (stack).start+(size), \
+ (stack).end = (stack).start+INITIAL_STACK_SIZE, \
1) : \
((context)->error = YAML_MEMORY_ERROR, \
0))
#define POP(context,stack) \
(*(--(stack).top))
-#define QUEUE_INIT(context,queue,size) \
- (((queue).start = yaml_malloc((size)*sizeof(*(queue).start))) ? \
+#define QUEUE_INIT(context,queue,size,type) \
+ (((queue).start = (type)yaml_malloc((size)*sizeof(*(queue).start))) ? \
((queue).head = (queue).tail = (queue).start, \
(queue).end = (queue).start+(size), \
1) : \
(node).data.mapping.pairs.end = (node_pairs_end), \
(node).data.mapping.pairs.top = (node_pairs_start), \
(node).data.mapping.style = (node_style))
+
+/* Strict C compiler warning helpers */
+
+#if defined(__clang__) || defined(__GNUC__)
+# define HASATTRIBUTE_UNUSED
+#endif
+#ifdef HASATTRIBUTE_UNUSED
+# define __attribute__unused__ __attribute__((__unused__))
+#else
+# define __attribute__unused__
+#endif
+
+/* Shim arguments are arguments that must be included in your function,
+ * but serve no purpose inside. Silence compiler warnings. */
+#define SHIM(a) /*@unused@*/ a __attribute__unused__
+
+/* UNUSED_PARAM() marks a shim argument in the body to silence compiler warnings */
+#ifdef __clang__
+# define UNUSED_PARAM(a) (void)(a);
+#else
+# define UNUSED_PARAM(a) /*@-noeffect*/if (0) (void)(a)/*@=noeffect*/;
+#endif
+
+#define YAML_MALLOC_STATIC(type) (type*)yaml_malloc(sizeof(type))
+#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size)
case YAML_READER_ERROR:
if (parser.problem_value != -1) {
- fprintf(stderr, "Reader error: %s: #%X at %zu\n", parser.problem,
- parser.problem_value, parser.problem_offset);
+ fprintf(stderr, "Reader error: %s: #%X at %ld\n", parser.problem,
+ parser.problem_value, (long)parser.problem_offset);
}
else {
- fprintf(stderr, "Reader error: %s at %zu\n", parser.problem,
- parser.problem_offset);
+ fprintf(stderr, "Reader error: %s at %ld\n", parser.problem,
+ (long)parser.problem_offset);
}
break;
case YAML_SCANNER_ERROR:
if (parser.context) {
- fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n"
- "%s at line %lu, column %lu\n", parser.context,
- parser.context_mark.line+1, parser.context_mark.column+1,
- parser.problem, parser.problem_mark.line+1,
- parser.problem_mark.column+1);
+ fprintf(stderr, "Scanner error: %s at line %d, column %d\n"
+ "%s at line %d, column %d\n", parser.context,
+ (int)parser.context_mark.line+1, (int)parser.context_mark.column+1,
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
}
else {
- fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n",
- parser.problem, parser.problem_mark.line+1,
- parser.problem_mark.column+1);
+ fprintf(stderr, "Scanner error: %s at line %d, column %d\n",
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
}
break;
case YAML_PARSER_ERROR:
if (parser.context) {
- fprintf(stderr, "Parser error: %s at line %lu, column %lu\n"
- "%s at line %lu, column %lu\n", parser.context,
- parser.context_mark.line+1, parser.context_mark.column+1,
- parser.problem, parser.problem_mark.line+1,
- parser.problem_mark.column+1);
+ fprintf(stderr, "Parser error: %s at line %d, column %d\n"
+ "%s at line %d, column %d\n", parser.context,
+ (int)parser.context_mark.line+1, (int)parser.context_mark.column+1,
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
}
else {
- fprintf(stderr, "Parser error: %s at line %lu, column %lu\n",
- parser.problem, parser.problem_mark.line+1,
- parser.problem_mark.column+1);
+ fprintf(stderr, "Parser error: %s at line %d, column %d\n",
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
}
break;
case YAML_READER_ERROR:
if (parser.problem_value != -1) {
- fprintf(stderr, "Reader error: %s: #%X at %zd\n", parser.problem,
- parser.problem_value, parser.problem_offset);
+ fprintf(stderr, "Reader error: %s: #%X at %ld\n", parser.problem,
+ parser.problem_value, (long)parser.problem_offset);
}
else {
- fprintf(stderr, "Reader error: %s at %zd\n", parser.problem,
- parser.problem_offset);
+ fprintf(stderr, "Reader error: %s at %ld\n", parser.problem,
+ (long)parser.problem_offset);
}
break;
case YAML_SCANNER_ERROR:
if (parser.context) {
- fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n"
- "%s at line %lu, column %lu\n", parser.context,
- parser.context_mark.line+1, parser.context_mark.column+1,
- parser.problem, parser.problem_mark.line+1,
- parser.problem_mark.column+1);
+ fprintf(stderr, "Scanner error: %s at line %d, column %d\n"
+ "%s at line %d, column %d\n", parser.context,
+ (int)parser.context_mark.line+1, (int)parser.context_mark.column+1,
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
}
else {
- fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n",
- parser.problem, parser.problem_mark.line+1,
- parser.problem_mark.column+1);
+ fprintf(stderr, "Scanner error: %s at line %d, column %d\n",
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
}
break;
case YAML_PARSER_ERROR:
if (parser.context) {
- fprintf(stderr, "Parser error: %s at line %lu, column %lu\n"
- "%s at line %lu, column %lu\n", parser.context,
- parser.context_mark.line+1, parser.context_mark.column+1,
- parser.problem, parser.problem_mark.line+1,
- parser.problem_mark.column+1);
+ fprintf(stderr, "Parser error: %s at line %d, column %d\n"
+ "%s at line %d, column %d\n", parser.context,
+ (int)parser.context_mark.line+1, (int)parser.context_mark.column+1,
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
}
else {
- fprintf(stderr, "Parser error: %s at line %lu, column %lu\n",
- parser.problem, parser.problem_mark.line+1,
- parser.problem_mark.column+1);
+ fprintf(stderr, "Parser error: %s at line %d, column %d\n",
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
}
break;
if (feof(file)) break;
}
fclose(file);
- printf("#### (length: %zd)\n", total_size);
- printf("OUTPUT:\n%s#### (length: %zd)\n", buffer, size);
+ printf("#### (length: %ld)\n", (long)total_size);
+ printf("OUTPUT:\n%s#### (length: %ld)\n", buffer, (long)size);
return 0;
}
yaml_document_delete(documents+k);
}
- printf("PASSED (length: %zd)\n", written);
+ printf("PASSED (length: %ld)\n", (long)written);
print_output(argv[number], buffer, written, -1);
}
if (feof(file)) break;
}
fclose(file);
- printf("#### (length: %zd)\n", total_size);
- printf("OUTPUT:\n%s#### (length: %zd)\n", buffer, size);
+ printf("#### (length: %ld)\n", (long)total_size);
+ printf("OUTPUT:\n%s#### (length: %ld)\n", buffer, (long)size);
return 0;
}
yaml_event_delete(events+k);
}
- printf("PASSED (length: %zd)\n", written);
+ printf("PASSED (length: %ld)\n", (long)written);
print_output(argv[number], buffer, written, -1);
}
}
else if (parser.error == YAML_READER_ERROR) {
if (parser.problem_value != -1) {
- printf("(reader error: %s: #%X at %zu)\n",
- parser.problem, parser.problem_value, parser.problem_offset);
+ printf("(reader error: %s: #%X at %ld)\n",
+ parser.problem, parser.problem_value, (long)parser.problem_offset);
}
else {
- printf("(reader error: %s at %zu)\n",
- parser.problem, parser.problem_offset);
+ printf("(reader error: %s at %ld)\n",
+ parser.problem, (long)parser.problem_offset);
}
}
if (*end == '!') break;
yaml_parser_set_input_string(&parser, (unsigned char *)start, end-start);
result = yaml_parser_update_buffer(&parser, end-start);
if (!result) {
- printf("- (reader error: %s at %zu)\n", parser.problem, parser.problem_offset);
+ printf("- (reader error: %s at %ld)\n", parser.problem, (long)parser.problem_offset);
failed++;
}
else {
if (parser.unread != check) {
- printf("- (length=%zu while expected length=%d)\n", parser.unread, check);
+ printf("- (length=%ld while expected length=%d)\n", (long)parser.unread, check);
failed++;
}
else if (memcmp(parser.buffer.start, bom_original, check) != 0) {
int j;
int failed = 0;
unsigned char ch0, ch1;
- unsigned char *buffer = malloc(3+LONG*2);
+ unsigned char *buffer = (unsigned char *)malloc(3+LONG*2);
assert(buffer);
printf("checking a long utf8 sequence...\n");
buffer[k++] = '\xef';
for (k = 0; k < LONG; k++) {
if (!parser.unread) {
if (!yaml_parser_update_buffer(&parser, 1)) {
- printf("\treader error: %s at %zu\n", parser.problem, parser.problem_offset);
+ printf("\treader error: %s at %ld\n", parser.problem, (long)parser.problem_offset);
failed = 1;
break;
}
}
if (!failed) {
if (!yaml_parser_update_buffer(&parser, 1)) {
- printf("\treader error: %s at %zu\n", parser.problem, parser.problem_offset);
+ printf("\treader error: %s at %ld\n", parser.problem, (long)parser.problem_offset);
failed = 1;
}
else if (parser.buffer.pointer[0] != '\0') {
- printf("\texpected NUL, found %X (eof=%d, unread=%zu)\n", (int)parser.buffer.pointer[0], parser.eof, parser.unread);
+ printf("\texpected NUL, found %X (eof=%d, unread=%ld)\n", (int)parser.buffer.pointer[0], parser.eof, (long)parser.unread);
failed = 1;
}
}
int j;
int failed = 0;
unsigned char ch0, ch1;
- unsigned char *buffer = malloc(2+LONG*2);
+ unsigned char *buffer = (unsigned char *)malloc(2+LONG*2);
assert(buffer);
printf("checking a long utf16 sequence...\n");
buffer[k++] = '\xff';
for (k = 0; k < LONG; k++) {
if (!parser.unread) {
if (!yaml_parser_update_buffer(&parser, 1)) {
- printf("\treader error: %s at %zu\n", parser.problem, parser.problem_offset);
+ printf("\treader error: %s at %ld\n", parser.problem, (long)parser.problem_offset);
failed = 1;
break;
}
}
if (!failed) {
if (!yaml_parser_update_buffer(&parser, 1)) {
- printf("\treader error: %s at %zu\n", parser.problem, parser.problem_offset);
+ printf("\treader error: %s at %ld\n", parser.problem, (long)parser.problem_offset);
failed = 1;
}
else if (parser.buffer.pointer[0] != '\0') {
- printf("\texpected NUL, found %X (eof=%d, unread=%zu)\n", (int)parser.buffer.pointer[0], parser.eof, parser.unread);
+ printf("\texpected NUL, found %X (eof=%d, unread=%ld)\n", (int)parser.buffer.pointer[0], parser.eof, (long)parser.unread);
failed = 1;
}
}
assert(strcmp(buf, yaml_get_version_string()) == 0);
/* Print structure sizes. */
- printf("sizeof(token) = %lu\n", sizeof(yaml_token_t));
- printf("sizeof(event) = %lu\n", sizeof(yaml_event_t));
- printf("sizeof(parser) = %lu\n", sizeof(yaml_parser_t));
+ printf("sizeof(token) = %ld\n", (long)sizeof(yaml_token_t));
+ printf("sizeof(event) = %ld\n", (long)sizeof(yaml_event_t));
+ printf("sizeof(parser) = %ld\n", (long)sizeof(yaml_parser_t));
return 0;
}