f7ef5ca · typeable/yaml

git.iko.soy/typeable/yaml

libyaml upgrade (fixes #110)

commitf7ef5ca83744d3d3927c60e245fbcda7d5c643ca authorMichael Snoyman <michael@snoyman.com> dateThu 28 Jun 2018, 12:06 (8 years ago) parentb99195f

12 files changed+101−82

compare with master

unifiedsplit

ChangeLog.md+1 libyaml/LICENSE+1 libyaml/api.c+26−25 libyaml/dumper.c+2−2 libyaml/emitter.c+2−2 libyaml/loader.c+4−4 libyaml/parser.c+9−13 libyaml/reader.c+3−3 libyaml/scanner.c+3−9 libyaml/yaml.h+3−3 libyaml/yaml_private.h+46−20 vendor/libyaml+1−1

ChangeLog.md+1

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

11## 0.8.31

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

4+* Upgrade libyaml versions

56## 0.8.30

libyaml/LICENSE+1

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

34Permission 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)

8181yaml_string_extend(yaml_char_t **start,

8282 yaml_char_t **pointer, yaml_char_t **end)

8383{

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);

8585

8686 if (!new_start) return 0;

8787

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

101101YAML_DECLARE(int)

102102yaml_string_join(

103103 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))

105105{

106+ UNUSED_PARAM(b_end)

106107 if (*b_start == *b_pointer)

107108 return 1;

108109

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

184185 goto error;

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

186187 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*))

188189 goto error;

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

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

190191 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*))

192193 goto error;

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

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

194195 goto error;

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

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

196197 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*))

198199 goto error;

199200

200201 return 1;

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

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

251252 size_t *size_read)

252253{

253− yaml_parser_t *parser = data;

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

254255

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

256257 *size_read = 0;

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

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

277278 size_t *size_read)

278279{

279− yaml_parser_t *parser = data;

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

280281

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

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

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

362363 goto error;

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

364365 goto error;

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

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

366367 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*))

368369 goto error;

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

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

370371 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*))

372373 goto error;

373374

374375 return 1;

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

420421static int

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

422423{

423− yaml_emitter_t *emitter = data;

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

424425

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

426427 < size) {

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

446447static int

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

448449{

449− yaml_emitter_t *emitter = data;

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

450451

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

452453}

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

724725 /* Valid tag directives are expected. */

725726

726727 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);

728729 if (!version_directive_copy) goto error;

729730 version_directive_copy->major = version_directive->major;

730731 version_directive_copy->minor = version_directive->minor;

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

732733

733734 if (tag_directives_start != tag_directives_end) {

734735 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*))

736737 goto error;

737738 for (tag_directive = tag_directives_start;

738739 tag_directive != tag_directives_end; tag_directive ++) {

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

852853 }

853854

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

855− value_copy = yaml_malloc(length+1);

856+ value_copy = YAML_MALLOC(length+1);

856857 if (!value_copy) goto error;

857858 memcpy(value_copy, value, length);

858859 value_copy[length] = '\0';

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

10641065 (tag_directives_start == tag_directives_end));

10651066 /* Valid tag directives are expected. */

10661067

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

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

10681069

10691070 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);

10711072 if (!version_directive_copy) goto error;

10721073 version_directive_copy->major = version_directive->major;

10731074 version_directive_copy->minor = version_directive->minor;

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

10751076

10761077 if (tag_directives_start != tag_directives_end) {

10771078 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*))

10791080 goto error;

10801081 for (tag_directive = tag_directives_start;

10811082 tag_directive != tag_directives_end; tag_directive ++) {

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

12281229 }

12291230

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

1231− value_copy = yaml_malloc(length+1);

1232+ value_copy = YAML_MALLOC(length+1);

12321233 if (!value_copy) goto error;

12331234 memcpy(value_copy, value, length);

12341235 value_copy[length] = '\0';

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

12751276 tag_copy = yaml_strdup(tag);

12761277 if (!tag_copy) goto error;

12771278

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

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

12791280

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

12811282 style, mark, mark);

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

13201321 tag_copy = yaml_strdup(tag);

13211322 if (!tag_copy) goto error;

13221323

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

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

13241325

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

13261327 style, mark, mark);

libyaml/dumper.c+2−2

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

245245#define ANCHOR_TEMPLATE_LENGTH 16

246246

247247static 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)

249249{

250− yaml_char_t *anchor = yaml_malloc(ANCHOR_TEMPLATE_LENGTH);

250+ yaml_char_t *anchor = YAML_MALLOC(ANCHOR_TEMPLATE_LENGTH);

251251

252252 if (!anchor) return NULL;

253253

libyaml/emitter.c+2−2

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

10021002 */

10031003

10041004static 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))

10061006{

10071007 if (!yaml_emitter_process_anchor(emitter))

10081008 return 0;

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

10871087 */

10881088

10891089static int

1090−yaml_emitter_check_empty_document(yaml_emitter_t *emitter)

1090+yaml_emitter_check_empty_document(SHIM(yaml_emitter_t *emitter))

10911091{

10921092 return 0;

10931093}

libyaml/loader.c+4−4

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

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

7373

7474 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*))

