MagickCore  6.9.13-8
Convert, Edit, Or Compose Bitmap Images
utility-private.h
1 /*
2  Copyright 1999 ImageMagick Studio LLC, a non-profit organization
3  dedicated to making software imaging solutions freely available.
4 
5  You may not use this file except in compliance with the License. You may
6  obtain a copy of the License at
7 
8  https://imagemagick.org/script/license.php
9 
10  Unless required by applicable law or agreed to in writing, software
11  distributed under the License is distributed on an "AS IS" BASIS,
12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  See the License for the specific language governing permissions and
14  limitations under the License.
15 
16  MagickCore private utility methods.
17 */
18 #ifndef MAGICKCORE_UTILITY_PRIVATE_H
19 #define MAGICKCORE_UTILITY_PRIVATE_H
20 
21 #include "magick/memory_.h"
22 #include "magick/nt-base.h"
23 #include "magick/nt-base-private.h"
24 
25 #if defined(__cplusplus) || defined(c_plusplus)
26 extern "C" {
27 #endif
28 
29 extern MagickPrivate MagickBooleanType
30  ShredFile(const char *);
31 
32 static inline int MagickReadDirectory(DIR *directory,struct dirent *entry,
33  struct dirent **result)
34 {
35  (void) entry;
36  errno=0;
37  *result=readdir(directory);
38  return(errno);
39 }
40 
41 /*
42  Windows UTF8 compatibility methods.
43 */
44 
45 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
46 static inline wchar_t *create_wchar_path(const char *utf8)
47 {
48  int
49  count;
50 
51  wchar_t
52  *wideChar;
53 
54  count=MultiByteToWideChar(CP_UTF8,0,utf8,-1,NULL,0);
55  if ((count > MAX_PATH) && (NTLongPathsEnabled() == MagickFalse))
56  {
57  char
58  buffer[MaxTextExtent];
59 
60  wchar_t
61  shortPath[MAX_PATH],
62  *longPath;
63 
64  (void) FormatLocaleString(buffer,MaxTextExtent,"\\\\?\\%s",utf8);
65  count+=4;
66  longPath=(wchar_t *) NTAcquireQuantumMemory((size_t) count,
67  sizeof(*longPath));
68  if (longPath == (wchar_t *) NULL)
69  return((wchar_t *) NULL);
70  count=MultiByteToWideChar(CP_UTF8,0,buffer,-1,longPath,count);
71  if (count != 0)
72  count=(int) GetShortPathNameW(longPath,shortPath,MAX_PATH);
73  longPath=(wchar_t *) RelinquishMagickMemory(longPath);
74  if ((count < 5) || (count >= MAX_PATH))
75  return((wchar_t *) NULL);
76  wideChar=(wchar_t *) NTAcquireQuantumMemory((size_t) count-3,
77  sizeof(*wideChar));
78  wcscpy(wideChar,shortPath+4);
79  return(wideChar);
80  }
81  wideChar=(wchar_t *) NTAcquireQuantumMemory(count,sizeof(*wideChar));
82  if (wideChar == (wchar_t *) NULL)
83  return((wchar_t *) NULL);
84  count=MultiByteToWideChar(CP_UTF8,0,utf8,-1,wideChar,count);
85  if (count == 0)
86  {
87  wideChar=(wchar_t *) RelinquishMagickMemory(wideChar);
88  return((wchar_t *) NULL);
89  }
90  return(wideChar);
91 }
92 #endif
93 
94 static inline int access_utf8(const char *path,int mode)
95 {
96  if (path == (const char *) NULL)
97  return(-1);
98 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
99  return(access(path,mode));
100 #else
101  int
102  status;
103 
104  wchar_t
105  *path_wide;
106 
107  path_wide=create_wchar_path(path);
108  if (path_wide == (wchar_t *) NULL)
109  return(-1);
110  status=_waccess(path_wide,mode);
111  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
112  return(status);
113 #endif
114 }
115 
116 static inline FILE *fopen_utf8(const char *path,const char *mode)
117 {
118 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
119  return(fopen(path,mode));
120 #else
121  FILE
122  *file;
123 
124  wchar_t
125  *mode_wide,
126  *path_wide;
127 
128  path_wide=create_wchar_path(path);
129  if (path_wide == (wchar_t *) NULL)
130  return((FILE *) NULL);
131  mode_wide=create_wchar_path(mode);
132  if (mode_wide == (wchar_t *) NULL)
133  {
134  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
135  return((FILE *) NULL);
136  }
137  file=_wfopen(path_wide,mode_wide);
138  mode_wide=(wchar_t *) RelinquishMagickMemory(mode_wide);
139  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
140  return(file);
141 #endif
142 }
143 
144 static inline void getcwd_utf8(char *path,size_t extent)
145 {
146 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
147  char
148  *directory;
149 
150  directory=getcwd(path,extent);
151  (void) directory;
152 #else
153  wchar_t
154  wide_path[MaxTextExtent];
155 
156  (void) _wgetcwd(wide_path,MaxTextExtent-1);
157  (void) WideCharToMultiByte(CP_UTF8,0,wide_path,-1,path,(int) extent,NULL,NULL);
158 #endif
159 }
160 
161 #if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__CYGWIN__) && !defined(__MINGW32__)
162 typedef int
163  mode_t;
164 #endif
165 
166 static inline int open_utf8(const char *path,int flags,mode_t mode)
167 {
168 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
169  return(open(path,flags,mode));
170 #else
171  int
172  status;
173 
174  wchar_t
175  *path_wide;
176 
177  path_wide=create_wchar_path(path);
178  if (path_wide == (wchar_t *) NULL)
179  return(-1);
180  status=_wopen(path_wide,flags,mode);
181  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
182  return(status);
183 #endif
184 }
185 
186 static inline FILE *popen_utf8(const char *command,const char *type)
187 {
188 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
189  return(popen(command,type));
190 #else
191  FILE
192  *file;
193 
194  int
195  length;
196 
197  wchar_t
198  *command_wide,
199  type_wide[5];
200 
201  file=(FILE *) NULL;
202  length=MultiByteToWideChar(CP_UTF8,0,type,-1,type_wide,5);
203  if (length == 0)
204  return(file);
205  length=MultiByteToWideChar(CP_UTF8,0,command,-1,NULL,0);
206  if (length == 0)
207  return(file);
208  command_wide=(wchar_t *) AcquireQuantumMemory((size_t) length,
209  sizeof(*command_wide));
210  if (command_wide == (wchar_t *) NULL)
211  return(file);
212  length=MultiByteToWideChar(CP_UTF8,0,command,-1,command_wide,length);
213  if (length != 0)
214  file=_wpopen(command_wide,type_wide);
215  command_wide=(wchar_t *) RelinquishMagickMemory(command_wide);
216  return(file);
217 #endif
218 }
219 
220 static inline int remove_utf8(const char *path)
221 {
222 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
223  return(unlink(path));
224 #else
225  int
226  status;
227 
228  wchar_t
229  *path_wide;
230 
231  path_wide=create_wchar_path(path);
232  if (path_wide == (wchar_t *) NULL)
233  return(-1);
234  status=_wremove(path_wide);
235  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
236  return(status);
237 #endif
238 }
239 
240 static inline int rename_utf8(const char *source,const char *destination)
241 {
242 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
243  return(rename(source,destination));
244 #else
245  int
246  status;
247 
248  wchar_t
249  *destination_wide,
250  *source_wide;
251 
252  source_wide=create_wchar_path(source);
253  if (source_wide == (wchar_t *) NULL)
254  return(-1);
255  destination_wide=create_wchar_path(destination);
256  if (destination_wide == (wchar_t *) NULL)
257  {
258  source_wide=(wchar_t *) RelinquishMagickMemory(source_wide);
259  return(-1);
260  }
261  status=_wrename(source_wide,destination_wide);
262  destination_wide=(wchar_t *) RelinquishMagickMemory(destination_wide);
263  source_wide=(wchar_t *) RelinquishMagickMemory(source_wide);
264  return(status);
265 #endif
266 }
267 
268 static inline int stat_utf8(const char *path,struct stat *attributes)
269 {
270 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
271  return(stat(path,attributes));
272 #else
273  int
274  status;
275 
276  wchar_t
277  *path_wide;
278 
279  path_wide=create_wchar_path(path);
280  if (path_wide == (WCHAR *) NULL)
281  return(-1);
282  status=wstat(path_wide,attributes);
283  path_wide=(WCHAR *) RelinquishMagickMemory(path_wide);
284  return(status);
285 #endif
286 }
287 
288 #if defined(__cplusplus) || defined(c_plusplus)
289 }
290 #endif
291 
292 #endif
Definition: mac.h:53
Definition: mac.h:41