← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/ghostscript/oneiric

« back to all changes in this revision

Viewing changes to base/gp_os2fs.c

  • Committer: Bazaar Package Importer
  • Author(s): Till Kamppeter
  • Date: 2011-07-15 16:49:55 UTC
  • mfrom: (1.1.23 upstream)
  • Revision ID: james.westby@ubuntu.com-20110715164955-uga6qibao6kez05c
Tags: 9.04~dfsg~20110715-0ubuntu1
* New upstream release
   - GIT snapshot from Jult, 12 2011.
* debian/patches/020110406~a54df2d.patch,
  debian/patches/020110408~0791cc8.patch,
  debian/patches/020110408~507cbee.patch,
  debian/patches/020110411~4509a49.patch,
  debian/patches/020110412~78bb9a6.patch,
  debian/patches/020110418~a05ab8a.patch,
  debian/patches/020110420~20b6c78.patch,
  debian/patches/020110420~4ddefa2.patch: Removed upstream patches.
* debian/rules: Generate ABI version number (variable "abi") correctly,
  cutting off repackaging and pre-release parts.
* debian/rules: Added ./lcms2/ directory to DEB_UPSTREAM_REPACKAGE_EXCLUDES.
* debian/copyright: Added lcms2/* to the list of excluded files.
* debian/symbols.common: Updated for new upstream source. Applied patch
  which dpkg-gensymbols generated for debian/libgs9.symbols to this file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
base/gp_os2fs.c
1
1
/* Copyright (C) 2001-2008 Artifex Software, Inc.
2
2
   All Rights Reserved.
3
 
  
 
3
 
4
4
   This software is provided AS-IS with no warranty, either express or
5
5
   implied.
6
6
 
70
70
 
71
71
/* ------ File enumeration ------ */
72
72
 
73
 
 
74
73
struct file_enum_s {
75
74
    FILEFINDBUF3 findbuf;
76
75
    HDIR hdir;
83
82
    gs_memory_t *memory;
84
83
};
85
84
gs_private_st_ptrs1(st_file_enum, struct file_enum_s, "file_enum",
86
 
                    file_enum_enum_ptrs, file_enum_reloc_ptrs, pattern);
 
85
                    file_enum_enum_ptrs, file_enum_reloc_ptrs, pattern);
87
86
 
88
87
/* Initialize an enumeration.  may NEED WORK ON HANDLING * ? \. */
89
88
file_enum *
96
95
    int i;
97
96
 
98
97
    if (pfen == 0)
99
 
        return 0;
 
98
        return 0;
100
99
 
101
100
    /* pattern could be allocated as a string, */
102
101
    /* but it's simpler for GC and freeing to allocate it as bytes. */
103
102
 
104
103
    pattern = (char *)gs_alloc_bytes(mem, pat_size,
105
 
                                     "gp_enumerate_files(pattern)");
 
104
                                     "gp_enumerate_files(pattern)");
106
105
    if (pattern == 0)
107
 
        return 0;
 
106
        return 0;
108
107
    memcpy(pattern, pat, patlen);
109
108
    /* find directory name = header */
110
109
    for (i = 0; i < patlen; i++) {
111
 
        switch (pat[i]) {
112
 
            case '\\':
113
 
                if (i + 1 < patlen && pat[i + 1] == '\\')
114
 
                    i++;
115
 
                /* falls through */
116
 
            case ':':
117
 
            case '/':
118
 
                hsize = i + 1;
119
 
        }
 
110
        switch (pat[i]) {
 
111
            case '\\':
 
112
                if (i + 1 < patlen && pat[i + 1] == '\\')
 
113
                    i++;
 
114
                /* falls through */
 
115
            case ':':
 
116
            case '/':
 
117
                hsize = i + 1;
 
118
        }
120
119
    }
121
120
    pattern[patlen] = 0;
122
121
    pfen->pattern = pattern;
137
136
    ULONG cFilenames = 1;
138
137
 
139
138
    if (!isos2) {
140
 
        /* CAN'T DO IT SO JUST RETURN THE PATTERN. */
141
 
        if (pfen->first_time) {
142
 
            char *pattern = pfen->pattern;
143
 
            uint len = strlen(pattern);
 
139
        /* CAN'T DO IT SO JUST RETURN THE PATTERN. */
 
140
        if (pfen->first_time) {
 
141
            char *pattern = pfen->pattern;
 
142
            uint len = strlen(pattern);
144
143
 
145
 
            pfen->first_time = 0;
146
 
            if (len > maxlen)
147
 
                return maxlen + 1;
148
 
            strcpy(ptr, pattern);
149
 
            return len;
150
 
        }
151
 
        return -1;
 
144
            pfen->first_time = 0;
 
145
            if (len > maxlen)
 
146
                return maxlen + 1;
 
147
            strcpy(ptr, pattern);
 
148
            return len;
 
149
        }
 
150
        return -1;
152
151
    }
