自学教程：C++ GlobalLock16函数代码示例

/********************************************************************** *	    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;}

/*********************************************************************** *           GetInstanceData   (KERNEL.54) */INT16 WINAPI GetInstanceData16( HINSTANCE16 instance, WORD buffer, INT16 len ){    char *ptr = GlobalLock16( instance );    if (!ptr || !len) return 0;    if ((int)buffer + len >= 0x10000) len = 0x10000 - buffer;    memcpy( (char *)GlobalLock16(CURRENT_DS) + buffer, ptr + buffer, len );    return len;}

/*********************************************************************** *           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;}

/*********************************************************************** *           SetCurrentDirectory   (KERNEL.412) */BOOL16 WINAPI SetCurrentDirectory16( LPCSTR dir ){    char fulldir[MAX_PATH];    if (!GetFullPathNameA( dir, MAX_PATH, fulldir, NULL )) return FALSE;    if (!SetCurrentDirectoryA( dir )) return FALSE;    if (fulldir[0] && fulldir[1] == ':')    {        TDB *pTask = GlobalLock16( GetCurrentTask() );        char env_var[4] = "=A:";        env_var[1] = fulldir[0];        SetEnvironmentVariableA( env_var, fulldir );        /* update the directory in the TDB */        if (pTask)        {            pTask->curdrive = 0x80 | (fulldir[0] - 'A');            GetShortPathNameA( fulldir + 2, pTask->curdir, sizeof(pTask->curdir) );        }    }    return TRUE;}

static void MZ_Launch( LPCSTR cmdtail, int length ){  TDB *pTask = GlobalLock16( GetCurrentTask() );  BYTE *psp_start = PTR_REAL_TO_LIN( DOSVM_psp, 0 );  DWORD rv;  SYSLEVEL *lock;  MZ_FillPSP(psp_start, cmdtail, length);  pTask->flags |= TDBF_WINOLDAP;  /* DTA is set to PSP:0080h when a program is started. */  pTask->dta = MAKESEGPTR( DOSVM_psp, 0x80 );  GetpWin16Lock( &lock );  _LeaveSysLevel( lock );  ResumeThread(dosvm_thread);  rv = DOSVM_Loop(dosvm_thread);  CloseHandle(dosvm_thread);  dosvm_thread = 0; dosvm_tid = 0;  CloseHandle(loop_thread);  loop_thread = 0; loop_tid = 0;  VGA_Clean();  ExitProcess(rv);}

/*********************************************************************** *           K32WOWHandle32              (KERNEL32.57) */HANDLE WINAPI K32WOWHandle32( WORD handle, WOW_HANDLE_TYPE type ){    switch ( type )    {    case WOW_TYPE_HWND:    case WOW_TYPE_HMENU:    case WOW_TYPE_HDWP:    case WOW_TYPE_HDROP:    case WOW_TYPE_HDC:    case WOW_TYPE_HFONT:    case WOW_TYPE_HRGN:    case WOW_TYPE_HBITMAP:    case WOW_TYPE_HBRUSH:    case WOW_TYPE_HPALETTE:    case WOW_TYPE_HPEN:    case WOW_TYPE_HACCEL:        return (HANDLE)(ULONG_PTR)handle;    case WOW_TYPE_HMETAFILE:        FIXME( "conversion of metafile handles not supported yet/n" );        return (HANDLE)(ULONG_PTR)handle;    case WOW_TYPE_HTASK:        return ((TDB *)GlobalLock16(handle))->teb->ClientId.UniqueThread;    case WOW_TYPE_FULLHWND:        FIXME( "conversion of full window handles not supported yet/n" );        return (HANDLE)(ULONG_PTR)handle;    default:        ERR( "handle 0x%04x of unknown type %d/n", handle, type );        return (HANDLE)(ULONG_PTR)handle;    }}

