logical pc_ADK_FieldControl :: AddTabControl (int32 posx, int32 posy ) { pc_ADK_Field fields(GPH("fields")); PropertyHandle *my_class = GPH("class"); PropertyHandle *member; PropertyHandle *fc; logical term = NO; BEGINSEQ if ( !my_class->Get(FIRST_INSTANCE) ) ERROR pc_ADK_Class new_class(*my_class); if ( !(fc = new_class.ProvideDefaultTabControl()) || !fc->Exist() ) ERROR if ( fields.NewField("tab",posx,posy) ) ERROR fields.SetupDataSource("*","DRT_PropertyPath",NO); fields.SetupFromFieldControl(fc); fields.GPH("class")->Add(new_class.ExtractKey()); CTXCERR fields.GPH("field_control")->Add(fc->ExtractKey()); CTXCERR fields.Save(); CTXCERR SetActionResult(fields.GPH("sys_ident")->GetString()); RECOVER SetActionResult(""); term = YES; ENDSEQ return(term); }
void Environment::add_class(std::string ident, std::string extends_ident) { Environment::ClsInfoPtr new_class(new Environment::lat_class); new_class->ident = ident; Environment::ClsInfoPtr parent = this->get_class(extends_ident); new_class->lat_cls_parent = parent; this->env_cls[ident] = new_class; }
Class* VM::new_class_under(const char* name, Module* under) { return new_class(name, G(object), under); }
Class* VM::new_class(const char* name, Class* super_class) { return new_class(name, super_class, G(object)); }
Class* VM::new_class(const char* name) { return new_class(name, G(object), G(object)); }
void VM::bootstrap_exceptions() { Class *exc, *scp, *std, *arg, *nam, *loe, *rex, *stk, *sxp, *sce, *type, *lje, *vme; Class* rng; #define dexc(name, sup) new_class(#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); dexc(RuntimeError, std); sce = dexc(SystemCallError, std); stk = dexc(StackError, exc); sxp = dexc(StackExploded, stk); 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(new_class("Internal", exc, G(rubinius))); // Some special exceptions scoped under the Rubinius module vme = new_class("VMException", exc, G(rubinius)); new_class("AssertionError", vme, G(rubinius)); new_class("ObjectBoundsExceededError", vme, G(rubinius)); // Create the stack error object now, since we probably wont be // able to later. GO(stack_error).set(new_object<Exception>(stk)); GO(exc_type).set(type); GO(exc_arg).set(arg); GO(exc_loe).set(loe); GO(exc_rex).set(rex); GO(exc_stack_explosion).set(sxp); GO(exc_primitive_failure).set(dexc(PrimitiveFailure, exc)); GO(exc_segfault).set(dexc(MemorySegmentionError, exc)); Module* ern = new_module("Errno"); GO(errno_mapping).set(LookupTable::create(state)); ern->set_const(state, symbol("Mapping"), G(errno_mapping)); #define set_syserr(num, name) setup_errno(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 }
void VM::initialize_builtin_classes() { // Create the immediate classes. GO(nil_class).set(new_class("NilClass")); G(nil_class)->set_object_type(state, NilType); GO(true_class).set(new_class("TrueClass")); G(true_class)->set_object_type(state, TrueType); GO(false_class).set(new_class("FalseClass")); G(false_class)->set_object_type(state, FalseType); Class* numeric = new_class("Numeric"); GO(numeric).set(numeric); Class* integer = new_class("Integer", numeric); GO(integer).set(integer); Fixnum::init(this); Symbol::init(this); // 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)Qfalse] = GO(false_class); globals().special_classes[(uintptr_t)Qnil ] = GO(nil_class); globals().special_classes[(uintptr_t)Qtrue ] = GO(true_class); /* Create IncludedModule */ GO(included_module).set(new_class("IncludedModule", G(module), G(rubinius))); G(included_module)->set_object_type(state, IncludedModuleType); G(included_module)->name(this, symbol("Rubinius::IncludedModule")); // Let all the builtin classes initialize themselves. This // typically means creating a Ruby class. Array::init(this); ArrayIterator::init(this); ByteArray::init(this); String::init(this); kcode::init(this); Executable::init(this); CompiledMethod::init(this); IO::init(this); BlockEnvironment::init(this); StaticScope::init(this); Dir::init(this); CompactLookupTable::init(this); Time::init(this); Regexp::init(this); Bignum::init(this); Float::init(this); InstructionSequence::init(this); List::init(this); init_ffi(); init_native_libraries(); Thread::init(this); AccessVariable::init(this); MemoryPointer::init(this); NativeFunction::init(this); TaskProbe::init(this); Exception::init(this); Data::init(this); Autoload::init(this); Proc::init(this); VariableScope::init(this); Location::init(this); Channel::init(this); NativeMethod::init(this); GlobalCacheEntry::init(this); WeakRef::init(this); Fiber::init(this); Alias::init(this); }
void Environment::add_class(std::string ident) { Environment::ClsInfoPtr new_class(new Environment::lat_class); new_class->ident = ident; this->env_cls[ident] = new_class; }
Class* VM::new_class_under(const char* name, Module* under) { return new_class(name, G(object), G(object)->instance_fields()->to_native(), under); }
Class* VM::new_class(const char* name, Class* sup, size_t fields) { return new_class(name, sup, fields, G(object)); }
Class* VM::new_class(const char* name, Class* super_class) { return new_class(name, super_class, G(object)->instance_fields()->to_native(), G(object)); }
logical pc_ADK_Field :: SetupField ( ) { PropertyHandle *pfc = GetParentProperty(); PropertyHandle *my_class = pfc->GPH("class"); PropertyHandle *member; PropertyHandle *fc; logical vgrow = YES; logical hgrow = YES; logical coll_opt; char *ref_type; char *propnames = NULL; char strnames[ID_SIZE+1]; logical term = NO; BEGINSEQ if ( IsInitialized() ) LEAVESEQ propnames = strdup(GPH("sys_ident")->GetString()); SetupFromParent(); if ( !my_class->Get(FIRST_INSTANCE) ) ERROR pc_ADK_Class new_class(GetObjectHandle(),PI_Update); PropertyHandle extent(GetObjectHandle(),"SDB_Extend",PI_Read); PropertyHandle phpropnames(propnames); pc_ADK_Class structure(*my_class); if ( member = structure.GetMember(propnames) ) { if ( !(fc = new_class.ProvideDefaultControl(member,hgrow,vgrow)) || !fc->Exist() ) ERROR coll_opt = pc0_SDB_Member(member).IsMultipleRef() ? YES : NO; ref_type = "DRT_PropertyPath"; strcpy(strnames,member->GetString("ddetype")); } else if ( extent.Get(phpropnames) ) { if ( !(fc = new_class.ProvideDefaultControl(&extent,hgrow,vgrow)) || !fc->Exist() ) ERROR coll_opt = YES; ref_type = "DRT_Extent"; strcpy(strnames,extent.GetString("ddetype")); } else ERROR if ( !hgrow ) *GPH("allign.hori_sizing") = "SIZE_Fixed"; if ( !vgrow ) *GPH("allign.vert_sizing") = "SIZE_Fixed"; *GPH("auto_open") = YES; SetupDataSource(propnames,ref_type,coll_opt); SetupFromFieldControl(fc); SetupTitle(propnames); GPH("class")->Add(new_class.ExtractKey()); CTXCERR GPH("field_control")->Add(fc->ExtractKey()); CTXCERR RECOVER term = YES; ENDSEQ if ( propnames ) free(propnames); return(term); }
void Environment::init_ontology(State& S) { check(!top_); String* on = String::internalize(S, "Object"); Class* o = new(S) Class(S, Class::Boot, 0, 0, on); String* cn = String::internalize(S, "Class"); Class* c = new(S) Class(S, Class::Boot, 0, o, cn); String* mn = String::internalize(S, "MetaClass"); Class* m = new(S) Class(S, Class::Boot, 0, 0, mn); Class* mco = new(S) Class(S, Class::Boot, m, c, Class::metaclass_name(S, on)); o->klass_ = mco; Class* mcc = new(S) Class(S, Class::Boot, m, mco, Class::metaclass_name(S, cn)); c->klass_ = mcc; Class* mcm = new(S) Class(S, Class::Boot, m, mco, Class::metaclass_name(S, mn)); m->klass_ = mcm; Class* mod = new(S) Class(S, o, String::internalize(S, "Module")); top_ = new(S) Module(S, mod, String::internalize(S, "lang")); bind(S, on, o); bind(S, cn, c); bind(S, mn, m); bind(S, String::internalize(S, "Module"), mod); Class::init(S, c); Object::init(S, o); Class* trait = Trait::init(S, this); Class* i = Integer::init(S, this); Class* n = new_class(S, "NilClass"); Class* s = new_class(S, "String"); Class* d = new_class(S, "Code"); Class* mc = Method::init(S, this); Class* t = new_class(S, "TrueClass"); t->add_method(S, "to_s", true_to_s, 0); Class* f = new_class(S, "FalseClass"); f->add_method(S, "to_s", false_to_s, 0); Class* tuple = Tuple::init(S, this); Class* dict = new_class(S, "Dictionary"); Class* list = new_class(S, "List"); modules_ = new(S) Dictionary(S); args_ = new(S) List(S); sys_ = new(S) Dictionary(S); sys_->set(S, String::internalize(S, "modules"), modules_); sys_->set(S, String::internalize(S, "args"), args_); Class* exc = new_class(S, "Exception"); Class* rte = new_class(S, "RuntimeError", exc); Class* arg_err = new_class(S, "ArgumentError", rte); new_class(S, "ImportError", rte); Class* nme = new_class(S, "NoMethodError", rte); exc->add_method(S, "message", exc_message, 0); exc->add_method(S, "show", exc_show, 0); Class** tbl = new(S) Class*[OOP::TotalTypes]; tbl[OOP::eNil] = n; tbl[OOP::eClass] = c; tbl[OOP::eInteger] = i; tbl[OOP::eString] = s; tbl[OOP::eCode] = d; tbl[OOP::eUser] = 0; tbl[OOP::eTrue] = t; tbl[OOP::eFalse] = f; tbl[OOP::eUnwind] = new_class(S, "Unwind"); tbl[OOP::eMethod] = mc; tbl[OOP::eTuple] = tuple; tbl[OOP::eDictionary] = dict; tbl[OOP::eList] = list; tbl[OOP::eTrait] = trait; Class::init_base(tbl); Module::init(S, *this); String* io_n = String::internalize(S, "io"); Module* io = new(S) Module(S, mod, io_n); io->add_method(S, "puts", io_puts, 1); io->add_method(S, "print", io_print, 1); bind(S, io_n, io); Class* importer = init_import(S); String::init(S); Dictionary::init(S, dict); List::init(S, list); globals_ = new(S) Closure(14); globals_->set(0, o); globals_->set(1, io); globals_->set(2, c); globals_->set(3, importer); globals_->set(4, dict); globals_->set(5, i); globals_->set(6, sys_); globals_->set(7, trait); globals_->set(8, arg_err); globals_->set(9, nme); globals_->set(10, exc); globals_->set(11, list); Code* enum_code = 0; if(dev_) { FILE* file = fopen("kernel/enumerable.mr", "r"); check(file); Compiler compiler; check(compiler.compile(S, String::internalize(S, "kernel/enumerable.mr"), file)); enum_code = compiler.code(); fclose(file); } else { enum_code = frozen_enumerable(S); } run_top_code(S, enum_code); Trait* enum_ = lookup(S, "Enumerable").as_trait(); tuple->uses_trait(S, enum_); init_builtin_extensions(S); S.set_importer(new(S) User(S, lookup(S, "Importer").as_class())); run_top_code(S, frozen_dir(S)); { #include "kernel/moment.mrc" run_top_code(S, Code::load_raw(S, (unsigned char*)data, data_size)); } globals_->set(12, lookup(S, "Dir")); globals_->set(13, lookup(S, "Moment")); }