1 /*
2 *******************************************************************************
3 *
4 * Copyright (C) 1999-2014, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 *******************************************************************************
8 * file name: toolutil.c
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 1999nov19
14 * created by: Markus W. Scherer
15 *
16 * 6/25/08 - Added Cygwin specific code in uprv_mkdir - Brian Rower
17 *
18 * This file contains utility functions for ICU tools like genccode.
19 */
20
21 #include "unicode/platform.h"
22 #if U_PLATFORM == U_PF_MINGW
23 // *cough* - for struct stat
24 #ifdef __STRICT_ANSI__
25 #undef __STRICT_ANSI__
26 #endif
27 #endif
28
29 #include <stdio.h>
30 #include <sys/stat.h>
31 #include "unicode/utypes.h"
32
33 #ifndef U_TOOLUTIL_IMPLEMENTATION
34 #error U_TOOLUTIL_IMPLEMENTATION not set - must be set for all ICU source files in common/ - see http://userguide.icu-project.org/howtouseicu
35 #endif
36
37 #if U_PLATFORM_USES_ONLY_WIN32_API
38 # define VC_EXTRALEAN
39 # define WIN32_LEAN_AND_MEAN
40 # define NOUSER
41 # define NOSERVICE
42 # define NOIME
43 # define NOMCX
44 # if U_PLATFORM == U_PF_MINGW
45 # define __NO_MINGW_LFS /* gets around missing 'off64_t' */
46 # endif
47 # include <windows.h>
48 # include <direct.h>
49 #else
50 # include <sys/stat.h>
51 # include <sys/types.h>
52 #endif
53
54 /* In MinGW environment, io.h needs to be included for _mkdir() */
55 #if U_PLATFORM == U_PF_MINGW
56 #include <io.h>
57 #endif
58
59 #include <errno.h>
60
61 #include "unicode/errorcode.h"
62 #include "unicode/putil.h"
63 #include "cmemory.h"
64 #include "cstring.h"
65 #include "toolutil.h"
66 #include "unicode/ucal.h"
67
68 U_NAMESPACE_BEGIN
69
~IcuToolErrorCode()70 IcuToolErrorCode::~IcuToolErrorCode() {
71 // Safe because our handleFailure() does not throw exceptions.
72 if(isFailure()) { handleFailure(); }
73 }
74
handleFailure() const75 void IcuToolErrorCode::handleFailure() const {
76 fprintf(stderr, "error at %s: %s\n", location, errorName());
77 exit(errorCode);
78 }
79
80 U_NAMESPACE_END
81
82 static int32_t currentYear = -1;
83
getCurrentYear()84 U_CAPI int32_t U_EXPORT2 getCurrentYear() {
85 #if !UCONFIG_NO_FORMATTING
86 UErrorCode status=U_ZERO_ERROR;
87 UCalendar *cal = NULL;
88
89 if(currentYear == -1) {
90 cal = ucal_open(NULL, -1, NULL, UCAL_TRADITIONAL, &status);
91 ucal_setMillis(cal, ucal_getNow(), &status);
92 currentYear = ucal_get(cal, UCAL_YEAR, &status);
93 ucal_close(cal);
94 }
95 #else
96 /* No formatting- no way to set the current year. */
97 #endif
98 return currentYear;
99 }
100
101
102 U_CAPI const char * U_EXPORT2
getLongPathname(const char * pathname)103 getLongPathname(const char *pathname) {
104 #if U_PLATFORM_USES_ONLY_WIN32_API
105 /* anticipate problems with "short" pathnames */
106 static WIN32_FIND_DATAA info;
107 HANDLE file=FindFirstFileA(pathname, &info);
108 if(file!=INVALID_HANDLE_VALUE) {
109 if(info.cAlternateFileName[0]!=0) {
110 /* this file has a short name, get and use the long one */
111 const char *basename=findBasename(pathname);
112 if(basename!=pathname) {
113 /* prepend the long filename with the original path */
114 uprv_memmove(info.cFileName+(basename-pathname), info.cFileName, uprv_strlen(info.cFileName)+1);
115 uprv_memcpy(info.cFileName, pathname, basename-pathname);
116 }
117 pathname=info.cFileName;
118 }
119 FindClose(file);
120 }
121 #endif
122 return pathname;
123 }
124
125 U_CAPI const char * U_EXPORT2
findDirname(const char * path,char * buffer,int32_t bufLen,UErrorCode * status)126 findDirname(const char *path, char *buffer, int32_t bufLen, UErrorCode* status) {
127 if(U_FAILURE(*status)) return NULL;
128 const char *resultPtr = NULL;
129 int32_t resultLen = 0;
130
131 const char *basename=uprv_strrchr(path, U_FILE_SEP_CHAR);
132 #if U_FILE_ALT_SEP_CHAR!=U_FILE_SEP_CHAR
133 const char *basenameAlt=uprv_strrchr(path, U_FILE_ALT_SEP_CHAR);
134 if(basenameAlt && (!basename || basename<basenameAlt)) {
135 basename = basenameAlt;
136 }
137 #endif
138 if(!basename) {
139 /* no basename - return ''. */
140 resultPtr = "";
141 resultLen = 0;
142 } else {
143 resultPtr = path;
144 resultLen = basename - path;
145 if(resultLen<1) {
146 resultLen = 1; /* '/' or '/a' -> '/' */
147 }
148 }
149
150 if((resultLen+1) <= bufLen) {
151 uprv_strncpy(buffer, resultPtr, resultLen);
152 buffer[resultLen]=0;
153 return buffer;
154 } else {
155 *status = U_BUFFER_OVERFLOW_ERROR;
156 return NULL;
157 }
158 }
159
160 U_CAPI const char * U_EXPORT2
findBasename(const char * filename)161 findBasename(const char *filename) {
162 const char *basename=uprv_strrchr(filename, U_FILE_SEP_CHAR);
163
164 #if U_FILE_ALT_SEP_CHAR!=U_FILE_SEP_CHAR
165 #if !(U_PLATFORM == U_PF_CYGWIN && U_PLATFORM_USES_ONLY_WIN32_API)
166 if(basename==NULL)
167 #endif
168 {
169 /* Use lenient matching on Windows, which can accept either \ or /
170 This is useful for environments like Win32+CygWin which have both.
171 */
172 basename=uprv_strrchr(filename, U_FILE_ALT_SEP_CHAR);
173 }
174 #endif
175
176 if(basename!=NULL) {
177 return basename+1;
178 } else {
179 return filename;
180 }
181 }
182
183 U_CAPI void U_EXPORT2
uprv_mkdir(const char * pathname,UErrorCode * status)184 uprv_mkdir(const char *pathname, UErrorCode *status) {
185
186 int retVal = 0;
187 #if U_PLATFORM_USES_ONLY_WIN32_API
188 retVal = _mkdir(pathname);
189 #else
190 retVal = mkdir(pathname, S_IRWXU | (S_IROTH | S_IXOTH) | (S_IROTH | S_IXOTH));
191 #endif
192 if (retVal && errno != EEXIST) {
193 #if U_PF_MINGW <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
194 /*if using Cygwin and the mkdir says it failed...check if the directory already exists..*/
195 /* if it does...don't give the error, if it does not...give the error - Brian Rower - 6/25/08 */
196 struct stat st;
197
198 if(stat(pathname,&st) != 0)
199 {
200 *status = U_FILE_ACCESS_ERROR;
201 }
202 #else
203 *status = U_FILE_ACCESS_ERROR;
204 #endif
205 }
206 }
207
208 #if !UCONFIG_NO_FILE_IO
209 U_CAPI UBool U_EXPORT2
uprv_fileExists(const char * file)210 uprv_fileExists(const char *file) {
211 struct stat stat_buf;
212 if (stat(file, &stat_buf) == 0) {
213 return TRUE;
214 } else {
215 return FALSE;
216 }
217 }
218 #endif
219
220 /*U_CAPI UDate U_EXPORT2
221 uprv_getModificationDate(const char *pathname, UErrorCode *status)
222 {
223 if(U_FAILURE(*status)) {
224 return;
225 }
226 // TODO: handle case where stat is not available
227 struct stat st;
228
229 if(stat(pathname,&st) != 0)
230 {
231 *status = U_FILE_ACCESS_ERROR;
232 } else {
233 return st.st_mtime;
234 }
235 }
236 */
237
238 /* tool memory helper ------------------------------------------------------- */
239
240 struct UToolMemory {
241 char name[64];
242 int32_t capacity, maxCapacity, size, idx;
243 void *array;
244 UAlignedMemory staticArray[1];
245 };
246
247 U_CAPI UToolMemory * U_EXPORT2
utm_open(const char * name,int32_t initialCapacity,int32_t maxCapacity,int32_t size)248 utm_open(const char *name, int32_t initialCapacity, int32_t maxCapacity, int32_t size) {
249 UToolMemory *mem;
250
251 if(maxCapacity<initialCapacity) {
252 maxCapacity=initialCapacity;
253 }
254
255 mem=(UToolMemory *)uprv_malloc(sizeof(UToolMemory)+initialCapacity*size);
256 if(mem==NULL) {
257 fprintf(stderr, "error: %s - out of memory\n", name);
258 exit(U_MEMORY_ALLOCATION_ERROR);
259 }
260 mem->array=mem->staticArray;
261
262 uprv_strcpy(mem->name, name);
263 mem->capacity=initialCapacity;
264 mem->maxCapacity=maxCapacity;
265 mem->size=size;
266 mem->idx=0;
267 return mem;
268 }
269
270 U_CAPI void U_EXPORT2
utm_close(UToolMemory * mem)271 utm_close(UToolMemory *mem) {
272 if(mem!=NULL) {
273 if(mem->array!=mem->staticArray) {
274 uprv_free(mem->array);
275 }
276 uprv_free(mem);
277 }
278 }
279
280
281 U_CAPI void * U_EXPORT2
utm_getStart(UToolMemory * mem)282 utm_getStart(UToolMemory *mem) {
283 return (char *)mem->array;
284 }
285
286 U_CAPI int32_t U_EXPORT2
utm_countItems(UToolMemory * mem)287 utm_countItems(UToolMemory *mem) {
288 return mem->idx;
289 }
290
291
292 static UBool
utm_hasCapacity(UToolMemory * mem,int32_t capacity)293 utm_hasCapacity(UToolMemory *mem, int32_t capacity) {
294 if(mem->capacity<capacity) {
295 int32_t newCapacity;
296
297 if(mem->maxCapacity<capacity) {
298 fprintf(stderr, "error: %s - trying to use more than maxCapacity=%ld units\n",
299 mem->name, (long)mem->maxCapacity);
300 exit(U_MEMORY_ALLOCATION_ERROR);
301 }
302
303 /* try to allocate a larger array */
304 if(capacity>=2*mem->capacity) {
305 newCapacity=capacity;
306 } else if(mem->capacity<=mem->maxCapacity/3) {
307 newCapacity=2*mem->capacity;
308 } else {
309 newCapacity=mem->maxCapacity;
310 }
311
312 if(mem->array==mem->staticArray) {
313 mem->array=uprv_malloc(newCapacity*mem->size);
314 if(mem->array!=NULL) {
315 uprv_memcpy(mem->array, mem->staticArray, mem->idx*mem->size);
316 }
317 } else {
318 mem->array=uprv_realloc(mem->array, newCapacity*mem->size);
319 }
320
321 if(mem->array==NULL) {
322 fprintf(stderr, "error: %s - out of memory\n", mem->name);
323 exit(U_MEMORY_ALLOCATION_ERROR);
324 }
325 mem->capacity=newCapacity;
326 }
327
328 return TRUE;
329 }
330
331 U_CAPI void * U_EXPORT2
utm_alloc(UToolMemory * mem)332 utm_alloc(UToolMemory *mem) {
333 char *p=NULL;
334 int32_t oldIndex=mem->idx;
335 int32_t newIndex=oldIndex+1;
336 if(utm_hasCapacity(mem, newIndex)) {
337 p=(char *)mem->array+oldIndex*mem->size;
338 mem->idx=newIndex;
339 uprv_memset(p, 0, mem->size);
340 }
341 return p;
342 }
343
344 U_CAPI void * U_EXPORT2
utm_allocN(UToolMemory * mem,int32_t n)345 utm_allocN(UToolMemory *mem, int32_t n) {
346 char *p=NULL;
347 int32_t oldIndex=mem->idx;
348 int32_t newIndex=oldIndex+n;
349 if(utm_hasCapacity(mem, newIndex)) {
350 p=(char *)mem->array+oldIndex*mem->size;
351 mem->idx=newIndex;
352 uprv_memset(p, 0, n*mem->size);
353 }
354 return p;
355 }
356