f7ef5ca · typeable/yaml

git.iko.soy/typeable/yaml

on master help sign in

libyaml upgrade (fixes #110)

f7ef5caMichael Snoyman8 years ago

ChangeLog.md+1

compare with master

unifiedsplit

@@ -1,6 +1,7 @@

1## 0.8.31

3* Add `decodeThrow` and `decodeFileThrow` convenience functions.

4+* Upgrade libyaml versions

5## 0.8.30

6## 0.8.30

libyaml/LICENSE+1

@@ -1,3 +1,4 @@

3Permission is hereby granted, free of charge, to any person obtaining a copy of

4Permission is hereby granted, free of charge, to any person obtaining a copy of

libyaml/api.c+26−25

@@ -81,7 +81,7 @@ YAML_DECLARE(int)

81yaml_string_extend(yaml_char_t **start,

82 yaml_char_t **pointer, yaml_char_t **end)

83{

84− yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2);

84+ yaml_char_t *new_start = (yaml_char_t *)yaml_realloc((void*)*start, (*end - *start)*2);

86 if (!new_start) return 0;

@@ -101,8 +101,9 @@ yaml_string_extend(yaml_char_t **start,

101YAML_DECLARE(int)

102yaml_string_join(

103 yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,

104− yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end)

104+ yaml_char_t **b_start, yaml_char_t **b_pointer, SHIM(yaml_char_t **b_end))

105{

106+ UNUSED_PARAM(b_end)

106 if (*b_start == *b_pointer)

107 if (*b_start == *b_pointer)

107 return 1;

108 return 1;

108

109

@@ -184,17 +185,17 @@ yaml_parser_initialize(yaml_parser_t *parser)

184 goto error;

185 goto error;

185 if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))

186 if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))

186 goto error;

187 goto error;

187− if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE))

188+ if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE, yaml_token_t*))

188 goto error;

189 goto error;

189− if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE))

190+ if (!STACK_INIT(parser, parser->indents, int*))

190 goto error;

191 goto error;

191− if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE))

192+ if (!STACK_INIT(parser, parser->simple_keys, yaml_simple_key_t*))

192 goto error;

193 goto error;

193− if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE))

194+ if (!STACK_INIT(parser, parser->states, yaml_parser_state_t*))

194 goto error;

195 goto error;

195− if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE))

196+ if (!STACK_INIT(parser, parser->marks, yaml_mark_t*))

196 goto error;

197 goto error;

197− if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE))

198+ if (!STACK_INIT(parser, parser->tag_directives, yaml_tag_directive_t*))

198 goto error;

199 goto error;

199

200

200 return 1;

201 return 1;

@@ -250,7 +251,7 @@ static int

250yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,

251yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,

251 size_t *size_read)

252 size_t *size_read)

252{

253{

253− yaml_parser_t *parser = data;

254+ yaml_parser_t *parser = (yaml_parser_t *)data;

254

255

255 if (parser->input.string.current == parser->input.string.end) {

256 if (parser->input.string.current == parser->input.string.end) {

256 *size_read = 0;

257 *size_read = 0;

@@ -276,7 +277,7 @@ static int

276yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,

277yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,

277 size_t *size_read)

278 size_t *size_read)

278{

279{

279− yaml_parser_t *parser = data;

280+ yaml_parser_t *parser = (yaml_parser_t *)data;

280

281

281 *size_read = fread(buffer, 1, size, parser->input.file);

282 *size_read = fread(buffer, 1, size, parser->input.file);

282 return !ferror(parser->input.file);

283 return !ferror(parser->input.file);

@@ -362,13 +363,13 @@ yaml_emitter_initialize(yaml_emitter_t *emitter)

362 goto error;

363 goto error;

363 if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))

364 if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))

364 goto error;

365 goto error;

365− if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE))

366+ if (!STACK_INIT(emitter, emitter->states, yaml_emitter_state_t*))

366 goto error;

367 goto error;

367− if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE))

368+ if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE, yaml_event_t*))

368 goto error;

369 goto error;

