Add yaml_emitter_emit_* set of functions.

diff --git a/include/yaml.h b/include/yaml.h
index 204872ab3b0ba55a601e0167c19cf43f9848bb55..a4fc4e8afedde448625d311c8299de280ca5174b 100644 (file)
--- a/include/yaml.h
+++ b/include/yaml.h
@@ -1139,14 +1139,14 @@ yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical);
  * Set the intendation increment.
  *
  * @param[in]   emitter     An emitter object.
- * @param[in]   indent      The indentation increment (> 1).
+ * @param[in]   indent      The indentation increment (1 < . < 10).
  */
 
 YAML_DECLARE(void)
 yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent);
 
 /**
- * Set the preferred line width. @c 0 means unlimited.
+ * Set the preferred line width. @c -1 means unlimited.
  *
  * @param[in]   emitter     An emitter object.
  * @param[in]   width       The preferred line width.

diff --git a/src/Makefile.am b/src/Makefile.am
index 25a5bc82e8d81a1324558820da9419ebdd12f9e9..cc815e73468652e4b99bcad87b981bafdfe5ad63 100644 (file)
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,4 +1,4 @@
 AM_CPPFLAGS = -I$(top_srcdir)/include
 lib_LTLIBRARIES = libyaml.la
-libyaml_la_SOURCES = api.c reader.c scanner.c parser.c writer.c
+libyaml_la_SOURCES = api.c reader.c scanner.c parser.c writer.c emitter.c
 libyaml_la_LDFLAGS = -release $(YAML_LT_RELEASE) -version-info $(YAML_LT_CURRENT):$(YAML_LT_REVISION):$(YAML_LT_AGE)

diff --git a/src/api.c b/src/api.c
index 90d86fddee87e11aebce9f5f2f4ea1dde0e6c1cf..8d5f624f48218237d473b461a13092e937ce15d4 100644 (file)
--- a/src/api.c
+++ b/src/api.c
@@ -57,10 +57,13 @@ yaml_free(void *ptr)
  * Duplicate a string.
  */
 
-YAML_DECLARE(char *)
-yaml_strdup(const char *str)
+YAML_DECLARE(yaml_char_t *)
+yaml_strdup(const yaml_char_t *str)
 {
-    return strdup(str);
+    if (!str)
+        return NULL;
+
+    return (yaml_char_t *)strdup((char *)str);
 }
 
 /*
@@ -389,6 +392,7 @@ yaml_emitter_delete(yaml_emitter_t *emitter)
         yaml_event_delete(&DEQUEUE(emitter, emitter->events));
     }
     STACK_DEL(emitter, emitter->indents);
+    yaml_event_delete(&emitter->event);
     while (!STACK_EMPTY(empty, emitter->tag_directives)) {
         yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
         yaml_free(tag_directive.handle);
@@ -536,7 +540,7 @@ yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
 {
     assert(emitter);    /* Non-NULL emitter object expected. */
 
