//===--------------- PNetLib.cpp - PNetLib interface ----------------------===// // // N3 // // This file is distributed under the University of Illinois Open Source // License with the following additions: // // Copyright (C) 2001, 2002, 2003 Southern Storm Software, Pty Ltd. // // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include #include #include #include "mvm/JIT.h" #include "Assembly.h" #include "CLIAccess.h" #include "CLIJit.h" #include "PNetString.h" #include "NativeUtil.h" #include "MSCorlib.h" #include "N3.h" #include "PNetLib.h" #include "Reader.h" #include "VMArray.h" #include "VMClass.h" #include "VMObject.h" #include "VMThread.h" #include "CLIString.h" #include "PNetPath.inc" #include "llvm/LLVMContext.h" using namespace n3; #define IL_CONSOLE_NORMAL 0 #define MEMBER_TYPES_CONSTRUCTOR 0x1 #define MEMBER_TYPES_EVENT 0x2 #define MEMBER_TYPES_FIELD 0x4 #define MEMBER_TYPES_METHOD 0x8 #define MEMBER_TYPES_PROPERTY 0x10 #define MEMBER_TYPES_TYPEINFO 0x20 #define MEMBER_TYPES_CUSTOM 0x40 #define MEMBER_TYPES_NESTEDTYPE 0x80 #define MEMBER_TYPES_ALL 0xBF #define METHOD_SEMANTIC_ATTRIBUTES_SETTER 0x1 #define METHOD_SEMANTIC_ATTRIBUTES_GETTER 0x2 #define METHOD_SEMANTIC_ATTRIBUTES_OTHER 0x4 #define METHOD_SEMANTIC_ATTRIBUTES_ADDON 0x8 #define METHOD_SEMANTIC_ATTRIBUTES_REMOVEON 0x10 #define METHOD_SEMANTIC_ATTRIBUTES_FIRE 0x20 extern "C" { extern uint32 ILGetCodePage(void); extern uint32 ILGetCultureID(void); extern char* ILGetCultureName(void); extern sint32 ILAnsiGetMaxByteCount(sint32); extern sint32 ILConsoleWriteChar(sint32); extern uint32 ILConsoleGetMode(void); extern sint32 ILAnsiGetBytes(uint16*, sint32, uint8*, sint32); extern void _IL_Stdio_StdFlush(void*, sint32); extern char ILGetUnicodeCategory(sint32); extern sint64 _IL_TimeMethods_GetCurrentTime(void*); extern uint32 ILUnicodeStringToLower(void*, void*, uint32); extern sint32 ILUnicodeStringCompareIgnoreCase(void*, void*, sint32); extern sint32 ILUnicodeStringCompareNoIgnoreCase(void*, void*, sint32); #include "mvm/Config/config.h" // PNET wants this void *GC_run_thread(void *(*thread_func)(void *), void *arg){ return 0; } #if not(USE_GC_BOEHM) int GC_invoke_finalizers (void) { return 0; } int GC_should_invoke_finalizers (void) { return 0; } void GC_register_finalizer_no_order(void*, void (*)(void*, void*), void*, void (**)(void*, void*), void**) { return; } void GC_gcollect(void) {} void* GC_malloc_uncollectable(size_t) { return 0; } void GC_exclude_static_roots(void*, void*) {} void GC_free(void*) {} void GC_malloc_explicitly_typed(void) {} size_t GC_get_heap_size(void) {return 0;} int GC_register_disappearing_link(void**) { return 0; } int GC_general_register_disappearing_link(void**, void*) { return 0; } int GC_pthread_sigmask(int, const sigset_t*, sigset_t*) { return 0; } int GC_pthread_detach(pthread_t) { return 0; } int GC_pthread_create(pthread_t*, const pthread_attr_t*, void* (*)(void*), void*) { return 0; } void* GC_malloc(size_t) { return 0; } void GC_make_descriptor(void) {} int GC_unregister_disappearing_link(void**) { return 0; } void (*GC_finalizer_notifier)(void); int GC_java_finalization; int GC_finalize_on_demand; void GC_set_max_heap_size(size_t) {} void* GC_malloc_atomic(size_t) { return 0; } #endif // Fake termcap symbols void tigetstr(void) { abort(); } void tgetstr(void) { abort(); } void setupterm(void) { abort(); } void tigetnum(void) { abort(); } void tgetnum(void) { abort(); } void tigetflag(void) { abort(); } void tparm(void) { abort(); } void tgetent(void) { abort(); } void tputs(void) { abort(); } void tgoto(void) { abort(); } void tgetflag(void) { abort(); } } extern "C" uint32 System_Text_DefaultEncoding_InternalCodePage() { return ILGetCodePage(); } extern "C" uint32 System_Globalization_CultureInfo_InternalCultureID() { return ILGetCultureID(); } extern "C" VMObject* System_Globalization_CultureInfo_InternalCultureName() { char* val = ILGetCultureName(); N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(ArrayChar*, array) = 0; if (val) { array = vm->asciizToArray(val); free(val); } else { array = vm->asciizToArray("iv"); } declare_gcroot(VMObject*, res) = vm->arrayToString(array); return res; } static const ArrayChar* newBuilder(N3* vm, PNetString* value, uint32 length) { llvm_gcroot(value, 0); uint32 valueLength = value ? value->length : 0; declare_gcroot(const ArrayChar*, array) = value ? value->value : 0; uint32 roundLength = (7 + length) & 0xfffffff8; uint16* buf = (uint16*)alloca(roundLength * sizeof(uint16)); uint32 strLength = 0; if (value != 0) { if (valueLength <= roundLength) { memcpy(buf, array->elements, valueLength * sizeof(uint16)); strLength = valueLength; } else { memcpy(buf, array->elements, roundLength * sizeof(uint16)); strLength = roundLength; } } declare_gcroot(ArrayChar*, array_res) = vm->bufToArray(buf, strLength); return array_res; } extern "C" VMObject* System_String_NewBuilder(PNetString* value, uint32 length) { llvm_gcroot(value, 0); N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(PNetString*, str) = (PNetString*)vm->arrayToString(newBuilder(vm, value, length)); return str; } extern "C" VMObject* Platform_SysCharInfo_GetNewLine() { N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(ArrayChar*, array) = vm->asciizToArray("\n"); declare_gcroot(VMObject*, res) = vm->arrayToString(array); return res; } extern "C" void System_String_CopyToChecked(PNetString* str, sint32 sstart, ArrayChar* dest, sint32 dstart, sint32 count) { llvm_gcroot(str, 0); llvm_gcroot(dest, 0); declare_gcroot(const ArrayChar*, value) = str->value; memcpy(&dest->elements[dstart], &value->elements[sstart], count << 1); } extern "C" sint32 System_Text_DefaultEncoding_InternalGetMaxByteCount(sint32 val) { return ILAnsiGetMaxByteCount(val); } extern "C" void Platform_Stdio_StdWrite(sint32 fd, ArrayUInt8* value, sint32 index, sint32 count) { llvm_gcroot(value, 0); if (fd == 1) { if (ILConsoleGetMode() == IL_CONSOLE_NORMAL) { fwrite(&value->elements[index], 1, count, stdout); } else { char* buf = (char*)(&value->elements[index]); while (count > 0) { ILConsoleWriteChar(*buf); ++buf; --count; } fflush(stdout); } } else { fwrite(&value->elements[index], 1, count, stderr); } } extern "C" sint32 System_Text_DefaultEncoding_InternalGetBytes(ArrayChar* chars, sint32 charIndex, sint32 charCount, ArrayUInt8* bytes, sint32 byteIndex) { llvm_gcroot(chars, 0); llvm_gcroot(bytes, 0); return ILAnsiGetBytes(&chars->elements[charIndex], charCount, &bytes->elements[byteIndex], bytes->size - byteIndex); } extern "C" void Platform_Stdio_StdFlush(sint32 fd) { _IL_Stdio_StdFlush(0, fd); } extern "C" VMObject* System_Reflection_ClrType_GetElementType(VMObject* Klass) { llvm_gcroot(Klass, 0); VMCommonClass* cl = (VMCommonClass*)MSCorlib::typeClrType->getIntPtr(Klass); if (!cl->isArray) { VMThread::get()->getVM()->error("implement me"); return 0; } else { declare_gcroot(VMObject *, delegatee) = ((VMClassArray*)cl)->baseClass->getClassDelegatee(); return delegatee; } } extern "C" PNetString* System_String_NewString(uint32 size) { declare_gcroot(PNetString*, str) = (PNetString*)MSCorlib::pString->doNew(); str->length = size; return str; } extern "C" void System_String_Copy_3(PNetString* dest, sint32 pos, PNetString* src) { llvm_gcroot(dest, 0); llvm_gcroot(src, 0); declare_gcroot(ArrayChar*, arr) = (ArrayChar*)MSCorlib::arrayChar->doNew(pos + src->value->size); for (sint32 i = 0; i < pos; ++i) { arr->elements[i] = dest->value->elements[i]; } for (sint32 i = 0; i < src->length; ++i) { arr->elements[pos + i] = src->value->elements[i]; } dest->value = arr; dest->length = dest->value->size; } extern "C" void System_String_Copy_5(PNetString* dest, sint32 destPos, PNetString* src, sint32 srcPos, sint32 length) { llvm_gcroot(dest, 0); llvm_gcroot(src, 0); declare_gcroot(const ArrayChar*, arraySrc) = src->value; // printf("Copy %p %p %d %d %d (%p %d)\n", (void *)dest, (void *)src, destPos, srcPos, length, (void *)dest->value, dest->length); if(destPos == 0 && srcPos == 0 && length == src->length) { dest->value = arraySrc; dest->length = length; } else { sint32 top = destPos + length; uint16 *buf = (uint16*)alloca((top < dest->length ? dest->length : top) * sizeof(uint16)); if(destPos) memcpy(buf, dest->value->elements, destPos * sizeof(uint16)); memcpy(buf + destPos, src->value->elements + srcPos, length * sizeof(uint16)); if(top <= dest->length) memcpy(buf + top, dest->value->elements + top, (dest->length - top) * sizeof(uint16)); else dest->length = top; declare_gcroot(ArrayChar*, array) = VMThread::get()->getVM()->bufToArray(buf, dest->length); dest->value = array; } // printf("---> %s\n", mvm::PrintBuffer(VMThread::get()->getVM()->arrayToUTF8(dest->value)).cString()); } extern "C" void System_Threading_Monitor_Enter(VMObject* obj) { llvm_gcroot(obj, 0); // obj->aquire(); } extern "C" void System_Threading_Monitor_Exit(VMObject* obj) { llvm_gcroot(obj, 0); // obj->unlock(); } extern "C" bool System_String_Equals(PNetString* str1, PNetString* str2) { llvm_gcroot(str1, 0); llvm_gcroot(str2, 0); declare_gcroot(const ArrayChar*, a1) = str1->value; declare_gcroot(const ArrayChar*, a2) = str2->value; return a1 == a2; } extern "C" sint32 Platform_SysCharInfo_GetUnicodeCategory(char c) { return ILGetUnicodeCategory(c); } extern "C" uint16 System_String_GetChar(PNetString* str, sint32 index) { llvm_gcroot(str, 0); return str->value->elements[index]; } extern "C" sint32 System_String_IndexOf(PNetString* str, uint16 value, sint32 startIndex, sint32 count) { llvm_gcroot(str, 0); if (startIndex < 0) { VMThread::get()->getVM()->error("shoud throw arg range"); } if ((count < 0) || (str->length - startIndex < count)) { VMThread::get()->getVM()->error("shoud throw arg range"); } sint32 i = startIndex; declare_gcroot(const ArrayChar*, array) = str->value; while (i < startIndex + count) { if (array->elements[i] == value) return i; else ++i; } return -1; } extern "C" sint32 System_String_GetHashCode(PNetString* str) { llvm_gcroot(str, 0); sint32 hash = 0; declare_gcroot(const ArrayChar*, array) = str->value; for (sint32 i = 0; i < array->size; ++i) { hash += ((hash << 5) + array->elements[i]); } return hash; } extern "C" VMObject* System_Text_StringBuilder_Insert_System_Text_StringBuilder_System_Int32_System_Char( StringBuilder* obj, sint32 index, uint16 value) { llvm_gcroot(obj, 0); N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(PNetString*, buildString) = obj->buildString; declare_gcroot(const ArrayChar*, array) = buildString->value; sint32 strLength = buildString->length; sint32 length = (index + 1) > strLength ? index + 1 : strLength + 1; uint16* buf = (uint16*)alloca(length * sizeof(uint16)); if (index != 0) { memcpy(buf, array->elements, index * sizeof(uint16)); } if (strLength > index) { memcpy(&(buf[index + 1]), &(array->elements[index]), (strLength - index) * sizeof(uint16)); } buf[index] = value; declare_gcroot(ArrayChar*, array_res) = vm->bufToArray(buf, length); declare_gcroot(PNetString*, str) = (PNetString*)vm->arrayToString(array_res); obj->buildString = str; return obj; } extern "C" VMObject* System_Text_StringBuilder_Insert_System_Text_StringBuilder_System_Int32_System_String( StringBuilder* obj, sint32 index, PNetString* str) { llvm_gcroot(obj, 0); llvm_gcroot(str, 0); N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(PNetString*, buildString) = obj->buildString; declare_gcroot(const ArrayChar*, strArray) = str->value; declare_gcroot(const ArrayChar*, buildArray) = buildString->value; sint32 strLength = str->length; sint32 buildLength = buildString->length; sint32 length = strLength + buildLength; uint16* buf = (uint16*)alloca(length * sizeof(uint16)); if (index != 0) { memcpy(buf, buildArray->elements, index * sizeof(uint16)); } if (strLength != 0) { memcpy(&(buf[index]), strArray->elements, strLength * sizeof(uint16)); } if (buildLength - index > 0) { memcpy(&(buf[strLength + index]), &(buildArray->elements[index]), (buildLength - index) * sizeof(uint16)); } declare_gcroot(ArrayChar*, array_res) = vm->bufToArray(buf, length); declare_gcroot(PNetString*, val) = (PNetString*)vm->arrayToString(array_res); obj->buildString = val; return obj; } extern "C" VMObject* System_Text_StringBuilder_Append_System_Text_StringBuilder_System_Char( StringBuilder* obj, uint16 value) { llvm_gcroot(obj, 0); N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(PNetString*, buildString) = obj->buildString; declare_gcroot(const ArrayChar*, array) = buildString->value; sint32 length = buildString->length; uint16* buf = (uint16*)alloca((length + 1) * sizeof(uint16)); memcpy(buf, array->elements, length * sizeof(uint16)); buf[length] = value; declare_gcroot(ArrayChar*, array_res) = vm->bufToArray(buf, length + 1); declare_gcroot(PNetString*, val) = (PNetString*)vm->arrayToString(array_res); obj->buildString = val; return obj; } extern "C" VMObject* System_Text_StringBuilder_Append_System_Text_StringBuilder_System_String( StringBuilder* obj, PNetString* str) { llvm_gcroot(obj, 0); llvm_gcroot(str, 0); N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(PNetString*, buildString) = obj->buildString; declare_gcroot(const ArrayChar*, buildArray) = buildString->value; declare_gcroot(const ArrayChar*, strArray) = str->value; sint32 buildLength = buildString->length; sint32 strLength = str->length; sint32 length = buildLength + strLength; uint16* buf = (uint16*)alloca(length * sizeof(uint16)); memcpy(buf, buildArray->elements, buildLength * sizeof(uint16)); memcpy(&(buf[buildLength]), strArray->elements, strLength * sizeof(uint16)); declare_gcroot(ArrayChar*, array_res) = vm->bufToArray(buf, length); declare_gcroot(PNetString*, val) = (PNetString*)vm->arrayToString(array_res); obj->buildString = val; return obj; } extern "C" sint32 System_String_FindInRange(PNetString* obj, sint32 srcFirst, sint32 srcLast, sint32 step, PNetString* dest) { llvm_gcroot(obj, 0); llvm_gcroot(dest, 0); uint16* buf1 = (uint16*)&(obj->value->elements[srcFirst]); uint16* buf2 = (uint16*)(dest->value->elements); sint32 destLength = dest->length; sint32 size = destLength * sizeof(uint16); if (step > 0) { if (destLength == 1) { while (srcFirst <= srcLast) { if (buf1[0] == buf2[0]) { return srcFirst; } else { buf1 = &(buf1[1]); ++srcFirst; } } } else { while (srcFirst <= srcLast) { if ((buf1[0] == buf2[0]) && !memcmp(buf1, buf2, size)) { return srcFirst; } else { buf1 = &(buf1[1]); ++srcFirst; } } } } else { if (destLength == 1) { while (srcFirst >= srcLast) { if (buf1[0] == buf2[0]) { return srcFirst; } else { buf1 = buf1 - 1; --srcFirst; } } } else { while (srcFirst >= srcLast) { if ((buf1[0] == buf2[0]) && !memcmp(buf1, buf2, size)) { return srcFirst; } else { buf1 = buf1 - 1; --srcFirst; } } } } return -1; } extern "C" VMObject* System_Reflection_Assembly_LoadFromName(PNetString* str, sint32 & error, VMObject* parent) { llvm_gcroot(str, 0); llvm_gcroot(parent, 0); N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(const ArrayChar*, value) = str->value; Assembly* ass = vm->constructAssembly(vm->arrayToUTF8(value)); if(!ass->resolve(1, "dll")) vm->error("unfound assembly %s\n", mvm::PrintBuffer(value).cString()); error = 0; declare_gcroot(VMObject*, delegatee) = ass->getAssemblyDelegatee(); return delegatee; } extern "C" PNetString* System_String_Concat_2(PNetString* str1, PNetString* str2) { llvm_gcroot(str1, 0); llvm_gcroot(str2, 0); N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(const ArrayChar*, a1) = str1->value; declare_gcroot(const ArrayChar*, a2) = str2->value; sint32 len1 = str1->length; sint32 len2 = str2->length; uint16* buf = (uint16*)alloca((len1 + len2) * sizeof(uint16)); memcpy(buf, a1->elements, len1 * sizeof(uint16)); memcpy(&(buf[len1]), a2->elements, len2 * sizeof(uint16)); declare_gcroot(ArrayChar*, array_res) = vm->bufToArray(buf, len1 + len2); declare_gcroot(PNetString*, val) = (PNetString*)vm->arrayToString(array_res); return val; } extern "C" PNetString* System_String_Concat_3(PNetString* str1, PNetString* str2, PNetString* str3) { llvm_gcroot(str1, 0); llvm_gcroot(str2, 0); llvm_gcroot(str3, 0); N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(const ArrayChar*, a1) = str1->value; declare_gcroot(const ArrayChar*, a2) = str2->value; declare_gcroot(const ArrayChar*, a3) = str3->value; sint32 len1 = str1->length; sint32 len2 = str2->length; sint32 len3 = str3->length; uint16* buf = (uint16*)alloca((len1 + len2 + len3) * sizeof(uint16)); memcpy(buf, a1->elements, len1 * sizeof(uint16)); memcpy(&(buf[len1]), a2->elements, len2 * sizeof(uint16)); memcpy(&(buf[len1 + len2]), a3->elements, len3 * sizeof(uint16)); declare_gcroot(ArrayChar*, array_res) = vm->bufToArray(buf, len1 + len2 + len3); declare_gcroot(PNetString*, val) = (PNetString*)vm->arrayToString(array_res); return val; } extern "C" void System_String_RemoveSpace(PNetString* str, sint32 index, sint32 length) { llvm_gcroot(str, 0); declare_gcroot(const ArrayChar*, array) = str->value; sint32 strLength = str->length; uint16* buf = (uint16*)alloca(strLength * sizeof(uint16)); sint32 j = index; if (index != 0) { memcpy(buf, array->elements, index * sizeof(uint16)); } // 32 is space for (sint32 i = 0; i < length; ++i) { uint16 cur = array->elements[index + i]; if (cur != 32) { buf[j] = cur; } else { ++j; } } if (strLength > (index + length)) { memcpy(&(buf[j]), &(array->elements[index + length]), (strLength - (index + length)) * sizeof(uint16)); } declare_gcroot(const ArrayChar*, res) = VMThread::get()->getVM()->bufToArray(buf, j); str->value = res; str->length = j; } extern "C" void System_String__ctor_3(PNetString* str, uint16 ch, sint32 count) { llvm_gcroot(str, 0); declare_gcroot(ArrayChar*, array) = (ArrayChar*)MSCorlib::arrayChar->doNew(count); for (sint32 i = 0; i < count; ++i) { array->elements[i] = ch; } str->value = array; str->length = array->size; str->capacity = array->size; } extern "C" int64_t Platform_TimeMethods_GetCurrentTime() { return _IL_TimeMethods_GetCurrentTime(0); } #define ASSEMBLY_VALUE(obj) ((Assembly**)obj)[3] void* sys_memrchr(const void* s, int c, size_t n) { unsigned char* m = (unsigned char*) s + n; for (;;) { if (!(n--)) return NULL; else if (*m-- == (unsigned char)c) return (void*)(m+1); } } extern "C" VMObject* System_Reflection_Assembly_GetType(VMObject* obj, PNetString* str, bool onError, bool ignoreCase) { llvm_gcroot(obj, 0); llvm_gcroot(str, 0); Assembly* ass = ASSEMBLY_VALUE(obj); declare_gcroot(const ArrayChar*, array) = str->value; mvm::PrintBuffer pb(array); char* asciiz = pb.cString(); char* index = (char*)sys_memrchr(asciiz, '.', strlen(asciiz)); N3* vm = ass->vm; index[0] = 0; ++index; VMCommonClass* cl = ass->loadTypeFromName(vm->asciizToUTF8(index), vm->asciizToUTF8(asciiz), true, true, true, onError); if (!cl) VMThread::get()->getVM()->error("implement me"); declare_gcroot(VMObject *, delegatee) = cl->getClassDelegatee(); return delegatee; } static bool parameterMatch(std::vector params, ArrayObject* types, bool virt) { llvm_gcroot(types, 0); uint32 v = virt ? 1 : 0; if (types->size + v + 1 != params.size()) return false; for (sint32 i = 0; i < types->size; ++i) { VMCommonClass* cur = (VMCommonClass*)MSCorlib::typeClrType->getIntPtr(types->elements[i]); if (cur != params[i + 1 + v]) return false; } return true; } extern "C" VMObject* System_Reflection_ClrType_GetMemberImpl(VMObject* Type, PNetString* str, sint32 memberTypes, sint32 bindingFlags, VMObject* binder, sint32 callingConventions, ArrayObject* types, VMObject* modifiers) { llvm_gcroot(Type, 0); llvm_gcroot(str, 0); llvm_gcroot(binder, 0); llvm_gcroot(types, 0); llvm_gcroot(modifiers, 0); VMCommonClass* type = (VMCommonClass*)MSCorlib::typeClrType->getIntPtr(Type); N3* vm = (N3*)(VMThread::get()->getVM()); const UTF8* name = vm->arrayToUTF8(str->value); if (memberTypes == MEMBER_TYPES_PROPERTY) { std::vector > properties = type->properties; Property *res = 0; for (std::vector >::iterator i = properties.begin(), e = properties.end(); i!= e; ++i) { if ((*i)->name == name) { res = *i; break; } } if (res == 0) VMThread::get()->getVM()->error("implement me"); declare_gcroot(VMObject*, prop_res) = res->getPropertyDelegatee(); return prop_res; } else if (memberTypes == MEMBER_TYPES_METHOD) { std::vector virtualMethods = type->virtualMethods; std::vector staticMethods = type->staticMethods; for (std::vector::iterator i = virtualMethods.begin(), e = virtualMethods.end(); i!= e; ++i) { VMMethod* meth = *i; if (meth->name == name) { if (parameterMatch(meth->parameters, types, true)) { declare_gcroot(VMObject*, meth_res) = meth->getMethodDelegatee(); return meth_res; } } } for (std::vector::iterator i = staticMethods.begin(), e = staticMethods.end(); i!= e; ++i) { VMMethod* meth = *i; if (meth->name == name) { if (parameterMatch(meth->parameters, types, false)) { declare_gcroot(VMObject*, meth_res) = meth->getMethodDelegatee(); return meth_res; } } } } else { VMThread::get()->getVM()->error("implement me"); } return 0; } extern "C" VMObject* System_Reflection_ClrHelpers_GetSemantics(uintptr_t item, uint32 attributes, bool nonPublic) { if (attributes == METHOD_SEMANTIC_ATTRIBUTES_GETTER) { Property* prop = (Property*)item; mvm::PrintBuffer _asciiz(prop->name); const char* asciiz = _asciiz.cString(); char* buf = (char*)alloca(strlen(asciiz) + 5); sprintf(buf, "get_%s", asciiz); N3* vm = VMThread::get()->getVM(); VMMethod* meth = prop->type->lookupMethod(vm->asciizToUTF8(buf), prop->parameters, true, false); assert(meth); declare_gcroot(VMObject*, res) = meth->getMethodDelegatee(); return res; } else { VMThread::get()->getVM()->error("implement me: GetSemantics: %d", attributes); return 0; } } static void decapsulePrimitive(VMObject* arg, const llvm::Type* type, std::vector& args) { llvm_gcroot(arg, 0); if (type == llvm::Type::getInt1Ty(llvm::getGlobalContext())) { llvm::GenericValue gv; gv.IntVal = llvm::APInt(1, (bool)((uint32*)arg)[VALUE_OFFSET]); args.push_back(gv); } else if (type == llvm::Type::getInt8Ty(llvm::getGlobalContext())) { llvm::GenericValue gv; gv.IntVal = llvm::APInt(8, (uint8)((uint32*)arg)[VALUE_OFFSET]); args.push_back(gv); } else if (type == llvm::Type::getInt16Ty(llvm::getGlobalContext())) { llvm::GenericValue gv; gv.IntVal = llvm::APInt(16, (uint16)((uint32*)arg)[VALUE_OFFSET]); args.push_back(gv); } else if (type == llvm::Type::getInt32Ty(llvm::getGlobalContext())) { llvm::GenericValue gv; gv.IntVal = llvm::APInt(32, (uint32)((uint32*)arg)[VALUE_OFFSET]); args.push_back(gv); } else if (type == llvm::Type::getInt64Ty(llvm::getGlobalContext())) { llvm::GenericValue gv; uint32* ptr = &((uint32*)arg)[VALUE_OFFSET]; gv.IntVal = llvm::APInt(64, ((uint64*)ptr)[0]); args.push_back(gv); } else if (type == llvm::Type::getFloatTy(llvm::getGlobalContext())) { llvm::GenericValue gv; float* ptr = &((float*)arg)[VALUE_OFFSET]; gv.FloatVal = ((float*)ptr)[0]; args.push_back(gv); } else if (type == llvm::Type::getDoubleTy(llvm::getGlobalContext())) { llvm::GenericValue gv; uint32* ptr = &((uint32*)arg)[VALUE_OFFSET]; gv.DoubleVal = ((double*)ptr)[0]; args.push_back(gv); } else if (type == llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(llvm::getGlobalContext()))) { llvm::GenericValue gv(((void**)arg)[VALUE_OFFSET]); args.push_back(gv); } else { VMThread::get()->getVM()->error("implement me"); } } extern "C" VMObject* System_Reflection_ClrMethod_Invoke(VMObject* Method, VMObject* obj, sint32 invokeAttr, VMObject* binder, ArrayObject* args, VMObject* culture) { llvm_gcroot(Method, 0); llvm_gcroot(obj, 0); llvm_gcroot(binder, 0); llvm_gcroot(args, 0); llvm_gcroot(culture, 0); VMMethod* meth = (VMMethod*)MSCorlib::methodMethodType->getIntPtr(Method); meth->getSignature(NULL); meth->compiledPtr(NULL); llvm::Function* func = CLIJit::compile(meth->classDef, meth); VMClass* type = meth->classDef; type->resolveStatic(true, NULL); uint32 virt = meth->virt; if ((obj != 0) && virt) { if (!(obj->classOf->isAssignableFrom(type))) { VMThread::get()->getVM()->illegalArgumentException(mvm::PrintBuffer(meth->name).cString()); } verifyNull(obj); } std::vector gvargs; uint32 index = 0; llvm::Function::arg_iterator i = func->arg_begin(); llvm::Function::arg_iterator e = func->arg_end(); if (virt) { llvm::GenericValue gv(obj); gvargs.push_back(gv); ++i; } for ( ;i != e; ++i, ++index) { const llvm::Type* type = i->getType(); if (llvm::isa(type) && type != llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(llvm::getGlobalContext()))) { llvm::GenericValue gv(args->elements[index]); gvargs.push_back(gv); } else { decapsulePrimitive(args->elements[index], type, gvargs); } } llvm::GenericValue gv; try{ gv = meth->compileToNative()->invokeGeneric(gvargs); }catch(...) { assert(0); } declare_gcroot(VMObject*, res) = 0; VMCommonClass* retType = meth->parameters[0]; #define CONSTRUCT_RES(name, type, gv_extractor) \ else if(retType == MSCorlib::p##name) { \ res = MSCorlib::p##name->doNew(); \ MSCorlib::ctor##name->set##name(res, (type)gv.gv_extractor); \ } if (retType == MSCorlib::pVoid) { res = MSCorlib::pVoid->doNew(); } ON_PRIMITIVES(CONSTRUCT_RES, _F_NTE) else { if (retType->super == MSCorlib::pValue || retType->super == MSCorlib::pEnum) VMThread::get()->getVM()->error("implement me"); res = (VMObject*)gv.PointerVal; } return res; } static VMObject* createResourceStream(Assembly* ass, sint32 posn) { uint32 resSize = ass->resSize; uint32 resRva = ass->resRva; Section* textSection = ass->textSection; uint32 sectionLen = resSize; uint32 section = 0; uint32 start = 0; uint32 length = 0; uint32 pad = 0; Reader* reader = ass->newReader(ass->bytes); section = textSection->rawAddress + (resRva - textSection->virtualAddress); reader->seek(section, Reader::SeekSet); while (posn > 0) { if (sectionLen < 4) return 0; length = reader->readU4(); if (length > (sectionLen - 4)) return 0; if ((length % 4) != 0) { pad = 4 - (length % 4); } else { pad = 0; } start = start + length + pad + 4; section = section + length + pad + 4; reader->seek(section + length + pad + 4, Reader::SeekSet); sectionLen = sectionLen - (length + pad + 4); posn = posn - 1; } start = start + 4; if (sectionLen < 4) return 0; length = reader->readU4(); if (length > (sectionLen - 4)) return 0; declare_gcroot(VMObject*, res) = MSCorlib::resourceStreamType->doNew(); MSCorlib::ctorResourceStreamType->compileToNative()->invokeVoid(res, ass, (uint64)start, (uint64)length); return res; } extern "C" VMObject* System_Reflection_Assembly_GetManifestResourceStream(VMObject* Ass, PNetString* str) { llvm_gcroot(Ass, 0); llvm_gcroot(str, 0); Assembly* ass = (Assembly*)MSCorlib::assemblyAssemblyReflection->getIntPtr(Ass); N3* vm = (N3*)(VMThread::get()->getVM()); declare_gcroot(const ArrayChar*, array) = str->value; const UTF8* id = vm->arrayToUTF8(array); Header* header = ass->CLIHeader; uint32 stringOffset = header->stringStream->realOffset; Table* manTable = header->tables[CONSTANT_ManifestResource]; uint32 manRows = manTable->rowsNumber; sint32 pos = -1; uint32 i = 0; while ((pos == -1) && (i < manRows)) { uint32 nameOffset = manTable->readIndexInRow(i + 1, CONSTANT_MANIFEST_RESOURCE_NAME, ass->bytes); const UTF8* name = ass->readString(vm, stringOffset + nameOffset); if (name == id) { pos = i; } else { ++i; } } if (pos != -1) { declare_gcroot(VMObject*, res) = createResourceStream(ass, pos); return res; } else { return 0; } } extern "C" ArrayObject* System_Reflection_ClrHelpers_GetCustomAttributes(Assembly* ass, VMCommonClass* clrTypePrivate, bool inherit) { declare_gcroot(ArrayObject*, res) = ass->getCustomAttributes(clrTypePrivate->token, clrTypePrivate); return res; } extern "C" VMObject* System_Globalization_TextInfo_ToLower(VMObject* obj, PNetString* str) { llvm_gcroot(obj, 0); llvm_gcroot(str, 0); verifyNull(str); declare_gcroot(const ArrayChar*, array) = str->value; uint32 length = str->length; uint16* buf = (uint16*)alloca(length * sizeof(uint16)); N3* vm = VMThread::get()->getVM(); memcpy(buf, array->elements, length * sizeof(uint16)); ILUnicodeStringToLower((void*)buf, (void*)array->elements, length); declare_gcroot(const ArrayChar*, res) = vm->bufToArray(buf, length); declare_gcroot(VMObject*, res_str) = vm->arrayToString(res); return res_str; } extern "C" VMObject* System_String_Replace(PNetString* str, uint16 c1, uint16 c2) { llvm_gcroot(str, 0); declare_gcroot(const ArrayChar*, array) = str->value; uint32 length = str->length; if ((c1 == c2) || length == 0) return str; uint16* buf = (uint16*)alloca(length * sizeof(uint16)); memcpy(buf, array->elements, length * sizeof(uint16)); for (uint32 i = 0; i < length; ++i) { if (buf[i] == c1) buf[i] = c2; } N3* vm = (N3*)VMThread::get()->getVM(); declare_gcroot(const ArrayChar*, res) = vm->bufToArray(buf, length); declare_gcroot(VMObject*, res_str) = vm->arrayToString(res); return res_str; } extern "C" uint32 System_Reflection_ClrResourceStream_ResourceRead(Assembly* assembly, uint64 position, ArrayUInt8* buffer, uint32 offset, uint32 count) { llvm_gcroot(buffer, 0); uint32 resRva = assembly->resRva; ByteCode* bytes = assembly->bytes; Section* textSection = assembly->textSection; uint32 section = 0; section = textSection->rawAddress + (resRva - textSection->virtualAddress); memcpy(&(buffer->elements[offset]), &(bytes->elements[section + position]), count); return count; } extern "C" sint32 System_String_CompareInternal(PNetString* strA, sint32 indexA, sint32 lengthA, PNetString* strB, sint32 indexB, sint32 lengthB, bool ignoreCase) { llvm_gcroot(strA, 0); llvm_gcroot(strB, 0); if (strA == 0) { if (strB == 0) { return 0; } return -1; } else if (strB == 0) { return 1; } else { sint32 cmp = 0; if (lengthA >= lengthB) { if (ignoreCase) { cmp = ILUnicodeStringCompareIgnoreCase((void*)&(strA->value->elements[indexA]), (void*)&(strB->value->elements[indexB]), lengthB); } else { cmp = ILUnicodeStringCompareNoIgnoreCase((void*)&(strA->value->elements[indexA]), (void*)&(strB->value->elements[indexB]), lengthB); } if (cmp != 0) return cmp; else if (lengthA > lengthB) return 1; else return 0; } else { if (ignoreCase) { cmp = ILUnicodeStringCompareIgnoreCase((void*)&(strA->value->elements[indexA]), (void*)&(strB->value->elements[indexB]), lengthA); } else { cmp = ILUnicodeStringCompareNoIgnoreCase((void*)&(strA->value->elements[indexA]), (void*)&(strB->value->elements[indexB]), lengthA); } if (cmp != 0) return cmp; else return -1; } } } extern "C" void System_String_CharFill(PNetString* str, sint32 start, sint32 count, char ch) { llvm_gcroot(str, 0); declare_gcroot(const ArrayChar*, array) = str->value; sint32 length = start + count; uint16* buf = (uint16*)alloca(length * sizeof(uint16)); memcpy(buf, array->elements, start * sizeof(uint16)); for (sint32 i = 0; i < count; ++i) { buf[i + start] = ch; } N3* vm = VMThread::get()->getVM(); declare_gcroot(const ArrayChar*, val) = vm->bufToArray(buf, length); str->value = val; str->length = length; } extern "C" sint32 System_String_InternalOrdinal(PNetString *strA, sint32 indexA, sint32 lengthA, PNetString *strB, sint32 indexB, sint32 lengthB) { llvm_gcroot(strA, 0); llvm_gcroot(strB, 0); const uint16 *bufA; const uint16 *bufB; /* Handle the easy cases first */ if(!strA) { if(!strB) { return 0; } else { return -1; } } else if(!strB) { return 1; } /* Compare the two strings */ bufA = &(strA->value->elements[indexA]); bufB = &(strB->value->elements[indexB]); while(lengthA > 0 && lengthB > 0) { if(*bufA < *bufB) { return -1; } else if(*bufA > *bufB) { return 1; } ++bufA; ++bufB; --lengthA; --lengthB; } /* Determine the ordering based on the tail sections */ if(lengthA > 0) { return 1; } else if(lengthB > 0) { return -1; } else { return 0; } } extern "C" VMObject* System_Threading_Thread_InternalCurrentThread() { declare_gcroot(VMObject*, appThread) = VMThread::get()->ooo_appThread; return appThread; }