369− if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE))

370+ if (!STACK_INIT(emitter, emitter->indents, int*))

370 goto error;

371 goto error;

371− if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE))

372+ if (!STACK_INIT(emitter, emitter->tag_directives, yaml_tag_directive_t*))

372 goto error;

373 goto error;

373

374

374 return 1;

375 return 1;

@@ -420,7 +421,7 @@ yaml_emitter_delete(yaml_emitter_t *emitter)

420static int

421static int

421yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)

422yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)

422{

423{

423− yaml_emitter_t *emitter = data;

424+ yaml_emitter_t *emitter = (yaml_emitter_t *)data;

424

425

425 if (emitter->output.string.size - *emitter->output.string.size_written

426 if (emitter->output.string.size - *emitter->output.string.size_written

426 < size) {

427 < size) {

@@ -446,7 +447,7 @@ yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)

446static int

447static int

447yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)

448yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)

448{

449{

449− yaml_emitter_t *emitter = data;

450+ yaml_emitter_t *emitter = (yaml_emitter_t *)data;

450

451

451 return (fwrite(buffer, 1, size, emitter->output.file) == size);

452 return (fwrite(buffer, 1, size, emitter->output.file) == size);

452}

453}

@@ -724,7 +725,7 @@ yaml_document_start_event_initialize(yaml_event_t *event,

724 /* Valid tag directives are expected. */

725 /* Valid tag directives are expected. */

725

726

726 if (version_directive) {

727 if (version_directive) {

727− version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));

728+ version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);

728 if (!version_directive_copy) goto error;

729 if (!version_directive_copy) goto error;

729 version_directive_copy->major = version_directive->major;

730 version_directive_copy->major = version_directive->major;

730 version_directive_copy->minor = version_directive->minor;

731 version_directive_copy->minor = version_directive->minor;

@@ -732,7 +733,7 @@ yaml_document_start_event_initialize(yaml_event_t *event,

732

733

733 if (tag_directives_start != tag_directives_end) {

734 if (tag_directives_start != tag_directives_end) {

734 yaml_tag_directive_t *tag_directive;

735 yaml_tag_directive_t *tag_directive;

735− if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))

736+ if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))

736 goto error;

737 goto error;

737 for (tag_directive = tag_directives_start;

738 for (tag_directive = tag_directives_start;

738 tag_directive != tag_directives_end; tag_directive ++) {

739 tag_directive != tag_directives_end; tag_directive ++) {

@@ -852,7 +853,7 @@ yaml_scalar_event_initialize(yaml_event_t *event,

852 }

853 }

853

854

854 if (!yaml_check_utf8(value, length)) goto error;

855 if (!yaml_check_utf8(value, length)) goto error;

855− value_copy = yaml_malloc(length+1);

856+ value_copy = YAML_MALLOC(length+1);

856 if (!value_copy) goto error;

857 if (!value_copy) goto error;

857 memcpy(value_copy, value, length);

858 memcpy(value_copy, value, length);

858 value_copy[length] = '\0';

859 value_copy[length] = '\0';

@@ -1064,10 +1065,10 @@ yaml_document_initialize(yaml_document_t *document,

1064 (tag_directives_start == tag_directives_end));

1065 (tag_directives_start == tag_directives_end));

1065 /* Valid tag directives are expected. */

1066 /* Valid tag directives are expected. */

1066

1067

1067− if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error;

1068+ if (!STACK_INIT(&context, nodes, yaml_node_t*)) goto error;

1068

1069

1069 if (version_directive) {

1070 if (version_directive) {

1070− version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));

1071+ version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);

1071 if (!version_directive_copy) goto error;

1072 if (!version_directive_copy) goto error;

1072 version_directive_copy->major = version_directive->major;

1073 version_directive_copy->major = version_directive->major;

1073 version_directive_copy->minor = version_directive->minor;

1074 version_directive_copy->minor = version_directive->minor;

