bool PluginLoader::ParsePlugin(FileSpecifier& file_name) { OpenedFile file; if (file_name.Open(file)) { int32 data_size; file.GetLength(data_size); m_data.resize(data_size); if (file.Read(data_size, &m_data[0])) { file_name.ToDirectory(current_plugin_directory); char name[256]; current_plugin_directory.GetName(name); m_name = name; if (!DoParse()) { logError1("There were parsing errors in %s Plugin.xml\n", m_name.c_str()); } } m_data.clear(); return true; } return false; }
bool XML_Loader_SDL::ParseFile(FileSpecifier &file_name) { // Open file OpenedFile file; if (file_name.Open(file)) { printf ( "Parsing: %s\n", file_name.GetPath() ); // Get file size and allocate buffer file.GetLength(data_size); data = new char[data_size]; // In case there were errors... file_name.GetName(FileName); // Read and parse file if (file.Read(data_size, data)) { if (!DoParse()) { fprintf(stderr, "There were parsing errors in configuration file %s\n", FileName); } } // Delete buffer delete[] data; data = NULL; return true; } else { printf ( "Couldn't open: %s\n", file_name.GetPath() ); } return false; }
void stop_recording( void) { if (replay.game_is_being_recorded) { replay.game_is_being_recorded = false; short player_index; int32 total_length; assert(replay.valid); for (player_index= 0; player_index<dynamic_world->player_count; player_index++) { save_recording_queue_chunk(player_index); } /* Rewrite the header, since it has the new length */ FilmFile.SetPosition(0); byte Header[SIZEOF_recording_header]; pack_recording_header(Header,&replay.header,1); // ZZZ: removing code that does stuff from assert() argument. BUT... // should we really be asserting on this anyway? I mean, the write could fail // in 'normal operation' too, not just when we screwed something up in writing the program? bool successfulWrite = FilmFile.Write(SIZEOF_recording_header,Header); assert(successfulWrite); FilmFile.GetLength(total_length); assert(total_length==replay.header.length); FilmFile.Close(); } replay.valid= false; }
static void import_m1_physics_data() { OpenedFile PhysicsFile; if (!PhysicsFileSpec.Open(PhysicsFile)) { return; } int32 position = 0; int32 length; PhysicsFile.GetLength(length); while (position < length) { std::vector<uint8> header(12); PhysicsFile.Read(header.size(), &header[0]); AIStreamBE header_stream(&header[0], header.size()); uint32 tag; uint16 count; uint16 size; header_stream >> tag; header_stream.ignore(4); // unused header_stream >> count; header_stream >> size; std::vector<uint8> data(count * size); PhysicsFile.Read(data.size(), &data[0]); switch (tag) { case M1_MONSTER_PHYSICS_TAG: unpack_m1_monster_definition(&data[0], count); break; case M1_EFFECTS_PHYSICS_TAG: unpack_m1_effect_definition(&data[0], count); break; case M1_PROJECTILE_PHYSICS_TAG: unpack_m1_projectile_definition(&data[0], count); break; case M1_PHYSICS_PHYSICS_TAG: unpack_m1_physics_constants(&data[0], count); break; case M1_WEAPONS_PHYSICS_TAG: unpack_m1_weapon_definition(&data[0], count); break; } PhysicsFile.GetPosition(position); } }
void *get_network_physics_buffer( int32 *physics_length) { if (physics_file_is_m1()) { bool success = false; uint8 *data = NULL; OpenedFile PhysicsFile; if (PhysicsFileSpec.Open(PhysicsFile) && PhysicsFile.GetLength(*physics_length)) { data = (uint8 *)malloc(*physics_length + 4); SDL_RWops *ops = SDL_RWFromMem(data, *physics_length + 4); success = SDL_WriteBE32(ops, uint32(M1_PHYSICS_MAGIC_COOKIE)); if (success) success = SDL_WriteBE32(ops, uint32(*physics_length)); SDL_RWclose(ops); if (success) success = PhysicsFile.Read(*physics_length, &data[8]); if (!success) free(data); } if (!success) { *physics_length = 0; return NULL; } return data; } short SavedType, SavedError = get_game_error(&SavedType); void *data= get_flat_data(PhysicsFileSpec, false, 0); set_game_error(SavedType, SavedError); if(data) { *physics_length= get_flat_data_length(data); } else { *physics_length= 0; } return data; }
// DJB OpenGL char* parseFile(FileSpecifier& fileSpec) { if (fileSpec == FileSpecifier() || !fileSpec.Exists()) { return NULL; } OpenedFile file; if (!fileSpec.Open(file)) { fprintf(stderr, "%s not found\n", fileSpec.GetPath()); return NULL; } int32 length; file.GetLength(length); char* str = new char[length + 1]; file.Read(length, str); str[length] = 0; return str; }
std::string WadImageCache::image_to_new_name(SDL_Surface *image, int32 *filesize) const { // create name boost::uuids::random_generator gen; boost::uuids::uuid u = gen(); std::string ustr = boost::uuids::to_string(u); FileSpecifier File; File.SetToImageCacheDir(); File.AddPart(ustr); FileSpecifier TempFile; TempFile.SetTempName(File); int ret; //#if defined(HAVE_PNG) && defined(HAVE_SDL_IMAGE) // ret = aoIMG_SavePNG(TempFile.GetPath(), image, IMG_COMPRESS_DEFAULT, NULL, 0); #ifdef HAVE_SDL_IMAGE ret = IMG_SavePNG(image, TempFile.GetPath()); #else ret = SDL_SaveBMP(image, TempFile.GetPath()); #endif if (ret == 0 && TempFile.Rename(File)) { if (filesize) { OpenedFile of; if (File.Open(of)) of.GetLength(*filesize); } return ustr; } if (filesize) *filesize = 0; return ""; }
// Determine file type Typecode FileSpecifier::GetType() { // if there's an extension, assume it's correct const char *extension = strrchr(GetPath(), '.'); if (extension) { extension_mapping *mapping = extensions; while (mapping->extension) { if (( mapping->case_sensitive && (strcmp(extension + 1, mapping->extension) == 0)) || (!mapping->case_sensitive && (strcasecmp(extension + 1, mapping->extension) == 0))) { return mapping->typecode; } ++mapping; } } // Open file OpenedFile f; if (!Open(f)) return _typecode_unknown; SDL_RWops *p = f.GetRWops(); int32 file_length = 0; f.GetLength(file_length); // Check for Sounds file { f.SetPosition(0); uint32 version = SDL_ReadBE32(p); uint32 tag = SDL_ReadBE32(p); if ((version == 0 || version == 1) && tag == FOUR_CHARS_TO_INT('s', 'n', 'd', '2')) return _typecode_sounds; } // Check for Map/Physics file { f.SetPosition(0); int version = SDL_ReadBE16(p); int data_version = SDL_ReadBE16(p); if ((version == 0 || version == 1 || version == 2 || version == 4) && (data_version == 0 || data_version == 1 || data_version == 2)) { SDL_RWseek(p, 68, SEEK_CUR); int32 directory_offset = SDL_ReadBE32(p); if (directory_offset >= file_length) goto not_map; f.SetPosition(128); uint32 tag = SDL_ReadBE32(p); // ghs: I do not believe this list is comprehensive // I think it's just what we've seen so far? switch (tag) { case LINE_TAG: case POINT_TAG: case SIDE_TAG: return _typecode_scenario; break; case MONSTER_PHYSICS_TAG: return _typecode_physics; break; } } not_map: ; } // Check for Shapes file { f.SetPosition(0); for (int i=0; i<32; i++) { uint32 status_flags = SDL_ReadBE32(p); int32 offset = SDL_ReadBE32(p); int32 length = SDL_ReadBE32(p); int32 offset16 = SDL_ReadBE32(p); int32 length16 = SDL_ReadBE32(p); if (status_flags != 0 || (offset != NONE && (offset >= file_length || offset + length > file_length)) || (offset16 != NONE && (offset16 >= file_length || offset16 + length16 > file_length))) goto not_shapes; SDL_RWseek(p, 12, SEEK_CUR); } return _typecode_shapes; not_shapes: ; } // Not identified return _typecode_unknown; }
/* This is gross, (Alain wrote it, not me!) but I don't have time to clean it up */ static bool vblFSRead( OpenedFile& File, int32 *count, void *dest, bool& HitEOF) { int32 fsread_count; bool status = true; assert(replay.fsread_buffer); // LP: way for testing whether hitting end-of-file; // doing that by testing for whether a read was complete. HitEOF = false; if (replay.bytes_in_cache < *count) { assert(replay.bytes_in_cache + *count < int(DISK_CACHE_SIZE)); if (replay.bytes_in_cache) { memcpy(replay.fsread_buffer, replay.location_in_cache, replay.bytes_in_cache); } replay.location_in_cache = replay.fsread_buffer; fsread_count= DISK_CACHE_SIZE - replay.bytes_in_cache; int32 PrevPos; File.GetPosition(PrevPos); int32 replay_left= replay.header.length - PrevPos; if(replay_left < fsread_count) fsread_count= replay_left; if(fsread_count > 0) { assert(fsread_count > 0); // LP: wrapped the routines with some for finding out the file positions; // this finds out how much is read indirectly status = File.Read(fsread_count,replay.fsread_buffer+replay.bytes_in_cache); int32 CurrPos; File.GetPosition(CurrPos); int32 new_fsread_count = CurrPos - PrevPos; int32 FileLen; File.GetLength(FileLen); HitEOF = (new_fsread_count < fsread_count) && (CurrPos == FileLen); fsread_count = new_fsread_count; if(status) replay.bytes_in_cache += fsread_count; } } // If we're still low, then we've consumed the disk cache if(replay.bytes_in_cache < *count) { HitEOF = true; } // Ignore EOF if we still have cache if (HitEOF && replay.bytes_in_cache < *count) { *count= replay.bytes_in_cache; } else { status = true; HitEOF = false; } memcpy(dest, replay.location_in_cache, *count); replay.bytes_in_cache -= *count; replay.location_in_cache += *count; return status; }