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