-    emitter->best_width = (width > 0) ? width : 0;
+    emitter->best_width = (width >= 0) ? width : -1;
 }
 
 /*

diff --git a/src/emitter.c b/src/emitter.c
new file mode 100644 (file)
index 0000000..e659e3e
--- /dev/null
+++ b/src/emitter.c
@@ -0,0 +1,408 @@
+
+#include "yaml_private.h"
+
+/*
+ * API functions.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
+
+YAML_DECLARE(int)
+yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
+        yaml_encoding_t encoding);
+
+YAML_DECLARE(int)
+yaml_emitter_emit_stream_end(yaml_emitter_t *emitter);
+
+YAML_DECLARE(int)
+yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
+        yaml_version_directive_t *version_directive,
+        yaml_tag_directive_t *tag_directives_start,
+        yaml_tag_directive_t *tag_directives_end,
+        int implicit);
+
+YAML_DECLARE(int)
+yaml_emitter_emit_document_end(yaml_emitter_t *emitter, int implicit);
+
+YAML_DECLARE(int)
+yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_char_t *anchor);
+
+YAML_DECLARE(int)
+yaml_emitter_emit_scalar(yaml_emitter_t *emitter,
+        yaml_char_t *anchor, yaml_char_t *tag,
+        yaml_char_t *value, size_t length,
+        int plain_implicit, int quoted_implicit,
+        yaml_scalar_style_t style);
+
+YAML_DECLARE(int)
+yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter,
+        yaml_char_t *anchor, yaml_char_t *tag, int implicit,
+        yaml_sequence_style_t style);
+
+YAML_DECLARE(int)
+yaml_emitter_emit_sequence_end(yaml_emitter_t *emitter);
+
+YAML_DECLARE(int)
+yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter,
+        yaml_char_t *anchor, yaml_char_t *tag, int implicit,
+        yaml_mapping_style_t style);
+
+YAML_DECLARE(int)
+yaml_emitter_emit_mapping_end(yaml_emitter_t *emitter);
+
+/*
+ * Emit STREAM-START.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
+        yaml_encoding_t encoding)
+{
+    yaml_event_t event;
+    yaml_mark_t mark = { 0, 0, 0 };
+
+    assert(emitter);    /* Non-NULL emitter object is expected. */
+
+    STREAM_START_EVENT_INIT(event, encoding, mark, mark);
+
+    return yaml_emitter_emit(emitter, &event);
+}
+
+/*
+ * Emit STREAM-END.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit_stream_end(yaml_emitter_t *emitter)
+{
+    yaml_event_t event;
+    yaml_mark_t mark = { 0, 0, 0 };
+
+    assert(emitter);    /* Non-NULL emitter object is expected. */
+
+    STREAM_END_EVENT_INIT(event, mark, mark);
+
+    return yaml_emitter_emit(emitter, &event);
+}
+
+/*
+ * Emit DOCUMENT-START.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
+        yaml_version_directive_t *version_directive,
+        yaml_tag_directive_t *tag_directives_start,
+        yaml_tag_directive_t *tag_directives_end,
+        int implicit)
+{
+    yaml_event_t event;
+    yaml_mark_t mark = { 0, 0, 0 };
+    yaml_version_directive_t *version_directive_copy = NULL;
+    struct {
+        yaml_tag_directive_t *start;
+        yaml_tag_directive_t *end;
+        yaml_tag_directive_t *top;
+    } tag_directives_copy = { NULL, NULL, NULL };
+    yaml_tag_directive_t value = { NULL, NULL };
+
+    assert(emitter);        /* Non-NULL emitter object is expected. */
+    assert((tag_directives_start && tag_directives_end) ||
+            (tag_directives_start == tag_directives_end));
+                            /* Valid tag directives are expected. */
+
+    if (version_directive) {
+        version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
+        if (!version_directive_copy) {
+            emitter->error = YAML_MEMORY_ERROR;
+            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(emitter, tag_directives_copy, INITIAL_STACK_SIZE))
+            goto error;
+        for (tag_directive = tag_directives_start;
+                tag_directive != tag_directives_end; tag_directive ++) {
+            value.handle = yaml_strdup(tag_directive->handle);
+            value.prefix = yaml_strdup(tag_directive->prefix);
+            if (!value.handle || !value.prefix) {
+                emitter->error = YAML_MEMORY_ERROR;
+                goto error;
+            }
+            if (!PUSH(emitter, tag_directives_copy, value))
+                goto error;
+            value.handle = NULL;
+            value.prefix = NULL;
+        }
+    }
+
+    DOCUMENT_START_EVENT_INIT(event, version_directive_copy,
+            tag_directives_copy.start, tag_directives_copy.end,
+            implicit, mark, mark);
+
+    if (yaml_emitter_emit(emitter, &event)) {
+        return 1;
+    }
+
+error:
+    yaml_free(version_directive_copy);
+    while (!STACK_EMPTY(emitter, tag_directives_copy)) {
+        yaml_tag_directive_t value = POP(emitter, tag_directives_copy);
+        yaml_free(value.handle);
+        yaml_free(value.prefix);
+    }
+    STACK_DEL(emitter, tag_directives_copy);
+    yaml_free(value.handle);
+    yaml_free(value.prefix);
+
+    return 0;
+}
+
+/*
+ * Emit DOCUMENT-END.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit_document_end(yaml_emitter_t *emitter, int implicit)
+{
+    yaml_event_t event;
+    yaml_mark_t mark = { 0, 0, 0 };
+
+    assert(emitter);    /* Non-NULL emitter object is expected. */
+
+    DOCUMENT_END_EVENT_INIT(event, implicit, mark, mark);
+
+    return yaml_emitter_emit(emitter, &event);
+}
+
+/*
+ * Emit ALIAS.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_char_t *anchor)
+{
+    yaml_event_t event;
+    yaml_mark_t mark = { 0, 0, 0 };
+    yaml_char_t *anchor_copy = NULL;
+
+    assert(emitter);    /* Non-NULL emitter object is expected. */
+    assert(anchor);     /* Non-NULL anchor is expected. */
+
+    anchor_copy = yaml_strdup(anchor);
+    if (!anchor_copy) {
+        emitter->error = YAML_MEMORY_ERROR;
+        return 0;
+    }
+
+    ALIAS_EVENT_INIT(event, anchor_copy, mark, mark);
+
+    if (yaml_emitter_emit(emitter, &event)) {
+        return 1;
+    }
+
+    yaml_free(anchor_copy);
+
+    return 0;
+}
+
+/*
+ * Emit SCALAR.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit_scalar(yaml_emitter_t *emitter,
+        yaml_char_t *anchor, yaml_char_t *tag,
+        yaml_char_t *value, size_t length,
+        int plain_implicit, int quoted_implicit,
+        yaml_scalar_style_t style)
+{
+    yaml_event_t event;
+    yaml_mark_t mark = { 0, 0, 0 };
+    yaml_char_t *anchor_copy = NULL;
+    yaml_char_t *tag_copy = NULL;
+    yaml_char_t *value_copy = NULL;
+
+    assert(emitter);    /* Non-NULL emitter object is expected. */
+    assert(value);      /* Non-NULL anchor is expected. */
+
+    if (anchor) {
+        anchor_copy = yaml_strdup(anchor);
+        if (!anchor_copy) {
+            emitter->error = YAML_MEMORY_ERROR;
+            goto error;
+        }
+    }
+
+    if (tag) {
+        tag_copy = yaml_strdup(tag);
+        if (!tag_copy) {
+            emitter->error = YAML_MEMORY_ERROR;
+            goto error;
+        }
+    }
+
+    value_copy = yaml_malloc(length+1);
+    if (!value_copy) {
+        emitter->error = YAML_MEMORY_ERROR;
+        goto error;
+    }
+    memcpy(value_copy, value, length);
+    value_copy[length] = '\0';
+
+    SCALAR_EVENT_INIT(event, anchor_copy, tag_copy, value_copy, length,
+            plain_implicit, quoted_implicit, style, mark, mark);
+
+    if (yaml_emitter_emit(emitter, &event)) {
+        return 1;
+    }
+
+error:
+    yaml_free(anchor_copy);
+    yaml_free(tag_copy);
+    yaml_free(value_copy);
+
+    return 0;
+}
+
+/*
+ * Emit SEQUENCE-START.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter,
+        yaml_char_t *anchor, yaml_char_t *tag, int implicit,
+        yaml_sequence_style_t style)
+{
+    yaml_event_t event;
+    yaml_mark_t mark = { 0, 0, 0 };
+    yaml_char_t *anchor_copy = NULL;
+    yaml_char_t *tag_copy = NULL;
+
+    assert(emitter);    /* Non-NULL emitter object is expected. */
+
+    if (anchor) {
+        anchor_copy = yaml_strdup(anchor);
+        if (!anchor_copy) {
+            emitter->error = YAML_MEMORY_ERROR;
+            goto error;
+        }
+    }
+
+    if (tag) {
+        tag_copy = yaml_strdup(tag);
+        if (!tag_copy) {
+            emitter->error = YAML_MEMORY_ERROR;
+            goto error;
+        }
+    }
+
+    SEQUENCE_START_EVENT_INIT(event, anchor_copy, tag_copy,
+            implicit, style, mark, mark);
+
+    if (yaml_emitter_emit(emitter, &event)) {
+        return 1;
+    }
+
+error:
+    yaml_free(anchor_copy);
+    yaml_free(tag_copy);
+
+    return 0;
+}
+
+/*
+ * Emit SEQUENCE-END.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit_sequence_end(yaml_emitter_t *emitter)
+{
+    yaml_event_t event;
+    yaml_mark_t mark = { 0, 0, 0 };
+
+    assert(emitter);    /* Non-NULL emitter object is expected. */
+
+    SEQUENCE_END_EVENT_INIT(event, mark, mark);
+
+    return yaml_emitter_emit(emitter, &event);
+}
+
+/*
+ * Emit MAPPING-START.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter,
+        yaml_char_t *anchor, yaml_char_t *tag, int implicit,
+        yaml_mapping_style_t style)
+{
+    yaml_event_t event;
+    yaml_mark_t mark = { 0, 0, 0 };
+    yaml_char_t *anchor_copy = NULL;
+    yaml_char_t *tag_copy = NULL;
+
+    assert(emitter);    /* Non-NULL emitter object is expected. */
+
+    if (anchor) {
+        anchor_copy = yaml_strdup(anchor);
+        if (!anchor_copy) {
+            emitter->error = YAML_MEMORY_ERROR;
+            goto error;
+        }
+    }
+
+    if (tag) {
+        tag_copy = yaml_strdup(tag);
+        if (!tag_copy) {
+            emitter->error = YAML_MEMORY_ERROR;
+            goto error;
+        }
+    }
+
+    MAPPING_START_EVENT_INIT(event, anchor_copy, tag_copy,
+            implicit, style, mark, mark);
+
+    if (yaml_emitter_emit(emitter, &event)) {
+        return 1;
+    }
+
+error:
+    yaml_free(anchor_copy);
+    yaml_free(tag_copy);
+
+    return 0;
+}
+
+/*
+ * Emit MAPPING-END.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit_mapping_end(yaml_emitter_t *emitter)
+{
+    yaml_event_t event;
+    yaml_mark_t mark = { 0, 0, 0 };
+
+    assert(emitter);    /* Non-NULL emitter object is expected. */
+
+    MAPPING_END_EVENT_INIT(event, mark, mark);
+
+    return yaml_emitter_emit(emitter, &event);
+}
+
+/*
+ * Emit an event.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
+{
+    return 0;
+}
+

diff --git a/src/parser.c b/src/parser.c
index 020d5d6898a0af388388f038359702c03c88f47c..ed3c019ae6fc4ede9ba8a1f413e914f8f21b799c 100644 (file)
--- a/src/parser.c
+++ b/src/parser.c
@@ -1335,8 +1335,8 @@ yaml_parser_append_tag_directive(yaml_parser_t *parser,
         }
     }
 
-    copy.handle = (yaml_char_t *)yaml_strdup((char *)value.handle);
-    copy.prefix = (yaml_char_t *)yaml_strdup((char *)value.prefix);
+    copy.handle = yaml_strdup(value.handle);
+    copy.prefix = yaml_strdup(value.prefix);
     if (!copy.handle || !copy.prefix) {
         parser->error = YAML_MEMORY_ERROR;
         goto error;

diff --git a/src/yaml_private.h b/src/yaml_private.h
index 7304d8d3376f2b6cff568ef0410660483b295a58..faa855bd62d6e15ffb912854abcec82e0bc6aaa9 100644 (file)
--- a/src/yaml_private.h
+++ b/src/yaml_private.h
@@ -20,8 +20,8 @@ yaml_realloc(void *ptr, size_t size);
 YAML_DECLARE(void)
 yaml_free(void *ptr);
 
-YAML_DECLARE(char *)
-yaml_strdup(const char *);
+YAML_DECLARE(yaml_char_t *)
+yaml_strdup(const yaml_char_t *);
 
 /*
  * Reader: Ensure that the buffer contains at least `length` characters.