Index: libyaml/trunk/src/api.c
===================================================================
--- libyaml/trunk/src/api.c	(revision 263)
+++ libyaml/trunk/src/api.c	(revision 264)
@@ -68,9 +68,114 @@
 
 /*
+ * Format an error message.
+ */
+
+YAML_DECLARE(int)
+yaml_error_message(yaml_error_t *error, char *buffer, size_t capacity)
+{
+    char *prefixes[] = {
+        "No error",
+        "Memory error",
+        "Reader error",
+        "Decoder error",
+        "Scanner error",
+        "Parser error",
+        "Composer error",
+        "Writer error",
+        "Emitter error",
+        "Serializer error",
+        "Resolver error",
+    };
+    int length;
+
+    assert(error);  /* Non-NULL error is expected. */
+    assert(buffer); /* Non-NULL buffer is expected. */
+
+    switch (error->type)
+    {
+        case YAML_NO_ERROR:
+        case YAML_MEMORY_ERROR:
+            length = snprintf(buffer, capacity, "%s",
+                    prefixes[error->type]);
+            break;
+
+        case YAML_READER_ERROR:
+        case YAML_DECODER_ERROR:
+            if (error->data.reading.value == -1) {
+                length = snprintf(buffer, capacity,
+                        "%s: %s at position %d",
+                        prefixes[error->type],
+                        error->data.reading.problem,
+                        error->data.reading.offset);
+            }
+            else {
+                length = snprintf(buffer, capacity,
+                        "%s: %s (#%X) at position %d",
+                        prefixes[error->type],
+                        error->data.reading.problem,
+                        error->data.reading.value,
+                        error->data.reading.offset);
+            }
+            break;
+
+        case YAML_SCANNER_ERROR:
+        case YAML_PARSER_ERROR:
+        case YAML_COMPOSER_ERROR:
+            if (!error->data.loading.context) {
+                length = snprintf(buffer, capacity,
+                        "%s: %s at line %d, column %d",
+                        prefixes[error->type],
+                        error->data.loading.problem,
+                        error->data.loading.problem_mark.line+1,
+                        error->data.loading.problem_mark.column+1);
+            }
+            else {
+                length = snprintf(buffer, capacity,
+                        "%s: %s at line %d, column %d, %s at line %d, column %d",
+                        prefixes[error->type],
+                        error->data.loading.context,
+                        error->data.loading.context_mark.line+1,
+                        error->data.loading.context_mark.column+1,
+                        error->data.loading.problem,
+                        error->data.loading.problem_mark.line+1,
+                        error->data.loading.problem_mark.column+1);
+            }
+            break;
+
+        case YAML_WRITER_ERROR:
+            length = snprintf(buffer, capacity,
+                    "%s: %s at position %d",
+                    prefixes[error->type],
+                    error->data.writing.problem,
+                    error->data.writing.offset);
+            break;
+
+        case YAML_EMITTER_ERROR:
+        case YAML_SERIALIZER_ERROR:
+            length = snprintf(buffer, capacity, "%s: %s",
+                    prefixes[error->type],
+                    error->data.dumping.problem);
+            break;
+
+        case YAML_RESOLVER_ERROR:
+            length = snprintf(buffer, capacity, "%s: %s",
+                    prefixes[error->type],
+                    error->data.resolving.problem);
+            break;
+
+        default:
+            assert(0);  /* Should never happen. */
+    }
+
+    return (length >= 0 && length < capacity);
+}
+
+
+/*
  * Extend a string.
  */
 
 YAML_DECLARE(int)
-yaml_string_extend(yaml_char_t **buffer, size_t *capacity)
+yaml_ostring_extend(yaml_char_t **buffer, size_t *capacity)
 {
     yaml_char_t *new_buffer = yaml_realloc(*buffer, (*capacity)*2);
@@ -91,7 +196,7 @@
 
 YAML_DECLARE(int)
-yaml_string_join(
+yaml_ostring_join(
         yaml_char_t **base_buffer, size_t *base_pointer, size_t *base_capacity,
-        yaml_char_t *adj_buffer, size_t adj_pointer, size_t adj_capacity)
+        yaml_char_t *adj_buffer, size_t adj_pointer)
 {
     if (!adj_pointer)
@@ -99,5 +204,5 @@
 
     while (*base_capacity - *base_pointer <= adj_pointer) {
-        if (!yaml_string_extend(base_buffer, base_capacity))
+        if (!yaml_ostring_extend(base_buffer, base_capacity))
             return 0;
     }
@@ -173,7 +278,7 @@
 
     memset(parser, 0, sizeof(yaml_parser_t));
-    if (!STRING_INIT(parser, parser->raw_input, RAW_INPUT_BUFFER_CAPACITY))
+    if (!IOSTRING_INIT(parser, parser->raw_input, RAW_INPUT_BUFFER_CAPACITY))
         goto error;
-    if (!STRING_INIT(parser, parser->input, INPUT_BUFFER_CAPACITY))
+    if (!IOSTRING_INIT(parser, parser->input, INPUT_BUFFER_CAPACITY))
         goto error;
     if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_CAPACITY))
