Subversion Repositories eduke32

Rev

Rev 6162 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 6162 Rev 7138
Line 26... Line 26...
26
#include <errno.h>
26
#include <errno.h>
27
#include "common.h"
27
#include "common.h"
28
#include "hio.h"
28
#include "hio.h"
29
#include "mdataio.h"
29
#include "mdataio.h"
30
30
-
 
31
#ifdef EDUKE32_DISABLED
31
static long get_size(FILE *f)
32
static long get_size(FILE *f)
32
{
33
{
33
        long size, pos;
34
        long size, pos;
34
35
35
        pos = ftell(f);
36
        pos = ftell(f);
Line 44... Line 45...
44
                return size;
45
                return size;
45
        } else {
46
        } else {
46
                return pos;
47
                return pos;
47
        }
48
        }
48
}
49
}
-
 
50
#endif
49
51
50
int8 hio_read8s(HIO_HANDLE *h)
52
int8 hio_read8s(HIO_HANDLE *h)
51
{
53
{
-
 
54
#ifdef EDUKE32_DISABLED
52
        int err;
55
        int err;
-
 
56
#endif
53
        int8 ret = 0;
57
        int8 ret = 0;
54
58
55
        switch (HIO_HANDLE_TYPE(h)) {
59
        switch (HIO_HANDLE_TYPE(h)) {
-
 
60
#ifdef EDUKE32_DISABLED
56
        case HIO_HANDLE_TYPE_FILE:
61
        case HIO_HANDLE_TYPE_FILE:
57
                ret = read8s(h->handle.file, &err);
62
                ret = read8s(h->handle.file, &err);
58
                if (err != 0) {
63
                if (err != 0) {
59
                        h->error = err;
64
                        h->error = err;
60
                }
65
                }
61
                break;
66
                break;
-
 
67
#endif
62
        case HIO_HANDLE_TYPE_MEMORY:
68
        case HIO_HANDLE_TYPE_MEMORY:
63
                ret = mread8s(h->handle.mem);
69
                ret = mread8s(h->handle.mem);
64
                break;
70
                break;
65
        }
71
        }
66
72
67
        return ret;
73
        return ret;
68
}
74
}
69
75
70
uint8 hio_read8(HIO_HANDLE *h)
76
uint8 hio_read8(HIO_HANDLE *h)
71
{
77
{
-
 
78
#ifdef EDUKE32_DISABLED
72
        int err;
79
        int err;
-
 
80
#endif
73
        uint8 ret = 0;
81
        uint8 ret = 0;
74
82
75
        switch (HIO_HANDLE_TYPE(h)) {
83
        switch (HIO_HANDLE_TYPE(h)) {
-
 
84
#ifdef EDUKE32_DISABLED
76
        case HIO_HANDLE_TYPE_FILE:
85
        case HIO_HANDLE_TYPE_FILE:
77
                ret = read8(h->handle.file, &err);
86
                ret = read8(h->handle.file, &err);
78
                if (err != 0) {
87
                if (err != 0) {
79
                        h->error = err;
88
                        h->error = err;
80
                }
89
                }
81
                break;
90
                break;
-
 
91
#endif
82
        case HIO_HANDLE_TYPE_MEMORY:
92
        case HIO_HANDLE_TYPE_MEMORY:
83
                ret = mread8(h->handle.mem);
93
                ret = mread8(h->handle.mem);
84
                break;
94
                break;
85
        }
95
        }
86
96
87
        return ret;
97
        return ret;
88
}
98
}
89
99
90
uint16 hio_read16l(HIO_HANDLE *h)
100
uint16 hio_read16l(HIO_HANDLE *h)
91
{
101
{
-
 
102
#ifdef EDUKE32_DISABLED
92
        int err;
103
        int err;
-
 
104
#endif
93
        uint16 ret = 0;
105
        uint16 ret = 0;
94
106
95
        switch (HIO_HANDLE_TYPE(h)) {
107
        switch (HIO_HANDLE_TYPE(h)) {
-
 
108
#ifdef EDUKE32_DISABLED
96
        case HIO_HANDLE_TYPE_FILE:
109
        case HIO_HANDLE_TYPE_FILE:
97
                ret = read16l(h->handle.file, &err);
110
                ret = read16l(h->handle.file, &err);
98
                if (err != 0) {
111
                if (err != 0) {
99
                        h->error = err;
112
                        h->error = err;
100
                }
113
                }
101
                break;
114
                break;
-
 
115
#endif
102
        case HIO_HANDLE_TYPE_MEMORY:
116
        case HIO_HANDLE_TYPE_MEMORY:
103
                ret = mread16l(h->handle.mem);
117
                ret = mread16l(h->handle.mem);
104
                break;
118
                break;
105
        }
119
        }
106
120
107
        return ret;
121
        return ret;
108
}
122
}
109
123
110
uint16 hio_read16b(HIO_HANDLE *h)
124
uint16 hio_read16b(HIO_HANDLE *h)
111
{
125
{
-
 
126
#ifdef EDUKE32_DISABLED
112
        int err;
127
        int err;
-
 
128
#endif
113
        uint16 ret = 0;
129
        uint16 ret = 0;
114
130
115
        switch (HIO_HANDLE_TYPE(h)) {
131
        switch (HIO_HANDLE_TYPE(h)) {
-
 
132
#ifdef EDUKE32_DISABLED
116
        case HIO_HANDLE_TYPE_FILE:
133
        case HIO_HANDLE_TYPE_FILE:
117
                ret = read16b(h->handle.file, &err);
134
                ret = read16b(h->handle.file, &err);
118
                if (err != 0) {
135
                if (err != 0) {
119
                        h->error = err;
136
                        h->error = err;
120
                }
137
                }
121
                break;
138
                break;
-
 
139
#endif
122
        case HIO_HANDLE_TYPE_MEMORY:
140
        case HIO_HANDLE_TYPE_MEMORY:
123
                ret = mread16b(h->handle.mem);
141
                ret = mread16b(h->handle.mem);
124
                break;
142
                break;
125
        }
143
        }
126
144
127
        return ret;
145
        return ret;
128
}
146
}
129
147
130
uint32 hio_read24l(HIO_HANDLE *h)
148
uint32 hio_read24l(HIO_HANDLE *h)
131
{
149
{
-
 
150
#ifdef EDUKE32_DISABLED
132
        int err;
151
        int err;
-
 
152
#endif
133
        uint32 ret = 0;
153
        uint32 ret = 0;
134
154
135
        switch (HIO_HANDLE_TYPE(h)) {
155
        switch (HIO_HANDLE_TYPE(h)) {
-
 
156
#ifdef EDUKE32_DISABLED
136
        case HIO_HANDLE_TYPE_FILE:
157
        case HIO_HANDLE_TYPE_FILE:
137
                ret = read24l(h->handle.file, &err);
158
                ret = read24l(h->handle.file, &err);
138
                if (err != 0) {
159
                if (err != 0) {
139
                        h->error = err;
160
                        h->error = err;
140
                }
161
                }
141
                break;
162
                break;
-
 
163
#endif
142
        case HIO_HANDLE_TYPE_MEMORY:
164
        case HIO_HANDLE_TYPE_MEMORY:
143
                ret = mread24l(h->handle.mem);
165
                ret = mread24l(h->handle.mem);
144
                break;
166
                break;
145
        }
167
        }
146
168
147
        return ret;
169
        return ret;
148
}
170
}
149
171
150
uint32 hio_read24b(HIO_HANDLE *h)
172
uint32 hio_read24b(HIO_HANDLE *h)
151
{
173
{
-
 
174
#ifdef EDUKE32_DISABLED
152
        int err;
175
        int err;
-
 
176
#endif
153
        uint32 ret = 0;
177
        uint32 ret = 0;
154
178
155
        switch (HIO_HANDLE_TYPE(h)) {
179
        switch (HIO_HANDLE_TYPE(h)) {
-
 
180
#ifdef EDUKE32_DISABLED
156
        case HIO_HANDLE_TYPE_FILE:
181
        case HIO_HANDLE_TYPE_FILE:
157
                ret = read24b(h->handle.file, &err);
182
                ret = read24b(h->handle.file, &err);
158
                if (err != 0) {
183
                if (err != 0) {
159
                        h->error = err;
184
                        h->error = err;
160
                }
185
                }
161
                break;
186
                break;
-
 
187
#endif
162
        case HIO_HANDLE_TYPE_MEMORY:
188
        case HIO_HANDLE_TYPE_MEMORY:
163
                ret = mread24b(h->handle.mem);
189
                ret = mread24b(h->handle.mem);
164
                break;
190
                break;
165
        }
191
        }
166
192
167
        return ret;
193
        return ret;
168
}
194
}
169
195
170
uint32 hio_read32l(HIO_HANDLE *h)
196
uint32 hio_read32l(HIO_HANDLE *h)
171
{
197
{
-
 
198
#ifdef EDUKE32_DISABLED
172
        int err;
199
        int err;
-
 
200
#endif
173
        uint32 ret = 0;
201
        uint32 ret = 0;
174
202
175
        switch (HIO_HANDLE_TYPE(h)) {
203
        switch (HIO_HANDLE_TYPE(h)) {
-
 
204
#ifdef EDUKE32_DISABLED
176
        case HIO_HANDLE_TYPE_FILE:
205
        case HIO_HANDLE_TYPE_FILE:
177
                ret = read32l(h->handle.file, &err);
206
                ret = read32l(h->handle.file, &err);
178
                if (err != 0) {
207
                if (err != 0) {
179
                        h->error = err;
208
                        h->error = err;
180
                }
209
                }
181
                break;
210
                break;
-
 
211
#endif
182
        case HIO_HANDLE_TYPE_MEMORY:
212
        case HIO_HANDLE_TYPE_MEMORY:
183
                ret = mread32l(h->handle.mem);
213
                ret = mread32l(h->handle.mem);
184
                break;
214
                break;
185
        }
215
        }
186
216
187
        return ret;
217
        return ret;
188
}
218
}
189
219
190
uint32 hio_read32b(HIO_HANDLE *h)
220
uint32 hio_read32b(HIO_HANDLE *h)
191
{
221
{
-
 
222
#ifdef EDUKE32_DISABLED
192
        int err;
223
        int err;
-
 
224
#endif
193
        uint32 ret = 0;
225
        uint32 ret = 0;
194
226
195
        switch (HIO_HANDLE_TYPE(h)) {
227
        switch (HIO_HANDLE_TYPE(h)) {
-
 
228
#ifdef EDUKE32_DISABLED
196
        case HIO_HANDLE_TYPE_FILE:
229
        case HIO_HANDLE_TYPE_FILE:
197
                ret = read32b(h->handle.file, &err);
230
                ret = read32b(h->handle.file, &err);
198
                if (err != 0) {
231
                if (err != 0) {
199
                        h->error = err;
232
                        h->error = err;
200
                }
233
                }
201
                break;
234
                break;
-
 
235
#endif
202
        case HIO_HANDLE_TYPE_MEMORY:
236
        case HIO_HANDLE_TYPE_MEMORY:
203
                ret = mread32b(h->handle.mem);
237
                ret = mread32b(h->handle.mem);
204
        }
238
        }
205
239
206
        return ret;
240
        return ret;
Line 209... Line 243...
209
size_t hio_read(void *buf, size_t size, size_t num, HIO_HANDLE *h)
243
size_t hio_read(void *buf, size_t size, size_t num, HIO_HANDLE *h)
210
{
244
{
211
        size_t ret = 0;
245
        size_t ret = 0;
212
246
213
        switch (HIO_HANDLE_TYPE(h)) {
247
        switch (HIO_HANDLE_TYPE(h)) {
-
 
248
#ifdef EDUKE32_DISABLED
214
        case HIO_HANDLE_TYPE_FILE:
249
        case HIO_HANDLE_TYPE_FILE:
215
                ret = fread(buf, size, num, h->handle.file);
250
                ret = fread(buf, size, num, h->handle.file);
216
                if (ret != num) {
251
                if (ret != num) {
217
                        if (ferror(h->handle.file)) {
252
                        if (ferror(h->handle.file)) {
218
                                h->error = errno;
253
                                h->error = errno;
219
                        } else {
254
                        } else {
220
                                h->error = feof(h->handle.file) ? EOF : -2;
255
                                h->error = feof(h->handle.file) ? EOF : -2;
221
                        }
256
                        }
222
                }
257
                }
223
                break;
258
                break;
-
 
259
#endif
224
        case HIO_HANDLE_TYPE_MEMORY:
260
        case HIO_HANDLE_TYPE_MEMORY:
225
                ret = mread(buf, size, num, h->handle.mem);
261
                ret = mread(buf, size, num, h->handle.mem);
226
                if (ret != num) {
262
                if (ret != num) {
227
                        h->error = errno;
263
                        h->error = errno;
228
                }
264
                }
Line 235... Line 271...
235
int hio_seek(HIO_HANDLE *h, long offset, int whence)
271
int hio_seek(HIO_HANDLE *h, long offset, int whence)
236
{
272
{
237
        int ret = -1;
273
        int ret = -1;
238
274
239
        switch (HIO_HANDLE_TYPE(h)) {
275
        switch (HIO_HANDLE_TYPE(h)) {
-
 
276
#ifdef EDUKE32_DISABLED
240
        case HIO_HANDLE_TYPE_FILE:
277
        case HIO_HANDLE_TYPE_FILE:
241
                ret = fseek(h->handle.file, offset, whence);
278
                ret = fseek(h->handle.file, offset, whence);
242
                if (ret < 0) {
279
                if (ret < 0) {
243
                        h->error = errno;
280
                        h->error = errno;
244
                }
281
                }
245
                break;
282
                break;
-
 
283
#endif
246
        case HIO_HANDLE_TYPE_MEMORY:
284
        case HIO_HANDLE_TYPE_MEMORY:
247
                ret = mseek(h->handle.mem, offset, whence);
285
                ret = mseek(h->handle.mem, offset, whence);
248
                if (ret < 0) {
286
                if (ret < 0) {
249
                        h->error = errno;
287
                        h->error = errno;
250
                }
288
                }
Line 257... Line 295...
257
long hio_tell(HIO_HANDLE *h)
295
long hio_tell(HIO_HANDLE *h)
258
{
296
{
259
        long ret = -1;
297
        long ret = -1;
260
298
261
        switch (HIO_HANDLE_TYPE(h)) {
299
        switch (HIO_HANDLE_TYPE(h)) {
-
 
300
#ifdef EDUKE32_DISABLED
262
        case HIO_HANDLE_TYPE_FILE:
301
        case HIO_HANDLE_TYPE_FILE:
263
                ret = ftell(h->handle.file);
302
                ret = ftell(h->handle.file);
264
                if (ret < 0) {
303
                if (ret < 0) {
265
                        h->error = errno;
304
                        h->error = errno;
266
                }
305
                }
267
                break;
306
                break;
-
 
307
#endif
268
        case HIO_HANDLE_TYPE_MEMORY:
308
        case HIO_HANDLE_TYPE_MEMORY:
269
                ret = mtell(h->handle.mem);
309
                ret = mtell(h->handle.mem);
270
                if (ret < 0) {
310
                if (ret < 0) {
271
                        h->error = errno;
311
                        h->error = errno;
272
                }
312
                }
Line 277... Line 317...
277
}
317
}
278
318
279
int hio_eof(HIO_HANDLE *h)
319
int hio_eof(HIO_HANDLE *h)
280
{
320
{
281
        switch (HIO_HANDLE_TYPE(h)) {
321
        switch (HIO_HANDLE_TYPE(h)) {
-
 
322
#ifdef EDUKE32_DISABLED
282
        case HIO_HANDLE_TYPE_FILE:
323
        case HIO_HANDLE_TYPE_FILE:
283
                return feof(h->handle.file);
324
                return feof(h->handle.file);
-
 
325
#endif
284
        case HIO_HANDLE_TYPE_MEMORY:
326
        case HIO_HANDLE_TYPE_MEMORY:
285
                return meof(h->handle.mem);
327
                return meof(h->handle.mem);
286
        default:
328
        default:
287
                return EOF;
329
                return EOF;
288
        }
330
        }
Line 293... Line 335...
293
        int error = h->error;
335
        int error = h->error;
294
        h->error = 0;
336
        h->error = 0;
295
        return error;
337
        return error;
296
}
338
}
297
339
-
 
340
#ifdef EDUKE32_DISABLED
298
HIO_HANDLE *hio_open(const void *path, const char *mode)
341
HIO_HANDLE *hio_open(const void *path, const char *mode)
299
{
342
{
300
        HIO_HANDLE *h;
343
        HIO_HANDLE *h;
301
344
302
        h = (HIO_HANDLE *)malloc(sizeof (HIO_HANDLE));
345
        h = (HIO_HANDLE *)malloc(sizeof (HIO_HANDLE));
Line 320... Line 363...
320
    err2:
363
    err2:
321
        free(h);
364
        free(h);
322
    err:
365
    err:
323
        return NULL;
366
        return NULL;
324
}
367
}
-
 
368
#endif
325
369
326
HIO_HANDLE *hio_open_mem(const void *ptr, long size)
370
HIO_HANDLE *hio_open_mem(const void *ptr, long size)
327
{
371
{
328
        HIO_HANDLE *h;
372
        HIO_HANDLE *h;
329
373
Line 337... Line 381...
337
        h->size = size;
381
        h->size = size;
338
382
339
        return h;
383
        return h;
340
}
384
}
341
385
-
 
386
#ifdef EDUKE32_DISABLED
342
HIO_HANDLE *hio_open_file(FILE *f)
387
HIO_HANDLE *hio_open_file(FILE *f)
343
{
388
{
344
        HIO_HANDLE *h;
389
        HIO_HANDLE *h;
345
390
346
        h = (HIO_HANDLE *)malloc(sizeof (HIO_HANDLE));
391
        h = (HIO_HANDLE *)malloc(sizeof (HIO_HANDLE));
Line 352... Line 397...
352
        h->handle.file = f /*fdopen(fileno(f), "rb")*/;
397
        h->handle.file = f /*fdopen(fileno(f), "rb")*/;
353
        h->size = get_size(f);
398
        h->size = get_size(f);
354
399
355
        return h;
400
        return h;
356
}
401
}
-
 
402
#endif
357
403
358
int hio_close(HIO_HANDLE *h)
404
int hio_close(HIO_HANDLE *h)
359
{
405
{
360
        int ret;
406
        int ret;
361
407
362
        switch (HIO_HANDLE_TYPE(h)) {
408
        switch (HIO_HANDLE_TYPE(h)) {
-
 
409
#ifdef EDUKE32_DISABLED
363
        case HIO_HANDLE_TYPE_FILE:
410
        case HIO_HANDLE_TYPE_FILE:
364
                ret = fclose(h->handle.file);
411
                ret = fclose(h->handle.file);
365
                break;
412
                break;
-
 
413
#endif
366
        case HIO_HANDLE_TYPE_MEMORY:
414
        case HIO_HANDLE_TYPE_MEMORY:
367
                ret = mclose(h->handle.mem);
415
                ret = mclose(h->handle.mem);
368
                break;
416
                break;
369
        default:
417
        default:
370
                ret = -1;
418
                ret = -1;