Expose public error-code interface

Publicly define the error codes returned from the various public API
functions. The error codes are defined in the amqp_status_enum and are
all negative in value to work with functions that return positive
values.

OS and SSL specific codes are no longer munged into the error code, as
it is unlikely for that information to be useful to library users.

16 files changed, 455 insertions, 469 deletions

diff --git a/librabbitmq/amqp.h b/librabbitmq/amqp.h
index 1504def..f469dda 100644
--- a/librabbitmq/amqp.h
+++ b/librabbitmq/amqp.h
@@ -329,6 +329,22 @@ typedef struct amqp_connection_state_t_ *amqp_connection_state_t;
 
 typedef struct amqp_socket_t_ amqp_socket_t;
 
+typedef enum amqp_status_enum_
+{
+  AMQP_STATUS_OK =                         0x0,
+  AMQP_STATUS_NO_MEMORY =                 -0x0001,
+  AMQP_STATUS_BAD_AMQP_DATA =             -0x0002,
+  AMQP_STATUS_UNKNOWN_CLASS =             -0x0003,
+  AMQP_STATUS_UNKNOWN_METHOD =            -0x0004,
+  AMQP_STATUS_HOSTNAME_RESOLUTION_FAILED= -0x0005,
+  AMQP_STATUS_INCOMPATIBLE_AMQP_VERSION = -0x0006,
+  AMQP_STATUS_CONNECTION_CLOSED =         -0x0007,
+  AMQP_STATUS_BAD_URL =                   -0x0008,
+  AMQP_STATUS_SOCKET_ERROR =              -0x0009,
+
+  AMQP_STATUS_SSL_ERROR =                 -0x0200
+} amqp_status_enum;
+
 AMQP_PUBLIC_FUNCTION
 char const *
 AMQP_CALL amqp_version(void);
diff --git a/librabbitmq/amqp_api.c b/librabbitmq/amqp_api.c
index 6bc8397..cab0f4b 100644
--- a/librabbitmq/amqp_api.c
+++ b/librabbitmq/amqp_api.c
@@ -46,42 +46,31 @@
 #include <stdlib.h>
 #include <string.h>
 
