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"));
}
