git.oblomov.eu Git - wine/blob - include/local.h

   1 /*
   2  * Local heap declarations
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #ifndef __WINE_LOCAL_H
  22 #define __WINE_LOCAL_H
  23
  24 #include <windef.h>
  25 #include <wine/windef16.h>
  26 #include <wine/winbase16.h>
  27 #include <winreg.h>
  28 #include <winternl.h>
  29
  30 #define CURRENT_DS (((STACK16FRAME*)MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved))->ds)
  31
  32   /* These function are equivalent to the Local* API functions, */
  33   /* excepted that they need DS as the first parameter. This    */
  34   /* allows managing several heaps from the emulation library.  */
  35 static inline HLOCAL16 LOCAL_Alloc( HANDLE16 ds, UINT16 flags, WORD size )
  36 {
  37     HANDLE16 oldDS = CURRENT_DS;
  38     HLOCAL16 ret;
  39
  40     CURRENT_DS = ds;
  41     ret = LocalAlloc16 (flags, size);
  42     CURRENT_DS = oldDS;
  43     return ret;
  44 }
  45
  46 static inline  HLOCAL16 LOCAL_ReAlloc( HANDLE16 ds, HLOCAL16 handle, WORD size, UINT16 flags )
  47 {
  48     HANDLE16 oldDS = CURRENT_DS;
  49     HLOCAL16 ret;
  50
  51     CURRENT_DS = ds;
  52     ret = LocalReAlloc16 (handle, size, flags);
  53     CURRENT_DS = oldDS;
  54     return ret;
  55 }
  56
  57 static inline HLOCAL16 LOCAL_Free( HANDLE16 ds, HLOCAL16 handle )
  58 {
  59     HANDLE16 oldDS = CURRENT_DS;
  60     HLOCAL16 ret;
  61
  62     CURRENT_DS = ds;
  63     ret = LocalFree16 (handle);
  64     CURRENT_DS = oldDS;
  65     return ret;
  66 }
  67 static inline HLOCAL16 LOCAL_Handle( HANDLE16 ds, WORD addr )
  68 {
  69     HANDLE16 oldDS = CURRENT_DS;
  70     HLOCAL16 ret;
  71
  72     CURRENT_DS = ds;
  73     ret = LocalHandle16 (addr);
  74     CURRENT_DS = oldDS;
  75     return ret;
  76 }
  77
  78 static inline UINT16 LOCAL_Size( HANDLE16 ds, HLOCAL16 handle )
  79 {
  80     HANDLE16 oldDS = CURRENT_DS;
  81     UINT16 ret;
  82
  83     CURRENT_DS = ds;
  84     ret = LocalSize16 (handle);
  85     CURRENT_DS = oldDS;
  86     return ret;
  87 }
  88
  89 static inline UINT16 LOCAL_Flags( HANDLE16 ds, HLOCAL16 handle )
  90 {
  91     HANDLE16 oldDS = CURRENT_DS;
  92     UINT16 ret;
  93
  94     CURRENT_DS = ds;
  95     ret = LocalFlags16 (handle);
  96     CURRENT_DS = oldDS;
  97     return ret;
  98 }
  99
 100
 101 static inline UINT16 LOCAL_HeapSize( HANDLE16 ds )
 102 {
 103     HANDLE16 oldDS = CURRENT_DS;
 104     UINT16 ret;
 105
 106     CURRENT_DS = ds;
 107     ret = LocalHeapSize16 ();
 108     CURRENT_DS = oldDS;
 109     return ret;
 110 }
 111
 112 static inline UINT16 LOCAL_CountFree( HANDLE16 ds )
 113 {
 114     HANDLE16 oldDS = CURRENT_DS;
 115     UINT16 ret;
 116
 117     CURRENT_DS = ds;
 118     ret = LocalCountFree16 ();
 119     CURRENT_DS = oldDS;
 120     return ret;
 121 }
 122
 123 static inline void *LOCAL_Lock( HANDLE16 ds, HLOCAL16 handle )
 124 {
 125     HANDLE16 oldDS = CURRENT_DS;
 126     SEGPTR ret;
 127
 128     CURRENT_DS = ds;
 129     ret = LocalLock16 (handle);
 130     CURRENT_DS = oldDS;
 131
 132     return MapSL(ret);
 133 }
 134
 135 static inline BOOL16 LOCAL_Unlock( HANDLE16 ds, HLOCAL16 handle )
 136 {
 137     HANDLE16 oldDS = CURRENT_DS;
 138     BOOL16 ret;
 139
 140     CURRENT_DS = ds;
 141     ret = LocalUnlock16 (handle);
 142     CURRENT_DS = oldDS;
 143     return ret;
 144 }
 145
 146 static inline WORD LOCAL_Compact( HANDLE16 ds, UINT16 minfree )
 147 {
 148     HANDLE16 oldDS = CURRENT_DS;
 149     WORD ret;
 150
 151     CURRENT_DS = ds;
 152     ret = LocalCompact16 (minfree);
 153     CURRENT_DS = oldDS;
 154     return ret;
 155 }
 156
 157
 158 #endif  /* __WINE_LOCAL_H */