void w_write_preferences_file( void) { struct wad_header header; /* We can be called atexit. */ if(error_pending()) { set_game_error(systemError, errNone); } assert(!error_pending()); // LP: need to re-create that file to avoid // nonexistence-induced errors in the MacOS version Typecode Type = prefInfo->PrefsFile.GetType(); // Setting to default if _typecode_unknown if (Type == _typecode_unknown) { Type = _typecode_preferences; } // CB: delete old prefs file, we're overwriting it // (writing can go wrong when the old file is still in place) prefInfo->PrefsFile.Delete(); // Re-creating the file // CB: is Create() supposed to truncate the file to zero length // if it already exists? Then the Delete() call above can go away. prefInfo->PrefsFile.Create(Type); OpenedFile PrefsFile; if (open_wad_file_for_writing(prefInfo->PrefsFile,PrefsFile)) { struct directory_entry entry; fill_default_wad_header(prefInfo->PrefsFile, CURRENT_WADFILE_VERSION, CURRENT_PREF_WADFILE_VERSION, 1, 0l, &header); if (write_wad_header(PrefsFile, &header)) { int32 wad_length; int32 offset= sizeof(struct wad_header); /* Length? */ wad_length= calculate_wad_length(&header, prefInfo->wad); /* Set the entry data..... (and put into correct byte-order for writing) */ set_indexed_directory_offset_and_length(&header, &entry, 0, offset, wad_length, 0); /* Now write it.. */ if (write_wad(PrefsFile, &header, prefInfo->wad, offset)) { offset+= wad_length; header.directory_offset= offset; if (write_wad_header(PrefsFile, &header) && write_directorys(PrefsFile, &header, &entry)) { /* Success! */ } else { assert(error_pending()); } } else { assert(error_pending()); } /* Since we don't free it, it is opened.. */ } else { assert(error_pending()); } close_wad_file(PrefsFile); } }
/* preferences pointer.. */ bool w_open_preferences_file( char *PrefName, Typecode Type) { int error = 0; bool success= true; /* allocate space for our global structure to keep track of the prefs file */ prefInfo = NULL; try { prefInfo = new preferences_info; #if defined(mac) prefInfo->PrefsFile.SetParentToPreferences(); prefInfo->PrefsFile.SetName(PrefName,Type); /* check for the preferences folder using FindFolder, creating it if necessary */ #elif defined(SDL) prefInfo->PrefsFile.SetToPreferencesDir(); prefInfo->PrefsFile += PrefName; #endif /* does the preferences file exist? */ load_preferences(); /* Uses prefInfo.. */ if(error_pending()) { short type; error= get_game_error(&type); if(type==systemError) { if (!prefInfo->PrefsFile.Exists()) { prefInfo->PrefsFile.Create(Type); prefInfo->wad = create_empty_wad(); set_game_error(systemError,prefInfo->PrefsFile.GetError()); w_write_preferences_file(); } } else { /* Something was invalid.. */ if (prefInfo->PrefsFile.Delete()) { prefInfo->wad= create_empty_wad(); set_game_error(systemError, error); w_write_preferences_file(); } set_game_error(systemError, errNone); } } } catch (...) { dprintf("In \"catch\""); set_game_error(systemError, memory_error()); } if (error) { /* if something is broken, make sure we at least return valid prefs */ if(prefInfo && !prefInfo->wad) { prefInfo->wad= create_empty_wad(); } } /* Gotta bail... */ if(!prefInfo || !prefInfo->wad) { success= false; } // dump_wad(prefInfo->wad); return success; }
void create_updated_save(QuickSave& save) { // read data from existing save file struct wad_header header; struct wad_data *game_wad, *orig_meta_wad, *new_meta_wad; int32 game_wad_length; std::string imagedata; OpenedFile currentFile; if (save.save_file.Open(currentFile)) { if (read_wad_header(currentFile, &header)) { game_wad = read_indexed_wad_from_file(currentFile, &header, 0, false); if (game_wad) game_wad_length = calculate_wad_length(&header, game_wad); orig_meta_wad = read_indexed_wad_from_file(currentFile, &header, SAVE_GAME_METADATA_INDEX, true); if (orig_meta_wad) { size_t data_length; char *raw_imagedata = (char *)extract_type_from_wad(orig_meta_wad, SAVE_IMG_TAG, &data_length); imagedata = std::string(raw_imagedata, data_length); } } close_wad_file(currentFile); } // create updated save file short err = 0; int32 offset, meta_wad_length; struct directory_entry entries[2]; FileSpecifier TempFile; TempFile.SetTempName(save.save_file); if (create_wadfile(TempFile, _typecode_savegame)) { OpenedFile SaveFile; if(open_wad_file_for_writing(TempFile, SaveFile)) { if (write_wad_header(SaveFile, &header)) { offset = SIZEOF_wad_header; set_indexed_directory_offset_and_length(&header, entries, 0, offset, game_wad_length, 0); if (write_wad(SaveFile, &header, game_wad, offset)) { offset += game_wad_length; header.directory_offset= offset; new_meta_wad = build_meta_game_wad(build_save_metadata(save), imagedata, &header, &meta_wad_length); if (new_meta_wad) { set_indexed_directory_offset_and_length(&header, entries, 1, offset, meta_wad_length, SAVE_GAME_METADATA_INDEX); if (write_wad(SaveFile, &header, new_meta_wad, offset)) { offset += meta_wad_length; header.directory_offset= offset; if (write_wad_header(SaveFile, &header) && write_directorys(SaveFile, &header, entries)) { } } free_wad(new_meta_wad); } } free_wad(game_wad); free_wad(orig_meta_wad); } err = SaveFile.GetError(); close_wad_file(SaveFile); } if (!err) { if (!TempFile.Rename(save.save_file)) { err = 1; } } } if (err || error_pending()) { if (!err) err = get_game_error(NULL); alert_user(infoError, strERRORS, fileError, err); clear_game_error(); } }