home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mitsch75.zip / scheme-7_5_17-src.zip / scheme-7.5.17 / src / microcode / ntutl / scheme31.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-01-02  |  6.7 KB  |  286 lines
  1. /* -*-C-*-
  2.  
  3. $Id: scheme31.c,v 1.10 1999/01/02 06:11:34 cph Exp $
  4.  
  5. Copyright (c) 1993-1999 Massachusetts Institute of Technology
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or (at
  10. your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful, but
  13. WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15. General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. /* MIT Scheme under Windows system utiltities DLL source.
  23.    Win32s (vs. true NT) version.
  24.  */
  25.  
  26. #define W32SUT_32
  27. #include "ntscmlib.h"
  28.  
  29. /* Utilities */
  30.  
  31. #ifdef CL386
  32.  
  33. unsigned short
  34. getCS (void)
  35. {
  36.   _asm    mov    ax,cs
  37. }
  38.  
  39. unsigned short
  40. getDS (void)
  41. {
  42.   _asm    mov    ax,ds
  43. }
  44.  
  45. unsigned short
  46. getSS (void)
  47. {
  48.   _asm    mov    ax,ss
  49. }
  50.  
  51. #else /* not CL386 */
  52. #ifdef __WATCOMC__
  53.  
  54. extern unsigned short getCS (void);
  55. #pragma aux getCS = "mov ax,cs" value [ax];
  56.  
  57. extern unsigned short getDS (void);
  58. #pragma aux getDS = "mov ax,ds" value [ax];
  59.  
  60. extern unsigned short getSS (void);
  61. #pragma aux getSS = "mov ax,ss" value [ax];
  62.  
  63. #endif /* __WATCOMC__ */
  64. #endif /* not CL386 */
  65.  
  66. static UT32PROC call_16_bit_code = NULL;
  67.  
  68. DWORD WINAPI
  69. called_from_16_bit_code (LPVOID buff, DWORD tag)
  70. {
  71.   return (0L);
  72. }
  73.  
  74. BOOL WINAPI
  75. ntw32lib_dllinit (HANDLE self, DWORD reason, LPVOID reserved)
  76. {
  77.   BOOL crt_result = TRUE;
  78.   static counter = 0;
  79.  
  80.   switch (reason)
  81.   {
  82.     case DLL_PROCESS_ATTACH:
  83.       if (counter++ == 0)
  84.     return ((UTRegister (self,
  85.                  NTW16LIB_DLL_NAME,
  86.                  "ntw16lib_init",
  87.                  "ntw16lib_handler",
  88.                  & call_16_bit_code,
  89.                  called_from_16_bit_code,
  90.                  NULL))
  91.         && crt_result
  92.         );
  93.       break;
  94.  
  95.     case DLL_THREAD_ATTACH:
  96.       break;    
  97.  
  98.     case DLL_THREAD_DETACH:
  99.       break;    
  100.  
  101.     case DLL_PROCESS_DETACH:
  102.       if (--counter == 0)
  103.     UTUnRegister (self);
  104.       break;
  105.  
  106.     default:
  107.       return (FALSE);
  108.   }
  109.   return (crt_result);
  110. }
  111.  
  112. static BOOL
  113. win32_under_win32s_p (void)
  114. {
  115.   return (TRUE);
  116. }
  117.  
  118. static char *
  119. win32_allocate_heap (unsigned long size, unsigned long * handle)
  120. {
  121.   LPVOID base;
  122.  
  123.   base = (VirtualAlloc (((LPVOID) NULL),
  124.             ((DWORD) size),
  125.             ((DWORD) (MEM_RESERVE | MEM_COMMIT)),
  126.             ((DWORD) PAGE_READWRITE)));
  127.   * handle = size;
  128.   return ((char *) base);
  129. }
  130.  
  131. static void
  132. win32_release_heap (char * area, unsigned long handle)
  133. {
  134.   VirtualFree (((LPVOID) area),
  135.            ((DWORD) handle),
  136.            ((DWORD) MEM_DECOMMIT));
  137.   VirtualFree (((LPVOID) area),
  138.            ((DWORD) 0),
  139.            ((DWORD) MEM_RELEASE));
  140.   return;
  141. }
  142.  
  143. static BOOL
  144. win32_lock_memory_area (LPVOID area, unsigned long size)
  145. {
  146.   struct ntw32lib_vlock_s param;
  147.   LPVOID translation[2];
  148.  
  149.   param.area = ((SCM_VDPTR) area);
  150.   param.size = ((SCM_ULONG) size);
  151.   translation[0] = ((LPVOID) & param.area);
  152.   translation[1] = ((LPVOID) NULL);
  153.  
  154.   return ((BOOL) ((* call_16_bit_code)
  155.           (¶m, NTW32LIB_VIRTUAL_LOCK, &translation[0])));
  156. }
  157.  
  158. static void
  159. win32_unlock_memory_area (LPVOID area, unsigned long size)
  160. {
  161.   struct ntw32lib_vulock_s param;
  162.   LPVOID translation[2];
  163.  
  164.   param.area = ((SCM_VDPTR) area);
  165.   param.size = ((SCM_ULONG) size);
  166.   translation[0] = ((LPVOID) & param.area);
  167.   translation[1] = ((LPVOID) NULL);
  168.  
  169.   (* call_16_bit_code) (¶m, NTW32LIB_VIRTUAL_UNLOCK, &translation[0]);
  170.   return;
  171. }
  172.  
  173. static UINT
  174. win32_install_async_timer (void ** state_ptr,
  175.                unsigned long * base,
  176.                long memtop_off,
  177.                long int_code_off,
  178.                long int_mask_off,
  179.                unsigned long bit_mask,
  180.                long ctr_off,
  181.                unsigned long ctr_message,
  182.                unsigned long interrupt_message,
  183.                HWND window,
  184.                void (*grab_int_regs) (void),
  185.                void (*release_int_regs) (void))
  186. {
  187.   struct ntw32lib_itimer_s param;
  188.   LPVOID translation[2];
  189.   UINT result;
  190.  
  191.   param.base = ((SCM_ULPTR) base);
  192.   param.memtop_off = ((SCM_LONG) memtop_off);
  193.   param.int_code_off = ((SCM_LONG) int_code_off);
  194.   param.int_mask_off = ((SCM_LONG) int_mask_off);
  195.   param.bit_mask = ((SCM_ULONG) bit_mask);
  196.   param.ctr_off = ((SCM_LONG) ctr_off);
  197.   param.ctr_message = ((SCM_ULONG) ctr_message);
  198.   param.interrupt_message = ((SCM_ULONG) interrupt_message);
  199.   param.window = ((SCM_ULONG) window);
  200.  
  201.   translation[0] = ((LPVOID) & param.base);
  202.   translation[1] = ((LPVOID) NULL);
  203.  
  204.   result = ((UINT) ((* call_16_bit_code)
  205.             (& param, NTW32LIB_INSTALL_TIMER, &translation[0])));
  206.   * state_ptr = ((void *) param.handle);
  207.   return (result);
  208. }
  209.  
  210. static void
  211. win32_flush_async_timer (void * timer_state)
  212. {
  213.   struct ntw32lib_ftimer_s param;
  214.   LPVOID translation[1];
  215.   
  216.   param.handle = ((SCM_ULONG) timer_state);
  217.   translation[0] = ((LPVOID) NULL);
  218.   (* call_16_bit_code) (& param, NTW32LIB_FLUSH_TIMER, &translation[0]);
  219.   return;
  220. }
  221.  
  222. #define I386_PAGE_SIZE 0x1000
  223.  
  224. static BOOL
  225. win32_alloc_scheme_selectors (unsigned long base,
  226.                   unsigned long size,
  227.                   unsigned short * scheme_cs,
  228.                   unsigned short * scheme_ds,
  229.                   unsigned short * scheme_ss)
  230. {
  231.   BOOL result;
  232.   struct ntw32lib_selalloc_s param;
  233.   LPVOID translation[1];
  234.  
  235.   param.base = base;
  236.   param.limit = ((size + (I386_PAGE_SIZE - 1)) & (~ (I386_PAGE_SIZE - 1)));
  237.   param.cs32 = (getCS ());
  238.   param.ds32 = (getDS ());
  239.   param.cs = 0;
  240.   param.ds = 0;
  241.   param.ss = 0;
  242.   translation[0] = ((LPVOID) NULL);
  243.   result = ((BOOL)
  244.         ((* call_16_bit_code) (& param, NTW32LIB_ALLOC_SELECTORS,
  245.                    &translation[0])));
  246.   * scheme_cs = param.cs;
  247.   * scheme_ds = param.ds;
  248.   * scheme_ss = param.ss;
  249.   return (result);
  250. }
  251.  
  252. static void
  253. win32_release_scheme_selectors (unsigned short scheme_cs,
  254.                 unsigned short scheme_ds,
  255.                 unsigned short scheme_ss)
  256. {
  257.   struct ntw32lib_selfree_s param;
  258.   LPVOID translation[1];
  259.  
  260.   param.cs32 = (getCS ());
  261.   param.ds32 = (getDS ());
  262.   param.cs = scheme_cs;
  263.   param.ds = scheme_ds;
  264.   param.ss = scheme_ss;
  265.   translation[0] = ((LPVOID) NULL);
  266.   (* call_16_bit_code) (& param, NTW32LIB_FREE_SELECTORS, &translation[0]);
  267.   return;
  268. }
  269.  
  270.  
  271.  
  272. void
  273. install_win32_system_utilities (WIN32_SYSTEM_UTILITIES *utils)
  274. {
  275. #define EXPORT(field) utils->field = win32_##field
  276.   EXPORT (under_win32s_p);
  277.   EXPORT (allocate_heap);
  278.   EXPORT (release_heap);
  279.   EXPORT (lock_memory_area);
  280.   EXPORT (unlock_memory_area);
  281.   EXPORT (install_async_timer);
  282.   EXPORT (flush_async_timer);
  283.   EXPORT (alloc_scheme_selectors);
  284.   EXPORT (release_scheme_selectors);
  285. }
  286.