/*********************************************************************** *           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 );}

/*********************************************************************** *           TASK_AllocThunk * * Allocate a thunk for MakeProcInstance(). */static SEGPTR TASK_AllocThunk(void){    TDB *pTask;    THUNKS *pThunk;    WORD sel, base;    if (!(pTask = TASK_GetCurrent())) return 0;    sel = pTask->hCSAlias;    pThunk = (THUNKS *)pTask->thunks;    base = (char *)pThunk - (char *)pTask;    while (!pThunk->free)    {        sel = pThunk->next;        if (!sel)  /* Allocate a new segment */        {            sel = GLOBAL_Alloc( GMEM_FIXED, FIELD_OFFSET( THUNKS, thunks[MIN_THUNKS] ),                                pTask->hPDB, WINE_LDT_FLAGS_CODE );            if (!sel) return 0;            TASK_CreateThunks( sel, 0, MIN_THUNKS );            pThunk->next = sel;        }        pThunk = GlobalLock16( sel );        base = 0;    }    base += pThunk->free;    pThunk->free = *(WORD *)((BYTE *)pThunk + pThunk->free);    return MAKESEGPTR( sel, base );}

/************************************************************************* *				DragQueryFile		[SHELL.11] */UINT16 WINAPI DragQueryFile16(	HDROP16 hDrop,	WORD wFile,	LPSTR lpszFile,	WORD wLength){ 	LPSTR lpDrop;	UINT i = 0;	LPDROPFILESTRUCT16 lpDropFileStruct = (LPDROPFILESTRUCT16) GlobalLock16(hDrop);	TRACE("(%04x, %x, %p, %u)/n", hDrop,wFile,lpszFile,wLength);	if(!lpDropFileStruct) goto end;	lpDrop = (LPSTR) lpDropFileStruct + lpDropFileStruct->wSize;	while (i++ < wFile)	{	  while (*lpDrop++); /* skip filename */	  if (!*lpDrop)	  {	    i = (wFile == 0xFFFF) ? i : 0;	    goto end;	  }	}	i = strlen(lpDrop);	if (!lpszFile ) goto end;   /* needed buffer size */	lstrcpynA (lpszFile, lpDrop, wLength);end:	GlobalUnlock16(hDrop);	return i;}

static DWORD MZ_Launch( LPCSTR cmdtail, int length ){  TDB *pTask = GlobalLock16( GetCurrentTask() );  BYTE *psp_start = PTR_REAL_TO_LIN( DOSVM_psp, 0 );  DWORD rv;  SYSLEVEL *lock;  MSG msg;  MZ_FillPSP(psp_start, cmdtail, length);  pTask->flags |= TDBF_WINOLDAP;  /* DTA is set to PSP:0080h when a program is started. */  pTask->dta = MAKESEGPTR( DOSVM_psp, 0x80 );  GetpWin16Lock( &lock );  _LeaveSysLevel( lock );  /* force the message queue to be created */  PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);  ResumeThread(dosvm_thread);  rv = DOSVM_Loop(dosvm_thread);  CloseHandle(dosvm_thread);  dosvm_thread = 0; dosvm_tid = 0;  CloseHandle(loop_thread);  loop_thread = 0; loop_tid = 0;  if (rv) return rv;  VGA_Clean();  ExitProcess(0);}

/****************************************************************************** * 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;}

/*********************************************************************** *           KERNEL thread initialisation routine */static void thread_attach(void){    /* allocate the 16-bit stack (FIXME: should be done lazily) */    HGLOBAL16 hstack = WOWGlobalAlloc16( GMEM_FIXED, 0x10000 );    kernel_get_thread_data()->stack_sel = GlobalHandleToSel16( hstack );    NtCurrentTeb()->WOW32Reserved = (void *)MAKESEGPTR( kernel_get_thread_data()->stack_sel,                                                        0x10000 - sizeof(STACK16FRAME) );    memset( (char *)GlobalLock16(hstack) + 0x10000 - sizeof(STACK16FRAME), 0, sizeof(STACK16FRAME) );}