@@ -1075,7 +1076,7 @@ yaml_document_initialize(yaml_document_t *document,

1075

1076

1076 if (tag_directives_start != tag_directives_end) {

1077 if (tag_directives_start != tag_directives_end) {

1077 yaml_tag_directive_t *tag_directive;

1078 yaml_tag_directive_t *tag_directive;

1078− if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))

1079+ if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))

1079 goto error;

1080 goto error;

1080 for (tag_directive = tag_directives_start;

1081 for (tag_directive = tag_directives_start;

1081 tag_directive != tag_directives_end; tag_directive ++) {

1082 tag_directive != tag_directives_end; tag_directive ++) {

@@ -1228,7 +1229,7 @@ yaml_document_add_scalar(yaml_document_t *document,

1228 }

1229 }

1229

1230

1230 if (!yaml_check_utf8(value, length)) goto error;

1231 if (!yaml_check_utf8(value, length)) goto error;

1231− value_copy = yaml_malloc(length+1);

1232+ value_copy = YAML_MALLOC(length+1);

1232 if (!value_copy) goto error;

1233 if (!value_copy) goto error;

1233 memcpy(value_copy, value, length);

1234 memcpy(value_copy, value, length);

1234 value_copy[length] = '\0';

1235 value_copy[length] = '\0';

@@ -1275,7 +1276,7 @@ yaml_document_add_sequence(yaml_document_t *document,

1275 tag_copy = yaml_strdup(tag);

1276 tag_copy = yaml_strdup(tag);

1276 if (!tag_copy) goto error;

1277 if (!tag_copy) goto error;

1277

1278

1278− if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error;

1279+ if (!STACK_INIT(&context, items, yaml_node_item_t*)) goto error;

1279

1280

1280 SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,

1281 SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,

1281 style, mark, mark);

1282 style, mark, mark);

@@ -1320,7 +1321,7 @@ yaml_document_add_mapping(yaml_document_t *document,

1320 tag_copy = yaml_strdup(tag);

1321 tag_copy = yaml_strdup(tag);

1321 if (!tag_copy) goto error;

1322 if (!tag_copy) goto error;

1322

1323

1323− if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error;

1324+ if (!STACK_INIT(&context, pairs, yaml_node_pair_t*)) goto error;

1324

1325

1325 MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,

1326 MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,

1326 style, mark, mark);

1327 style, mark, mark);

libyaml/dumper.c+2−2

@@ -245,9 +245,9 @@ yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index)

245#define ANCHOR_TEMPLATE_LENGTH 16

246

247static yaml_char_t *

248−yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id)

248+yaml_emitter_generate_anchor(SHIM(yaml_emitter_t *emitter), int anchor_id)

249{

250− yaml_char_t *anchor = yaml_malloc(ANCHOR_TEMPLATE_LENGTH);

250+ yaml_char_t *anchor = YAML_MALLOC(ANCHOR_TEMPLATE_LENGTH);

251

252 if (!anchor) return NULL;

253

libyaml/emitter.c+2−2

@@ -1002,7 +1002,7 @@ yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,

1002 */

1003

1004static int

1005−yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event)

1005+yaml_emitter_emit_alias(yaml_emitter_t *emitter, SHIM(yaml_event_t *event))

1006{

1007 if (!yaml_emitter_process_anchor(emitter))

1008 return 0;

@@ -1087,7 +1087,7 @@ yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event)

1087 */

1088

1089static int

1090−yaml_emitter_check_empty_document(yaml_emitter_t *emitter)

1090+yaml_emitter_check_empty_document(SHIM(yaml_emitter_t *emitter))

1091{

1092 return 0;

1093}

libyaml/loader.c+4−4

@@ -72,7 +72,7 @@ yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document)

72 assert(document); /* Non-NULL document object is expected. */

74 memset(document, 0, sizeof(yaml_document_t));

75− if (!STACK_INIT(parser, document->nodes, INITIAL_STACK_SIZE))

75+ if (!STACK_INIT(parser, document->nodes, yaml_node_t*))

76 goto error;

78 if (!parser->stream_start_produced) {

@@ -90,7 +90,7 @@ yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document)

