home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / aspisrc.zip / dev / DEVHELP.H < prev    next >
C/C++ Source or Header  |  1998-11-29  |  40KB  |  1,312 lines
  1.  
  2. // Prevent multiple inclusion
  3. #if !defined(DevHelp_h)
  4. #define DevHelp_h 1
  5.  
  6. #if !defined(__WATCOMC__) || !defined(__cplusplus)
  7. #error Watcom C++ must be used for the inline DevHlp interface.
  8. #endif
  9.  
  10.  
  11. #include "devtype.h"
  12. #include "devrp.h"
  13.  
  14.  
  15.  
  16. // Calling conventions for device driver functions
  17. //
  18. //
  19.  
  20. // Strategy call calling convention
  21. #pragma aux STRATEGY far parm [es bx];
  22.  
  23. // Inter device driver calling convention
  24. #pragma aux IDC far loadds parm [] caller reverse value [ax];
  25.  
  26. // Dynamic API calling convention
  27. #pragma aux DYNAMIC far loadds parm [si] value [ax];
  28.  
  29. // OS/2 16-bit API calling convention
  30. #pragma aux API16 "^" far parm reverse routine [] \
  31.   value struct float struct caller [] modify [ax bx cx dx];
  32.  
  33.  
  34.  
  35.  
  36. // Interface to the OS/2 Ring 0 Device Helper functions
  37. //
  38. //
  39.  
  40. // Private declarations for use by the Dev* library
  41. extern "C"
  42.   {
  43.   extern WORD32 Dev_Entry;
  44.   extern WORD32 Dev_StdEntry;
  45.   extern WORD32 Dev_DbgEntry;
  46.   }
  47.  
  48.  
  49.  
  50. VOID DevInit                  // Initialize the Dev* library (call at Init)
  51.   (
  52.   WORD32 DeviceHelp           // Far pointer to OS/2 Dev_Help entry point
  53.   );                          // Returns: Nothing
  54.  
  55. inline VOID DevInit(WORD32 DeviceHelp)
  56.   {
  57.   Dev_Entry = Dev_StdEntry = DeviceHelp;
  58.   return;
  59.   }
  60.  
  61.  
  62.  
  63. WORD16 DevDebug               // Set the debugging mode for the Dev* library
  64.   (
  65.   WORD16 EnableInt3           // Debugging flag: 1 = debug on, 0 = debug off
  66.   );                          // Returns: The previous debugging state
  67.  
  68. inline WORD16 DevDebug(WORD16 EnableInt3)
  69.   {
  70.   WORD16 value = (Dev_Entry == Dev_DbgEntry);
  71.   Dev_Entry = (EnableInt3) ? Dev_DbgEntry : Dev_StdEntry;
  72.   return value;
  73.   }
  74.  
  75.  
  76.  
  77. VOID DevInt3                  // Generate an INT 3 breakpoint
  78.   (
  79.   );                          // Returns: Nothing
  80.  
  81. #pragma aux DevInt3 =         \
  82.   "int 3";
  83.  
  84.  
  85.  
  86. VOID DevDone                  // Complete device I/O
  87.   (
  88.   RP FAR* RequestPacket       // Request packet for which to unblock threads
  89.   );                          // Returns: Nothing
  90.  
  91. #pragma aux DevDone =         \
  92.   "mov dl,01h"                \
  93.   "call dword ptr Dev_Entry"  \
  94.   modify [dl]                 \
  95.   parm [es bx];
  96.  
  97.  
  98.  
  99. VOID DevYield                 // Yield the CPU to pending threads
  100.   (
  101.   );                          // Returns: Nothing
  102.  
  103. #pragma aux DevYield =        \
  104.   "mov dl,02h"                \
  105.   "call dword ptr Dev_Entry"  \
  106.   modify [dl];
  107.  
  108.  
  109.  
  110. VOID DevTCYield               // Yield the CPU to time critical threads
  111.   (
  112.   );                          // Returns: Nothing
  113.  
  114. #pragma aux DevTCYield =      \
  115.   "mov dl,03h"                \
  116.   "call dword ptr Dev_Entry"  \
  117.   modify [dl];
  118.  
  119.  
  120.  
  121. WORD16 DevBlock               // Block the current thread
  122.   (
  123.   WORD32 Id,                  // Id to be used by DevRun call
  124.   WORD32 WaitMilliSec,        // Milliseconds to wait for (-1 = forever)
  125.   BYTE InterruptableFlag      // 1 if block is interruptable, else 0
  126.   );                          // Returns: 0 = Ran, 1 = Timeout, 2 = Ctrl+C
  127.  
  128. #pragma aux DevBlock =        \
  129.   "xchg ax,bx"                \
  130.   "xchg di,cx"                \
  131.   "mov dl,04h"                \
  132.   "call dword ptr Dev_Entry"  \
  133.   "setnz al"                  \
  134.   "setc bl"                   \
  135.   "inc al"                    \
  136.   "neg bl"                    \
  137.   "and al,bl"                 \
  138.   "xor ah,ah"                 \
  139.   modify [dl]                 \
  140.   parm [bx ax] [cx di] [dh]   \
  141.   value [ax];
  142.  
  143.  
  144.  
  145. WORD16 DevRun                 // Run a blocked thread
  146.   (
  147.   WORD32 Id                   // Id used in DevBlock call
  148.   );                          // Returns: Count of awakened threads
  149.  
  150. #pragma aux DevRun =          \
  151.   "xchg ax,bx"                \
  152.   "mov dl,05h"                \
  153.   "call dword ptr Dev_Entry"  \
  154.   modify [dl]                 \
  155.   parm [bx ax]                \
  156.   value [ax];
  157.  
  158.  
  159.  
  160. WORD16 DevSemRequest          // Set a 16 bit semaphore
  161.   (
  162.   HSEMAPHORE Handle,          // Handle of semaphore to request
  163.   WORD32 WaitMilliSec         // Milliseconds to wait for (-1 = forever)
  164.   );                          // Returns: 0 = success, other = error code
  165.  
  166. #pragma aux DevSemRequest =   \
  167.   "xchg ax,bx"                \
  168.   "xchg di,cx"                \
  169.   "mov dl,06h"                \
  170.   "call dword ptr Dev_Entry"  \
  171.   "setc dl"                   \
  172.   "xor dh,dh"                 \
  173.   "neg dx"                    \
  174.   "and ax,dx"                 \
  175.   modify [dx]                 \
  176.   parm [bx ax] [cx di]        \
  177.   value [ax];
  178.  
  179.  
  180.  
  181. WORD16 DevSemClear            // Clear a 16 bit semaphore
  182.   (
  183.   HSEMAPHORE Handle           // Handle of semaphore to release
  184.   );                          // Returns: 0 = success, other = error code
  185.  
  186. #pragma aux DevSemClear =     \
  187.   "xchg ax,bx"                \
  188.   "mov dl,07h"                \
  189.   "call dword ptr Dev_Entry"  \
  190.   "setc dl"                   \
  191.   "xor dh,dh"                 \
  192.   "neg dx"                    \
  193.   "and ax,dx"                 \
  194.   modify [dx]                 \
  195.   parm [bx ax]                \
  196.   value [ax];
  197.  
  198.  
  199.  
  200. WORD16 DevSemUseHandle        // Obtain a handle to an application semaphore
  201.   (
  202.   WORD32 AppSem,              // Handle of application semaphore
  203.   HSEMAPHORE FAR* Handle      // Storage for converted semaphore handle
  204.   );                          // Returns: 0 = success, other = error code
  205.  
  206. #pragma aux DevSemUseHandle = \
  207.   "xchg ax,bx"                \
  208.   "mov dx,0108h"              \
  209.   "call dword ptr Dev_Entry"  \
  210.   "setc dl"                   \
  211.   "xor dh,dh"                 \
  212.   "neg dx"                    \
  213.   "mov es:[si][0],bx"         \
  214.   "mov es:[si][2],ax"         \
  215.   "and ax,dx"                 \
  216.   modify [dx]                 \
  217.   parm [bx ax] [es si]        \
  218.   value [ax];
  219.  
  220.  
  221.  
  222. WORD16 DevSemFreeHandle       // Free a handle obtained with DevSemUseHandle
  223.   (
  224.   HSEMAPHORE Handle           // Handle of system semaphore
  225.   );                          // Returns: 0 = success, other = error code
  226.  
  227. #pragma aux DevSemFreeHandle= \
  228.   "xchg ax,bx"                \
  229.   "mov dx,0008h"              \
  230.   "call dword ptr Dev_Entry"  \
  231.   "setc dl"                   \
  232.   "xor dh,dh"                 \
  233.   "neg dx"                    \
  234.   "and ax,dx"                 \
  235.   modify [dx]                 \
  236.   parm [bx ax]                \
  237.   value [ax];
  238.  
  239.  
  240.  
  241. VOID DevReqPush               // Add a request packet to queue
  242.   (
  243.   WORD32 FAR* QueueHead,      // Pointer to space for head of queue (init to 0)
  244.   RP FAR* RequestPacket       // Request packet to add to list
  245.   );                          // Returns: Nothing
  246.  
  247. #pragma aux DevReqPush =      \
  248.   "mov ax,ds"                 \
  249.   "mov dx,fs"                 \
  250.   "mov ds,dx"                 \
  251.   "mov dl,09h"                \
  252.   "call dword ptr Dev_Entry"  \
  253.   "mov ds,ax"                 \
  254.   modify [ax dx]              \
  255.   parm [fs si] [es bx];
  256.  
  257.  
  258.  
  259. WORD16 DevReqPull             // Remove a request packet from queue
  260.   (
  261.   WORD32 FAR* QueueHead,      // Pointer to head of queue
  262.   RP FAR* FAR* RequestPacket  // Storage for pointer to removed request packet
  263.   );                          // Returns: 0 = success, 1 = queue is empty
  264.  
  265. #pragma aux DevReqPull =      \
  266.   "mov ax,ds"                 \
  267.   "mov dx,fs"                 \
  268.   "mov ds,dx"                 \
  269.   "mov dl,0Ah"                \
  270.   "call dword ptr Dev_Entry"  \
  271.   "setc dl"                   \
  272.   "xor dh,dh"                 \
  273.   "mov gs:[di][0],bx"         \
  274.   "mov gs:[di][2],es"         \
  275.   "mov ds,ax"                 \
  276.   modify [es ax bx]           \
  277.   parm [fs si] [gs di]        \
  278.   value [dx];
  279.  
  280.  
  281.  
  282. WORD16 DevReqPullParticular   // Remove a specific request packet from queue
  283.   (
  284.   WORD32 FAR* QueueHead,      // Pointer to head of queue
  285.   RP FAR* RequestPacket       // Request packet to remove from list
  286.   );                          // Returns: 0 = success, 1 = packet not found
  287.  
  288. #pragma aux DevReqPullParticular= \
  289.   "mov ax,ds"                 \
  290.   "mov dx,fs"                 \
  291.   "mov ds,dx"                 \
  292.   "mov dl,0Bh"                \
  293.   "call dword ptr Dev_Entry"  \
  294.   "setc dl"                   \
  295.   "xor dh,dh"                 \
  296.   "mov ds,ax"                 \
  297.   modify [ax]                 \
  298.   parm [fs si] [es bx]        \
  299.   value [dx];
  300.  
  301.  
  302.  
  303. VOID DevReqPushSorted         // Add a request packet to queue in sorted order
  304.   (
  305.   WORD32 FAR* QueueHead,      // Pointer to space for head of queue (init to 0)
  306.   RP FAR* RequestPacket       // Request packet to add to list
  307.   );                          // Returns: Nothing
  308.  
  309. #pragma aux DevReqPushSorted= \
  310.   "mov ax,ds"                 \
  311.   "mov dx,fs"                 \
  312.   "mov ds,dx"                 \
  313.   "mov dl,0Ch"                \
  314.   "call dword ptr Dev_Entry"  \
  315.   "mov ds,ax"                 \
  316.   modify [ax dx]              \
  317.   parm [fs si] [es bx];
  318.  
  319.  
  320.  
  321. WORD16 DevReqAlloc            // Allocate an empty maximum-sized request packet
  322.   (
  323.   BYTE NoWaitFlag,            // 0 to wait for RP or 1 to return immediately
  324.   RP FAR* FAR* RequestPacket  // Storage for pointer to empty request packet
  325.   );                          // Returns: 0 = success, 1 = error
  326.  
  327. #pragma aux DevReqAlloc =     \
  328.   "mov ax,ds"                 \
  329.   "mov dx,fs"                 \
  330.   "mov ds,dx"                 \
  331.   "mov dl,0Dh"                \
  332.   "call dword ptr Dev_Entry"  \
  333.   "setc dl"                   \
  334.   "xor dh,dh"                 \
  335.   "mov [di][0],bx"            \
  336.   "mov [di][2],es"            \
  337.   "mov ds,ax"                 \
  338.   modify [es bx]              \
  339.   parm [dh] [fs di]           \
  340.   value [dx];
  341.  
  342.  
  343.  
  344. VOID DevReqFree               // Free a request packet alloced with DevReqAlloc
  345.   (
  346.   RP FAR* RequestPacket       // Request packet to free
  347.   );                          // Returns: Nothing
  348.  
  349. #pragma aux DevReqFree =      \
  350.   "mov dl,0Eh"                \
  351.   "call dword ptr Dev_Entry"  \
  352.   modify [dl]                 \
  353.   parm [es bx];
  354.  
  355.  
  356.  
  357. VOID DevQueueInit             // Initialize a character queue
  358.   (
  359.   QBASE FAR* Queue            // Pointer to QUEUE<> structure
  360.   );                          // Returns: Nothing
  361.  
  362. #pragma aux DevQueueInit =    \
  363.   "mov ax,ds"                 \
  364.   "mov dx,fs"                 \
  365.   "mov ds,dx"                 \
  366.   "mov dl,0Fh"                \
  367.   "call dword ptr Dev_Entry"  \
  368.   "mov ds,ax"                 \
  369.   modify [ax dx]              \
  370.   parm [fs bx];
  371.  
  372.  
  373.  
  374. VOID DevQueueFlush            // Empty a character queue
  375.   (
  376.   QBASE FAR* Queue            // Pointer to QUEUE<> structure
  377.   );                          // Returns: Nothing
  378.  
  379. #pragma aux DevQueueFlush =   \
  380.   "mov ax,ds"                 \
  381.   "mov dx,fs"                 \
  382.   "mov ds,dx"                 \
  383.   "mov dl,10h"                \
  384.   "call dword ptr Dev_Entry"  \
  385.   "mov ds,ax"                 \
  386.   modify [ax dx]              \
  387.   parm [fs bx];
  388.  
  389.  
  390.  
  391. WORD16 DevQueueWrite          // Add a byte to the end of a character queue
  392.   (
  393.   QBASE FAR* Queue,           // Pointer to QUEUE<> structure
  394.   WORD16 Data                 // Data byte to add to queue
  395.   );                          // Returns: 0 = success, 1 = queue full
  396.  
  397. #pragma aux DevQueueWrite =   \
  398.   "mov cx,ds"                 \
  399.   "mov dx,fs"                 \
  400.   "mov ds,dx"                 \
  401.   "mov dl,11h"                \
  402.   "call dword ptr Dev_Entry"  \
  403.   "setc dl"                   \
  404.   "xor dh,dh"                 \
  405.   "mov ds,cx"                 \
  406.   modify [cx]                 \
  407.   parm [fs bx] [ax]           \
  408.   value [dx];
  409.  
  410.  
  411.  
  412. WORD16 DevQueueRead           // Remove a byte from a character queue
  413.   (
  414.   QBASE FAR* Queue,           // Pointer to QUEUE<> structure
  415.   BYTE FAR* Data              // Storage for data byte
  416.   );                          // Returns: 0 = success, 1 = queue empty
  417.  
  418. #pragma aux DevQueueRead =    \
  419.   "mov cx,ds"                 \
  420.   "mov dx,fs"                 \
  421.   "mov ds,dx"                 \
  422.   "mov dl,12h"                \
  423.   "call dword ptr Dev_Entry"  \
  424.   "setc dl"                   \
  425.   "xor dh,dh"                 \
  426.   "mov gs:[di],al"            \
  427.   "mov ds,cx"                 \
  428.   modify [al cx]              \
  429.   parm [fs bx] [gs di]        \
  430.   value [dx];
  431.  
  432.  
  433.  
  434. WORD16 DevSegLock             // Lock a segment down in memory
  435.   (
  436.   SEL Selector,               // Selector of memory to lock down
  437.   WORD16 Type,                // Type (0 = short, 1 = long, 3 = long & hi,
  438.                               //       4 = short & verify)
  439.   WORD16 NoWaitFlag,          // 0 to wait for lock or 1 to return immediately
  440.   HLOCK FAR* Handle           // Storage for segment lock handle
  441.   );                          // Returns: 0 = success, 1 = error
  442.  
  443. #pragma aux DevSegLock =      \
  444.   "mov bh,cl"                 \
  445.   "mov dl,13h"                \
  446.   "call dword ptr Dev_Entry"  \
  447.   "setc dl"                   \
  448.   "xor dh,dh"                 \
  449.   "mov fs:[di][0],bx"         \
  450.   "mov fs:[di][2],ax"         \
  451.   parm [ax] [cx] [bx] [fs di] \
  452.   value [dx];
  453.  
  454.  
  455.  
  456. WORD16 DevSegUnlock           // Unlock a segment locked by DevSegLock
  457.   (
  458.   HLOCK Handle                // Handle of locked segment
  459.   );                          // Returns: 0 = success, other = error code
  460.  
  461. #pragma aux DevSegUnlock =    \
  462.   "xchg ax,bx"                \
  463.   "mov dl,14h"                \
  464.   "call dword ptr Dev_Entry"  \
  465.   "setc dl"                   \
  466.   "xor dh,dh"                 \
  467.   "neg dx"                    \
  468.   "and ax,dx"                 \
  469.   modify [dx]                 \
  470.   parm [bx ax]                \
  471.   value [ax];
  472.  
  473.  
  474.  
  475. WORD16 DevPhysToVirt          // Convert a physical address to a 16:16 address
  476.   (
  477.   PHYSICAL PhysAddr,          // Physical address to convert
  478.   WORD16 Length,              // Length of virtual segment
  479.   VIRTUAL FAR* VirtAddr       // Storage for virtual address
  480.   );                          // Returns: 0 = success, other = error code
  481.  
  482. #pragma aux DevPhysToVirt =   \
  483.   "xchg ax,bx"                \
  484.   "mov dx,0115h"              \
  485.   "call dword ptr Dev_Entry"  \
  486.   "setc dl"                   \
  487.   "xor dh,dh"                 \
  488.   "neg dx"                    \
  489.   "mov fs:[si][0],di"         \
  490.   "mov fs:[si][2],es"         \
  491.   "and ax,dx"                 \
  492.   modify [dx es di]           \
  493.   parm [bx ax] [cx] [fs si]   \
  494.   value [ax];
  495.  
  496.  
  497.  
  498. VOID DevVirtToPhys            // Convert a locked 16:16 address to physical
  499.   (
  500.   VIRTUAL VirtAddr,           // Virtual address to convert (must be locked)
  501.   PHYSICAL FAR* PhysAddr      // Storage for physical address
  502.   );                          // Returns: Nothing
  503.  
  504.  
  505. /*#pragma aux DevVirtToPhys =   \
  506.   "mov cx,ds"                 \
  507.   "mov ax,es"                 \
  508.   "mov ds,ax"                 \
  509.   "mov dl,16h"                \
  510.   "call dword ptr Dev_Entry"  \
  511.   "mov fs:[di][0],bx"         \
  512.   "mov fs:[di][2],ax"         \
  513.   "mov ds,cx"                 \
  514.   modify [dx ax bx cx]        \
  515.   parm [es si] [fs di];   */
  516.  
  517. #pragma aux DevVirtToPhys = \
  518.    "push ds" \
  519.    "mov  dl,16h" \
  520.    "push es" \
  521.    "mov  si,ds" \
  522.    "mov  es,si" \
  523.    "mov  ds,bx" \
  524.    "mov  si,ax" \
  525.    "call far es:[Dev_Entry]" \
  526.    "pop  es" \
  527.    "mov  es:[di],bx" \
  528.    "mov  es:[di+2],ax" \
  529.    "pop  ds" \
  530.    "sub  ax,ax" \
  531.    value [ax] \
  532.    parm caller nomemory [ax bx] [es di] \
  533.    modify exact [ax bx dl es si];
  534.  
  535. WORD16 DevPhysToUVirt         // Convert a physical address to an LDT address
  536.   (
  537.   PHYSICAL PhysAddr,          // Physical address to convert
  538.   WORD16 Length,              // Length of virtual segment
  539.   BYTE Type,                  // Type (0 = code, 1 = data, 2 = free, 5 = video)
  540.   BYTE Ring,                  // Ring number for segment (ring 3 or 2)
  541.   VIRTUAL FAR* VirtAddr       // Storage for virtual address
  542.   );                          // Returns: 0 = success, 1 = error
  543.  
  544. // Massage the Ring and Type parameters into a single value in dh,
  545. // by using a Ring look-up table (bitmask) in dx.
  546. #pragma aux DevPhysToUVirt =  \
  547.   "xchg ax,bx"                \
  548.   "mov dh,30h"                \
  549.   "shl cl,01h"                \
  550.   "shr dh,cl"                 \
  551.   "and dh,03h"                \
  552.   "add dh,ch"                 \
  553.   "mov cx,di"                 \
  554.   "mov dl,17h"                \
  555.   "call dword ptr Dev_Entry"  \
  556.   "setc dl"                   \
  557.   "xor dh,dh"                 \
  558.   "mov fs:[si][0],bx"         \
  559.   "mov fs:[si][2],es"         \
  560.   modify [es]                 \
  561.   parm [bx ax] [di] [ch] [cl] [fs si] \
  562.   value [dx];
  563.  
  564.  
  565.  
  566. WORD16 DevPhysAlloc           // Allocate a block of physical memory
  567.   (
  568.   WORD32 Size,                // Size of memory to allocate
  569.   BYTE LoFlag,                // Flag: 0 = above 1 MB, 1 = below 1 MB
  570.   PHYSICAL FAR* PhysAddr      // Storage for address of memory block
  571.   );                          // Returns: 0 = success, other = error code
  572.  
  573. #pragma aux DevPhysAlloc =    \
  574.   "xchg ax,bx"                \
  575.   "mov dl,18h"                \
  576.   "call dword ptr Dev_Entry"  \
  577.   "setc dl"                   \
  578.   "xor dh,dh"                 \
  579.   "neg dx"                    \
  580.   "mov es:[si][0],bx"         \
  581.   "mov es:[si][2],ax"         \
  582.   "and ax,dx"                 \
  583.   modify [dl]                 \
  584.   parm [bx ax] [dh] [es si]   \
  585.   value [ax];
  586.  
  587.  
  588.  
  589. WORD16 DevPhysFree            // Free a block of physical memory
  590.   (
  591.   PHYSICAL PhysAddr           // Address of memory block to be freed
  592.   );                          // Returns: 0 = success, 1 = error
  593.  
  594. #pragma aux DevPhysFree =     \
  595.   "xchg ax,bx"                \
  596.   "mov dl,19h"                \
  597.   "call dword ptr Dev_Entry"  \
  598.   "setc dl"                   \
  599.   "xor dh,dh"                 \
  600.   parm [bx ax]                \
  601.   value [dx];
  602.  
  603.  
  604.  
  605. WORD16 DevIRQSet              // Register an interrupt handler for an IRQ
  606.   (
  607.   WORD16 IRQ,                 // IRQ Number to handle
  608.   VOID* Handler,              // Handler function entry-point
  609.   BYTE SharableFlag           // Sharable: 1 = sharable, 0 = exclusive
  610.   );                          // Returns: 0 = success, other = error code
  611.  
  612. #pragma aux DevIRQSet =       \
  613.   "mov dl,1Bh"                \
  614.   "call dword ptr Dev_Entry"  \
  615.   "setc dl"                   \
  616.   "xor dh,dh"                 \
  617.   "neg dx"                    \
  618.   "and ax,dx"                 \
  619.   modify [dl]                 \
  620.   parm [bx] [ax] [dh]         \
  621.   value [ax];
  622.  
  623.  
  624.  
  625. WORD16 DevIRQClear            // Remove a registered IRQ handler
  626.   (
  627.   WORD16 IRQ                  // IRQ Number to release
  628.   );                          // Returns: 0 = success, 1 = error
  629.  
  630. #pragma aux DevIRQClear =     \
  631.   "mov dl,1Ch"                \
  632.   "call dword ptr Dev_Entry"  \
  633.   "setc dl"                   \
  634.   "xor dh,dh"                 \
  635.   parm [bx]                   \
  636.   value [dx];
  637.  
  638.  
  639.  
  640. WORD16 DevTimerSet            // Register a timer handler
  641.   (
  642.   VOID* Handler               // Handler function entry-point
  643.   );                          // Returns: 0 = success, other = error code
  644.  
  645. #pragma aux DevTimerSet =     \
  646.   "mov dl,1Dh"                \
  647.   "call dword ptr Dev_Entry"  \
  648.   "setc dl"                   \
  649.   "xor dh,dh"                 \
  650.   "neg dx"                    \
  651.   "and ax,dx"                 \
  652.   modify [dx]                 \
  653.   parm [ax]                   \
  654.   value [ax];
  655.  
  656.  
  657.  
  658. WORD16 DevTimerClear          // Remove a timer handler
  659.   (
  660.   VOID* Handler               // Handler function entry-point
  661.   );                          // Returns: 0 = success, other = error code
  662.  
  663. #pragma aux DevTimerClear =   \
  664.   "mov dl,1Eh"                \
  665.   "call dword ptr Dev_Entry"  \
  666.   "setc dl"                   \
  667.   "xor dh,dh"                 \
  668.   "neg dx"                    \
  669.   "and ax,dx"                 \
  670.   modify [dx]                 \
  671.   parm [ax]                   \
  672.   value [ax];
  673.  
  674.  
  675.  
  676. WORD16 DevGetDOSVar           // Get a pointer to a system variable
  677.   (
  678.   WORD16 Index,               // ID of variable to request
  679.   VIRTUAL FAR* Pointer        // Storage for address of system variable
  680.   );                          // Returns: 0 = success, 1 = error
  681.  
  682. #pragma aux DevGetDOSVar =    \
  683.   "mov dl,24h"                \
  684.   "call dword ptr Dev_Entry"  \
  685.   "setc dl"                   \
  686.   "xor dh,dh"                 \
  687.   "mov es:[si][0],bx"         \
  688.   "mov es:[si][2],ax"         \
  689.   modify [bx]                 \
  690.   parm [ax] [es si]           \
  691.   value [dx];
  692.  
  693.  
  694.  
  695. WORD16 DevSendEvent           // Fake a user event to the operating system
  696.   (
  697.   WORD16 Event,               // ID of the event to fake
  698.   WORD16 Parameter            // Parameter for the event
  699.   );                          // Returns: 0 = success, 1 = error
  700.  
  701. #pragma aux DevSendEvent =    \
  702.   "mov dl,25h"                \
  703.   "call dword ptr Dev_Entry"  \
  704.   "setc dl"                   \
  705.   "xor dh,dh"                 \
  706.   parm [ax] [bx]              \
  707.   value [dx];
  708.  
  709.  
  710.  
  711. WORD16 DevVerifyAccess        // Verify that the caller has access to memory
  712.   (
  713.   VIRTUAL Address,            // Address of memory to verify
  714.   WORD16 Length,              // Length of memory to verify
  715.   BYTE Type                   // Type of access (0 = read, 1 = read/write)
  716.   );                          // Returns: 0 = success, 1 = error
  717.  
  718. #pragma aux DevVerifyAccess = \
  719.   "xchg ax,di"                \
  720.   "mov dl,27h"                \
  721.   "call dword ptr Dev_Entry"  \
  722.   "setc dl"                   \
  723.   "xor dh,dh"                 \
  724.   modify [dl]                 \
  725.   parm [di ax] [cx] [dh]      \
  726.   value [dx];
  727.  
  728.  
  729.  
  730. WORD16 DevSysTrace            // Trace data into the RAS tracing facility
  731.   (
  732.   WORD16 MajorCode,           // Major trace code
  733.   WORD16 MinorCode,           // Minor trace code
  734.   WORD16 Length,              // Length of data buffer
  735.   BYTE FAR* Data              // Data buffer
  736.   );                          // Returns: 0 = success, 1 = error
  737.  
  738. #pragma aux DevSysTrace =     \
  739.   "mov di,ds"                 \
  740.   "mov dx,fs"                 \
  741.   "mov ds,dx"                 \
  742.   "mov dl,28h"                \
  743.   "call dword ptr Dev_Entry"  \
  744.   "setc dl"                   \
  745.   "xor dh,dh"                 \
  746.   "mov ds,di"                 \
  747.   modify [di]                 \
  748.   parm [ax] [cx] [bx] [fs si] \
  749.   value [dx];
  750.  
  751.  
  752.  
  753. WORD16 DevAttachDD            // Attach to another device driver for IDC
  754.   (
  755.   CHAR* DriverName,           // Device driver name (from device header)
  756.   IDCDATA* IDCData            // Storage for IDC data
  757.   );                          // Returns: 0 = success, 1 = error
  758.  
  759. #pragma aux DevAttachDD =     \
  760.   "mov dl,2Ah"                \
  761.   "call dword ptr Dev_Entry"  \
  762.   "setc dl"                   \
  763.   "xor dh,dh"                 \
  764.   parm [bx] [di]              \
  765.   value [dx];
  766.  
  767.  
  768.  
  769. VOID DevInternalError         // Signal an internal consistency error to OS/2
  770.   (
  771.   CHAR FAR* Message,          // Text describing error
  772.   WORD16 Length               // Length of message text
  773.   );                          // Returns: Function does not return
  774.  
  775. #pragma aux DevInternalError= \
  776.   "mov ax,ds"                 \
  777.   "mov dx,fs"                 \
  778.   "mov ds,dx"                 \
  779.   "mov dl,2Bh"                \
  780.   "call dword ptr Dev_Entry"  \
  781.   "setc dl"                   \
  782.   "xor dh,dh"                 \
  783.   "mov ds,ax"                 \
  784.   modify [ax]                 \
  785.   parm [fs si] [di]           \
  786.   value [dx];
  787.  
  788.  
  789.  
  790. WORD16 DevAllocGDTSel         // Allocate GDT selectors at Init time
  791.   (
  792.   SEL FAR* SelectorArray,     // Storage for allocated GDT selectors
  793.   WORD16 Count                // Number of GDT selectors to allocate
  794.   );                          // Returns: 0 = success, other = error code
  795.  
  796. #pragma aux DevAllocGDTSel =  \
  797.   "mov dl,2Dh"                \
  798.   "call dword ptr Dev_Entry"  \
  799.   "setc dl"                   \
  800.   "xor dh,dh"                 \
  801.   "neg dx"                    \
  802.   "and ax,dx"                 \
  803.   modify [dx]                 \
  804.   parm [es di] [cx]           \
  805.   value [ax];
  806.  
  807.  
  808.  
  809. WORD16 DevPhysToGDTSel        // Convert a 32 bit address to a GDT selector
  810.   (
  811.   PHYSICAL Address,           // 32 bit physical address to convert
  812.   WORD16 Length,              // Length of fabricated segment
  813.   SEL Selector                // Selector to refer to 32 bit address
  814.   );                          // Returns: 0 = success, other = error code
  815.  
  816. #pragma aux DevPhysToGDTSel = \
  817.   "xchg ax,bx"                \
  818.   "mov dl,2Eh"                \
  819.   "call dword ptr Dev_Entry"  \
  820.   "setc dl"                   \
  821.   "xor dh,dh"                 \
  822.   "neg dx"                    \
  823.   "and ax,dx"                 \
  824.   modify [dx]                 \
  825.   parm [bx ax] [cx] [si]      \
  826.   value [ax];
  827.  
  828.  
  829.  
  830. VOID DevEOI                   // Signal end of interrupt processing to PIC
  831.   (
  832.   WORD16 IRQ                  // IRQ number to end
  833.   );                          // Returns: Nothing
  834.  
  835. #pragma aux DevEOI =          \
  836.   "mov dl,31h"                \
  837.   "call dword ptr Dev_Entry"  \
  838.   modify [dl]                 \
  839.   parm [ax];
  840.  
  841.  
  842.  
  843. WORD16 DevTimerModify         // Modify or create periodic timer handler
  844.   (
  845.   VOID* Handler,              // Handler function entry-point
  846.   WORD16 Period               // Period between calls (number of timer ticks)
  847.   );                          // Returns: 0 = success, other = error code
  848.  
  849. #pragma aux DevTimerModify =  \
  850.   "mov dl,33h"                \
  851.   "call dword ptr Dev_Entry"  \
  852.   "setc dl"                   \
  853.   "xor dh,dh"                 \
  854.   "neg dx"                    \
  855.   "and ax,dx"                 \
  856.   modify [dx]                 \
  857.   parm [ax] [bx]              \
  858.   value [ax];
  859.  
  860.  
  861.  
  862. WORD16 DevIRQStackUsage       // Register stack usage properties
  863.   (
  864.   STACKUSAGE FAR* StackUsage  // Stack usage information
  865.   );                          // Returns: 0 = success, 1 = error
  866.  
  867. #pragma aux DevIRQStackUsage= \
  868.   "mov ax,ds"                 \
  869.   "mov dx,fs"                 \
  870.   "mov ds,dx"                 \
  871.   "mov dl,3Ah"                \
  872.   "call dword ptr Dev_Entry"  \
  873.   "setc dl"                   \
  874.   "xor dh,dh"                 \
  875.   "mov ds,ax"                 \
  876.   modify [ax]                 \
  877.   parm [fs bx]                \
  878.   value [dx];
  879.  
  880.  
  881.  
  882. VOID DevRegisterPDD           // Register driver for PDD-VDD communications
  883.   (
  884.   CHAR FAR* Name,             // Device driver name
  885.   VOID FAR* EntryPoint        // Entry point for PDD-VDD communications
  886.   );                          // Returns: Nothing = success, halt = error
  887.  
  888. #pragma aux DevRegisterPDD =  \
  889.   "mov ax,ds"                 \
  890.   "mov dx,fs"                 \
  891.   "mov ds,dx"                 \
  892.   "mov dl,50h"                \
  893.   "call dword ptr Dev_Entry"  \
  894.   "mov ds,ax"                 \
  895.   modify [ax dx]              \
  896.   parm [fs si] [es di];
  897.  
  898.  
  899.  
  900. WORD16 DevBeep                // Generate a beep
  901.   (
  902.   WORD16 Frequency,           // Beep pitch in hz
  903.   WORD16 Duration             // Beep duration
  904.   );                          // Returns: 0 = success, other = error code
  905.  
  906. #pragma aux DevBeep =         \
  907.   "mov dl,52h"                \
  908.   "call dword ptr Dev_Entry"  \
  909.   "setc dl"                   \
  910.   "xor dh,dh"                 \
  911.   "neg dx"                    \
  912.   "and ax,dx"                 \
  913.   modify [dx]                 \
  914.   parm [bx] [cx]              \
  915.   value [ax];
  916.  
  917.  
  918.  
  919. WORD16 DevFreeGDTSel          // Free an allocated GDT selector at task time
  920.   (
  921.   SEL Selector                // Selector to free
  922.   );                          // Returns: 0 = success, other = error code
  923.  
  924. #pragma aux DevFreeGDTSel =   \
  925.   "mov dl,53h"                \
  926.   "call dword ptr Dev_Entry"  \
  927.   "setc dl"                   \
  928.   "xor dh,dh"                 \
  929.   "neg dx"                    \
  930.   "and ax,dx"                 \
  931.   modify [dx]                 \
  932.   parm [ax]                   \
  933.   value [ax];
  934.  
  935.  
  936.  
  937. WORD16 DevVirtToLin           // Convert a virtual address to linear
  938.   (
  939.   SEL Selector,               // Selector to convert
  940.   WORD32 Offset,              // Offset to convert
  941.   LINEAR FAR* Linear          // Storage for linear address
  942.   );                          // Returns: 0 = success, other = error code
  943.  
  944. #pragma aux DevVirtToLin =    \
  945.   "xchg si,dx"                \
  946.   "shl esi,10h"               \
  947.   "mov si,dx"                 \
  948.   "mov dl,5Bh"                \
  949.   "call dword ptr Dev_Entry"  \
  950.   "mov es:[di],eax"           \
  951.   "setc dl"                   \
  952.   "xor dh,dh"                 \
  953.   "neg dx"                    \
  954.   "and ax,dx"                 \
  955.   parm [ax] [dx si] [es di]   \
  956.   value [ax];
  957.  
  958.  
  959.  
  960. WORD16 DevLinToGDTSel         // Convert a linear address to virtual
  961.   (
  962.   SEL Selector,               // Selector to refer to linear address
  963.   LINEAR Linear,              // Linear address to convert
  964.   WORD32 Length               // Length of memory space to convert
  965.   );                          // Returns: 0 = success, other = error code
  966.  
  967. #pragma aux DevLinToGDTSel =  \
  968.   "xchg bx,di"                \
  969.   "shl ebx,10h"               \
  970.   "mov bx,di"                 \
  971.   "shl ecx,10h"               \
  972.   "mov cx,dx"                 \
  973.   "mov dl,5Ch"                \
  974.   "call dword ptr Dev_Entry"  \
  975.   "setc dl"                   \
  976.   "xor dh,dh"                 \
  977.   "neg dx"                    \
  978.   "and ax,dx"                 \
  979.   parm [ax] [di bx] [cx dx]   \
  980.   value [ax];
  981.  
  982.  
  983.  
  984. HCONTEXT DevCtxAllocate         // Allocate a context hook
  985.   (
  986.   VOID FAR* Handler          // Pointer to handler function
  987. //  HCONTEXT FAR* Hook          // Storage for allocated context hook handle
  988.   );                          // Returns: 0 = success, other = error code (WORD16)
  989.  
  990. /*#pragma aux DevCtxAllocate =  \
  991.   "mov cx,ds"                 \
  992.   "mov dx,fs"                 \
  993.   "mov ds,dx"                 \
  994.   "and eax,0000FFFFh"         \
  995.   "mov ebx,0FFFFFFFFh"        \
  996.   "mov dl,63h"                \
  997.   "call dword ptr Dev_Entry"  \
  998.   "mov es:[di],eax"           \
  999.   "setc dl"                   \
  1000.   "xor dh,dh"                 \
  1001.   "neg dx"                    \
  1002.   "and ax,dx"                 \
  1003.   "mov ds,cx"                 \
  1004.   modify [cx dx bx]           \
  1005.   parm [fs ax] [es di]        \
  1006.   value [ax];
  1007. */
  1008.  
  1009. /* #pragma aux DevCtxAllocate = \
  1010.    "push bx" \
  1011.    "movzx   eax,ax" \
  1012.    "mov  ebx,-1" \
  1013.    "mov  dl,63h" \
  1014.    "call far Dev_Entry" \
  1015.    "pop  bx" \
  1016.    "jc   error" \
  1017.    "mov  es:[bx],eax" \
  1018.    "sub  ax,ax" \
  1019.    "error:" \
  1020.    value [ax] \
  1021.    parm caller nomemory [ax] [es bx] \
  1022.    modify exact [ax bx dl es]; */
  1023.  
  1024. // Version von Alger Pike
  1025. #pragma aux DevCtxAllocate =  \
  1026.   "and eax,0000FFFFh"         \
  1027.   "mov ebx,0FFFFFFFFh"        \
  1028.   "mov dl,63h"                \
  1029.   "call dword ptr Dev_Entry"  \
  1030.   "mov edx, eax"            \
  1031.   "shr edx, 10h"              \
  1032.   modify exact [ax bx]           \
  1033.   parm caller nomemory [ax]         \
  1034.   value [dx ax];
  1035.  
  1036.  
  1037. WORD16 DevCtxFree             // Free a context hook
  1038.   (
  1039.   HCONTEXT Hook               // Handle of context hook to free
  1040.   );                          // Returns: 0 = success, other = error code
  1041.  
  1042. #pragma aux DevCtxFree =      \
  1043.   "shl eax,10h"               \
  1044.   "mov ax,dx"                 \
  1045.   "mov dl,64h"                \
  1046.   "call dword ptr Dev_Entry"  \
  1047.   "setc dl"                   \
  1048.   "xor dh,dh"                 \
  1049.   "neg dx"                    \
  1050.   "and ax,dx"                 \
  1051.   parm [ax dx]                \
  1052.   value [ax];
  1053.  
  1054.  
  1055.  
  1056. WORD16 DevCtxArm              // Arm a context hook
  1057.   (
  1058.   HCONTEXT Hook,              // Handle of context hook to arm
  1059.   WORD32 Parameter            // Parameter to pass to context hook in EAX
  1060.   );                          // Returns: 0 = success, other = error code
  1061.  
  1062. #pragma aux DevCtxArm =       \
  1063.   "xchg bx,cx"                \
  1064.   "xchg ax,dx"                \
  1065.   "shl eax,10h"               \
  1066.   "mov ax,dx"                 \
  1067.   "shl ebx,10h"               \
  1068.   "mov bx,cx"                 \
  1069.   "mov ecx,0FFFFFFFFh"        \
  1070.   "mov dl,65h"                \
  1071.   "call dword ptr Dev_Entry"  \
  1072.   "setc dl"                   \
  1073.   "xor dh,dh"                 \
  1074.   "neg dx"                    \
  1075.   "and ax,dx"                 \
  1076.   parm [cx bx] [dx ax]        \
  1077.   value [ax];
  1078.  
  1079.  
  1080.  
  1081. WORD16 DevEventOpen           // Open a shared event semaphore
  1082.   (
  1083.   WORD32 Semaphore            // Shared event semaphore handle
  1084.   );                          // Returns: 0 = success, other = error code
  1085.  
  1086. #pragma aux DevEventOpen =    \
  1087.   "xchg ax,dx"                \
  1088.   "shl eax,10h"               \
  1089.   "mov ax,dx"                 \
  1090.   "mov dl,67h"                \
  1091.   "call dword ptr Dev_Entry"  \
  1092.   "setc dl"                   \
  1093.   "xor dh,dh"                 \
  1094.   "neg dx"                    \
  1095.   "and ax,dx"                 \
  1096.   parm [dx ax]                \
  1097.   value [ax];
  1098.  
  1099.  
  1100.  
  1101. WORD16 DevEventClose          // Close a shared event semaphore
  1102.   (
  1103.   WORD32 Semaphore            // Shared event semaphore handle
  1104.   );                          // Returns: 0 = success, other = error code
  1105.  
  1106. #pragma aux DevEventClose =   \
  1107.   "xchg ax,dx"                \
  1108.   "shl eax,10h"               \
  1109.   "mov ax,dx"                 \
  1110.   "mov dl,68h"                \
  1111.   "call dword ptr Dev_Entry"  \
  1112.   "setc dl"                   \
  1113.   "xor dh,dh"                 \
  1114.   "neg dx"                    \
  1115.   "and ax,dx"                 \
  1116.   parm [dx ax]                \
  1117.   value [ax];
  1118.  
  1119.  
  1120.  
  1121. WORD16 DevEventPost           // Post a shared event semaphore
  1122.   (
  1123.   WORD32 Semaphore            // Shared event semaphore handle
  1124.   );                          // Returns: 0 = success, other = error code
  1125.  
  1126. #pragma aux DevEventPost =    \
  1127.   "xchg ax,dx"                \
  1128.   "shl eax,10h"               \
  1129.   "mov ax,dx"                 \
  1130.   "mov dl,69h"                \
  1131.   "call dword ptr Dev_Entry"  \
  1132.   "setc dl"                   \
  1133.   "xor dh,dh"                 \
  1134.   "neg dx"                    \
  1135.   "and ax,dx"                 \
  1136.   parm [dx ax]                \
  1137.   value [ax];
  1138.  
  1139.  
  1140.  
  1141. WORD16 DevEventReset          // Reset a shared event semaphore
  1142.   (
  1143.   WORD32 Semaphore            // Shared event semaphore handle
  1144.   );                          // Returns: 0 = success, other = error code
  1145.  
  1146. #pragma aux DevEventReset =   \
  1147.   "xchg ax,dx"                \
  1148.   "shl eax,10h"               \
  1149.   "mov ax,dx"                 \
  1150.   "mov dl,6Ah"                \
  1151.   "call dword ptr Dev_Entry"  \
  1152.   "setc dl"                   \
  1153.   "xor dh,dh"                 \
  1154.   "neg dx"                    \
  1155.   "and ax,dx"                 \
  1156.   parm [dx ax]                \
  1157.   value [ax];
  1158.  
  1159.  
  1160.  
  1161. WORD16 DevDynamicAPI16        // Create a call gate into a 16:16 function
  1162.   (
  1163.   VOID FAR* EntryPoint,       // Entry point for the created call gate
  1164.   WORD16 Count,               // Parameter count
  1165.   BYTE GateType,              // Gate type: 1 = 16 bit gate, 0 = 32 bit gate
  1166.   SEL FAR* Selector           // Storage for created call gate selector
  1167.   );                          // Returns: 0 = success, other = error code
  1168.  
  1169. #pragma aux DevDynamicAPI16 = \
  1170.   "xchg ax,bx"                \
  1171.   "and dh,01h"                \
  1172.   "or dh,02h"                 \
  1173.   "mov dl,6Ch"                \
  1174.   "call dword ptr Dev_Entry"  \
  1175.   "mov es:[si],di"            \
  1176.   "setc dl"                   \
  1177.   "xor dh,dh"                 \
  1178.   "neg dx"                    \
  1179.   "and ax,dx"                 \
  1180.   modify [di dl]              \
  1181.   parm [bx ax] [cx] [dh] [es si] \
  1182.   value [ax];
  1183.  
  1184.  
  1185.  
  1186. WORD16 DevDynamicAPI32        // Create a call gate into a 0:32 function
  1187.   (
  1188.   LINEAR EntryPoint,          // Entry point for the created call gate
  1189.   WORD16 Count,               // Parameter count
  1190.   BYTE GateType,              // Gate type: 1 = 16 bit gate, 0 = 32 bit gate
  1191.   SEL FAR* Selector           // Storage for created call gate selector
  1192.   );                          // Returns: 0 = success, other = error code
  1193.  
  1194. #pragma aux DevDynamicAPI32 = \
  1195.   "xchg ax,bx"                \
  1196.   "and dh,01h"                \
  1197.   "mov dl,6Ch"                \
  1198.   "call dword ptr Dev_Entry"  \
  1199.   "mov es:[si],di"            \
  1200.   "setc dl"                   \
  1201.   "xor dh,dh"                 \
  1202.   "neg dx"                    \
  1203.   "and ax,dx"                 \
  1204.   modify [di dl]              \
  1205.   parm [bx ax] [cx] [dh] [es si] \
  1206.   value [ax];
  1207.  
  1208.  
  1209.  
  1210.  
  1211. // Interface to the OS/2 Ring 3 APIs available at initialization
  1212. //
  1213. //
  1214.  
  1215. extern "C"
  1216. {
  1217. //File bsedos.h:
  1218.    #define FILE_NORMAL     0x0000
  1219. //File bsedos.h:
  1220.    #define FILE_ARCHIVED   0x0020
  1221.    #define MUST_HAVE_ARCHIVED      ( (FILE_ARCHIVED  << 8) | FILE_ARCHIVED  )
  1222. //File bsedos.h:
  1223.    #define OPEN_ACTION_CREATE_IF_NEW      0x0010  /* ---- ---- 0001 ---- */
  1224. //File bsedos.h:
  1225.    #define OPEN_ACTION_OPEN_IF_EXISTS     0x0001  /* ---- ---- ---- 0001 */
  1226. //File bsedos.h:
  1227.    #define OPEN_FLAGS_NOINHERIT           0x0080  /* ---- ---- 1--- ---- */
  1228. //File bseerr.h:
  1229.    #define NO_ERROR        0       /* MSG%RESPONSE_DATA */
  1230.    #define NO_ERROR_MOUSE_NO_DATA  393     /* MSG%none */
  1231.    #define NO_ERROR_MOUSE_PTR_DRAWN        394     /* MSG%none */
  1232.    #define NO_ERROR_BIDI_RW_INCOMPLETE     684    /* MSG%none */
  1233. //File bsedos.h:
  1234.    #define FILE_BEGIN      0x0000   /* Move relative to beginning of file */
  1235. //File bsedos.h:
  1236.    #define OPEN_SHARE_DENYNONE            0x0040  /* ---- ---- -100 ---- */
  1237. //File bsedos.h:
  1238.    #define OPEN_ACCESS_READWRITE          0x0002  /* ---- ---- ---- -010 */
  1239.  
  1240. WORD16 DosBeep(WORD16 Frequency, WORD16 Duration);
  1241. #pragma aux (API16) DosBeep;
  1242.  
  1243. WORD16 DosCaseMap(WORD16 Length, VOID FAR* Country, CHAR FAR* String);
  1244. #pragma aux (API16) DosCaseMap;
  1245.  
  1246. WORD16 DosChgFilePtr(HFILE File, LONG Dist, WORD16 Type, WORD32 FAR* Pointer);
  1247. #pragma aux (API16) DosChgFilePtr;
  1248.  
  1249. WORD16 DosClose(HFILE File);
  1250. #pragma aux (API16) DosClose;
  1251.  
  1252. WORD16 DosDelete(CONST CHAR FAR* FileName, WORD32 Reserved);
  1253. #pragma aux (API16) DosDelete;
  1254.  
  1255. WORD16 DosDevConfig(BYTE FAR* Info, WORD16 Type, WORD16 Reserved);
  1256. #pragma aux (API16) DosDevConfig;
  1257.  
  1258. WORD16 DosDevIOCtl(VOID FAR*, VOID FAR*, WORD16, WORD16, WORD16);
  1259. #pragma aux (API16) DosDevIOCtl;
  1260.  
  1261. WORD16 DosFindClose(HDIR Handle);
  1262. #pragma aux (API16) DosFindClose;
  1263.  
  1264. WORD16 DosFindFirst(CONST CHAR FAR* FileName, HDIR FAR* Handle, WORD16 Attrib,
  1265.                     VOID FAR* ResultBuf, WORD16 ResultLen,
  1266.                     WORD32 FAR* SearchCount, WORD32 Level);
  1267. #pragma aux (API16) DosFindFirst;
  1268.  
  1269. WORD16 DosFindNext(HDIR Handle, VOID FAR* ResultBuf, WORD16 ResultLen,
  1270.                    WORD32 FAR* SearchCount);
  1271. #pragma aux (API16) DosFindNext;
  1272.  
  1273. WORD16 DosGetEnv(VOID FAR*, VOID FAR*);
  1274. #pragma aux (API16) DosGetEnv;
  1275.  
  1276. WORD16 DosGetMessage(WORD32 FAR* Table, WORD16 Count,
  1277.                      CHAR FAR* DataBuf, WORD16 DataSize,
  1278.                      WORD16 Number, CONST CHAR FAR* FileName,
  1279.                      WORD32 FAR* Length);
  1280. #pragma aux (API16) DosGetMessage;
  1281.  
  1282. WORD16 DosOpen(CONST CHAR FAR* FileName, HFILE FAR* File, WORD32 FAR* Action,
  1283.                WORD32 Size, WORD16 Attr, WORD16 Flag, WORD16 Mode, WORD32);
  1284. #pragma aux (API16) DosOpen;
  1285.  
  1286. WORD16 DosPutMessage(HFILE, WORD16 Length, CONST CHAR FAR* Message);
  1287. #pragma aux (API16) DosPutMessage;
  1288.  
  1289. WORD16 DosQCurDir(WORD16 Drive, CONST CHAR FAR* Path, WORD32 FAR* Length);
  1290. #pragma aux (API16) DosQCurDir;
  1291.  
  1292. WORD16 DosQCurDisk(WORD32 FAR* Drive, WORD32 FAR* DriveMap);
  1293. #pragma aux (API16) DosQCurDisk;
  1294.  
  1295. WORD16 DosQFileInfo(HFILE File, WORD16 Level, VOID FAR* Buffer, WORD16 Size);
  1296. #pragma aux (API16) DosQFileInfo;
  1297.  
  1298. WORD16 DosQFileMode(VOID FAR*, VOID FAR*, WORD32);
  1299. #pragma aux (API16) DosQFileMode;
  1300.  
  1301. WORD16 DosRead(HFILE File, VOID FAR* Buffer, WORD16 Size, WORD16 FAR* Length);
  1302. #pragma aux (API16) DosRead;
  1303.  
  1304. WORD16 DosWrite(HFILE File, VOID FAR* Buffer, WORD16 Size, WORD16 FAR* Length);
  1305. #pragma aux (API16) DosWrite;
  1306. }
  1307.  
  1308.  
  1309.  
  1310.  
  1311. #endif // DevHelp_h
  1312.