Merge pull request #365 from phst/bug352

Use last byte of error text as numeric error code

doc/apiref.rst

@@ -813,6 +813,9 @@ this struct.
       The error message (in UTF-8), or an empty string if a message is
       not available.
 
+      The last byte of this array contains a numeric error code.  Use
+      :func:`json_error_code()` to extract this code.
+
    .. member:: char source[]
 
       Source of the error. This can be (a part of) the file name or a
@@ -855,6 +858,93 @@ success. See :ref:`apiref-decoding` for more info.
 All functions also accept *NULL* as the :type:`json_error_t` pointer,
 in which case no error information is returned to the caller.
 
+.. type:: enum json_error_code
+
+   An enumeration containing numeric error codes.  The following errors are
+   currently defined:
+
+   ``json_error_unknown``
+
+       Unknown error.  This should only be returned for non-errorneous
+       :type:`json_error_t` structures.
+
+   ``json_error_out_of_memory``
+
+       The library couldn’t allocate any heap memory.
+
+   ``json_error_stack_overflow``
+
+       Nesting too deep.
+
+   ``json_error_cannot_open_file``
+
+       Couldn’t open input file.
+
+   ``json_error_invalid_argument``
+
+       A function argument was invalid.
+
+   ``json_error_invalid_utf8``
+
+       The input string isn’t valid UTF-8.
+
+   ``json_error_premature_end_of_input``
+
+       The input ended in the middle of a JSON value.
+
+   ``json_error_end_of_input_expected``
+
+       There was some text after the end of a JSON value.  See the
+       ``JSON_DISABLE_EOF_CHECK`` flag.
+
+   ``json_error_invalid_syntax``
+
+       JSON syntax error.
+
+   ``json_error_invalid_format``
+
+       Invalid format string for packing or unpacking.
+
+   ``json_error_wrong_type``
+
+       When packing or unpacking, the actual type of a value differed from the
+       one specified in the format string.
+
+   ``json_error_null_character``
+
+       A null character was detected in a JSON string.  See the
+       ``JSON_ALLOW_NUL`` flag.
+
+   ``json_error_null_value``
+
+       When packing or unpacking, some key or value was ``NULL``.
+
+   ``json_error_null_byte_in_key``
+
+       An object key would contain a null byte.  Jansson can’t represent such
+       keys; see :ref:`rfc-conformance`.
+
+   ``json_error_duplicate_key``
+
+       Duplicate key in object.  See the ``JSON_REJECT_DUPLICATES`` flag.
+
+   ``json_error_numeric_overflow``
+
+       When converting a JSON number to a C numeric type, a numeric overflow
+       was detected.
+
+   ``json_error_item_not_found``
+
+       Key in object not found.
+
+   ``json_error_index_out_of_range``
+
+       Array index is out of range.
+
+.. function:: enum json_error_code json_error_code(const json_error_t *error)
+
+   Returns the error code embedded in ``error->text``.
+
 
 Encoding
 ========

src/error.c

@@ -34,17 +34,19 @@ void jsonp_error_set_source(json_error_t *error, const char *source)
 }
 
 void jsonp_error_set(json_error_t *error, int line, int column,
-                     size_t position, const char *msg, ...)
+                     size_t position, enum json_error_code code,
+                     const char *msg, ...)
 {
     va_list ap;
 
     va_start(ap, msg);
-    jsonp_error_vset(error, line, column, position, msg, ap);
+    jsonp_error_vset(error, line, column, position, code, msg, ap);
     va_end(ap);
 }
 
 void jsonp_error_vset(json_error_t *error, int line, int column,
-                      size_t position, const char *msg, va_list ap)
+                      size_t position, enum json_error_code code,
+                      const char *msg, va_list ap)
 {
     if(!error)
         return;
@@ -58,6 +60,7 @@ void jsonp_error_vset(json_error_t *error, int line, int column,
     error->column = column;
     error->position = (int)position;
 
-    vsnprintf(error->text, JSON_ERROR_TEXT_LENGTH, msg, ap);
+    vsnprintf(error->text, JSON_ERROR_TEXT_LENGTH - 1, msg, ap);
-    error->text[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
+    error->text[JSON_ERROR_TEXT_LENGTH - 2] = '\0';
+    error->text[JSON_ERROR_TEXT_LENGTH - 1] = code;
 }

src/jansson.h

@@ -139,6 +139,30 @@ typedef struct json_error_t {
     char text[JSON_ERROR_TEXT_LENGTH];
 } json_error_t;
 
+enum json_error_code {
+    json_error_unknown,
+    json_error_out_of_memory,
+    json_error_stack_overflow,
+    json_error_cannot_open_file,
+    json_error_invalid_argument,
+    json_error_invalid_utf8,
+    json_error_premature_end_of_input,
+    json_error_end_of_input_expected,
+    json_error_invalid_syntax,
+    json_error_invalid_format,
+    json_error_wrong_type,
+    json_error_null_character,
+    json_error_null_value,
+    json_error_null_byte_in_key,
+    json_error_duplicate_key,
+    json_error_numeric_overflow,
+    json_error_item_not_found,
+    json_error_index_out_of_range
+};
+
+static JSON_INLINE enum json_error_code json_error_code(const json_error_t *e) {
+    return e->text[JSON_ERROR_TEXT_LENGTH - 1];
+}
 
 /* getters, setters, manipulation */
 

src/jansson_private.h

@@ -75,9 +75,11 @@ json_t *jsonp_stringn_nocheck_own(const char *value, size_t len);
 void jsonp_error_init(json_error_t *error, const char *source);
 void jsonp_error_set_source(json_error_t *error, const char *source);
 void jsonp_error_set(json_error_t *error, int line, int column,
-                     size_t position, const char *msg, ...);
+                     size_t position, enum json_error_code code,
+                     const char *msg, ...);
 void jsonp_error_vset(json_error_t *error, int line, int column,
-                      size_t position, const char *msg, va_list ap);
+                      size_t position, enum json_error_code code,
+                      const char *msg, va_list ap);
 
 /* Locale independent string<->double conversions */
 int jsonp_strtod(strbuffer_t *strbuffer, double *out);

