← Back to branch summary

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

« back to all changes in this revision

Viewing changes to base/sfxcommon.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/sfxcommon.c
1
1
/* Copyright (C) 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
 
35
35
    stream *s;
36
36
    s = s_alloc(mem, cname);
37
37
    if (s == 0)
38
 
        return 0;
 
38
        return 0;
39
39
    s_init_ids(s);
40
40
    s->is_temp = 0;             /* not a temp stream */
41
41
    s->foreign = 0;
57
57
/* but don't open an OS file or initialize the stream. */
58
58
int
59
59
file_open_stream(const char *fname, uint len, const char *file_access,
60
 
                 uint buffer_size, stream ** ps, gx_io_device *iodev,
61
 
                 iodev_proc_fopen_t fopen_proc, gs_memory_t *mem)
 
60
                 uint buffer_size, stream ** ps, gx_io_device *iodev,
 
61
                 iodev_proc_fopen_t fopen_proc, gs_memory_t *mem)
62
62
{
63
63
    int code;
64
64
    FILE *file;
65
65
    char fmode[4];  /* r/w/a, [+], [b], null */
66
66
 
67
67
    if (!iodev)
68
 
        iodev = iodev_default(mem);
 
68
        iodev = iodev_default(mem);
69
69
    code = file_prepare_stream(fname, len, file_access, buffer_size, ps, fmode, mem);
70
70
    if (code < 0)
71
 
        return code;
 
71
        return code;
72
72
    if (fname == 0)
73
 
        return 0;
 
73
        return 0;
74
74
    if (fname[0] == 0)          /* fopen_proc gets NUL terminated string, not len */
75
 
        return 0;               /* so this is the same as len == 0, so return NULL */
 
75
        return 0;               /* so this is the same as len == 0, so return NULL */
76
76
    code = (*fopen_proc)(iodev, (char *)(*ps)->cbuf, fmode, &file,
77
 
                         (char *)(*ps)->cbuf, (*ps)->bsize);
 
77
                         (char *)(*ps)->cbuf, (*ps)->bsize);
78
78
    if (code < 0) {
79
 
        /* discard the stuff we allocated to keep from accumulating stuff needing GC */
80
 
        gs_free_object(mem, (*ps)->cbuf, "file_close(buffer)");
81
 
        gs_free_object(mem, *ps, "file_prepare_stream(stream)");
82
 
        *ps = NULL;
83
 
        return code;
 
79
        /* discard the stuff we allocated to keep from accumulating stuff needing GC */
 
80
        gs_free_object(mem, (*ps)->cbuf, "file_close(buffer)");
 
81
        gs_free_object(mem, *ps, "file_prepare_stream(stream)");
 
82
        *ps = NULL;
 
83
        return code;
84
84
    }
85
85
    file_init_stream(*ps, file, fmode, (*ps)->cbuf, (*ps)->bsize);
86
86
    return 0;
96
96
    int code = file_close_disable(s);
97
97
 
98
98
    if (code)
99
 
        return code;
 
99
        return code;
100
100
    /*
101
101
     * Check for temporary streams created for filters.
102
102
     * There may be more than one in the case of a procedure-based filter,
105
105
     * allocated by file_alloc_stream, so we mustn't free them.
106
106
     */
107
107
    while (stemp != 0 && stemp->is_temp != 0) {
108
 
        stream *snext = stemp->strm;
 
108
        stream *snext = stemp->strm;
109
109
 
110
 
        mem = stemp->memory;
111
 
        if (stemp->is_temp > 1)
112
 
            gs_free_object(mem, stemp->cbuf,
113
 
                           "file_close(temp stream buffer)");
114
 
        s_disable(stemp);
115
 
        stemp = snext;
 
110
        mem = stemp->memory;
 
111
        if (stemp->is_temp > 1)
 
112
            gs_free_object(mem, stemp->cbuf,
 
113
                           "file_close(temp stream buffer)");
 
114
        s_disable(stemp);
 
115
        stemp = snext;
116
116
    }
117
117
    mem = s->memory;
118
118
    gs_free_object(mem, s->cbuf, "file_close(buffer)");
