tAsyncCall* System_Enum_Internal_GetInfo(PTR pThis_, PTR pParams, PTR pReturnValue) { tMD_TypeDef *pEnumType = RuntimeType_DeRef((PTR)((tMD_TypeDef**)pParams)[0]); U32 i, retIndex; HEAP_PTR names, values; // An enum type always has just one non-literal field, with all other fields being the values. names = SystemArray_NewVector(types[TYPE_SYSTEM_ARRAY_STRING], pEnumType->numFields - 1); values = SystemArray_NewVector(types[TYPE_SYSTEM_ARRAY_INT32], pEnumType->numFields - 1); for (i=0, retIndex=0; i<pEnumType->numFields; i++) { tMD_FieldDef *pField = pEnumType->ppFields[i]; HEAP_PTR name; I32 value; if (!FIELD_ISLITERAL(pField)) { continue; } name = SystemString_FromCharPtrASCII(pField->name); SystemArray_StoreElement(names, retIndex, (PTR)&name); MetaData_GetConstant(pField->pMetaData, pField->tableIndex, (PTR)&value); SystemArray_StoreElement(values, retIndex, (PTR)&value); retIndex++; } *(((HEAP_PTR**)pParams)[1]) = names; *(((HEAP_PTR**)pParams)[2]) = values; return NULL; }
tAsyncCall* System_RuntimeType_get_Namespace(PTR pThis_, PTR pParams, PTR pReturnValue) { tRuntimeType *pRuntimeType = (tRuntimeType*)pThis_; HEAP_PTR strResult; strResult = SystemString_FromCharPtrASCII(pRuntimeType->pTypeDef->nameSpace); *(HEAP_PTR*)pReturnValue = strResult; return NULL; }
tAsyncCall* System_IO_FileInternal_GetCurrentDirectory(PTR pThis_, PTR pParams, PTR pReturnValue) { U32 *pError = ((U32**)pParams)[0]; HEAP_PTR curDir; #ifdef WIN32 unsigned short dir[256]; GetCurrentDirectoryW(256, dir); curDir = SystemString_FromCharPtrUTF16(dir); #else unsigned char dir[256]; getcwd(dir, 256); curDir = SystemString_FromCharPtrASCII(dir); #endif *pError = 0; *(HEAP_PTR*)pReturnValue = curDir; return NULL; }
I32 CLIFile_Execute(tCLIFile *pThis, int argc, char **argp) { tThread *pThread; HEAP_PTR args; int i; // Create a string array for the program arguments // Don't include the argument that is the program name. argc--; argp++; args = SystemArray_NewVector(types[TYPE_SYSTEM_ARRAY_STRING], argc); Heap_MakeUndeletable(args); for (i = 0; i < argc; i++) { HEAP_PTR arg = SystemString_FromCharPtrASCII(argp[i]); SystemArray_StoreElement(args, i, (PTR)&arg); } // Create the main application thread pThread = Thread(); Thread_SetEntryPoint(pThread, pThis->pMetaData, pThis->entryPoint, (PTR)&args, sizeof(void*)); return Thread_Execute(); }
tAsyncCall* System_IO_FileInternal_GetFileSystemEntries(PTR pThis_, PTR pParams, PTR pReturnValue) { //HEAP_PTR pathHP = ((HEAP_PTR*)pParams)[0]; HEAP_PTR pathPatternHP = ((HEAP_PTR*)pParams)[1]; U32 attrs = ((U32*)pParams)[2]; U32 mask = ((U32*)pParams)[3]; U32* pError = ((U32**)pParams)[4]; U32 /*pathLen,*/ pathPatternLen; //STRING2 path = SystemString_GetString(pathHP, &pathLen); STRING2 pathPattern = SystemString_GetString(pathPatternHP, &pathPatternLen); HEAP_PTR retArray; U32 tempStoreSize = 32, tempStoreOfs = 0, i; HEAP_PTR *pTempStore = malloc(tempStoreSize * sizeof(void*)); PTR arrayElements; #ifdef WIN32 unsigned short pathPatternNullTerm[256]; HANDLE hFind; WIN32_FIND_DATA find; memcpy(pathPatternNullTerm, pathPattern, pathPatternLen << 1); pathPatternNullTerm[pathPatternLen] = 0; hFind = FindFirstFileW(pathPatternNullTerm, &find); if (hFind != INVALID_HANDLE_VALUE) { do { if ((find.dwFileAttributes & mask) == attrs) { HEAP_PTR str; // Want this file, so store it in tempStore if (tempStoreOfs >= tempStoreSize) { tempStoreSize <<= 1; pTempStore = realloc(pTempStore, tempStoreSize * sizeof(void*)); } str = SystemString_FromCharPtrUTF16(find.cFileName); // Need to temporarily make these undeletable, in case a GC happens before they're in the array Heap_MakeUndeletable(str); pTempStore[tempStoreOfs++] = str; } } while (FindNextFile(hFind, &find) != 0); FindClose(hFind); } #else unsigned char path8[256]; glob_t gl; for (i=0; i<pathPatternLen; i++) { path8[i] = (U8)pathPattern[i]; } path8[i] = 0; i = glob(path8, GLOB_NOSORT, NULL, &gl); if (i == 0) { for (i=0; i<gl.gl_pathc; i++) { unsigned char *pResult = gl.gl_pathv[i]; U32 fileAttrs = Attrs(pResult, pError); if (fileAttrs == (U32)-1) { break; } if ((fileAttrs & mask) == attrs) { HEAP_PTR str; // Want this file, so store it in tempStore if (tempStoreOfs >= tempStoreSize) { tempStoreSize <<= 1; pTempStore = realloc(pTempStore, tempStoreSize * sizeof(void*)); } str = SystemString_FromCharPtrASCII(pResult); // Need to temporarily make these undeletable, in case a GC happens before they're in the array Heap_MakeUndeletable(str); pTempStore[tempStoreOfs++] = str; } } globfree(&gl); } else { *pError = errno; } #endif // Move the temp-store values into the final returnable array retArray = SystemArray_NewVector(types[TYPE_SYSTEM_ARRAY_STRING], tempStoreOfs); arrayElements = SystemArray_GetElements(retArray); memcpy(arrayElements, pTempStore, tempStoreOfs * sizeof(void*)); free(pTempStore); *(HEAP_PTR*)pReturnValue = retArray; // Make the strings deletable again for (i=0; i<tempStoreOfs; i++) { Heap_MakeDeletable(((HEAP_PTR*)arrayElements)[i]); } return NULL; }
U32 PInvoke_Call(tJITCallPInvoke *pCall, PTR pParams, PTR pReturnValue) { U32 _args[MAX_ARGS]; double _argsd[MAX_ARGS]; void* _pTempMem[MAX_ARGS]; U32 numParams, param, paramTypeNum; tMD_MethodDef *pMethod = pCall->pMethod; tMD_TypeDef *pReturnType = pMethod->pReturnType; tMD_ImplMap *pImplMap = pCall->pImplMap; void *pFn = pCall->fn; U32 _argOfs = 0, _argdOfs = 0, paramOfs = 0; U32 _tempMemOfs = 0; U32 i; U32 funcParams = DEFAULT; U64 u64Ret; float fRet; double dRet; if (pReturnType != NULL) { if (pReturnType == types[TYPE_SYSTEM_SINGLE]) { funcParams = SINGLE; } else if (pReturnType == types[TYPE_SYSTEM_DOUBLE]) { funcParams = DOUBLE; } } numParams = pMethod->numberOfParameters; for (param = 0, paramTypeNum = 0; param<numParams; param++, paramTypeNum++) { tParameter *pParam = &(pMethod->pParams[param]); tMD_TypeDef *pParamType = pParam->pTypeDef; U32 paramType = DEFAULT; if (pParamType->stackType == EVALSTACK_INT32) { _args[_argOfs] = *(U32*)(pParams + paramOfs); _argOfs++; paramOfs += 4; } else if (pParamType == types[TYPE_SYSTEM_STRING]) { // Allocate a temp bit of memory for the string that's been converted. void *pString; if (IMPLMAP_ISCHARSET_ANSI(pImplMap) || IMPLMAP_ISCHARSET_AUTO(pImplMap) || IMPLMAP_ISCHARSET_NOTSPEC(pImplMap)) { pString = ConvertStringToANSI(*(HEAP_PTR*)(pParams + paramOfs)); } else if (IMPLMAP_ISCHARSET_UNICODE(pImplMap)) { pString = ConvertStringToUnicode(*(HEAP_PTR*)(pParams + paramOfs)); } else { Crash("PInvoke_Call() Cannot handle string marshalling of given type"); } _pTempMem[_tempMemOfs] = pString; _tempMemOfs++; _args[_argOfs] = (U32)pString; _argOfs++; paramOfs += 4; } else if (pParamType == types[TYPE_SYSTEM_INTPTR]) { // Only works for 32-bit _args[_argOfs] = *(U32*)(pParams + paramOfs); _argOfs++; paramOfs += 4; } else if (pParamType == types[TYPE_SYSTEM_SINGLE]) { _argsd[_argdOfs] = *(float*)(pParams + paramOfs); _argdOfs++; paramOfs += 4; paramType = SINGLE; } else if (pParamType == types[TYPE_SYSTEM_DOUBLE]) { _argsd[_argdOfs] = *(double*)(pParams + paramOfs); _argdOfs++; paramOfs += 8; paramType = DOUBLE; } else { Crash("PInvoke_Call() Cannot handle parameter of type: %s", pParamType->name); } SET_ARG_TYPE(paramTypeNum, paramType); } switch (funcParams) { #include "PInvoke_CaseCode.h" case CALL5(DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT): u64Ret = ((_uCuuuuu)(pFn))(_args[0], _args[1], _args[2], _args[3], _args[4]); break; case CALL6(DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT): u64Ret = ((_uCuuuuuu)(pFn))(_args[0], _args[1], _args[2], _args[3], _args[4], _args[5]); break; case CALL7(DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT): u64Ret = ((_uCuuuuuuu)(pFn))(_args[0], _args[1], _args[2], _args[3], _args[4], _args[5], _args[6]); break; case CALL8(DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT): u64Ret = ((_uCuuuuuuuu)(pFn))(_args[0], _args[1], _args[2], _args[3], _args[4], _args[5], _args[6], _args[7]); break; case CALL9(DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT): u64Ret = ((_uCuuuuuuuuu)(pFn))(_args[0], _args[1], _args[2], _args[3], _args[4], _args[5], _args[6], _args[7], _args[8]); break; case CALL10(DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT): u64Ret = ((_uCuuuuuuuuuu)(pFn))(_args[0], _args[1], _args[2], _args[3], _args[4], _args[5], _args[6], _args[7], _args[8], _args[9]); break; default: Crash("PInvoke_Call() Cannot handle the function parameters: 0x%08x", funcParams); } for (i=0; i<_tempMemOfs; i++) { free(_pTempMem[i]); } if (pReturnType == NULL) { return 0; } if (pReturnType->stackType == EVALSTACK_INT32) { *(U32*)pReturnValue = (U32)u64Ret; return 4; } if (pReturnType == types[TYPE_SYSTEM_STRING]) { if (IMPLMAP_ISCHARSET_ANSI(pImplMap) || IMPLMAP_ISCHARSET_AUTO(pImplMap) || IMPLMAP_ISCHARSET_NOTSPEC(pImplMap)) { *(HEAP_PTR*)pReturnValue = SystemString_FromCharPtrASCII((U8*)(U32)u64Ret); } else if (IMPLMAP_ISCHARSET_UNICODE(pImplMap)) { *(HEAP_PTR*)pReturnValue = SystemString_FromCharPtrUTF16((U16*)(U32)u64Ret); } else { Crash("PInvoke_Call() Cannot handle return string in specified format"); } return sizeof(void*); } if (pReturnType == types[TYPE_SYSTEM_INTPTR]) { *(void**)pReturnValue = (void*)(U32)u64Ret; return sizeof(void*); } if (pReturnType == types[TYPE_SYSTEM_SINGLE]) { *(double*)pReturnValue = (double)fRet; return 8; } if (pReturnType == types[TYPE_SYSTEM_DOUBLE]) { *(double*)pReturnValue = dRet; return 8; } Crash("PInvoke_Call() Cannot handle return type: %s", pReturnType->name); FAKE_RETURN; }