| //===--------------- 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 <math.h> |
| |
| #include <dlfcn.h> |
| #include <stdio.h> |
| |
| #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<VMCommonClass*> 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<Property*, gc_allocator<Property*> > properties = |
| type->properties; |
| Property *res = 0; |
| for (std::vector<Property*, gc_allocator<Property*> >::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<VMMethod*> virtualMethods = type->virtualMethods; |
| std::vector<VMMethod*> staticMethods = type->staticMethods; |
| |
| for (std::vector<VMMethod*>::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<VMMethod*>::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<llvm::GenericValue>& 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<llvm::GenericValue> 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<llvm::PointerType>(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; |
| } |