src/load.c

@@ -84,6 +84,7 @@ typedef struct {
 /*** error reporting ***/
 
 static void error_set(json_error_t *error, const lex_t *lex,
+                      enum json_error_code code,
                       const char *msg, ...)
 {
     va_list ap;
@@ -134,7 +135,7 @@ static void error_set(json_error_t *error, const lex_t *lex,
         }
     }
 
-    jsonp_error_set(error, line, col, pos, "%s", result);
+    jsonp_error_set(error, line, col, pos, code, "%s", result);
 }
 
 
@@ -213,7 +214,7 @@ static int stream_get(stream_t *stream, json_error_t *error)
 
 out:
     stream->state = STREAM_STATE_ERROR;
-    error_set(error, stream_to_lex(stream), "unable to decode byte 0x%x", c);
+    error_set(error, stream_to_lex(stream), json_error_invalid_utf8, "unable to decode byte 0x%x", c);
     return STREAM_STATE_ERROR;
 }
 
@@ -336,7 +337,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
             goto out;
 
         else if(c == STREAM_STATE_EOF) {
-            error_set(error, lex, "premature end of input");
+            error_set(error, lex, json_error_premature_end_of_input, "premature end of input");
             goto out;
         }
 
@@ -344,9 +345,9 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
             /* control character */
             lex_unget_unsave(lex, c);
             if(c == '\n')
-                error_set(error, lex, "unexpected newline");
+                error_set(error, lex, json_error_invalid_syntax, "unexpected newline");
             else
-                error_set(error, lex, "control character 0x%x", c);
+                error_set(error, lex, json_error_invalid_syntax, "control character 0x%x", c);
             goto out;
         }
 
@@ -356,7 +357,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
                 c = lex_get_save(lex, error);
                 for(i = 0; i < 4; i++) {
                     if(!l_isxdigit(c)) {
-                        error_set(error, lex, "invalid escape");
+                        error_set(error, lex, json_error_invalid_syntax, "invalid escape");
                         goto out;
                     }
                     c = lex_get_save(lex, error);
@@ -366,7 +367,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
                     c == 'f' || c == 'n' || c == 'r' || c == 't')
                 c = lex_get_save(lex, error);
             else {
-                error_set(error, lex, "invalid escape");
+                error_set(error, lex, json_error_invalid_syntax, "invalid escape");
                 goto out;
             }
         }
@@ -400,7 +401,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
 
                 value = decode_unicode_escape(p);
                 if(value < 0) {
-                    error_set(error, lex, "invalid Unicode escape '%.6s'", p - 1);
+                    error_set(error, lex, json_error_invalid_syntax, "invalid Unicode escape '%.6s'", p - 1);
                     goto out;
                 }
                 p += 5;
@@ -410,7 +411,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
                     if(*p == '\\' && *(p + 1) == 'u') {
                         int32_t value2 = decode_unicode_escape(++p);
                         if(value2 < 0) {
-                            error_set(error, lex, "invalid Unicode escape '%.6s'", p - 1);
+                            error_set(error, lex, json_error_invalid_syntax, "invalid Unicode escape '%.6s'", p - 1);
                             goto out;
                         }
                         p += 5;
@@ -425,6 +426,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
                         else {
                             /* invalid second surrogate */
                             error_set(error, lex,
+                                      json_error_invalid_syntax,
                                       "invalid Unicode '\\u%04X\\u%04X'",
                                       value, value2);
                             goto out;
@@ -432,13 +434,13 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
                     }
                     else {
                         /* no second surrogate */
-                        error_set(error, lex, "invalid Unicode '\\u%04X'",
+                        error_set(error, lex, json_error_invalid_syntax, "invalid Unicode '\\u%04X'",
                                   value);
                         goto out;
                     }
                 }
                 else if(0xDC00 <= value && value <= 0xDFFF) {
-                    error_set(error, lex, "invalid Unicode '\\u%04X'", value);
+                    error_set(error, lex, json_error_invalid_syntax, "invalid Unicode '\\u%04X'", value);
                     goto out;
                 }
 
@@ -526,9 +528,9 @@ static int lex_scan_number(lex_t *lex, int c, json_error_t *error)
         intval = json_strtoint(saved_text, &end, 10);
         if(errno == ERANGE) {
             if(intval < 0)
-                error_set(error, lex, "too big negative integer");
+                error_set(error, lex, json_error_numeric_overflow, "too big negative integer");
             else
-                error_set(error, lex, "too big integer");
+                error_set(error, lex, json_error_numeric_overflow, "too big integer");
             goto out;
         }
 
@@ -570,7 +572,7 @@ static int lex_scan_number(lex_t *lex, int c, json_error_t *error)
     lex_unget_unsave(lex, c);
 
     if(jsonp_strtod(&lex->saved_text, &doubleval)) {
-        error_set(error, lex, "real number overflow");
+        error_set(error, lex, json_error_numeric_overflow, "real number overflow");
         goto out;
     }
 
@@ -701,7 +703,7 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
         json_t *value;
 
         if(lex->token != TOKEN_STRING) {
-            error_set(error, lex, "string or '}' expected");
+            error_set(error, lex, json_error_invalid_syntax, "string or '}' expected");
             goto error;
         }
 
@@ -710,14 +712,14 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
             return NULL;
         if (memchr(key, '\0', len)) {
             jsonp_free(key);
-            error_set(error, lex, "NUL byte in object key not supported");
+            error_set(error, lex, json_error_null_byte_in_key, "NUL byte in object key not supported");
             goto error;
         }
 
         if(flags & JSON_REJECT_DUPLICATES) {
             if(json_object_get(object, key)) {
                 jsonp_free(key);
-                error_set(error, lex, "duplicate object key");
+                error_set(error, lex, json_error_duplicate_key, "duplicate object key");
                 goto error;
             }
         }
@@ -725,7 +727,7 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
         lex_scan(lex, error);
         if(lex->token != ':') {
             jsonp_free(key);
-            error_set(error, lex, "':' expected");
+            error_set(error, lex, json_error_invalid_syntax, "':' expected");
             goto error;
         }
 
@@ -753,7 +755,7 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
     }
 
     if(lex->token != '}') {
-        error_set(error, lex, "'}' expected");
+        error_set(error, lex, json_error_invalid_syntax, "'}' expected");
         goto error;
     }
 