153
152
    /* else OS/2 */
154
153
    if (pfen->first_time) {
155
 
        rc = DosFindFirst(pfen->pattern, &pfen->hdir, FILE_NORMAL,
156
 
                          &pfen->findbuf, sizeof(pfen->findbuf),
157
 
                          &cFilenames, FIL_STANDARD);
158
 
        pfen->first_time = 0;
 
154
        rc = DosFindFirst(pfen->pattern, &pfen->hdir, FILE_NORMAL,
 
155
                          &pfen->findbuf, sizeof(pfen->findbuf),
 
156
                          &cFilenames, FIL_STANDARD);
 
157
        pfen->first_time = 0;
159
158
    } else {
160
 
        rc = DosFindNext(pfen->hdir, &pfen->findbuf, sizeof(pfen->findbuf),
161
 
                         &cFilenames);
 
159
        rc = DosFindNext(pfen->hdir, &pfen->findbuf, sizeof(pfen->findbuf),
 
160
                         &cFilenames);
162
161
    }
163
162
    if (rc)
164
 
        return -1;
 
163
        return -1;
165
164
 
166
165
    if (pfen->head_size + pfen->findbuf.cchName < maxlen) {
167
 
        memcpy(ptr, pfen->pattern, pfen->head_size);
168
 
        strcpy(ptr + pfen->head_size, pfen->findbuf.achName);
169
 
        return pfen->head_size + pfen->findbuf.cchName;
 
166
        memcpy(ptr, pfen->pattern, pfen->head_size);
 
167
        strcpy(ptr + pfen->head_size, pfen->findbuf.achName);
 
168
        return pfen->head_size + pfen->findbuf.cchName;
170
169
    }
171
170
    if (pfen->head_size >= maxlen)
172
 
        return 0;               /* no hope at all */
 
171
        return 0;               /* no hope at all */
173
172
 
174
173
    memcpy(ptr, pfen->pattern, pfen->head_size);
175
174
    strncpy(ptr + pfen->head_size, pfen->findbuf.achName,
176
 
            maxlen - pfen->head_size - 1);
 
175
            maxlen - pfen->head_size - 1);
177
176
    return maxlen;
178
177
}
179
178
 
184
183
    gs_memory_t *mem = pfen->memory;
185
184
 
186
185
    if (isos2)
187
 
        DosFindClose(pfen->hdir);
 
186
        DosFindClose(pfen->hdir);
188
187
    gs_free_object(mem, pfen->pattern,
189
 
                   "gp_enumerate_files_close(pattern)");
 
188
                   "gp_enumerate_files_close(pattern)");
190
189
    gs_free_object(mem, pfen, "gp_enumerate_files_close");
191
190
}
192
191
 
193
 
 
194
192
/* ------ File naming and accessing ------ */
195
193
 
196
194
/* Create and open a scratch file with a given name prefix. */
199
197
gp_open_scratch_file(const gs_memory_t *mem,
200
198
                     const char        *prefix,
201
199
                           char         fname[gp_file_name_sizeof],
202
 
                     const char        *mode)
 
200
                     const char        *mode)
203
201
{
204
202
    FILE *f;
205
203
#ifdef __IBMC__
208
206
    int prefix_length = strlen(prefix);
209
207
 
210
208
    if (!gp_file_name_is_absolute(prefix, prefix_length)) {
211
 
        temp = getenv("TMPDIR");
212
 
        if (temp == 0)
213
 
            temp = getenv("TEMP");
 
209
        temp = getenv("TMPDIR");
 
210
        if (temp == 0)
 
211
            temp = getenv("TEMP");
214
212
    }
215
213
    *fname = 0;
216
214
    tname = _tempnam(temp, (char *)prefix);
217
215
    if (tname) {
218
 
        if (strlen(tname) > gp_file_name_sizeof - 1) {
219
 
            free(tname);
220
 
            return 0;           /* file name too long */
221
 
        }
222
 
        strcpy(fname, tname);
223
 
        free(tname);
 
216
        if (strlen(tname) > gp_file_name_sizeof - 1) {
 
217
            free(tname);
 
218
            return 0;           /* file name too long */
 
219
        }
 
220
        strcpy(fname, tname);
 
221
        free(tname);
224
222
    }
225
223
#else
226
224
    /* The -7 is for XXXXXX plus a possible final \. */
228
226
    int len = gp_file_name_sizeof - prefix_length - 7;
229
227
 
230
228
    if (gp_file_name_is_absolute(prefix, prefix_length) ||
231
 
        gp_gettmpdir(fname, &len) != 0)
232
 
        *fname = 0;
 
229
        gp_gettmpdir(fname, &len) != 0)
 
