/********************************************************************** * FreeResource (KERNEL.63) */ BOOL16 WINAPI FreeResource16( HGLOBAL16 handle ) { FARPROC16 proc; HMODULE16 user; NE_MODULE *pModule = NE_GetPtr( FarGetOwner16( handle ) ); TRACE("(%04x)\n", handle ); /* Try NE resource first */ if (pModule && pModule->ne_rsrctab) { NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->ne_rsrctab + 2); while (pTypeInfo->type_id) { WORD count; NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1); for (count = pTypeInfo->count; count > 0; count--) { if (pNameInfo->handle == handle) { if (pNameInfo->usage > 0) pNameInfo->usage--; if (pNameInfo->usage == 0) { GlobalFree16( pNameInfo->handle ); pNameInfo->handle = 0; pNameInfo->flags &= ~NE_SEGFLAGS_LOADED; } return FALSE; } pNameInfo++; } pTypeInfo = (NE_TYPEINFO *)pNameInfo; } } /* If this failed, call USER.DestroyIcon32; this will check whether it is a shared cursor/icon; if not it will call GlobalFree16() */ user = GetModuleHandle16( "user" ); if (user && (proc = GetProcAddress16( user, "DestroyIcon32" ))) { WORD args[2]; DWORD result; args[1] = handle; args[0] = 1; /* CID_RESOURCE */ WOWCallback16Ex( (SEGPTR)proc, WCB16_PASCAL, sizeof(args), args, &result ); return LOWORD(result); } else return GlobalFree16( handle ); }
/*********************************************************************** * DefResourceHandler (KERNEL.456) * * This is the default LoadProc() function. */ HGLOBAL16 WINAPI NE_DefResourceHandler( HGLOBAL16 hMemObj, HMODULE16 hModule, HRSRC16 hRsrc ) { HGLOBAL16 handle; WORD sizeShift; NE_NAMEINFO* pNameInfo; NE_MODULE* pModule = NE_GetPtr( hModule ); if (!pModule) return 0; sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab); pNameInfo = (NE_NAMEINFO *)((char *)pModule + hRsrc); if ( hMemObj ) handle = GlobalReAlloc16( hMemObj, pNameInfo->length << sizeShift, 0 ); else handle = AllocResource16( hModule, hRsrc, 0 ); if (handle) { if (!NE_READ_DATA( pModule, GlobalLock16( handle ), (int)pNameInfo->offset << sizeShift, (int)pNameInfo->length << sizeShift )) { GlobalFree16( handle ); handle = 0; } } return handle; }
/********************************************************************** * FreeResource (KERNEL.63) * FreeResource16 (KERNEL32.@) */ BOOL16 WINAPI FreeResource16( HGLOBAL16 handle ) { HGLOBAL retv = handle; NE_MODULE *pModule = NE_GetPtr( FarGetOwner16( handle ) ); TRACE("(%04x)\n", handle ); /* Try NE resource first */ retv = NE_FreeResource( pModule, handle ); /* If this failed, call USER.DestroyIcon32; this will check whether it is a shared cursor/icon; if not it will call GlobalFree16() */ if ( retv ) { pDestroyIcon32Proc proc; HMODULE user = GetModuleHandleA( "user32.dll" ); if (user && (proc = (pDestroyIcon32Proc)GetProcAddress( user, "DestroyIcon32" ))) retv = proc( handle, CID_RESOURCE ); else retv = GlobalFree16( handle ); } return (BOOL)retv; }
/*********************************************************************** * TASK_DeleteTask */ static void TASK_DeleteTask( HTASK16 hTask ) { TDB *pTask; HGLOBAL16 hPDB; if (!(pTask = TASK_GetPtr( hTask ))) return; hPDB = pTask->hPDB; pTask->magic = 0xdead; /* invalidate signature */ /* Free the selector aliases */ GLOBAL_FreeBlock( pTask->hCSAlias ); GLOBAL_FreeBlock( pTask->hPDB ); /* Free the task module */ FreeModule16( pTask->hModule ); /* Free the task structure itself */ GlobalFree16( hTask ); /* Free all memory used by this task (including the 32-bit stack, */ /* the environment block and the thunk segments). */ GlobalFreeAll16( hPDB ); }
/********************************************************************** * FreeResource (KERNEL.63) */ BOOL16 WINAPI FreeResource16( HGLOBAL16 handle ) { pDestroyIcon32Proc proc; HMODULE user; NE_MODULE *pModule = NE_GetPtr( FarGetOwner16( handle ) ); TRACE("(%04x)\n", handle ); /* Try NE resource first */ if (pModule && pModule->ne_rsrctab) { NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->ne_rsrctab + 2); while (pTypeInfo->type_id) { WORD count; NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1); for (count = pTypeInfo->count; count > 0; count--) { if (pNameInfo->handle == handle) { if (pNameInfo->usage > 0) pNameInfo->usage--; if (pNameInfo->usage == 0) { GlobalFree16( pNameInfo->handle ); pNameInfo->handle = 0; pNameInfo->flags &= ~NE_SEGFLAGS_LOADED; } return 0; } pNameInfo++; } pTypeInfo = (NE_TYPEINFO *)pNameInfo; } } /* If this failed, call USER.DestroyIcon32; this will check whether it is a shared cursor/icon; if not it will call GlobalFree16() */ user = GetModuleHandleA( "user32.dll" ); if (user && (proc = (pDestroyIcon32Proc)GetProcAddress( user, "DestroyIcon32" ))) return proc( handle, 1 /*CID_RESOURCE*/ ); else return GlobalFree16( handle ); }
/************************************************************************* * FindClose (KERNEL.415) */ BOOL16 WINAPI FindClose16( HANDLE16 handle ) { HANDLE *ptr; if ((handle == INVALID_HANDLE_VALUE16) || !(ptr = GlobalLock16( handle ))) { SetLastError( ERROR_INVALID_HANDLE ); return FALSE; } FindClose( *ptr ); GlobalUnlock16( handle ); GlobalFree16( handle ); return TRUE; }
/************************************************************************* * FindFirstFile (KERNEL.413) */ HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATAA *data ) { HGLOBAL16 h16; HANDLE handle, *ptr; if (!(h16 = GlobalAlloc16( GMEM_MOVEABLE, sizeof(handle) ))) return INVALID_HANDLE_VALUE16; ptr = GlobalLock16( h16 ); *ptr = handle = FindFirstFileA( path, data ); GlobalUnlock16( h16 ); if (handle == INVALID_HANDLE_VALUE) { GlobalFree16( h16 ); h16 = INVALID_HANDLE_VALUE16; } return h16; }
/****************************************************************************** * This is the destructor of the HGLOBALStreamImpl class. * * This method will clean-up all the resources used-up by the given * HGLOBALLockBytesImpl16 class. The pointer passed-in to this function will be * freed and will not be valid anymore. */ static void HGLOBALLockBytesImpl16_Destroy(HGLOBALLockBytesImpl16* This) { TRACE("()\n"); /* * Release the HGlobal if the constructor asked for that. */ if (This->deleteOnRelease) { GlobalFree16(This->supportHandle); This->supportHandle = 0; } /* * Finally, free the memory used-up by the class. */ HeapFree(GetProcessHeap(), 0, This); }
/************************************************************************* * InternalExtractIcon [SHELL.39] * * This abortion is called directly by Progman */ HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance, LPCSTR lpszExeFileName, UINT16 nIconIndex, WORD n ) { HGLOBAL16 hRet = 0; HICON16 *RetPtr = NULL; TRACE("(%04x,file %s,start %d,extract %d\n", hInstance, lpszExeFileName, nIconIndex, n); if (!n) return 0; hRet = GlobalAlloc16(GMEM_FIXED | GMEM_ZEROINIT, sizeof(*RetPtr) * n); RetPtr = GlobalLock16(hRet); if (nIconIndex == (UINT16)-1) /* get number of icons */ { RetPtr[0] = PrivateExtractIconsA(lpszExeFileName, 0, 0, 0, NULL, NULL, 0, LR_DEFAULTCOLOR); } else { UINT ret; HICON *icons; icons = HeapAlloc(GetProcessHeap(), 0, n * sizeof(*icons)); ret = PrivateExtractIconsA(lpszExeFileName, nIconIndex, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), icons, NULL, n, LR_DEFAULTCOLOR); if ((ret != 0xffffffff) && ret) { int i; for (i = 0; i < n; i++) RetPtr[i] = convert_icon_to_16(hInstance, icons[i]); } else { GlobalFree16(hRet); hRet = 0; } HeapFree(GetProcessHeap(), 0, icons); } return hRet; }
/*********************************************************************** * NE_InitializeDLLs * * Recursively initialize all DLLs (according to the order in which * they where loaded). */ void NE_InitializeDLLs( HMODULE16 hModule ) { NE_MODULE *pModule; HMODULE16 *pDLL; if (!(pModule = NE_GetPtr( hModule ))) return; assert( !(pModule->ne_flags & NE_FFLAGS_WIN32) ); if (pModule->dlls_to_init) { HGLOBAL16 to_init = pModule->dlls_to_init; pModule->dlls_to_init = 0; for (pDLL = GlobalLock16( to_init ); *pDLL; pDLL++) { NE_InitializeDLLs( *pDLL ); } GlobalFree16( to_init ); } NE_InitDLL( pModule ); }
void WINAPI XMS_Handler( CONTEXT86 *context ) { switch(AH_reg(context)) { case 0x00: /* Get XMS version number */ TRACE("get XMS version number\n"); SET_AX( context, 0x0200 ); /* 2.0 */ SET_BX( context, 0x0000 ); /* internal revision */ SET_DX( context, 0x0001 ); /* HMA exists */ break; case 0x08: /* Query Free Extended Memory */ { MEMORYSTATUS status; TRACE("query free extended memory\n"); GlobalMemoryStatus( &status ); SET_DX( context, status.dwAvailVirtual >> 10 ); SET_AX( context, status.dwAvailVirtual >> 10 ); TRACE("returning largest %dK, total %dK\n", AX_reg(context), DX_reg(context)); } break; case 0x09: /* Allocate Extended Memory Block */ TRACE("allocate extended memory block (%dK)\n", DX_reg(context)); SET_DX( context, GlobalAlloc16(GMEM_MOVEABLE, (DWORD)DX_reg(context)<<10) ); SET_AX( context, DX_reg(context) ? 1 : 0 ); if (!DX_reg(context)) SET_BL( context, 0xA0 ); /* out of memory */ break; case 0x0a: /* Free Extended Memory Block */ TRACE("free extended memory block %04x\n",DX_reg(context)); if(!DX_reg(context) || GlobalFree16(DX_reg(context))) { SET_AX( context, 0 ); /* failure */ SET_BL( context, 0xa2 ); /* invalid handle */ } else SET_AX( context, 1 ); /* success */ break; case 0x0b: /* Move Extended Memory Block */ { MOVESTRUCT*move=CTX_SEG_OFF_TO_LIN(context, context->SegDs,context->Esi); BYTE*src,*dst; TRACE("move extended memory block\n"); src=XMS_Offset(&move->Source); dst=XMS_Offset(&move->Dest); memcpy(dst,src,move->Length); if (move->Source.Handle) GlobalUnlock16(move->Source.Handle); if (move->Dest.Handle) GlobalUnlock16(move->Dest.Handle); break; } case 0x88: /* Query Any Free Extended Memory */ { MEMORYSTATUS status; SYSTEM_INFO info; TRACE("query any free extended memory\n"); GlobalMemoryStatus( &status ); GetSystemInfo( &info ); context->Eax = status.dwAvailVirtual >> 10; context->Edx = status.dwAvailVirtual >> 10; context->Ecx = (DWORD)info.lpMaximumApplicationAddress; SET_BL( context, 0 ); /* No errors. */ TRACE("returning largest %dK, total %dK, highest 0x%x\n", context->Eax, context->Edx, context->Ecx); } break; default: INT_BARF( context, 0x31 ); SET_AX( context, 0x0000 ); /* failure */ SET_BL( context, 0x80 ); /* function not implemented */ break; } }
/********************************************************************** * K32WOWGlobalFree16 (KERNEL32.62) */ WORD WINAPI K32WOWGlobalFree16( WORD hMem ) { return (WORD)GlobalFree16( (HGLOBAL16)hMem ); }
/********************************************************************** * DeletePQ (GDI.235) * */ INT16 WINAPI DeletePQ16(HPQ16 hPQ) { return GlobalFree16(hPQ); }
/****************************************************************** * EnumMetaFile (GDI.175) * */ BOOL16 WINAPI EnumMetaFile16( HDC16 hdc16, HMETAFILE16 hmf, MFENUMPROC16 lpEnumFunc, LPARAM lpData ) { METAHEADER *mh = MF_GetMetaHeader16(hmf); METARECORD *mr; HANDLETABLE16 *ht; HDC hdc = HDC_32(hdc16); HGLOBAL16 hHT; SEGPTR spht; unsigned int offset = 0; WORD i, seg; HPEN hPen; HBRUSH hBrush; HFONT hFont; WORD args[8]; BOOL16 result = TRUE; TRACE("(%p, %04x, %p, %08lx)\n", hdc, hmf, lpEnumFunc, lpData); if(!mh) return FALSE; /* save the current pen, brush and font */ hPen = GetCurrentObject(hdc, OBJ_PEN); hBrush = GetCurrentObject(hdc, OBJ_BRUSH); hFont = GetCurrentObject(hdc, OBJ_FONT); /* create the handle table */ hHT = GlobalAlloc16(GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(HANDLETABLE16) * mh->mtNoObjects); spht = WOWGlobalLock16(hHT); seg = hmf | 7; offset = mh->mtHeaderSize * 2; /* loop through metafile records */ args[7] = hdc16; args[6] = SELECTOROF(spht); args[5] = OFFSETOF(spht); args[4] = seg + (HIWORD(offset) << __AHSHIFT); args[3] = LOWORD(offset); args[2] = mh->mtNoObjects; args[1] = HIWORD(lpData); args[0] = LOWORD(lpData); while (offset < (mh->mtSize * 2)) { DWORD ret; mr = (METARECORD *)((char *)mh + offset); WOWCallback16Ex( (DWORD)lpEnumFunc, WCB16_PASCAL, sizeof(args), args, &ret ); if (!LOWORD(ret)) { result = FALSE; break; } offset += (mr->rdSize * 2); args[4] = seg + (HIWORD(offset) << __AHSHIFT); args[3] = LOWORD(offset); } SelectObject(hdc, hBrush); SelectObject(hdc, hPen); SelectObject(hdc, hFont); ht = GlobalLock16(hHT); /* free objects in handle table */ for(i = 0; i < mh->mtNoObjects; i++) if(*(ht->objectHandle + i) != 0) DeleteObject( (HGDIOBJ)(ULONG_PTR)(*(ht->objectHandle + i) )); /* free handle table */ GlobalFree16(hHT); MF_ReleaseMetaHeader16(hmf); return result; }
/****************************************************************** * DeleteMetaFile (GDI.127) */ BOOL16 WINAPI DeleteMetaFile16( HMETAFILE16 hmf ) { return !GlobalFree16( hmf ); }
/************************************************************************* * DragFinish [SHELL.12] */ void WINAPI DragFinish16(HDROP16 h) { TRACE("\n"); GlobalFree16(h); }
/************************************************************************* * InternalExtractIcon [SHELL.39] * * This abortion is called directly by Progman */ HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance, LPCSTR lpszExeFileName, UINT16 nIconIndex, WORD n ) { HGLOBAL16 hRet = 0; HICON16 *RetPtr = NULL; OFSTRUCT ofs; HFILE hFile; TRACE("(%04x,file %s,start %d,extract %d\n", hInstance, lpszExeFileName, nIconIndex, n); if( !n ) return 0; hFile = OpenFile( lpszExeFileName, &ofs, OF_READ|OF_EXIST ); hRet = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, sizeof(HICON16)*n); RetPtr = (HICON16*)GlobalLock16(hRet); if (hFile == HFILE_ERROR) { /* not found - load from builtin module if available */ HINSTANCE hInst = (HINSTANCE)LoadLibrary16(lpszExeFileName); if (hInst < 32) /* hmm, no Win16 module - try Win32 :-) */ hInst = LoadLibraryA(lpszExeFileName); if (hInst) { int i; for (i=nIconIndex; i < nIconIndex + n; i++) RetPtr[i-nIconIndex] = (HICON16)LoadIconA(hInst, (LPCSTR)(DWORD)i); FreeLibrary(hInst); return hRet; } GlobalFree16( hRet ); return 0; } if (nIconIndex == (UINT16)-1) /* get number of icons */ { RetPtr[0] = PrivateExtractIconsA( ofs.szPathName, -1, 0, 0, NULL, 0, 0, 0 ); } else { HRESULT res; HICON *icons; icons = HeapAlloc( GetProcessHeap(), 0, n * sizeof(*icons) ); res = PrivateExtractIconsA( ofs.szPathName, nIconIndex, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), icons, 0, n, 0 ); if (!res) { int i; for (i = 0; i < n; i++) RetPtr[i] = (HICON16)icons[i]; } else { GlobalFree16( hRet ); hRet = 0; } HeapFree( GetProcessHeap(), 0, icons ); } return hRet; }
/********************************************************************** * DeletePQ (GDI.235) * */ INT16 WINAPI DeletePQ16(HPQ16 hPQ) { return GlobalFree16((HGLOBAL16)hPQ); }
void SNOOP16_RegisterDLL(HMODULE16 hModule,LPCSTR name) { SNOOP16_DLL **dll = &(firstdll); char *s; if (!TRACE_ON(snoop)) return; TRACE("hmod=%x, name=%s\n", hModule, name); if (!snr) { xsnr=GLOBAL_Alloc(GMEM_ZEROINIT,2*sizeof(*snr),0,WINE_LDT_FLAGS_CODE|WINE_LDT_FLAGS_32BIT); snr = GlobalLock16(xsnr); snr[0].pushbp = 0x5566; snr[0].pusheax = 0x50; snr[0].pushax = 0x5066; snr[0].pushl = 0x68; snr[0].realfun = (DWORD)SNOOP16_Entry; snr[0].lcall = 0x9a; snr[0].callfromregs = (DWORD)__wine_call_from_16_regs; snr[0].seg = wine_get_cs(); snr[0].lret = 0xcb66; snr[1].pushbp = 0x5566; snr[1].pusheax = 0x50; snr[1].pushax = 0x5066; snr[1].pushl = 0x68; snr[1].realfun = (DWORD)SNOOP16_Return; snr[1].lcall = 0x9a; snr[1].callfromregs = (DWORD)__wine_call_from_16_regs; snr[1].seg = wine_get_cs(); snr[1].lret = 0xcb66; } while (*dll) { if ((*dll)->hmod == hModule) { /* another dll, loaded at the same address */ GlobalUnlock16((*dll)->funhandle); GlobalFree16((*dll)->funhandle); break; } dll = &((*dll)->next); } if (*dll) *dll = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *dll, sizeof(SNOOP16_DLL)+strlen(name)); else *dll = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SNOOP16_DLL)+strlen(name)); (*dll)->next = NULL; (*dll)->hmod = hModule; if ((s=strrchr(name,'\\'))) name = s+1; strcpy( (*dll)->name, name ); if ((s=strrchr((*dll)->name,'.'))) *s='\0'; (*dll)->funhandle = GlobalHandleToSel16(GLOBAL_Alloc(GMEM_ZEROINIT,65535,0,WINE_LDT_FLAGS_CODE)); (*dll)->funs = GlobalLock16((*dll)->funhandle); if (!(*dll)->funs) { HeapFree(GetProcessHeap(),0,*dll); FIXME("out of memory\n"); return; } }
/************************************************************************* * DragFinish [SHELL.12] */ void WINAPI DragFinish16(HDROP16 h) { TRACE("\n"); GlobalFree16((HGLOBAL16)h); }