[286] | 1 | // This file is a part of Framsticks SDK. http://www.framsticks.com/ |
---|
| 2 | // Copyright (C) 1999-2015 Maciej Komosinski and Szymon Ulatowski. |
---|
| 3 | // See LICENSE.txt for details. |
---|
[109] | 4 | |
---|
| 5 | #include "virtfile.h" |
---|
[206] | 6 | #include <common/stl-util.h> |
---|
[109] | 7 | |
---|
[298] | 8 | VirtFILE *VirtFILE::Vstdin = NULL; |
---|
| 9 | VirtFILE *VirtFILE::Vstdout = NULL; |
---|
| 10 | VirtFILE *VirtFILE::Vstderr = NULL; |
---|
[109] | 11 | |
---|
[298] | 12 | VirtFileSystem *VirtFILE::vfs = NULL; |
---|
[109] | 13 | |
---|
[301] | 14 | //#define DEBUG_DLL_CALLS |
---|
| 15 | |
---|
| 16 | VirtFILE *Vfopen(const char* path,const char* mode) |
---|
[109] | 17 | { |
---|
[301] | 18 | #ifdef DEBUG_DLL_CALLS |
---|
| 19 | printf("VirtFILE::Vfopen %s %s (vfs=%p)\n",path,mode,VirtFILE::vfs); |
---|
| 20 | #endif |
---|
[298] | 21 | return VirtFILE::vfs ? VirtFILE::vfs->Vfopen(path,mode) : NULL; |
---|
[109] | 22 | } |
---|
| 23 | |
---|
| 24 | VirtDIR *Vopendir(const char* path) |
---|
| 25 | { |
---|
[301] | 26 | #ifdef DEBUG_DLL_CALLS |
---|
| 27 | printf("VirtFILE::Vfopendir %s (vfs=%p)\n",path,VirtFILE::vfs); |
---|
| 28 | #endif |
---|
[298] | 29 | return VirtFILE::vfs ? VirtFILE::vfs->Vopendir(path) : NULL; |
---|
[109] | 30 | } |
---|
| 31 | |
---|
[295] | 32 | bool Vfexists(const char* path) |
---|
[109] | 33 | { |
---|
[295] | 34 | return VirtFILE::vfs ? VirtFILE::vfs->Vfexists(path) : false; |
---|
[109] | 35 | } |
---|
| 36 | |
---|
[295] | 37 | bool Vdirexists(const char* path,bool is_writable) |
---|
| 38 | { |
---|
| 39 | return VirtFILE::vfs ? VirtFILE::vfs->Vdirexists(path,is_writable) : false; |
---|
| 40 | } |
---|
| 41 | |
---|
| 42 | bool Vmkdir(const char* path) |
---|
| 43 | { |
---|
| 44 | return VirtFILE::vfs ? VirtFILE::vfs->Vmkdir(path) : false; |
---|
| 45 | } |
---|
| 46 | |
---|
| 47 | bool Vmkdirs(const char* path) |
---|
| 48 | { |
---|
| 49 | return VirtFILE::vfs ? VirtFILE::vfs->Vmkdirs(path) : false; |
---|
| 50 | } |
---|
| 51 | |
---|
[109] | 52 | VirtFILE::~VirtFILE() |
---|
| 53 | {} |
---|
| 54 | |
---|
[301] | 55 | void VirtFILE::selectFileSystem(VirtFileSystem *s) |
---|
| 56 | { |
---|
| 57 | vfs=s; |
---|
| 58 | #ifdef DEBUG_DLL_CALLS |
---|
| 59 | ::printf("VirtFILE::selectFileSystem: %p := %p\n",vfs,s); |
---|
| 60 | #endif |
---|
| 61 | } |
---|
[109] | 62 | |
---|
[206] | 63 | int VirtFILE::Vprintf(const char *format, va_list args) |
---|
| 64 | { |
---|
| 65 | string s=ssprintf_va(format,args); |
---|
| 66 | return Vwrite(s.c_str(),1,s.size()); |
---|
| 67 | } |
---|
| 68 | |
---|
[109] | 69 | int VirtFILE::printf(const char *format, ...) |
---|
| 70 | { |
---|
| 71 | int ret; va_list argptr; |
---|
| 72 | va_start(argptr,format); |
---|
| 73 | ret=Vprintf(format,argptr); |
---|
| 74 | va_end(argptr); |
---|
| 75 | return ret; |
---|
| 76 | } |
---|
| 77 | |
---|
[247] | 78 | int VirtFILE::getSize() |
---|
| 79 | { |
---|
| 80 | int saved_pos = Vtell(); |
---|
| 81 | Vseek(0, SEEK_END); |
---|
| 82 | int size = Vtell(); |
---|
| 83 | Vseek(saved_pos, SEEK_SET); |
---|
| 84 | return size; |
---|
| 85 | } |
---|
| 86 | |
---|
[109] | 87 | void VirtFILE::setVstdin(VirtFILE *f) {Vstdin=f;} |
---|
| 88 | void VirtFILE::setVstdout(VirtFILE *f) {Vstdout=f;} |
---|
| 89 | void VirtFILE::setVstderr(VirtFILE *f) {Vstderr=f;} |
---|
| 90 | VirtFILE* VirtFILE::getVstdin() {return Vstdin;} |
---|
| 91 | VirtFILE* VirtFILE::getVstdout() {return Vstdout;} |
---|
| 92 | VirtFILE* VirtFILE::getVstderr() {return Vstderr;} |
---|
| 93 | ////////////////////////////////////////////////////////////////////////// |
---|
| 94 | |
---|
[298] | 95 | // base class only returns NULL/false/not supported - implementations perform the actual work |
---|
[301] | 96 | VirtFILE* VirtFileSystem::Vfopen(const char* path,const char* mode) {return NULL;} |
---|
[298] | 97 | bool VirtFileSystem::Vfexists(const char* path) {return false;} |
---|
| 98 | VirtDIR* VirtFileSystem::Vopendir(const char* path) {return NULL;} |
---|
| 99 | bool VirtFileSystem::Vmkdir(const char* path) {return false;} |
---|
[295] | 100 | bool VirtFileSystem::Vdirexists(const char* path,bool is_writable) {return false;} |
---|
[109] | 101 | |
---|
| 102 | ////////////////////////////////////////////////////////////////////////// |
---|
| 103 | |
---|
| 104 | |
---|
| 105 | |
---|
| 106 | int fread(void *ptr, size_t size, size_t nmemb, VirtFILE* f) {return f->Vread(ptr,size,nmemb);} |
---|
| 107 | int fwrite(const void *ptr, size_t size, size_t nmemb, VirtFILE* f) {return f->Vwrite(ptr,size,nmemb);} |
---|
[123] | 108 | |
---|
[131] | 109 | |
---|
| 110 | //since we want our own feof(VirtFILE*) function and some systems unfortunately define feof as a macro, we need to #undef it. Same as in virtfile.h |
---|
[225] | 111 | #if defined _MSC_VER || defined __CYGWIN__ || defined SHP || defined __ANDROID__ |
---|
[131] | 112 | #pragma push_macro("feof") |
---|
[123] | 113 | #undef feof |
---|
| 114 | #endif |
---|
[131] | 115 | #if defined __BORLANDC__ //does not support #pragma push_macro/pop_macro |
---|
| 116 | #undef feof |
---|
| 117 | #endif |
---|
[123] | 118 | |
---|
| 119 | int feof(VirtFILE* f) {return f->Veof();} |
---|
| 120 | |
---|
| 121 | //...and then restore the original macro: |
---|
[225] | 122 | #if defined _MSC_VER || defined __CYGWIN__ || defined SHP || defined __ANDROID__ |
---|
[131] | 123 | #pragma pop_macro("feof") |
---|
| 124 | #endif |
---|
[225] | 125 | #if defined __BORLANDC__ |
---|
[123] | 126 | #define feof(__f) ((__f)->flags & _F_EOF) |
---|
[109] | 127 | #endif |
---|
| 128 | |
---|
[123] | 129 | |
---|
[109] | 130 | int fputc(int c,VirtFILE* f) {return f->Vputc(c);} |
---|
| 131 | int fputs(const char *s,VirtFILE* f) {return f->Vputs(s);} |
---|
| 132 | int fgetc(VirtFILE* f) {return f->Vgetc();} |
---|
| 133 | int fseek(VirtFILE* f,long offset, int whence) {return f->Vseek(offset,whence);} |
---|
| 134 | int ftell(VirtFILE* f) {return f->Vtell();} |
---|
| 135 | void rewind(VirtFILE* f) {f->Vrewind();} |
---|
| 136 | int fflush(VirtFILE* f) {return f->Vflush();} |
---|
| 137 | char *fgets(char *s, int size, VirtFILE* f) {return f->Vgets(s,size);} |
---|
| 138 | int fprintf(VirtFILE* f,const char *format, ...) |
---|
| 139 | { |
---|
| 140 | int ret; va_list argptr; |
---|
| 141 | va_start(argptr,format); |
---|
| 142 | ret=f->Vprintf(format,argptr); |
---|
| 143 | va_end(argptr); |
---|
| 144 | return ret; |
---|
| 145 | } |
---|
| 146 | int fclose(VirtFILE* f) {delete f; return 0;} |
---|
| 147 | |
---|
| 148 | int closedir(VirtDIR* d) {delete d; return 0;} |
---|
| 149 | dirent* readdir(VirtDIR* d) {return d->Vreaddir();} |
---|
[123] | 150 | |
---|
[295] | 151 | ///////// |
---|
| 152 | |
---|
| 153 | bool VirtFileSystem::Vmkdirs(const char* path) |
---|
| 154 | { |
---|
| 155 | if (Vdirexists(path,true)) return true; |
---|
| 156 | string parentdir = getFileDir(path); |
---|
| 157 | if (!Vmkdirs(parentdir.c_str())) return false; |
---|
| 158 | return Vmkdir(path); |
---|
| 159 | } |
---|
| 160 | |
---|
| 161 | ////////// |
---|
| 162 | |
---|
[301] | 163 | |
---|
| 164 | ChainFileSystem::ChainFileSystem(VirtFileSystem *_chain) |
---|
[295] | 165 | { |
---|
[301] | 166 | chain=_chain; |
---|
| 167 | #ifdef DEBUG_DLL_CALLS |
---|
| 168 | printf("ChainFileSystem constructor: %p := %p\n",chain,_chain); |
---|
| 169 | #endif |
---|
| 170 | } |
---|
| 171 | |
---|
| 172 | |
---|
| 173 | VirtFILE *ChainFileSystem::Vfopen(const char* path, const char* mode) |
---|
| 174 | { |
---|
| 175 | #ifdef DEBUG_DLL_CALLS |
---|
| 176 | printf("ChainFileSystem::Vfopen %s %s (chain=%p)\n",path,mode,chain); |
---|
| 177 | #endif |
---|
[295] | 178 | return (chain != NULL) ? chain->Vfopen(path, mode) : NULL; |
---|
| 179 | } |
---|
| 180 | |
---|
| 181 | bool ChainFileSystem::Vfexists(const char* path) |
---|
| 182 | { |
---|
| 183 | return (chain != NULL) ? chain->Vfexists(path) : false; |
---|
| 184 | } |
---|
| 185 | |
---|
| 186 | VirtDIR *ChainFileSystem::Vopendir(const char* path) |
---|
| 187 | { |
---|
[301] | 188 | #ifdef DEBUG_DLL_CALLS |
---|
| 189 | printf("ChainFileSystem::Vfopendir %s (chain=%p)\n",path,chain); |
---|
| 190 | #endif |
---|
[295] | 191 | return (chain != NULL) ? chain->Vopendir(path) : NULL; |
---|
| 192 | } |
---|
| 193 | |
---|
| 194 | bool ChainFileSystem::Vmkdir(const char* path) |
---|
| 195 | { |
---|
| 196 | return (chain != NULL) ? chain->Vmkdir(path) : false; |
---|
| 197 | } |
---|
| 198 | |
---|
| 199 | bool ChainFileSystem::Vmkdirs(const char* path) |
---|
| 200 | { |
---|
| 201 | return (chain != NULL) ? chain->Vmkdirs(path) : false; |
---|
| 202 | } |
---|
| 203 | |
---|
| 204 | bool ChainFileSystem::Vdirexists(const char* path,bool is_writable) |
---|
| 205 | { |
---|
| 206 | return (chain != NULL) ? chain->Vdirexists(path,is_writable) : false; |
---|
| 207 | } |
---|