/*********************************************************************** * GetDOSEnvironment (KERNEL.131) * * Note: the environment is allocated once, it doesn't track changes * made using the Win32 API. This shouldn't matter. * * Format of a 16-bit environment block: * ASCIIZ string 1 (xx=yy format) * ... * ASCIIZ string n * BYTE 0 * WORD 1 * ASCIIZ program name (e.g. C:\WINDOWS\SYSTEM\KRNL386.EXE) */ SEGPTR WINAPI GetDOSEnvironment16(void) { static const char ENV_program_name[] = "C:\\WINDOWS\\SYSTEM\\KRNL386.EXE"; static HGLOBAL16 handle; /* handle to the 16 bit environment */ if (!handle) { DWORD size; LPSTR p, env; p = env = GetEnvironmentStringsA(); while (*p) p += strlen(p) + 1; p++; /* skip last null */ size = (p - env) + sizeof(WORD) + sizeof(ENV_program_name); handle = GlobalAlloc16( GMEM_FIXED, size ); if (handle) { WORD one = 1; LPSTR env16 = GlobalLock16( handle ); memcpy( env16, env, p - env ); memcpy( env16 + (p - env), &one, sizeof(one)); memcpy( env16 + (p - env) + sizeof(WORD), ENV_program_name, sizeof(ENV_program_name)); GlobalUnlock16( handle ); } FreeEnvironmentStringsA( env ); } return WOWGlobalLock16( handle ); }
/********************************************************************** * NE_LoadPEResource */ static HGLOBAL16 NE_LoadPEResource( NE_MODULE *pModule, WORD type, LPVOID bits, DWORD size ) { HGLOBAL16 handle; TRACE("module=%04x type=%04x\n", pModule->self, type ); handle = GlobalAlloc16( 0, size ); switch (type) { case RT_MENU: ConvertMenu32To16( bits, size, GlobalLock16( handle ) ); break; case RT_DIALOG: ConvertDialog32To16( bits, size, GlobalLock16( handle ) ); break; case RT_ACCELERATOR: ConvertAccelerator32To16( bits, size, GlobalLock16( handle ) ); break; case RT_STRING: FIXME("not yet implemented!\n" ); /* fall through */ default: memcpy( GlobalLock16( handle ), bits, size ); break; } return handle; }
/*********************************************************************** * USER initialisation routine */ static BOOL process_attach(void) { HINSTANCE16 instance; /* Create USER heap */ if ((instance = LoadLibrary16( "USER.EXE" )) >= 32) USER_HeapSel = instance | 7; else { USER_HeapSel = GlobalAlloc16( GMEM_FIXED, 65536 ); LocalInit16( USER_HeapSel, 32, 65534 ); } /* some Win9x dlls expect keyboard to be loaded */ if (GetVersion() & 0x80000000) LoadLibrary16( "keyboard.drv" ); winstation_init(); /* Initialize system colors and metrics */ SYSPARAMS_Init(); /* Setup palette function pointers */ palette_init(); /* Initialize built-in window classes */ CLASS_RegisterBuiltinClasses(); /* Initialize message spying */ if (!SPY_Init()) return FALSE; return TRUE; }
/****************************************************************************** * OleMetaFilePictFromIconAndLabel (OLE2.56) * * Returns a global memory handle to a metafile which contains the icon and * label given. * I guess the result of that should look somehow like desktop icons. * If no hIcon is given, we load the icon via lpszSourceFile and iIconIndex. * This code might be wrong at some places. */ HGLOBAL16 WINAPI OleMetaFilePictFromIconAndLabel16( HICON16 hIcon, LPCOLESTR16 lpszLabel, LPCOLESTR16 lpszSourceFile, UINT16 iIconIndex ) { METAFILEPICT16 *mf16; HGLOBAL16 hmf16; HMETAFILE hmf; INT mfSize; HDC hdc; if (!hIcon) { if (lpszSourceFile) { HINSTANCE16 hInstance = LoadLibrary16(lpszSourceFile); /* load the icon at index from lpszSourceFile */ hIcon = HICON_16(LoadIconA(HINSTANCE_32(hInstance), (LPCSTR)(DWORD)iIconIndex)); FreeLibrary16(hInstance); } else return 0; } FIXME("(%04x, '%s', '%s', %d): incorrect metrics, please try to correct them !\n", hIcon, lpszLabel, lpszSourceFile, iIconIndex); hdc = CreateMetaFileW(NULL); DrawIcon(hdc, 0, 0, HICON_32(hIcon)); /* FIXME */ TextOutA(hdc, 0, 0, lpszLabel, 1); /* FIXME */ hmf = CloseMetaFile(hdc); hmf16 = GlobalAlloc16(0, sizeof(METAFILEPICT16)); mf16 = (METAFILEPICT16 *)GlobalLock16(hmf16); mf16->mm = MM_ANISOTROPIC; mf16->xExt = 20; /* FIXME: bogus */ mf16->yExt = 20; /* dito */ mfSize = GetMetaFileBitsEx(hmf, 0, 0); mf16->hMF = GlobalAlloc16(GMEM_MOVEABLE, mfSize); if(mf16->hMF) { GetMetaFileBitsEx(hmf, mfSize, GlobalLock16(mf16->hMF)); GlobalUnlock16(mf16->hMF); } return hmf16; }
/****************************************************************************** * This is the constructor for the HGLOBALLockBytesImpl16 class. * * Params: * hGlobal - Handle that will support the stream. can be NULL. * fDeleteOnRelease - Flag set to TRUE if the HGLOBAL16 will be released * when the IStream object is destroyed. */ static HGLOBALLockBytesImpl16* HGLOBALLockBytesImpl16_Construct(HGLOBAL16 hGlobal, BOOL16 fDeleteOnRelease) { HGLOBALLockBytesImpl16* newLockBytes; static ILockBytes16Vtbl vt16; static SEGPTR msegvt16; HMODULE16 hcomp = GetModuleHandle16("OLE2"); TRACE("(%x,%d)\n",hGlobal,fDeleteOnRelease); newLockBytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl16)); if (newLockBytes == NULL) return NULL; /* * Set up the virtual function table and reference count. */ if (!msegvt16) { #define VTENT(x) vt16.x = (void*)GetProcAddress16(hcomp,"HGLOBALLockBytesImpl16_"#x);assert(vt16.x) VTENT(QueryInterface); VTENT(AddRef); VTENT(Release); VTENT(ReadAt); VTENT(WriteAt); VTENT(Flush); VTENT(SetSize); VTENT(LockRegion); VTENT(UnlockRegion); #undef VTENT msegvt16 = MapLS( &vt16 ); } newLockBytes->lpVtbl = (const ILockBytes16Vtbl*)msegvt16; newLockBytes->ref = 0; /* * Initialize the support. */ newLockBytes->supportHandle = hGlobal; newLockBytes->deleteOnRelease = fDeleteOnRelease; /* * This method will allocate a handle if one is not supplied. */ if (newLockBytes->supportHandle == 0) newLockBytes->supportHandle = GlobalAlloc16(GMEM_MOVEABLE | GMEM_NODISCARD, 0); /* * Initialize the size of the array to the size of the handle. */ newLockBytes->byteArraySize.u.HighPart = 0; newLockBytes->byteArraySize.u.LowPart = GlobalSize16( newLockBytes->supportHandle); return (HGLOBALLockBytesImpl16*)MapLS(newLockBytes); }
/********************************************************************** * DirectResAlloc (KERNEL.168) * * Check Schulman, p. 232 for details */ HGLOBAL16 WINAPI DirectResAlloc16( HINSTANCE16 hInstance, WORD wType, UINT16 wSize ) { HGLOBAL16 ret; TRACE("(%04x,%04x,%04x)\n", hInstance, wType, wSize ); if (!(hInstance = GetExePtr( hInstance ))) return 0; if(wType != 0x10) /* 0x10 is the only observed value, passed from CreateCursorIndirect. */ TRACE("(wType=%x)\n", wType); ret = GlobalAlloc16( GMEM_MOVEABLE, wSize ); if (ret) FarSetOwner16( ret, hInstance ); return ret; }
/*********************************************************************** * NE_LoadAllSegments */ BOOL NE_LoadAllSegments( NE_MODULE *pModule ) { int i; SEGTABLEENTRY * pSegTable = (SEGTABLEENTRY *) NE_SEG_TABLE(pModule); if (pModule->flags & NE_FFLAGS_SELFLOAD) { HANDLE hf; HFILE16 hFile16; HGLOBAL16 sel; /* Handle self-loading modules */ SELFLOADHEADER *selfloadheader; HMODULE16 mod = GetModuleHandle16("KERNEL"); DWORD oldstack; TRACE_(module)("%.*s is a self-loading module!\n", *((BYTE*)pModule + pModule->name_table), (char *)pModule + pModule->name_table + 1); if (!NE_LoadSegment( pModule, 1 )) return FALSE; selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg), 0) ); selfloadheader->EntryAddrProc = GetProcAddress16(mod,"EntryAddrProc"); selfloadheader->MyAlloc = GetProcAddress16(mod,"MyAlloc"); selfloadheader->SetOwner = GetProcAddress16(mod,"FarSetOwner"); sel = GlobalAlloc16( GMEM_ZEROINIT, 0xFF00 ); pModule->self_loading_sel = SEL(sel); FarSetOwner16( sel, pModule->self ); oldstack = NtCurrentTeb()->WOW32Reserved; NtCurrentTeb()->WOW32Reserved = MAKESEGPTR(pModule->self_loading_sel, 0xff00 - sizeof(STACK16FRAME) ); DuplicateHandle( GetCurrentProcess(), NE_OpenFile(pModule), GetCurrentProcess(), &hf, 0, FALSE, DUPLICATE_SAME_ACCESS ); hFile16 = Win32HandleToDosFileHandle( hf ); TRACE_(dll)("CallBootAppProc(hModule=0x%04x,hf=0x%04x)\n", pModule->self,hFile16); NE_CallTo16_word_ww(selfloadheader->BootApp, pModule->self,hFile16); TRACE_(dll)("Return from CallBootAppProc\n"); _lclose16(hFile16); NtCurrentTeb()->WOW32Reserved = oldstack; for (i = 2; i <= pModule->seg_count; i++) if (!NE_LoadSegment( pModule, i )) return FALSE; } else { for (i = 1; i <= pModule->seg_count; i++) if (!NE_LoadSegment( pModule, i )) return FALSE; } return TRUE; }
/*********************************************************************** * NE_LoadAllSegments */ BOOL NE_LoadAllSegments( NE_MODULE *pModule ) { int i; SEGTABLEENTRY * pSegTable = NE_SEG_TABLE(pModule); if (pModule->ne_flags & NE_FFLAGS_SELFLOAD) { HFILE16 hFile16; HGLOBAL16 sel; /* Handle self-loading modules */ SELFLOADHEADER *selfloadheader; HMODULE16 mod = GetModuleHandle16("KERNEL"); void *oldstack; WORD args[2]; TRACE_(module)("%.*s is a self-loading module!\n", *((BYTE*)pModule + pModule->ne_restab), (char *)pModule + pModule->ne_restab + 1); if (!NE_LoadSegment( pModule, 1 )) return FALSE; selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg), 0) ); selfloadheader->EntryAddrProc = GetProcAddress16(mod,"EntryAddrProc"); selfloadheader->MyAlloc = GetProcAddress16(mod,"MyAlloc"); selfloadheader->SetOwner = GetProcAddress16(mod,"FarSetOwner"); sel = GlobalAlloc16( GMEM_ZEROINIT, 0xFF00 ); pModule->self_loading_sel = SEL(sel); FarSetOwner16( sel, pModule->self ); oldstack = getWOW32Reserved(); setWOW32Reserved((void *)MAKESEGPTR(pModule->self_loading_sel, 0xff00 - sizeof(STACK16FRAME) )); hFile16 = NE_OpenFile(pModule); TRACE_(dll)("CallBootAppProc(hModule=0x%04x,hf=0x%04x)\n", pModule->self,hFile16); args[1] = pModule->self; args[0] = hFile16; WOWCallback16Ex( (DWORD)selfloadheader->BootApp, WCB16_PASCAL, sizeof(args), args, NULL ); TRACE_(dll)("Return from CallBootAppProc\n"); _lclose16(hFile16); setWOW32Reserved(oldstack); for (i = 2; i <= pModule->ne_cseg; i++) if (!NE_LoadSegment( pModule, i )) return FALSE; } else { for (i = 1; i <= pModule->ne_cseg; i++) if (!NE_LoadSegment( pModule, i )) return FALSE; } return TRUE; }
/****************************************************************** * create_metafile16 * * Create a 16-bit metafile from a 32-bit one. The 32-bit one is deleted. */ static HMETAFILE16 create_metafile16( HMETAFILE hmf ) { UINT size; HMETAFILE16 hmf16; if (!hmf) return 0; size = GetMetaFileBitsEx( hmf, 0, NULL ); hmf16 = GlobalAlloc16( GMEM_MOVEABLE, size ); if (hmf16) { void *buffer = GlobalLock16( hmf16 ); GetMetaFileBitsEx( hmf, size, buffer ); GlobalUnlock16( hmf16 ); } DeleteMetaFile( hmf ); return hmf16; }
/************************************************************************* * 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; }
/************************************************************************* * 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; }
/********************************************************************** * AllocResource (KERNEL.66) */ HGLOBAL16 WINAPI AllocResource16( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size) { NE_NAMEINFO *pNameInfo=NULL; WORD sizeShift; HGLOBAL16 ret; NE_MODULE *pModule = NE_GetPtr( hModule ); if (!pModule || !pModule->ne_rsrctab || !hRsrc) return 0; TRACE("module=%04x res=%04x size=%ld\n", hModule, hRsrc, size ); sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab); pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc); if (size < (DWORD)pNameInfo->length << sizeShift) size = (DWORD)pNameInfo->length << sizeShift; ret = GlobalAlloc16( GMEM_FIXED, size ); if (ret) FarSetOwner16( ret, hModule ); return ret; }
static BOOL PRINTDLG_CreateDevNames16(HGLOBAL16 *hmem, const char* DeviceDriverName, const char* DeviceName, const char* OutputPort) { long size; char* pDevNamesSpace; char* pTempPtr; LPDEVNAMES lpDevNames; char buf[260]; DWORD dwBufLen = sizeof(buf); size = strlen(DeviceDriverName) + 1 + strlen(DeviceName) + 1 + strlen(OutputPort) + 1 + sizeof(DEVNAMES); if(*hmem) *hmem = GlobalReAlloc16(*hmem, size, GMEM_MOVEABLE); else *hmem = GlobalAlloc16(GMEM_MOVEABLE, size); if (*hmem == 0) return FALSE; pDevNamesSpace = GlobalLock16(*hmem); lpDevNames = (LPDEVNAMES) pDevNamesSpace; pTempPtr = pDevNamesSpace + sizeof(DEVNAMES); strcpy(pTempPtr, DeviceDriverName); lpDevNames->wDriverOffset = pTempPtr - pDevNamesSpace; pTempPtr += strlen(DeviceDriverName) + 1; strcpy(pTempPtr, DeviceName); lpDevNames->wDeviceOffset = pTempPtr - pDevNamesSpace; pTempPtr += strlen(DeviceName) + 1; strcpy(pTempPtr, OutputPort); lpDevNames->wOutputOffset = pTempPtr - pDevNamesSpace; GetDefaultPrinterA(buf, &dwBufLen); lpDevNames->wDefault = (strcmp(buf, DeviceName) == 0) ? 1 : 0; GlobalUnlock16(*hmem); return TRUE; }
/*********************************************************************** * MyAlloc (KERNEL.668) Wine-specific export * * MyAlloc() function for self-loading apps. */ DWORD WINAPI MyAlloc16( WORD wFlags, WORD wSize, WORD wElem ) { WORD size = wSize << wElem; HANDLE16 hMem = 0; if (wSize || (wFlags & NE_SEGFLAGS_MOVEABLE)) hMem = GlobalAlloc16( NE_Ne2MemFlags(wFlags), size); if ( ((wFlags & 0x7) != 0x1) && /* DATA */ ((wFlags & 0x7) != 0x7) ) /* DATA|ALLOCATED|LOADED */ { WORD hSel = SEL(hMem); WORD access = SelectorAccessRights16(hSel,0,0); access |= 2<<2; /* SEGMENT_CODE */ SelectorAccessRights16(hSel,1,access); } if (size) return MAKELONG( hMem, SEL(hMem) ); else return MAKELONG( 0, hMem ); }
/********************************************************************** * CreatePQ (GDI.230) * */ HPQ16 WINAPI CreatePQ16(INT16 size) { #if 0 HGLOBAL16 hpq = 0; WORD tmp_size; LPWORD pPQ; tmp_size = size << 2; if (!(hpq = GlobalAlloc16(GMEM_SHARE|GMEM_MOVEABLE, tmp_size + 8))) return 0xffff; pPQ = GlobalLock16(hpq); *pPQ++ = 0; *pPQ++ = tmp_size; *pPQ++ = 0; *pPQ++ = 0; GlobalUnlock16(hpq); return (HPQ16)hpq; #else FIXME("(%d): stub\n",size); return 1; #endif }
/****************************************************************** * 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; }
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; } }
/********************************************************************** * K32WOWGlobalAlloc16 (KERNEL32.59) */ WORD WINAPI K32WOWGlobalAlloc16( WORD wFlags, DWORD cb ) { return (WORD)GlobalAlloc16( wFlags, cb ); }
/*********************************************************************** * TASK_Create * * NOTE: This routine might be called by a Win32 thread. Thus, we need * to be careful to protect global data structures. We do this * by entering the Win16Lock while linking the task into the * global task list. */ static TDB *TASK_Create( NE_MODULE *pModule, UINT16 cmdShow, LPCSTR cmdline, BYTE len ) { HTASK16 hTask; TDB *pTask; FARPROC16 proc; char curdir[MAX_PATH]; HMODULE16 hModule = pModule ? pModule->self : 0; /* Allocate the task structure */ hTask = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, sizeof(TDB) ); if (!hTask) return NULL; pTask = TASK_GetPtr( hTask ); FarSetOwner16( hTask, hModule ); /* Fill the task structure */ pTask->hSelf = hTask; pTask->version = pModule ? pModule->ne_expver : 0x0400; pTask->hModule = hModule; pTask->hParent = GetCurrentTask(); pTask->magic = TDB_MAGIC; pTask->nCmdShow = cmdShow; GetCurrentDirectoryA( sizeof(curdir), curdir ); GetShortPathNameA( curdir, curdir, sizeof(curdir) ); pTask->curdrive = (curdir[0] - 'A') | 0x80; lstrcpynA( pTask->curdir, curdir + 2, sizeof(pTask->curdir) ); /* Create the thunks block */ TASK_CreateThunks( hTask, (char *)pTask->thunks - (char *)pTask, 7 ); /* Copy the module name */ if (hModule) { char name[sizeof(pTask->module_name)+1]; size_t len; GetModuleName16( hModule, name, sizeof(name) ); len = strlen(name) + 1; memcpy(pTask->module_name, name, min(len,sizeof(pTask->module_name))); pTask->compat_flags = GetProfileIntA( "Compatibility", name, 0 ); } /* Allocate a selector for the PDB */ pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB16), hModule, WINE_LDT_FLAGS_DATA ); /* Fill the PDB */ pTask->pdb.int20 = 0x20cd; pTask->pdb.dispatcher[0] = 0x9a; /* ljmp */ proc = GetProcAddress16( GetModuleHandle16("KERNEL"), "DOS3Call" ); memcpy( &pTask->pdb.dispatcher[1], &proc, sizeof(proc) ); pTask->pdb.savedint22 = 0; pTask->pdb.savedint23 = 0; pTask->pdb.savedint24 = 0; pTask->pdb.fileHandlesPtr = MAKESEGPTR( GlobalHandleToSel16(pTask->hPDB), FIELD_OFFSET( PDB16, fileHandles )); pTask->pdb.hFileHandles = 0; memset( pTask->pdb.fileHandles, 0xff, sizeof(pTask->pdb.fileHandles) ); /* FIXME: should we make a copy of the environment? */ pTask->pdb.environment = SELECTOROF(GetDOSEnvironment16()); pTask->pdb.nbFiles = 20; /* Fill the command line */ if (!cmdline) { cmdline = GetCommandLineA(); /* remove the first word (program name) */ if (*cmdline == '"') if (!(cmdline = strchr( cmdline+1, '"' ))) cmdline = GetCommandLineA(); while (*cmdline && (*cmdline != ' ') && (*cmdline != '\t')) cmdline++; while ((*cmdline == ' ') || (*cmdline == '\t')) cmdline++; len = strlen(cmdline); } if (len >= sizeof(pTask->pdb.cmdLine)) len = sizeof(pTask->pdb.cmdLine)-1; pTask->pdb.cmdLine[0] = len; memcpy( pTask->pdb.cmdLine + 1, cmdline, len ); /* pTask->pdb.cmdLine[len+1] = 0; */ TRACE("cmdline='%.*s' task=%04x\n", len, cmdline, hTask ); /* Allocate a code segment alias for the TDB */ pTask->hCSAlias = GLOBAL_CreateBlock( GMEM_FIXED, pTask, sizeof(TDB), pTask->hPDB, WINE_LDT_FLAGS_CODE ); /* Default DTA overwrites command line */ pTask->dta = MAKESEGPTR( pTask->hPDB, FIELD_OFFSET( PDB16, cmdLine )); /* Create scheduler event for 16-bit tasks */ if ( !(pTask->flags & TDBF_WIN32) ) NtCreateEvent( &pTask->hEvent, EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE ); if (!initial_task) initial_task = hTask; return pTask; }
/************************************************************************* * 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; }