@@ -793,7 +795,7 @@ static json_t *parse_array(lex_t *lex, size_t flags, json_error_t *error)
     }
 
     if(lex->token != ']') {
-        error_set(error, lex, "']' expected");
+        error_set(error, lex, json_error_invalid_syntax, "']' expected");
         goto error;
     }
 
@@ -810,7 +812,7 @@ static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)
 
     lex->depth++;
     if(lex->depth > JSON_PARSER_MAX_DEPTH) {
-        error_set(error, lex, "maximum parsing depth reached");
+        error_set(error, lex, json_error_stack_overflow, "maximum parsing depth reached");
         return NULL;
     }
 
@@ -821,7 +823,7 @@ static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)
 
             if(!(flags & JSON_ALLOW_NUL)) {
                 if(memchr(value, '\0', len)) {
-                    error_set(error, lex, "\\u0000 is not allowed without JSON_ALLOW_NUL");
+                    error_set(error, lex, json_error_null_character, "\\u0000 is not allowed without JSON_ALLOW_NUL");
                     return NULL;
                 }
             }
@@ -865,11 +867,11 @@ static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)
             break;
 
         case TOKEN_INVALID:
-            error_set(error, lex, "invalid token");
+            error_set(error, lex, json_error_invalid_syntax, "invalid token");
             return NULL;
 
         default:
-            error_set(error, lex, "unexpected token");
+            error_set(error, lex, json_error_invalid_syntax, "unexpected token");
             return NULL;
     }
 
@@ -889,7 +891,7 @@ static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error)
     lex_scan(lex, error);
     if(!(flags & JSON_DECODE_ANY)) {
         if(lex->token != '[' && lex->token != '{') {
-            error_set(error, lex, "'[' or '{' expected");
+            error_set(error, lex, json_error_invalid_syntax, "'[' or '{' expected");
             return NULL;
         }
     }
@@ -901,7 +903,7 @@ static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error)
     if(!(flags & JSON_DISABLE_EOF_CHECK)) {
         lex_scan(lex, error);
         if(lex->token != TOKEN_EOF) {
-            error_set(error, lex, "end of file expected");
+            error_set(error, lex, json_error_end_of_input_expected, "end of file expected");
             json_decref(result);
             return NULL;
         }
@@ -944,7 +946,7 @@ json_t *json_loads(const char *string, size_t flags, json_error_t *error)
     jsonp_error_init(error, "<string>");
 
     if (string == NULL) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
         return NULL;
     }
 
@@ -988,7 +990,7 @@ json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t
     jsonp_error_init(error, "<buffer>");
 
     if (buffer == NULL) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
         return NULL;
     }
 
@@ -1019,7 +1021,7 @@ json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
     jsonp_error_init(error, source);
 
     if (input == NULL) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
         return NULL;
     }
 
@@ -1058,7 +1060,7 @@ json_t *json_loadfd(int input, size_t flags, json_error_t *error)
     jsonp_error_init(error, source);
 
     if (input < 0) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
         return NULL;
     }
 
@@ -1079,14 +1081,14 @@ json_t *json_load_file(const char *path, size_t flags, json_error_t *error)
     jsonp_error_init(error, path);
 
     if (path == NULL) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
         return NULL;
     }
 
     fp = fopen(path, "rb");
     if(!fp)
     {
-        error_set(error, NULL, "unable to open %s: %s",
+        error_set(error, NULL, json_error_cannot_open_file, "unable to open %s: %s",
                   path, strerror(errno));
         return NULL;
     }
@@ -1139,7 +1141,7 @@ json_t *json_load_callback(json_load_callback_t callback, void *arg, size_t flag
     jsonp_error_init(error, "<callback>");
 
     if (callback == NULL) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
         return NULL;
     }
 

src/pack_unpack.c

@@ -105,13 +105,14 @@ static void prev_token(scanner_t *s)
     s->token = s->prev_token;
 }
 
-static void set_error(scanner_t *s, const char *source, const char *fmt, ...)
+static void set_error(scanner_t *s, const char *source, enum json_error_code code,
+                      const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
 
     jsonp_error_vset(s->error, s->token.line, s->token.column, s->token.pos,
-                     fmt, ap);
+                     code, fmt, ap);
 
     jsonp_error_set_source(s->error, source);
 
