debase-ruby_core_source 0.10.2 → 0.10.11

data/lib/debase/ruby_core_source/{ruby-2.5.0-preview1 → ruby-2.6.0-p0}/iseq.h

@@ -2,7 +2,7 @@
 
   iseq.h -
 
-  $Author: mame $
+  $Author: ko1 $
   created at: 04/01/01 23:36:57 JST
 
   Copyright (C) 2004-2008 Koichi Sasada
@@ -12,8 +12,9 @@
 #ifndef RUBY_ISEQ_H
 #define RUBY_ISEQ_H 1
 
-#define ISEQ_MAJOR_VERSION 2
-#define ISEQ_MINOR_VERSION 3
+RUBY_EXTERN const int ruby_api_version[];
+#define ISEQ_MAJOR_VERSION ((unsigned int)ruby_api_version[0])
+#define ISEQ_MINOR_VERSION ((unsigned int)ruby_api_version[1])
 
 #ifndef rb_iseq_t
 typedef struct rb_iseq_struct rb_iseq_t;
@@ -26,58 +27,117 @@ rb_call_info_kw_arg_bytes(int keyword_len)
     return sizeof(struct rb_call_info_kw_arg) + sizeof(VALUE) * (keyword_len - 1);
 }
 
-enum iseq_mark_ary_index {
-    ISEQ_MARK_ARY_COVERAGE,
-    ISEQ_MARK_ARY_FLIP_CNT,
-    ISEQ_MARK_ARY_ORIGINAL_ISEQ,
-    ISEQ_MARK_ARY_INITIAL_SIZE
-};
-
-static inline VALUE
-iseq_mark_ary_create(int flip_cnt)
-{
-    VALUE ary = rb_ary_tmp_new(ISEQ_MARK_ARY_INITIAL_SIZE);
-    rb_ary_push(ary, Qnil);              /* ISEQ_MARK_ARY_COVERAGE */
-    rb_ary_push(ary, INT2FIX(flip_cnt)); /* ISEQ_MARK_ARY_FLIP_CNT */
-    rb_ary_push(ary, Qnil);              /* ISEQ_MARK_ARY_ORIGINAL_ISEQ */
-    return ary;
-}
-
-#define ISEQ_MARK_ARY(iseq)           (iseq)->body->mark_ary
-
-#define ISEQ_COVERAGE(iseq)           RARRAY_AREF(ISEQ_MARK_ARY(iseq), ISEQ_MARK_ARY_COVERAGE)
-#define ISEQ_COVERAGE_SET(iseq, cov)  RARRAY_ASET(ISEQ_MARK_ARY(iseq), ISEQ_MARK_ARY_COVERAGE, cov)
+#define ISEQ_COVERAGE(iseq)           iseq->body->variable.coverage
+#define ISEQ_COVERAGE_SET(iseq, cov)  RB_OBJ_WRITE(iseq, &iseq->body->variable.coverage, cov)
 #define ISEQ_LINE_COVERAGE(iseq)      RARRAY_AREF(ISEQ_COVERAGE(iseq), COVERAGE_INDEX_LINES)
 #define ISEQ_BRANCH_COVERAGE(iseq)    RARRAY_AREF(ISEQ_COVERAGE(iseq), COVERAGE_INDEX_BRANCHES)
-#define ISEQ_METHOD_COVERAGE(iseq)    RARRAY_AREF(ISEQ_COVERAGE(iseq), COVERAGE_INDEX_METHODS)
 
-#define ISEQ_FLIP_CNT(iseq) FIX2INT(RARRAY_AREF(ISEQ_MARK_ARY(iseq), ISEQ_MARK_ARY_FLIP_CNT))
+#define ISEQ_PC2BRANCHINDEX(iseq)         iseq->body->variable.pc2branchindex
+#define ISEQ_PC2BRANCHINDEX_SET(iseq, h)  RB_OBJ_WRITE(iseq, &iseq->body->variable.pc2branchindex, h)
 
-static inline int
+#define ISEQ_FLIP_CNT(iseq) (iseq)->body->variable.flip_count
+
+static inline rb_snum_t
 ISEQ_FLIP_CNT_INCREMENT(const rb_iseq_t *iseq)
 {
-    int cnt = ISEQ_FLIP_CNT(iseq);
-    RARRAY_ASET(ISEQ_MARK_ARY(iseq), ISEQ_MARK_ARY_FLIP_CNT, INT2FIX(cnt+1));
+    rb_snum_t cnt = iseq->body->variable.flip_count;
+    iseq->body->variable.flip_count += 1;
     return cnt;
 }
 
 static inline VALUE *
 ISEQ_ORIGINAL_ISEQ(const rb_iseq_t *iseq)
 {
-    VALUE str = RARRAY_AREF(ISEQ_MARK_ARY(iseq), ISEQ_MARK_ARY_ORIGINAL_ISEQ);
-    if (RTEST(str)) return (VALUE *)RSTRING_PTR(str);
-    return NULL;
+    return iseq->body->variable.original_iseq;
+}
+
+static inline void
+ISEQ_ORIGINAL_ISEQ_CLEAR(const rb_iseq_t *iseq)
+{
+    void *ptr = iseq->body->variable.original_iseq;
+    iseq->body->variable.original_iseq = NULL;
+    if (ptr) {
+        ruby_xfree(ptr);
+    }
 }
 
 static inline VALUE *
 ISEQ_ORIGINAL_ISEQ_ALLOC(const rb_iseq_t *iseq, long size)
 {
-    VALUE str = rb_str_tmp_new(size * sizeof(VALUE));
-    RARRAY_ASET(ISEQ_MARK_ARY(iseq), ISEQ_MARK_ARY_ORIGINAL_ISEQ, str);
-    return (VALUE *)RSTRING_PTR(str);
+    return iseq->body->variable.original_iseq =
+        ruby_xmalloc2(size, sizeof(VALUE));
+}
+
+#define ISEQ_TRACE_EVENTS (RUBY_EVENT_LINE  | \
+			   RUBY_EVENT_CLASS | \
+			   RUBY_EVENT_END   | \
+			   RUBY_EVENT_CALL  | \
+			   RUBY_EVENT_RETURN| \
+			   RUBY_EVENT_B_CALL| \
+			   RUBY_EVENT_B_RETURN| \
+                           RUBY_EVENT_COVERAGE_LINE| \
+                           RUBY_EVENT_COVERAGE_BRANCH)
+
+#define ISEQ_NOT_LOADED_YET   IMEMO_FL_USER1
+#define ISEQ_USE_COMPILE_DATA IMEMO_FL_USER2
+#define ISEQ_TRANSLATED       IMEMO_FL_USER3
+#define ISEQ_MARKABLE_ISEQ    IMEMO_FL_USER4
+
+#define ISEQ_EXECUTABLE_P(iseq) (FL_TEST_RAW((iseq), ISEQ_NOT_LOADED_YET | ISEQ_USE_COMPILE_DATA) == 0)
+
+struct iseq_compile_data {
+    /* GC is needed */
+    const VALUE err_info;
+    VALUE mark_ary;
+    const VALUE catch_table_ary;	/* Array */
+
+    /* GC is not needed */
+    struct iseq_label_data *start_label;
+    struct iseq_label_data *end_label;
+    struct iseq_label_data *redo_label;
+    const rb_iseq_t *current_block;
+    VALUE ensure_node;
+    VALUE for_iseq;
+    struct iseq_compile_data_ensure_node_stack *ensure_node_stack;
+    struct iseq_compile_data_storage *storage_head;
+    struct iseq_compile_data_storage *storage_current;
+    int loopval_popped;	/* used by NODE_BREAK */
+    int last_line;
+    int label_no;
+    int node_level;
+    unsigned int ci_index;
+    unsigned int ci_kw_index;
+    const rb_compile_option_t *option;
+    struct rb_id_table *ivar_cache_table;
+#if SUPPORT_JOKE
+    st_table *labels_table;
+#endif
+};
+
+static inline struct iseq_compile_data *
+ISEQ_COMPILE_DATA(const rb_iseq_t *iseq)
+{
+    if (iseq->flags & ISEQ_USE_COMPILE_DATA) {
+	return iseq->aux.compile_data;
+    }
+    else {
+	return NULL;
+    }
 }
 