/*********************************************************************** *           GetExePtrHelper */static inline HMODULE16 GetExePtrHelper( HANDLE16 handle, HTASK16 *hTask ){    char *ptr;    HANDLE16 owner;      /* Check for module handle */    if (!(ptr = GlobalLock16( handle ))) return 0;    if (((NE_MODULE *)ptr)->ne_magic == IMAGE_OS2_SIGNATURE) return handle;      /* Search for this handle inside all tasks */    *hTask = hFirstTask;    while (*hTask)    {        TDB *pTask = TASK_GetPtr( *hTask );        if ((*hTask == handle) ||            (pTask->hInstance == handle) ||            (pTask->hQueue == handle) ||            (pTask->hPDB == handle)) return pTask->hModule;        *hTask = pTask->hNext;    }      /* Check the owner for module handle */    owner = FarGetOwner16( handle );    if (!(ptr = GlobalLock16( owner ))) return 0;    if (((NE_MODULE *)ptr)->ne_magic == IMAGE_OS2_SIGNATURE) return owner;      /* Search for the owner inside all tasks */    *hTask = hFirstTask;    while (*hTask)    {        TDB *pTask = TASK_GetPtr( *hTask );        if ((*hTask == owner) ||            (pTask->hInstance == owner) ||            (pTask->hQueue == owner) ||            (pTask->hPDB == owner)) return pTask->hModule;        *hTask = pTask->hNext;    }    return 0;}

static HICON convert_icon_to_32( HICON16 icon16 ){    CURSORICONINFO *info = GlobalLock16( icon16 );    void *and_bits = info + 1;    void *xor_bits = (BYTE *)and_bits + info->nHeight * 2 * ((info->nWidth + 15) / 16);    HICON ret = CreateIcon( 0, info->nWidth, info->nHeight, info->bPlanes, info->bBitsPerPixel,                            and_bits, xor_bits );    GlobalUnlock16( icon16 );    return ret;}

/********************************************************************** *	    TASK_GetCodeSegment * * Helper function for GetCodeHandle/GetCodeInfo: Retrieve the module * and logical segment number of a given code segment. * * 'proc' either *is* already a pair of module handle and segment number, * in which case there's nothing to do.  Otherwise, it is a pointer to * a function, and we need to retrieve the code segment.  If the pointer * happens to point to a thunk, we'll retrieve info about the code segment * where the function pointed to by the thunk resides, not the thunk itself. * * FIXME: if 'proc' is a SNOOP16 return stub, we should retrieve info about *        the function the snoop code will return to ... * */static BOOL TASK_GetCodeSegment( FARPROC16 proc, NE_MODULE **ppModule,                                 SEGTABLEENTRY **ppSeg, int *pSegNr ){    NE_MODULE *pModule = NULL;    SEGTABLEENTRY *pSeg = NULL;    int segNr=0;    /* Try pair of module handle / segment number */    pModule = GlobalLock16( HIWORD( proc ) );    if ( pModule && pModule->ne_magic == IMAGE_OS2_SIGNATURE )    {        segNr = LOWORD( proc );        if ( segNr && segNr <= pModule->ne_cseg )            pSeg = NE_SEG_TABLE( pModule ) + segNr-1;    }    /* Try thunk or function */    else    {        BYTE *thunk = MapSL( (SEGPTR)proc );        WORD selector;        if ((thunk[0] == 0xb8) && (thunk[3] == 0xea))            selector = thunk[6] + (thunk[7] << 8);        else            selector = HIWORD( proc );        pModule = NE_GetPtr( GlobalHandle16( selector ) );        pSeg = pModule? NE_SEG_TABLE( pModule ) : NULL;        if ( pModule )            for ( segNr = 1; segNr <= pModule->ne_cseg; segNr++, pSeg++ )                if ( GlobalHandleToSel16(pSeg->hSeg) == selector )                    break;        if ( pModule && segNr > pModule->ne_cseg )            pSeg = NULL;    }    /* Abort if segment not found */    if ( !pModule || !pSeg )        return FALSE;    /* Return segment data */    if ( ppModule ) *ppModule = pModule;    if ( ppSeg    ) *ppSeg    = pSeg;    if ( pSegNr   ) *pSegNr   = segNr;    return TRUE;}

/************************************************************************* *				DragQueryPoint		[SHELL.13] */BOOL16 WINAPI DragQueryPoint16(HDROP16 hDrop, POINT16 *p){  LPDROPFILESTRUCT16 lpDropFileStruct;  BOOL16           bRet;  TRACE("/n");  lpDropFileStruct = (LPDROPFILESTRUCT16) GlobalLock16(hDrop);  memcpy(p,&lpDropFileStruct->ptMousePos,sizeof(POINT16));  bRet = lpDropFileStruct->fInNonClientArea;  GlobalUnlock16(hDrop);  return bRet;}