@@ -140,14 +141,14 @@ static char *read_string(scanner_t *s, va_list *ap,
         str = va_arg(*ap, const char *);
 
         if(!str) {
-            set_error(s, "<args>", "NULL string argument");
+            set_error(s, "<args>", json_error_null_value, "NULL string argument");
             return NULL;
         }
 
         length = strlen(str);
 
         if(!utf8_check_string(str, length)) {
-            set_error(s, "<args>", "Invalid UTF-8 %s", purpose);
+            set_error(s, "<args>", json_error_invalid_utf8, "Invalid UTF-8 %s", purpose);
             return NULL;
         }
 
@@ -161,7 +162,7 @@ static char *read_string(scanner_t *s, va_list *ap,
     while(1) {
         str = va_arg(*ap, const char *);
         if(!str) {
-            set_error(s, "<args>", "NULL string argument");
+            set_error(s, "<args>", json_error_null_value, "NULL string argument");
             strbuffer_close(&strbuff);
             return NULL;
         }
@@ -180,7 +181,7 @@ static char *read_string(scanner_t *s, va_list *ap,
         }
 
         if(strbuffer_append_bytes(&strbuff, str, length) == -1) {
-            set_error(s, "<internal>", "Out of memory");
+            set_error(s, "<internal>", json_error_out_of_memory, "Out of memory");
             strbuffer_close(&strbuff);
             return NULL;
         }
@@ -193,7 +194,7 @@ static char *read_string(scanner_t *s, va_list *ap,
     }
 
     if(!utf8_check_string(strbuff.value, strbuff.length)) {
-        set_error(s, "<args>", "Invalid UTF-8 %s", purpose);
+        set_error(s, "<args>", json_error_invalid_utf8, "Invalid UTF-8 %s", purpose);
         strbuffer_close(&strbuff);
         return NULL;
     }
@@ -215,12 +216,12 @@ static json_t *pack_object(scanner_t *s, va_list *ap)
         json_t *value;
 
         if(!token(s)) {
-            set_error(s, "<format>", "Unexpected end of format string");
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
             goto error;
         }
 
         if(token(s) != 's') {
-            set_error(s, "<format>", "Expected format 's', got '%c'", token(s));
+            set_error(s, "<format>", json_error_invalid_format, "Expected format 's', got '%c'", token(s));
             goto error;
         }
 
@@ -245,7 +246,7 @@ static json_t *pack_object(scanner_t *s, va_list *ap)
         }
 
         if(json_object_set_new_nocheck(object, key, value)) {
-            set_error(s, "<internal>", "Unable to add key \"%s\"", key);
+            set_error(s, "<internal>", json_error_out_of_memory, "Unable to add key \"%s\"", key);
             if(ours)
                 jsonp_free(key);
 
@@ -276,7 +277,7 @@ static json_t *pack_array(scanner_t *s, va_list *ap)
         json_t *value;
 
         if(!token(s)) {
-            set_error(s, "<format>", "Unexpected end of format string");
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
             goto error;
         }
 
@@ -292,7 +293,7 @@ static json_t *pack_array(scanner_t *s, va_list *ap)
         }
 
         if(json_array_append_new(array, value)) {
-            set_error(s, "<internal>", "Unable to append to array");
+            set_error(s, "<internal>", json_error_out_of_memory, "Unable to append to array");
             goto error;
         }
 
@@ -393,7 +394,7 @@ static json_t *pack(scanner_t *s, va_list *ap)
         }
 
         default:
-            set_error(s, "<format>", "Unexpected format character '%c'",
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected format character '%c'",
                       token(s));
             return NULL;
     }
@@ -415,12 +416,12 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
     hashtable_t key_set;
 
     if(hashtable_init(&key_set)) {
-        set_error(s, "<internal>", "Out of memory");
+        set_error(s, "<internal>", json_error_out_of_memory, "Out of memory");
         return -1;
     }
 
     if(root && !json_is_object(root)) {
-        set_error(s, "<validation>", "Expected object, got %s",
+        set_error(s, "<validation>", json_error_wrong_type, "Expected object, got %s",
                   type_name(root));
         goto out;
     }
@@ -432,13 +433,13 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
         int opt = 0;
 
         if(strict != 0) {
-            set_error(s, "<format>", "Expected '}' after '%c', got '%c'",
+            set_error(s, "<format>", json_error_invalid_format, "Expected '}' after '%c', got '%c'",
                       (strict == 1 ? '!' : '*'), token(s));
             goto out;
         }
 
         if(!token(s)) {
-            set_error(s, "<format>", "Unexpected end of format string");
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
             goto out;
         }
 
@@ -449,13 +450,13 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
         }
 
         if(token(s) != 's') {
-            set_error(s, "<format>", "Expected format 's', got '%c'", token(s));
+            set_error(s, "<format>", json_error_invalid_format, "Expected format 's', got '%c'", token(s));
             goto out;
         }
 
         key = va_arg(*ap, const char *);
         if(!key) {
-            set_error(s, "<args>", "NULL object key");
+            set_error(s, "<args>", json_error_null_value, "NULL object key");
             goto out;
         }
 
@@ -473,7 +474,7 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
         else {
             value = json_object_get(root, key);
             if(!value && !opt) {
-                set_error(s, "<validation>", "Object item not found: %s", key);
+                set_error(s, "<validation>", json_error_item_not_found, "Object item not found: %s", key);
                 goto out;
             }
         }
@@ -530,7 +531,7 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
                     }
                 }
             }
