home *** CD-ROM | disk | FTP | other *** search
/ Programmer Power Tools / Programmer Power Tools.iso / progjrn / pj_6_1.arc / CODE.EMM < prev    next >
Encoding:
Text File  |  1987-12-28  |  8.8 KB  |  389 lines
  1.  
  2. (*          TURBO PASCAL LIM 4.0 EXPANDED MEMORY CODING EXAMPLES           *)
  3. (*-------------------------------------------------------------------------*)
  4. (* Most of the TYPE declarations in this listing are provided as Pascal    *)
  5. (* templates for data structures defined in the LIM 4.0 EMS specification. *)
  6. (* Most of the function/procedure VAR parameters are declared as Turbo     *)
  7. (* Pascal untyped parameters due to the fact that the size of the data     *)
  8. (* structures will have to be determined dynamically at the time of the    *)
  9. (* function/procedure call.  Note that this code is not a program, unit,   *)
  10. (* or other compilable structure and has not been tested in executable     *)
  11. (* form.  Page 34 V6.1.  Copyright 1987 John J. Newlin                     *)  
  12.  
  13. TYPE
  14.  
  15.   Str4 = string[4];
  16.  
  17.   PartMapPtrType = ^integer;
  18.  
  19.   HandleNameType = array[1..8] of char;
  20.  
  21.   Regpack     = record case integer of
  22.                  1 : (ax,bx,cx,dx,bp,si,di,ds,es,flags:integer);
  23.                  2 : (al,ah,bl,bh,cl,ch,dl,dh : byte);
  24.                 end;
  25.  
  26.   HandlePageRec = record
  27.                     emm_handle,pages : integer;
  28.                   end;
  29.  
  30.   MapArrayType = array[0..255] of byte;
  31.  
  32.   TargetAddrPtrType = ^integer;
  33.  
  34.   MapArrayPtrType = ^integer;
  35.  
  36.   MapJumpType = record
  37.                   target_addr_ptr : TargetAddrPtrType;
  38.                   map_length      : byte;
  39.                   map_array_ptr   : MapArrayPtrType;
  40.                 end;
  41.  
  42.   MapCallType = record
  43.                   target_addr_ptr   : TargetAddrPtrType;
  44.                   new_map_length    : byte;
  45.                   new_map_array_ptr : MapArrayPtrtype;
  46.                   old_map_length    : byte;
  47.                   old_map_array_ptr : MapArrayPtrType;
  48.                   reserved          : array[1..4] of integer;
  49.                 end;
  50.  
  51.   LongIntType = Array[1..2] of integer;
  52.  
  53.   SourceDestType = record
  54.                      region_length      : LongIntType;
  55.                      source_mem_type    : byte;
  56.                      source_handle      : integer;
  57.                      source_init_offset : integer;
  58.                      source_init_seg    : integer;
  59.                      dest_mem_type      : byte;
  60.                      dest_handle        : integer;
  61.                      dest_init_offset   : integer;
  62.                      dest_init_seg      : integer;
  63.                    end;
  64.  
  65. CONST
  66.  
  67.  Emm = $67;
  68.  
  69. VAR
  70.   Regs : Regpack;
  71.   HandlePageArray : array[1..255] of HandlePageRec;
  72.  
  73. Function GetStatus : integer;
  74. begin
  75.   Regs.ah := $40;
  76.   intr(Emm,Regs);
  77.   GetStatus := Regs.ah
  78. end;
  79.  
  80. Function PageFrame : integer;
  81. begin
  82.   Regs.ah := $41;
  83.   intr(Emm,Regs);
  84.   PageFrame := Regs.bx
  85. end;
  86.  
  87. Function FreePages(var TotalPages : integer) : integer;
  88. begin
  89.   Regs.ah := $42;
  90.   intr(Emm,Regs);
  91.   TotalPages := Regs.dx;
  92.   FreePages := Regs.bx;
  93. end;
  94.  
  95. Procedure GetPages(var Handle,Pages : integer);
  96. begin
  97.   Regs.ah := $43;
  98.   Regs.bx := Pages;
  99.   intr(Emm,Regs);
  100.   Handle := Regs.dx;
  101. end;
  102.  
  103. Procedure MapPages(Handle,Logical,Physical : integer);
  104. begin
  105.   Regs.ah := $44;
  106.   Regs.al := Physical;
  107.   Regs.bx := Logical;
  108.   Regs.dx := Handle;
  109.   intr(Emm,Regs);
  110. end;
  111.  
  112. Procedure GivePages(Handle : integer);
  113. begin
  114.   Regs.ah := $45;
  115.   Regs.dx := Handle;
  116.   intr(Emm,Regs);
  117. end;
  118.  
  119. Function EmmVersion : str4;
  120. var lobyte : byte;
  121.     s1,s2 : str4;
  122. begin
  123.   Regs.ah := $46;
  124.   intr(Emm,Regs);
  125.   lobyte := Regs.al shl 4;
  126.   lobyte := lobyte shr 4;
  127.   str(Regs.al shr 4,s1);
  128.   str(lobyte,s2);
  129.   EmmVersion := s1 + '.' + s2;
  130. end;
  131.  
  132. Procedure SavePageMap(Handle : integer);
  133. begin
  134.   Regs.ah := $47;
  135.   Regs.dx := Handle;
  136.   intr(Emm,Regs);
  137. end;
  138.  
  139. Procedure RestSaveMap(Handle : integer);
  140. begin
  141.   Regs.ah := $48;
  142.   Regs.dx := Handle;
  143.   intr(Emm,Regs);
  144. end;
  145.  
  146. Function HandleCount : integer;
  147. begin
  148.   Regs.ah := $4B;
  149.   intr(Emm,Regs);
  150.   HandleCount := Regs.bx;
  151. end;
  152.  
  153. Function HandlePages(Handle : integer) : integer;
  154. begin
  155.   Regs.ah := $4C;
  156.   Regs.dx := Handle;
  157.   intr(Emm,Regs);
  158.   HandlePages := Regs.bx;
  159. end;
  160.  
  161. Function GetAllHandles : integer;
  162. begin
  163.   Regs.ah := $4D;
  164.   Regs.es := seg(HandlePageArray);
  165.   Regs.di := ofs(HandlePageArray);
  166.   intr(Emm,Regs);
  167.   GetAllHandles := Regs.bx;
  168. end;
  169.  
  170. Procedure GetPageMap(var maparray);
  171. begin
  172.   Regs.ax := $4E00;
  173.   Regs.es := seg(maparray);
  174.   Regs.di := ofs(maparray);
  175.   intr(Emm,Regs);
  176. end;
  177.  
  178. Procedure SetPageMap(var maparray);
  179. begin
  180.   Regs.ax := $4E01;
  181.   Regs.ds := seg(maparray);
  182.   Regs.si := ofs(maparray);
  183.   intr(Emm,Regs);
  184. end;
  185.  
  186. Procedure GetSetMap(var getarray,setarray);
  187. begin
  188.   Regs.ax := $4E02;
  189.   Regs.es := seg(getarray);
  190.   Regs.di := ofs(getarray);
  191.   Regs.ds := seg(setarray);
  192.   Regs.si := ofs(setarray);
  193.   intr(Emm,Regs);
  194. end;
  195.  
  196. Function PageMapSize : integer;
  197. begin
  198.   Regs.ax := $4E03;
  199.   intr(Emm,Regs);
  200.   PageMapSize := Regs.al;
  201. end;
  202.  
  203. Procedure GetPartMap(var part_page_map,dest_array);
  204. begin
  205.   Regs.ax := $4F00;
  206.   Regs.ds := seg(part_page_map);
  207.   Regs.si := ofs(part_page_map);
  208.   Regs.es := seg(dest_array);
  209.   Regs.di := ofs(dest_array);
  210.   intr(Emm,Regs);
  211. end;
  212.  
  213. Procedure SetPartMap(var source_array);
  214. begin
  215.   Regs.ax := $4F01;
  216.   Regs.ds := seg(source_array);
  217.   Regs.si := ofs(source_array);
  218.   intr(Emm,Regs);
  219. end;
  220.  
  221. Function PartMapSize(pages : integer) : integer;
  222. begin
  223.   Regs.ax := $4F02;
  224.   Regs.bx := pages;
  225.   intr(Emm,Regs);
  226.   PartMapSize := Regs.al;
  227. end;
  228.  
  229. Procedure MapLogToPhys(var map_array; handle,map_array_len : integer);
  230. begin
  231.   Regs.ax := $5000;
  232.   Regs.dx := handle;
  233.   Regs.cx := map_array_len;
  234.   Regs.ds := seg(map_array);
  235.   Regs.si := ofs(map_array);
  236.   intr(Emm,Regs);
  237. end;
  238.  
  239. Procedure MapLogToSeg(var seg_array; handle,seg_array_len : integer);
  240. begin
  241.   Regs.ax := $5001;
  242.   Regs.dx := handle;
  243.   Regs.cx := seg_array_len;
  244.   Regs.ds := seg(seg_array);
  245.   Regs.si := ofs(seg_array);
  246.   intr(Emm,Regs);
  247. end;
  248.  
  249. Function ReAllocPages(handle,alloc_count : integer);
  250. begin
  251.   Regs.ah := $51;
  252.   Regs.bx := alloc_count;
  253.   Regs.dx := handle;
  254.   intr(Emm,Regs);
  255.   ReAllocPages := Regs.bx;
  256. end;
  257.  
  258. Function GetHandleAttr(handle : integer) : integer;
  259. begin
  260.   Regs.ax := $5200;
  261.   Regs.dx := handle;
  262.   intr(Emm,Regs);
  263.   GetHandleAttr := regs.al;
  264. end;
  265.  
  266. Procedure SetHandleAttr(handle,attr : integer);
  267. begin
  268.   Regs.ax := $5201;
  269.   Regs.bl := attr;
  270.   Regs.dx := handle;
  271.   intr(Emm,Regs);
  272. end;
  273.  
  274. Function GetAttr : integer;
  275. begin
  276.   Regs.ax := $5202;
  277.   intr(Emm,Regs);
  278.   GetAttr := Regs.al;
  279. end;
  280.  
  281. Procedure GetHandleName(handle : integer; var name : HandleNameType);
  282. begin
  283.   Regs.ax := $5300;
  284.   Regs.dx := handle;
  285.   Regs.es := seg(name);
  286.   Regs.di := ofs(name);
  287.   intr(Emm,Regs);
  288. end;
  289.  
  290. Procedure SetHandleName(handle : integer; var name : HandleNameType);
  291. begin
  292.   Regs.ax := $5301;
  293.   Regs.dx := handle;
  294.   Regs.ds := seg(name);
  295.   Regs.si := ofs(name);
  296.   intr(Emm,Regs);
  297. end;
  298.  
  299. Function GetHandleDir(var handle_dir) : integer;
  300. begin
  301.   Regs.ax := $5400;
  302.   Regs.es := seg(handle_dir);
  303.   Regs.di := ofs(handle_dir);
  304.   intr(Emm,Regs);
  305.   GetHandleDir := Regs.al;
  306. end;
  307.  
  308. Function GetHandleValue(var name : HandleNameType) : integer;
  309. begin
  310.   Regs.ax := $5401;
  311.   Regs.ds := seg(name);
  312.   Regs.si := ofs(name);
  313.   intr(Emm,Regs);
  314.   GetHandleValue := Regs.dx;
  315. end;
  316.  
  317. Function GetTotalHandles : integer;
  318. begin
  319.   Regs.ax := $5402;
  320.   intr(Emm,Regs);
  321.   GetTotalHandles := Regs.bx;
  322. end;
  323.  
  324. Procedure EmmJump(handle : integer; var map_jump_rec; page_selector : byte);
  325. begin
  326.   Regs.ah := $55;
  327.   Regs.al := page_selector;
  328.   Regs.dx := handle;
  329.   Regs.ds := seg(map_jump_rec);
  330.   Regs.si := ofs(map_jump_rec);
  331.   intr(Emm,Regs);
  332. end;
  333.  
  334. Procedure EmmCall(handle : integer; var map_call_rec; page_selector : byte);
  335. begin
  336.   Regs.ah := $56;
  337.   Regs.al := page_selector;
  338.   Regs.dx := handle;
  339.   Regs.ds := seg(map_call_rec);
  340.   Regs.si := seg(map_call_rec);
  341.   intr(Emm,Regs);
  342. end;
  343.  
  344. Function MapStackSize : integer;
  345. begin
  346.   Regs.Ax := $5602;
  347.   intr(Emm,Regs);
  348.   MapStackSize := Regs.bx;
  349. end;
  350.  
  351. Procedure MovMemRegion(var source_dest_rec);
  352. begin
  353.   Regs.ax := $5700;
  354.   Regs.ds := seg(source_dest_rec);
  355.   Regs.si := ofs(source_dest_rec);
  356.   intr(Emm,Regs);
  357. end;
  358.  
  359. Procedure ExcMemRegion(var source_dest_rec);
  360. begin
  361.   Regs.ax := $5701;
  362.   Regs.ds := seg(source_dest_rec);
  363.   Regs.si := seg(source_dest_rec);
  364.   intr(Emm,Regs);
  365. end;
  366.  
  367. Procedure PhysMapArray(var phys_map_array; var map_size : integer);
  368. begin
  369.   Regs.ax := $5800;
  370.   Regs.es := seg(phys_map_array);
  371.   Regs.di := ofs(phys_map_array);
  372.   intr(Emm,Regs);
  373.   map_size := Regs.cx;
  374. end;
  375.  
  376. Function PhysMapEntries : integer;
  377. begin
  378.   Regs.ax := $5801;
  379.   intr(Emm,Regs);
  380.   PhysMapEntries := Regs.cx;
  381. end;
  382.  
  383. Procedure PrepWarmBoot;
  384. begin
  385.   Regs.ah := $5C;
  386.   intr(Emm,Regs);
  387. end;
  388.  
  389.