Mercurial > sdl-ios-xcode
annotate src/file/SDL_rwops.c @ 1312:c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
I batch edited these files, so please let me know if I've accidentally removed anybody's
credit here.
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Wed, 01 Feb 2006 06:32:25 +0000 |
| parents | 905d5b482f2a |
| children | 450721ad5436 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1269
diff
changeset
|
3 Copyright (C) 1997-2006 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1269
diff
changeset
|
6 modify it under the terms of the GNU Lesser General Public |
| 0 | 7 License as published by the Free Software Foundation; either |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1269
diff
changeset
|
8 version 2.1 of the License, or (at your option) any later version. |
| 0 | 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 | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1269
diff
changeset
|
13 Lesser General Public License for more details. |
| 0 | 14 |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1269
diff
changeset
|
15 You should have received a copy of the GNU Lesser General Public |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1269
diff
changeset
|
16 License along with this library; if not, write to the Free Software |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1269
diff
changeset
|
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 0 | 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 /* This file provides a general interface for SDL to read and write | |
| 24 data sources. It can easily be extended to files, memory, etc. | |
| 25 */ | |
| 26 | |
| 27 #include <stdlib.h> | |
|
36
13ee9f4834ea
Windows CE patches contributed by Rainer Loritz
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
28 #include <stdio.h> |
| 0 | 29 #include <string.h> |
| 30 | |
| 31 #include "SDL_error.h" | |
| 32 #include "SDL_rwops.h" | |
| 33 | |
| 34 /* Functions to read/write stdio file pointers */ | |
| 35 | |
| 36 static int stdio_seek(SDL_RWops *context, int offset, int whence) | |
| 37 { | |
| 38 if ( fseek(context->hidden.stdio.fp, offset, whence) == 0 ) { | |
| 39 return(ftell(context->hidden.stdio.fp)); | |
| 40 } else { | |
| 41 SDL_Error(SDL_EFSEEK); | |
| 42 return(-1); | |
| 43 } | |
| 44 } | |
| 45 static int stdio_read(SDL_RWops *context, void *ptr, int size, int maxnum) | |
| 46 { | |
| 47 size_t nread; | |
| 48 | |
| 49 nread = fread(ptr, size, maxnum, context->hidden.stdio.fp); | |
| 50 if ( nread == 0 && ferror(context->hidden.stdio.fp) ) { | |
| 51 SDL_Error(SDL_EFREAD); | |
| 52 } | |
| 53 return(nread); | |
| 54 } | |
| 55 static int stdio_write(SDL_RWops *context, const void *ptr, int size, int num) | |
| 56 { | |
| 57 size_t nwrote; | |
| 58 | |
| 59 nwrote = fwrite(ptr, size, num, context->hidden.stdio.fp); | |
| 60 if ( nwrote == 0 && ferror(context->hidden.stdio.fp) ) { | |
| 61 SDL_Error(SDL_EFWRITE); | |
| 62 } | |
| 63 return(nwrote); | |
| 64 } | |
| 65 static int stdio_close(SDL_RWops *context) | |
| 66 { | |
| 67 if ( context ) { | |
| 68 if ( context->hidden.stdio.autoclose ) { | |
| 69 /* WARNING: Check the return value here! */ | |
| 70 fclose(context->hidden.stdio.fp); | |
| 71 } | |
|
1202
0748fbb272e7
Matched SDL_AllowRW and SDL_FreeRW calls in SDL_rwops.c ...
Ryan C. Gordon <icculus@icculus.org>
parents:
1078
diff
changeset
|
72 SDL_FreeRW(context); |
| 0 | 73 } |
| 74 return(0); | |
| 75 } | |
| 76 | |
| 77 /* Functions to read/write memory pointers */ | |
| 78 | |
| 79 static int mem_seek(SDL_RWops *context, int offset, int whence) | |
| 80 { | |
| 81 Uint8 *newpos; | |
| 82 | |
| 83 switch (whence) { | |
| 84 case SEEK_SET: | |
| 85 newpos = context->hidden.mem.base+offset; | |
| 86 break; | |
| 87 case SEEK_CUR: | |
| 88 newpos = context->hidden.mem.here+offset; | |
| 89 break; | |
| 90 case SEEK_END: | |
| 91 newpos = context->hidden.mem.stop+offset; | |
| 92 break; | |
| 93 default: | |
| 94 SDL_SetError("Unknown value for 'whence'"); | |
| 95 return(-1); | |
| 96 } | |
| 97 if ( newpos < context->hidden.mem.base ) { | |
| 98 newpos = context->hidden.mem.base; | |
| 99 } | |
| 100 if ( newpos > context->hidden.mem.stop ) { | |
| 101 newpos = context->hidden.mem.stop; | |
| 102 } | |
| 103 context->hidden.mem.here = newpos; | |
| 104 return(context->hidden.mem.here-context->hidden.mem.base); | |
| 105 } | |
| 106 static int mem_read(SDL_RWops *context, void *ptr, int size, int maxnum) | |
| 107 { | |
|
1078
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
108 int total_bytes; |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
109 int mem_available; |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
110 |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
111 total_bytes = (maxnum * size); |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
112 if ( (maxnum <= 0) || (size <= 0) || ((total_bytes / maxnum) != size) ) { |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
113 return 0; |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
114 } |
| 0 | 115 |
|
1078
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
116 mem_available = (context->hidden.mem.stop - context->hidden.mem.here); |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
117 if (total_bytes > mem_available) { |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
118 total_bytes = mem_available; |
| 0 | 119 } |
|
1078
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
120 |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
121 memcpy(ptr, context->hidden.mem.here, total_bytes); |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
122 context->hidden.mem.here += total_bytes; |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
123 |
|
e2ef6b7001fd
Patch from Antonio SJ Musumeci:
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
124 return (total_bytes / size); |
| 0 | 125 } |
| 126 static int mem_write(SDL_RWops *context, const void *ptr, int size, int num) | |
| 127 { | |
| 128 if ( (context->hidden.mem.here + (num*size)) > context->hidden.mem.stop ) { | |
| 129 num = (context->hidden.mem.stop-context->hidden.mem.here)/size; | |
| 130 } | |
| 131 memcpy(context->hidden.mem.here, ptr, num*size); | |
| 132 context->hidden.mem.here += num*size; | |
| 133 return(num); | |
| 134 } | |
|
764
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
135 static int mem_writeconst(SDL_RWops *context, const void *ptr, int size, int num) |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
136 { |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
137 SDL_SetError("Can't write to read-only memory"); |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
138 return(-1); |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
139 } |
| 0 | 140 static int mem_close(SDL_RWops *context) |
| 141 { | |
| 142 if ( context ) { | |
|
1202
0748fbb272e7
Matched SDL_AllowRW and SDL_FreeRW calls in SDL_rwops.c ...
Ryan C. Gordon <icculus@icculus.org>
parents:
1078
diff
changeset
|
143 SDL_FreeRW(context); |
| 0 | 144 } |
| 145 return(0); | |
| 146 } | |
| 147 | |
| 148 /* Functions to create SDL_RWops structures from various data sources */ | |
| 149 #ifdef WIN32 | |
| 150 /* Aggh. You can't (apparently) open a file in an application and | |
| 151 read from it in a DLL. | |
| 152 */ | |
| 153 static int in_sdl = 0; | |
| 154 #endif | |
| 155 | |
| 156 #ifdef macintosh | |
| 157 /* | |
| 158 * translate unix-style slash-separated filename to mac-style colon-separated | |
| 159 * name; return malloced string | |
| 160 */ | |
| 161 static char *unix_to_mac(const char *file) | |
| 162 { | |
| 163 int flen = strlen(file); | |
| 164 char *path = malloc(flen + 2); | |
| 165 const char *src = file; | |
| 166 char *dst = path; | |
| 167 if(*src == '/') { | |
| 168 /* really depends on filesystem layout, hope for the best */ | |
| 169 src++; | |
| 170 } else { | |
| 171 /* Check if this is a MacOS path to begin with */ | |
| 172 if(*src != ':') | |
| 173 *dst++ = ':'; /* relative paths begin with ':' */ | |
| 174 } | |
| 175 while(src < file + flen) { | |
| 176 const char *end = strchr(src, '/'); | |
| 177 int len; | |
| 178 if(!end) | |
| 179 end = file + flen; /* last component */ | |
| 180 len = end - src; | |
| 181 if(len == 0 || (len == 1 && src[0] == '.')) { | |
| 182 /* remove repeated slashes and . */ | |
| 183 } else { | |
| 184 if(len == 2 && src[0] == '.' && src[1] == '.') { | |
| 185 /* replace .. with the empty string */ | |
| 186 } else { | |
| 187 memcpy(dst, src, len); | |
| 188 dst += len; | |
| 189 } | |
| 190 if(end < file + flen) | |
| 191 *dst++ = ':'; | |
| 192 } | |
| 193 src = end + 1; | |
| 194 } | |
| 195 *dst++ = '\0'; | |
| 196 return path; | |
| 197 } | |
| 198 #endif /* macintosh */ | |
| 199 | |
| 200 SDL_RWops *SDL_RWFromFile(const char *file, const char *mode) | |
| 201 { | |
| 202 FILE *fp; | |
| 203 SDL_RWops *rwops; | |
| 204 | |
| 205 rwops = NULL; | |
| 206 | |
| 207 #ifdef macintosh | |
| 208 { | |
| 209 char *mpath = unix_to_mac(file); | |
| 210 fp = fopen(mpath, mode); | |
| 211 free(mpath); | |
| 212 } | |
| 213 #else | |
| 214 fp = fopen(file, mode); | |
| 215 #endif | |
| 216 if ( fp == NULL ) { | |
| 217 SDL_SetError("Couldn't open %s", file); | |
| 218 } else { | |
| 219 #ifdef WIN32 | |
| 220 in_sdl = 1; | |
| 221 rwops = SDL_RWFromFP(fp, 1); | |
| 222 in_sdl = 0; | |
| 223 #else | |
| 224 rwops = SDL_RWFromFP(fp, 1); | |
| 225 #endif | |
| 226 } | |
| 227 return(rwops); | |
| 228 } | |
| 229 | |
| 230 SDL_RWops *SDL_RWFromFP(FILE *fp, int autoclose) | |
| 231 { | |
| 232 SDL_RWops *rwops; | |
| 233 | |
| 234 #ifdef WIN32 | |
| 235 if ( ! in_sdl ) { | |
|
1269
905d5b482f2a
Some explanation on why SDL_RWFromFP doesn't always work on Win32
Sam Lantinga <slouken@libsdl.org>
parents:
1202
diff
changeset
|
236 /* It's when SDL and the app are compiled with different C runtimes */ |
|
543
522e5202014d
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
237 SDL_SetError("You can't pass a FILE pointer to a DLL (?)"); |
| 0 | 238 /*return(NULL);*/ |
| 239 } | |
| 240 #endif | |
| 241 rwops = SDL_AllocRW(); | |
| 242 if ( rwops != NULL ) { | |
| 243 rwops->seek = stdio_seek; | |
| 244 rwops->read = stdio_read; | |
| 245 rwops->write = stdio_write; | |
| 246 rwops->close = stdio_close; | |
| 247 rwops->hidden.stdio.fp = fp; | |
| 248 rwops->hidden.stdio.autoclose = autoclose; | |
| 249 } | |
| 250 return(rwops); | |
| 251 } | |
| 252 | |
| 253 SDL_RWops *SDL_RWFromMem(void *mem, int size) | |
| 254 { | |
| 255 SDL_RWops *rwops; | |
| 256 | |
| 257 rwops = SDL_AllocRW(); | |
| 258 if ( rwops != NULL ) { | |
| 259 rwops->seek = mem_seek; | |
| 260 rwops->read = mem_read; | |
| 261 rwops->write = mem_write; | |
| 262 rwops->close = mem_close; | |
| 263 rwops->hidden.mem.base = (Uint8 *)mem; | |
| 264 rwops->hidden.mem.here = rwops->hidden.mem.base; | |
| 265 rwops->hidden.mem.stop = rwops->hidden.mem.base+size; | |
| 266 } | |
| 267 return(rwops); | |
| 268 } | |
| 269 | |
|
764
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
270 SDL_RWops *SDL_RWFromConstMem(const void *mem, int size) |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
271 { |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
272 SDL_RWops *rwops; |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
273 |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
274 rwops = SDL_AllocRW(); |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
275 if ( rwops != NULL ) { |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
276 rwops->seek = mem_seek; |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
277 rwops->read = mem_read; |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
278 rwops->write = mem_writeconst; |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
279 rwops->close = mem_close; |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
280 rwops->hidden.mem.base = (Uint8 *)mem; |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
281 rwops->hidden.mem.here = rwops->hidden.mem.base; |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
282 rwops->hidden.mem.stop = rwops->hidden.mem.base+size; |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
283 } |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
284 return(rwops); |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
285 } |
|
974c0fb74bf8
Added function to create RWops from const memory: SDL_RWFromConstMem()
Sam Lantinga <slouken@libsdl.org>
parents:
543
diff
changeset
|
286 |
| 0 | 287 SDL_RWops *SDL_AllocRW(void) |
| 288 { | |
| 289 SDL_RWops *area; | |
| 290 | |
| 291 area = (SDL_RWops *)malloc(sizeof *area); | |
| 292 if ( area == NULL ) { | |
| 293 SDL_OutOfMemory(); | |
| 294 } | |
| 295 return(area); | |
| 296 } | |
| 297 | |
| 298 void SDL_FreeRW(SDL_RWops *area) | |
| 299 { | |
| 300 free(area); | |
| 301 } |