static VALUE
id2ref(VALUE obj, SEL sel, VALUE objid)
{
#if SIZEOF_LONG == SIZEOF_VOIDP
#define NUM2PTR(x) NUM2ULONG(x)
#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
#define NUM2PTR(x) NUM2ULL(x)
#endif
VALUE ptr;
void *p0;
rb_secure(4);
ptr = NUM2PTR(objid);
p0 = (void *)ptr;
if (ptr == Qtrue) return Qtrue;
if (ptr == Qfalse) return Qfalse;
if (ptr == Qnil) return Qnil;
if (FIXNUM_P(ptr) || SYMBOL_P(ptr))
return ptr;
if (auto_zone_is_valid_pointer(__auto_zone, p0)) {
auto_memory_type_t type =
auto_zone_get_layout_type(__auto_zone, p0);
if ((type == AUTO_OBJECT_SCANNED || type == AUTO_OBJECT_UNSCANNED)
&& (NATIVE((VALUE)p0)
|| (BUILTIN_TYPE(p0) < T_FIXNUM && BUILTIN_TYPE(p0) != T_ICLASS)))
return (VALUE)p0;
}
rb_raise(rb_eRangeError, "%p is not id value", p0);
}
void
rb_gc_copy_finalizer(VALUE dest, VALUE obj)
{
VALUE table;
if (__os_finalizers == NULL)
return;
if (NATIVE(obj)) {
if (!rb_objc_flag_check((void *)obj, FL_FINALIZE))
return;
}
else {
if (!FL_TEST(obj, FL_FINALIZE))
return;
}
table = (VALUE)CFDictionaryGetValue((CFDictionaryRef)__os_finalizers,
(const void *)obj);
if (table == 0) {
CFDictionaryRemoveValue(__os_finalizers, (const void *)dest);
}
else {
CFDictionarySetValue(__os_finalizers, (const void *)dest,
(const void *)table);
}
}
String ImmutableIndex::GetBucketLabel(Int64 peer, Int32 index)
{
NATIVE(AlphabeticIndex::ImmutableIndex)* ii = immutableIndexFromPeer(peer);
// TODO: There is a problem here. Waiting for new .so files.
#if 0 // for compiling
const NATIVE(AlphabeticIndex::Bucket)* bucket = ii->getBucket(index);
if(NULL == bucket) {
return String(NULL);
}
// Return "" for the underflow/inflow/overflow buckets.
if (bucket->getLabelType() != U_ALPHAINDEX_NORMAL) {
return String("");
}
const UnicodeString& label(bucket->getLabel());
String s;
ElStringByteSink sink(&s);
label.toUTF8(sink);
return s;
#else
assert(0);
return String(NULL);
#endif
}
Int32 ImmutableIndex::GetBucketCount(Int64 peer)
{
NATIVE(AlphabeticIndex::ImmutableIndex)* ii = immutableIndexFromPeer(peer);
// TODO: There is a problem here. Waiting for new .so files.
#if 0 // for compiling
return ii->getBucketCount();
#else
assert(0);
return 0;
#endif
}
static VALUE
undefine_final(VALUE os, SEL sel, VALUE obj)
{
if (__os_finalizers != NULL)
CFDictionaryRemoveValue(__os_finalizers, (const void *)obj);
if (NATIVE(obj)) {
rb_objc_flag_set((void *)obj, FL_FINALIZE, false);
}
else {
FL_UNSET(obj, FL_FINALIZE);
}
return obj;
}
Int32 ImmutableIndex::GetBucketIndex(Int64 peer, const String& s)
{
NATIVE(AlphabeticIndex::ImmutableIndex)* ii = immutableIndexFromPeer(peer);
if(s.IsNull())
return -1;
UErrorCode status = U_ZERO_ERROR;
// TODO: There is a problem here. Waiting for new .so files.
#if 0 // for compiling
Int32 result = ii->getBucketIndex(UnicodeString::fromUTF8(s.string()), status);
if(!U_SUCCESS(status))
return -1;
return result;
#else
assert(0);
return 0;
#endif
}
static VALUE
define_final(VALUE os, SEL sel, int argc, VALUE *argv)
{
VALUE obj, block, table;
if (__os_finalizers == NULL)
__os_finalizers = CFDictionaryCreateMutable(NULL, 0, NULL,
&kCFTypeDictionaryValueCallBacks);
rb_scan_args(argc, argv, "11", &obj, &block);
if (argc == 1) {
block = rb_block_proc();
}
else if (!rb_respond_to(block, rb_intern("call"))) {
rb_raise(rb_eArgError, "wrong type argument %s (should be callable)",
rb_obj_classname(block));
}
table = (VALUE)CFDictionaryGetValue((CFDictionaryRef)__os_finalizers,
(const void *)obj);
if (table == 0) {
table = rb_ary_new();
CFDictionarySetValue(__os_finalizers, (const void *)obj,
(const void *)table);
}
rb_ary_push(table, block);
if (NATIVE(obj)) {
rb_objc_flag_set((void *)obj, FL_FINALIZE, true);
}
else {
FL_SET(obj, FL_FINALIZE);
}
VALUE ret = rb_ary_new3(2, INT2FIX(rb_safe_level()), block);
OBJ_FREEZE(ret);
return ret;
}
static void
rb_obj_imp_finalize(void *obj, SEL sel)
{
#if 0
// const bool need_protection =
// GET_THREAD()->thread_id != pthread_self();
bool call_finalize, free_ivar;
if (NATIVE((VALUE)obj)) {
long flag;
flag = rb_objc_remove_flags(obj);
call_finalize = (flag & FL_FINALIZE) == FL_FINALIZE;
free_ivar = (flag & FL_EXIVAR) == FL_EXIVAR;
}
else {
call_finalize = FL_TEST(obj, FL_FINALIZE);
free_ivar = FL_TEST(obj, FL_EXIVAR);
}
if (call_finalize || free_ivar) {
// if (need_protection) {
// native_mutex_lock(&GET_THREAD()->vm->global_interpreter_lock);
// }
if (call_finalize) {
rb_call_os_finalizer(obj);
}
if (free_ivar) {
rb_free_generic_ivar((VALUE)obj);
}
// if (need_protection) {
// native_mutex_unlock(&GET_THREAD()->vm->global_interpreter_lock);
// }
}
#endif
}
QWidget::QWidget()
: NativeInheritWrapper()
{
}
QWidget::QWidget(QWidget^ parent)
: NativeInheritWrapper(init<NATIVE(QWidget)>(parent))
{
}
QWidget::QWidget(QWidget^ parent, WindowType f)
: NativeInheritWrapper(init<NATIVE(QWidget)>(parent, f))
{
}
QWidget::QWidget(NATIVE(QWidget)* native)
: NativeInheritWrapper(native)
{
}
QWidget::QWidget(NATIVE(QWidget)& native)
: NativeInheritWrapper(native)
{
}
QN_STR^ QWidget::WindowTitle::get()
{
return gcnew QN_STR(ref().windowTitle());
}
void QWidget::WindowTitle::set(QN_STR^ val)
//cannot use static here!!
cell_t W3ExtShowShop2(IPluginContext *pCtx, const cell_t *params)
{
cell_t client=params[1];
//ERR("in");
static bool once=true;
if(!g->helperVerifiedIntegrity){
ERR("Shop2: helper not verified");
EXTChatMessage(client,"ERROR: helper not verified. Contact server owner.");
return 0;
}
if(once){
ERR("Shop2: helper OK");
}
clienttotranslatecached=client;
IMenuStyle *style=g->imenus->GetDefaultStyle();
if(once){
ERR("Shop2: Style OK");
}
//MyMenuHandler *handler=new MyMenuHandler(); //extens IMenuHandler without any implementation for now
static Shopmenu2Handler *myhandler=new Shopmenu2Handler();
if(once){ ERR("Shop2: Handler OK"); }
IBaseMenu *basemenu=style->CreateMenu(myhandler );
if(once){ ERR("Shop2: CreateMenu OK"); }
char buffer[1000];
void* param2[7];
param2[0]=(void*)"[War3Source] Select an item to buy. You have {amount}/{amount} items";
param2[1]=&client;
cell_t dum=(NATIVE("GetClientItems2Owned",client));
param2[2]=&dum;
cell_t dum2=ITEMS2CANHAVE;
param2[3]=&dum2;
param2[4]=(void*)"You have {amount} Diamonds";
param2[5]=&client;
if(once){ ERR("Shop2: before GetDiamonds OK"); }
cell_t dum3=GetDiamonds(client);
if(once){ ERR("Shop2: after GetDiamonds OK"); }
param2[6]=&dum3;
size_t dummy;
char* failedchar=NULL;
if(shopitem2count<1){
ERR("item2 count <1");
}
if(!g->myphrasecollection->FormatString(buffer,sizeof(buffer),"%T",param2,4,&dummy,(const char**)&failedchar)){
ERR("1trans failed %s",failedchar);
}
char buffer2[512];
if(!g->myphrasecollection->FormatString(buffer2,sizeof(buffer2),"%T",param2+4,3,&dummy,(const char**)&failedchar)){
ERR("2trans failed %s",failedchar);
}
char title[512];
FORMAT(title,sizeof(title),"%s\n%s\n",buffer,buffer2);
//ERR("%s",title);
basemenu->SetDefaultTitle(title);
for(int i=1;i<=shopitem2count;i++){
GetItem(i);
FORMAT(buffer,sizeof(buffer),"%s%s %d",GetOwnsItem(client,item->itemid)?">":"",item->name(),item->cost()); //itemid
ItemDrawInfo mydrawinfo(buffer); //dies on stack
if(GetOwnsItem(client,item->itemid)||GetDiamonds(client)<item->cost()){
mydrawinfo.style=ITEMDRAW_DISABLED;
}
basemenu->AppendItem(item->itemidstr,mydrawinfo);
}
if(once){ ERR("Shop2: before Display OK"); }
//ERR("1 %d %d",client,shopitem2count);
basemenu->Display(client,0);
if(once){ ERR("Shop2: Displayed OK"); }
//ERR("2");*/
once=false;
return 0;
}
once=false;
}
void Shopmenu2Handler::OnMenuDestroy(IBaseMenu *menu)
{
static bool once=true;
if(once) ERR("OnMenuDestroy called");
once=false;
}
#ifdef failed
//public does not work, vformat gets wrong cell values
IPluginFunction *publicfunc= g->helperplugin->GetRuntime()->GetFunctionByName("myvformat");
cell_t own=NATIVE("GetClientItemsOwned",client);
cell_t max=NATIVE("GetMaxShopitemsPerPlayer");
publicfunc->PushStringEx(buffer,sizeof(buffer),0,SM_PARAM_COPYBACK);
publicfunc->PushCell(sizeof(buffer));
publicfunc->PushString("%T");
publicfunc->PushString("[War3Source] Select an item to buy. You have {amount}/{amount} items");
publicfunc->PushCell(0);
publicfunc->PushCell(own);
publicfunc->PushCell(max);
publicfunc->Execute(&result);
ERR("%s",buffer);
#endif
void wrenInitializeCore(WrenVM* vm)
{
// Define the root Object class. This has to be done a little specially
// because it has no superclass and an unusual metaclass (Class).
vm->objectClass = defineSingleClass(vm, "Object");
NATIVE(vm->objectClass, "== ", object_eqeq);
NATIVE(vm->objectClass, "!= ", object_bangeq);
NATIVE(vm->objectClass, "new", object_new);
NATIVE(vm->objectClass, "toString", object_toString);
NATIVE(vm->objectClass, "type", object_type);
NATIVE(vm->objectClass, " instantiate", object_instantiate);
// Now we can define Class, which is a subclass of Object, but Object's
// metaclass.
vm->classClass = defineSingleClass(vm, "Class");
// Now that Object and Class are defined, we can wire them up to each other.
wrenBindSuperclass(vm, vm->classClass, vm->objectClass);
vm->objectClass->metaclass = vm->classClass;
vm->classClass->metaclass = vm->classClass;
// Define the methods specific to Class after wiring up its superclass to
// prevent the inherited ones from overwriting them.
NATIVE(vm->classClass, " instantiate", class_instantiate);
NATIVE(vm->classClass, "name", class_name);
// The core class diagram ends up looking like this, where single lines point
// to a class's superclass, and double lines point to its metaclass:
//
// __________ /====\
// / \ // \\
// v \ v \\
// .---------. .--------------. //
// | Object |==>| Class |==/
// '---------' '--------------'
// ^ ^
// | |
// .---------. .--------------. \
// | Base |==>| Base.type | |
// '---------' '--------------' |
// ^ ^ | Hypothetical example classes
// | | |
// .---------. .--------------. |
// | Derived |==>| Derived.type | |
// '---------' '--------------' /
// The rest of the classes can not be defined normally.
vm->boolClass = defineClass(vm, "Bool");
NATIVE(vm->boolClass, "toString", bool_toString);
NATIVE(vm->boolClass, "!", bool_not);
// TODO: Make fibers inherit Sequence and be iterable.
vm->fiberClass = defineClass(vm, "Fiber");
NATIVE(vm->fiberClass->metaclass, " instantiate", fiber_instantiate);
NATIVE(vm->fiberClass->metaclass, "new ", fiber_new);
NATIVE(vm->fiberClass->metaclass, "yield", fiber_yield);
NATIVE(vm->fiberClass->metaclass, "yield ", fiber_yield1);
NATIVE(vm->fiberClass, "call", fiber_call);
NATIVE(vm->fiberClass, "call ", fiber_call1);
NATIVE(vm->fiberClass, "isDone", fiber_isDone);
NATIVE(vm->fiberClass, "run", fiber_run);
NATIVE(vm->fiberClass, "run ", fiber_run1);
vm->fnClass = defineClass(vm, "Fn");
NATIVE(vm->fnClass->metaclass, " instantiate", fn_instantiate);
NATIVE(vm->fnClass->metaclass, "new ", fn_new);
NATIVE(vm->fnClass, "call", fn_call0);
NATIVE(vm->fnClass, "call ", fn_call1);
NATIVE(vm->fnClass, "call ", fn_call2);
NATIVE(vm->fnClass, "call ", fn_call3);
NATIVE(vm->fnClass, "call ", fn_call4);
NATIVE(vm->fnClass, "call ", fn_call5);
NATIVE(vm->fnClass, "call ", fn_call6);
NATIVE(vm->fnClass, "call ", fn_call7);
NATIVE(vm->fnClass, "call ", fn_call8);
NATIVE(vm->fnClass, "call ", fn_call9);
NATIVE(vm->fnClass, "call ", fn_call10);
NATIVE(vm->fnClass, "call ", fn_call11);
NATIVE(vm->fnClass, "call ", fn_call12);
NATIVE(vm->fnClass, "call ", fn_call13);
NATIVE(vm->fnClass, "call ", fn_call14);
NATIVE(vm->fnClass, "call ", fn_call15);
NATIVE(vm->fnClass, "call ", fn_call16);
NATIVE(vm->fnClass, "toString", fn_toString);
vm->nullClass = defineClass(vm, "Null");
NATIVE(vm->nullClass, "toString", null_toString);
vm->numClass = defineClass(vm, "Num");
NATIVE(vm->numClass, "abs", num_abs);
NATIVE(vm->numClass, "ceil", num_ceil);
NATIVE(vm->numClass, "cos", num_cos);
NATIVE(vm->numClass, "floor", num_floor);
NATIVE(vm->numClass, "isNan", num_isNan);
NATIVE(vm->numClass, "sin", num_sin);
NATIVE(vm->numClass, "sqrt", num_sqrt);
NATIVE(vm->numClass, "toString", num_toString)
NATIVE(vm->numClass, "-", num_negate);
NATIVE(vm->numClass, "- ", num_minus);
NATIVE(vm->numClass, "+ ", num_plus);
NATIVE(vm->numClass, "* ", num_multiply);
NATIVE(vm->numClass, "/ ", num_divide);
NATIVE(vm->numClass, "% ", num_mod);
NATIVE(vm->numClass, "< ", num_lt);
NATIVE(vm->numClass, "> ", num_gt);
NATIVE(vm->numClass, "<= ", num_lte);
NATIVE(vm->numClass, ">= ", num_gte);
NATIVE(vm->numClass, "~", num_bitwiseNot);
NATIVE(vm->numClass, "& ", num_bitwiseAnd);
NATIVE(vm->numClass, "| ", num_bitwiseOr);
NATIVE(vm->numClass, ".. ", num_dotDot);
NATIVE(vm->numClass, "... ", num_dotDotDot);
vm->stringClass = defineClass(vm, "String");
NATIVE(vm->stringClass, "contains ", string_contains);
NATIVE(vm->stringClass, "count", string_count);
NATIVE(vm->stringClass, "toString", string_toString)
NATIVE(vm->stringClass, "+ ", string_plus);
NATIVE(vm->stringClass, "== ", string_eqeq);
NATIVE(vm->stringClass, "!= ", string_bangeq);
NATIVE(vm->stringClass, "[ ]", string_subscript);
wrenInterpret(vm, "Wren core library", libSource);
vm->listClass = AS_CLASS(findGlobal(vm, "List"));
NATIVE(vm->listClass->metaclass, " instantiate", list_instantiate);
NATIVE(vm->listClass, "add ", list_add);
NATIVE(vm->listClass, "clear", list_clear);
NATIVE(vm->listClass, "count", list_count);
NATIVE(vm->listClass, "insert ", list_insert);
NATIVE(vm->listClass, "iterate ", list_iterate);
NATIVE(vm->listClass, "iteratorValue ", list_iteratorValue);
NATIVE(vm->listClass, "removeAt ", list_removeAt);
NATIVE(vm->listClass, "[ ]", list_subscript);
NATIVE(vm->listClass, "[ ]=", list_subscriptSetter);
vm->rangeClass = AS_CLASS(findGlobal(vm, "Range"));
NATIVE(vm->rangeClass, "from", range_from);
NATIVE(vm->rangeClass, "to", range_to);
NATIVE(vm->rangeClass, "min", range_min);
NATIVE(vm->rangeClass, "max", range_max);
NATIVE(vm->rangeClass, "isInclusive", range_isInclusive);
NATIVE(vm->rangeClass, "iterate ", range_iterate);
NATIVE(vm->rangeClass, "iteratorValue ", range_iteratorValue);
NATIVE(vm->rangeClass, "toString", range_toString);
// These are defined just so that 0 and -0 are equal, which is specified by
// IEEE 754 even though they have different bit representations.
NATIVE(vm->numClass, "== ", num_eqeq);
NATIVE(vm->numClass, "!= ", num_bangeq);
}