7676 goto error;

7777

7878 if (!parser->stream_start_produced) {

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

9090 return 1;

9191 }

9292

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

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

9494 goto error;

9595

9696 parser->document = document;

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

339339 if (!tag) goto error;

340340 }

341341

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

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

343343

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

345345 first_event->data.sequence_start.style,

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

402402 if (!tag) goto error;

403403 }

404404

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

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

406406

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

408408 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,

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

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

607607 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);

609609 if (!tag) {

610610 parser->error = YAML_MEMORY_ERROR;

611611 goto error;

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

685685 return 1;

686686 }

687687 else if (anchor || tag) {

688− yaml_char_t *value = yaml_malloc(1);

688+ yaml_char_t *value = YAML_MALLOC(1);

689689 if (!value) {

690690 parser->error = YAML_MEMORY_ERROR;

691691 goto error;

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

759759

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

761761 {

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

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

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

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

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

766765 SKIP_TOKEN(parser);

767766 return 1;

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

869868

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

871870 {

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

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

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

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

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

876874 SKIP_TOKEN(parser);

877875 return 1;

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

952950 yaml_event_t *event, int first)

953951{

954952 yaml_token_t *token;

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

956953

957954 if (first) {

958955 token = PEEK_TOKEN(parser);

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

997994 }

998995

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

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

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

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

1002999 SKIP_TOKEN(parser);

10031000 return 1;

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

11041101 yaml_event_t *event, int first)

11051102{

11061103 yaml_token_t *token;

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

11081104

11091105 if (first) {

11101106 token = PEEK_TOKEN(parser);

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

11581154 }

11591155

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

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

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

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

11631159 SKIP_TOKEN(parser);

11641160 return 1;

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

12121208{

12131209 yaml_char_t *value;

12141210

1215− value = yaml_malloc(1);

1211+ value = YAML_MALLOC(1);

12161212 if (!value) {

12171213 parser->error = YAML_MEMORY_ERROR;

12181214 return 0;

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

12491245 } tag_directives = { NULL, NULL, NULL };

12501246 yaml_token_t *token;

12511247

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

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

12531249 goto error;

12541250

12551251 token = PEEK_TOKEN(parser);

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

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

12711267 goto error;

12721268 }

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

1269+ version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t);

12741270 if (!version_directive) {

12751271 parser->error = YAML_MEMORY_ERROR;

12761272 goto error;

libyaml/reader.c+3−3

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

460460

461461 }

462462

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

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

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

465− PTRDIFF_MAX, -1);

465+ parser->offset, -1);

466+ }

466467

467468 return 1;

468469}

469−

libyaml/scanner.c+3−9

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

11861186static int

11871187yaml_parser_decrease_flow_level(yaml_parser_t *parser)

11881188{

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

1190−

11911189 if (parser->flow_level) {

11921190 parser->flow_level --;

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

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

11941192 }

11951193

11961194 return 1;

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

24012399 {

24022400 /* Set the handle to '' */

24032401

2404− handle = yaml_malloc(1);

2402+ handle = YAML_MALLOC(1);

24052403 if (!handle) goto error;

24062404 handle[0] = '\0';

24072405

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

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

24542452

24552453 yaml_free(handle);

2456− handle = yaml_malloc(2);

2454+ handle = YAML_MALLOC(2);

24572455 if (!handle) goto error;

24582456 handle[0] = '!';

24592457 handle[1] = '\0';

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

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

31673165 break;

31683166

3169− case '\'':

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

3171− break;

3172−

31733167 case '\\':

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

31753169 break;

libyaml/yaml.h+3−3

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

10911091 yaml_error_type_t error;

10921092 /** Error description. */

10931093 const char *problem;

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

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

10951095 size_t problem_offset;

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

10971097 int problem_value;

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

19401940 *

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

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

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

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

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

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

19451945 *

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

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

libyaml/yaml_private.h+46−20

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

88#include <limits.h>

99#include <stddef.h>

1010

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−

2111/*

2212 * Memory management.

2313 */

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

7666

7767#define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2)

7868

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+

7980/*

8081 * The size of other stacks and queues.

8182 */

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

8990 */

9091

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

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

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

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

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

9596 1) : \

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

129130 (value).pointer = (string))

130131

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

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

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

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

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

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

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

419420YAML_DECLARE(int)

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

421422

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

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

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

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

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

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

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

426427 1) : \

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

428429 0))

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

452453#define POP(context,stack) \

453454 (*(--(stack).top))

454455

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

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

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

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

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

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

459460 1) : \

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

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

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

659660

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+

660686/* 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"

662688#define YAML_VERSION_MAJOR 0

663−#define YAML_VERSION_MINOR 1

664−#define YAML_VERSION_PATCH 7

689+#define YAML_VERSION_MINOR 2

690+#define YAML_VERSION_PATCH 1

vendor/libyaml+1−1

Submodule changed.