-#define ISEQ_COMPILE_DATA(iseq)       (iseq)->aux.compile_data
+static inline void
+ISEQ_COMPILE_DATA_ALLOC(rb_iseq_t *iseq)
+{
+    iseq->aux.compile_data = ZALLOC(struct iseq_compile_data);
+    iseq->flags |= ISEQ_USE_COMPILE_DATA;
+}
+
+static inline void
+ISEQ_COMPILE_DATA_CLEAR(rb_iseq_t *iseq)
+{
+    iseq->flags &= ~ISEQ_USE_COMPILE_DATA;
+    iseq->aux.compile_data = NULL;
+}
 
 static inline rb_iseq_t *
 iseq_imemo_alloc(void)
@@ -85,17 +145,24 @@ iseq_imemo_alloc(void)
     return (rb_iseq_t *)rb_imemo_new(imemo_iseq, 0, 0, 0, 0);
 }
 
-#define ISEQ_NOT_LOADED_YET   IMEMO_FL_USER1
-
-VALUE iseq_ibf_dump(const rb_iseq_t *iseq, VALUE opt);
-void ibf_load_iseq_complete(rb_iseq_t *iseq);
-const rb_iseq_t *iseq_ibf_load(VALUE str);
-VALUE iseq_ibf_load_extra_data(VALUE str);
+VALUE rb_iseq_ibf_dump(const rb_iseq_t *iseq, VALUE opt);
+void rb_ibf_load_iseq_complete(rb_iseq_t *iseq);
+const rb_iseq_t *rb_iseq_ibf_load(VALUE str);
+VALUE rb_iseq_ibf_load_extra_data(VALUE str);
+void rb_iseq_init_trace(rb_iseq_t *iseq);
+int rb_iseq_add_local_tracepoint_recursively(const rb_iseq_t *iseq, rb_event_flag_t turnon_events, VALUE tpval, unsigned int target_line);
+int rb_iseq_remove_local_tracepoint_recursively(const rb_iseq_t *iseq, VALUE tpval);
+const rb_iseq_t *rb_iseq_load_iseq(VALUE fname);
+
+#if VM_INSN_INFO_TABLE_IMPL == 2
+unsigned int *rb_iseq_insns_info_decode_positions(const struct rb_iseq_constant_body *body);
+#endif
 
 RUBY_SYMBOL_EXPORT_BEGIN
 
 /* compile.c */