-            set_error(s, "<validation>",
+            set_error(s, "<validation>", json_error_end_of_input_expected,
                       "%li object item(s) left unpacked: %s",
                       unpacked, strbuffer_value(&unrecognized_keys));
             strbuffer_close(&unrecognized_keys);
@@ -551,7 +552,7 @@ static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
     int strict = 0;
 
     if(root && !json_is_array(root)) {
-        set_error(s, "<validation>", "Expected array, got %s", type_name(root));
+        set_error(s, "<validation>", json_error_wrong_type, "Expected array, got %s", type_name(root));
         return -1;
     }
     next_token(s);
@@ -560,14 +561,14 @@ static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
         json_t *value;
 
         if(strict != 0) {
-            set_error(s, "<format>", "Expected ']' after '%c', got '%c'",
+            set_error(s, "<format>", json_error_invalid_format, "Expected ']' after '%c', got '%c'",
                       (strict == 1 ? '!' : '*'),
                       token(s));
             return -1;
         }
 
         if(!token(s)) {
-            set_error(s, "<format>", "Unexpected end of format string");
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
             return -1;
         }
 
@@ -578,7 +579,7 @@ static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
         }
 
         if(!strchr(unpack_value_starters, token(s))) {
-            set_error(s, "<format>", "Unexpected format character '%c'",
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected format character '%c'",
                       token(s));
             return -1;
         }
@@ -590,7 +591,7 @@ static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
         else {
             value = json_array_get(root, i);
             if(!value) {
-                set_error(s, "<validation>", "Array index %lu out of range",
+                set_error(s, "<validation>", json_error_index_out_of_range, "Array index %lu out of range",
                           (unsigned long)i);
                 return -1;
             }
@@ -608,7 +609,7 @@ static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
 
     if(root && strict == 1 && i != json_array_size(root)) {
         long diff = (long)json_array_size(root) - (long)i;
-        set_error(s, "<validation>", "%li array item(s) left unpacked", diff);
+        set_error(s, "<validation>", json_error_end_of_input_expected, "%li array item(s) left unpacked", diff);
         return -1;
     }
 
@@ -627,7 +628,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
 
         case 's':
             if(root && !json_is_string(root)) {
-                set_error(s, "<validation>", "Expected string, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected string, got %s",
                           type_name(root));
                 return -1;
             }
@@ -638,7 +639,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
 
                 str_target = va_arg(*ap, const char **);
                 if(!str_target) {
-                    set_error(s, "<args>", "NULL string argument");
+                    set_error(s, "<args>", json_error_null_value, "NULL string argument");
                     return -1;
                 }
 
@@ -647,7 +648,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
                 if(token(s) == '%') {
                     len_target = va_arg(*ap, size_t *);
                     if(!len_target) {
-                        set_error(s, "<args>", "NULL string length argument");
+                        set_error(s, "<args>", json_error_null_value, "NULL string length argument");
                         return -1;
                     }
                 }
@@ -664,7 +665,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
 
         case 'i':
             if(root && !json_is_integer(root)) {
-                set_error(s, "<validation>", "Expected integer, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected integer, got %s",
                           type_name(root));
                 return -1;
             }
@@ -679,7 +680,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
 
         case 'I':
             if(root && !json_is_integer(root)) {
-                set_error(s, "<validation>", "Expected integer, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected integer, got %s",
                           type_name(root));
                 return -1;
             }
@@ -694,7 +695,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
 
         case 'b':
             if(root && !json_is_boolean(root)) {
-                set_error(s, "<validation>", "Expected true or false, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected true or false, got %s",
                           type_name(root));
                 return -1;
             }
@@ -709,7 +710,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
 
         case 'f':
             if(root && !json_is_real(root)) {
-                set_error(s, "<validation>", "Expected real, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected real, got %s",
                           type_name(root));
                 return -1;
             }
@@ -724,7 +725,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
 
         case 'F':
             if(root && !json_is_number(root)) {
-                set_error(s, "<validation>", "Expected real or integer, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected real or integer, got %s",
                           type_name(root));
                 return -1;
             }
@@ -754,14 +755,14 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
         case 'n':
             /* Never assign, just validate */
             if(root && !json_is_null(root)) {
-                set_error(s, "<validation>", "Expected null, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected null, got %s",
                           type_name(root));
                 return -1;
             }
             return 0;
 
         default:
-            set_error(s, "<format>", "Unexpected format character '%c'",
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected format character '%c'",
                       token(s));
             return -1;
     }
@@ -776,7 +777,7 @@ json_t *json_vpack_ex(json_error_t *error, size_t flags,
 
     if(!fmt || !*fmt) {
         jsonp_error_init(error, "<format>");
-        jsonp_error_set(error, -1, -1, 0, "NULL or empty format string");
+        jsonp_error_set(error, -1, -1, 0, json_error_invalid_argument, "NULL or empty format string");
         return NULL;
     }
     jsonp_error_init(error, NULL);
@@ -794,7 +795,7 @@ json_t *json_vpack_ex(json_error_t *error, size_t flags,
     next_token(&s);
     if(token(&s)) {
         json_decref(value);
-        set_error(&s, "<format>", "Garbage after format string");
+        set_error(&s, "<format>", json_error_invalid_format, "Garbage after format string");
         return NULL;
     }
 
@@ -833,13 +834,13 @@ int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags,
 
     if(!root) {
         jsonp_error_init(error, "<root>");
-        jsonp_error_set(error, -1, -1, 0, "NULL root value");
+        jsonp_error_set(error, -1, -1, 0, json_error_null_value, "NULL root value");
         return -1;
     }
 
     if(!fmt || !*fmt) {
         jsonp_error_init(error, "<format>");
-        jsonp_error_set(error, -1, -1, 0, "NULL or empty format string");
+        jsonp_error_set(error, -1, -1, 0, json_error_invalid_argument, "NULL or empty format string");
         return -1;
     }
     jsonp_error_init(error, NULL);
@@ -856,7 +857,7 @@ int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags,
 
     next_token(&s);
     if(token(&s)) {
-        set_error(&s, "<format>", "Garbage after format string");
+        set_error(&s, "<format>", json_error_invalid_format, "Garbage after format string");
         return -1;
     }
 

test/suites/api/test_load.c

@@ -32,6 +32,8 @@ static void file_not_found()
 
     if(strcmp(error.text, "unable to open /path/to/nonexistent/file.json") != 0)
         fail("json_load_file returned an invalid error message");
+    if(json_error_code(&error) != json_error_cannot_open_file)
+        fail("json_load_file returned an invalid error code");
 }
 
 static void very_long_file_name() {
@@ -46,6 +48,8 @@ static void very_long_file_name() {
 
     if (strncmp(error.source, "...aaa", 6) != 0)
         fail("error source was set incorrectly");
+    if(json_error_code(&error) != json_error_cannot_open_file)
+        fail("error code was set incorrectly");
 }
 
 static void reject_duplicates()
@@ -54,7 +58,7 @@ static void reject_duplicates()
 
     if(json_loads("{\"foo\": 1, \"foo\": 2}", JSON_REJECT_DUPLICATES, &error))
         fail("json_loads did not detect a duplicate key");
-    check_error("duplicate object key near '\"foo\"'", "<string>", 1, 16, 16);
+    check_error(json_error_duplicate_key, "duplicate object key near '\"foo\"'", "<string>", 1, 16, 16);
 }
 
 static void disable_eof_check()
@@ -66,7 +70,7 @@ static void disable_eof_check()
 
     if(json_loads(text, 0, &error))
         fail("json_loads did not detect garbage after JSON text");
-    check_error("end of file expected near 'garbage'", "<string>", 1, 18, 18);
+    check_error(json_error_end_of_input_expected, "end of file expected near 'garbage'", "<string>", 1, 18, 18);
 
     json = json_loads(text, JSON_DISABLE_EOF_CHECK, &error);
     if(!json)
@@ -137,7 +141,8 @@ static void decode_int_as_real()
     big[310] = '\0';
 
     json = json_loads(big, JSON_DECODE_INT_AS_REAL | JSON_DECODE_ANY, &error);
-    if (json || strcmp(error.text, "real number overflow") != 0)
+    if (json || strcmp(error.text, "real number overflow") != 0 ||
+        json_error_code(&error) != json_error_numeric_overflow)
         fail("json_load decode int as real failed - expected overflow");
     json_decref(json);
 
@@ -206,6 +211,18 @@ static void position()
     json_decref(json);
 }
 
+static void error_code()
+{
+    json_error_t error;
+    json_t *json = json_loads("[123] garbage", 0, &error);
+    if(json != NULL)
+        fail("json_loads returned not NULL");
+    if(strlen(error.text) >= JSON_ERROR_TEXT_LENGTH)
+        fail("error.text longer than expected");
+    if(json_error_code(&error) != json_error_end_of_input_expected)
+        fail("json_loads returned incorrect error code");
+}
+
 static void run_tests()
 {
     file_not_found();
@@ -217,4 +234,5 @@ static void run_tests()
     allow_nul();
     load_wrong_args();
     position();
+    error_code();
 }

test/suites/api/test_pack.c

@@ -302,78 +302,78 @@ static void run_tests()
     /* newline in format string */
     if(json_pack_ex(&error, 0, "{\n\n1"))
         fail("json_pack failed to catch invalid format '1'");
-    check_error("Expected format 's', got '1'", "<format>", 3, 1, 4);
+    check_error(json_error_invalid_format, "Expected format 's', got '1'", "<format>", 3, 1, 4);
 
     /* mismatched open/close array/object */
     if(json_pack_ex(&error, 0, "[}"))
         fail("json_pack failed to catch mismatched '}'");
-    check_error("Unexpected format character '}'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 2, 2);
 
     if(json_pack_ex(&error, 0, "{]"))
         fail("json_pack failed to catch mismatched ']'");
-    check_error("Expected format 's', got ']'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1, 2, 2);
 
     /* missing close array */
     if(json_pack_ex(&error, 0, "["))
         fail("json_pack failed to catch missing ']'");
-    check_error("Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);
 
     /* missing close object */
     if(json_pack_ex(&error, 0, "{"))
         fail("json_pack failed to catch missing '}'");
-    check_error("Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);
 
     /* garbage after format string */
     if(json_pack_ex(&error, 0, "[i]a", 42))
         fail("json_pack failed to catch garbage after format string");
-    check_error("Garbage after format string", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 4, 4);
 
     if(json_pack_ex(&error, 0, "ia", 42))
         fail("json_pack failed to catch garbage after format string");
-    check_error("Garbage after format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 2, 2);
 
     /* NULL string */
     if(json_pack_ex(&error, 0, "s", NULL))
         fail("json_pack failed to catch null argument string");
-    check_error("NULL string argument", "<args>", 1, 1, 1);
+    check_error(json_error_null_value, "NULL string argument", "<args>", 1, 1, 1);
 
     /* + on its own */
     if(json_pack_ex(&error, 0, "+", NULL))
         fail("json_pack failed to a lone +");
-    check_error("Unexpected format character '+'", "<format>", 1, 1, 1);
+    check_error(json_error_invalid_format, "Unexpected format character '+'", "<format>", 1, 1, 1);
 
     /* NULL format */
     if(json_pack_ex(&error, 0, NULL))
         fail("json_pack failed to catch NULL format string");
-    check_error("NULL or empty format string", "<format>", -1, -1, 0);
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", -1, -1, 0);
 
     /* NULL key */
     if(json_pack_ex(&error, 0, "{s:i}", NULL, 1))
         fail("json_pack failed to catch NULL key");
-    check_error("NULL string argument", "<args>", 1, 2, 2);
+    check_error(json_error_null_value, "NULL string argument", "<args>", 1, 2, 2);
 
     /* More complicated checks for row/columns */
     if(json_pack_ex(&error, 0, "{ {}: s }", "foo"))
         fail("json_pack failed to catch object as key");
-    check_error("Expected format 's', got '{'", "<format>", 1, 3, 3);
+    check_error(json_error_invalid_format, "Expected format 's', got '{'", "<format>", 1, 3, 3);
 
     /* Complex object */
     if(json_pack_ex(&error, 0, "{ s: {},  s:[ii{} }", "foo", "bar", 12, 13))
         fail("json_pack failed to catch missing ]");
-    check_error("Unexpected format character '}'", "<format>", 1, 19, 19);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 19, 19);
 
     /* Complex array */
     if(json_pack_ex(&error, 0, "[[[[[   [[[[[  [[[[ }]]]] ]]]] ]]]]]"))
         fail("json_pack failed to catch extra }");
-    check_error("Unexpected format character '}'", "<format>", 1, 21, 21);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 21, 21);
 
     /* Invalid UTF-8 in object key */
     if(json_pack_ex(&error, 0, "{s:i}", "\xff\xff", 42))
         fail("json_pack failed to catch invalid UTF-8 in an object key");
-    check_error("Invalid UTF-8 object key", "<args>", 1, 2, 2);
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 object key", "<args>", 1, 2, 2);
 
     /* Invalid UTF-8 in a string */
     if(json_pack_ex(&error, 0, "{s:s}", "foo", "\xff\xff"))
         fail("json_pack failed to catch invalid UTF-8 in a string");
-    check_error("Invalid UTF-8 string", "<args>", 1, 4, 4);
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 4, 4);
 }

test/suites/api/test_unpack.c

@@ -144,65 +144,65 @@ static void run_tests()
     j = json_integer(42);
     if(!json_unpack_ex(j, &error, 0, "z"))
         fail("json_unpack succeeded with invalid format character");
-    check_error("Unexpected format character 'z'", "<format>", 1, 1, 1);
+    check_error(json_error_invalid_format, "Unexpected format character 'z'", "<format>", 1, 1, 1);
 
     if(!json_unpack_ex(NULL, &error, 0, "[i]"))
         fail("json_unpack succeeded with NULL root");
-    check_error("NULL root value", "<root>", -1, -1, 0);
+    check_error(json_error_null_value, "NULL root value", "<root>", -1, -1, 0);
     json_decref(j);
 
     /* mismatched open/close array/object */
     j = json_pack("[]");
     if(!json_unpack_ex(j, &error, 0, "[}"))
         fail("json_unpack failed to catch mismatched ']'");
-    check_error("Unexpected format character '}'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 2, 2);
     json_decref(j);
 
     j = json_pack("{}");
     if(!json_unpack_ex(j, &error, 0, "{]"))
         fail("json_unpack failed to catch mismatched '}'");
-    check_error("Expected format 's', got ']'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1, 2, 2);
     json_decref(j);
 
     /* missing close array */
     j = json_pack("[]");
     if(!json_unpack_ex(j, &error, 0, "["))
         fail("json_unpack failed to catch missing ']'");
-    check_error("Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);
     json_decref(j);
 
     /* missing close object */
     j = json_pack("{}");
     if(!json_unpack_ex(j, &error, 0, "{"))
         fail("json_unpack failed to catch missing '}'");
-    check_error("Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);
     json_decref(j);
 
     /* garbage after format string */
     j = json_pack("[i]", 42);
     if(!json_unpack_ex(j, &error, 0, "[i]a", &i1))
         fail("json_unpack failed to catch garbage after format string");
-    check_error("Garbage after format string", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 4, 4);
     json_decref(j);
 
     j = json_integer(12345);
     if(!json_unpack_ex(j, &error, 0, "ia", &i1))
         fail("json_unpack failed to catch garbage after format string");
-    check_error("Garbage after format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 2, 2);
     json_decref(j);
 
     /* NULL format string */
     j = json_pack("[]");
     if(!json_unpack_ex(j, &error, 0, NULL))
         fail("json_unpack failed to catch null format string");
-    check_error("NULL or empty format string", "<format>", -1, -1, 0);
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", -1, -1, 0);
     json_decref(j);
 
     /* NULL string pointer */
     j = json_string("foobie");
     if(!json_unpack_ex(j, &error, 0, "s", NULL))
         fail("json_unpack failed to catch null string pointer");
-    check_error("NULL string argument", "<args>", 1, 1, 1);
+    check_error(json_error_null_value, "NULL string argument", "<args>", 1, 1, 1);
     json_decref(j);
 
     /* invalid types */
@@ -210,39 +210,39 @@ static void run_tests()
     j2 = json_string("foo");
     if(!json_unpack_ex(j, &error, 0, "s"))
         fail("json_unpack failed to catch invalid type");
-    check_error("Expected string, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected string, got integer", "<validation>", 1, 1, 1);
 
     if(!json_unpack_ex(j, &error, 0, "n"))
         fail("json_unpack failed to catch invalid type");
-    check_error("Expected null, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected null, got integer", "<validation>", 1, 1, 1);
 
     if(!json_unpack_ex(j, &error, 0, "b"))
         fail("json_unpack failed to catch invalid type");
-    check_error("Expected true or false, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected true or false, got integer", "<validation>", 1, 1, 1);
 
     if(!json_unpack_ex(j2, &error, 0, "i"))
         fail("json_unpack failed to catch invalid type");
-    check_error("Expected integer, got string", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1, 1, 1);
 
     if(!json_unpack_ex(j2, &error, 0, "I"))
         fail("json_unpack failed to catch invalid type");
-    check_error("Expected integer, got string", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1, 1, 1);
 
     if(!json_unpack_ex(j, &error, 0, "f"))
         fail("json_unpack failed to catch invalid type");
-    check_error("Expected real, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected real, got integer", "<validation>", 1, 1, 1);
 
     if(!json_unpack_ex(j2, &error, 0, "F"))
         fail("json_unpack failed to catch invalid type");
-    check_error("Expected real or integer, got string", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected real or integer, got string", "<validation>", 1, 1, 1);
 
     if(!json_unpack_ex(j, &error, 0, "[i]"))
         fail("json_unpack failed to catch invalid type");
-    check_error("Expected array, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected array, got integer", "<validation>", 1, 1, 1);
 
     if(!json_unpack_ex(j, &error, 0, "{si}", "foo"))
         fail("json_unpack failed to catch invalid type");
-    check_error("Expected object, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected object, got integer", "<validation>", 1, 1, 1);
 
     json_decref(j);
     json_decref(j2);
@@ -251,21 +251,21 @@ static void run_tests()
     j = json_pack("[i]", 1);
     if(!json_unpack_ex(j, &error, 0, "[ii]", &i1, &i2))
         fail("json_unpack failed to catch index out of array bounds");
-    check_error("Array index 1 out of range", "<validation>", 1, 3, 3);
+    check_error(json_error_index_out_of_range, "Array index 1 out of range", "<validation>", 1, 3, 3);
     json_decref(j);
 
     /* NULL object key */
     j = json_pack("{si}", "foo", 42);
     if(!json_unpack_ex(j, &error, 0, "{si}", NULL, &i1))
         fail("json_unpack failed to catch null string pointer");
-    check_error("NULL object key", "<args>", 1, 2, 2);
+    check_error(json_error_null_value, "NULL object key", "<args>", 1, 2, 2);
     json_decref(j);
 
     /* Object key not found */
     j = json_pack("{si}", "foo", 42);
     if(!json_unpack_ex(j, &error, 0, "{si}", "baz", &i1))
         fail("json_unpack failed to catch null string pointer");
-    check_error("Object item not found: baz", "<validation>", 1, 3, 3);
+    check_error(json_error_item_not_found, "Object item not found: baz", "<validation>", 1, 3, 3);
     json_decref(j);
 
     /*
@@ -281,14 +281,14 @@ static void run_tests()
     j = json_pack("[iii]", 1, 2, 3);
     if(!json_unpack_ex(j, &error, 0, "[ii!]", &i1, &i2))
         fail("json_unpack array with strict validation failed");
-    check_error("1 array item(s) left unpacked", "<validation>", 1, 5, 5);
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", "<validation>", 1, 5, 5);
     json_decref(j);
 
     /* Like above, but with JSON_STRICT instead of '!' format */
     j = json_pack("[iii]", 1, 2, 3);
     if(!json_unpack_ex(j, &error, JSON_STRICT, "[ii]", &i1, &i2))
         fail("json_unpack array with strict validation failed");
-    check_error("1 array item(s) left unpacked", "<validation>", 1, 4, 4);
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", "<validation>", 1, 4, 4);
     json_decref(j);
 
     j = json_pack("{s:s, s:i}", "foo", "bar", "baz", 42);
@@ -306,7 +306,7 @@ static void run_tests()
             "2 object item(s) left unpacked: baz, quux",
             "2 object item(s) left unpacked: quux, baz"
         };
-        check_errors(possible_errors, 2, "<validation>", 1, 10, 10);
+        check_errors(json_error_end_of_input_expected, possible_errors, 2, "<validation>", 1, 10, 10);
     }
     json_decref(j);
 
@@ -320,35 +320,35 @@ static void run_tests()
     j = json_pack("[ii]", 1, 2);
     if(!json_unpack_ex(j, &error, 0, "[i!i]", &i1, &i2))
         fail("json_unpack failed to catch ! in the middle of an array");
-    check_error("Expected ']' after '!', got 'i'", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Expected ']' after '!', got 'i'", "<format>", 1, 4, 4);
 
     if(!json_unpack_ex(j, &error, 0, "[i*i]", &i1, &i2))
         fail("json_unpack failed to catch * in the middle of an array");
-    check_error("Expected ']' after '*', got 'i'", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Expected ']' after '*', got 'i'", "<format>", 1, 4, 4);
     json_decref(j);
 
     j = json_pack("{sssi}", "foo", "bar", "baz", 42);
     if(!json_unpack_ex(j, &error, 0, "{ss!si}", "foo", &s, "baz", &i1))
         fail("json_unpack failed to catch ! in the middle of an object");
-    check_error("Expected '}' after '!', got 's'", "<format>", 1, 5, 5);
+    check_error(json_error_invalid_format, "Expected '}' after '!', got 's'", "<format>", 1, 5, 5);
 
     if(!json_unpack_ex(j, &error, 0, "{ss*si}", "foo", &s, "baz", &i1))
         fail("json_unpack failed to catch ! in the middle of an object");
-    check_error("Expected '}' after '*', got 's'", "<format>", 1, 5, 5);
+    check_error(json_error_invalid_format, "Expected '}' after '*', got 's'", "<format>", 1, 5, 5);
     json_decref(j);
 
     /* Error in nested object */
     j = json_pack("{s{snsn}}", "foo", "bar", "baz");
     if(!json_unpack_ex(j, &error, 0, "{s{sn!}}", "foo", "bar"))
         fail("json_unpack nested object with strict validation failed");
-    check_error("1 object item(s) left unpacked: baz", "<validation>", 1, 7, 7);
+    check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz", "<validation>", 1, 7, 7);
     json_decref(j);
 
     /* Error in nested array */
     j = json_pack("[[ii]]", 1, 2);
     if(!json_unpack_ex(j, &error, 0, "[[i!]]", &i1))
         fail("json_unpack nested array with strict validation failed");
-    check_error("1 array item(s) left unpacked", "<validation>", 1, 5, 5);
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", "<validation>", 1, 5, 5);
     json_decref(j);
 
     /* Optional values */
@@ -401,6 +401,6 @@ static void run_tests()
     i1 = i2 = i3 = 0;
     if(!json_unpack_ex(j, &error, 0, "{sis?i!}", "foo", &i1, "bar", &i2))
         fail("json_unpack failed for optional values with strict mode and compensation");
-    check_error("1 object item(s) left unpacked: baz", "<validation>", 1, 8, 8);
+    check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz", "<validation>", 1, 8, 8);
     json_decref(j);
 }

test/suites/api/util.h

@@ -30,9 +30,16 @@
     } while(0)
 
 /* Assumes json_error_t error */
-#define check_errors(texts_, num_, source_, line_, column_, position_)  \
+#define check_errors(code_, texts_, num_, source_,                      \
+    line_, column_, position_)                                          \
     do {                                                                \
         int i_, found_ = 0;                                             \
+        if(json_error_code(&error) != code_) {                          \
+            failhdr;                                                    \
+            fprintf(stderr, "code: %d != %d\n",                         \
+                    json_error_code(&error), code_);                    \
+            exit(1);                                                    \
+        }                                                               \
         for(i_ = 0; i_ < num_; i_++) {                                  \
             if(strcmp(error.text, texts_[i_]) == 0) {                   \
                 found_ = 1;                                             \
@@ -73,8 +80,8 @@
 
 
 /* Assumes json_error_t error */
-#define check_error(text_, source_, line_, column_, position_)          \
+#define check_error(code_, text_, source_, line_, column_, position_)   \
-    check_errors(&text_, 1, source_, line_, column_, position_)
+    check_errors(code_, &text_, 1, source_, line_, column_, position_)
 
 
 static void run_tests();