-static const char *client_error_strings[ERROR_MAX] = {
-  "could not allocate memory", /* ERROR_NO_MEMORY */
-  "received bad AMQP data", /* ERROR_BAD_AQMP_DATA */
-  "unknown AMQP class id", /* ERROR_UNKOWN_CLASS */
-  "unknown AMQP method id", /* ERROR_UNKOWN_METHOD */
-  "unknown host", /* ERROR_GETHOSTBYNAME_FAILED */
-  "incompatible AMQP version", /* ERROR_INCOMPATIBLE_AMQP_VERSION */
-  "connection closed unexpectedly", /* ERROR_CONNECTION_CLOSED */
-  "could not parse AMQP URL", /* ERROR_BAD_AMQP_URL */
+static const char *client_error_strings[] = {
+  "operation completed successfully",   /* AMQP_STATUS_OK */
+  "could not allocate memory",          /* AMQP_STATUS_NO_MEMORY */
+  "received bad AMQP data",             /* AMQP_STATUS_BAD_AQMP_DATA */
+  "unknown AMQP class id",              /* AMQP_STATUS_UNKNOWN_CLASS */
+  "unknown AMQP method id",             /* AMQP_STATUS_UNKNOWN_METHOD */
+  "hostname lookup failed",             /* AMQP_STATUS_GETHOSTBYNAME_FAILED */
+  "incompatible AMQP version",          /* AMQP_STATUS_INCOMPATIBLE_AMQP_VERSION */
+  "connection closed unexpectedly",     /* AMQP_STATUS_CONNECTION_CLOSED */
+  "could not parse AMQP URL",           /* AMQP_STATUS_BAD_AMQP_URL */
+  "a socket error occurred",            /* AMQP_STATUS_SOCKET_ERROR */
+  "a SSL error occurred"                /* AMQP_STATUS_SSL_ERROR */
 };
 
 char *amqp_error_string(int err)
 {
   const char *str;
-  int category = (err & ERROR_CATEGORY_MASK);
-  err = (err & ~ERROR_CATEGORY_MASK);
+  const int max_error_index = sizeof(client_error_strings) / sizeof(char *);
 
-  switch (category) {
-  case ERROR_CATEGORY_CLIENT:
-    if (err < 1 || err > ERROR_MAX) {
-      str = "(undefined librabbitmq error)";
-    } else {
-      str = client_error_strings[err - 1];
-    }
-    break;
-
-  case ERROR_CATEGORY_OS:
-    return amqp_os_error_string(err);
-
-#ifdef WITH_SSL
-  case ERROR_CATEGORY_SSL:
-    return amqp_ssl_error_string(err);
-#endif
+  err = -err;
 
-  default:
-    str = "(undefined error category)";
+  if (err < 0 || err > max_error_index) {
+    str = "an unknown error occurred";
+  } else {
+    str = client_error_strings[err];
   }
 
   return strdup(str);
@@ -174,7 +163,7 @@ int amqp_basic_publish(amqp_connection_state_t state,
     }
   }
 
-  return 0;
+  return AMQP_STATUS_OK;
 }
 
 amqp_rpc_reply_t amqp_channel_close(amqp_connection_state_t state,
diff --git a/librabbitmq/amqp_connection.c b/librabbitmq/amqp_connection.c
index 962cc42..c9936fc 100644
--- a/librabbitmq/amqp_connection.c
+++ b/librabbitmq/amqp_connection.c
@@ -148,11 +148,11 @@ int amqp_tune_connection(amqp_connection_state_t state,
   newbuf = realloc(state->outbound_buffer.bytes, frame_max);
   if (newbuf == NULL) {
     amqp_destroy_connection(state);
-    return -ERROR_NO_MEMORY;
+    return AMQP_STATUS_NO_MEMORY;
   }
   state->outbound_buffer.bytes = newbuf;
 
-  return 0;
+  return AMQP_STATUS_OK;
 }
 
 int amqp_get_channel_max(amqp_connection_state_t state)
@@ -162,15 +162,13 @@ int amqp_get_channel_max(amqp_connection_state_t state)
 
 int amqp_destroy_connection(amqp_connection_state_t state)
 {
-  int status = 0;
+  int status = AMQP_STATUS_OK;
   if (state) {
     empty_amqp_pool(&state->frame_pool);
     empty_amqp_pool(&state->decoding_pool);
     free(state->outbound_buffer.bytes);
     free(state->sock_inbound_buffer.bytes);
-    if (amqp_socket_close(state->socket) < 0) {
-      status = -amqp_socket_error(state->socket);
-    }
+    status = amqp_socket_close(state->socket);
     free(state);
   }
   return status;
@@ -214,7 +212,7 @@ int amqp_handle_input(amqp_connection_state_t state,
   decoded_frame->frame_type = 0;
 
   if (received_data.len == 0) {
-    return 0;
+    return AMQP_STATUS_OK;
   }
 
   if (state->state == CONNECTION_STATE_IDLE) {
@@ -225,7 +223,7 @@ int amqp_handle_input(amqp_connection_state_t state,
       corresponds to frame_max, which is not permitted to be less
       than AMQP_FRAME_MIN_SIZE (currently 4096 bytes). */
     {
-      return -ERROR_NO_MEMORY;
+      return AMQP_STATUS_NO_MEMORY;
     }
 
     state->state = CONNECTION_STATE_HEADER;
@@ -286,7 +284,7 @@ int amqp_handle_input(amqp_connection_state_t state,
 
     /* Check frame end marker (footer) */
     if (amqp_d8(raw_frame, state->target_size - 1) != AMQP_FRAME_END) {
-      return -ERROR_BAD_AMQP_DATA;
+      return AMQP_STATUS_BAD_AMQP_DATA;
     }
 
     decoded_frame->frame_type = amqp_d8(raw_frame, 0);
@@ -455,8 +453,8 @@ int amqp_send_frame(amqp_connection_state_t state,
   }
 
   if (res < 0) {
-    return -amqp_socket_error(state->socket);
+    return amqp_socket_error(state->socket);
   } else {
-    return 0;
+    return AMQP_STATUS_OK;
   }
 }
diff --git a/librabbitmq/amqp_cyassl.c b/librabbitmq/amqp_cyassl.c
index 9657449..89047d9 100644
--- a/librabbitmq/amqp_cyassl.c
+++ b/librabbitmq/amqp_cyassl.c
@@ -58,7 +58,7 @@ amqp_ssl_socket_send(void *base,
   self->last_error = 0;
   status = CyaSSL_write(self->ssl, buf, len);
   if (status <= 0) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
   }
 
   return status;
@@ -84,7 +84,7 @@ amqp_ssl_socket_writev(void *base,
     self->buffer = malloc(bytes);
     if (!self->buffer) {
       self->length = 0;
-      self->last_error = ERROR_NO_MEMORY;
+      self->last_error = AMQP_STATUS_NO_MEMORY;
       goto exit;
     }
     self->length = bytes;
@@ -111,7 +111,7 @@ amqp_ssl_socket_recv(void *base,
   self->last_error = 0;
   status = CyaSSL_read(self->ssl, buf, len);
   if (status <= 0) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
   }
 
   return status;
@@ -163,7 +163,7 @@ amqp_ssl_socket_open(void *base, const char *host, int port)
 
   self->ssl = CyaSSL_new(self->ctx);
   if (NULL == self->ssl) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
     return -1;
   }
 
@@ -175,7 +175,7 @@ amqp_ssl_socket_open(void *base, const char *host, int port)
   CyaSSL_set_fd(self->ssl, self->sockfd);
   status = CyaSSL_connect(self->ssl);
   if (SSL_SUCCESS != status) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
     return -1;
   }
   return 0;
diff --git a/librabbitmq/amqp_framing.c b/librabbitmq/amqp_framing.c
index 22d97b8..62b01f6 100644
--- a/librabbitmq/amqp_framing.c
+++ b/librabbitmq/amqp_framing.c
@@ -183,9 +183,9 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
   switch (methodNumber) {
     case AMQP_CONNECTION_START_METHOD: {
       amqp_connection_start_t *m = (amqp_connection_start_t *) amqp_pool_alloc(pool, sizeof(amqp_connection_start_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_8(encoded, &offset, &m->version_major)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_8(encoded, &offset, &m->version_minor)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_8(encoded, &offset, &m->version_major)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &m->version_minor)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         int res = amqp_decode_table(encoded, pool, &(m->server_properties), &offset);
         if (res < 0) return res;
@@ -194,20 +194,20 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
         uint32_t len;
         if (!amqp_decode_32(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->mechanisms, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint32_t len;
         if (!amqp_decode_32(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->locales, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_CONNECTION_START_OK_METHOD: {
       amqp_connection_start_ok_t *m = (amqp_connection_start_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_connection_start_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         int res = amqp_decode_table(encoded, pool, &(m->client_properties), &offset);
         if (res < 0) return res;
@@ -216,109 +216,109 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->mechanism, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint32_t len;
         if (!amqp_decode_32(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->response, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->locale, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_CONNECTION_SECURE_METHOD: {
       amqp_connection_secure_t *m = (amqp_connection_secure_t *) amqp_pool_alloc(pool, sizeof(amqp_connection_secure_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint32_t len;
         if (!amqp_decode_32(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->challenge, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_CONNECTION_SECURE_OK_METHOD: {
       amqp_connection_secure_ok_t *m = (amqp_connection_secure_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_connection_secure_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint32_t len;
         if (!amqp_decode_32(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->response, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_CONNECTION_TUNE_METHOD: {
       amqp_connection_tune_t *m = (amqp_connection_tune_t *) amqp_pool_alloc(pool, sizeof(amqp_connection_tune_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->channel_max)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_32(encoded, &offset, &m->frame_max)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_16(encoded, &offset, &m->heartbeat)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->channel_max)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_32(encoded, &offset, &m->frame_max)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_16(encoded, &offset, &m->heartbeat)) return AMQP_STATUS_BAD_AMQP_DATA;
       *decoded = m;
       return 0;
     }
     case AMQP_CONNECTION_TUNE_OK_METHOD: {
       amqp_connection_tune_ok_t *m = (amqp_connection_tune_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_connection_tune_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->channel_max)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_32(encoded, &offset, &m->frame_max)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_16(encoded, &offset, &m->heartbeat)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->channel_max)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_32(encoded, &offset, &m->frame_max)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_16(encoded, &offset, &m->heartbeat)) return AMQP_STATUS_BAD_AMQP_DATA;
       *decoded = m;
       return 0;
     }
     case AMQP_CONNECTION_OPEN_METHOD: {
       amqp_connection_open_t *m = (amqp_connection_open_t *) amqp_pool_alloc(pool, sizeof(amqp_connection_open_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->virtual_host, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->capabilities, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->insist = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
     }
     case AMQP_CONNECTION_OPEN_OK_METHOD: {
       amqp_connection_open_ok_t *m = (amqp_connection_open_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_connection_open_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->known_hosts, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_CONNECTION_CLOSE_METHOD: {
       amqp_connection_close_t *m = (amqp_connection_close_t *) amqp_pool_alloc(pool, sizeof(amqp_connection_close_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->reply_code)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->reply_code)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->reply_text, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_16(encoded, &offset, &m->class_id)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_16(encoded, &offset, &m->method_id)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_16(encoded, &offset, &m->class_id)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_16(encoded, &offset, &m->method_id)) return AMQP_STATUS_BAD_AMQP_DATA;
       *decoded = m;
       return 0;
     }
@@ -329,56 +329,56 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_CHANNEL_OPEN_METHOD: {
       amqp_channel_open_t *m = (amqp_channel_open_t *) amqp_pool_alloc(pool, sizeof(amqp_channel_open_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->out_of_band, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_CHANNEL_OPEN_OK_METHOD: {
       amqp_channel_open_ok_t *m = (amqp_channel_open_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_channel_open_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint32_t len;
         if (!amqp_decode_32(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->channel_id, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_CHANNEL_FLOW_METHOD: {
       amqp_channel_flow_t *m = (amqp_channel_flow_t *) amqp_pool_alloc(pool, sizeof(amqp_channel_flow_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->active = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
     }
     case AMQP_CHANNEL_FLOW_OK_METHOD: {
       amqp_channel_flow_ok_t *m = (amqp_channel_flow_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_channel_flow_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->active = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
     }
     case AMQP_CHANNEL_CLOSE_METHOD: {
       amqp_channel_close_t *m = (amqp_channel_close_t *) amqp_pool_alloc(pool, sizeof(amqp_channel_close_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->reply_code)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->reply_code)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->reply_text, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_16(encoded, &offset, &m->class_id)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_16(encoded, &offset, &m->method_id)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_16(encoded, &offset, &m->class_id)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_16(encoded, &offset, &m->method_id)) return AMQP_STATUS_BAD_AMQP_DATA;
       *decoded = m;
       return 0;
     }
@@ -389,14 +389,14 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_ACCESS_REQUEST_METHOD: {
       amqp_access_request_t *m = (amqp_access_request_t *) amqp_pool_alloc(pool, sizeof(amqp_access_request_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->realm, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->exclusive = (bit_buffer & (1 << 0)) ? 1 : 0;
       m->passive = (bit_buffer & (1 << 1)) ? 1 : 0;
       m->active = (bit_buffer & (1 << 2)) ? 1 : 0;
@@ -407,28 +407,28 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_ACCESS_REQUEST_OK_METHOD: {
       amqp_access_request_ok_t *m = (amqp_access_request_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_access_request_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       *decoded = m;
       return 0;
     }
     case AMQP_EXCHANGE_DECLARE_METHOD: {
       amqp_exchange_declare_t *m = (amqp_exchange_declare_t *) amqp_pool_alloc(pool, sizeof(amqp_exchange_declare_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->exchange, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->type, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->passive = (bit_buffer & (1 << 0)) ? 1 : 0;
       m->durable = (bit_buffer & (1 << 1)) ? 1 : 0;
       m->auto_delete = (bit_buffer & (1 << 2)) ? 1 : 0;
@@ -448,15 +448,15 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_EXCHANGE_DELETE_METHOD: {
       amqp_exchange_delete_t *m = (amqp_exchange_delete_t *) amqp_pool_alloc(pool, sizeof(amqp_exchange_delete_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->exchange, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->if_unused = (bit_buffer & (1 << 0)) ? 1 : 0;
       m->nowait = (bit_buffer & (1 << 1)) ? 1 : 0;
       *decoded = m;
@@ -469,27 +469,27 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_EXCHANGE_BIND_METHOD: {
       amqp_exchange_bind_t *m = (amqp_exchange_bind_t *) amqp_pool_alloc(pool, sizeof(amqp_exchange_bind_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->destination, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->source, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->routing_key, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->nowait = (bit_buffer & (1 << 0)) ? 1 : 0;
       {
         int res = amqp_decode_table(encoded, pool, &(m->arguments), &offset);
@@ -505,27 +505,27 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_EXCHANGE_UNBIND_METHOD: {
       amqp_exchange_unbind_t *m = (amqp_exchange_unbind_t *) amqp_pool_alloc(pool, sizeof(amqp_exchange_unbind_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->destination, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->source, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->routing_key, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->nowait = (bit_buffer & (1 << 0)) ? 1 : 0;
       {
         int res = amqp_decode_table(encoded, pool, &(m->arguments), &offset);
@@ -541,15 +541,15 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_QUEUE_DECLARE_METHOD: {
       amqp_queue_declare_t *m = (amqp_queue_declare_t *) amqp_pool_alloc(pool, sizeof(amqp_queue_declare_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->queue, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->passive = (bit_buffer & (1 << 0)) ? 1 : 0;
       m->durable = (bit_buffer & (1 << 1)) ? 1 : 0;
       m->exclusive = (bit_buffer & (1 << 2)) ? 1 : 0;
@@ -564,41 +564,41 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_QUEUE_DECLARE_OK_METHOD: {
       amqp_queue_declare_ok_t *m = (amqp_queue_declare_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_queue_declare_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->queue, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_32(encoded, &offset, &m->message_count)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_32(encoded, &offset, &m->consumer_count)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_32(encoded, &offset, &m->message_count)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_32(encoded, &offset, &m->consumer_count)) return AMQP_STATUS_BAD_AMQP_DATA;
       *decoded = m;
       return 0;
     }
     case AMQP_QUEUE_BIND_METHOD: {
       amqp_queue_bind_t *m = (amqp_queue_bind_t *) amqp_pool_alloc(pool, sizeof(amqp_queue_bind_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->queue, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->exchange, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->routing_key, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->nowait = (bit_buffer & (1 << 0)) ? 1 : 0;
       {
         int res = amqp_decode_table(encoded, pool, &(m->arguments), &offset);
@@ -614,37 +614,37 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_QUEUE_PURGE_METHOD: {
       amqp_queue_purge_t *m = (amqp_queue_purge_t *) amqp_pool_alloc(pool, sizeof(amqp_queue_purge_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->queue, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->nowait = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
     }
     case AMQP_QUEUE_PURGE_OK_METHOD: {
       amqp_queue_purge_ok_t *m = (amqp_queue_purge_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_queue_purge_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_32(encoded, &offset, &m->message_count)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_32(encoded, &offset, &m->message_count)) return AMQP_STATUS_BAD_AMQP_DATA;
       *decoded = m;
       return 0;
     }
     case AMQP_QUEUE_DELETE_METHOD: {
       amqp_queue_delete_t *m = (amqp_queue_delete_t *) amqp_pool_alloc(pool, sizeof(amqp_queue_delete_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->queue, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->if_unused = (bit_buffer & (1 << 0)) ? 1 : 0;
       m->if_empty = (bit_buffer & (1 << 1)) ? 1 : 0;
       m->nowait = (bit_buffer & (1 << 2)) ? 1 : 0;
@@ -653,32 +653,32 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_QUEUE_DELETE_OK_METHOD: {
       amqp_queue_delete_ok_t *m = (amqp_queue_delete_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_queue_delete_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_32(encoded, &offset, &m->message_count)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_32(encoded, &offset, &m->message_count)) return AMQP_STATUS_BAD_AMQP_DATA;
       *decoded = m;
       return 0;
     }
     case AMQP_QUEUE_UNBIND_METHOD: {
       amqp_queue_unbind_t *m = (amqp_queue_unbind_t *) amqp_pool_alloc(pool, sizeof(amqp_queue_unbind_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->queue, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->exchange, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->routing_key, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         int res = amqp_decode_table(encoded, pool, &(m->arguments), &offset);
@@ -694,10 +694,10 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_BASIC_QOS_METHOD: {
       amqp_basic_qos_t *m = (amqp_basic_qos_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_qos_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_32(encoded, &offset, &m->prefetch_size)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_16(encoded, &offset, &m->prefetch_count)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_32(encoded, &offset, &m->prefetch_size)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_16(encoded, &offset, &m->prefetch_count)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->global = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
@@ -709,21 +709,21 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_BASIC_CONSUME_METHOD: {
       amqp_basic_consume_t *m = (amqp_basic_consume_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_consume_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->queue, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->consumer_tag, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->no_local = (bit_buffer & (1 << 0)) ? 1 : 0;
       m->no_ack = (bit_buffer & (1 << 1)) ? 1 : 0;
       m->exclusive = (bit_buffer & (1 << 2)) ? 1 : 0;
@@ -737,59 +737,59 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_BASIC_CONSUME_OK_METHOD: {
       amqp_basic_consume_ok_t *m = (amqp_basic_consume_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_consume_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->consumer_tag, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_CANCEL_METHOD: {
       amqp_basic_cancel_t *m = (amqp_basic_cancel_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_cancel_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->consumer_tag, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->nowait = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_CANCEL_OK_METHOD: {
       amqp_basic_cancel_ok_t *m = (amqp_basic_cancel_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_cancel_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->consumer_tag, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_PUBLISH_METHOD: {
       amqp_basic_publish_t *m = (amqp_basic_publish_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_publish_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->exchange, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->routing_key, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->mandatory = (bit_buffer & (1 << 0)) ? 1 : 0;
       m->immediate = (bit_buffer & (1 << 1)) ? 1 : 0;
       *decoded = m;
@@ -797,135 +797,135 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_BASIC_RETURN_METHOD: {
       amqp_basic_return_t *m = (amqp_basic_return_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_return_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->reply_code)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->reply_code)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->reply_text, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->exchange, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->routing_key, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_DELIVER_METHOD: {
       amqp_basic_deliver_t *m = (amqp_basic_deliver_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_deliver_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->consumer_tag, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_64(encoded, &offset, &m->delivery_tag)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_64(encoded, &offset, &m->delivery_tag)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->redelivered = (bit_buffer & (1 << 0)) ? 1 : 0;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->exchange, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->routing_key, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_GET_METHOD: {
       amqp_basic_get_t *m = (amqp_basic_get_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_get_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_16(encoded, &offset, &m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->queue, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->no_ack = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_GET_OK_METHOD: {
       amqp_basic_get_ok_t *m = (amqp_basic_get_ok_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_get_ok_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_64(encoded, &offset, &m->delivery_tag)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_64(encoded, &offset, &m->delivery_tag)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->redelivered = (bit_buffer & (1 << 0)) ? 1 : 0;
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->exchange, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->routing_key, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
-      if (!amqp_decode_32(encoded, &offset, &m->message_count)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_32(encoded, &offset, &m->message_count)) return AMQP_STATUS_BAD_AMQP_DATA;
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_GET_EMPTY_METHOD: {
       amqp_basic_get_empty_t *m = (amqp_basic_get_empty_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_get_empty_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &m->cluster_id, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_ACK_METHOD: {
       amqp_basic_ack_t *m = (amqp_basic_ack_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_ack_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_64(encoded, &offset, &m->delivery_tag)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_64(encoded, &offset, &m->delivery_tag)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->multiple = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_REJECT_METHOD: {
       amqp_basic_reject_t *m = (amqp_basic_reject_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_reject_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_64(encoded, &offset, &m->delivery_tag)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_64(encoded, &offset, &m->delivery_tag)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->requeue = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_RECOVER_ASYNC_METHOD: {
       amqp_basic_recover_async_t *m = (amqp_basic_recover_async_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_recover_async_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->requeue = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
     }
     case AMQP_BASIC_RECOVER_METHOD: {
       amqp_basic_recover_t *m = (amqp_basic_recover_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_recover_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->requeue = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
@@ -937,9 +937,9 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_BASIC_NACK_METHOD: {
       amqp_basic_nack_t *m = (amqp_basic_nack_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_nack_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_64(encoded, &offset, &m->delivery_tag)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_64(encoded, &offset, &m->delivery_tag)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->multiple = (bit_buffer & (1 << 0)) ? 1 : 0;
       m->requeue = (bit_buffer & (1 << 1)) ? 1 : 0;
       *decoded = m;
@@ -977,8 +977,8 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_CONFIRM_SELECT_METHOD: {
       amqp_confirm_select_t *m = (amqp_confirm_select_t *) amqp_pool_alloc(pool, sizeof(amqp_confirm_select_t));
-      if (m == NULL) { return -ERROR_NO_MEMORY; }
-      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }
+      if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       m->nowait = (bit_buffer & (1 << 0)) ? 1 : 0;
       *decoded = m;
       return 0;
@@ -988,7 +988,7 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
       *decoded = m;
       return 0;
     }
-    default: return -ERROR_UNKNOWN_METHOD;
+    default: return AMQP_STATUS_UNKNOWN_METHOD;
   }
 }
 
@@ -1005,7 +1005,7 @@ int amqp_decode_properties(uint16_t class_id,
 
   do {
     if (!amqp_decode_16(encoded, &offset, &partial_flags))
-      return -ERROR_BAD_AMQP_DATA;
+      return AMQP_STATUS_BAD_AMQP_DATA;
     flags |= (partial_flags << (flagword_index * 16));
     flagword_index++;
   } while (partial_flags & 1);
@@ -1013,49 +1013,49 @@ int amqp_decode_properties(uint16_t class_id,
   switch (class_id) {
     case 10: {
       amqp_connection_properties_t *p = (amqp_connection_properties_t *) amqp_pool_alloc(pool, sizeof(amqp_connection_properties_t));
-      if (p == NULL) { return -ERROR_NO_MEMORY; }
+      if (p == NULL) { return AMQP_STATUS_NO_MEMORY; }
       p->_flags = flags;
       *decoded = p;
       return 0;
     }
     case 20: {
       amqp_channel_properties_t *p = (amqp_channel_properties_t *) amqp_pool_alloc(pool, sizeof(amqp_channel_properties_t));
-      if (p == NULL) { return -ERROR_NO_MEMORY; }
+      if (p == NULL) { return AMQP_STATUS_NO_MEMORY; }
       p->_flags = flags;
       *decoded = p;
       return 0;
     }
     case 30: {
       amqp_access_properties_t *p = (amqp_access_properties_t *) amqp_pool_alloc(pool, sizeof(amqp_access_properties_t));
-      if (p == NULL) { return -ERROR_NO_MEMORY; }
+      if (p == NULL) { return AMQP_STATUS_NO_MEMORY; }
       p->_flags = flags;
       *decoded = p;
       return 0;
     }
     case 40: {
       amqp_exchange_properties_t *p = (amqp_exchange_properties_t *) amqp_pool_alloc(pool, sizeof(amqp_exchange_properties_t));
-      if (p == NULL) { return -ERROR_NO_MEMORY; }
+      if (p == NULL) { return AMQP_STATUS_NO_MEMORY; }
       p->_flags = flags;
       *decoded = p;
       return 0;
     }
     case 50: {
       amqp_queue_properties_t *p = (amqp_queue_properties_t *) amqp_pool_alloc(pool, sizeof(amqp_queue_properties_t));
-      if (p == NULL) { return -ERROR_NO_MEMORY; }
+      if (p == NULL) { return AMQP_STATUS_NO_MEMORY; }
       p->_flags = flags;
       *decoded = p;
       return 0;
     }
     case 60: {
       amqp_basic_properties_t *p = (amqp_basic_properties_t *) amqp_pool_alloc(pool, sizeof(amqp_basic_properties_t));
-      if (p == NULL) { return -ERROR_NO_MEMORY; }
+      if (p == NULL) { return AMQP_STATUS_NO_MEMORY; }
       p->_flags = flags;
       if (flags & AMQP_BASIC_CONTENT_TYPE_FLAG) {
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &p->content_type, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       }
       if (flags & AMQP_BASIC_CONTENT_ENCODING_FLAG) {
@@ -1063,7 +1063,7 @@ int amqp_decode_properties(uint16_t class_id,
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &p->content_encoding, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       }
       if (flags & AMQP_BASIC_HEADERS_FLAG) {
@@ -1073,17 +1073,17 @@ int amqp_decode_properties(uint16_t class_id,
       }
       }
       if (flags & AMQP_BASIC_DELIVERY_MODE_FLAG) {
-      if (!amqp_decode_8(encoded, &offset, &p->delivery_mode)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &p->delivery_mode)) return AMQP_STATUS_BAD_AMQP_DATA;
       }
       if (flags & AMQP_BASIC_PRIORITY_FLAG) {
-      if (!amqp_decode_8(encoded, &offset, &p->priority)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_8(encoded, &offset, &p->priority)) return AMQP_STATUS_BAD_AMQP_DATA;
       }
       if (flags & AMQP_BASIC_CORRELATION_ID_FLAG) {
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &p->correlation_id, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       }
       if (flags & AMQP_BASIC_REPLY_TO_FLAG) {
@@ -1091,7 +1091,7 @@ int amqp_decode_properties(uint16_t class_id,
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &p->reply_to, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       }
       if (flags & AMQP_BASIC_EXPIRATION_FLAG) {
@@ -1099,7 +1099,7 @@ int amqp_decode_properties(uint16_t class_id,
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &p->expiration, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       }
       if (flags & AMQP_BASIC_MESSAGE_ID_FLAG) {
@@ -1107,18 +1107,18 @@ int amqp_decode_properties(uint16_t class_id,
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &p->message_id, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       }
       if (flags & AMQP_BASIC_TIMESTAMP_FLAG) {
-      if (!amqp_decode_64(encoded, &offset, &p->timestamp)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_decode_64(encoded, &offset, &p->timestamp)) return AMQP_STATUS_BAD_AMQP_DATA;
       }
       if (flags & AMQP_BASIC_TYPE_FLAG) {
       {
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &p->type, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       }
       if (flags & AMQP_BASIC_USER_ID_FLAG) {
@@ -1126,7 +1126,7 @@ int amqp_decode_properties(uint16_t class_id,
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &p->user_id, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       }
       if (flags & AMQP_BASIC_APP_ID_FLAG) {
@@ -1134,7 +1134,7 @@ int amqp_decode_properties(uint16_t class_id,
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &p->app_id, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       }
       if (flags & AMQP_BASIC_CLUSTER_ID_FLAG) {
@@ -1142,7 +1142,7 @@ int amqp_decode_properties(uint16_t class_id,
         uint8_t len;
         if (!amqp_decode_8(encoded, &offset, &len)
             || !amqp_decode_bytes(encoded, &offset, &p->cluster_id, len))
-          return -ERROR_BAD_AMQP_DATA;
+          return AMQP_STATUS_BAD_AMQP_DATA;
       }
       }
       *decoded = p;
@@ -1150,19 +1150,19 @@ int amqp_decode_properties(uint16_t class_id,
     }
     case 90: {
       amqp_tx_properties_t *p = (amqp_tx_properties_t *) amqp_pool_alloc(pool, sizeof(amqp_tx_properties_t));
-      if (p == NULL) { return -ERROR_NO_MEMORY; }
+      if (p == NULL) { return AMQP_STATUS_NO_MEMORY; }
       p->_flags = flags;
       *decoded = p;
       return 0;
     }
     case 85: {
       amqp_confirm_properties_t *p = (amqp_confirm_properties_t *) amqp_pool_alloc(pool, sizeof(amqp_confirm_properties_t));
-      if (p == NULL) { return -ERROR_NO_MEMORY; }
+      if (p == NULL) { return AMQP_STATUS_NO_MEMORY; }
       p->_flags = flags;
       *decoded = p;
       return 0;
     }
-    default: return -ERROR_UNKNOWN_CLASS;
+    default: return AMQP_STATUS_UNKNOWN_CLASS;
   }
 }
 
@@ -1176,18 +1176,18 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
   switch (methodNumber) {
     case AMQP_CONNECTION_START_METHOD: {
       amqp_connection_start_t *m = (amqp_connection_start_t *) decoded;
-      if (!amqp_encode_8(encoded, &offset, m->version_major)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_8(encoded, &offset, m->version_minor)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, m->version_major)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, m->version_minor)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         int res = amqp_encode_table(encoded, &(m->server_properties), &offset);
         if (res < 0) return res;
       }
       if (!amqp_encode_32(encoded, &offset, m->mechanisms.len)
           || !amqp_encode_bytes(encoded, &offset, m->mechanisms))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_32(encoded, &offset, m->locales.len)
           || !amqp_encode_bytes(encoded, &offset, m->locales))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CONNECTION_START_OK_METHOD: {
@@ -1198,71 +1198,71 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
       }
       if (!amqp_encode_8(encoded, &offset, m->mechanism.len)
           || !amqp_encode_bytes(encoded, &offset, m->mechanism))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_32(encoded, &offset, m->response.len)
           || !amqp_encode_bytes(encoded, &offset, m->response))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->locale.len)
           || !amqp_encode_bytes(encoded, &offset, m->locale))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CONNECTION_SECURE_METHOD: {
       amqp_connection_secure_t *m = (amqp_connection_secure_t *) decoded;
       if (!amqp_encode_32(encoded, &offset, m->challenge.len)
           || !amqp_encode_bytes(encoded, &offset, m->challenge))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CONNECTION_SECURE_OK_METHOD: {
       amqp_connection_secure_ok_t *m = (amqp_connection_secure_ok_t *) decoded;
       if (!amqp_encode_32(encoded, &offset, m->response.len)
           || !amqp_encode_bytes(encoded, &offset, m->response))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CONNECTION_TUNE_METHOD: {
       amqp_connection_tune_t *m = (amqp_connection_tune_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->channel_max)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_32(encoded, &offset, m->frame_max)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_16(encoded, &offset, m->heartbeat)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->channel_max)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_32(encoded, &offset, m->frame_max)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->heartbeat)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CONNECTION_TUNE_OK_METHOD: {
       amqp_connection_tune_ok_t *m = (amqp_connection_tune_ok_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->channel_max)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_32(encoded, &offset, m->frame_max)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_16(encoded, &offset, m->heartbeat)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->channel_max)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_32(encoded, &offset, m->frame_max)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->heartbeat)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CONNECTION_OPEN_METHOD: {
       amqp_connection_open_t *m = (amqp_connection_open_t *) decoded;
       if (!amqp_encode_8(encoded, &offset, m->virtual_host.len)
           || !amqp_encode_bytes(encoded, &offset, m->virtual_host))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->capabilities.len)
           || !amqp_encode_bytes(encoded, &offset, m->capabilities))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->insist) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CONNECTION_OPEN_OK_METHOD: {
       amqp_connection_open_ok_t *m = (amqp_connection_open_ok_t *) decoded;
       if (!amqp_encode_8(encoded, &offset, m->known_hosts.len)
           || !amqp_encode_bytes(encoded, &offset, m->known_hosts))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CONNECTION_CLOSE_METHOD: {
       amqp_connection_close_t *m = (amqp_connection_close_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->reply_code)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->reply_code)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->reply_text.len)
           || !amqp_encode_bytes(encoded, &offset, m->reply_text))
-        return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_16(encoded, &offset, m->class_id)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_16(encoded, &offset, m->method_id)) return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->class_id)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->method_id)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CONNECTION_CLOSE_OK_METHOD: {
@@ -1272,38 +1272,38 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
       amqp_channel_open_t *m = (amqp_channel_open_t *) decoded;
       if (!amqp_encode_8(encoded, &offset, m->out_of_band.len)
           || !amqp_encode_bytes(encoded, &offset, m->out_of_band))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CHANNEL_OPEN_OK_METHOD: {
       amqp_channel_open_ok_t *m = (amqp_channel_open_ok_t *) decoded;
       if (!amqp_encode_32(encoded, &offset, m->channel_id.len)
           || !amqp_encode_bytes(encoded, &offset, m->channel_id))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CHANNEL_FLOW_METHOD: {
       amqp_channel_flow_t *m = (amqp_channel_flow_t *) decoded;
       bit_buffer = 0;
       if (m->active) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CHANNEL_FLOW_OK_METHOD: {
       amqp_channel_flow_ok_t *m = (amqp_channel_flow_ok_t *) decoded;
       bit_buffer = 0;
       if (m->active) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CHANNEL_CLOSE_METHOD: {
       amqp_channel_close_t *m = (amqp_channel_close_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->reply_code)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->reply_code)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->reply_text.len)
           || !amqp_encode_bytes(encoded, &offset, m->reply_text))
-        return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_16(encoded, &offset, m->class_id)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_16(encoded, &offset, m->method_id)) return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->class_id)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->method_id)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CHANNEL_CLOSE_OK_METHOD: {
@@ -1313,37 +1313,37 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
       amqp_access_request_t *m = (amqp_access_request_t *) decoded;
       if (!amqp_encode_8(encoded, &offset, m->realm.len)
           || !amqp_encode_bytes(encoded, &offset, m->realm))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->exclusive) bit_buffer |= (1 << 0);
       if (m->passive) bit_buffer |= (1 << 1);
       if (m->active) bit_buffer |= (1 << 2);
       if (m->write) bit_buffer |= (1 << 3);
       if (m->read) bit_buffer |= (1 << 4);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_ACCESS_REQUEST_OK_METHOD: {
       amqp_access_request_ok_t *m = (amqp_access_request_ok_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_EXCHANGE_DECLARE_METHOD: {
       amqp_exchange_declare_t *m = (amqp_exchange_declare_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->exchange.len)
           || !amqp_encode_bytes(encoded, &offset, m->exchange))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->type.len)
           || !amqp_encode_bytes(encoded, &offset, m->type))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->passive) bit_buffer |= (1 << 0);
       if (m->durable) bit_buffer |= (1 << 1);
       if (m->auto_delete) bit_buffer |= (1 << 2);
       if (m->internal) bit_buffer |= (1 << 3);
       if (m->nowait) bit_buffer |= (1 << 4);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         int res = amqp_encode_table(encoded, &(m->arguments), &offset);
         if (res < 0) return res;
@@ -1355,14 +1355,14 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_EXCHANGE_DELETE_METHOD: {
       amqp_exchange_delete_t *m = (amqp_exchange_delete_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->exchange.len)
           || !amqp_encode_bytes(encoded, &offset, m->exchange))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->if_unused) bit_buffer |= (1 << 0);
       if (m->nowait) bit_buffer |= (1 << 1);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_EXCHANGE_DELETE_OK_METHOD: {
@@ -1370,19 +1370,19 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_EXCHANGE_BIND_METHOD: {
       amqp_exchange_bind_t *m = (amqp_exchange_bind_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->destination.len)
           || !amqp_encode_bytes(encoded, &offset, m->destination))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->source.len)
           || !amqp_encode_bytes(encoded, &offset, m->source))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->routing_key.len)
           || !amqp_encode_bytes(encoded, &offset, m->routing_key))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->nowait) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         int res = amqp_encode_table(encoded, &(m->arguments), &offset);
         if (res < 0) return res;
@@ -1394,19 +1394,19 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_EXCHANGE_UNBIND_METHOD: {
       amqp_exchange_unbind_t *m = (amqp_exchange_unbind_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->destination.len)
           || !amqp_encode_bytes(encoded, &offset, m->destination))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->source.len)
           || !amqp_encode_bytes(encoded, &offset, m->source))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->routing_key.len)
           || !amqp_encode_bytes(encoded, &offset, m->routing_key))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->nowait) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         int res = amqp_encode_table(encoded, &(m->arguments), &offset);
         if (res < 0) return res;
@@ -1418,17 +1418,17 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_QUEUE_DECLARE_METHOD: {
       amqp_queue_declare_t *m = (amqp_queue_declare_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->queue.len)
           || !amqp_encode_bytes(encoded, &offset, m->queue))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->passive) bit_buffer |= (1 << 0);
       if (m->durable) bit_buffer |= (1 << 1);
       if (m->exclusive) bit_buffer |= (1 << 2);
       if (m->auto_delete) bit_buffer |= (1 << 3);
       if (m->nowait) bit_buffer |= (1 << 4);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         int res = amqp_encode_table(encoded, &(m->arguments), &offset);
         if (res < 0) return res;
@@ -1439,26 +1439,26 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
       amqp_queue_declare_ok_t *m = (amqp_queue_declare_ok_t *) decoded;
       if (!amqp_encode_8(encoded, &offset, m->queue.len)
           || !amqp_encode_bytes(encoded, &offset, m->queue))
-        return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_32(encoded, &offset, m->message_count)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_32(encoded, &offset, m->consumer_count)) return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_32(encoded, &offset, m->message_count)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_32(encoded, &offset, m->consumer_count)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_QUEUE_BIND_METHOD: {
       amqp_queue_bind_t *m = (amqp_queue_bind_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->queue.len)
           || !amqp_encode_bytes(encoded, &offset, m->queue))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->exchange.len)
           || !amqp_encode_bytes(encoded, &offset, m->exchange))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->routing_key.len)
           || !amqp_encode_bytes(encoded, &offset, m->routing_key))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->nowait) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         int res = amqp_encode_table(encoded, &(m->arguments), &offset);
         if (res < 0) return res;
@@ -1470,50 +1470,50 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_QUEUE_PURGE_METHOD: {
       amqp_queue_purge_t *m = (amqp_queue_purge_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->queue.len)
           || !amqp_encode_bytes(encoded, &offset, m->queue))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->nowait) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_QUEUE_PURGE_OK_METHOD: {
       amqp_queue_purge_ok_t *m = (amqp_queue_purge_ok_t *) decoded;
-      if (!amqp_encode_32(encoded, &offset, m->message_count)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_32(encoded, &offset, m->message_count)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_QUEUE_DELETE_METHOD: {
       amqp_queue_delete_t *m = (amqp_queue_delete_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->queue.len)
           || !amqp_encode_bytes(encoded, &offset, m->queue))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->if_unused) bit_buffer |= (1 << 0);
       if (m->if_empty) bit_buffer |= (1 << 1);
       if (m->nowait) bit_buffer |= (1 << 2);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_QUEUE_DELETE_OK_METHOD: {
       amqp_queue_delete_ok_t *m = (amqp_queue_delete_ok_t *) decoded;
-      if (!amqp_encode_32(encoded, &offset, m->message_count)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_32(encoded, &offset, m->message_count)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_QUEUE_UNBIND_METHOD: {
       amqp_queue_unbind_t *m = (amqp_queue_unbind_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->queue.len)
           || !amqp_encode_bytes(encoded, &offset, m->queue))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->exchange.len)
           || !amqp_encode_bytes(encoded, &offset, m->exchange))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->routing_key.len)
           || !amqp_encode_bytes(encoded, &offset, m->routing_key))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       {
         int res = amqp_encode_table(encoded, &(m->arguments), &offset);
         if (res < 0) return res;
@@ -1525,11 +1525,11 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_BASIC_QOS_METHOD: {
       amqp_basic_qos_t *m = (amqp_basic_qos_t *) decoded;
-      if (!amqp_encode_32(encoded, &offset, m->prefetch_size)) return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_16(encoded, &offset, m->prefetch_count)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_32(encoded, &offset, m->prefetch_size)) return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->prefetch_count)) return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->global) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_QOS_OK_METHOD: {
@@ -1537,19 +1537,19 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_BASIC_CONSUME_METHOD: {
       amqp_basic_consume_t *m = (amqp_basic_consume_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->queue.len)
           || !amqp_encode_bytes(encoded, &offset, m->queue))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->consumer_tag.len)
           || !amqp_encode_bytes(encoded, &offset, m->consumer_tag))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->no_local) bit_buffer |= (1 << 0);
       if (m->no_ack) bit_buffer |= (1 << 1);
       if (m->exclusive) bit_buffer |= (1 << 2);
       if (m->nowait) bit_buffer |= (1 << 3);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       {
         int res = amqp_encode_table(encoded, &(m->arguments), &offset);
         if (res < 0) return res;
@@ -1560,133 +1560,133 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
       amqp_basic_consume_ok_t *m = (amqp_basic_consume_ok_t *) decoded;
       if (!amqp_encode_8(encoded, &offset, m->consumer_tag.len)
           || !amqp_encode_bytes(encoded, &offset, m->consumer_tag))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_CANCEL_METHOD: {
       amqp_basic_cancel_t *m = (amqp_basic_cancel_t *) decoded;
       if (!amqp_encode_8(encoded, &offset, m->consumer_tag.len)
           || !amqp_encode_bytes(encoded, &offset, m->consumer_tag))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->nowait) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_CANCEL_OK_METHOD: {
       amqp_basic_cancel_ok_t *m = (amqp_basic_cancel_ok_t *) decoded;
       if (!amqp_encode_8(encoded, &offset, m->consumer_tag.len)
           || !amqp_encode_bytes(encoded, &offset, m->consumer_tag))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_PUBLISH_METHOD: {
       amqp_basic_publish_t *m = (amqp_basic_publish_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->exchange.len)
           || !amqp_encode_bytes(encoded, &offset, m->exchange))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->routing_key.len)
           || !amqp_encode_bytes(encoded, &offset, m->routing_key))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->mandatory) bit_buffer |= (1 << 0);
       if (m->immediate) bit_buffer |= (1 << 1);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_RETURN_METHOD: {
       amqp_basic_return_t *m = (amqp_basic_return_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->reply_code)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->reply_code)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->reply_text.len)
           || !amqp_encode_bytes(encoded, &offset, m->reply_text))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->exchange.len)
           || !amqp_encode_bytes(encoded, &offset, m->exchange))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->routing_key.len)
           || !amqp_encode_bytes(encoded, &offset, m->routing_key))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_DELIVER_METHOD: {
       amqp_basic_deliver_t *m = (amqp_basic_deliver_t *) decoded;
       if (!amqp_encode_8(encoded, &offset, m->consumer_tag.len)
           || !amqp_encode_bytes(encoded, &offset, m->consumer_tag))
-        return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_64(encoded, &offset, m->delivery_tag)) return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_64(encoded, &offset, m->delivery_tag)) return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->redelivered) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->exchange.len)
           || !amqp_encode_bytes(encoded, &offset, m->exchange))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->routing_key.len)
           || !amqp_encode_bytes(encoded, &offset, m->routing_key))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_GET_METHOD: {
       amqp_basic_get_t *m = (amqp_basic_get_t *) decoded;
-      if (!amqp_encode_16(encoded, &offset, m->ticket)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_16(encoded, &offset, m->ticket)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->queue.len)
           || !amqp_encode_bytes(encoded, &offset, m->queue))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->no_ack) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_GET_OK_METHOD: {
       amqp_basic_get_ok_t *m = (amqp_basic_get_ok_t *) decoded;
-      if (!amqp_encode_64(encoded, &offset, m->delivery_tag)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_64(encoded, &offset, m->delivery_tag)) return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->redelivered) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->exchange.len)
           || !amqp_encode_bytes(encoded, &offset, m->exchange))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       if (!amqp_encode_8(encoded, &offset, m->routing_key.len)
           || !amqp_encode_bytes(encoded, &offset, m->routing_key))
-        return -ERROR_BAD_AMQP_DATA;
-      if (!amqp_encode_32(encoded, &offset, m->message_count)) return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
+      if (!amqp_encode_32(encoded, &offset, m->message_count)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_GET_EMPTY_METHOD: {
       amqp_basic_get_empty_t *m = (amqp_basic_get_empty_t *) decoded;
       if (!amqp_encode_8(encoded, &offset, m->cluster_id.len)
           || !amqp_encode_bytes(encoded, &offset, m->cluster_id))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_ACK_METHOD: {
       amqp_basic_ack_t *m = (amqp_basic_ack_t *) decoded;
-      if (!amqp_encode_64(encoded, &offset, m->delivery_tag)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_64(encoded, &offset, m->delivery_tag)) return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->multiple) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_REJECT_METHOD: {
       amqp_basic_reject_t *m = (amqp_basic_reject_t *) decoded;
-      if (!amqp_encode_64(encoded, &offset, m->delivery_tag)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_64(encoded, &offset, m->delivery_tag)) return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->requeue) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_RECOVER_ASYNC_METHOD: {
       amqp_basic_recover_async_t *m = (amqp_basic_recover_async_t *) decoded;
       bit_buffer = 0;
       if (m->requeue) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_RECOVER_METHOD: {
       amqp_basic_recover_t *m = (amqp_basic_recover_t *) decoded;
       bit_buffer = 0;
       if (m->requeue) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_BASIC_RECOVER_OK_METHOD: {
@@ -1694,11 +1694,11 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
     }
     case AMQP_BASIC_NACK_METHOD: {
       amqp_basic_nack_t *m = (amqp_basic_nack_t *) decoded;
-      if (!amqp_encode_64(encoded, &offset, m->delivery_tag)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_64(encoded, &offset, m->delivery_tag)) return AMQP_STATUS_BAD_AMQP_DATA;
       bit_buffer = 0;
       if (m->multiple) bit_buffer |= (1 << 0);
       if (m->requeue) bit_buffer |= (1 << 1);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_TX_SELECT_METHOD: {
@@ -1723,13 +1723,13 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
       amqp_confirm_select_t *m = (amqp_confirm_select_t *) decoded;
       bit_buffer = 0;
       if (m->nowait) bit_buffer |= (1 << 0);
-      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;
       return offset;
     }
     case AMQP_CONFIRM_SELECT_OK_METHOD: {
       return offset;
     }
-    default: return -ERROR_UNKNOWN_METHOD;
+    default: return AMQP_STATUS_UNKNOWN_METHOD;
   }
 }
 
@@ -1752,7 +1752,7 @@ int amqp_encode_properties(uint16_t class_id,
       uint16_t partial_flags = remaining_flags & 0xFFFE;
       if (remainder != 0) { partial_flags |= 1; }
       if (!amqp_encode_16(encoded, &offset, partial_flags))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       remaining_flags = remainder;
     } while (remaining_flags != 0);
   }
@@ -1778,12 +1778,12 @@ int amqp_encode_properties(uint16_t class_id,
             if (flags & AMQP_BASIC_CONTENT_TYPE_FLAG) {
       if (!amqp_encode_8(encoded, &offset, p->content_type.len)
           || !amqp_encode_bytes(encoded, &offset, p->content_type))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_CONTENT_ENCODING_FLAG) {
       if (!amqp_encode_8(encoded, &offset, p->content_encoding.len)
           || !amqp_encode_bytes(encoded, &offset, p->content_encoding))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_HEADERS_FLAG) {
       {
@@ -1792,53 +1792,53 @@ int amqp_encode_properties(uint16_t class_id,
       }
       }
             if (flags & AMQP_BASIC_DELIVERY_MODE_FLAG) {
-      if (!amqp_encode_8(encoded, &offset, p->delivery_mode)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, p->delivery_mode)) return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_PRIORITY_FLAG) {
-      if (!amqp_encode_8(encoded, &offset, p->priority)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_8(encoded, &offset, p->priority)) return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_CORRELATION_ID_FLAG) {
       if (!amqp_encode_8(encoded, &offset, p->correlation_id.len)
           || !amqp_encode_bytes(encoded, &offset, p->correlation_id))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_REPLY_TO_FLAG) {
       if (!amqp_encode_8(encoded, &offset, p->reply_to.len)
           || !amqp_encode_bytes(encoded, &offset, p->reply_to))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_EXPIRATION_FLAG) {
       if (!amqp_encode_8(encoded, &offset, p->expiration.len)
           || !amqp_encode_bytes(encoded, &offset, p->expiration))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_MESSAGE_ID_FLAG) {
       if (!amqp_encode_8(encoded, &offset, p->message_id.len)
           || !amqp_encode_bytes(encoded, &offset, p->message_id))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_TIMESTAMP_FLAG) {
-      if (!amqp_encode_64(encoded, &offset, p->timestamp)) return -ERROR_BAD_AMQP_DATA;
+      if (!amqp_encode_64(encoded, &offset, p->timestamp)) return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_TYPE_FLAG) {
       if (!amqp_encode_8(encoded, &offset, p->type.len)
           || !amqp_encode_bytes(encoded, &offset, p->type))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_USER_ID_FLAG) {
       if (!amqp_encode_8(encoded, &offset, p->user_id.len)
           || !amqp_encode_bytes(encoded, &offset, p->user_id))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_APP_ID_FLAG) {
       if (!amqp_encode_8(encoded, &offset, p->app_id.len)
           || !amqp_encode_bytes(encoded, &offset, p->app_id))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       }
             if (flags & AMQP_BASIC_CLUSTER_ID_FLAG) {
       if (!amqp_encode_8(encoded, &offset, p->cluster_id.len)
           || !amqp_encode_bytes(encoded, &offset, p->cluster_id))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       }
       return offset;
     }
@@ -1848,7 +1848,7 @@ int amqp_encode_properties(uint16_t class_id,
     case 85: {
       return offset;
     }
-    default: return -ERROR_UNKNOWN_CLASS;
+    default: return AMQP_STATUS_UNKNOWN_CLASS;
   }
 }
 
diff --git a/librabbitmq/amqp_gnutls.c b/librabbitmq/amqp_gnutls.c
index f05fcb8..734643c 100644
--- a/librabbitmq/amqp_gnutls.c
+++ b/librabbitmq/amqp_gnutls.c
@@ -60,7 +60,7 @@ amqp_ssl_socket_send(void *base,
   self->last_error = 0;
   status = gnutls_record_send(self->session, buf, len);
   if (status < 0) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
   }
   return status;
 }
@@ -85,7 +85,7 @@ amqp_ssl_socket_writev(void *base,
     self->buffer = malloc(bytes);
     if (!self->buffer) {
       self->length = 0;
-      self->last_error = ERROR_NO_MEMORY;
+      self->last_error = AMQP_STATUS_NO_MEMORY;
       goto exit;
     }
     self->length = 0;
@@ -112,7 +112,7 @@ amqp_ssl_socket_recv(void *base,
   self->last_error = 0;
   status = gnutls_record_recv(self->session, buf, len);
   if (status < 0) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
   }
 
   return status;
@@ -128,7 +128,7 @@ amqp_ssl_socket_open(void *base, const char *host, int port)
   free(self->host);
   self->host = strdup(host);
   if (NULL == self->host) {
-    self->last_error = ERROR_NO_MEMORY;
+    self->last_error = AMQP_STATUS_NO_MEMORY;
     return -1;
   }
 
@@ -144,7 +144,7 @@ amqp_ssl_socket_open(void *base, const char *host, int port)
   } while (status < 0 && !gnutls_error_is_fatal(status));
 
   if (gnutls_error_is_fatal(status)) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
   }
 
   return status;
diff --git a/librabbitmq/amqp_openssl.c b/librabbitmq/amqp_openssl.c
index 301a10d..0b0655e 100644
--- a/librabbitmq/amqp_openssl.c
+++ b/librabbitmq/amqp_openssl.c
@@ -80,7 +80,7 @@ amqp_ssl_socket_send(void *base,
   self->last_error = 0;
   sent = SSL_write(self->ssl, buf, len);
   if (0 > sent) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
     switch (SSL_get_error(self->ssl, sent)) {
     case SSL_ERROR_NONE:
     case SSL_ERROR_ZERO_RETURN:
@@ -113,7 +113,7 @@ amqp_ssl_socket_writev(void *base,
     self->buffer = malloc(bytes);
     if (!self->buffer) {
       self->length = 0;
-      self->last_error = ERROR_NO_MEMORY;
+      self->last_error = AMQP_STATUS_NO_MEMORY;
       goto exit;
     }
     self->length = bytes;
@@ -140,7 +140,7 @@ amqp_ssl_socket_recv(void *base,
   self->last_error = 0;
   received = SSL_read(self->ssl, buf, len);
   if (0 > received) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
     switch(SSL_get_error(self->ssl, received)) {
     case SSL_ERROR_WANT_READ:
     case SSL_ERROR_WANT_WRITE:
@@ -225,7 +225,7 @@ amqp_ssl_socket_open(void *base, const char *host, int port)
   self->last_error = 0;
   self->ssl = SSL_new(self->ctx);
   if (!self->ssl) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
     return -1;
   }
   SSL_set_mode(self->ssl, SSL_MODE_AUTO_RETRY);
@@ -236,23 +236,23 @@ amqp_ssl_socket_open(void *base, const char *host, int port)
   }
   status = SSL_set_fd(self->ssl, self->sockfd);
   if (!status) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
     return -1;
   }
   status = SSL_connect(self->ssl);
   if (!status) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
     return -1;
   }
   result = SSL_get_verify_result(self->ssl);
   if (X509_V_OK != result) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
     return -1;
   }
   if (self->verify) {
     int status = amqp_ssl_socket_verify(self, host);
     if (status) {
-      self->last_error = ERROR_CATEGORY_SSL;
+      self->last_error = AMQP_STATUS_SSL_ERROR;
       return -1;
     }
   }
diff --git a/librabbitmq/amqp_polarssl.c b/librabbitmq/amqp_polarssl.c
index 56c45c6..770fdbe 100644
--- a/librabbitmq/amqp_polarssl.c
+++ b/librabbitmq/amqp_polarssl.c
@@ -67,7 +67,7 @@ amqp_ssl_socket_send(void *base,
   self->last_error = 0;
   status = ssl_write(self->ssl, buf, len);
   if (status < 0) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
   }
 
   return status;
@@ -93,7 +93,7 @@ amqp_ssl_socket_writev(void *base,
     self->buffer = malloc(bytes);
     if (!self->buffer) {
       self->length = 0;
-      self->last_error = ERROR_NO_MEMORY;
+      self->last_error = AMQP_STATUS_NO_MEMORY;
       goto exit;
     }
     self->length = bytes;
@@ -121,7 +121,7 @@ amqp_ssl_socket_recv(void *base,
   self->last_error = 0;
   status = ssl_read(self->ssl, buf, len);
   if (status < 0) {
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
   }
 
   return status;
@@ -139,7 +139,7 @@ amqp_ssl_socket_open(void *base, const char *host, int port)
     /* This isn't quite right. We should probably translate between
      * POLARSSL_ERR_* to our internal error codes
      */
-    self->last_error = ERROR_CATEGORY_SSL;
+    self->last_error = AMQP_STATUS_SSL_ERROR;
     return -1;
   }
   if (self->cacert) {
@@ -156,7 +156,7 @@ amqp_ssl_socket_open(void *base, const char *host, int port)
     case POLARSSL_ERR_NET_WANT_WRITE:
       continue;
     default:
-      self->last_error = ERROR_CATEGORY_SSL;
+      self->last_error = AMQP_STATUS_SSL_ERROR;
       break;
     }
   }
@@ -193,7 +193,7 @@ amqp_ssl_socket_close(void *base)
 static int
 amqp_ssl_socket_error(AMQP_UNUSED void *user_data)
 {
-  return ERROR_CATEGORY_SSL;
+  return AMQP_STATUS_SSL_ERROR;
 }
 
 char *
diff --git a/librabbitmq/amqp_private.h b/librabbitmq/amqp_private.h
index a33205e..cc3c7f2 100644
--- a/librabbitmq/amqp_private.h
+++ b/librabbitmq/amqp_private.h
@@ -49,28 +49,6 @@
 #include <arpa/inet.h>
 #endif
 
-/* Error numbering: Because of differences in error numbering on
- * different platforms, we want to keep error numbers opaque for
- * client code.  Internally, we encode the category of an error
- * (i.e. where its number comes from) in the top bits of the number
- * (assuming that an int has at least 32 bits).
- */
-#define ERROR_CATEGORY_CLIENT (0 << 29) /* librabbitmq error codes */
-#define ERROR_CATEGORY_OS (1 << 29) /* OS-specific error codes */
-#define ERROR_CATEGORY_SSL (1 << 28) /* SSL-specific error codes */
-#define ERROR_CATEGORY_MASK (ERROR_CATEGORY_OS | ERROR_CATEGORY_SSL)
-
-/* librabbitmq error codes */
-#define ERROR_NO_MEMORY 1
-#define ERROR_BAD_AMQP_DATA 2
-#define ERROR_UNKNOWN_CLASS 3
-#define ERROR_UNKNOWN_METHOD 4
-#define ERROR_GETHOSTBYNAME_FAILED 5
-#define ERROR_INCOMPATIBLE_AMQP_VERSION 6
-#define ERROR_CONNECTION_CLOSED 7
-#define ERROR_BAD_AMQP_URL 8
-#define ERROR_MAX 8
-
 /* GCC attributes */
 #if __GNUC__ > 2 | (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
 #define AMQP_NORETURN \
diff --git a/librabbitmq/amqp_socket.c b/librabbitmq/amqp_socket.c
index f0f8b9f..cd9e75c 100644
--- a/librabbitmq/amqp_socket.c
+++ b/librabbitmq/amqp_socket.c
@@ -88,7 +88,7 @@ amqp_socket_close(amqp_socket_t *self)
     assert(self->klass->close);
     return self->klass->close(self);
   }
-  return 0;
+  return AMQP_STATUS_OK;
 }
 
 int
@@ -115,12 +115,12 @@ int amqp_open_socket(char const *hostname,
   struct addrinfo *addr;
   char portnumber_string[33];
   int sockfd = -1;
-  int last_error = 0;
+  int last_error = AMQP_STATUS_OK;
   int one = 1; /* for setsockopt */
 
   last_error = amqp_socket_init();
-  if (0 != last_error) {
-    return -last_error;
+  if (AMQP_STATUS_OK != last_error) {
+    return last_error;
   }
 
   memset(&hint, 0, sizeof(hint));
@@ -132,8 +132,8 @@ int amqp_open_socket(char const *hostname,
 
   last_error = getaddrinfo(hostname, portnumber_string, &hint, &address_list);
 
-  if (last_error != 0) {
-    return -ERROR_GETHOSTBYNAME_FAILED;
+  if (0 != last_error) {
+    return AMQP_STATUS_HOSTNAME_RESOLUTION_FAILED;
   }
 
   for (addr = address_list; addr; addr = addr->ai_next) {
@@ -143,29 +143,29 @@ int amqp_open_socket(char const *hostname,
     */
     sockfd = (int)socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
     if (-1 == sockfd) {
-      last_error = -amqp_os_socket_error();
+      last_error = AMQP_STATUS_SOCKET_ERROR;
       continue;
     }
 #ifdef DISABLE_SIGPIPE_WITH_SETSOCKOPT
     if (0 != amqp_socket_setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &one, sizeof(one))) {
-      last_error = -amqp_os_socket_error();
+      last_error = AMQP_STATUS_SOCKET_ERROR;
       amqp_os_socket_close(sockfd);
       continue;
     }
 #endif /* DISABLE_SIGPIPE_WITH_SETSOCKOPT */
     if (0 != amqp_socket_setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one))
         || 0 != connect(sockfd, addr->ai_addr, addr->ai_addrlen)) {
-      last_error = -amqp_os_socket_error();
+      last_error = AMQP_STATUS_SOCKET_ERROR;
       amqp_os_socket_close(sockfd);
       continue;
     } else {
-      last_error = 0;
+      last_error = AMQP_STATUS_OK;
       break;
     }
   }
 
   freeaddrinfo(address_list);
-  if (last_error != 0) {
+  if (last_error != AMQP_STATUS_OK) {
     return last_error;
   }
 
@@ -269,7 +269,7 @@ static int wait_frame_inner(amqp_connection_state_t state,
 
       if (decoded_frame->frame_type != 0) {
         /* Complete frame was read. Return it. */
-        return 0;
+        return AMQP_STATUS_OK;
       }
 
       /* Incomplete or ignored frame. Keep processing input. */
@@ -280,9 +280,9 @@ static int wait_frame_inner(amqp_connection_state_t state,
                            state->sock_inbound_buffer.len, 0);
     if (res <= 0) {
       if (res == 0) {
-        return -ERROR_CONNECTION_CLOSED;
+        return AMQP_STATUS_CONNECTION_CLOSED;
       } else {
-        return -amqp_socket_error(state->socket);
+        return amqp_socket_error(state->socket);
       }
     }
 
@@ -301,7 +301,7 @@ int amqp_simple_wait_frame(amqp_connection_state_t state,
       state->last_queued_frame = NULL;
     }
     *decoded_frame = *f;
-    return 0;
+    return AMQP_STATUS_OK;
   } else {
     return wait_frame_inner(state, decoded_frame);
   }
@@ -337,7 +337,7 @@ int amqp_simple_wait_method(amqp_connection_state_t state,
                frame.payload.method.id);
   }
   *output = frame.payload.method;
-  return 0;
+  return AMQP_STATUS_OK;
 }
 
 int amqp_send_method(amqp_connection_state_t state,
@@ -379,7 +379,7 @@ amqp_rpc_reply_t amqp_simple_rpc(amqp_connection_state_t state,
   status = amqp_send_method(state, channel, request_id, decoded_request_method);
   if (status < 0) {
     result.reply_type = AMQP_RESPONSE_LIBRARY_EXCEPTION;
-    result.library_error = -status;
+    result.library_error = status;
     return result;
   }
 
@@ -390,7 +390,7 @@ retry:
     status = wait_frame_inner(state, &frame);
     if (status < 0) {
       result.reply_type = AMQP_RESPONSE_LIBRARY_EXCEPTION;
-      result.library_error = -status;
+      result.library_error = status;
       return result;
     }
 
@@ -417,7 +417,7 @@ retry:
 
       if (frame_copy == NULL || link == NULL) {
         result.reply_type = AMQP_RESPONSE_LIBRARY_EXCEPTION;
-        result.library_error = ERROR_NO_MEMORY;
+        result.library_error = AMQP_STATUS_NO_MEMORY;
         return result;
       }
 
@@ -520,7 +520,7 @@ static amqp_rpc_reply_t amqp_login_inner(amqp_connection_state_t state,
     amqp_connection_start_t *s = (amqp_connection_start_t *) method.decoded;
     if ((s->version_major != AMQP_PROTOCOL_VERSION_MAJOR)
         || (s->version_minor != AMQP_PROTOCOL_VERSION_MINOR)) {
-      res = -ERROR_INCOMPATIBLE_AMQP_VERSION;
+      res = AMQP_STATUS_INCOMPATIBLE_AMQP_VERSION;
       goto error_res;
     }
 
@@ -537,7 +537,7 @@ static amqp_rpc_reply_t amqp_login_inner(amqp_connection_state_t state,
                                   sasl_method, vl);
 
     if (response_bytes.bytes == NULL) {
-      res = -ERROR_NO_MEMORY;
+      res = AMQP_STATUS_NO_MEMORY;
       goto error_res;
     }
 
@@ -572,7 +572,7 @@ static amqp_rpc_reply_t amqp_login_inner(amqp_connection_state_t state,
       s.client_properties.entries = amqp_pool_alloc(&state->decoding_pool,
                                     sizeof(amqp_table_entry_t) * (default_table.num_entries + client_properties->num_entries));
       if (NULL == s.client_properties.entries) {
-        res = -ERROR_NO_MEMORY;
+        res = AMQP_STATUS_NO_MEMORY;
         goto error_res;
       }
       s.client_properties.num_entries = 0;
diff --git a/librabbitmq/amqp_table.c b/librabbitmq/amqp_table.c
index 847770e..8495377 100644
--- a/librabbitmq/amqp_table.c
+++ b/librabbitmq/amqp_table.c
@@ -72,12 +72,12 @@ static int amqp_decode_array(amqp_bytes_t encoded,
   int res;
 
   if (!amqp_decode_32(encoded, offset, &arraysize)) {
-    return -ERROR_BAD_AMQP_DATA;
+    return AMQP_STATUS_BAD_AMQP_DATA;
   }
 
   entries = malloc(allocated_entries * sizeof(amqp_field_value_t));
   if (entries == NULL) {
-    return -ERROR_NO_MEMORY;
+    return AMQP_STATUS_NO_MEMORY;
   }
 
   limit = *offset + arraysize;
@@ -86,7 +86,7 @@ static int amqp_decode_array(amqp_bytes_t encoded,
       void *newentries;
       allocated_entries = allocated_entries * 2;
       newentries = realloc(entries, allocated_entries * sizeof(amqp_field_value_t));
-      res = -ERROR_NO_MEMORY;
+      res = AMQP_STATUS_NO_MEMORY;
       if (newentries == NULL) {
         goto out;
       }
@@ -105,7 +105,7 @@ static int amqp_decode_array(amqp_bytes_t encoded,
 
   output->num_entries = num_entries;
   output->entries = amqp_pool_alloc(pool, num_entries * sizeof(amqp_field_value_t));
-  res = -ERROR_NO_MEMORY;
+  res = AMQP_STATUS_NO_MEMORY;
   /* NULL is legitimate if we requested a zero-length block. */
   if (output->entries == NULL && num_entries > 0) {
     goto out;
@@ -132,19 +132,19 @@ int amqp_decode_table(amqp_bytes_t encoded,
   int res;
 
   if (!amqp_decode_32(encoded, offset, &tablesize)) {
-    return -ERROR_BAD_AMQP_DATA;
+    return AMQP_STATUS_BAD_AMQP_DATA;
   }
 
   entries = malloc(allocated_entries * sizeof(amqp_table_entry_t));
   if (entries == NULL) {
-    return -ERROR_NO_MEMORY;
+    return AMQP_STATUS_NO_MEMORY;
   }
 
   limit = *offset + tablesize;
   while (*offset < limit) {
     uint8_t keylen;
 
-    res = -ERROR_BAD_AMQP_DATA;
+    res = AMQP_STATUS_BAD_AMQP_DATA;
     if (!amqp_decode_8(encoded, offset, &keylen)) {
       goto out;
     }
@@ -153,7 +153,7 @@ int amqp_decode_table(amqp_bytes_t encoded,
       void *newentries;
       allocated_entries = allocated_entries * 2;
       newentries = realloc(entries, allocated_entries * sizeof(amqp_table_entry_t));
-      res = -ERROR_NO_MEMORY;
+      res = AMQP_STATUS_NO_MEMORY;
       if (newentries == NULL) {
         goto out;
       }
@@ -161,7 +161,7 @@ int amqp_decode_table(amqp_bytes_t encoded,
       entries = newentries;
     }
 
-    res = -ERROR_BAD_AMQP_DATA;
+    res = AMQP_STATUS_BAD_AMQP_DATA;
     if (!amqp_decode_bytes(encoded, offset, &entries[num_entries].key, keylen)) {
       goto out;
     }
@@ -177,14 +177,14 @@ int amqp_decode_table(amqp_bytes_t encoded,
 
   output->num_entries = num_entries;
   output->entries = amqp_pool_alloc(pool, num_entries * sizeof(amqp_table_entry_t));
-  res = -ERROR_NO_MEMORY;
+  res = AMQP_STATUS_NO_MEMORY;
   /* NULL is legitimate if we requested a zero-length block. */
   if (output->entries == NULL && num_entries > 0) {
     goto out;
   }
 
   memcpy(output->entries, entries, num_entries * sizeof(amqp_table_entry_t));
-  res = 0;
+  res = AMQP_STATUS_OK;
 
 out:
   free(entries);
@@ -196,7 +196,7 @@ static int amqp_decode_field_value(amqp_bytes_t encoded,
                                    amqp_field_value_t *entry,
                                    size_t *offset)
 {
-  int res = -ERROR_BAD_AMQP_DATA;
+  int res = AMQP_STATUS_BAD_AMQP_DATA;
 
   if (!amqp_decode_8(encoded, offset, &entry->kind)) {
     goto out;
@@ -275,7 +275,7 @@ static int amqp_decode_field_value(amqp_bytes_t encoded,
     goto out;
   }
 
-  res = 0;
+  res = AMQP_STATUS_OK;
 
 out:
   return res;
@@ -300,9 +300,9 @@ static int amqp_encode_array(amqp_bytes_t encoded,
   }
 
   if (amqp_encode_32(encoded, &start, *offset - start - 4)) {
-    res = 0;
+    res = AMQP_STATUS_OK;
   } else {
-    res = -ERROR_BAD_AMQP_DATA;
+    res = AMQP_STATUS_BAD_AMQP_DATA;
   }
 
 out:
@@ -336,9 +336,9 @@ int amqp_encode_table(amqp_bytes_t encoded,
   }
 
   if (amqp_encode_32(encoded, &start, *offset - start - 4)) {
-    res = 0;
+    res = AMQP_STATUS_OK;
   } else {
-    res = -ERROR_BAD_AMQP_DATA;
+    res = AMQP_STATUS_BAD_AMQP_DATA;
   }
 
 out:
@@ -349,7 +349,7 @@ static int amqp_encode_field_value(amqp_bytes_t encoded,
                                    amqp_field_value_t *entry,
                                    size_t *offset)
 {
-  int res = -ERROR_BAD_AMQP_DATA;
+  int res = AMQP_STATUS_BAD_AMQP_DATA;
 
   if (!amqp_encode_8(encoded, offset, entry->kind)) {
     goto out;
@@ -425,7 +425,7 @@ static int amqp_encode_field_value(amqp_bytes_t encoded,
     abort();
   }
 
-  res = 0;
+  res = AMQP_STATUS_OK;
 
 out:
   return res;
diff --git a/librabbitmq/amqp_tcp_socket.c b/librabbitmq/amqp_tcp_socket.c
index 2eb366f..1a155bb 100644
--- a/librabbitmq/amqp_tcp_socket.c
+++ b/librabbitmq/amqp_tcp_socket.c
@@ -76,7 +76,12 @@ amqp_tcp_socket_close(void *base)
     status = amqp_os_socket_close(self->sockfd);
     free(self);
   }
-  return status;
+
+  if (0 == status) {
+    return AMQP_STATUS_OK;
+  } else {
+    return AMQP_STATUS_SOCKET_ERROR;
+  }
 }
 
 static int
diff --git a/librabbitmq/amqp_url.c b/librabbitmq/amqp_url.c
index b200adc..602b554 100644
--- a/librabbitmq/amqp_url.c
+++ b/librabbitmq/amqp_url.c
@@ -110,7 +110,7 @@ static char find_delim(char **pp, int colon_and_at_sign_are_delims)
 /* Parse an AMQP URL into its component parts. */
 int amqp_parse_url(char *url, struct amqp_connection_info *parsed)
 {
-  int res = -ERROR_BAD_AMQP_URL;
+  int res = AMQP_STATUS_BAD_URL;
   char delim;
   char *start;
   char *host;
@@ -205,13 +205,13 @@ int amqp_parse_url(char *url, struct amqp_connection_info *parsed)
     }
 
     parsed->vhost = start;
-    res = 0;
+    res = AMQP_STATUS_OK;
   } else if (delim == 0) {
-    res = 0;
+    res = AMQP_STATUS_OK;
   }
 
   /* Any other delimiter is bad, and we will return
-     ERROR_BAD_AMQP_URL. */
+     AMQP_STATUS_BAD_AMQP_URL. */
 
 out:
   return res;
diff --git a/librabbitmq/codegen.py b/librabbitmq/codegen.py
index fedc0fb..7cdf5e2 100644
--- a/librabbitmq/codegen.py
+++ b/librabbitmq/codegen.py
@@ -71,7 +71,7 @@ class BitDecoder(object):
         """Generate code to decode a value of the AMQP bit type into
         the given lvalue."""
         if self.bit == 0:
-            self.emitter.emit("if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return -ERROR_BAD_AMQP_DATA;")
+            self.emitter.emit("if (!amqp_decode_8(encoded, &offset, &bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;")
 
         self.emitter.emit("%s = (bit_buffer & (1 << %d)) ? 1 : 0;"
                                                         % (lvalue, self.bit))
@@ -91,7 +91,7 @@ class BitEncoder(object):
     def flush(self):
         """Flush the state associated with AMQP bit types."""
         if self.bit:
-            self.emitter.emit("if (!amqp_encode_8(encoded, &offset, bit_buffer)) return -ERROR_BAD_AMQP_DATA;")
+            self.emitter.emit("if (!amqp_encode_8(encoded, &offset, bit_buffer)) return AMQP_STATUS_BAD_AMQP_DATA;")
             self.bit = 0
 
     def emit(self, line):
@@ -120,10 +120,10 @@ class SimpleType(object):
         self.ctype = "uint%d_t" % (bits,)
 
     def decode(self, emitter, lvalue):
-        emitter.emit("if (!amqp_decode_%d(encoded, &offset, &%s)) return -ERROR_BAD_AMQP_DATA;" % (self.bits, lvalue))
+        emitter.emit("if (!amqp_decode_%d(encoded, &offset, &%s)) return AMQP_STATUS_BAD_AMQP_DATA;" % (self.bits, lvalue))
 
     def encode(self, emitter, value):
-        emitter.emit("if (!amqp_encode_%d(encoded, &offset, %s)) return -ERROR_BAD_AMQP_DATA;" % (self.bits, value))
+        emitter.emit("if (!amqp_encode_%d(encoded, &offset, %s)) return AMQP_STATUS_BAD_AMQP_DATA;" % (self.bits, value))
 
     def literal(self, value):
         return value
@@ -140,13 +140,13 @@ class StrType(object):
         emitter.emit("  uint%d_t len;" % (self.lenbits,))
         emitter.emit("  if (!amqp_decode_%d(encoded, &offset, &len)" % (self.lenbits,))
         emitter.emit("      || !amqp_decode_bytes(encoded, &offset, &%s, len))" % (lvalue,))
-        emitter.emit("    return -ERROR_BAD_AMQP_DATA;")
+        emitter.emit("    return AMQP_STATUS_BAD_AMQP_DATA;")
         emitter.emit("}")
 
     def encode(self, emitter, value):
         emitter.emit("if (!amqp_encode_%d(encoded, &offset, %s.len)" % (self.lenbits, value))
         emitter.emit("    || !amqp_encode_bytes(encoded, &offset, %s))" % (value,))
-        emitter.emit("  return -ERROR_BAD_AMQP_DATA;")
+        emitter.emit("  return AMQP_STATUS_BAD_AMQP_DATA;")
 
     def literal(self, value):
         if value != '':
@@ -280,7 +280,7 @@ def genErl(spec):
         if m.arguments:
             print "      %s *m = (%s *) amqp_pool_alloc(pool, sizeof(%s));" % \
                 (m.structName(), m.structName(), m.structName())
-            print "      if (m == NULL) { return -ERROR_NO_MEMORY; }"
+            print "      if (m == NULL) { return AMQP_STATUS_NO_MEMORY; }"
         else:
             print "      %s *m = NULL; /* no fields */" % (m.structName(),)
 
@@ -296,7 +296,7 @@ def genErl(spec):
         print "    case %d: {" % (c.index,)
         print "      %s *p = (%s *) amqp_pool_alloc(pool, sizeof(%s));" % \
               (c.structName(), c.structName(), c.structName())
-        print "      if (p == NULL) { return -ERROR_NO_MEMORY; }"
+        print "      if (p == NULL) { return AMQP_STATUS_NO_MEMORY; }"
         print "      p->_flags = flags;"
 
         emitter = Emitter("      ")
@@ -434,7 +434,7 @@ int amqp_decode_method(amqp_method_number_t methodNumber,
 
   switch (methodNumber) {"""
     for m in methods: genDecodeMethodFields(m)
-    print """    default: return -ERROR_UNKNOWN_METHOD;
+    print """    default: return AMQP_STATUS_UNKNOWN_METHOD;
   }
 }"""
 
@@ -452,14 +452,14 @@ int amqp_decode_properties(uint16_t class_id,
 
   do {
     if (!amqp_decode_16(encoded, &offset, &partial_flags))
-      return -ERROR_BAD_AMQP_DATA;
+      return AMQP_STATUS_BAD_AMQP_DATA;
     flags |= (partial_flags << (flagword_index * 16));
     flagword_index++;
   } while (partial_flags & 1);
 
   switch (class_id) {"""
     for c in spec.allClasses(): genDecodeProperties(c)
-    print """    default: return -ERROR_UNKNOWN_CLASS;
+    print """    default: return AMQP_STATUS_UNKNOWN_CLASS;
   }
 }"""
 
@@ -473,7 +473,7 @@ int amqp_encode_method(amqp_method_number_t methodNumber,
 
   switch (methodNumber) {"""
     for m in methods: genEncodeMethodFields(m)
-    print """    default: return -ERROR_UNKNOWN_METHOD;
+    print """    default: return AMQP_STATUS_UNKNOWN_METHOD;
   }
 }"""
 
@@ -497,14 +497,14 @@ int amqp_encode_properties(uint16_t class_id,
       uint16_t partial_flags = remaining_flags & 0xFFFE;
       if (remainder != 0) { partial_flags |= 1; }
       if (!amqp_encode_16(encoded, &offset, partial_flags))
-        return -ERROR_BAD_AMQP_DATA;
+        return AMQP_STATUS_BAD_AMQP_DATA;
       remaining_flags = remainder;
     } while (remaining_flags != 0);
   }
 
   switch (class_id) {"""
     for c in spec.allClasses(): genEncodeProperties(c)
-    print """    default: return -ERROR_UNKNOWN_CLASS;
+    print """    default: return AMQP_STATUS_UNKNOWN_CLASS;
   }
 }"""
 
diff --git a/librabbitmq/unix/socket.c b/librabbitmq/unix/socket.c
index 4615480..69ec6e5 100644
--- a/librabbitmq/unix/socket.c
+++ b/librabbitmq/unix/socket.c
@@ -50,7 +50,7 @@
 int
 amqp_socket_init(void)
 {
-  return 0;
+  return AMQP_STATUS_OK;
 }
 
 int
@@ -98,5 +98,5 @@ amqp_os_socket_writev(int sockfd, const struct iovec *iov,
 int
 amqp_os_socket_error(void)
 {
-  return errno | ERROR_CATEGORY_OS;
+  return errno;
 }
diff --git a/librabbitmq/win32/socket.c b/librabbitmq/win32/socket.c
index 82051fe..8b44c25 100644
--- a/librabbitmq/win32/socket.c
+++ b/librabbitmq/win32/socket.c
@@ -56,13 +56,13 @@ amqp_socket_init(void)
     WSADATA data;
     int res = WSAStartup(0x0202, &data);
     if (res) {
-      return (ERROR_CATEGORY_OS | res);
+      return AMQP_STATUS_SOCKET_ERROR;
     }
 
     called_wsastartup = 1;
   }
 
-  return 0;
+  return AMQP_STATUS_OK;
 }
 
 char *
@@ -112,5 +112,5 @@ amqp_os_socket_writev(int sock, struct iovec *iov, int nvecs)
 int
 amqp_os_socket_error(void)
 {
-  return WSAGetLastError() | ERROR_CATEGORY_OS;
+  return AMQP_STATUS_SOCKET_ERROR;
 }