90 return 1;

91 }

93− if (!STACK_INIT(parser, parser->aliases, INITIAL_STACK_SIZE))

93+ if (!STACK_INIT(parser, parser->aliases, yaml_alias_data_t*))

94 goto error;

96 parser->document = document;

@@ -339,7 +339,7 @@ yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event)

339 if (!tag) goto error;

340 }

341

342− if (!STACK_INIT(parser, items, INITIAL_STACK_SIZE)) goto error;

342+ if (!STACK_INIT(parser, items, yaml_node_item_t*)) goto error;

343

344 SEQUENCE_NODE_INIT(node, tag, items.start, items.end,

345 first_event->data.sequence_start.style,

@@ -402,7 +402,7 @@ yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event)

402 if (!tag) goto error;

403 }

404

405− if (!STACK_INIT(parser, pairs, INITIAL_STACK_SIZE)) goto error;

405+ if (!STACK_INIT(parser, pairs, yaml_node_pair_t*)) goto error;

406

407 MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end,

408 first_event->data.mapping_start.style,

libyaml/parser.c+9−13

@@ -605,7 +605,7 @@ yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,

605 if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {

606 size_t prefix_len = strlen((char *)tag_directive->prefix);

607 size_t suffix_len = strlen((char *)tag_suffix);

608− tag = yaml_malloc(prefix_len+suffix_len+1);

608+ tag = YAML_MALLOC(prefix_len+suffix_len+1);

609 if (!tag) {

610 parser->error = YAML_MEMORY_ERROR;

611 goto error;

@@ -685,7 +685,7 @@ yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,

685 return 1;

686 }

687 else if (anchor || tag) {

688− yaml_char_t *value = yaml_malloc(1);

688+ yaml_char_t *value = YAML_MALLOC(1);

689 if (!value) {

690 parser->error = YAML_MEMORY_ERROR;

691 goto error;

@@ -759,9 +759,8 @@ yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,

759

760 else if (token->type == YAML_BLOCK_END_TOKEN)

761 {

762− yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */

763 parser->state = POP(parser, parser->states);

762 parser->state = POP(parser, parser->states);

764− dummy_mark = POP(parser, parser->marks);

763+ (void)POP(parser, parser->marks);

765 SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);

764 SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);

766 SKIP_TOKEN(parser);

765 SKIP_TOKEN(parser);

767 return 1;

766 return 1;

@@ -869,9 +868,8 @@ yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,

869

868

870 else if (token->type == YAML_BLOCK_END_TOKEN)

869 else if (token->type == YAML_BLOCK_END_TOKEN)

871 {

870 {

872− yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */

873 parser->state = POP(parser, parser->states);

871 parser->state = POP(parser, parser->states);

874− dummy_mark = POP(parser, parser->marks);

872+ (void)POP(parser, parser->marks);

875 MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);

873 MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);

876 SKIP_TOKEN(parser);

874 SKIP_TOKEN(parser);

877 return 1;

875 return 1;

@@ -952,7 +950,6 @@ yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,

952 yaml_event_t *event, int first)

950 yaml_event_t *event, int first)

953{

951{

954 yaml_token_t *token;

952 yaml_token_t *token;

955− yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */

956

953

957 if (first) {

954 if (first) {

958 token = PEEK_TOKEN(parser);

955 token = PEEK_TOKEN(parser);

@@ -997,7 +994,7 @@ yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,

997 }

994 }

998

995

999 parser->state = POP(parser, parser->states);

996 parser->state = POP(parser, parser->states);

1000− dummy_mark = POP(parser, parser->marks);

997+ (void)POP(parser, parser->marks);

1001 SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);

998 SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);

1002 SKIP_TOKEN(parser);

999 SKIP_TOKEN(parser);

1003 return 1;

1000 return 1;

@@ -1104,7 +1101,6 @@ yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,

1104 yaml_event_t *event, int first)

1101 yaml_event_t *event, int first)

