Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
1102 lines (984 sloc) 31.507 kb
#include <sys/ioctl.h>
#include <termios.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include "object_memory.hpp"
#include "vm.hpp"
#include "builtin/access_variable.hpp"
#include "builtin/array.hpp"
#include "builtin/basic_object.hpp"
#include "builtin/block_environment.hpp"
#include "builtin/byte_array.hpp"
#include "builtin/character.hpp"
#include "builtin/class.hpp"
#include "builtin/compact_lookup_table.hpp"
#include "builtin/compiled_code.hpp"
#include "builtin/channel.hpp"
#include "builtin/data.hpp"
#include "builtin/dir.hpp"
#include "builtin/encoding.hpp"
#include "builtin/executable.hpp"
#include "builtin/fixnum.hpp"
#include "builtin/float.hpp"
#include "builtin/fsevent.hpp"
#include "builtin/io.hpp"
#include "builtin/iseq.hpp"
#include "builtin/jit.hpp"
#include "builtin/list.hpp"
#include "builtin/logger.hpp"
#include "builtin/lookup_table.hpp"
#include "builtin/method_table.hpp"
#include "builtin/ffi_pointer.hpp"
#include "builtin/native_function.hpp"
#include "builtin/native_method.hpp"
#include "builtin/regexp.hpp"
#include "builtin/constant_scope.hpp"
#include "builtin/string.hpp"
#include "builtin/symbol.hpp"
#include "builtin/system.hpp"
#include "builtin/thread.hpp"
#include "builtin/time.hpp"
#include "builtin/stat.hpp"
#include "builtin/tuple.hpp"
#include "builtin/autoload.hpp"
#include "builtin/proc.hpp"
#include "builtin/variable_scope.hpp"
#include "builtin/location.hpp"
#include "builtin/mono_inline_cache.hpp"
#include "builtin/poly_inline_cache.hpp"
#include "builtin/call_custom_cache.hpp"
#include "builtin/respond_to_cache.hpp"
#include "builtin/constant_cache.hpp"
#include "builtin/weakref.hpp"
#include "builtin/fiber.hpp"
#include "builtin/alias.hpp"
#include "builtin/randomizer.hpp"
#include "builtin/module.hpp"
#include "builtin/class.hpp"
#include "builtin/atomic.hpp"
#include "builtin/thread_state.hpp"
#include "environment.hpp"
#include "configuration.hpp"
#include "config.h"
#include "paths.h"
#include "release.h"
#include "ontology.hpp"
#define SPECIAL_CLASS_MASK 0x1f
#define SPECIAL_CLASS_SIZE 32
namespace rubinius {
namespace ontology {
Class* new_basic_class(STATE, Class* sup) {
Class *cls = state->memory()->new_object_enduring<Class>(state, G(klass));
cls->init(state);
if(sup->nil_p()) {
cls->instance_type(state, Fixnum::from(ObjectType));
cls->set_type_info(state->vm()->find_type(ObjectType));
} else {
cls->instance_type(state, sup->instance_type());
cls->set_type_info(sup->type_info());
}
cls->superclass(state, sup);
return cls;
}
Class* new_class(STATE, const char* name) {
return new_class(state, name, G(object), G(object));
}
Class* new_class(STATE, const char* name, Class* sup, Module* under) {
if(!under) under = G(object);
Class* cls = new_basic_class(state, sup);
cls->setup(state, name, under);
// HACK test that we've got the MOP setup properly
SingletonClass::attach(state, cls, sup->singleton_class(state));
return cls;
}
Class* new_class_under(STATE, const char* name, Module* under) {
return new_class(state, name, G(object), under);
}
Module* new_module(STATE, const char* name, Module* under) {
Module *mod = state->new_object<Module>(G(module));
mod->setup(state, name, under);
return mod;
}
}
// Reset macros since we're inside state
#undef G
#undef GO
#define G(whatever) globals().whatever.get()
#define GO(whatever) globals().whatever
void VM::bootstrap_class(STATE) {
/* Class is created first by hand, and twiddle to setup the internal
recursion. */
Class* cls = reinterpret_cast<Class*>(om->allocate_object_raw(sizeof(Class)));
/* We create these 8 classes in a particular way and in a particular
* order. We need all 8 to create fully initialized Classes and
* Modules, so we just create them all uninitialized, then initialize
* them all at once */
// Class's klass is Class
cls->set_obj_type(ClassType);
cls->klass(state, cls);
cls->ivars(state, cNil);
cls->set_object_type(state, ClassType);
cls->init(state);
cls->set_packed_size(0);
// Set Class into the globals
GO(klass).set(cls);
// Now do Object
Class* basicobject = 0;
Class* object;
basicobject = ontology::new_basic_class(state, force_as<Class>(cNil));
GO(basicobject).set(basicobject);
basicobject->set_object_type(state, BasicObjectType);
object = ontology::new_basic_class(state, basicobject);
GO(object).set(object);
object->set_object_type(state, ObjectType);
// Now Module
GO(module).set(ontology::new_basic_class(state, object));
G(module)->set_object_type(state, ModuleType);
// Fixup Class's superclass to be Module
cls->superclass(state, G(module));
// Create Tuple
Tuple::init(state);
// Create Array
GO(array).set(ontology::new_basic_class(state, object));
G(array)->set_object_type(state, ArrayType);
// Create WeakRef
GO(cls_weakref).set(ontology::new_basic_class(state, basicobject));
G(cls_weakref)->set_object_type(state, WeakRefType);
// Create LookupTable
GO(lookuptable).set(ontology::new_basic_class(state, object));
G(lookuptable)->set_object_type(state, LookupTableType);
// Create LookupTableBucket
GO(lookuptablebucket).set(ontology::new_basic_class(state, object));
G(lookuptablebucket)->set_object_type(state, LookupTableBucketType);
// Create ConstantTable
GO(constant_table).set(ontology::new_basic_class(state, object));
G(constant_table)->set_object_type(state, ConstantTableType);
// Create ConstantTableBucket
GO(constant_table_bucket).set(ontology::new_basic_class(state, object));
G(constant_table_bucket)->set_object_type(state, ConstantTableBucketType);
// Create MethodTable
GO(methtbl).set(ontology::new_basic_class(state, object));
G(methtbl)->set_object_type(state, MethodTableType);
// Create MethodTableBucket
GO(methtblbucket).set(ontology::new_basic_class(state, object));
G(methtblbucket)->set_object_type(state, MethodTableBucketType);
/* Now, we have:
* Class
* Module
* Object
* Tuple
* Array
* LookupTable
* LookupTableBucket
* ConstantTable
* ConstantTableBucket
* MethodTable
* MethodTableBucket
*
* With these 8 in place, we can now create fully initialized classes
* and modules.
*
* Next we need to finish up the SingletonClass protocol (a.k.a. MOP).
* The SingletonClass of a subclass points to the SingletonClass of the
* superclass.
*/
// BasicObject's SingletonClass instance has Class for a superclass
SingletonClass::attach(state, basicobject, cls);
// Object's SingletonClass instance has BasicObject's SingletonClass instance for a superclass
Class* sc = SingletonClass::attach(state, object, basicobject->klass());
// Module's metaclass's superclass is Object's metaclass
sc = SingletonClass::attach(state, G(module), sc);
// Class's metaclass likewise has Module's metaclass above it
SingletonClass::attach(state, cls, sc);
// See?
assert(basicobject->superclass()->nil_p());
assert(object->superclass() == basicobject);
assert(G(module)->superclass() == object);
assert(G(module)->klass()->superclass() == object->klass());
assert(cls->superclass() == G(module));
assert(cls->klass()->superclass() == G(module)->klass());
// The other builtin classes get SingletonClasses wired to Object's singleton class
sc = G(object)->singleton_class(state);
SingletonClass::attach(state, G(tuple), sc);
SingletonClass::attach(state, G(array), sc);
SingletonClass::attach(state, G(cls_weakref), sc);
SingletonClass::attach(state, G(lookuptable), sc);
SingletonClass::attach(state, G(lookuptablebucket), sc);
SingletonClass::attach(state, G(constant_table), sc);
SingletonClass::attach(state, G(constant_table_bucket), sc);
SingletonClass::attach(state, G(methtbl), sc);
SingletonClass::attach(state, G(methtblbucket), sc);
// Now, finish initializing the basic Class/Module
G(object)->setup(state, "Object");
G(basicobject)->setup(state, "BasicObject", G(object));
G(klass)->setup(state, "Class");
G(module)->setup(state, "Module");
// Create the namespace for various implementation classes
GO(rubinius).set(ontology::new_module(state, "Rubinius"));
GO(runtime).set(ontology::new_module(state, "Runtime", G(rubinius)));
// Finish initializing the rest of the special 8
G(tuple)->setup(state, "Tuple", G(rubinius));
G(array)->setup(state, "Array");
G(cls_weakref)->setup(state, "WeakRef");
G(lookuptable)->setup(state, "LookupTable", G(rubinius));
G(lookuptablebucket)->setup(state, "Bucket", G(lookuptable));
G(constant_table)->setup(state, "ConstantTable", G(rubinius));
G(constant_table_bucket)->setup(state, "Bucket", G(constant_table));
G(methtbl)->setup(state, "MethodTable", G(rubinius));
G(methtblbucket)->setup(state, "Bucket", G(methtbl));
}
void VM::initialize_builtin_classes(STATE) {
// Create the immediate classes.
GO(nil_class).set(ontology::new_class(state, "NilClass"));
G(nil_class)->set_object_type(state, NilType);
GO(nil_class)->type_info()->allow_user_allocate = false;
GO(true_class).set(ontology::new_class(state, "TrueClass"));
G(true_class)->set_object_type(state, TrueType);
GO(true_class)->type_info()->allow_user_allocate = false;
GO(false_class).set(ontology::new_class(state, "FalseClass"));
G(false_class)->set_object_type(state, FalseType);
GO(false_class)->type_info()->allow_user_allocate = false;
Numeric::init(state);
Integer::init(state);
Fixnum::init(state);
Symbol::init(state);
// Setup the special_class lookup table. We use this to resolve
// the classes for Fixnum's, nil, true and false.
for(size_t i = 0; i < SPECIAL_CLASS_SIZE; i++) {
if(SYMBOL_P(i)) {
globals().special_classes[i] = GO(symbol);
} else if(FIXNUM_P(i)) {
globals().special_classes[i] = GO(fixnum_class);
} else {
globals().special_classes[i] = GO(object); /* unused slot */
}
}
globals().special_classes[(uintptr_t)cFalse] = GO(false_class);
globals().special_classes[(uintptr_t)cNil ] = GO(nil_class);
globals().special_classes[(uintptr_t)cTrue ] = GO(true_class);
/* Create IncludedModule */
GO(included_module).set(ontology::new_class(state,
"IncludedModule", G(module), G(rubinius)));
G(included_module)->set_object_type(state, IncludedModuleType);
// Let all the builtin classes initialize themselves. this
// typically means creating a Ruby class.
BasicObject::init(state);
CompactLookupTable::init(state);
ByteArray::init(state);
String::init(state);
Character::init(state);
Executable::init(state);
CompiledCode::init(state);
AtomicReference::init(state);
IO::init(state);
BlockEnvironment::init(state);
ConstantScope::init(state);
Dir::init(state);
Time::init(state);
Stat::init(state);
Regexp::init(state);
Bignum::init(state);
Float::init(state);
InstructionSequence::init(state);
List::init(state);
init_ffi(state);
Thread::init(state);
ThreadState::init(state);
AccessVariable::init(state);
Pointer::init(state);
NativeFunction::init(state);
Exception::init(state);
Data::init(state);
Autoload::init(state);
Proc::init(state);
VariableScope::init(state);
Location::init(state);
Channel::init(state);
NativeMethod::init(state);
CallSite::init(state);
MonoInlineCache::init(state);
PolyInlineCache::init(state);
CallCustomCache::init(state);
ConstantCache::init(state);
RespondToCache::init(state);
Fiber::init(state);
Alias::init(state);
Randomizer::init(state);
Encoding::init(state);
FSEvent::init(state);
Logger::init(state);
JIT::init(state);
}
// @todo document all the sections of bootstrap_ontology
/* Creates the rubinius object universe from scratch. */
void VM::bootstrap_ontology(STATE) {
/*
* Bootstrap everything so we can create fully initialized
* Classes.
*/
bootstrap_symbol(state);
bootstrap_class(state);
/*
* Everything is now setup for us to make fully initialized
* classes.
*/
Object* undef = new_object<Object>(G(object));
GO(undefined).set(undef);
/*
* Create our Rubinius module that we hang stuff off
*/
initialize_fundamental_constants(state);
initialize_builtin_classes(state);
bootstrap_exceptions(state);
/*
* Create any 'stock' objects
*/
Object* main = new_object<Object>(G(object));
GO(main).set(main);
G(object)->set_const(state, "MAIN", main); // HACK test hooking up MAIN
GO(vm_class).set(ontology::new_class_under(state, "VM", G(rubinius)));
GO(type).set(ontology::new_module(state, "Type", G(rubinius)));
GO(mirror).set(ontology::new_class(state, "Mirror", G(object), G(rubinius)));
System::bootstrap_methods(state);
Module::bootstrap_methods(state);
ConstantScope::bootstrap_methods(state);
VariableScope::bootstrap_methods(state);
BlockEnvironment::bootstrap_methods(state);
/*
* Setup the table we use to store ivars for immediates
*/
GO(external_ivars).set(LookupTable::create(state));
initialize_platform_data(state);
}
void VM::initialize_fundamental_constants(STATE) {
if(sizeof(int) == sizeof(long)) {
G(rubinius)->set_const(state, "L64", cFalse);
} else {
G(rubinius)->set_const(state, "L64", cTrue);
}
G(rubinius)->set_const(state, "WORDSIZE", Fixnum::from(sizeof(void*) * 8));
}
void VM::initialize_platform_data(STATE) {
// HACK test hooking up IO
IO* in_io = IO::create(state, STDIN_FILENO);
IO* out_io = IO::create(state, STDOUT_FILENO);
IO* err_io = IO::create(state, STDERR_FILENO);
out_io->sync(state, cTrue);
err_io->sync(state, cTrue);
in_io->force_read_only(state);
out_io->force_write_only(state);
err_io->force_write_only(state);
G(object)->set_const(state, "STDIN", in_io);
G(object)->set_const(state, "STDOUT", out_io);
G(object)->set_const(state, "STDERR", err_io);
/* Fundamental constants. These are uniformly Strings and not symbols
* because some are passed to e.g. File.expand_path and having them
* be uniform is simpler.
*/
Environment* env = state->shared().env();
if(env) {
std::string prefix = env->system_prefix();
G(rubinius)->set_const(state, "PREFIX_PATH", String::create(state, prefix.c_str()));
std::string path = prefix + RBX_RUNTIME_PATH;
G(rubinius)->set_const(state, "RUNTIME_PATH", String::create(state, path.c_str()));
path = prefix + RBX_BIN_PATH;
G(rubinius)->set_const(state, "BIN_PATH", String::create(state, path.c_str()));
path = prefix + RBX_KERNEL_PATH;
G(rubinius)->set_const(state, "KERNEL_PATH", String::create(state, path.c_str()));
path = prefix + RBX_LIB_PATH;
G(rubinius)->set_const(state, "LIB_PATH", String::create(state, path.c_str()));
path = prefix + RBX_ENC_PATH;
G(rubinius)->set_const(state, "ENC_PATH", String::create(state, path.c_str()));
path = prefix + RBX_SITE_PATH;
G(rubinius)->set_const(state, "SITE_PATH", String::create(state, path.c_str()));
path = prefix + RBX_VENDOR_PATH;
G(rubinius)->set_const(state, "VENDOR_PATH", String::create(state, path.c_str()));
if(char* gems_path = getenv("RBX_GEMS_PATH")) {
G(rubinius)->set_const(state, "GEMS_PATH", String::create(state, gems_path));
} else {
path = prefix + RBX_GEMS_PATH;
G(rubinius)->set_const(state, "GEMS_PATH", String::create(state, path.c_str()));
}
path = prefix + RBX_HDR_PATH;
G(rubinius)->set_const(state, "HDR_PATH", String::create(state, path.c_str()));
}
G(rubinius)->set_const(state, "PROGRAM_NAME", String::create(state, RBX_PROGRAM_NAME));
G(rubinius)->set_const(state, "RUBY_VERSION", String::create(state, RBX_RUBY_VERSION));
G(rubinius)->set_const(state, "ENGINE_VERSION", String::create(state, RBX_ENGINE_VERSION));
#ifdef ENABLE_LLVM
G(rubinius)->set_const(state, "LLVM_VERSION", String::create(state, RBX_LLVM_VERSION));
#endif
G(rubinius)->set_const(state, "VERSION", String::create(state, RBX_VERSION));
G(rubinius)->set_const(state, "LIB_VERSION", String::create(state, RBX_LIB_VERSION));
G(rubinius)->set_const(state, "BUILD_REV", String::create(state, RBX_BUILD_REV));
G(rubinius)->set_const(state, "RELEASE_DATE", String::create(state, RBX_RELEASE_DATE));
G(rubinius)->set_const(state, "DEBUG_BUILD", RBOOL(RBX_DEBUG_BUILD));
G(rubinius)->set_const(state, "LDSHARED", String::create(state, RBX_LDSHARED));
G(rubinius)->set_const(state, "LDSHAREDXX", String::create(state, RBX_LDSHAREDXX));
G(rubinius)->set_const(state, "HOST", String::create(state, RBX_HOST));
G(rubinius)->set_const(state, "CPU", String::create(state, RBX_CPU));
G(rubinius)->set_const(state, "VENDOR", String::create(state, RBX_VENDOR));
G(rubinius)->set_const(state, "OS", String::create(state, RBX_OS));
G(rubinius)->set_const(state, "RUBY_LIB_VERSION", Fixnum::from(RBX_RUBY_LIB_VERSION));
G(rubinius)->set_const(state, "LIBC", String::create(state, RBX_LIBC));
G(rubinius)->set_const(state, "HAVE_LCHMOD", RBX_HAVE_LCHMOD ? cTrue : cFalse);
G(rubinius)->set_const(state, "HAVE_LCHOWN", RBX_HAVE_LCHOWN ? cTrue : cFalse);
#ifdef RBX_LITTLE_ENDIAN
G(rubinius)->set_const(state, "ENDIAN", state->symbol("little"));
#else
G(rubinius)->set_const(state, "ENDIAN", state->symbol("big"));
#endif
G(rubinius)->set_const(state, "PATH_MAX", Fixnum::from(PATH_MAX));
// Used in Array.pack
G(rubinius)->set_const(state, "SIZEOF_SHORT", Fixnum::from(sizeof(short)));
G(rubinius)->set_const(state, "SIZEOF_INT", Fixnum::from(sizeof(int)));
G(rubinius)->set_const(state, "SIZEOF_LONG", Fixnum::from(sizeof(long)));
struct winsize w;
if(ioctl(0, TIOCGWINSZ, &w)) {
w.ws_col = 80;
}
G(rubinius)->set_const(state, "TERMINAL_WIDTH", Fixnum::from(w.ws_col));
}
void VM::bootstrap_symbol(STATE) {
#define add_sym(name) GO(sym_ ## name).set(state->symbol(#name))
add_sym(object_id);
add_sym(method_missing);
add_sym(inherited);
add_sym(from_literal);
add_sym(method_added);
add_sym(send);
add_sym(public);
add_sym(private);
add_sym(protected);
add_sym(undef);
add_sym(const_missing);
add_sym(object_id);
add_sym(call);
add_sym(coerce_to_array);
add_sym(to_ary);
add_sym(to_hash);
#undef add_sym
GO(sym_respond_to_missing).set(state->symbol("respond_to_missing?"));
GO(sym_s_method_added).set(state->symbol("singleton_method_added"));
GO(sym_init_copy).set(state->symbol("initialize_copy"));
GO(sym_plus).set(state->symbol("+"));
GO(sym_minus).set(state->symbol("-"));
GO(sym_equal).set(state->symbol("=="));
GO(sym_nequal).set(state->symbol("!="));
GO(sym_tequal).set(state->symbol("==="));
GO(sym_lt).set(state->symbol("<"));
GO(sym_gt).set(state->symbol(">"));
GO(sym_allocation_site).set(state->symbol("@__allocation_site__"));
GO(sym_keyword_object).set(state->symbol("keyword_object?"));
}
void VM::setup_errno(STATE, int num, const char* name, Class* sce, Module* ern) {
bool found = false;
Object* key = Fixnum::from(num);
Object* current = state->globals().errno_mapping->fetch(state, key, &found);
if(found) {
ern->set_const(state, state->symbol(name), current);
} else {
Class* cls = ontology::new_class(state, name, sce, ern);
// new_class has simply name setting logic that doesn't take into account
// being not under Object. So we set it again using the smart method.
cls->set_name(state, name, ern);
cls->set_const(state, state->symbol("Errno"), key);
char buf[RBX_STRERROR_BUFSIZE];
char* err = RBX_STRERROR(num, buf, RBX_STRERROR_BUFSIZE);
cls->set_const(state, state->symbol("Strerror"), String::create(state, err));
state->globals().errno_mapping->store(state, key, cls);
}
}
void VM::bootstrap_exceptions(STATE) {
Class *exc, *scp, *std, *arg, *nam, *loe, *rex, *stk, *sce, *type, *lje, *vme;
Class *rng, *rte;
#define dexc(name, sup) ontology::new_class(state, #name, sup)
exc = G(exception);
scp = dexc(ScriptError, exc);
std = dexc(StandardError, exc);
type = dexc(TypeError, std);
arg = dexc(ArgumentError, std);
nam = dexc(NameError, std);
rex = dexc(RegexpError, std);
dexc(NoMethodError, nam);
dexc(SyntaxError, scp);
loe = dexc(LoadError, scp);
rte = dexc(RuntimeError, std);
sce = dexc(SystemCallError, std);
stk = dexc(SystemStackError, exc);
lje = dexc(LocalJumpError, std);
rng = dexc(RangeError, std);
dexc(FloatDomainError, rng);
dexc(ZeroDivisionError, std);
dexc(IOError, std);
GO(jump_error).set(lje);
GO(exc_vm_internal).set(ontology::new_class(state,
"Internal", exc, G(rubinius)));
GO(exc_vm_bad_bytecode).set(
ontology::new_class(state, "InvalidBytecode",
G(exc_vm_internal), G(rubinius)));
// Some special exceptions scoped under the Rubinius module
vme = ontology::new_class(state, "VMException", exc, G(rubinius));
ontology::new_class(state, "AssertionError", vme, G(rubinius));
ontology::new_class(state, "ObjectBoundsExceededError", vme, G(rubinius));
// The stack_error mechanisms assume that there will be enough
// space left over to allocate the actual exception.
GO(stack_error).set(stk);
GO(exc_type).set(type);
GO(exc_arg).set(arg);
GO(exc_loe).set(loe);
GO(exc_rex).set(rex);
GO(exc_rte).set(rte);
GO(exc_primitive_failure).set(dexc(PrimitiveFailure, exc));
GO(exc_segfault).set(dexc(MemorySegmentionError, exc));
Module* ern = ontology::new_module(state, "Errno");
GO(errno_mapping).set(LookupTable::create(state));
ern->set_const(state, state->symbol("Mapping"), G(errno_mapping));
#define set_syserr(num, name) setup_errno(state, num, name, sce, ern)
/*
* Stolen from MRI
*/
#ifdef EPERM
set_syserr(EPERM, "EPERM");
#endif
#ifdef ENOENT
set_syserr(ENOENT, "ENOENT");
#endif
#ifdef ESRCH
set_syserr(ESRCH, "ESRCH");
#endif
#ifdef EINTR
set_syserr(EINTR, "EINTR");
#endif
#ifdef EIO
set_syserr(EIO, "EIO");
#endif
#ifdef ENXIO
set_syserr(ENXIO, "ENXIO");
#endif
#ifdef E2BIG
set_syserr(E2BIG, "E2BIG");
#endif
#ifdef ENOEXEC
set_syserr(ENOEXEC, "ENOEXEC");
#endif
#ifdef EBADF
set_syserr(EBADF, "EBADF");
#endif
#ifdef ECHILD
set_syserr(ECHILD, "ECHILD");
#endif
#ifdef EAGAIN
set_syserr(EAGAIN, "EAGAIN");
#endif
#ifdef ENOMEM
set_syserr(ENOMEM, "ENOMEM");
#endif
#ifdef EACCES
set_syserr(EACCES, "EACCES");
#endif
#ifdef EFAULT
set_syserr(EFAULT, "EFAULT");
#endif
#ifdef ENOTBLK
set_syserr(ENOTBLK, "ENOTBLK");
#endif
#ifdef EBUSY
set_syserr(EBUSY, "EBUSY");
#endif
#ifdef EEXIST
set_syserr(EEXIST, "EEXIST");
#endif
#ifdef EXDEV
set_syserr(EXDEV, "EXDEV");
#endif
#ifdef ENODEV
set_syserr(ENODEV, "ENODEV");
#endif
#ifdef ENOTDIR
set_syserr(ENOTDIR, "ENOTDIR");
#endif
#ifdef EISDIR
set_syserr(EISDIR, "EISDIR");
#endif
#ifdef EINVAL
set_syserr(EINVAL, "EINVAL");
#endif
#ifdef ENFILE
set_syserr(ENFILE, "ENFILE");
#endif
#ifdef EMFILE
set_syserr(EMFILE, "EMFILE");
#endif
#ifdef ENOTTY
set_syserr(ENOTTY, "ENOTTY");
#endif
#ifdef ETXTBSY
set_syserr(ETXTBSY, "ETXTBSY");
#endif
#ifdef EFBIG
set_syserr(EFBIG, "EFBIG");
#endif
#ifdef ENOSPC
set_syserr(ENOSPC, "ENOSPC");
#endif
#ifdef ESPIPE
set_syserr(ESPIPE, "ESPIPE");
#endif
#ifdef EROFS
set_syserr(EROFS, "EROFS");
#endif
#ifdef EMLINK
set_syserr(EMLINK, "EMLINK");
#endif
#ifdef EPIPE
set_syserr(EPIPE, "EPIPE");
#endif
#ifdef EDOM
set_syserr(EDOM, "EDOM");
#endif
#ifdef ERANGE
set_syserr(ERANGE, "ERANGE");
#endif
#ifdef EDEADLK
set_syserr(EDEADLK, "EDEADLK");
#endif
#ifdef ENAMETOOLONG
set_syserr(ENAMETOOLONG, "ENAMETOOLONG");
#endif
#ifdef ENOLCK
set_syserr(ENOLCK, "ENOLCK");
#endif
#ifdef ENOSYS
set_syserr(ENOSYS, "ENOSYS");
#endif
#ifdef ENOTEMPTY
set_syserr(ENOTEMPTY, "ENOTEMPTY");
#endif
#ifdef ELOOP
set_syserr(ELOOP, "ELOOP");
#endif
#ifdef EWOULDBLOCK
set_syserr(EWOULDBLOCK, "EWOULDBLOCK");
#endif
#ifdef ENOMSG
set_syserr(ENOMSG, "ENOMSG");
#endif
#ifdef EIDRM
set_syserr(EIDRM, "EIDRM");
#endif
#ifdef ECHRNG
set_syserr(ECHRNG, "ECHRNG");
#endif
#ifdef EL2NSYNC
set_syserr(EL2NSYNC, "EL2NSYNC");
#endif
#ifdef EL3HLT
set_syserr(EL3HLT, "EL3HLT");
#endif
#ifdef EL3RST
set_syserr(EL3RST, "EL3RST");
#endif
#ifdef ELNRNG
set_syserr(ELNRNG, "ELNRNG");
#endif
#ifdef EUNATCH
set_syserr(EUNATCH, "EUNATCH");
#endif
#ifdef ENOCSI
set_syserr(ENOCSI, "ENOCSI");
#endif
#ifdef EL2HLT
set_syserr(EL2HLT, "EL2HLT");
#endif
#ifdef EBADE
set_syserr(EBADE, "EBADE");
#endif
#ifdef EBADR
set_syserr(EBADR, "EBADR");
#endif
#ifdef EXFULL
set_syserr(EXFULL, "EXFULL");
#endif
#ifdef ENOANO
set_syserr(ENOANO, "ENOANO");
#endif
#ifdef EBADRQC
set_syserr(EBADRQC, "EBADRQC");
#endif
#ifdef EBADSLT
set_syserr(EBADSLT, "EBADSLT");
#endif
#ifdef EDEADLOCK
set_syserr(EDEADLOCK, "EDEADLOCK");
#endif
#ifdef EBFONT
set_syserr(EBFONT, "EBFONT");
#endif
#ifdef ENOSTR
set_syserr(ENOSTR, "ENOSTR");
#endif
#ifdef ENODATA
set_syserr(ENODATA, "ENODATA");
#endif
#ifdef ETIME
set_syserr(ETIME, "ETIME");
#endif
#ifdef ENOSR
set_syserr(ENOSR, "ENOSR");
#endif
#ifdef ENONET
set_syserr(ENONET, "ENONET");
#endif
#ifdef ENOPKG
set_syserr(ENOPKG, "ENOPKG");
#endif
#ifdef EREMOTE
set_syserr(EREMOTE, "EREMOTE");
#endif
#ifdef ENOLINK
set_syserr(ENOLINK, "ENOLINK");
#endif
#ifdef EADV
set_syserr(EADV, "EADV");
#endif
#ifdef ESRMNT
set_syserr(ESRMNT, "ESRMNT");
#endif
#ifdef ECOMM
set_syserr(ECOMM, "ECOMM");
#endif
#ifdef EPROTO
set_syserr(EPROTO, "EPROTO");
#endif
#ifdef EMULTIHOP
set_syserr(EMULTIHOP, "EMULTIHOP");
#endif
#ifdef EDOTDOT
set_syserr(EDOTDOT, "EDOTDOT");
#endif
#ifdef EBADMSG
set_syserr(EBADMSG, "EBADMSG");
#endif
#ifdef EOVERFLOW
set_syserr(EOVERFLOW, "EOVERFLOW");
#endif
#ifdef ENOTUNIQ
set_syserr(ENOTUNIQ, "ENOTUNIQ");
#endif
#ifdef EBADFD
set_syserr(EBADFD, "EBADFD");
#endif
#ifdef EREMCHG
set_syserr(EREMCHG, "EREMCHG");
#endif
#ifdef ELIBACC
set_syserr(ELIBACC, "ELIBACC");
#endif
#ifdef ELIBBAD
set_syserr(ELIBBAD, "ELIBBAD");
#endif
#ifdef ELIBSCN
set_syserr(ELIBSCN, "ELIBSCN");
#endif
#ifdef ELIBMAX
set_syserr(ELIBMAX, "ELIBMAX");
#endif
#ifdef ELIBEXEC
set_syserr(ELIBEXEC, "ELIBEXEC");
#endif
#ifdef EILSEQ
set_syserr(EILSEQ, "EILSEQ");
#endif
#ifdef ERESTART
set_syserr(ERESTART, "ERESTART");
#endif
#ifdef ESTRPIPE
set_syserr(ESTRPIPE, "ESTRPIPE");
#endif
#ifdef EUSERS
set_syserr(EUSERS, "EUSERS");
#endif
#ifdef ENOTSOCK
set_syserr(ENOTSOCK, "ENOTSOCK");
#endif
#ifdef EDESTADDRREQ
set_syserr(EDESTADDRREQ, "EDESTADDRREQ");
#endif
#ifdef EMSGSIZE
set_syserr(EMSGSIZE, "EMSGSIZE");
#endif
#ifdef EPROTOTYPE
set_syserr(EPROTOTYPE, "EPROTOTYPE");
#endif
#ifdef ENOPROTOOPT
set_syserr(ENOPROTOOPT, "ENOPROTOOPT");
#endif
#ifdef EPROTONOSUPPORT
set_syserr(EPROTONOSUPPORT, "EPROTONOSUPPORT");
#endif
#ifdef ESOCKTNOSUPPORT
set_syserr(ESOCKTNOSUPPORT, "ESOCKTNOSUPPORT");
#endif
#ifdef EOPNOTSUPP
set_syserr(EOPNOTSUPP, "EOPNOTSUPP");
#endif
#ifdef EPFNOSUPPORT
set_syserr(EPFNOSUPPORT, "EPFNOSUPPORT");
#endif
#ifdef EAFNOSUPPORT
set_syserr(EAFNOSUPPORT, "EAFNOSUPPORT");
#endif
#ifdef EADDRINUSE
set_syserr(EADDRINUSE, "EADDRINUSE");
#endif
#ifdef EADDRNOTAVAIL
set_syserr(EADDRNOTAVAIL, "EADDRNOTAVAIL");
#endif
#ifdef ENETDOWN
set_syserr(ENETDOWN, "ENETDOWN");
#endif
#ifdef ENETUNREACH
set_syserr(ENETUNREACH, "ENETUNREACH");
#endif
#ifdef ENETRESET
set_syserr(ENETRESET, "ENETRESET");
#endif
#ifdef ECONNABORTED
set_syserr(ECONNABORTED, "ECONNABORTED");
#endif
#ifdef ECONNRESET
set_syserr(ECONNRESET, "ECONNRESET");
#endif
#ifdef ENOBUFS
set_syserr(ENOBUFS, "ENOBUFS");
#endif
#ifdef EISCONN
set_syserr(EISCONN, "EISCONN");
#endif
#ifdef ENOTCONN
set_syserr(ENOTCONN, "ENOTCONN");
#endif
#ifdef ESHUTDOWN
set_syserr(ESHUTDOWN, "ESHUTDOWN");
#endif
#ifdef ETOOMANYREFS
set_syserr(ETOOMANYREFS, "ETOOMANYREFS");
#endif
#ifdef ETIMEDOUT
set_syserr(ETIMEDOUT, "ETIMEDOUT");
#endif
#ifdef ECONNREFUSED
set_syserr(ECONNREFUSED, "ECONNREFUSED");
#endif
#ifdef EHOSTDOWN
set_syserr(EHOSTDOWN, "EHOSTDOWN");
#endif
#ifdef EHOSTUNREACH
set_syserr(EHOSTUNREACH, "EHOSTUNREACH");
#endif
#ifdef EALREADY
set_syserr(EALREADY, "EALREADY");
#endif
#ifdef EINPROGRESS
set_syserr(EINPROGRESS, "EINPROGRESS");
#endif
#ifdef ESTALE
set_syserr(ESTALE, "ESTALE");
#endif
#ifdef EUCLEAN
set_syserr(EUCLEAN, "EUCLEAN");
#endif
#ifdef ENOTNAM
set_syserr(ENOTNAM, "ENOTNAM");
#endif
#ifdef ENAVAIL
set_syserr(ENAVAIL, "ENAVAIL");
#endif
#ifdef EISNAM
set_syserr(EISNAM, "EISNAM");
#endif
#ifdef EREMOTEIO
set_syserr(EREMOTEIO, "EREMOTEIO");
#endif
#ifdef EDQUOT
set_syserr(EDQUOT, "EDQUOT");
#endif
#ifdef EBADRPC
set_syserr(EBADRPC, "EBADRPC");
#endif
#ifdef ERPCMISMATCH
set_syserr(ERPCMISMATCH, "ERPCMISMATCH");
#endif
#ifdef EPROGUNAVAIL
set_syserr(EPROGUNAVAIL, "EPROGUNAVAIL");
#endif
#ifdef EPROGMISMATCH
set_syserr(EPROGMISMATCH, "EPROGMISMATCH");
#endif
#ifdef EPROCUNAVAIL
set_syserr(EPROCUNAVAIL, "EPROCUNAVAIL");
#endif
#ifdef EFTYPE
set_syserr(EFTYPE, "EFTYPE");
#endif
#ifdef EAUTH
set_syserr(EAUTH, "EAUTH");
#endif
#ifdef ENEEDAUTH
set_syserr(ENEEDAUTH, "ENEEDAUTH");
#endif
#ifdef ECANCELED
set_syserr(ECANCELED, "ECANCELED");
#endif
#ifdef ENOATTR
set_syserr(ENOATTR, "ENOATTR");
#endif
#ifdef EDOOFUS
set_syserr(EDOOFUS, "EDOOFUS");
#endif
#ifdef ENOTCAPABLE
set_syserr(ENOTCAPABLE, "ENOTCAPABLE");
#endif
#ifdef EPROCLIM
set_syserr(EPROCLIM, "EPROCLIM");
#endif
#ifdef EPRWOFF
set_syserr(EPWROFF, "EPWROFF");
#endif
#ifdef EDEVERR
set_syserr(EDEVERR, "EDEVERR");
#endif
#ifdef ENOPOLICY
set_syserr(ENOPOLICY, "ENOPOLICY");
#endif
#ifdef ENOMEDIUM
set_syserr(ENOMEDIUM, "ENOMEDIUM");
#endif
#ifdef EMEDIUMTYPE
set_syserr(EMEDIUMTYPE, "EMEDIUMTYPE");
#endif
#ifdef ENOKEY
set_syserr(ENOKEY, "ENOKEY");
#endif
#ifdef EKEYEXPIRED
set_syserr(EKEYEXPIRED, "EKEYEXPIRED");
#endif
#ifdef EKEYREVOKED
set_syserr(EKEYREVOKED, "EKEYREVOKED");
#endif
#ifdef EKEYREJECTED
set_syserr(EKEYREJECTED, "EKEYREJECTED");
#endif
#ifdef EOWNERDEAD
set_syserr(EOWNERDEAD, "EOWNERDEAD");
#endif
#ifdef ENOTRECOVERABLE
set_syserr(ENOTRECOVERABLE, "ENOTRECOVERABLE");
#endif
#ifdef ERFKILL
set_syserr(ERFKILL, "ERFKILL");
#endif
}
};
Jump to Line
Something went wrong with that request. Please try again.