119
119
    if (s->close_strm && stemp != 0)
120
 
        return sclose(stemp);
 
120
        return sclose(stemp);
121
121
    return 0;
122
122
}
123
123
 
127
127
 */
128
128
void
129
129
file_init_stream(stream *s, FILE *file, const char *fmode, byte *buffer,
130
 
                 uint buffer_size)
 
130
                 uint buffer_size)
131
131
{
132
132
    switch (fmode[0]) {
133
133
    case 'a':
134
 
        sappend_file(s, file, buffer, buffer_size);
135
 
        break;
 
134
        sappend_file(s, file, buffer, buffer_size);
 
135
        break;
136
136
    case 'r':
137
 
        /* Defeat buffering for terminals. */
138
 
        {
139
 
            struct stat rstat;
 
137
        /* Defeat buffering for terminals. */
 
138
        {
 
139
            struct stat rstat;
140
140
 
141
 
            fstat(fileno(file), &rstat);
142
 
            sread_file(s, file, buffer,
143
 
                       (S_ISCHR(rstat.st_mode) ? 1 : buffer_size));
144
 
        }
145
 
        break;
 
141
            fstat(fileno(file), &rstat);
 
142
            sread_file(s, file, buffer,
 
143
                       (S_ISCHR(rstat.st_mode) ? 1 : buffer_size));
 
144
        }
 
145
        break;
146
146
    case 'w':
147
 
        swrite_file(s, file, buffer, buffer_size);
 
147
        swrite_file(s, file, buffer, buffer_size);
148
148
    }
149
149
    if (fmode[1] == '+')
150
 
        s->file_modes |= s_mode_read | s_mode_write;
 
150
        s->file_modes |= s_mode_read | s_mode_write;
151
151
    s->save_close = s->procs.close;
152
152
    s->procs.close = file_close_file;
153
153
}
157
157
/* On a successful return, the C file name is in the stream buffer. */
158
158
/* If fname==0, set up stream, and buffer. */
159
159
int
160
 
file_prepare_stream(const char *fname, uint len, const char *file_access, 
161
 
                 uint buffer_size, stream ** ps, char fmode[4], gs_memory_t *mem)
 
160
file_prepare_stream(const char *fname, uint len, const char *file_access,
 
161
                 uint buffer_size, stream ** ps, char fmode[4], gs_memory_t *mem)
162
162
{
163
163
    byte *buffer;
164
164
    register stream *s;
167
167
    strcpy(fmode, file_access);
168
168
    strcat(fmode, gp_fmode_binary_suffix);
169
169
    if (buffer_size == 0)
170
 
        buffer_size = file_default_buffer_size;
 
170
        buffer_size = file_default_buffer_size;
171
171
    if (len >= buffer_size)    /* we copy the file name into the buffer */
172
 
        return_error(gs_error_limitcheck);
 
172
        return_error(gs_error_limitcheck);
173
173
    /* Allocate the stream first, since it persists */
174
174
    /* even after the file has been closed. */
175
175
    s = file_alloc_stream(mem, "file_prepare_stream");
176
176
    if (s == 0)
177
 
        return_error(gs_error_VMerror);
 
177
        return_error(gs_error_VMerror);
178
178
    /* Allocate the buffer. */
179
179
    buffer = gs_alloc_bytes(mem, buffer_size, "file_prepare_stream(buffer)");
180
180
    if (buffer == 0)
181
 
        return_error(gs_error_VMerror);
 
181
        return_error(gs_error_VMerror);
182
182
    if (fname != 0) {
183
 
        memcpy(buffer, fname, len);
184
 
        buffer[len] = 0;        /* terminate string */
 
183
        memcpy(buffer, fname, len);
 
184
        buffer[len] = 0;        /* terminate string */
185
185
    } else
186
 
        buffer[0] = 0;  /* safety */
 
186
        buffer[0] = 0;  /* safety */
187
187
    s->cbuf = buffer;
188
188
    s->bsize = s->cbsize = buffer_size;
189
189
    s->save_close = 0;      /* in case this stream gets disabled before init finishes */