1105{

1102{

1106 yaml_token_t *token;

1103 yaml_token_t *token;

1107− yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */

1108

1104

1109 if (first) {

1105 if (first) {

1110 token = PEEK_TOKEN(parser);

1106 token = PEEK_TOKEN(parser);

@@ -1158,7 +1154,7 @@ yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,

1158 }

1154 }

1159

1155

1160 parser->state = POP(parser, parser->states);

1156 parser->state = POP(parser, parser->states);

1161− dummy_mark = POP(parser, parser->marks);

1157+ (void)POP(parser, parser->marks);

1162 MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);

1158 MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);

1163 SKIP_TOKEN(parser);

1159 SKIP_TOKEN(parser);

1164 return 1;

1160 return 1;

@@ -1212,7 +1208,7 @@ yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event,

1212{

1208{

1213 yaml_char_t *value;

1209 yaml_char_t *value;

1214

1210

1215− value = yaml_malloc(1);

1211+ value = YAML_MALLOC(1);

1216 if (!value) {

1212 if (!value) {

1217 parser->error = YAML_MEMORY_ERROR;

1213 parser->error = YAML_MEMORY_ERROR;

1218 return 0;

1214 return 0;

@@ -1249,7 +1245,7 @@ yaml_parser_process_directives(yaml_parser_t *parser,

1249 } tag_directives = { NULL, NULL, NULL };

1245 } tag_directives = { NULL, NULL, NULL };

1250 yaml_token_t *token;

1246 yaml_token_t *token;

1251

1247

1252− if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE))

1248+ if (!STACK_INIT(parser, tag_directives, yaml_tag_directive_t*))

1253 goto error;

1249 goto error;

1254

1250

1255 token = PEEK_TOKEN(parser);

1251 token = PEEK_TOKEN(parser);

@@ -1270,7 +1266,7 @@ yaml_parser_process_directives(yaml_parser_t *parser,

1270 "found incompatible YAML document", token->start_mark);

1266 "found incompatible YAML document", token->start_mark);

1271 goto error;

1267 goto error;

1272 }

1268 }

1273− version_directive = yaml_malloc(sizeof(yaml_version_directive_t));

1269+ version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t);

1274 if (!version_directive) {

1270 if (!version_directive) {

1275 parser->error = YAML_MEMORY_ERROR;

1271 parser->error = YAML_MEMORY_ERROR;

1276 goto error;

1272 goto error;

libyaml/reader.c+3−3

@@ -460,10 +460,10 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)

460

461 }

462

463− if (parser->offset >= PTRDIFF_MAX)

463+ if (parser->offset >= MAX_FILE_SIZE) {

464 return yaml_parser_set_reader_error(parser, "input is too long",

465− PTRDIFF_MAX, -1);

465+ parser->offset, -1);

466+ }

466

467

467 return 1;

468 return 1;

468}

469}

469−

libyaml/scanner.c+3−9

@@ -1186,11 +1186,9 @@ yaml_parser_increase_flow_level(yaml_parser_t *parser)

1186static int

1187yaml_parser_decrease_flow_level(yaml_parser_t *parser)

1188{

1189− yaml_simple_key_t dummy_key; /* Used to eliminate a compiler warning. */

1190−

1191 if (parser->flow_level) {

1189 if (parser->flow_level) {

1192 parser->flow_level --;

1190 parser->flow_level --;

1193− dummy_key = POP(parser, parser->simple_keys);

1191+ (void)POP(parser, parser->simple_keys);

1194 }

1192 }

1195

1193

1196 return 1;

1194 return 1;

@@ -2401,7 +2399,7 @@ yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)