@@ -207,6 +312,6 @@
     assert(parser); /* Non-NULL parser object expected. */
 
-    STRING_DEL(parser, parser->raw_input);
-    STRING_DEL(parser, parser->input);
+    IOSTRING_DEL(parser, parser->raw_input);
+    IOSTRING_DEL(parser, parser->input);
     while (!QUEUE_EMPTY(parser, parser->tokens)) {
         yaml_token_destroy(&DEQUEUE(parser, parser->tokens));
@@ -250,11 +355,11 @@
     yaml_standard_reader_data_t *data = untyped_data;
 
-    if (data->string.pointer == data->string.capacity) {
+    if (data->string.pointer == data->string.length) {
         *length = 0;
         return 1;
     }
 
-    if (capacity > (size_t)(data->string.capacity - data->string.pointer)) {
-        capacity = data->string.capacity - data->string.pointer;
+    if (capacity > (size_t)(data->string.length - data->string.pointer)) {
+        capacity = data->string.length - data->string.pointer;
     }
 
@@ -294,7 +399,7 @@
     parser->reader_data = &(parser->standard_reader_data);
 
-    parser->standard_reader_data.string.buffer = (unsigned char *)buffer;
+    parser->standard_reader_data.string.buffer = buffer;
     parser->standard_reader_data.string.pointer = 0;
-    parser->standard_reader_data.string.capacity = length;
+    parser->standard_reader_data.string.length = length;
 }
 
@@ -358,7 +463,7 @@
 
     memset(emitter, 0, sizeof(yaml_emitter_t));
-    if (!STRING_INIT(emitter, emitter->output, OUTPUT_BUFFER_CAPACITY))
+    if (!IOSTRING_INIT(emitter, emitter->output, OUTPUT_BUFFER_CAPACITY))
         goto error;
-    if (!STRING_INIT(emitter, emitter->raw_output, RAW_OUTPUT_BUFFER_CAPACITY))
+    if (!IOSTRING_INIT(emitter, emitter->raw_output, RAW_OUTPUT_BUFFER_CAPACITY))
         goto error;
     if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_CAPACITY))
@@ -388,6 +493,6 @@
     assert(emitter);    /* Non-NULL emitter object expected. */
 
-    STRING_DEL(emitter, emitter->output);
-    STRING_DEL(emitter, emitter->raw_output);
+    IOSTRING_DEL(emitter, emitter->output);
+    IOSTRING_DEL(emitter, emitter->raw_output);
     STACK_DEL(emitter, emitter->states);
     while (!QUEUE_EMPTY(emitter, emitter->events)) {
@@ -425,5 +530,5 @@
 
 static int
-yaml_string_writer(void *untyped_data, unsigned char *buffer, size_t length)
+yaml_string_writer(void *untyped_data, const unsigned char *buffer, size_t length)
 {
     yaml_standard_writer_data_t *data = untyped_data;
@@ -447,5 +552,5 @@
 
 static int
-yaml_file_writer(void *untyped_data, unsigned char *buffer, size_t length)
+yaml_file_writer(void *untyped_data, const unsigned char *buffer, size_t length)
 {
     yaml_standard_writer_data_t *data = untyped_data;
@@ -617,5 +722,5 @@
 
 YAML_DECLARE(int)
-yaml_token_duplicate(yaml_token_t *token, yaml_token_t *model)
+yaml_token_duplicate(yaml_token_t *token, const yaml_token_t *model)
 {
     assert(token);  /* Non-NULL token object is expected. */
@@ -810,5 +915,5 @@
 
 YAML_DECLARE(int)
-yaml_event_duplicate(yaml_event_t *event, yaml_event_t *model)
+yaml_event_duplicate(yaml_event_t *event, const yaml_event_t *model)
 {
     struct {