home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 19 / CD_ASCQ_19_010295.iso / dos / prg / midas / ems.pas < prev    next >
Pascal/Delphi Source File  |  1994-08-06  |  8KB  |  271 lines
  1. {*      EMS.PAS
  2.  *
  3.  * EMS heap manager, v1.10
  4.  *
  5.  * Copyright 1994 Petteri Kangaslampi and Jarno Paananen
  6.  *
  7.  * This file is part of the MIDAS Sound System, and may only be
  8.  * used, modified and distributed under the terms of the MIDAS
  9.  * Sound System license, LICENSE.TXT. By continuing to use,
  10.  * modify or distribute this file you indicate that you have
  11.  * read the license and understand and accept it fully.
  12. *}
  13.  
  14.  
  15. unit EMS;
  16.  
  17.  
  18. interface
  19.  
  20.  
  21. {****************************************************************************\
  22. *       struct emsBlock
  23. *       ---------------
  24. * Description:  Allocated EMS block structure
  25. \****************************************************************************}
  26.  
  27. type
  28.     emsBlock = Record
  29.         addr : word;                        { address of block inside handle
  30.                                               memory area }
  31.         bytes : word;                       { size of block }
  32.         next : pointer;                     { pointer to next block in same
  33.                                               handle }
  34.         prev : pointer;                     { pointer to previous block }
  35.         used : word;                        { 1 if used, 0 if not }
  36.         handle : pointer;                   { handle of the block }
  37.     end;
  38.  
  39.  
  40.  
  41. {****************************************************************************\
  42. *       struct emsHandle
  43. *       ----------------
  44. * Description:  One EMS handle consisting of four pages. Used internally by
  45. *               heap manager.
  46. \****************************************************************************}
  47.  
  48. type
  49.     emsHandle = Record
  50.         handle : word;                      { EMM handle number }
  51.         block : pointer;                    { pointer to first block }
  52.         next : pointer;                     { pointer to next handle }
  53.         prev : pointer;                     { pointer to previous handle }
  54.     end;
  55.  
  56.     PemsBlock = ^emsBlock;
  57.     PemsHandle = ^emsHandle;
  58.  
  59.     Pinteger = ^integer;
  60.     Ppointer = ^pointer;
  61.  
  62.  
  63.  
  64. {****************************************************************************\
  65. *
  66. * Function:     emsInit(emmOK : Pinteger) : integer;
  67. *
  68. * Description:  Initializes EMS heap. Must be called before other EMS heap
  69. *               manager functions.
  70. *
  71. * Input:        emmOK : Pinteger        pointer to variable containing EMM
  72. *                                       status
  73. *
  74. * Returns:      MIDAS error code.
  75. *               emmOK^ contains 1 if Expanded Memory Manager was found (EMS
  76. *               initialized succesfully) or 0 if not. Note that the lack
  77. *               of Expanded Memory Manager is _not_ an error.
  78. *
  79. \****************************************************************************}
  80.  
  81. function emsInit(emmOK : Pinteger) : integer;
  82.  
  83.  
  84.  
  85. {****************************************************************************\
  86. *
  87. * Function:     emsClose : integer;
  88. *
  89. * Description:  Uninitializes EMS heap freeing all allocated blocks. Must be
  90. *               called before program exits if emsInit() has been called.
  91. *
  92. * Returns:      MIDAS error code
  93. *
  94. \****************************************************************************}
  95.  
  96. function emsClose : integer;
  97.  
  98.  
  99.  
  100. {****************************************************************************\
  101. *
  102. * Function:     emsAlloc(bytes : word; emsb : Ppointer) : integer;
  103. *
  104. * Description:  Allocates an EMS memory block
  105. *
  106. * Input:        bytes : word            number of bytes to be allocated
  107. *               emsb : Ppointer         pointer to EMS Block pointer
  108. *
  109. * Returns:      MIDAS error code.
  110. *               EMS block pointer stored in ems^, NULL if failure
  111. *
  112. \****************************************************************************}
  113.  
  114. function emsAlloc(bytes : word; ems : Ppointer) : integer;
  115.  
  116.  
  117.  
  118. {****************************************************************************\
  119. *
  120. * Function:     emsFree(ems : pointer) : integer;
  121. *
  122. * Description:  Deallocates an EMS block allocated with emsAlloc
  123. *
  124. * Input:        ems : pointer           pointer to block to be deallocated
  125. *
  126. * Returns:      MIDAS error code
  127. *
  128. \****************************************************************************}
  129.  
  130. function emsFree(ems : pointer) : integer;
  131.  
  132.  
  133.  
  134. {****************************************************************************\
  135. *
  136. * Function:     int emsMap(emsBlock *ems, void **memPtr);
  137. *
  138. * Description:  Maps an EMS block to conventional memory.
  139. *
  140. * Input:        ems : pointer           pointer to block to be mapped
  141. *               memPtr : Ppointer       pointer to conventional memory ptr
  142. *
  143. * Returns:      MIDAS error code.
  144. *               Pointer to the conventional memory area where the block
  145. *               was mapped is stored in memPtr^, NULL if failure.
  146. *
  147. \****************************************************************************}
  148.  
  149. function emsMap(ems : pointer; memPtr : Ppointer) : integer;
  150.  
  151.  
  152.  
  153. {****************************************************************************\
  154. *
  155. * Function:     emsSave : integer;
  156. *
  157. * Description:  Saves the EMS status. To be used by TempoTimer. Can only be
  158. *               called once.
  159. *
  160. * Returns:      MIDAS error code
  161. *
  162. \****************************************************************************}
  163.  
  164. function emsSave : integer;
  165.  
  166.  
  167.  
  168. {****************************************************************************\
  169. *
  170. * Function:     emsRestore : integer;
  171. *
  172. * Description:  Restores EMS status saved with emsSave(). To be used by
  173. *               TempoTimer. Can only be called once.
  174. *
  175. * Returns:      MIDAS error code
  176. *
  177. \****************************************************************************}
  178.  
  179. function emsRestore : integer;
  180.  
  181.  
  182.  
  183.  
  184. {****************************************************************************\
  185. *
  186. * Function:     emsAllocPages(emsh : PemsHandle) : integer;
  187. *
  188. * Description:  Allocates 4 pages of EMS memory to a handle. Used internally
  189. *               by EMS heap manager.
  190. *
  191. * Returns:      MIDAS error code.
  192. *               Pointer to a emsHandle structure for the pages stored in
  193. *               emsh^, NULL if failure.
  194. *
  195. \****************************************************************************}
  196.  
  197. function emsAllocPages(emsh : PemsHandle) : integer;
  198.  
  199.  
  200.  
  201. {****************************************************************************\
  202. *
  203. * Function:     emsFreePages(handle : PemsHandle) : integer;
  204. *
  205. * Description:  Deallocates an EMS handle allocated by emsAllocPages(). Used
  206. *               internally by EMS heap manager.
  207. *
  208. * Input:        handle : PemsHandle     pointer to handle to be deallocated.
  209. *
  210. * Returns:      MIDAS error code
  211. *
  212. \****************************************************************************}
  213.  
  214. function emsFreePages(handle : PemsHandle) : integer;
  215.  
  216.  
  217.  
  218.  
  219. {****************************************************************************\
  220. *
  221. * Function:     emsSafe : integer;
  222. *
  223. * Description:  Sets the EMS safety flag on so that the EMS heap manager
  224. *               can optimize page mappings. Until emsStopSafe() is restored,
  225. *               no other routine than emsMap() must touch the EMS page
  226. *               mappings
  227. *
  228. * Returns:      MIDAS error code
  229. *
  230. \****************************************************************************}
  231.  
  232. function emsSafe : integer;
  233.  
  234.  
  235.  
  236. {****************************************************************************\
  237. *
  238. * Function:     emsStopSafe : integer;
  239. *
  240. * Description:  Sets the EMS safety flag off.
  241. *
  242. * Returns:      MIDAS error code
  243. *
  244. \****************************************************************************}
  245.  
  246. function emsStopSafe : integer;
  247.  
  248.  
  249.  
  250.  
  251. implementation
  252.  
  253. uses mMem, Errors;
  254.  
  255.  
  256. function emsInit(emmOK : Pinteger) : integer; external;
  257. function emsClose : integer; external;
  258. function emsAlloc(bytes : word; ems : Ppointer) : integer; external;
  259. function emsFree(ems : pointer) : integer; external;
  260. function emsMap(ems : pointer; memPtr : Ppointer) : integer; external;
  261. function emsSave : integer; external;
  262. function emsRestore : integer; external;
  263. function emsAllocPages(emsh : PemsHandle) : integer; external;
  264. function emsFreePages(handle : PemsHandle) : integer; external;
  265. function emsSafe : integer; external;
  266. function emsStopSafe : integer; external;
  267. {$L EMS.OBJ}
  268.  
  269.  
  270. END.
  271.