2401 {

2399 {

2402 /* Set the handle to '' */

2400 /* Set the handle to '' */

2403

2401

2404− handle = yaml_malloc(1);

2402+ handle = YAML_MALLOC(1);

2405 if (!handle) goto error;

2403 if (!handle) goto error;

2406 handle[0] = '\0';

2404 handle[0] = '\0';

2407

2405

@@ -2453,7 +2451,7 @@ yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)

2453 /* Set the handle to '!'. */

2451 /* Set the handle to '!'. */

2454

2452

2455 yaml_free(handle);

2453 yaml_free(handle);

2456− handle = yaml_malloc(2);

2454+ handle = YAML_MALLOC(2);

2457 if (!handle) goto error;

2455 if (!handle) goto error;

2458 handle[0] = '!';

2456 handle[0] = '!';

2459 handle[1] = '\0';

2457 handle[1] = '\0';

@@ -3166,10 +3164,6 @@ yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token,

3166 *(string.pointer++) = '/';

3164 *(string.pointer++) = '/';

3167 break;

3165 break;

3168

3166

3169− case '\'':

3170− *(string.pointer++) = '\'';

3171− break;

3172−

3173 case '\\':

3167 case '\\':

3174 *(string.pointer++) = '\\';

3168 *(string.pointer++) = '\\';

3175 break;

3169 break;

libyaml/yaml.h+3−3

@@ -1091,7 +1091,7 @@ typedef struct yaml_parser_s {

1091 yaml_error_type_t error;

1092 /** Error description. */

1093 const char *problem;

1094− /** The byte about which the problem occurred. */

1094+ /** The byte about which the problem occured. */

1095 size_t problem_offset;

1096 /** The problematic value (@c -1 is none). */

1097 int problem_value;

@@ -1940,8 +1940,8 @@ yaml_emitter_close(yaml_emitter_t *emitter);

1940 *

1941 * The documen object may be generated using the yaml_parser_load() function

1942 * or the yaml_document_initialize() function. The emitter takes the

1943− * responsibility for the document object and destoys its content after

1943+ * responsibility for the document object and destroys its content after

1944− * it is emitted. The document object is destroyedeven if the function fails.

1944+ * it is emitted. The document object is destroyed even if the function fails.

1945 *

1946 * @param[in,out] emitter An emitter object.

1947 * @param[in,out] document A document object.

libyaml/yaml_private.h+46−20

@@ -8,16 +8,6 @@

8#include <limits.h>

9#include <stddef.h>

11−#ifndef _MSC_VER

12−#include <stdint.h>

13−#else

14−#ifdef _WIN64

15−#define PTRDIFF_MAX _I64_MAX

16−#else

17−#define PTRDIFF_MAX INT_MAX

18−#endif

19−#endif

20−

21/*

11/*

22 * Memory management.

12 * Memory management.

23 */

13 */

@@ -76,6 +66,17 @@ yaml_parser_fetch_more_tokens(yaml_parser_t *parser);

77#define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2)

67#define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2)

69+/*

70+ * The maximum size of a YAML input file.

71+ * This used to be PTRDIFF_MAX, but that's not entirely portable

72+ * because stdint.h isn't available on all platforms.

73+ * It is not entirely clear why this isn't the maximum value

74+ * that can fit into the parser->offset field.

75+ */

76+

77+#define MAX_FILE_SIZE (~(size_t)0 / 2)

78+

79+

79/*

80/*

80 * The size of other stacks and queues.

81 * The size of other stacks and queues.

81 */

82 */

@@ -89,7 +90,7 @@ yaml_parser_fetch_more_tokens(yaml_parser_t *parser);

89 */

90 */

91#define BUFFER_INIT(context,buffer,size) \

92#define BUFFER_INIT(context,buffer,size) \

92− (((buffer).start = yaml_malloc(size)) ? \

93+ (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \

93 ((buffer).last = (buffer).pointer = (buffer).start, \

94 ((buffer).last = (buffer).pointer = (buffer).start, \

94 (buffer).end = (buffer).start+(size), \

95 (buffer).end = (buffer).start+(size), \

95 1) : \

96 1) : \

@@ -129,7 +130,7 @@ yaml_string_join(

129 (value).pointer = (string))

130 (value).pointer = (string))

130

131

131#define STRING_INIT(context,string,size) \

132#define STRING_INIT(context,string,size) \

132− (((string).start = yaml_malloc(size)) ? \

133+ (((string).start = YAML_MALLOC(size)) ? \

133 ((string).pointer = (string).start, \

134 ((string).pointer = (string).start, \

134 (string).end = (string).start+(size), \

135 (string).end = (string).start+(size), \

135 memset((string).start, 0, (size)), \

136 memset((string).start, 0, (size)), \

@@ -419,10 +420,10 @@ yaml_stack_extend(void **start, void **top, void **end);

419YAML_DECLARE(int)

420YAML_DECLARE(int)

420yaml_queue_extend(void **start, void **head, void **tail, void **end);

421yaml_queue_extend(void **start, void **head, void **tail, void **end);

421

422

422−#define STACK_INIT(context,stack,size) \

423+#define STACK_INIT(context,stack,type) \

423− (((stack).start = yaml_malloc((size)*sizeof(*(stack).start))) ? \

424+ (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \

424 ((stack).top = (stack).start, \

425 ((stack).top = (stack).start, \

425− (stack).end = (stack).start+(size), \

426+ (stack).end = (stack).start+INITIAL_STACK_SIZE, \

426 1) : \

427 1) : \

427 ((context)->error = YAML_MEMORY_ERROR, \

428 ((context)->error = YAML_MEMORY_ERROR, \

428 0))

429 0))

@@ -452,8 +453,8 @@ yaml_queue_extend(void **start, void **head, void **tail, void **end);

452#define POP(context,stack) \

453#define POP(context,stack) \

453 (*(--(stack).top))

454 (*(--(stack).top))

454

455

455−#define QUEUE_INIT(context,queue,size) \

456+#define QUEUE_INIT(context,queue,size,type) \

456− (((queue).start = yaml_malloc((size)*sizeof(*(queue).start))) ? \

457+ (((queue).start = (type)yaml_malloc((size)*sizeof(*(queue).start))) ? \

457 ((queue).head = (queue).tail = (queue).start, \

458 ((queue).head = (queue).tail = (queue).start, \

458 (queue).end = (queue).start+(size), \

459 (queue).end = (queue).start+(size), \

459 1) : \

460 1) : \

@@ -657,8 +658,33 @@ yaml_queue_extend(void **start, void **head, void **tail, void **end);

657 (node).data.mapping.pairs.top = (node_pairs_start), \

658 (node).data.mapping.pairs.top = (node_pairs_start), \

658 (node).data.mapping.style = (node_style))

659 (node).data.mapping.style = (node_style))

659

660

661+/* Strict C compiler warning helpers */

662+

663+#if defined(__clang__) || defined(__GNUC__)

664+# define HASATTRIBUTE_UNUSED

665+#endif

666+#ifdef HASATTRIBUTE_UNUSED

667+# define __attribute__unused__ __attribute__((__unused__))

668+#else

669+# define __attribute__unused__

670+#endif

671+

672+/* Shim arguments are arguments that must be included in your function,

673+ * but serve no purpose inside. Silence compiler warnings. */

674+#define SHIM(a) /*@unused@*/ a __attribute__unused__

675+

676+/* UNUSED_PARAM() marks a shim argument in the body to silence compiler warnings */

677+#ifdef __clang__

678+# define UNUSED_PARAM(a) (void)(a);

679+#else

680+# define UNUSED_PARAM(a) /*@-noeffect*/if (0) (void)(a)/*@=noeffect*/;

681+#endif

682+

683+#define YAML_MALLOC_STATIC(type) (type*)yaml_malloc(sizeof(type))

684+#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size)

685+

660/* For Haskell yaml package, since we do not use the configure script */

686/* For Haskell yaml package, since we do not use the configure script */

661−#define YAML_VERSION_STRING "0.1.7"

687+#define YAML_VERSION_STRING "0.2.1"

662#define YAML_VERSION_MAJOR 0

688#define YAML_VERSION_MAJOR 0

663−#define YAML_VERSION_MINOR 1

689+#define YAML_VERSION_MINOR 2

664−#define YAML_VERSION_PATCH 7

690+#define YAML_VERSION_PATCH 1

vendor/libyaml+1−1

Submodule changed.