home *** CD-ROM | disk | FTP | other *** search
/ Computer Panoráma / computer_panorama_1997-12-hibas.iso / SHARE / GRAPH / PTC051.ZIP / SRC / DPMI.H < prev    next >
C/C++ Source or Header  |  1997-09-09  |  9KB  |  469 lines
  1. ////////////////////
  2. // DPMI interface //
  3. ////////////////////
  4.  
  5. #ifndef __DPMI_H
  6. #define __DPMI_H
  7.  
  8. #include "lang.h"
  9. #include "misc.h"
  10. #include "config.h"
  11.  
  12.  
  13.  
  14. #ifdef __DPMI__
  15.  
  16. #include <dos.h>
  17. #include "far.h"
  18. #include <string.h>
  19.  
  20. #ifdef __DJGPP__
  21. #include <dpmi.h>
  22. #endif
  23.  
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30. // DPMI registers
  31. #pragma pack(1)
  32. struct DPMIREGS
  33. {
  34.     uint edi      PACKED;
  35.     uint esi      PACKED;
  36.     uint ebp      PACKED;
  37.     uint reserved PACKED;
  38.     uint ebx      PACKED;
  39.     uint edx      PACKED;
  40.     uint ecx      PACKED;
  41.     uint eax      PACKED;
  42.     ushort flags  PACKED;
  43.     ushort es     PACKED;
  44.     ushort ds     PACKED;
  45.     ushort fs     PACKED;
  46.     ushort gs     PACKED;
  47.     ushort ip     PACKED;
  48.     ushort cs     PACKED;
  49.     ushort sp     PACKED;
  50.     ushort ss     PACKED;
  51. };
  52. #pragma pack()
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60. class DPMI
  61. {
  62.     public:
  63.  
  64.         // DPMI info
  65.         #pragma pack(1)
  66.         struct INFO
  67.         {
  68.             uchar major     PACKED;
  69.             uchar minor     PACKED;
  70.             ushort flags    PACKED;
  71.             uchar processor PACKED;
  72.             uchar masterPIC PACKED;
  73.             uchar slavePIC  PACKED;
  74.         };
  75.         #pragma pack()
  76.         
  77.         // setup
  78.         inline DPMI();
  79.         inline ~DPMI();
  80.  
  81.         // high level dpmi interface
  82.         inline int GetDosMemory(ushort *segment,ushort *selector,int bytes=4096); 
  83.  
  84.         // low level dpmi interface
  85.         inline static int GetVersion(INFO *version);
  86.         inline static int AllocateSelector(ushort *selector);
  87.         inline static int FreeSelector(ushort selector);
  88.         inline static int SegmentToSelector(ushort segment,ushort *selector);
  89.         inline static int GetSelectorBase(ushort selector,uint *base);
  90.         inline static int SetSelectorBase(ushort selector,uint base);
  91.         inline static int SetSelectorLimit(ushort selector,uint limit);
  92.         inline static int SetSelectorRights(ushort selector,ushort rights);
  93.         inline static int AllocateDosMemory(ushort *segment,ushort *selector,uint bytes);
  94.         inline static int FreeDosMemory(ushort selector);
  95.         inline static int ResizeDosMemory(ushort selector,uint bytes);
  96.         inline static int MapPhysicalAddress(uint physical,uint size,uint *linear);
  97.         inline static int FreePhysicalMapping(uint linear);
  98.         inline static int int86(uchar interrupt_no,DPMIREGS *in,DPMIREGS *out);
  99.  
  100.         // status
  101.         inline int ok();
  102.  
  103.     private:
  104.  
  105.         // static dos memory
  106.         static int InitDosMemory(int bytes);
  107.         static void CloseDosMemory();
  108.         static int DosMemoryCount;
  109.         static ushort DosMemorySegment;
  110.         static ushort DosMemorySelector;
  111.         static uint DosMemorySize;
  112.  
  113.         // status
  114.         int Status;
  115. };
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122. // WHAT TO DO WITH THIS? -- ????
  123.  
  124. // map a realmode pointer into flat address space
  125. #define DPMI_MapRealPointer(p)   (void*)((((uint)(p)>>12)&0xFFFF0)+((p)&0xFFFF))
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132. inline DPMI::DPMI()
  133. {
  134.     // initialize dos memory
  135.     if (!InitDosMemory(4096)) Status=0;
  136.     else Status=1;
  137. }
  138.  
  139.  
  140. inline DPMI::~DPMI()
  141. {
  142.     // close dos memory
  143.     CloseDosMemory();
  144. }
  145.  
  146.  
  147.  
  148.  
  149.  
  150.  
  151. inline int DPMI::GetDosMemory(ushort *segment,ushort *selector,int size)
  152. {
  153.     if (size>DosMemorySize)
  154.     {
  155.         // resize static block?
  156.         return 0;
  157.     }
  158.          
  159.     // return static dos memory block
  160.     *segment=DosMemorySegment;
  161.     *selector=DosMemorySelector;
  162.     return 1;
  163. }
  164.  
  165.  
  166.  
  167.  
  168.  
  169.  
  170. inline int DPMI::GetVersion(DPMI::INFO *version)
  171. {
  172. #ifdef __DJGPP__
  173.  
  174.     if (__dpmi_get_version((__dpmi_version_ret*)version)!=-1) return 1;
  175.     else return 0;
  176.  
  177. #else
  178.  
  179.     REGS regs;
  180.     memset(®s,0,sizeof(regs));
  181.     regs.w.ax=0x400;
  182.     ::int386(0x31,®s,®s);
  183.     version->major=regs.h.ah;
  184.     version->minor=regs.h.al;
  185.     version->flags=regs.w.bx;
  186.     version->processor=regs.h.cl;
  187.     version->masterPIC=regs.h.dh;
  188.     version->slavePIC=regs.h.dl;
  189.     return !regs.w.cflag;
  190.  
  191. #endif
  192. }
  193.  
  194.  
  195. inline int DPMI::AllocateSelector(ushort *selector)
  196. {     
  197.     REGS regs;
  198.     memset(®s,0,sizeof(regs));
  199.     regs.w.ax=0;
  200.     regs.w.cx=1;
  201.     ::int386(0x31,®s,®s);
  202.     *selector=regs.w.ax;
  203.     return !regs.w.cflag;
  204. }
  205.  
  206.  
  207. inline int DPMI::FreeSelector(ushort selector)
  208. {
  209.     REGS regs;
  210.     memset(®s,0,sizeof(regs));
  211.     regs.w.ax=1;
  212.     regs.w.bx=selector;
  213.     ::int386(0x31,®s,®s);
  214.     return !regs.w.cflag;
  215. }
  216.  
  217.  
  218. inline int DPMI::SegmentToSelector(ushort segment,ushort *selector)
  219. {
  220.     REGS regs;
  221.     memset(®s,0,sizeof(regs));
  222.     regs.w.ax=2;
  223.     regs.w.bx=segment;
  224.     ::int386(0x31,®s,®s);
  225.     *selector=regs.w.ax;
  226.     return !regs.w.cflag;
  227. }
  228.  
  229.  
  230. inline int DPMI::GetSelectorBase(ushort selector,uint *base)
  231. {
  232.     REGS regs;
  233.     memset(®s,0,sizeof(regs));
  234.     regs.w.ax=6;
  235.     regs.w.bx=selector;
  236.     ::int386(0x31,®s,®s);
  237.     *base=((uint)regs.w.cx<<16)+regs.w.dx;
  238.     return !regs.w.cflag;
  239. }
  240.  
  241.  
  242. inline int DPMI::SetSelectorBase(ushort selector,uint base)
  243. {
  244.     REGS regs;
  245.     memset(®s,0,sizeof(regs));
  246.     regs.w.ax=7;
  247.     regs.w.bx=selector;
  248.     regs.w.cx=base >> 16;
  249.     regs.w.dx=base & 0xffff;
  250.     ::int386(0x31,®s,®s);
  251.     return !regs.w.cflag;
  252. }
  253.  
  254.  
  255. inline int DPMI::SetSelectorLimit(ushort selector,uint limit)
  256. {
  257.     REGS regs;
  258.     memset(®s,0,sizeof(regs));
  259.     regs.w.ax=8;
  260.     regs.w.bx=selector;
  261.     regs.w.cx=limit >> 16;
  262.     regs.w.dx=limit & 0xffff;
  263.     ::int386(0x31,®s,®s);
  264.     return !regs.w.cflag;
  265. }
  266.  
  267.  
  268. inline int DPMI::SetSelectorRights(ushort selector,ushort rights)
  269. {
  270.     REGS regs;
  271.     memset(®s,0,sizeof(regs));
  272.     regs.w.ax=9;
  273.     regs.w.bx=selector;
  274.     regs.w.cx=rights;
  275.     ::int386(0x31,®s,®s);
  276.     return !regs.w.cflag;
  277. }
  278.  
  279.  
  280. inline int DPMI::AllocateDosMemory(ushort *segment,ushort *selector,uint bytes)
  281. {
  282. /*
  283. #ifdef __DJGPP__
  284.  
  285.     int sel;
  286.     if (__dpmi_allocate_dos_memory((bytes+16)>>4,&sel)!=-1)
  287.     {
  288.         *selector=sel;
  289.         segment=
  290.         return 1;
  291.     }
  292.     else return 0;
  293.  
  294. #else
  295. */
  296.     REGS regs;
  297.     memset(®s,0,sizeof(regs));
  298.     regs.w.ax=0x100;
  299.     regs.w.bx=(bytes+16)>>4;
  300.     ::int386(0x31,®s,®s);
  301.     if (regs.w.cflag==0)
  302.     {
  303.         *segment=regs.w.ax;
  304.         *selector=regs.w.dx;
  305.         return 1;
  306.     }
  307.     else return 0;
  308.  
  309. //#endif
  310. }
  311.  
  312.  
  313. inline int DPMI::FreeDosMemory(ushort selector)
  314. {
  315. #ifdef __DJGPP__
  316.  
  317.     if (__dpmi_free_dos_memory(selector)!=-1) return 1;
  318.     else return 0;
  319.  
  320. #else
  321.  
  322.     REGS regs;
  323.     memset(®s,0,sizeof(regs));
  324.     regs.w.ax=0x101;
  325.     regs.w.dx=selector;
  326.     ::int386(0x31,®s,®s);
  327.     return !regs.w.cflag;
  328.  
  329. #endif
  330. }
  331.  
  332.  
  333. inline int DPMI::ResizeDosMemory(ushort selector,uint bytes)
  334. {
  335. #ifdef __DJGPP__
  336.  
  337.     if (__dpmi_resize_dos_memory(selector,(bytes+16)>>4,NULL)!=-1) return 1;
  338.     else return 0;
  339.  
  340. #else
  341.  
  342.     REGS regs;
  343.     memset(®s,0,sizeof(regs));
  344.     regs.w.ax=0x102;
  345.     regs.w.bx=selector;
  346.     regs.w.dx=(bytes+16)>>4;
  347.     ::int386(0x31,®s,®s);
  348.     return !regs.w.cflag;
  349.  
  350. #endif
  351. }
  352.  
  353.  
  354. inline int DPMI::MapPhysicalAddress(uint physical,uint size,uint *linear)
  355. {
  356. #ifdef __DJGPP__
  357.  
  358.     __dpmi_meminfo info;
  359.     info.size=size;
  360.     info.address=physical;    
  361.     if (__dpmi_physical_address_mapping(&info)!=-1)
  362.     {
  363.         *linear=info.address;
  364.         return 1;
  365.     }
  366.     else 
  367.     {
  368.         *linear=NULL;
  369.         return 0;
  370.     }
  371.  
  372. #else
  373.  
  374.     REGS regs;
  375.     memset(®s,0,sizeof(regs));
  376.     regs.w.ax=0x800;
  377.     regs.w.bx=physical >> 16;
  378.     regs.w.cx=physical & 0xffff;
  379.     regs.w.si=size >> 16;
  380.     regs.w.di=size & 0xffff;
  381.     ::int386(0x31,®s,®s);
  382.     if (regs.w.cflag==0)
  383.     {
  384.         *linear=((uint)regs.w.bx<<16) + regs.w.cx;
  385.         return 1;
  386.     }
  387.     else
  388.     {
  389.         *linear=NULL;
  390.         return 0;
  391.     }
  392.  
  393. #endif
  394. }
  395.  
  396.  
  397. inline int DPMI::FreePhysicalMapping(uint linear)
  398. {
  399. #ifdef __DJGPP__
  400.  
  401.     __dpmi_meminfo info;
  402.     info.size=0;
  403.     info.address=linear;
  404.     if (__dpmi_free_physical_address_mapping(&i