IBM Developer's Migration Kit/2

Table of Contents

IBM Announcement Letter No. ZP92-0612 dated August 18, 1992.

  • Title
  • Program Number
  • Abstract
  • General Availability
  • Highlights
  • Description
  • Growth Enablement
  • Investment Protection
  • User Productivity
  • Product Positioning
  • Publications
  • Technical Information
  • Specified Operating Environment
  • Design Issues
  • Supporting the API
  • Internal Structures
  • Windows Controls
  • Dialog Manager
  • Design Considerations
  • Callback Functions
  • OS/2 Application Icons
  • Shared Memory Among Processes
  • Library Management
  • Alphabetical Reference for Windows Functions
  • Planning Information
  • Security, Auditability and Control
  • Charges, Terms & Conditions for COU Program Package
  • Charges
  • Terms and Conditions
  • Announcement Countries

  • IBM Announcement Letter No. ZP92-0612 dated August 18, 1992.

    See final section for details of availability and limitations.


    IBM Developer's Migration Kit/2

    Program Number

    Order Type   Part         Program
    Number       Number       Name
    5604-404     41G2943      IBM Developer's Migration Kit/2


    The IBM Developer's Migration Kit/2 contains conversion utilities that allow developers of Windows(*) 3.0 applications to convert their products into OS/2 2.0 applications. The kit protects the developer's investment in Windows 3.0 source code while enabling the developer's product to take advantage of OS/2 2.0's advanced function and API.

    * - Windows is a trademark of the Microsoft Corporation.

    General Availability

    Planned General Availability Date is September 1992



    Growth Enablement

    The IBM Developer's Migration Kit/2 allows software developers to extend beyond the limitations of their Windows 3.0 applications. Using the kit to migrate to OS/2 2.0, developers can access advanced operating system functions such as multithreading and protected memory. These OS/2-enabled products can take advantage of the operating system's capabilities. The IBM Developer's Migration Kit/2 can expand the functionality of a developer's product, enabling the creation and implementation of new solutions to customer needs.

    By using the IBM Developer's Migration Kit/2 to create OS/2 applications, developers can gain a foothold in the growing installed base of OS/2 2.0 systems.

    Investment Protection

    The IBM Developer's Migration Kit/2 enables Windows software developers to create OS/2 2.0 versions of their products without a complete rewrite of existing Windows code. Their investment in the development of Windows code is protected -- use of the kit can produce Windows and OS/2 2.0 products from a single source.

    User Productivity

    Developer Productivity. The kit enables software developers to reuse their Windows 3.0 source code to build OS/2 products. Code reuse can significantly reduce product development time and effort. The kit also allows for the incremental addition of OS/2 function, smoothing the migration path from Windows 3.0 to OS/2 2.0 and reducing the "cost" of learning the advanced function of OS/2. Developers are able to produce OS/2 2.0 applications even before in-depth proficiencies in OS/2 APIs are developed.

    Customer Productivity. Using the kit, developers can take advantage of OS/2 2.0's advanced functionality such as multiple thread support. The kit can expand the functionality of a developer's product, enabling the creation and implementation of new solutions to customer needs.

    Product Positioning

    The IBM Developer's Migration Kit/2 is targeted primarily toward developers wishing to produce OS/2 2.0 applications from existing Windows 3.0 application code. Use of the kit requires the IBM Developer's Toolkit for OS/2 2.0.

    The amount of effort required to port applications using the kit is dependent upon the design and implementation of the Windows source code to be ported. Some developers may be able to migrate their products without any code changes; some may require only minor code modifications. Others may have significant design issues that must be resolved before successful migration with the kit; in-depth knowledge of the source code to be ported is essential. Refer to the Technical Information (Limitations) section for more information.


    The following ship-group publications may be ordered separately from IBM after availability. To order, contact your IBM representative.
          Title                                  Order Number
    -----------------------------------------    ------------
    IBM Developer's Migration Kit/2:
    Application Migration Guide and Reference      41G2944

    Technical Information

    Specified Operating Environment

    Machine Requirements

    The IBM Developer's Migration Kit/2 is designed to run as follows:

    Programming Requirements

    The IBM Developer's Migration Kit/2 and generated object programs will run only under IBM OS/2 2.0 (5621-077) with or without IBM Extended Services (5621-213) for OS/2.

    Use of the kit also requires:


    Applications using the IBM Developer's Migration Kit/2 will not run on previous versions of OS/2.


    Due to the technical complexity of the porting layer in the IBM Developer's Migration Kit/2, some changes or redesign of the Windows 3.0 source code may be necessary. The following information describes some restrictions of the kit.

    Design Issues

    Applications built using the kit utilize a dynamic link library (DLL) in OS/2 2.0 named Mirrors. Mirrors is a 32-bit DLL, which provides a thunking layer to convert 16-bit ported Windows API to 32-bit internal code. A thunking layer provides a translation layer between the 16-bit and 32-bit addressing schemes. This thunk is necessary because of the different addressing schemes used in 16-bit and 32-bit environments.

    For example, in the ported environment, when an application calls a Windows function such as GlobalAlloc, it is actually calling the function GlobalAlloc16, which determines the parameters (if any) that need to be converted, sets up a 32-bit stack, and makes a call to the 32-bit version of GlobalAlloc, which performs all the "real" work.

    Supporting the API

    Mirrors implements the supported API as documented in Windows. Notice that no other support is guaranteed. If a Windows function behaves differently from the documented behavior, Mirrors follows the actual Windows behavior.

    Internal Structures

    Mirrors maintains a number of internal data structures. Whereas a ported application would cause the creation and maintenance of a data structure within Windows, the structure is created and maintained by Mirrors. Mirrors can also create a similar structure within the Presentation Manager (PM) environment. For example, a ported Windows application might need to create a device context (DC). PM has a similar entity called a presentation space. Although similar, a presentation space is not identical to a Windows device context. Therefore, when a ported application needs to create a device context, Mirrors creates a presentation space in the PM environment and maintains structures to give the application the appearance of interacting with a device context.

    When the ported Windows application opens a device context, Mirrors returns a 16-bit handle to the application. The application can act on this handle as if it were a handle to a Windows device context. In actuality, Mirrors is maintaining a structure for this device context, which also includes a 32-bit value to the PM presentation space.

    Consider what happens when an application attempts to use a value from this device context. For example, if the ported Windows application tried to set the text color, the text color would be set in the Mirrors structure and also set in the PM presentation space. This arrangement enables Mirrors to perform some optimization. The application might set the text color five times in a row without realizing an object which uses that color. Although Mirrors changes the color in its internal device context structure and returns the previous color, it does not pass this change on to the PM presentation space until there is some demand for the color change such as a call to TextOut. Therefore, if the application does not make calls to use these intermediate colors, Mirrors can reduce the number of instruction cycles. This can save a considerable amount of time.

    Windows Controls

    All the Windows controls, which would ordinarily be realized by Windows, are actually realized by Mirrors. They are windows that Mirrors draws and maintains to emulate a Presentation Manager control. The ported Windows application and the Mirrors DLL combined are essentially a PM application. For example, when your application creates a button, Mirrors does not create a Presentation Manager button. Mirrors creates its own window registered as a button class. Messages are sent to this window in the same fashion as they would be for Windows even though it is neither a PM button nor a Windows button.

    Dialog Manager

    Dialog boxes are created and maintained by Mirrors. The Presentation Manager Dialog Box Manager is not used.

    Design Considerations

    The following list contains important design assumptions and constraints. Ensure that your application satisfies these items before beginning the porting process.

    Previous Instance Handle

    The previous instance handle passed to a ported application is always NULL. Windows performs in a similar manner to a shell under DOS, that is, it is aware of all the applications that might be running under it. Because Mirrors is simply an additional DLL running under OS/2 2.0, it cannot be aware of all the other processes running under OS/2 management. Therefore, Mirrors cannot determine whether any previous instances of the application are running.

    Synchronization Between Applications

    Under Windows, an application does not relinquish control of the CPU until GetMessage or PeekMessage is called. Under OS/2 2.0, an application can have control taken away at any time because OS/2 2.0 is a preemptive operating system. An application dependent upon Windows-style operation might experience unexpected problems. For example, suppose Program A calls the function LoadModule to start a second application (Program B), and that Program A depends on data that Program B sets prior to calling GetMessage. Under OS/2 2.0, Program A can continue as soon as the LoadModule call is complete and prior to beginning Program B's execution. Programs A and B must synchronize their activities with a PM semaphore and the OS/2 function WinMsgSemWait.

    Synchronizing Applications that Use DDE

    Applications that use a PeekMessage loop to wait for a specific message to be posted from another application should call Yield() before each call to PeekMessage. This is commonly done when using DDE and the application is waiting for a WM_DDE_ACK message in response to a posted WM_DDE_DATA message. Because the applications are running in a pre-emptive multitasking environment, it is difficult to determine when a task will receive the CPU and how much CPU time a particular task will receive for processing. Typically, the currently active task has the highest priority and will receive more CPU time than other tasks. This can cause the task, which is awaiting response from a server application, to timeout of its PeekMessage loop and assume a negative acknowledgement. By calling Yield(), the application is releasing its CPU time for other applications to run. This will usually be enough time for the server application to process some messages and post its acknowledgement. For example:

    dwTime = GetCurrentTime();
    while (GetCurrentTime() - dwTime < DDE_TIMEOUT)
      if (PeekMessage (&msg,hwnd,WM_DDE_ACK,WM_DDE_ACK,PM_REMOVE))

    Using C-Compiler Library Functions

    If a function exists within the Windows API or the Mirrors extensions to that API, use that function rather than a similar function from the library of the compiler used to develop the software. This is necessary to guarantee proper operation of certain functions within the Windows environment. For example, if a program uses the C function exit to terminate a function's operation instead of using a return, memory might not be freed by Windows or Mirrors and the proper values might not be returned in wParam and lParam.

    Registers and DLL Initialization

    OS/2 2.0 and Windows pass initialization data in different registers. Mirrors must correct this difference, therefore, it provides an include file MIRDLL.INC, which must be included as the first statement of the DLL initialization code. This include file will set up the registers as if they were under Windows. This file must be included if the DLL must receive the heapsize into the CX register and the address of the command line into ES :SI.

    Eliminating Improper Register Usage

    OS/2 2.0 has protected memory and Windows does not. Therefore, addressing is handled differently between the two systems. It is recommended not to assume the contents of the ES register across calls.

    In OS/2 2.0, values should not be stored into segment registers that were not returned by calls to the operating system because segments are selectors, and selectors are owned by processes. If an address value that has not been assigned to your process is calculated, your application will fail with a memory protection violation. In the worst case, if the calculated value matches a value that has been assigned to your process, the contents of memory are destroyed but this might not be discovered until some later point during processing.

    Multiple Document Interface (MDI) Differences

    The Restore button menu item for maximized MDI children (child windows) does not appear entirely right-justified in the menu. However, the functionality is not affected.

    Code Page Differences

    The Mirrors resource compiler can issue a message similar to the following:

        Code page 437 incompatible with Windows

    The IBM Developer's Migration Kit/2 resource compiler uses the code page directive from the CONFIG.SYS file on the development system. Notice that not all OS/2 code pages are compatible with Windows. Code page 437, which is frequently listed in this directive, is equivalent to the default IBM or IBM-compatible personal computer code page in the United States. This code page is not identical with the ANSI character set that Windows uses. Therefore, the kit's resource compiler issues a warning to notify you of possible differences.

    Generally, code page 437 will map correctly. However, code page 850 is closer to the one used by Windows. It is recommended that this code page be listed first in the code page directive of the OS/2 CONFIG.SYS on the development system, or that the -Gnnn option be used when calling the kit's resource compiler.

    Font Differences

    Many Windows applications assume that the sum of the extent of individual characters in a string is equal to the extent of the string. This is true for Windows but might not be true for OS/2 2.0. PM outline fonts support kerning pairs; Windows outline fonts do not. If your application relies on this action in Windows, it might need to be changed.

    The following short code sample is an illustration.

        DWORD   lCharSize = 0L;
        DWORD   lStrSize = 0L;
        lCharSize  = LOWORD(GetTextExtent(hDC,"M",1));
        lCharSize += LOWORD(GetTextExtent(hDC,"l",1));
        lStrSize   = LOWORD(GetTextExtent(hDC,"Ml",2));

    Notice that lCharSize will not always equal lStrSize in a ported Mirrors application.

    Font Mapping

    The fonts available to your ported application when it is run under OS/2 2.0 is different from those available under Windows. Therefore, some mapping must be done. The mapping algorithm used by Mirrors is the same as the font-mapping algorithm described in the Windows documentation.

    This means that the font chosen for your application will be the same font that Windows would have chosen if the font had been available. For example, the algorithm will map a Modern vector font to a Courier outline font, which is what Windows would do if it were presented with the same set of choices.

    Under Windows, outline and bit-map fonts do not have the same name. However, it is possible under OS/2 2.0 to have a font named HELV for both a bit map and an outline font. To prevent confusion for the ported application, Mirrors renames the outline fonts under Presentation Manager to append the string "outline" so that the ported Windows application can tell the difference between the two.

    Printer Properties and Job Properties

    Properties associated with printers are conceptually different between OS/2 2.0 and Windows. The Presentation Manager design has two categories of information associated with printers, printer properties and job properties. Printer properties involve more permanent aspects of the printer such as whether a printer has a tractor feed or not. Job properties are properties that can easily change between output such as printing in landscape or portrait orientation.

    In the ported Windows application, all references to the function DeviceMode should be changed to ExtDeviceMode. Initialization data obtained from this function should be saved and passed back to the CreateIC or CreateOC functions, which allow the program to change job properties such as orientation on a per-job basis rather than on a system-wide basis.

    Thunking and Packed Segments

    Mirrors must accomplish a certain amount of thunking to account for the different addressing schemes between the 32-bit memory model of OS/2 2.0 and the 16-bit world of Windows applications. Mirrors uses and expects a tiled memory scheme where the 16-bit segment addresses are evenly mapped into 64KB blocks in the 32-bit global memory. Because data segments are handled transparently by Mirrors, most programmers do not need to give this any attention. However, some programs attempt to use a scheme to read and write data from code segments. These code segments do not follow the same tiled-memory addressing scheme as data segments. Instead, they often follow a packed scheme. Therefore, Mirrors cannot correctly calculate the address to data placed in a code segment.

    If your application keeps data in a code segment, then the application is responsible for maintaining this data. It is strongly recommended that the application be modified to keep data in a data segment.

    Callback Functions

    All window and dialog callback functions must be exported in the DEF file. Notice that utility programs, such as FIXDS that modifies the executable file, will not work and should not be used.

    Because of the differences in stacksize requirements for a Windows application and a ported application, MIRDEF modifies the stacksize used during the link process.

    OS/2 Application Icons

    The icon, which OS/2 2.0 displays in a folder for the executable file, is determined by the following search order. Notice that the first icon found is used.

    1. ICON extended attribute.

    2. ICO file in the same directory as the executable file with the same prefix.

    3. Application-specific icon if PM or Windows executable file. The lowest-numbered icon or pointer resource.

    4. PM application icon (if executable), Windows application icon (if executable), OS/2 application icon (if OS/2 full-screen only executable), OS/2 window icon (if OS/2 window-compatible executable), DOS window icon (if DOS window executable), or Program application icon (if unknown type executable).

    It is recommended that your application icon be defined as the lowest-numbered icon or cursor resource in your resource file.

    Shared Memory Among Processes

    The concepts of processes and threads are new to many Windows programmers. A program executing within the DOS and Windows environment can be thought of as a single process with a single thread of execution. Access to system resources is shared among individual programs without strict controls. An executable file within OS/2 2.0 is a single process but that process can have many threads of execution within it. Because OS/2 2.0 is a true multitasking system, access to system resources is managed much more closely. The granularity of memory management is at the process level in OS/2 2.0 rather than at the program level as in DOS or Windows. Separate executing programs are not simply different threads of execution; they are different processes entirely and cannot overlap system resources without explicit declaration.

    Separate programs running under DOS or Windows can share blocks of memory because of the rather free manner in which DOS or Windows manage access to memory. Essentially, if a program can obtain a handle to a system resource such as global memory that program can access that memory even though it was not allocated by the program. However, due to the tighter controls which OS/2 2.0 places on memory, programs that might have acted together in a coordinated manner under the DOS and Windows combination might act differently under OS/2 2.0. A program cannot simply access memory anywhere in the system by using a memory handle.

    Under OS/2 2.0, memory that belongs to one process cannot be shared with another process without explicit declaration. This difference in memory management between the two environments can be overcome by following the coding suggestions below:

    Library Management

    The conceptual model for shared memory also applies to the differences to between Windows and OS/2 2.0 for their management of access to libraries. In Windows, a program can gain access to a DLL simply by obtaining a handle to that DLL. In OS/2 2.0, libraries must be explicitly linked against a process for the DLL to become available to that process. It can also become available to a process at run time by calling LoadLibrary.

    Alphabetical Reference for Windows Functions

    An alphabetical list is provided of all the functions that are part of the Windows environment. Each function is either fully supported, marked as supported with change, as extended support, or not supported.

    Fully supported functions perform as they would under Windows. Refer to the Windows Software Development Kit for descriptions of these functions.

    Function              Functional Area          Support Status
    _lclose               File I/O                  
    _lcreat               File I/O                  
    _llseek               File I/O                  
    _lopen                File I/O                  
    _lread                File I/O                  
    _lwrite               File I/O                  
    AccessResource        Resource management      Not supported
    AddAtom               Atom management           
    AddFontResource       Font                      
    AdjustWindowRect      Window creation           
    AdjustWindowRectEx    Window creation           
    AllocDStoCSAlias      Segment                  Not supported
    AllocResource         Resource management      Not supported
    AllocSelector         Segment                  Not supported
    AnimatePalette        Color palette             
    AnsiLower             String manipulation       
    AnsiLowerBuff         String manipulation       
    AnsiNext              String manipulation       
    AnsiPrev              String manipulation       
    AnsiToOem             String manipulation       
    AnsiToOemBuff         String manipulation       
    AnsiUpper             String manipulation       
    AnsiUpperBuff         String manipulation       
    AnyPopup              Information               
    AppendMenu            Menu                      
    Arc                   Line output               
     Windows              Display/movement          
     WindowPos            Display/movement          
    BeginPaint            Painting                  
    BitBlt                Bit map                   
    BringWindowToTop      Display/movement          
    BuildCommDCB          Communication            Not supported
    CallMsgFilter         Hook                     Supported
    CallWindowProc        Message                   
    Catch                 Task                      
     Chain                Clipboard                Supported
    ChangeMenu            Menu                      
    ChangeSelector        Segment                  Not supported
    CheckDlgButton        Dialog box                
    CheckMenuItem         Menu                      
    CheckRadioButton      Dialog box                
     Point                Coordinate/Info           
    Chord                 Ellipse & polygon
    ClearCommBreak        Communication            Not supported
    ClientToScreen        Coordinate                

    Function              Functional Area          Support Status
    ClipCursor            Cursor                    
    CloseClipboard        Clipboard                 
    CloseComm             Communication            Not supported
    CloseMetaFile         Metafile                  
    CloseSound            Sound                    Not supported
    CloseWindow           Display/movement          
    CombineRgn            Region                    
    CopyMetaFile          Metafile                  
    CopyRect              Rectangle                 
     Formats              Clipboard                 
    CountVoiceNotes       Sound                    Not supported
    CreateBitmap          Bit map                   
     Indirect             Bit map                   
     Indirect             Drawing tool              
    CreateCaret           Caret                     
     Bitmap               Bit map                   
    CreateCompatibleDC    Device context            
    CreateCursor          Cursor                    
    CreateDC              Device context            
    CreateDialog          Dialog box                
     Indirect             Dialog box                
     IndirectParam        Dialog box                
    CreateDialogParam     Dialog box                
    CreateDIBitmap        Device-ind. bit map       
     Brush                Drawing tool              
     Bitmap               Bit map                   
    CreateEllipticRgn     Region                    
     Indirect             Region                    
    CreateFont            Font                     Supported
    CreateFontIndirect    Font                     Supported
    CreateHatchBrush      Drawing tool             Supported
    CreateIC              Device context            
    CreateIcon            Painting                  
    CreateMenu            Menu                      
    CreateMenuIndirect    Menu                     Not supported
    CreateMetaFile        Metafile                  
    CreateOC              Device context           Supported
    CreatePalette         Color palette             
    CreatePatternBrush    Drawing tool              
    CreatePen             Drawing tool              

    Function              Functional Area          Support Status
    CreatePenIndirect     Drawing tool              
     PolygonRgn           Region                    
    CreatePolygonRgn      Region                    
    CreatePopupMenu       Menu                      
    CreateRectRgn         Region                    
     Indirect             Region                    
    CreateRoundRectRgn    Region                    
    CreateSolidBrush      Drawing tool              
    CreateWindow          Window creation           
    CreateWindowEx        Window creation           
    DebugBreak            Debugging                 
    DefDlgProc            Dialog box/
                          Window creation           
    DeferWindowPos        Display/movement          
    DefFrameProc          Window creation           
    DefHookProc           Hook                     Supported
    DefineHandleTable     Memory management        Not supported
    DefMDIChildProc       Window creation           
    DefWindowProc         Window creation           
    DeleteAtom            Atom management           
    DeleteDC              Device context            
    DeleteMenu            Menu                      
    DeleteMetaFile        Metafile                  
    DeleteObject          Drawing tool              
    DestroyCaret          Caret                     
    DestroyCursor         Cursor                    
    DestroyIcon           Painting                  
    DestroyMenu           Menu                      
    DestroyWindow         Window creation           
    DeviceCapabilities    Printer control          Supported
    DeviceMode            Printer control           
    DialogBox             Dialog box                
    DialogBoxIndirect     Dialog box                
     Param                Dialog box                
    DialogBoxParam        Dialog box                
    DispatchMessage       Message                   
    DlgDirList            Dialog box                
    DlgDirListComboBox    Dialog box                
    DlgDirSelect          Dialog box                
     ComboBox             Dialog box               Supported
    DOS3CALL              OS interrupt              
    DPtoLP                Coordinate                
    DrawFocusRect         Ellipse & polygon/
    DrawIcon              Painting                  

    Function              Functional Area          Support Status
    DrawMenuBar           Menu                      
    DrawText              Painting                  
    Ellipse               Ellipse & polygon
    EmptyClipboard        Clipboard                 
     Input                Hardware                  
    EnableMenuItem        Menu                      
    EnableWindow          Input                     
    EndDeferWindowPos     Display/movement          
    EndDialog             Dialog box                
    EndPaint              Painting                  
    EnumChildWindows      Information              Supported
     Formats              Clipboard                 
    EnumFonts             Font                      
    EnumMetaFile          Metafile                 Not supported
    EnumObjects           Drawing tool              
    EnumProps             Property                 Supported
    EnumTaskWindows       Information               
    EnumWindows           Information               
    EqualRect             Rectangle                 
    EqualRgn              Region                    
    Escape                Printer escape            
    EscapeCommFunction    Communication            Not supported
    ExcludeClipRect       Clipping                  
    ExcludeUpdateRgn      Painting                  
    ExitWindows           Task                     Supported
    ExtDeviceMode         Printer control          Supported
    ExtFloodFill          Bit map                   
    ExtTextOut            Text                      
    FatalAppExit          Debugging                 
    FatalExit             Debugging                 
    FillRect              Painting                  
    FillRgn               Region                    
    FindAtom              Atom management           
    FindResource          Resource management       
    FindWindow            Information               
    FlashWindow           Error                     
    FloodFill             Bit map                   
    FlushComm             Communication            Not supported
    FrameRect             Painting                  
    FrameRgn              Region                    
    FreeLibrary           Module management         
    FreeModule            Module management         
    FreeProcInstance      Module management         
    FreeResource          Resource management       
    FreeSelector          Segment                  Not supported
    GetActiveWindow       Input                     
     RatioFilter          Font                      

    Function              Functional Area          Support Status
    GetAsyncKeyState      Hardware                  
    GetAtomHandle         Atom management           
    GetAtomName           Atom management           
    GetBitmapBits         Bit map                   
     Dimension            Bit map                   
    GetBkColor            Drawing attribute         
    GetBkMode             Drawing attribute         
    GetBrushOrg           Drawing tool              
    GetCapture            Input                     
    GetCaretBlinkTime     Caret                     
    GetCaretPos           Caret                     
    GetCharWidth          Font                      
    GetClassInfo          Window creation           
    GetClassLong          Window creation           
    GetClassName          Window creation           
    GetClassWord          Window creation           
    GetClientRect         Display/movement          
    GetClipboardData      Clipboard                 
     FormatName           Clipboard                 
    GetClipboardOwner     Clipboard                 
    GetClipboardViewer    Clipboard                 
    GetClipBox            Clipping                  
    GetCodeHandle         Module management        Not supported
    GetCodeInfo           Segment                  Not supported
    GetCommError          Communication            Not supported
    GetCommEventMask      Communication            Not supported
    GetCommState          Communication            Not supported
    GetCurrentPDB         Task                     Not supported
    GetCurrentPosition    Line output               
    GetCurrentTask        Task                      
    GetCurrentTime        System                    
    GetCursorPos          Cursor                    
    GetDC                 Painting                  
    GetDCOrg              Device context            
    GetDesktopWindow      Information               
    GetDeviceCaps         Information               
    GetDialogBaseUnits    Dialog box                
    GetDIBits             Device-ind. bit map       
    GetDlgCtrlID          Dialog box                
    GetDlgItem            Dialog box                
    GetDlgItemInt         Dialog box                
    GetDlgItemText        Dialog box                
    GetDOSEnvironment     Task                      
    GetDoubleClickTime    Input                     
    GetDriveType          File I/O                  
    GetEnvironment        Environment               
    GetFocus              Input                     

    Function              Functional Area          Support Status
    GetFreeSpace          Memory management         
    GetInputState         Hardware                  
    GetInstanceData       Module management        Not supported
    GetKBCodePage         Hardware                  
    GetKeyboardState      Hardware                  
    GetKeyboardType       Hardware                  
    GetKeyNameText        Hardware                 Not supported
    GetKeyState           Hardware                  
    GetLastActivePopup    Window creation           
    GetMapMode            Mapping                   
    GetMenu               Menu                      
    Dimensions            Menu                      
    GetMenuItemCount      Menu                      
    GetMenuItemID         Menu                      
    GetMenuState          Menu                      
    GetMenuString         Menu                      
    GetMessage            Message                  Supported
    GetMessagePos         Message                   
    GetMessageTime        Message                   
    GetMetaFile           Metafile                  
    GetMetaFileBits       Metafile                 Supported
    GetModuleFileName     Module management         
    GetModuleHandle       Module management         
    GetModuleUsage        Module management         
    GetNearestColor       Color palette             
     Index                Color palette             
     GroupItem            Dialog box                
    GetNextDlgTabItem     Dialog box                
    GetNextWindow         Information               
    GetNumTasks           Task                      
    GetObject             Drawing tool              
    GetPaletteEntries     Color palette             
    GetParent             Information               
    GetPixel              Bit map                   
    GetPolyFillMode       Drawing attribute         
     ClipboardFormat      Clipboard                 
     ProfileInt           Initialization file       
     ProfileString        Initialization file      Supported
    GetProcAddress        Module management         
    GetProfileInt         Initialization file       
    GetProfileString      Initialization file      Supported
    GetProp               Property                  
    GetRgnBox             Region                    

    Function              Functional Area          Support Status
    GetROP2               Drawing attribute         
    GetScrollPos          Scrolling                 
    GetScrollRange        Scrolling                 
    GetStockObject        Drawing tool              
    GetStretchBltMode     Drawing attribute         
    GetSubMenu            Menu                      
    GetSysColors          System                   Supported
    GetSysModalWindow     Information               
    GetSystemDirectory    File I/O                  
    GetSystemMenu         Menu                      
    GetSystemMetrics      System                   Supported
     PaletteEntries       Color palette             
     PaletteUse           Color palette             
     TextExtent           Text                      
    GetTempDrive          File I/O                  
    GetTempFileName       File I/O                  
    GetTextAlign          Text                      
     Extra                Text                      
    GetTextColor          Drawing attribute         
    GetTextExtent         Text                      
    GetTextFace           Text                      
    GetTextMetrics        Text                      
    GetThresholdBuffer    Sound                    Not supported
    GetThresholdEvent     Sound                    Not supported
    GetThresholdStatus    Sound                    Not supported
    GetTickCount          Input                     
    GetTopWindow          Information               
    GetUpdateRect         Painting                  
    GetUpdateRgn          Painting                  
    GetVersion            Module management         
    GetViewportExt        Mapping                   
    GetViewportOrg        Mapping                   
    GetWindow             Information               
    GetWindowDC           Painting                  
    GetWindowExt          Mapping                   
    GetWindowLong         Window creation           
    GetWindowOrg          Mapping                   
    GetWindowRect         Display/movement          
     Directory            File I/O                  
    GetWindowTask         Information               
    GetWindowText         Display/movement          
     TextLength           Display/movement          
    GetWindowWord         Window creation           

    Function              Functional Area          Support Status
    GetWinFlags           Memory management        Extended support
     Alloc                WINMEM32.DLL             Not supported
     Free                 WINMEM32.DLL             Not supported
    Global32Alloc         WINMEM32.DLL             Not supported
    Global32CodeAlias     WINMEM32.DLL             Not supported
     AliasFree            WINMEM32.DLL             Not supported
    Global32Free          WINMEM32.DLL             Not supported
    Global32Realloc       WINMEM32.DLL             Not supported
    GlobalAddAtom         Atom management           
    GlobalAlloc           Memory management        Supported
    GlobalCompact         Memory management        Not supported
    GlobalDeleteAtom      Atom management           
    GlobalDiscard         Memory management        Not supported
    GlobalDosAlloc        Memory management        Not supported
    GlobalDosFree         Memory management        Not supported
    GlobalFindAtom        Atom management           
    GlobalFix             Segment                  Not supported
    GlobalFlags           Memory management         
    GlobalFree            Memory management         
    GlobalGetAtomName     Atom management           
    GlobalHandle          Memory management        Supported
    GlobalLock            Memory management         
    GlobalLRUNewest       Memory management         
    GlobalLRUOldest       Memory management         
    GlobalNotify          Memory management        Not supported
    GlobalPageLock        Segment                  Not supported
    GlobalPageUnlock      Segment                  Not supported
    GlobalReAlloc         Memory management         
    GlobalSize            Memory management         
    GlobalUnfix           Segment                  Not supported
    GlobalUnlock          Memory management         
    GlobalUnwire          Memory management        Supported
    GlobalWire            Memory management        Supported
    GrayString            Painting                  
    HideCaret             Caret                     
    HiliteMenuItem        Menu                      
    InflateRect           Rectangle                 
    InitAtomTable         Atom management           
    InSendMessage         Message                   
    InsertMenu            Menu                      
    IntersectClipRect     Clipping                  
    IntersectRect         Rectangle                 
    InvalidateRect        Region                    
    InvalidateRgn         Painting                  
    InvertRect            Painting                  
    InvertRgn             Region                    

    Function              Functional Area          Support Status
    IsCharAlpha           String manipulation       
    IsCharAlphaNumeric    String manipulation       
    IsCharLower           String manipulation       
    IsCharUpper           String manipulation       
    IsChild               Information               
     FormatAvailable      Clipboard                 
    IsDialogMessage       Dialog box                
    IsDlgButtonChecked    Dialog box                
    IsIconic              Display/movement          
    IsRectEmpty           Rectangle                 
    IsWindow              Information               
    IsWindowEnabled       Input                     
    IsWindowVisible       Display/movement          
    IsZoomed              Display/movement          
    KillTimer             Input                     
    LimitEMSPages         Memory management        Not supported
    LineDDA               Line output               
    LineTo                Line output               
    LoadAccelerators      Resource management       
    LoadBitmap            Bit map/Resource mgmt.    
    LoadCursor            Cursor/Resource mgmt.     
    LoadIcon              Resource management       
    LoadLibrary           Module management        Supported
    LoadMenu              Resource management       
    LoadMenuIndirect      Menu                     Not supported
    LoadModule            App. execution            
    LoadResource          Resource management       
    LoadString            Resource management       
    LocalAlloc            Memory management         
    LocalCompact          Memory management         
    LocalDiscard          Memory management         
    LocalFlags            Memory management         
    LocalFree             Memory management         
    LocalHandle           Memory management         
    LocalInit             Memory management         
    LocalLock             Memory management         
    LocalReAlloc          Memory management        Supported
    LocalShrink           Memory management         
    LocalSize             Memory management         
    LocalUnlock           Memory management         
    LockResource          Resource management       
    LockSegment           Memory management         
    LPtoDP                Coordinate                
    lstrcat               String manipulation       
    lstrcmp               String manipulation       
    lstrcmpi              String manipulation       
    lstrcpy               String manipulation       
    lstrlen               String manipulation       

    Function              Functional Area          Support Status
    MakeProcInstance      Module management         
    MapDialogRect         Dialog box                
    MapVirtualKey         Hardware                  
    MessageBeep           Error                     
    MessageBox            Error/Message            Supported
    ModifyMenu            Menu                      
    MoveTo                Line output               
    MoveWindow            Display/movement          
    NetBIOSCall           OS interrupt             Not supported
    OemKeyScan            Hardware                  
    OemToAnsi             String manipulation       
    OemToAnsiBuff         String manipulation       
    OffsetClipRgn         Clipping                  
    OffsetRect            Rectangle                 
    OffsetRgn             Region                    
    OffsetViewportOrg     Mapping                   
    OffsetWindowOrg       Mapping                   
    OpenClipboard         Clipboard                 
    OpenComm              Communication            Not supported
    OpenFile              File I/O                  
    OpenIcon              Display/movement          
    OpenSound             Sound                    Not supported
    OutputDebugString     Debugging                 
    PaintRgn              Region                    
    PatBlt                Bit map                   
    PeekMessage           Message                  Supported
    Pie                   Ellipse & polygon
    PlayMetaFile          Metafile                  
    PlayMetaFileRecord    Metafile                 Not supported
    Polygon               Ellipse & polygon
    Polyline              Line output               
    PolyPolygon           Region                   Supported
    PostAppMessage        Message                   
    PostMessage           Message                   
    PostQuitMessage       Message                   
    ProfClear             Optimization tool        Not supported
    ProfFinish            Optimization tool        Not supported
    ProfFlush             Optimization tool        Not supported
    ProfInsChk            Optimization tool        Not supported
    ProfSampRate          Optimization tool        Not supported
    ProfSetup             Optimization tool        Not supported
    ProfStart             Optimization tool        Not supported
    ProfStop              Optimization tool        Not supported
    PtInRect              Rectangle                 
    PtInRegion            Region                    
    PtVisible             Clipping                  
    ReadComm              Communication            Not supported
    RealizePalette        Color palette             
    Rectangle             Ellipse & polygon

    Function              Functional Area          Support Status
    RectInRegion          Region                    
    RectVisible           Clipping                  
    RegisterClass         Window creation          Supported
     ClipboardFormat      Clipboard                 
     WindowMessage        Message                   
    ReleaseCapture        Input                     
    ReleaseDC             Painting                  
    RemoveFontResource    Font                      
    RemoveMenu            Menu                      
    RemoveProp            Property                  
    ReplyMessage          Message                   
    ResizePalette         Color palette             
    Resource              Resource management       
    RestoreDC             Device context            
    RoundRect             Ellipse & polygon
    SaveDC                Device context            
    ScaleViewportExt      Mapping                   
    ScaleWindowExt        Mapping                   
    ScreenToClient        Coordinate                
    ScrollDC              Scrolling                 
    ScrollWindow          Scrolling                 
    SelectClipRgn         Clipping                  
    SelectObject          Drawing tool              
    SelectPalette         Color palette             
    SendDlgItemMessage    Dialog box                
    SendMessage           Message                  Supported
    SetActiveWindow       Input                     
    SetBitmapBits         Bit map                   
    SetBitmapDimension    Bit map                   
    SetBkColor            Drawing attribute         
    SetBkMode             Drawing attribute         
    SetBrushOrg           Drawing tool              
    SetCapture            Input                     
    SetCaretBlinkTime     Caret                     
    SetCaretPos           Caret                     
    SetClassLong          Window creation           
    SetClassWord          Window creation          Supported
    SetClipboardData      Clipboard                 
    SetClipboardViewer    Clipboard                Supported
    SetCommBreak          Communication            Not supported
    SetCommEventMask      Communication            Not supported
    SetCommState          Communication            Not supported
    SetCursor             Cursor                    
    SetCursorPos          Cursor                    
    SetDIBits             Device-ind. bit map       
    SetDIBitsToDevice     Device-ind. bit map       
    SetDlgItemInt         Dialog box                

    Function              Functional Area          Support Status
    SetDlgItemText        Dialog box                
    SetDoubleClickTime    Input                     
    SetEnvironment        Environment              Supported
    SetErrorMode          Task                      
    SetFocus              Input                    Supported
    SetHandleCount        File I/O                  
    SetKeyboardState      Hardware                  
    SetMapMode            Mapping                   
    SetMapperFlags        Font                      
    SetMenu               Menu                      
    SetMenuItemBitmaps    Menu                      
    SetMessageQueue       Message                  Supported
    SetMetaFileBits       Metafile                 Supported
    SetPaletteEntries     Color palette             
    SetParent             Information               
    SetPixel              Bit map                   
    SetPolyFillMode       Drawing attribute         
    SetProp               Property                  
    SetRect               Rectangle                 
    SetRectEmpty          Rectangle                 
    SetRectRgn            Region                    
    SetResourceHandler    Resource management      Not supported
    SetROP2               Drawing attribute         
    SetScrollPos          Scrolling                 
    SetScrollRange        Scrolling                 
    SetSoundNoise         Sound                    Not supported
    SetStretchBltMode     Drawing attribute         
    SetSwapAreaSize       Memory management         
    SetSysColors          System                    
    SetSysModalWindow     Input                     
     PaletteUse           Color palette             
    SetTextAlign          Text                      
     Extra                Text                      
    SetTextColor          Drawing attribute         
     Justification        Text                      
    SetTimer              Input                     
    SetViewportExt        Mapping                   
    SetViewportOrg        Mapping                   
    SetVoiceAccent        Sound                    Not supported
    SetVoiceEnvelope      Sound                    Not supported
    SetVoiceNote          Sound                    Not supported
    SetVoiceQueueSize     Sound                    Not supported
    SetVoiceSound         Sound                    Not supported
    SetVoiceThreshold     Sound                    Not supported
    SetWindowExt          Mapping                   
    SetWindowLong         Window creation           

    Function              Functional Area          Support Status
    SetWindowOrg          Mapping                   
    SetWindowPos          Display/movement          
    SetWindowsHook        Hook                     Supported
    SetWindowText         Display/movement          
    SetWindowWord         Window creation           
    ShowCaret             Caret                     
    ShowCursor            Cursor                    
    ShowOwnedPopups       Display/movement          
    ShowScrollBar         Scrolling                 
    ShowWindow            Display/movement          
    SizeofResource        Resource management       
    StartSound            Sound                    Not supported
    StopSound             Sound                    Not supported
    StretchBlt            Bit map                   
    StretchDIBits         Device-ind. bit map       
    SwapMouseButton       Input                     
    SwapRecording         Optimization tool        Not supported
    SwitchStackBack       Memory management        Not supported
    SwitchStackTo         Memory management        Not supported
    SyncAllVoices         Sound                    Not supported
    TabbedTextOut         Text                      
    TextOut               Text                      
    Throw                 String manip./Task        
    ToAscii               String manipulation       
    TrackPopupMenu        Menu                      
     Accelerator          Message                   
     MDISysAccel          Message                   
    TranslateMessage      Message                   
    TransmitCommChar      Communication            Not supported
    UngetCommChar         Communication            Not supported
    UnhookWindowsHook     Hook                     Supported
    UnionRect             Rectangle                 
    UnlockResource        Resource management       
    UnlockSegment         Segment                  Not supported
    UnrealizeObject       Drawing tool              
    UnregisterClass       Window creation           
    UpdateColors          Color palette             
    UpdateWindow          Painting                  
     Segments             Debugging                Not supported
    ValidateFreeSpaces    Debugging                Not supported
    ValidateRect          Painting                  
    ValidateRgn           Region                    
    VkKeyScan             Hardware                  
    WaitMessage           Message                   
    WaitSoundState        Sound                    Not supported
    WindowFromPoint       Coordinate/Info.          

    Function              Functional Area          Support Status
    WinExec               Application execution     
    WinHelp               Application execution     
    WriteComm             Communication            Not supported
     ProfileString        Initialization file      Supported
    WriteProfileString    Initialization file       
    wsprintf              String manipulation       
    wvsprintf             String manipulation       
    Yield                 Task                      

    Performance Considerations

    Planning Information

    Customer Responsibilities

    Customers should be aware of the technical limitations of the IBM Developer's Migration Kit/2 before purchase. The previously discussed restrictions should be communicated so that the customer is able to estimate the amount of work required for a successful port. The ship-group documentation, also available separately, provides further information on pre-migration considerations.

    IBM Conditions of Use apply to all Dual Media packages, thus the program in a package may only be used on a single machine at any one time, even though the program may be provided in the package on two different sized media. If a customer wishes to use an IBM Conditions of Use program concurrently on more than one machine at a time, irrespective of the size of the medium, he must acquire that number of program packages equal to the number of concurrent users of the program.


    The IBM Developer's Migration Kit/2 program package contains the following:

    Security, Auditability and Control

    User management is responsible for evaluation, selection, and implementation of security features, administrative procedures, and appropriate controls in application systems and communication facilities.

    Charges, Terms & Conditions for COU Program Package


    Consult your IBM Marketing Representative for the applicable One-Time Charge.

    Terms and Conditions

    This program is available from IBM under the Terms and Conditions for Purchase, and is subject to the Conditions of Use contained in the program package.

    The Conditions of Use authorize the customer to use the program on only one machine at any one time.

    Volume Discount

    Volume Discounting is available under the Terms and Conditions for IBM Volume Discount. Contact your IBM Marketing Representative for details.

    This program will be included into Category A Discount Group 1 of Exhibits COU-02 and COUED-02.

    Educational Volume Discount

    Education Discount is available, please contact your IBM Marketing Representative for details.

    Special Educational Allowance for Volume Orders

    This product is available under the Special Educational Allowance for Volume Orders of Selected IBM PC-PS/2 Conditions of Use Programs. Consult your IBM Marketing Representative for details.


    IBM standard warranty of media. Warranty period 3 months (or the period required by local legislation, if greater).

    Program Services

    Program service via Customer Technical Support Locations (CTSL's) is not available for this product. Customers are required to contact their remarketer/distributor, or IBM in writing, for program-defect related problems. Program service will be in accordance with the Service Statement included in the program package, and will be available until the Service End Date, July 28, 1994

    Announcement Countries

    All European, Middle Eastern and African Countries.

    The data in this letter is subject to the disclaimer in Letter ZS90-0112, which is available from IBM on request.

    ************ End of Document ************