-VALUE rb_iseq_compile_node(rb_iseq_t *iseq, NODE *node);
+VALUE rb_iseq_compile_node(rb_iseq_t *iseq, const NODE *node);
+VALUE rb_iseq_compile_ifunc(rb_iseq_t *iseq, const struct vm_ifunc *ifunc);
 int rb_iseq_translate_threaded_code(rb_iseq_t *iseq);
 VALUE *rb_iseq_original_iseq(const rb_iseq_t *iseq);
 void rb_iseq_build_from_ary(rb_iseq_t *iseq, VALUE misc,
@@ -103,15 +170,15 @@ void rb_iseq_build_from_ary(rb_iseq_t *iseq, VALUE misc,
 			    VALUE exception, VALUE body);
 
 /* iseq.c */
-void rb_iseq_add_mark_object(const rb_iseq_t *iseq, VALUE obj);
 VALUE rb_iseq_load(VALUE data, VALUE parent, VALUE opt);
 VALUE rb_iseq_parameters(const rb_iseq_t *iseq, int is_proc);
 struct st_table *ruby_insn_make_insn_table(void);
 unsigned int rb_iseq_line_no(const rb_iseq_t *iseq, size_t pos);
+void rb_iseq_trace_set(const rb_iseq_t *iseq, rb_event_flag_t turnon_events);
+void rb_iseq_trace_set_all(rb_event_flag_t turnon_events);
+void rb_iseq_trace_on_all(void);
+void rb_iseq_insns_info_encode_positions(const rb_iseq_t *iseq);
 
-int rb_iseqw_line_trace_each(VALUE iseqval, int (*func)(int line, rb_event_flag_t *events_ptr, void *d), void *data);
-VALUE rb_iseqw_line_trace_all(VALUE iseqval);
-VALUE rb_iseqw_line_trace_specify(VALUE iseqval, VALUE pos, VALUE set);
 VALUE rb_iseqw_new(const rb_iseq_t *iseq);
 const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
 
@@ -120,6 +187,9 @@ VALUE rb_iseq_label(const rb_iseq_t *iseq);
 VALUE rb_iseq_base_label(const rb_iseq_t *iseq);
 VALUE rb_iseq_first_lineno(const rb_iseq_t *iseq);
 VALUE rb_iseq_method_name(const rb_iseq_t *iseq);
+void rb_iseq_code_location(const rb_iseq_t *iseq, int *first_lineno, int *first_column, int *last_lineno, int *last_column);
+
+void rb_iseq_remove_coverage_all(void);
 
 /* proc.c */
 const rb_iseq_t *rb_method_iseq(VALUE body);
@@ -133,16 +203,15 @@ struct rb_compile_option_struct {
     unsigned int operands_unification: 1;
     unsigned int instructions_unification: 1;
     unsigned int stack_caching: 1;
-    unsigned int trace_instruction: 1;
     unsigned int frozen_string_literal: 1;
     unsigned int debug_frozen_string_literal: 1;
     unsigned int coverage_enabled: 1;
     int debug_level;
 };
 
-struct iseq_line_info_entry {
-    unsigned int position;
-    unsigned int line_no;
+struct iseq_insn_info_entry {
+    int line_no;
+    rb_event_flag_t events;
 };
 
 struct iseq_catch_table_entry {
@@ -177,18 +246,19 @@ struct iseq_catch_table_entry {
 
 PACKED_STRUCT_UNALIGNED(struct iseq_catch_table {
     unsigned int size;
-    struct iseq_catch_table_entry entries[1]; /* flexible array */
+    struct iseq_catch_table_entry entries[FLEX_ARY_LEN];
 });
 
 static inline int
 iseq_catch_table_bytes(int n)
 {
     enum {
-	catch_table_entries_max = (INT_MAX - sizeof(struct iseq_catch_table)) / sizeof(struct iseq_catch_table_entry)
+	catch_table_entry_size = sizeof(struct iseq_catch_table_entry),
+	catch_table_entries_max = (INT_MAX - offsetof(struct iseq_catch_table, entries)) / catch_table_entry_size
     };
     if (n > catch_table_entries_max) rb_fatal("too large iseq_catch_table - %d", n);
-    return (int)(sizeof(struct iseq_catch_table) +
-		 (n - 1) * sizeof(struct iseq_catch_table_entry));
+    return (int)(offsetof(struct iseq_catch_table, entries) +
+		 n * catch_table_entry_size);
 }
 
 #define INITIAL_ISEQ_COMPILE_DATA_STORAGE_BUFF_SIZE (512)
@@ -197,47 +267,13 @@ struct iseq_compile_data_storage {
     struct iseq_compile_data_storage *next;
     unsigned int pos;
     unsigned int size;
-    char buff[1]; /* flexible array */
-};
-
-/* account for flexible array */
-#define SIZEOF_ISEQ_COMPILE_DATA_STORAGE \
-    (sizeof(struct iseq_compile_data_storage) - 1)
-
-struct iseq_compile_data {
-    /* GC is needed */
-    const VALUE err_info;
-    VALUE mark_ary;
-    const VALUE catch_table_ary;	/* Array */
-
-    /* GC is not needed */
-    struct iseq_label_data *start_label;
-    struct iseq_label_data *end_label;
-    struct iseq_label_data *redo_label;
-    const rb_iseq_t *current_block;
-    VALUE ensure_node;
-    VALUE for_iseq;
-    struct iseq_compile_data_ensure_node_stack *ensure_node_stack;
-    int loopval_popped;	/* used by NODE_BREAK */
-    int cached_const;
-    struct iseq_compile_data_storage *storage_head;
-    struct iseq_compile_data_storage *storage_current;
-    int last_line;
-    int last_coverable_line;
-    int label_no;
-    int node_level;
-    unsigned int ci_index;
-    unsigned int ci_kw_index;
-    const rb_compile_option_t *option;
-    struct rb_id_table *ivar_cache_table;
-#if SUPPORT_JOKE
-    st_table *labels_table;
-#endif
+    char buff[FLEX_ARY_LEN];
 };
 
 /* defined? */
 
 enum defined_type {
+    DEFINED_NOT_DEFINED,
     DEFINED_NIL = 1,
     DEFINED_IVAR,
     DEFINED_LVAR,

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.6.0-p0}/known_errors.inc

@@ -4,743 +4,788 @@
  * template/known_errors.inc.tmpl and defs/known_errors.def.
  */
 
-#ifdef EPERM
-        defined_error("EPERM", EPERM)
+#ifdef E2BIG
+        defined_error("E2BIG", E2BIG)
 #else
-        undefined_error("EPERM")
+        undefined_error("E2BIG")
 #endif
-#ifdef ENOENT
-        defined_error("ENOENT", ENOENT)
+#ifdef EACCES
+        defined_error("EACCES", EACCES)
 #else
-        undefined_error("ENOENT")
+        undefined_error("EACCES")
 #endif
-#ifdef ESRCH
-        defined_error("ESRCH", ESRCH)
+#ifdef EADDRINUSE
+        defined_error("EADDRINUSE", EADDRINUSE)
 #else
-        undefined_error("ESRCH")
+        undefined_error("EADDRINUSE")
 #endif
-#ifdef EINTR
-        defined_error("EINTR", EINTR)
+#ifdef EADDRNOTAVAIL
+        defined_error("EADDRNOTAVAIL", EADDRNOTAVAIL)
 #else
-        undefined_error("EINTR")
+        undefined_error("EADDRNOTAVAIL")
 #endif
-#ifdef EIO
-        defined_error("EIO", EIO)
+#ifdef EADV
+        defined_error("EADV", EADV)
 #else
-        undefined_error("EIO")
+        undefined_error("EADV")
 #endif
-#ifdef ENXIO
-        defined_error("ENXIO", ENXIO)
+#ifdef EAFNOSUPPORT
+        defined_error("EAFNOSUPPORT", EAFNOSUPPORT)
 #else
-        undefined_error("ENXIO")
+        undefined_error("EAFNOSUPPORT")
 #endif
-#ifdef E2BIG
-        defined_error("E2BIG", E2BIG)
+#ifdef EAGAIN
+        defined_error("EAGAIN", EAGAIN)
 #else
-        undefined_error("E2BIG")
+        undefined_error("EAGAIN")
 #endif
-#ifdef ENOEXEC
-        defined_error("ENOEXEC", ENOEXEC)
+#ifdef EALREADY
+        defined_error("EALREADY", EALREADY)
 #else
-        undefined_error("ENOEXEC")
+        undefined_error("EALREADY")
 #endif
-#ifdef EBADF
-        defined_error("EBADF", EBADF)
+#ifdef EAUTH
+        defined_error("EAUTH", EAUTH)
 #else
-        undefined_error("EBADF")
+        undefined_error("EAUTH")
 #endif
-#ifdef ECHILD
-        defined_error("ECHILD", ECHILD)
+#ifdef EBADARCH
+        defined_error("EBADARCH", EBADARCH)
 #else
-        undefined_error("ECHILD")
+        undefined_error("EBADARCH")
 #endif
-#ifdef EAGAIN
-        defined_error("EAGAIN", EAGAIN)
+#ifdef EBADE
+        defined_error("EBADE", EBADE)
 #else
-        undefined_error("EAGAIN")
+        undefined_error("EBADE")
 #endif
-#ifdef ENOMEM
-        defined_error("ENOMEM", ENOMEM)
+#ifdef EBADEXEC
+        defined_error("EBADEXEC", EBADEXEC)
 #else
-        undefined_error("ENOMEM")
+        undefined_error("EBADEXEC")
 #endif
-#ifdef EACCES
-        defined_error("EACCES", EACCES)
+#ifdef EBADF
+        defined_error("EBADF", EBADF)
 #else
-        undefined_error("EACCES")
+        undefined_error("EBADF")
 #endif
-#ifdef EFAULT
-        defined_error("EFAULT", EFAULT)
+#ifdef EBADFD
+        defined_error("EBADFD", EBADFD)
 #else
-        undefined_error("EFAULT")
+        undefined_error("EBADFD")
 #endif
-#ifdef ENOTBLK
-        defined_error("ENOTBLK", ENOTBLK)
+#ifdef EBADMACHO
+        defined_error("EBADMACHO", EBADMACHO)
 #else
-        undefined_error("ENOTBLK")
+        undefined_error("EBADMACHO")
 #endif
-#ifdef EBUSY
-        defined_error("EBUSY", EBUSY)
+#ifdef EBADMSG
+        defined_error("EBADMSG", EBADMSG)
 #else
-        undefined_error("EBUSY")
+        undefined_error("EBADMSG")
 #endif
-#ifdef EEXIST
-        defined_error("EEXIST", EEXIST)
+#ifdef EBADR
+        defined_error("EBADR", EBADR)
 #else
-        undefined_error("EEXIST")
+        undefined_error("EBADR")
 #endif
-#ifdef EXDEV
-        defined_error("EXDEV", EXDEV)
+#ifdef EBADRPC
+        defined_error("EBADRPC", EBADRPC)
 #else
-        undefined_error("EXDEV")
+        undefined_error("EBADRPC")
 #endif
-#ifdef ENODEV
-        defined_error("ENODEV", ENODEV)
+#ifdef EBADRQC
+        defined_error("EBADRQC", EBADRQC)
 #else
-        undefined_error("ENODEV")
+        undefined_error("EBADRQC")
 #endif
-#ifdef ENOTDIR
-        defined_error("ENOTDIR", ENOTDIR)
+#ifdef EBADSLT
+        defined_error("EBADSLT", EBADSLT)
 #else
-        undefined_error("ENOTDIR")
+        undefined_error("EBADSLT")
 #endif
-#ifdef EISDIR
-        defined_error("EISDIR", EISDIR)
+#ifdef EBFONT
+        defined_error("EBFONT", EBFONT)
 #else
-        undefined_error("EISDIR")
+        undefined_error("EBFONT")
 #endif
-#ifdef EINVAL
-        defined_error("EINVAL", EINVAL)
+#ifdef EBUSY
+        defined_error("EBUSY", EBUSY)
 #else
-        undefined_error("EINVAL")
+        undefined_error("EBUSY")
 #endif
-#ifdef ENFILE
-        defined_error("ENFILE", ENFILE)
+#ifdef ECANCELED
+        defined_error("ECANCELED", ECANCELED)
 #else
-        undefined_error("ENFILE")
+        undefined_error("ECANCELED")
 #endif
-#ifdef EMFILE
-        defined_error("EMFILE", EMFILE)
+#ifdef ECAPMODE
+        defined_error("ECAPMODE", ECAPMODE)
 #else
-        undefined_error("EMFILE")
+        undefined_error("ECAPMODE")
 #endif
-#ifdef ENOTTY
-        defined_error("ENOTTY", ENOTTY)
+#ifdef ECHILD
+        defined_error("ECHILD", ECHILD)
 #else
-        undefined_error("ENOTTY")
+        undefined_error("ECHILD")
 #endif
-#ifdef ETXTBSY
-        defined_error("ETXTBSY", ETXTBSY)
+#ifdef ECHRNG
+        defined_error("ECHRNG", ECHRNG)
 #else
-        undefined_error("ETXTBSY")
+        undefined_error("ECHRNG")
 #endif
-#ifdef EFBIG
-        defined_error("EFBIG", EFBIG)
+#ifdef ECOMM
+        defined_error("ECOMM", ECOMM)
 #else
-        undefined_error("EFBIG")
+        undefined_error("ECOMM")
 #endif
-#ifdef ENOSPC
-        defined_error("ENOSPC", ENOSPC)
+#ifdef ECONNABORTED
+        defined_error("ECONNABORTED", ECONNABORTED)
 #else
-        undefined_error("ENOSPC")
+        undefined_error("ECONNABORTED")
 #endif
-#ifdef ESPIPE
-        defined_error("ESPIPE", ESPIPE)
+#ifdef ECONNREFUSED
+        defined_error("ECONNREFUSED", ECONNREFUSED)
 #else
-        undefined_error("ESPIPE")
+        undefined_error("ECONNREFUSED")
 #endif
-#ifdef EROFS
-        defined_error("EROFS", EROFS)
+#ifdef ECONNRESET
+        defined_error("ECONNRESET", ECONNRESET)
 #else
-        undefined_error("EROFS")
+        undefined_error("ECONNRESET")
 #endif
-#ifdef EMLINK
-        defined_error("EMLINK", EMLINK)
+#ifdef EDEADLK
+        defined_error("EDEADLK", EDEADLK)
 #else
-        undefined_error("EMLINK")
+        undefined_error("EDEADLK")
 #endif
-#ifdef EPIPE
-        defined_error("EPIPE", EPIPE)
+#ifdef EDEADLOCK
+        defined_error("EDEADLOCK", EDEADLOCK)
 #else
-        undefined_error("EPIPE")
+        undefined_error("EDEADLOCK")
+#endif
+#ifdef EDESTADDRREQ
+        defined_error("EDESTADDRREQ", EDESTADDRREQ)
+#else
+        undefined_error("EDESTADDRREQ")
+#endif
+#ifdef EDEVERR
+        defined_error("EDEVERR", EDEVERR)
+#else
+        undefined_error("EDEVERR")
 #endif
 #ifdef EDOM
         defined_error("EDOM", EDOM)
 #else
         undefined_error("EDOM")
 #endif
-#ifdef ERANGE
-        defined_error("ERANGE", ERANGE)
+#ifdef EDOOFUS
+        defined_error("EDOOFUS", EDOOFUS)
 #else
-        undefined_error("ERANGE")
+        undefined_error("EDOOFUS")
 #endif
-#ifdef EDEADLK
-        defined_error("EDEADLK", EDEADLK)
+#ifdef EDOTDOT
+        defined_error("EDOTDOT", EDOTDOT)
 #else
-        undefined_error("EDEADLK")
+        undefined_error("EDOTDOT")
 #endif
-#ifdef ENAMETOOLONG
-        defined_error("ENAMETOOLONG", ENAMETOOLONG)
+#ifdef EDQUOT
+        defined_error("EDQUOT", EDQUOT)
 #else
-        undefined_error("ENAMETOOLONG")
+        undefined_error("EDQUOT")
 #endif
-#ifdef ENOLCK
-        defined_error("ENOLCK", ENOLCK)
+#ifdef EEXIST
+        defined_error("EEXIST", EEXIST)
 #else
-        undefined_error("ENOLCK")
+        undefined_error("EEXIST")
 #endif
-#ifdef ENOSYS
-        defined_error("ENOSYS", ENOSYS)
+#ifdef EFAULT
+        defined_error("EFAULT", EFAULT)
 #else
-        undefined_error("ENOSYS")
+        undefined_error("EFAULT")
 #endif
-#ifdef ENOTEMPTY
-        defined_error("ENOTEMPTY", ENOTEMPTY)
+#ifdef EFBIG
+        defined_error("EFBIG", EFBIG)
 #else
-        undefined_error("ENOTEMPTY")
+        undefined_error("EFBIG")
 #endif
-#ifdef ELOOP
-        defined_error("ELOOP", ELOOP)
+#ifdef EFTYPE
+        defined_error("EFTYPE", EFTYPE)
 #else
-        undefined_error("ELOOP")
+        undefined_error("EFTYPE")
 #endif
-#ifdef EWOULDBLOCK
-        defined_error("EWOULDBLOCK", EWOULDBLOCK)
+#ifdef EHOSTDOWN
+        defined_error("EHOSTDOWN", EHOSTDOWN)
 #else
-        undefined_error("EWOULDBLOCK")
+        undefined_error("EHOSTDOWN")
 #endif
-#ifdef ENOMSG
-        defined_error("ENOMSG", ENOMSG)
+#ifdef EHOSTUNREACH
+        defined_error("EHOSTUNREACH", EHOSTUNREACH)
 #else
-        undefined_error("ENOMSG")
+        undefined_error("EHOSTUNREACH")
+#endif
+#ifdef EHWPOISON
+        defined_error("EHWPOISON", EHWPOISON)
+#else
+        undefined_error("EHWPOISON")
 #endif
 #ifdef EIDRM
         defined_error("EIDRM", EIDRM)
 #else
         undefined_error("EIDRM")
 #endif
-#ifdef ECHRNG
-        defined_error("ECHRNG", ECHRNG)
+#ifdef EILSEQ
+        defined_error("EILSEQ", EILSEQ)
 #else
-        undefined_error("ECHRNG")
+        undefined_error("EILSEQ")
 #endif
-#ifdef EL2NSYNC
-        defined_error("EL2NSYNC", EL2NSYNC)
+#ifdef EINPROGRESS
+        defined_error("EINPROGRESS", EINPROGRESS)
 #else
-        undefined_error("EL2NSYNC")
+        undefined_error("EINPROGRESS")
 #endif
-#ifdef EL3HLT
-        defined_error("EL3HLT", EL3HLT)
+#ifdef EINTR
+        defined_error("EINTR", EINTR)
 #else
-        undefined_error("EL3HLT")
+        undefined_error("EINTR")
 #endif
-#ifdef EL3RST
-        defined_error("EL3RST", EL3RST)
+#ifdef EINVAL
+        defined_error("EINVAL", EINVAL)
 #else
-        undefined_error("EL3RST")
+        undefined_error("EINVAL")
 #endif
-#ifdef ELNRNG
-        defined_error("ELNRNG", ELNRNG)
+#ifdef EIO
+        defined_error("EIO", EIO)
 #else
-        undefined_error("ELNRNG")
+        undefined_error("EIO")
 #endif
-#ifdef EUNATCH
-        defined_error("EUNATCH", EUNATCH)
+#ifdef EIPSEC
+        defined_error("EIPSEC", EIPSEC)
 #else
-        undefined_error("EUNATCH")
+        undefined_error("EIPSEC")
 #endif
-#ifdef ENOCSI
-        defined_error("ENOCSI", ENOCSI)
+#ifdef EISCONN
+        defined_error("EISCONN", EISCONN)
 #else
-        undefined_error("ENOCSI")
+        undefined_error("EISCONN")
 #endif
-#ifdef EL2HLT
-        defined_error("EL2HLT", EL2HLT)
+#ifdef EISDIR
+        defined_error("EISDIR", EISDIR)
 #else
-        undefined_error("EL2HLT")
+        undefined_error("EISDIR")
 #endif
-#ifdef EBADE
-        defined_error("EBADE", EBADE)
+#ifdef EISNAM
+        defined_error("EISNAM", EISNAM)
 #else
-        undefined_error("EBADE")
+        undefined_error("EISNAM")
 #endif
-#ifdef EBADR
-        defined_error("EBADR", EBADR)
+#ifdef EKEYEXPIRED
+        defined_error("EKEYEXPIRED", EKEYEXPIRED)
 #else
-        undefined_error("EBADR")
+        undefined_error("EKEYEXPIRED")
 #endif
-#ifdef EXFULL
-        defined_error("EXFULL", EXFULL)
+#ifdef EKEYREJECTED
+        defined_error("EKEYREJECTED", EKEYREJECTED)
 #else
-        undefined_error("EXFULL")
+        undefined_error("EKEYREJECTED")
 #endif
-#ifdef ENOANO
-        defined_error("ENOANO", ENOANO)
+#ifdef EKEYREVOKED
+        defined_error("EKEYREVOKED", EKEYREVOKED)
 #else
-        undefined_error("ENOANO")
+        undefined_error("EKEYREVOKED")
 #endif
-#ifdef EBADRQC
-        defined_error("EBADRQC", EBADRQC)
+#ifdef EL2HLT
+        defined_error("EL2HLT", EL2HLT)
 #else
-        undefined_error("EBADRQC")
+        undefined_error("EL2HLT")
 #endif
-#ifdef EBADSLT
-        defined_error("EBADSLT", EBADSLT)
+#ifdef EL2NSYNC
+        defined_error("EL2NSYNC", EL2NSYNC)
 #else
-        undefined_error("EBADSLT")
+        undefined_error("EL2NSYNC")
 #endif
-#ifdef EDEADLOCK
-        defined_error("EDEADLOCK", EDEADLOCK)
+#ifdef EL3HLT
+        defined_error("EL3HLT", EL3HLT)
 #else
-        undefined_error("EDEADLOCK")
+        undefined_error("EL3HLT")
 #endif
-#ifdef EBFONT
-        defined_error("EBFONT", EBFONT)
+#ifdef EL3RST
+        defined_error("EL3RST", EL3RST)
 #else
-        undefined_error("EBFONT")
+        undefined_error("EL3RST")
 #endif
-#ifdef ENOSTR
-        defined_error("ENOSTR", ENOSTR)
+#ifdef ELAST
+        defined_error("ELAST", ELAST)
 #else
-        undefined_error("ENOSTR")
+        undefined_error("ELAST")
 #endif
-#ifdef ENODATA
-        defined_error("ENODATA", ENODATA)
+#ifdef ELIBACC
+        defined_error("ELIBACC", ELIBACC)
 #else
-        undefined_error("ENODATA")
+        undefined_error("ELIBACC")
 #endif
-#ifdef ETIME
-        defined_error("ETIME", ETIME)
+#ifdef ELIBBAD
+        defined_error("ELIBBAD", ELIBBAD)
 #else
-        undefined_error("ETIME")
+        undefined_error("ELIBBAD")
 #endif
-#ifdef ENOSR
-        defined_error("ENOSR", ENOSR)
+#ifdef ELIBEXEC
+        defined_error("ELIBEXEC", ELIBEXEC)
 #else
-        undefined_error("ENOSR")
+        undefined_error("ELIBEXEC")
 #endif
-#ifdef ENONET
-        defined_error("ENONET", ENONET)
+#ifdef ELIBMAX
+        defined_error("ELIBMAX", ELIBMAX)
 #else
-        undefined_error("ENONET")
+        undefined_error("ELIBMAX")
 #endif
-#ifdef ENOPKG
-        defined_error("ENOPKG", ENOPKG)
+#ifdef ELIBSCN
+        defined_error("ELIBSCN", ELIBSCN)
 #else
-        undefined_error("ENOPKG")
+        undefined_error("ELIBSCN")
 #endif
-#ifdef EREMOTE
-        defined_error("EREMOTE", EREMOTE)
+#ifdef ELNRNG
+        defined_error("ELNRNG", ELNRNG)
 #else
-        undefined_error("EREMOTE")
+        undefined_error("ELNRNG")
 #endif
-#ifdef ENOLINK
-        defined_error("ENOLINK", ENOLINK)
+#ifdef ELOOP
+        defined_error("ELOOP", ELOOP)
 #else
-        undefined_error("ENOLINK")
+        undefined_error("ELOOP")
 #endif
-#ifdef EADV
-        defined_error("EADV", EADV)
+#ifdef EMEDIUMTYPE
+        defined_error("EMEDIUMTYPE", EMEDIUMTYPE)
 #else
-        undefined_error("EADV")
+        undefined_error("EMEDIUMTYPE")
 #endif
-#ifdef ESRMNT
-        defined_error("ESRMNT", ESRMNT)
+#ifdef EMFILE
+        defined_error("EMFILE", EMFILE)
 #else
-        undefined_error("ESRMNT")
+        undefined_error("EMFILE")
 #endif
-#ifdef ECOMM
-        defined_error("ECOMM", ECOMM)
+#ifdef EMLINK
+        defined_error("EMLINK", EMLINK)
 #else
-        undefined_error("ECOMM")
+        undefined_error("EMLINK")
 #endif
-#ifdef EPROTO
-        defined_error("EPROTO", EPROTO)
+#ifdef EMSGSIZE
+        defined_error("EMSGSIZE", EMSGSIZE)
 #else
-        undefined_error("EPROTO")
+        undefined_error("EMSGSIZE")
 #endif
 #ifdef EMULTIHOP
         defined_error("EMULTIHOP", EMULTIHOP)
 #else
         undefined_error("EMULTIHOP")
 #endif
-#ifdef EDOTDOT
-        defined_error("EDOTDOT", EDOTDOT)
+#ifdef ENAMETOOLONG
+        defined_error("ENAMETOOLONG", ENAMETOOLONG)
 #else
-        undefined_error("EDOTDOT")
+        undefined_error("ENAMETOOLONG")
 #endif
-#ifdef EBADMSG
-        defined_error("EBADMSG", EBADMSG)
+#ifdef ENAVAIL
+        defined_error("ENAVAIL", ENAVAIL)
 #else
-        undefined_error("EBADMSG")
+        undefined_error("ENAVAIL")
 #endif
-#ifdef EOVERFLOW
-        defined_error("EOVERFLOW", EOVERFLOW)
+#ifdef ENEEDAUTH
+        defined_error("ENEEDAUTH", ENEEDAUTH)
 #else
-        undefined_error("EOVERFLOW")
+        undefined_error("ENEEDAUTH")
 #endif
-#ifdef ENOTUNIQ
-        defined_error("ENOTUNIQ", ENOTUNIQ)
+#ifdef ENETDOWN
+        defined_error("ENETDOWN", ENETDOWN)
 #else
-        undefined_error("ENOTUNIQ")
+        undefined_error("ENETDOWN")
 #endif
-#ifdef EBADFD
-        defined_error("EBADFD", EBADFD)
+#ifdef ENETRESET
+        defined_error("ENETRESET", ENETRESET)
 #else
-        undefined_error("EBADFD")
+        undefined_error("ENETRESET")
 #endif
-#ifdef EREMCHG
-        defined_error("EREMCHG", EREMCHG)
+#ifdef ENETUNREACH
+        defined_error("ENETUNREACH", ENETUNREACH)
 #else
-        undefined_error("EREMCHG")
+        undefined_error("ENETUNREACH")
 #endif
-#ifdef ELIBACC
-        defined_error("ELIBACC", ELIBACC)
+#ifdef ENFILE
+        defined_error("ENFILE", ENFILE)
 #else
-        undefined_error("ELIBACC")
+        undefined_error("ENFILE")
 #endif
-#ifdef ELIBBAD
-        defined_error("ELIBBAD", ELIBBAD)
+#ifdef ENOANO
+        defined_error("ENOANO", ENOANO)
 #else
-        undefined_error("ELIBBAD")
+        undefined_error("ENOANO")
 #endif
-#ifdef ELIBSCN
-        defined_error("ELIBSCN", ELIBSCN)
+#ifdef ENOATTR
+        defined_error("ENOATTR", ENOATTR)
 #else
-        undefined_error("ELIBSCN")
+        undefined_error("ENOATTR")
 #endif
-#ifdef ELIBMAX
-        defined_error("ELIBMAX", ELIBMAX)
+#ifdef ENOBUFS
+        defined_error("ENOBUFS", ENOBUFS)
 #else
-        undefined_error("ELIBMAX")
+        undefined_error("ENOBUFS")
 #endif
-#ifdef ELIBEXEC
-        defined_error("ELIBEXEC", ELIBEXEC)
+#ifdef ENOCSI
+        defined_error("ENOCSI", ENOCSI)
 #else
-        undefined_error("ELIBEXEC")
+        undefined_error("ENOCSI")
 #endif
-#ifdef EILSEQ
-        defined_error("EILSEQ", EILSEQ)
+#ifdef ENODATA
+        defined_error("ENODATA", ENODATA)
 #else
-        undefined_error("EILSEQ")
+        undefined_error("ENODATA")
 #endif
-#ifdef ERESTART
-        defined_error("ERESTART", ERESTART)
+#ifdef ENODEV
+        defined_error("ENODEV", ENODEV)
 #else
-        undefined_error("ERESTART")
+        undefined_error("ENODEV")
 #endif
-#ifdef ESTRPIPE
-        defined_error("ESTRPIPE", ESTRPIPE)
+#ifdef ENOENT
+        defined_error("ENOENT", ENOENT)
 #else
-        undefined_error("ESTRPIPE")
+        undefined_error("ENOENT")
 #endif
-#ifdef EUSERS
-        defined_error("EUSERS", EUSERS)
+#ifdef ENOEXEC
+        defined_error("ENOEXEC", ENOEXEC)
 #else
-        undefined_error("EUSERS")
+        undefined_error("ENOEXEC")
 #endif
-#ifdef ENOTSOCK
-        defined_error("ENOTSOCK", ENOTSOCK)
+#ifdef ENOKEY
+        defined_error("ENOKEY", ENOKEY)
 #else
-        undefined_error("ENOTSOCK")
+        undefined_error("ENOKEY")
 #endif
-#ifdef EDESTADDRREQ
-        defined_error("EDESTADDRREQ", EDESTADDRREQ)
+#ifdef ENOLCK
+        defined_error("ENOLCK", ENOLCK)
 #else
-        undefined_error("EDESTADDRREQ")
+        undefined_error("ENOLCK")
 #endif
-#ifdef EMSGSIZE
-        defined_error("EMSGSIZE", EMSGSIZE)
+#ifdef ENOLINK
+        defined_error("ENOLINK", ENOLINK)
 #else
-        undefined_error("EMSGSIZE")
+        undefined_error("ENOLINK")
 #endif
-#ifdef EPROTOTYPE
-        defined_error("EPROTOTYPE", EPROTOTYPE)
+#ifdef ENOMEDIUM
+        defined_error("ENOMEDIUM", ENOMEDIUM)
 #else
-        undefined_error("EPROTOTYPE")
+        undefined_error("ENOMEDIUM")
 #endif
-#ifdef ENOPROTOOPT
-        defined_error("ENOPROTOOPT", ENOPROTOOPT)
+#ifdef ENOMEM
+        defined_error("ENOMEM", ENOMEM)
 #else
-        undefined_error("ENOPROTOOPT")
+        undefined_error("ENOMEM")
 #endif
-#ifdef EPROTONOSUPPORT
-        defined_error("EPROTONOSUPPORT", EPROTONOSUPPORT)
+#ifdef ENOMSG
+        defined_error("ENOMSG", ENOMSG)
 #else
-        undefined_error("EPROTONOSUPPORT")
+        undefined_error("ENOMSG")
 #endif
-#ifdef ESOCKTNOSUPPORT
-        defined_error("ESOCKTNOSUPPORT", ESOCKTNOSUPPORT)
+#ifdef ENONET
+        defined_error("ENONET", ENONET)
 #else
-        undefined_error("ESOCKTNOSUPPORT")
+        undefined_error("ENONET")
 #endif
-#ifdef EOPNOTSUPP
-        defined_error("EOPNOTSUPP", EOPNOTSUPP)
+#ifdef ENOPKG
+        defined_error("ENOPKG", ENOPKG)
 #else
-        undefined_error("EOPNOTSUPP")
+        undefined_error("ENOPKG")
 #endif
-#ifdef EPFNOSUPPORT
-        defined_error("EPFNOSUPPORT", EPFNOSUPPORT)
+#ifdef ENOPOLICY
+        defined_error("ENOPOLICY", ENOPOLICY)
 #else
-        undefined_error("EPFNOSUPPORT")
+        undefined_error("ENOPOLICY")
 #endif
-#ifdef EAFNOSUPPORT
-        defined_error("EAFNOSUPPORT", EAFNOSUPPORT)
+#ifdef ENOPROTOOPT
+        defined_error("ENOPROTOOPT", ENOPROTOOPT)
 #else
-        undefined_error("EAFNOSUPPORT")
+        undefined_error("ENOPROTOOPT")
 #endif
-#ifdef EADDRINUSE
-        defined_error("EADDRINUSE", EADDRINUSE)
+#ifdef ENOSPC
+        defined_error("ENOSPC", ENOSPC)
 #else
-        undefined_error("EADDRINUSE")
+        undefined_error("ENOSPC")
 #endif
-#ifdef EADDRNOTAVAIL
-        defined_error("EADDRNOTAVAIL", EADDRNOTAVAIL)
+#ifdef ENOSR
+        defined_error("ENOSR", ENOSR)
 #else
-        undefined_error("EADDRNOTAVAIL")
+        undefined_error("ENOSR")
 #endif
-#ifdef ENETDOWN
-        defined_error("ENETDOWN", ENETDOWN)
+#ifdef ENOSTR
+        defined_error("ENOSTR", ENOSTR)
 #else
-        undefined_error("ENETDOWN")
+        undefined_error("ENOSTR")
 #endif
-#ifdef ENETUNREACH
-        defined_error("ENETUNREACH", ENETUNREACH)
+#ifdef ENOSYS
+        defined_error("ENOSYS", ENOSYS)
 #else
-        undefined_error("ENETUNREACH")
+        undefined_error("ENOSYS")
 #endif
-#ifdef ENETRESET
-        defined_error("ENETRESET", ENETRESET)
+#ifdef ENOTBLK
+        defined_error("ENOTBLK", ENOTBLK)
 #else
-        undefined_error("ENETRESET")
+        undefined_error("ENOTBLK")
 #endif
-#ifdef ECONNABORTED
-        defined_error("ECONNABORTED", ECONNABORTED)
+#ifdef ENOTCAPABLE
+        defined_error("ENOTCAPABLE", ENOTCAPABLE)
 #else
-        undefined_error("ECONNABORTED")
+        undefined_error("ENOTCAPABLE")
 #endif
-#ifdef ECONNRESET
-        defined_error("ECONNRESET", ECONNRESET)
+#ifdef ENOTCONN
+        defined_error("ENOTCONN", ENOTCONN)
 #else
-        undefined_error("ECONNRESET")
+        undefined_error("ENOTCONN")
 #endif
-#ifdef ENOBUFS
-        defined_error("ENOBUFS", ENOBUFS)
+#ifdef ENOTDIR
+        defined_error("ENOTDIR", ENOTDIR)
 #else
-        undefined_error("ENOBUFS")
+        undefined_error("ENOTDIR")
 #endif
-#ifdef EISCONN
-        defined_error("EISCONN", EISCONN)
+#ifdef ENOTEMPTY
+        defined_error("ENOTEMPTY", ENOTEMPTY)
 #else
-        undefined_error("EISCONN")
+        undefined_error("ENOTEMPTY")
 #endif
-#ifdef ENOTCONN
-        defined_error("ENOTCONN", ENOTCONN)
+#ifdef ENOTNAM
+        defined_error("ENOTNAM", ENOTNAM)
 #else
-        undefined_error("ENOTCONN")
+        undefined_error("ENOTNAM")
 #endif
-#ifdef ESHUTDOWN
-        defined_error("ESHUTDOWN", ESHUTDOWN)
+#ifdef ENOTRECOVERABLE
+        defined_error("ENOTRECOVERABLE", ENOTRECOVERABLE)
 #else
-        undefined_error("ESHUTDOWN")
+        undefined_error("ENOTRECOVERABLE")
 #endif
-#ifdef ETOOMANYREFS
-        defined_error("ETOOMANYREFS", ETOOMANYREFS)
+#ifdef ENOTSOCK
+        defined_error("ENOTSOCK", ENOTSOCK)
 #else
-        undefined_error("ETOOMANYREFS")
+        undefined_error("ENOTSOCK")
 #endif
-#ifdef ETIMEDOUT
-        defined_error("ETIMEDOUT", ETIMEDOUT)
+#ifdef ENOTSUP
+        defined_error("ENOTSUP", ENOTSUP)
 #else
-        undefined_error("ETIMEDOUT")
+        undefined_error("ENOTSUP")
 #endif
-#ifdef ECONNREFUSED
-        defined_error("ECONNREFUSED", ECONNREFUSED)
+#ifdef ENOTTY
+        defined_error("ENOTTY", ENOTTY)
 #else
-        undefined_error("ECONNREFUSED")
+        undefined_error("ENOTTY")
 #endif
-#ifdef EHOSTDOWN
-        defined_error("EHOSTDOWN", EHOSTDOWN)
+#ifdef ENOTUNIQ
+        defined_error("ENOTUNIQ", ENOTUNIQ)
 #else
-        undefined_error("EHOSTDOWN")
+        undefined_error("ENOTUNIQ")
 #endif
-#ifdef EHOSTUNREACH
-        defined_error("EHOSTUNREACH", EHOSTUNREACH)
+#ifdef ENXIO
+        defined_error("ENXIO", ENXIO)
 #else
-        undefined_error("EHOSTUNREACH")
+        undefined_error("ENXIO")
 #endif
-#ifdef EALREADY
-        defined_error("EALREADY", EALREADY)
+#ifdef EOPNOTSUPP
+        defined_error("EOPNOTSUPP", EOPNOTSUPP)
 #else
-        undefined_error("EALREADY")
+        undefined_error("EOPNOTSUPP")
 #endif
-#ifdef EINPROGRESS
-        defined_error("EINPROGRESS", EINPROGRESS)
+#ifdef EOVERFLOW
+        defined_error("EOVERFLOW", EOVERFLOW)
 #else
-        undefined_error("EINPROGRESS")
+        undefined_error("EOVERFLOW")
 #endif
-#ifdef ESTALE
-        defined_error("ESTALE", ESTALE)
+#ifdef EOWNERDEAD
+        defined_error("EOWNERDEAD", EOWNERDEAD)
 #else
-        undefined_error("ESTALE")
+        undefined_error("EOWNERDEAD")
 #endif
-#ifdef EUCLEAN
-        defined_error("EUCLEAN", EUCLEAN)
+#ifdef EPERM
+        defined_error("EPERM", EPERM)
 #else
-        undefined_error("EUCLEAN")
+        undefined_error("EPERM")
 #endif
-#ifdef ENOTNAM
-        defined_error("ENOTNAM", ENOTNAM)
+#ifdef EPFNOSUPPORT
+        defined_error("EPFNOSUPPORT", EPFNOSUPPORT)
 #else
-        undefined_error("ENOTNAM")
+        undefined_error("EPFNOSUPPORT")
 #endif
-#ifdef ENAVAIL
-        defined_error("ENAVAIL", ENAVAIL)
+#ifdef EPIPE
+        defined_error("EPIPE", EPIPE)
 #else
-        undefined_error("ENAVAIL")
+        undefined_error("EPIPE")
 #endif
-#ifdef EISNAM
-        defined_error("EISNAM", EISNAM)
+#ifdef EPROCLIM
+        defined_error("EPROCLIM", EPROCLIM)
 #else
-        undefined_error("EISNAM")
+        undefined_error("EPROCLIM")
 #endif
-#ifdef EREMOTEIO
-        defined_error("EREMOTEIO", EREMOTEIO)
+#ifdef EPROCUNAVAIL
+        defined_error("EPROCUNAVAIL", EPROCUNAVAIL)
 #else
-        undefined_error("EREMOTEIO")
+        undefined_error("EPROCUNAVAIL")
 #endif
-#ifdef EDQUOT
-        defined_error("EDQUOT", EDQUOT)
+#ifdef EPROGMISMATCH
+        defined_error("EPROGMISMATCH", EPROGMISMATCH)
 #else
-        undefined_error("EDQUOT")
+        undefined_error("EPROGMISMATCH")
 #endif
-#ifdef ECANCELED
-        defined_error("ECANCELED", ECANCELED)
+#ifdef EPROGUNAVAIL
+        defined_error("EPROGUNAVAIL", EPROGUNAVAIL)
 #else
-        undefined_error("ECANCELED")
+        undefined_error("EPROGUNAVAIL")
 #endif
-#ifdef EKEYEXPIRED
-        defined_error("EKEYEXPIRED", EKEYEXPIRED)
+#ifdef EPROTO
+        defined_error("EPROTO", EPROTO)
 #else
-        undefined_error("EKEYEXPIRED")
+        undefined_error("EPROTO")
 #endif
-#ifdef EKEYREJECTED
-        defined_error("EKEYREJECTED", EKEYREJECTED)
+#ifdef EPROTONOSUPPORT
+        defined_error("EPROTONOSUPPORT", EPROTONOSUPPORT)
 #else
-        undefined_error("EKEYREJECTED")
+        undefined_error("EPROTONOSUPPORT")
 #endif
-#ifdef EKEYREVOKED
-        defined_error("EKEYREVOKED", EKEYREVOKED)
+#ifdef EPROTOTYPE
+        defined_error("EPROTOTYPE", EPROTOTYPE)
 #else
-        undefined_error("EKEYREVOKED")
+        undefined_error("EPROTOTYPE")
 #endif
-#ifdef EMEDIUMTYPE
-        defined_error("EMEDIUMTYPE", EMEDIUMTYPE)
+#ifdef EPWROFF
+        defined_error("EPWROFF", EPWROFF)
 #else
-        undefined_error("EMEDIUMTYPE")
+        undefined_error("EPWROFF")
 #endif
-#ifdef ENOKEY
-        defined_error("ENOKEY", ENOKEY)
+#ifdef EQFULL
+        defined_error("EQFULL", EQFULL)
 #else
-        undefined_error("ENOKEY")
+        undefined_error("EQFULL")
 #endif
-#ifdef ENOMEDIUM
-        defined_error("ENOMEDIUM", ENOMEDIUM)
+#ifdef ERANGE
+        defined_error("ERANGE", ERANGE)
 #else
-        undefined_error("ENOMEDIUM")
+        undefined_error("ERANGE")
 #endif
-#ifdef ENOTRECOVERABLE
-        defined_error("ENOTRECOVERABLE", ENOTRECOVERABLE)
+#ifdef EREMCHG
+        defined_error("EREMCHG", EREMCHG)
 #else
-        undefined_error("ENOTRECOVERABLE")
+        undefined_error("EREMCHG")
 #endif
-#ifdef EOWNERDEAD
-        defined_error("EOWNERDEAD", EOWNERDEAD)
+#ifdef EREMOTE
+        defined_error("EREMOTE", EREMOTE)
 #else
-        undefined_error("EOWNERDEAD")
+        undefined_error("EREMOTE")
+#endif
+#ifdef EREMOTEIO
+        defined_error("EREMOTEIO", EREMOTEIO)
+#else
+        undefined_error("EREMOTEIO")
+#endif
+#ifdef ERESTART
+        defined_error("ERESTART", ERESTART)
+#else
+        undefined_error("ERESTART")
 #endif
 #ifdef ERFKILL
         defined_error("ERFKILL", ERFKILL)
 #else
         undefined_error("ERFKILL")
 #endif
-#ifdef EAUTH
-        defined_error("EAUTH", EAUTH)
+#ifdef EROFS
+        defined_error("EROFS", EROFS)
 #else
-        undefined_error("EAUTH")
+        undefined_error("EROFS")
 #endif
-#ifdef EBADRPC
-        defined_error("EBADRPC", EBADRPC)
+#ifdef ERPCMISMATCH
+        defined_error("ERPCMISMATCH", ERPCMISMATCH)
 #else
-        undefined_error("EBADRPC")
+        undefined_error("ERPCMISMATCH")
 #endif
-#ifdef EDOOFUS
-        defined_error("EDOOFUS", EDOOFUS)
+#ifdef ESHLIBVERS
+        defined_error("ESHLIBVERS", ESHLIBVERS)
 #else
-        undefined_error("EDOOFUS")
+        undefined_error("ESHLIBVERS")
 #endif
-#ifdef EFTYPE
-        defined_error("EFTYPE", EFTYPE)
+#ifdef ESHUTDOWN
+        defined_error("ESHUTDOWN", ESHUTDOWN)
 #else
-        undefined_error("EFTYPE")
+        undefined_error("ESHUTDOWN")
 #endif
-#ifdef ENEEDAUTH
-        defined_error("ENEEDAUTH", ENEEDAUTH)
+#ifdef ESOCKTNOSUPPORT
+        defined_error("ESOCKTNOSUPPORT", ESOCKTNOSUPPORT)
 #else
-        undefined_error("ENEEDAUTH")
+        undefined_error("ESOCKTNOSUPPORT")
 #endif
-#ifdef ENOATTR
-        defined_error("ENOATTR", ENOATTR)
+#ifdef ESPIPE
+        defined_error("ESPIPE", ESPIPE)
 #else
-        undefined_error("ENOATTR")
+        undefined_error("ESPIPE")
 #endif
-#ifdef ENOTSUP
-        defined_error("ENOTSUP", ENOTSUP)
+#ifdef ESRCH
+        defined_error("ESRCH", ESRCH)
 #else
-        undefined_error("ENOTSUP")
+        undefined_error("ESRCH")
 #endif
-#ifdef EPROCLIM
-        defined_error("EPROCLIM", EPROCLIM)
+#ifdef ESRMNT
+        defined_error("ESRMNT", ESRMNT)
 #else
-        undefined_error("EPROCLIM")
+        undefined_error("ESRMNT")
 #endif
-#ifdef EPROCUNAVAIL
-        defined_error("EPROCUNAVAIL", EPROCUNAVAIL)
+#ifdef ESTALE
+        defined_error("ESTALE", ESTALE)
 #else
-        undefined_error("EPROCUNAVAIL")
+        undefined_error("ESTALE")
 #endif
-#ifdef EPROGMISMATCH
-        defined_error("EPROGMISMATCH", EPROGMISMATCH)
+#ifdef ESTRPIPE
+        defined_error("ESTRPIPE", ESTRPIPE)
 #else
-        undefined_error("EPROGMISMATCH")
+        undefined_error("ESTRPIPE")
 #endif
-#ifdef EPROGUNAVAIL
-        defined_error("EPROGUNAVAIL", EPROGUNAVAIL)
+#ifdef ETIME
+        defined_error("ETIME", ETIME)
 #else
-        undefined_error("EPROGUNAVAIL")
+        undefined_error("ETIME")
 #endif
-#ifdef ERPCMISMATCH
-        defined_error("ERPCMISMATCH", ERPCMISMATCH)
+#ifdef ETIMEDOUT
+        defined_error("ETIMEDOUT", ETIMEDOUT)
 #else
-        undefined_error("ERPCMISMATCH")
+        undefined_error("ETIMEDOUT")
 #endif
-#ifdef EIPSEC
-        defined_error("EIPSEC", EIPSEC)
+#ifdef ETOOMANYREFS
+        defined_error("ETOOMANYREFS", ETOOMANYREFS)
 #else
-        undefined_error("EIPSEC")
+        undefined_error("ETOOMANYREFS")
 #endif
-#ifdef EHWPOISON
-        defined_error("EHWPOISON", EHWPOISON)
+#ifdef ETXTBSY
+        defined_error("ETXTBSY", ETXTBSY)
 #else
-        undefined_error("EHWPOISON")
+        undefined_error("ETXTBSY")
 #endif
-#ifdef ECAPMODE
-        defined_error("ECAPMODE", ECAPMODE)
+#ifdef EUCLEAN
+        defined_error("EUCLEAN", EUCLEAN)
 #else
-        undefined_error("ECAPMODE")
+        undefined_error("EUCLEAN")
 #endif
-#ifdef ENOTCAPABLE
-        defined_error("ENOTCAPABLE", ENOTCAPABLE)
+#ifdef EUNATCH
+        defined_error("EUNATCH", EUNATCH)
 #else
-        undefined_error("ENOTCAPABLE")
+        undefined_error("EUNATCH")
+#endif
+#ifdef EUSERS
+        defined_error("EUSERS", EUSERS)
+#else
+        undefined_error("EUSERS")
+#endif
+#ifdef EWOULDBLOCK
+        defined_error("EWOULDBLOCK", EWOULDBLOCK)
+#else
+        undefined_error("EWOULDBLOCK")
+#endif
+#ifdef EXDEV
+        defined_error("EXDEV", EXDEV)
+#else
+        undefined_error("EXDEV")
+#endif
+#ifdef EXFULL
+        defined_error("EXFULL", EXFULL)
+#else
+        undefined_error("EXFULL")
 #endif