debase-ruby_core_source 0.10.5 → 0.10.10

data/lib/debase/ruby_core_source/ruby-2.6.5-p114/iseq.h

@@ -0,0 +1,304 @@
+/**********************************************************************
+
+  iseq.h -
+
+  $Author: ko1 $
+  created at: 04/01/01 23:36:57 JST
+
+  Copyright (C) 2004-2008 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef RUBY_ISEQ_H
+#define RUBY_ISEQ_H 1
+
+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;
+#define rb_iseq_t rb_iseq_t
+#endif
+
+static inline size_t
+rb_call_info_kw_arg_bytes(int keyword_len)
+{
+    return sizeof(struct rb_call_info_kw_arg) + sizeof(VALUE) * (keyword_len - 1);
+}
+
+#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_PC2BRANCHINDEX(iseq)         iseq->body->variable.pc2branchindex
+#define ISEQ_PC2BRANCHINDEX_SET(iseq, h)  RB_OBJ_WRITE(iseq, &iseq->body->variable.pc2branchindex, h)
+
+#define ISEQ_FLIP_CNT(iseq) (iseq)->body->variable.flip_count
+
+static inline rb_snum_t
+ISEQ_FLIP_CNT_INCREMENT(const rb_iseq_t *iseq)
+{
+    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)
+{
+    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)
+{
+    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;
+    }
+}
+
+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)
+{
+    return (rb_iseq_t *)rb_imemo_new(imemo_iseq, 0, 0, 0, 0);
+}
+
+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, 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,
+			    VALUE locals, VALUE args,
+			    VALUE exception, VALUE body);
+
+/* iseq.c */
+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);
+
+VALUE rb_iseqw_new(const rb_iseq_t *iseq);
+const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
+
+VALUE rb_iseq_absolute_path(const rb_iseq_t *iseq); /* obsolete */
+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);
+const rb_iseq_t *rb_proc_get_iseq(VALUE proc, int *is_proc);
+
+struct rb_compile_option_struct {
+    unsigned int inline_const_cache: 1;
+    unsigned int peephole_optimization: 1;
+    unsigned int tailcall_optimization: 1;
+    unsigned int specialized_instruction: 1;
+    unsigned int operands_unification: 1;
+    unsigned int instructions_unification: 1;
+    unsigned int stack_caching: 1;
+    unsigned int frozen_string_literal: 1;
+    unsigned int debug_frozen_string_literal: 1;
+    unsigned int coverage_enabled: 1;
+    int debug_level;
+};
+
+struct iseq_insn_info_entry {
+    int line_no;
+    rb_event_flag_t events;
+};
+
+struct iseq_catch_table_entry {
+    enum catch_type {
+	CATCH_TYPE_RESCUE = INT2FIX(1),
+	CATCH_TYPE_ENSURE = INT2FIX(2),
+	CATCH_TYPE_RETRY  = INT2FIX(3),
+	CATCH_TYPE_BREAK  = INT2FIX(4),
+	CATCH_TYPE_REDO   = INT2FIX(5),
+	CATCH_TYPE_NEXT   = INT2FIX(6)
+    } type;
+
+    /*
+     * iseq type:
+     *   CATCH_TYPE_RESCUE, CATCH_TYPE_ENSURE:
+     *     use iseq as continuation.
+     *
+     *   CATCH_TYPE_BREAK (iter):
+     *     use iseq as key.
+     *
+     *   CATCH_TYPE_BREAK (while), CATCH_TYPE_RETRY,
+     *   CATCH_TYPE_REDO, CATCH_TYPE_NEXT:
+     *     NULL.
+     */
+    const rb_iseq_t *iseq;
+
+    unsigned int start;
+    unsigned int end;
+    unsigned int cont;
+    unsigned int sp;
+};
+
+PACKED_STRUCT_UNALIGNED(struct iseq_catch_table {
+    unsigned int size;
+    struct iseq_catch_table_entry entries[FLEX_ARY_LEN];
+});
+
+static inline int
+iseq_catch_table_bytes(int n)
+{
+    enum {
+	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)(offsetof(struct iseq_catch_table, entries) +
+		 n * catch_table_entry_size);
+}
+
+#define INITIAL_ISEQ_COMPILE_DATA_STORAGE_BUFF_SIZE (512)
+
+struct iseq_compile_data_storage {
+    struct iseq_compile_data_storage *next;
+    unsigned int pos;
+    unsigned int size;
+    char buff[FLEX_ARY_LEN];
+};
+
+/* defined? */
+
+enum defined_type {
+    DEFINED_NOT_DEFINED,
+    DEFINED_NIL = 1,
+    DEFINED_IVAR,
+    DEFINED_LVAR,
+    DEFINED_GVAR,
+    DEFINED_CVAR,
+    DEFINED_CONST,
+    DEFINED_METHOD,
+    DEFINED_YIELD,
+    DEFINED_ZSUPER,
+    DEFINED_SELF,
+    DEFINED_TRUE,
+    DEFINED_FALSE,
+    DEFINED_ASGN,
+    DEFINED_EXPR,
+    DEFINED_IVAR2,
+    DEFINED_REF,
+    DEFINED_FUNC
+};
+
+VALUE rb_iseq_defined_string(enum defined_type type);
+void rb_iseq_make_compile_option(struct rb_compile_option_struct *option, VALUE opt);
+
+/* vm.c */
+VALUE rb_iseq_local_variables(const rb_iseq_t *iseq);
+
+RUBY_SYMBOL_EXPORT_END
+
+#endif /* RUBY_ISEQ_H */

data/lib/debase/ruby_core_source/ruby-2.6.5-p114/known_errors.inc

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