Mercurial > sdl-ios-xcode
annotate src/file/SDL_rwops.c @ 297:f6ffac90895c
Updated copyright information for 2002
author | Sam Lantinga <slouken@libsdl.org> |
---|---|
date | Wed, 06 Mar 2002 11:23:08 +0000 |
parents | e8157fcb3114 |
children | 522e5202014d |
rev | line source |
---|---|
0 | 1 /* |
2 SDL - Simple DirectMedia Layer | |
297
f6ffac90895c
Updated copyright information for 2002
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 Sam Lantinga |
0 | 4 |
5 This library is free software; you can redistribute it and/or | |
6 modify it under the terms of the GNU Library General Public | |
7 License as published by the Free Software Foundation; either | |
8 version 2 of the License, or (at your option) any later version. | |
9 | |
10 This library is distributed in the hope that it will be useful, | |
11 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 Library General Public License for more details. | |
14 | |
15 You should have received a copy of the GNU Library General Public | |
16 License along with this library; if not, write to the Free | |
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
18 | |
19 Sam Lantinga | |
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
36
diff
changeset
|
20 slouken@libsdl.org |
0 | 21 */ |
22 | |
23 #ifdef SAVE_RCSID | |
24 static char rcsid = | |
25 "@(#) $Id$"; | |
26 #endif | |
27 | |
28 /* This file provides a general interface for SDL to read and write | |
29 data sources. It can easily be extended to files, memory, etc. | |
30 */ | |
31 | |
32 #include <stdlib.h> | |
36
13ee9f4834ea
Windows CE patches contributed by Rainer Loritz
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
33 #include <stdio.h> |
0 | 34 #include <string.h> |
35 | |
36 #include "SDL_error.h" | |
37 #include "SDL_rwops.h" | |
38 | |
39 /* Functions to read/write stdio file pointers */ | |
40 | |
41 static int stdio_seek(SDL_RWops *context, int offset, int whence) | |
42 { | |
43 if ( fseek(context->hidden.stdio.fp, offset, whence) == 0 ) { | |
44 return(ftell(context->hidden.stdio.fp)); | |
45 } else { | |
46 SDL_Error(SDL_EFSEEK); | |
47 return(-1); | |
48 } | |
49 } | |
50 static int stdio_read(SDL_RWops *context, void *ptr, int size, int maxnum) | |
51 { | |
52 size_t nread; | |
53 | |
54 nread = fread(ptr, size, maxnum, context->hidden.stdio.fp); | |
55 if ( nread == 0 && ferror(context->hidden.stdio.fp) ) { | |
56 SDL_Error(SDL_EFREAD); | |
57 } | |
58 return(nread); | |
59 } | |
60 static int stdio_write(SDL_RWops *context, const void *ptr, int size, int num) | |
61 { | |
62 size_t nwrote; | |
63 | |
64 nwrote = fwrite(ptr, size, num, context->hidden.stdio.fp); | |
65 if ( nwrote == 0 && ferror(context->hidden.stdio.fp) ) { | |
66 SDL_Error(SDL_EFWRITE); | |
67 } | |
68 return(nwrote); | |
69 } | |
70 static int stdio_close(SDL_RWops *context) | |
71 { | |
72 if ( context ) { | |
73 if ( context->hidden.stdio.autoclose ) { | |
74 /* WARNING: Check the return value here! */ | |
75 fclose(context->hidden.stdio.fp); | |
76 } | |
77 free(context); | |
78 } | |
79 return(0); | |
80 } | |
81 | |
82 /* Functions to read/write memory pointers */ | |
83 | |
84 static int mem_seek(SDL_RWops *context, int offset, int whence) | |
85 { | |
86 Uint8 *newpos; | |
87 | |
88 switch (whence) { | |
89 case SEEK_SET: | |
90 newpos = context->hidden.mem.base+offset; | |
91 break; | |
92 case SEEK_CUR: | |
93 newpos = context->hidden.mem.here+offset; | |
94 break; | |
95 case SEEK_END: | |
96 newpos = context->hidden.mem.stop+offset; | |
97 break; | |
98 default: | |
99 SDL_SetError("Unknown value for 'whence'"); | |
100 return(-1); | |
101 } | |
102 if ( newpos < context->hidden.mem.base ) { | |
103 newpos = context->hidden.mem.base; | |
104 } | |
105 if ( newpos > context->hidden.mem.stop ) { | |
106 newpos = context->hidden.mem.stop; | |
107 } | |
108 context->hidden.mem.here = newpos; | |
109 return(context->hidden.mem.here-context->hidden.mem.base); | |
110 } | |
111 static int mem_read(SDL_RWops *context, void *ptr, int size, int maxnum) | |
112 { | |
113 int num; | |
114 | |
115 num = maxnum; | |
116 if ( (context->hidden.mem.here + (num*size)) > context->hidden.mem.stop ) { | |
117 num = (context->hidden.mem.stop-context->hidden.mem.here)/size; | |
118 } | |
119 memcpy(ptr, context->hidden.mem.here, num*size); | |
120 context->hidden.mem.here += num*size; | |
121 return(num); | |
122 } | |
123 static int mem_write(SDL_RWops *context, const void *ptr, int size, int num) | |
124 { | |
125 if ( (context->hidden.mem.here + (num*size)) > context->hidden.mem.stop ) { | |
126 num = (context->hidden.mem.stop-context->hidden.mem.here)/size; | |
127 } | |
128 memcpy(context->hidden.mem.here, ptr, num*size); | |
129 context->hidden.mem.here += num*size; | |
130 return(num); | |
131 } | |
132 static int mem_close(SDL_RWops *context) | |
133 { | |
134 if ( context ) { | |
135 free(context); | |
136 } | |
137 return(0); | |
138 } | |
139 | |
140 /* Functions to create SDL_RWops structures from various data sources */ | |
141 #ifdef WIN32 | |
142 /* Aggh. You can't (apparently) open a file in an application and | |
143 read from it in a DLL. | |
144 */ | |
145 static int in_sdl = 0; | |
146 #endif | |
147 | |
148 #ifdef macintosh | |
149 /* | |
150 * translate unix-style slash-separated filename to mac-style colon-separated | |
151 * name; return malloced string | |
152 */ | |
153 static char *unix_to_mac(const char *file) | |
154 { | |
155 int flen = strlen(file); | |
156 char *path = malloc(flen + 2); | |
157 const char *src = file; | |
158 char *dst = path; | |
159 if(*src == '/') { | |
160 /* really depends on filesystem layout, hope for the best */ | |
161 src++; | |
162 } else { | |
163 /* Check if this is a MacOS path to begin with */ | |
164 if(*src != ':') | |
165 *dst++ = ':'; /* relative paths begin with ':' */ | |
166 } | |
167 while(src < file + flen) { | |
168 const char *end = strchr(src, '/'); | |
169 int len; | |
170 if(!end) | |
171 end = file + flen; /* last component */ | |
172 len = end - src; | |
173 if(len == 0 || (len == 1 && src[0] == '.')) { | |
174 /* remove repeated slashes and . */ | |
175 } else { | |
176 if(len == 2 && src[0] == '.' && src[1] == '.') { | |
177 /* replace .. with the empty string */ | |
178 } else { | |
179 memcpy(dst, src, len); | |
180 dst += len; | |
181 } | |
182 if(end < file + flen) | |
183 *dst++ = ':'; | |
184 } | |
185 src = end + 1; | |
186 } | |
187 *dst++ = '\0'; | |
188 return path; | |
189 } | |
190 #endif /* macintosh */ | |
191 | |
192 SDL_RWops *SDL_RWFromFile(const char *file, const char *mode) | |
193 { | |
194 FILE *fp; | |
195 SDL_RWops *rwops; | |
196 | |
197 rwops = NULL; | |
198 | |
199 #ifdef macintosh | |
200 { | |
201 char *mpath = unix_to_mac(file); | |
202 fp = fopen(mpath, mode); | |
203 free(mpath); | |
204 } | |
205 #else | |
206 fp = fopen(file, mode); | |
207 #endif | |
208 if ( fp == NULL ) { | |
209 SDL_SetError("Couldn't open %s", file); | |
210 } else { | |
211 #ifdef WIN32 | |
212 in_sdl = 1; | |
213 rwops = SDL_RWFromFP(fp, 1); | |
214 in_sdl = 0; | |
215 #else | |
216 rwops = SDL_RWFromFP(fp, 1); | |
217 #endif | |
218 } | |
219 return(rwops); | |
220 } | |
221 | |
222 SDL_RWops *SDL_RWFromFP(FILE *fp, int autoclose) | |
223 { | |
224 SDL_RWops *rwops; | |
225 | |
226 #ifdef WIN32 | |
227 if ( ! in_sdl ) { | |
228 SDL_SetError("You can't pass a FILE pointer to a DLL (??)"); | |
229 /*return(NULL);*/ | |
230 } | |
231 #endif | |
232 rwops = SDL_AllocRW(); | |
233 if ( rwops != NULL ) { | |
234 rwops->seek = stdio_seek; | |
235 rwops->read = stdio_read; | |
236 rwops->write = stdio_write; | |
237 rwops->close = stdio_close; | |
238 rwops->hidden.stdio.fp = fp; | |
239 rwops->hidden.stdio.autoclose = autoclose; | |
240 } | |
241 return(rwops); | |
242 } | |
243 | |
244 SDL_RWops *SDL_RWFromMem(void *mem, int size) | |
245 { | |
246 SDL_RWops *rwops; | |
247 | |
248 rwops = SDL_AllocRW(); | |
249 if ( rwops != NULL ) { | |
250 rwops->seek = mem_seek; | |
251 rwops->read = mem_read; | |
252 rwops->write = mem_write; | |
253 rwops->close = mem_close; | |
254 rwops->hidden.mem.base = (Uint8 *)mem; | |
255 rwops->hidden.mem.here = rwops->hidden.mem.base; | |
256 rwops->hidden.mem.stop = rwops->hidden.mem.base+size; | |
257 } | |
258 return(rwops); | |
259 } | |
260 | |
261 SDL_RWops *SDL_AllocRW(void) | |
262 { | |
263 SDL_RWops *area; | |
264 | |
265 area = (SDL_RWops *)malloc(sizeof *area); | |
266 if ( area == NULL ) { | |
267 SDL_OutOfMemory(); | |
268 } | |
269 return(area); | |
270 } | |
271 | |
272 void SDL_FreeRW(SDL_RWops *area) | |
273 { | |
274 free(area); | |
275 } |