230
        *fname = 0;
233
231
    else {
234
 
        char last = '\\';
235
 
        char *temp;
 
232
        char last = '\\';
 
233
        char *temp;
236
234
 
237
 
        /* Prevent X's in path from being converted by mktemp. */
238
 
        for (temp = fname; *temp; temp++)
239
 
            *temp = last = tolower(*temp);
240
 
        switch (last) {
241
 
        default:
242
 
            strcat(fname, "\\");
243
 
        case ':':
244
 
        case '\\':
245
 
            ;
246
 
        }
 
235
        /* Prevent X's in path from being converted by mktemp. */
 
236
        for (temp = fname; *temp; temp++)
 
237
            *temp = last = tolower(*temp);
 
238
        switch (last) {
 
239
        default:
 
240
            strcat(fname, "\\");
 
241
        case ':':
 
242
        case '\\':
 
243
            ;
 
244
        }
247
245
    }
248
246
    if (strlen(fname) + prefix_length + 7 >= gp_file_name_sizeof)
249
 
        return 0;               /* file name too long */
 
247
        return 0;               /* file name too long */
250
248
    strcat(fname, prefix);
251
249
    strcat(fname, "XXXXXX");
252
250
    mktemp(fname);
266
264
 
267
265
uint gp_file_name_root(const char *fname, uint len)
268
266
{   int i = 0;
269
 
    
 
267
 
270
268
    if (len == 0)
271
 
        return 0;
 
269
        return 0;
272
270
    if (len > 1 && fname[0] == '\\' && fname[1] == '\\') {
273
 
        /* A network path: "\\server\share\" */
274
 
        int k = 0;
 
271
        /* A network path: "\\server\share\" */
 
272
        int k = 0;
275
273
 
276
 
        for (i = 2; i < len; i++)
277
 
            if (fname[i] == '\\' || fname[i] == '/')
278
 
                if (k++) {
279
 
                    i++;
280
 
                    break;
281
 
                }
 
274
        for (i = 2; i < len; i++)
 
275
            if (fname[i] == '\\' || fname[i] == '/')
 
276
                if (k++) {
 
277
                    i++;
 
278
                    break;
 
279
                }
282
280
    } else if (fname[0] == '/' || fname[0] == '\\') {
283
 
        /* Absolute with no drive. */
284
 
        i = 1;
 
281
        /* Absolute with no drive. */
 
282
        i = 1;
285
283
    } else if (len > 1 && fname[1] == ':') {
286
 
        /* Absolute with a drive. */
287
 
        i = (len > 2 && (fname[2] == '/' || fname[2] == '\\') ? 3 : 2);
 
284
        /* Absolute with a drive. */
 
285
        i = (len > 2 && (fname[2] == '/' || fname[2] == '\\') ? 3 : 2);
288
286
    }
289
287
    return i;
290
288
}
291
289
 
292
290
uint gs_file_name_check_separator(const char *fname, int len, const char *item)
293
291
{   if (len > 0) {
294
 
        if (fname[0] == '/' || fname[0] == '\\')
295
 
            return 1;
 
292
        if (fname[0] == '/' || fname[0] == '\\')
 
293
            return 1;
296
294
    } else if (len < 0) {
297
 
        if (fname[-1] == '/' || fname[-1] == '\\')
298
 
            return 1;
 
295
        if (fname[-1] == '/' || fname[-1] == '\\')
 
296
            return 1;
299
297
    }
300
298
    return 0;
301
299
}
333
331
}
334
332
 
335
333
gp_file_name_combine_result
336
 
gp_file_name_combine(const char *prefix, uint plen, const char *fname, uint flen, 
337
 
                    bool no_sibling, char *buffer, uint *blen)
 
334
gp_file_name_combine(const char *prefix, uint plen, const char *fname, uint flen,
 
335
                    bool no_sibling, char *buffer, uint *blen)
338
336
{
339
 
    return gp_file_name_combine_generic(prefix, plen, 
340
 
            fname, flen, no_sibling, buffer, blen);
 
337
    return gp_file_name_combine_generic(prefix, plen,
 
338
            fname, flen, no_sibling, buffer, blen);
341
339
}
342
 
 
343