src/yaml_private.h

   1
   2 #if HAVE_CONFIG_H
   3 #include <config.h>
   4 #endif
   5
   6 #include <yaml.h>
   7
   8 #include <assert.h>
   9 #include <limits.h>
  10
  11 /*
  12  * Memory management.
  13  */
  14
  15 YAML_DECLARE(void *)
  16 yaml_malloc(size_t size);
  17
  18 YAML_DECLARE(void *)
  19 yaml_realloc(void *ptr, size_t size);
  20
  21 YAML_DECLARE(void)
  22 yaml_free(void *ptr);
  23
  24 YAML_DECLARE(yaml_char_t *)
  25 yaml_strdup(const yaml_char_t *);
  26
  27 /*
  28  * Reader: Ensure that the buffer contains at least `length` characters.
  29  */
  30
  31 YAML_DECLARE(int)
  32 yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
  33
  34 /*
  35  * Scanner: Ensure that the token stack contains at least one token ready.
  36  */
  37
  38 YAML_DECLARE(int)
  39 yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
  40
  41 /*
  42  * The size of the input raw buffer.
  43  */
  44
  45 #define INPUT_RAW_BUFFER_SIZE   16384
  46
  47 /*
  48  * The size of the input buffer.
  49  *
  50  * It should be possible to decode the whole raw buffer.
  51  */
  52
  53 #define INPUT_BUFFER_SIZE       (INPUT_RAW_BUFFER_SIZE*3)
  54
  55 /*
  56  * The size of the output buffer.
  57  */
  58
  59 #define OUTPUT_BUFFER_SIZE      16384
  60
  61 /*
  62  * The size of the output raw buffer.
  63  *
  64  * It should be possible to encode the whole output buffer.
  65  */
  66
  67 #define OUTPUT_RAW_BUFFER_SIZE  (OUTPUT_BUFFER_SIZE*2+2)
  68
  69 /*
  70  * The size of other stacks and queues.
  71  */
  72
  73 #define INITIAL_STACK_SIZE  16
  74 #define INITIAL_QUEUE_SIZE  16
  75 #define INITIAL_STRING_SIZE 16
  76
  77 /*
  78  * Buffer management.
  79  */
  80
  81 #define BUFFER_INIT(context,buffer,size)                                        \
  82     (((buffer).start = yaml_malloc(size)) ?                                     \
  83         ((buffer).last = (buffer).pointer = (buffer).start,                     \
  84          (buffer).end = (buffer).start+(size),                                  \
  85          1) :                                                                   \
  86         ((context)->error = YAML_MEMORY_ERROR,                                  \
  87          0))
  88
  89 #define BUFFER_DEL(context,buffer)                                              \
  90     (yaml_free((buffer).start),                                                 \
  91      (buffer).start = (buffer).pointer = (buffer).end = 0)
  92
  93 /*
  94  * String management.
  95  */
  96
  97 typedef struct {
  98     yaml_char_t *start;
  99     yaml_char_t *end;
 100     yaml_char_t *pointer;
 101 } yaml_string_t;
 102
 103 YAML_DECLARE(int)
 104 yaml_string_extend(yaml_char_t **start,
 105         yaml_char_t **pointer, yaml_char_t **end);
 106
 107 YAML_DECLARE(int)
 108 yaml_string_join(
 109         yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
 110         yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end);
 111
 112 #define NULL_STRING { NULL, NULL, NULL }
 113
 114 #define STRING_INIT(context,string,size)                                        \
 115     (((string).start = yaml_malloc(size)) ?                                     \
 116         ((string).pointer = (string).start,                                     \
 117          (string).end = (string).start+(size),                                  \
 118          memset((string).start, 0, (size)),                                     \
 119          1) :                                                                   \
 120         ((context)->error = YAML_MEMORY_ERROR,                                  \
 121          0))
 122
 123 #define STRING_DEL(context,string)                                              \
 124     (yaml_free((string).start),                                                 \
 125      (string).start = (string).pointer = (string).end = 0)
 126
 127 #define STRING_EXTEND(context,string)                                           \
 128     (((string).pointer+5 < (string).end)                                        \
 129         || yaml_string_extend(&(string).start,                                  \
 130             &(string).pointer, &(string).end))
 131
 132 #define CLEAR(context,string)                                                   \
 133     ((string).pointer = (string).start,                                         \
 134      memset((string).start, 0, (string).end-(string).start))
 135
 136 #define JOIN(context,string_a,string_b)                                         \
 137     ((yaml_string_join(&(string_a).start, &(string_a).pointer,                  \
 138                        &(string_a).end, &(string_b).start,                      \
 139                        &(string_b).pointer, &(string_b).end)) ?                 \
 140         ((string_b).pointer = (string_b).start,                                 \
 141          1) :                                                                   \
 142         ((context)->error = YAML_MEMORY_ERROR,                                  \
 143          0))
 144
 145 /*
 146  * Stack and queue management.
 147  */
 148
 149 YAML_DECLARE(int)
 150 yaml_stack_extend(void **start, void **top, void **end);
 151
 152 YAML_DECLARE(int)
 153 yaml_queue_extend(void **start, void **head, void **tail, void **end);
 154
 155 #define STACK_INIT(context,stack,size)                                          \
 156     (((stack).start = yaml_malloc((size)*sizeof(*(stack).start))) ?             \
 157         ((stack).top = (stack).start,                                           \
 158          (stack).end = (stack).start+(size),                                    \
 159          1) :                                                                   \
 160         ((context)->error = YAML_MEMORY_ERROR,                                  \
 161          0))
 162
 163 #define STACK_DEL(context,stack)                                                \
 164     (yaml_free((stack).start),                                                  \
 165      (stack).start = (stack).top = (stack).end = 0)
 166
 167 #define STACK_EMPTY(context,stack)                                              \
 168     ((stack).start == (stack).top)
 169
 170 #define PUSH(context,stack,value)                                               \
 171     (((stack).top != (stack).end                                                \
 172       || yaml_stack_extend((void **)&(stack).start,                             \
 173               (void **)&(stack).top, (void **)&(stack).end)) ?                  \
 174         (*((stack).top++) = value,                                              \
 175          1) :                                                                   \
 176         ((context)->error = YAML_MEMORY_ERROR,                                  \
 177          0))
 178
 179 #define POP(context,stack)                                                      \
 180     (*(--(stack).top))
 181
 182 #define QUEUE_INIT(context,queue,size)                                          \
 183     (((queue).start = yaml_malloc((size)*sizeof(*(queue).start))) ?             \
 184         ((queue).head = (queue).tail = (queue).start,                           \
 185          (queue).end = (queue).start+(size),                                    \
 186          1) :                                                                   \
 187         ((context)->error = YAML_MEMORY_ERROR,                                  \
 188          0))
 189
 190 #define QUEUE_DEL(context,queue)                                                \
 191     (yaml_free((queue).start),                                                  \
 192      (queue).start = (queue).head = (queue).tail = (queue).end = 0)
 193
 194 #define QUEUE_EMPTY(context,queue)                                              \
 195     ((queue).head == (queue).tail)
 196
 197 #define ENQUEUE(context,queue,value)                                            \
 198     (((queue).tail != (queue).end                                               \
 199       || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head,     \
 200             (void **)&(queue).tail, (void **)&(queue).end)) ?                   \
 201         (*((queue).tail++) = value,                                             \
 202          1) :                                                                   \
 203         ((context)->error = YAML_MEMORY_ERROR,                                  \
 204          0))
 205
 206 #define DEQUEUE(context,queue)                                                  \
 207     (*((queue).head++))
 208
 209 #define QUEUE_INSERT(context,queue,index,value)                                 \
 210     (((queue).tail != (queue).end                                               \
 211       || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head,     \
 212             (void **)&(queue).tail, (void **)&(queue).end)) ?                   \
 213         (memmove((queue).head+(index)+1,(queue).head+(index),                   \
 214             ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)),        \
 215          *((queue).head+(index)) = value,                                       \
 216          (queue).tail++,                                                        \
 217          1) :                                                                   \
 218         ((context)->error = YAML_MEMORY_ERROR,                                  \
 219          0))
 220
 221 /*
 222  * Token initializers.
 223  */
 224
 225 #define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark)            \
 226     (memset(&(token), 0, sizeof(yaml_token_t)),                                 \
 227      (token).type = (token_type),                                               \
 228      (token).start_mark = (token_start_mark),                                   \
 229      (token).end_mark = (token_end_mark))
 230
 231 #define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark)       \
 232     (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)),       \
 233      (token).data.stream_start.encoding = (token_encoding))
 234
 235 #define STREAM_END_TOKEN_INIT(token,start_mark,end_mark)                        \
 236     (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark)))
 237
 238 #define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark)                 \
 239     (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)),              \
 240      (token).data.alias.value = (token_value))
 241
 242 #define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark)                \
 243     (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)),             \
 244      (token).data.anchor.value = (token_value))
 245
 246 #define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark)     \
 247     (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)),                \
 248      (token).data.tag.handle = (token_handle),                                  \
 249      (token).data.tag.suffix = (token_suffix))
 250
 251 #define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark)   \
 252     (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)),             \
 253      (token).data.scalar.value = (token_value),                                 \
 254      (token).data.scalar.length = (token_length),                               \
 255      (token).data.scalar.style = (token_style))
 256
 257 #define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark)     \
 258     (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)),  \
 259      (token).data.version_directive.major = (token_major),                      \
 260      (token).data.version_directive.minor = (token_minor))
 261
 262 #define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark)       \
 263     (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)),      \
 264      (token).data.tag_directive.handle = (token_handle),                        \
 265      (token).data.tag_directive.prefix = (token_prefix))
 266
 267 /*
 268  * Event initializers.
 269  */
 270
 271 #define EVENT_INIT(event,event_type,event_start_mark,event_end_mark)            \
 272     (memset(&(event), 0, sizeof(yaml_event_t)),                                 \
 273      (event).type = (event_type),                                               \
 274      (event).start_mark = (event_start_mark),                                   \
 275      (event).end_mark = (event_end_mark))
 276
 277 #define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark)       \
 278     (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)),       \
 279      (event).data.stream_start.encoding = (event_encoding))
 280
 281 #define STREAM_END_EVENT_INIT(event,start_mark,end_mark)                        \
 282     (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark)))
 283
 284 #define DOCUMENT_START_EVENT_INIT(event,event_version_directive,                \
 285         event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \
 286     (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)),     \
 287      (event).data.document_start.version_directive = (event_version_directive), \
 288      (event).data.document_start.tag_directives.start = (event_tag_directives_start),   \
 289      (event).data.document_start.tag_directives.end = (event_tag_directives_end),   \
 290      (event).data.document_start.implicit = (event_implicit))
 291
 292 #define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark)       \
 293     (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)),       \
 294      (event).data.document_end.implicit = (event_implicit))
 295
 296 #define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark)                \
 297     (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)),              \
 298      (event).data.alias.anchor = (event_anchor))
 299
 300 #define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length,    \
 301         event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark)    \
 302     (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)),             \
 303      (event).data.scalar.anchor = (event_anchor),                               \
 304      (event).data.scalar.tag = (event_tag),                                     \
 305      (event).data.scalar.value = (event_value),                                 \
 306      (event).data.scalar.length = (event_length),                               \
 307      (event).data.scalar.plain_implicit = (event_plain_implicit),               \
 308      (event).data.scalar.quoted_implicit = (event_quoted_implicit),             \
 309      (event).data.scalar.style = (event_style))
 310
 311 #define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag,                 \
 312         event_implicit,event_style,start_mark,end_mark)                         \
 313     (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)),     \
 314      (event).data.sequence_start.anchor = (event_anchor),                       \
 315      (event).data.sequence_start.tag = (event_tag),                             \
 316      (event).data.sequence_start.implicit = (event_implicit),                   \
 317      (event).data.sequence_start.style = (event_style))
 318
 319 #define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark)                      \
 320     (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark)))
 321
 322 #define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag,                  \
 323         event_implicit,event_style,start_mark,end_mark)                         \
 324     (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)),      \
 325      (event).data.mapping_start.anchor = (event_anchor),                        \
 326      (event).data.mapping_start.tag = (event_tag),                              \
 327      (event).data.mapping_start.implicit = (event_implicit),                    \
 328      (event).data.mapping_start.style = (event_style))
 329
 330 #define MAPPING_END_EVENT_INIT(event,start_mark,end_mark)                       \
 331     (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark)))
 332