/*********************************************************************** *           TASK_CreateThunks * * Create a thunk free-list in segment 'handle', starting from offset 'offset' * and containing 'count' entries. */static void TASK_CreateThunks( HGLOBAL16 handle, WORD offset, WORD count ){    int i;    THUNKS *pThunk;    pThunk = (THUNKS *)((BYTE *)GlobalLock16( handle ) + offset);    pThunk->next = 0;    pThunk->magic = THUNK_MAGIC;    pThunk->free = FIELD_OFFSET( THUNKS, thunks );    for (i = 0; i < count-1; i++)        *(WORD *)&pThunk->thunks[i] = FIELD_OFFSET( THUNKS, thunks[i+1] );    *(WORD *)&pThunk->thunks[i] = 0;  /* Last thunk */}

/************************************************************************** *           WINHELP entry point * * FIXME: should go into winhlp32.exe, but we don't support 16-bit modules in executables yet. */void WINAPI WINHELP_EntryPoint( CONTEXT86 *context ){    static const WCHAR winhlp32W[] = {'//','w','i','n','h','l','p','3','2','.','e','x','e',0};    PDB16 *psp;    INT len, total;    WCHAR *cmdline, *p;    PROCESS_INFORMATION info;    STARTUPINFOW startup;    DWORD count, exit_code = 1;    InitTask16( context );    TRACE( "(ds=%x es=%x fs=%x gs=%x, bx=%04x cx=%04x di=%04x si=%x)/n",            context->SegDs, context->SegEs, context->SegFs, context->SegGs,            context->Ebx, context->Ecx, context->Edi, context->Esi );    psp = GlobalLock16( context->SegEs );    len = MultiByteToWideChar( CP_ACP, 0, (char *)psp->cmdLine + 1, psp->cmdLine[0], NULL, 0 );    total = (GetSystemDirectoryW( NULL, 0 ) + len + 1) * sizeof(WCHAR) + sizeof(winhlp32W);    cmdline = HeapAlloc( GetProcessHeap(), 0, total );    GetSystemDirectoryW( cmdline, total );    lstrcatW( cmdline, winhlp32W );    p = cmdline + lstrlenW(cmdline);    if (len)    {        *p++ = ' ';        MultiByteToWideChar( CP_ACP, 0, (char *)psp->cmdLine + 1, psp->cmdLine[0], p, len );        p[len] = 0;    }    memset( &startup, 0, sizeof(startup) );    startup.cb = sizeof(startup);    if (CreateProcessW( NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info ))    {        /* Give 10 seconds to the app to come up */        if (wait_input_idle( info.hProcess, 10000 ) == WAIT_FAILED)            WARN("WaitForInputIdle failed: Error %d/n", GetLastError() );        ReleaseThunkLock( &count );        WaitForSingleObject( info.hProcess, INFINITE );        GetExitCodeProcess( info.hProcess, &exit_code );        CloseHandle( info.hThread );        CloseHandle( info.hProcess );    }    else        ReleaseThunkLock( &count );    HeapFree( GetProcessHeap(), 0, cmdline );    ExitThread( exit_code );}

/************************************************************************* *           FindNextFile   (KERNEL.414) */BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATAA *data ){    HANDLE *ptr;    BOOL ret = FALSE;    if ((handle == INVALID_HANDLE_VALUE16) || !(ptr = GlobalLock16( handle )))    {        SetLastError( ERROR_INVALID_HANDLE );        return ret;    }    ret = FindNextFileA( *ptr, data );    GlobalUnlock16( handle );    return ret;}

/************************************************************************* *           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;}

/****************************************************************** *         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;}

/*********************************************************************** *           TASK_CreateThunks * * Create a thunk free-list in segment 'handle', starting from offset 'offset' * and containing 'count' entries. */static void TASK_CreateThunks( HGLOBAL16 handle, WORD offset, WORD count ){    int i;    WORD free;    THUNKS *pThunk;    pThunk = (THUNKS *)((BYTE *)GlobalLock16( handle ) + offset);    pThunk->next = 0;    pThunk->magic = THUNK_MAGIC;    pThunk->free = (int)&pThunk->thunks - (int)pThunk;    free = pThunk->free;    for (i = 0; i < count-1; i++)    {        free += 8;  /* Offset of next thunk */        pThunk->thunks[4*i] = free;    }    pThunk->thunks[4*i] = 0;  /* Last thunk */}

/********************************************************************** *          DOSVM_GetPMHandler16 * * Return the protected mode interrupt vector for a given interrupt. */FARPROC16 DOSVM_GetPMHandler16( BYTE intnum ){    TDB *pTask;    FARPROC16 proc = 0;    pTask = GlobalLock16(GetCurrentTask());    if (pTask)    {        switch( intnum )        {        case 0x00:            proc = pTask->int0;            break;        case 0x02:            proc = pTask->int2;            break;        case 0x04:            proc = pTask->int4;            break;        case 0x06:            proc = pTask->int6;            break;        case 0x07:            proc = pTask->int7;            break;        case 0x3e:            proc = pTask->int3e;            break;        case 0x75:            proc = pTask->int75;            break;        }        if( proc )            return proc;    }    if (!DOSVM_Vectors16[intnum])    {        proc = (FARPROC16)MAKESEGPTR( DOSVM_dpmi_segments->int16_sel,                                                DOSVM_STUB_PM16 * intnum );        DOSVM_Vectors16[intnum] = proc;    }    return DOSVM_Vectors16[intnum];}

/************************************************************************* *			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;}

/************************************************************************** *           WINOLDAP entry point */void WINAPI WINOLDAP_EntryPoint( CONTEXT86 *context ){    PDB16 *psp;    INT len;    LPSTR cmdline;    PROCESS_INFORMATION info;    STARTUPINFOA startup;    DWORD count, exit_code = 1;    InitTask16( context );    TRACE( "(ds=%x es=%x fs=%x gs=%x, bx=%04x cx=%04x di=%04x si=%x)/n",            context->SegDs, context->SegEs, context->SegFs, context->SegGs,            context->Ebx, context->Ecx, context->Edi, context->Esi );    psp = GlobalLock16( context->SegEs );    len = psp->cmdLine[0];    cmdline = HeapAlloc( GetProcessHeap(), 0, len + 1 );    memcpy( cmdline, psp->cmdLine + 1, len );    cmdline[len] = 0;    memset( &startup, 0, sizeof(startup) );    startup.cb = sizeof(startup);    if (CreateProcessA( NULL, cmdline, NULL, NULL, FALSE,                        0, NULL, NULL, &startup, &info ))    {        /* Give 10 seconds to the app to come up */        if (wait_input_idle( info.hProcess, 10000 ) == WAIT_FAILED)            WARN("WaitForInputIdle failed: Error %d/n", GetLastError() );        ReleaseThunkLock( &count );        WaitForSingleObject( info.hProcess, INFINITE );        GetExitCodeProcess( info.hProcess, &exit_code );        CloseHandle( info.hThread );        CloseHandle( info.hProcess );    }    else        ReleaseThunkLock( &count );    HeapFree( GetProcessHeap(), 0, cmdline );    ExitThread( exit_code );}

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;}

/*********************************************************************** *           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 );}

/*********************************************************************** *           TASK_FreeThunk * * Free a MakeProcInstance() thunk. */static BOOL TASK_FreeThunk( SEGPTR thunk ){    TDB *pTask;    THUNKS *pThunk;    WORD sel, base;    if (!(pTask = TASK_GetCurrent())) return 0;    sel = pTask->hCSAlias;    pThunk = (THUNKS *)pTask->thunks;    base = (char *)pThunk - (char *)pTask;    while (sel && (sel != HIWORD(thunk)))    {        sel = pThunk->next;        pThunk = GlobalLock16( sel );        base = 0;    }    if (!sel) return FALSE;    *(WORD *)((BYTE *)pThunk + LOWORD(thunk) - base) = pThunk->free;    pThunk->free = LOWORD(thunk) - base;    return TRUE;}