void save_artifacts(struct memfile *mf) { /* artiexist and artidisco are arrays of bytes, so writing them in one * go is safe and portable */ mwrite(mf, artiexist, sizeof artiexist); mwrite(mf, artidisco, sizeof artidisco); }
/** * save_regions : */ void save_regions(struct memfile *mf, struct level *lev) { int i, j; unsigned len1, len2; struct region *r; mfmagic_set(mf, REGION_MAGIC); mtag(mf, ledger_no(&lev->z), MTAG_REGION); mwrite32(mf, save_encode_32(moves, moves, moves)); /* timestamp */ mwrite32(mf, lev->n_regions); /* Note: level regions don't have ID numbers, so we can't tag individual regions; instead, diff efficiency depends on the fact that regions tend to stay in the order and are typically inserted or deleted near the end of the list */ for (i = 0; i < lev->n_regions; i++) { r = lev->regions[i]; save_rect(mf, r->bounding_box); mwrite32(mf, r->attach_2_m); mwrite32(mf, r->effect_id); mwrite32(mf, r->arg); mwrite16(mf, r->nrects); for (j = 0; j < r->nrects; j++) save_rect(mf, r->rects[j]); mwrite16(mf, r->ttl); mwrite16(mf, r->expire_f); mwrite16(mf, r->can_enter_f); mwrite16(mf, r->enter_f); mwrite16(mf, r->can_leave_f); mwrite16(mf, r->leave_f); mwrite16(mf, r->inside_f); mwrite16(mf, r->n_monst); mwrite8(mf, r->player_flags); mwrite8(mf, r->attach_2_u); mwrite8(mf, r->visible); for (j = 0; j < r->n_monst; j++) mwrite32(mf, r->monsters[j]); len1 = r->enter_msg ? strlen(r->enter_msg) + 1 : 0; mwrite16(mf, len1); len2 = r->leave_msg ? strlen(r->leave_msg) + 1 : 0; mwrite16(mf, len2); if (len1 > 0) mwrite(mf, r->enter_msg, len1); if (len2 > 0) mwrite(mf, r->leave_msg, len2); } }
void write_info(unsigned int addr, block_info towrite){ uint8_t n4 = block_info.next_addr % (1<<8); block_info.next_addr = block_info.next_addr>>8; uint8_t n3 = block_info.next_addr % (1<<8); block_info.next_addr = block_info.next_addr >>8; uint8_t n2 = block_info.next_addr % (1<<8); block_info.next_addr = block_info.next_addr >>8; uint8_t n1 = block_info.next_addr % (1<<8); uint8_t e4 = block_info.addr_end % (1<<8); block_info.addr_end = block_info.addr_end>>8; uint8_t e3 = block_info.addr_end % (1<<8); block_info.addr_end = block_info.addr_end >>8; uint8_t e2 = block_info.addr_end % (1<<8); block_info.addr_end = block_info.addr_end >>8; uint8_t e1 = block_info.addr_end % (1<<8); mwrite( addr , b1 ); mwrite( addr+1 , b2 ); mwrite( addr+2 , b3 ); mwrite( addr+3 , b4 ); mwrite( addr+4 , e1 ); mwrite( addr+5 , e2 ); mwrite( addr+6 , e3 ); mwrite( addr+7 , e4 ); }
void mwrite64(struct memfile *mf, int64_t value) { int64_t le_value = host_to_le64(value); mwrite(mf, &le_value, 8); }
void mwrite32(struct memfile *mf, int32_t value) { int32_t le_value = host_to_le32(value); mwrite(mf, &le_value, 4); }
void mwrite16(struct memfile *mf, int16_t value) { int16_t le_value = host_to_le16(value); mwrite(mf, &le_value, 2); }
int main() { mount("volume2.vfs"); ls(); touch("ppg"); ls(); int fd; fd = mopen("ppg"); char *out = mread(fd); printf(out); mclose(fd); fd = mopen("ppg"); mwrite(fd, "spider man!"); mclose(fd); fd = mopen("ppg"); out = mread(fd); printf(out); mclose(fd); ls(); touch("hello.c"); ls(); fd = mopen("hello.c"); out = mread(fd); printf(out); mclose(fd); fd = mopen("hello.c"); mwrite(fd, "hello\nworld!\n"); mclose(fd); fd = mopen("hello.c"); out = mread(fd); mclose(fd); fd = mopen("ppg"); out = mread(fd); printf(out); mclose(fd); umount(); return 0; }
static void savelevchn(struct memfile *mf) { s_level *tmplev; int cnt = 0; for (tmplev = sp_levchn; tmplev; tmplev = tmplev->next) cnt++; mwrite32(mf, cnt); for (tmplev = sp_levchn; tmplev; tmplev = tmplev->next) { save_d_flags(mf, tmplev->flags); mwrite(mf, &tmplev->dlevel, sizeof(tmplev->dlevel)); mwrite(mf, tmplev->proto, sizeof(tmplev->proto)); mwrite8(mf, tmplev->boneid); mwrite8(mf, tmplev->rndlevs); } }
/** * Inicializacia pamate * * Zavola sa, v stave, ked sa zacina s prazdnou pamatou, ktora je inicializovana * na 0. */ void my_init(void) { //split 32-bit int 4 bytes unsigned int total_size = msize(); uint8_t size_part_4 = total_size % (1<<8); total_size = total_size>>8; uint8_t size_part_3 = total_size % (1<<8); total_size = total_size>>8; uint8_t size_part_2 = total_size % (1<<8); total_size = total_size>>8; uint8_t size_part_1 = total_size % (1<<8); // 0..3 bytes -> total memory mwrite(0,size_part_1); mwrite(1,size_part_2); mwrite(2,size_part_3); mwrite(3,size_part_4); return; }
static void save_flags(struct memfile *mf) { mwrite32(mf, flags.ident); mwrite32(mf, flags.moonphase); mwrite32(mf, flags.no_of_wizards); mwrite32(mf, flags.init_role); mwrite32(mf, flags.init_race); mwrite32(mf, flags.init_gend); mwrite32(mf, flags.init_align); mwrite32(mf, flags.randomall); mwrite32(mf, flags.pantheon); mwrite32(mf, flags.run); mwrite32(mf, flags.warntype); mwrite32(mf, flags.warnlevel); mwrite32(mf, flags.djinni_count); mwrite32(mf, flags.ghost_count); mwrite32(mf, flags.pickup_burden); mwrite8(mf, flags.autodig); mwrite8(mf, flags.autoquiver); mwrite8(mf, flags.beginner); mwrite8(mf, flags.confirm); mwrite8(mf, flags.debug); mwrite8(mf, flags.explore); mwrite8(mf, flags.female); mwrite8(mf, flags.forcefight); mwrite8(mf, flags.friday13); mwrite8(mf, flags.legacy); mwrite8(mf, flags.lit_corridor); mwrite8(mf, flags.made_amulet); mwrite8(mf, flags.mon_moving); mwrite8(mf, flags.move); mwrite8(mf, flags.mv); mwrite8(mf, flags.nopick); mwrite8(mf, flags.null); mwrite8(mf, flags.pickup); mwrite8(mf, flags.pushweapon); mwrite8(mf, flags.rest_on_space); mwrite8(mf, flags.safe_dog); mwrite8(mf, flags.silent); mwrite8(mf, flags.sortpack); mwrite8(mf, flags.soundok); mwrite8(mf, flags.sparkle); mwrite8(mf, flags.tombstone); mwrite8(mf, flags.verbose); mwrite8(mf, flags.prayconfirm); mwrite8(mf, flags.travel); mwrite8(mf, flags.end_disclose); mwrite8(mf, flags.menu_style); mwrite8(mf, flags.elbereth_enabled); mwrite8(mf, flags.rogue_enabled); mwrite8(mf, flags.seduce_enabled); mwrite8(mf, flags.bones_enabled); mwrite(mf, flags.inv_order, sizeof(flags.inv_order)); }
int fast_write(MFILE *mfp, char *buf, size_t buf_len) { int wr = mwrite(mfp, buf, buf_len); if (wr != 1) { mclose(mfp); mfp = NULL; return 0; } return wr; }
void child(char n, int fd0,int fds) { int i,j; for (i=0; i< turns; i++) { for (j=0; j<fds; j++) { mwrite(n, fd0+(j*(n+1))%fds ); } } exit(0); }
static void savegamestate(struct memfile *mf) { unsigned book_id; mtag(mf, 0, MTAG_GAMESTATE); mfmagic_set(mf, STATE_MAGIC); /* must come before migrating_objs and migrating_mons are freed */ save_timers(mf, level, RANGE_GLOBAL); save_light_sources(mf, level, RANGE_GLOBAL); saveobjchn(mf, invent); savemonchn(mf, migrating_mons); save_mvitals(mf); save_quest_status(mf); save_spellbook(mf); save_artifacts(mf); save_oracles(mf); mwrite(mf, pl_character, sizeof pl_character); mwrite(mf, pl_fruit, sizeof pl_fruit); mwrite32(mf, current_fruit); savefruitchn(mf); savenames(mf); save_waterlevel(mf); mwrite32(mf, lastinvnr); save_mt_state(mf); save_track(mf); save_food(mf); save_steal(mf); save_dig_status(mf); book_id = book ? book->o_id : 0; mwrite32(mf, book_id); mwrite32(mf, stetho_last_used_move); mwrite32(mf, stetho_last_used_movement); mwrite32(mf, multi); save_rndmonst_state(mf); save_history(mf); }
void save_obj(struct memfile *mf, struct obj *obj) { unsigned int oflags; oflags = (obj->cursed << 31) | (obj->blessed << 30) | (obj->unpaid << 29) | (obj->no_charge << 28) | (obj->known << 27) | (obj->dknown << 26) | (obj->bknown << 25) | (obj->rknown << 24) | (obj->oeroded << 22) | (obj->oeroded2 << 20) | (obj->oerodeproof << 19) | (obj->olocked << 18) | (obj->obroken << 17) | (obj->otrapped << 16) | (obj->recharged << 13) | (obj->lamplit << 12) | (obj->greased << 11) | (obj->oattached << 9) | (obj->in_use << 8) | (obj->was_thrown << 7) | (obj->bypass << 6); mfmagic_set(mf, OBJ_MAGIC); mwrite32(mf, obj->onamelth); mwrite32(mf, obj->o_id); mwrite32(mf, obj->owt); mwrite32(mf, obj->quan); mwrite32(mf, obj->corpsenm); mwrite32(mf, obj->oeaten); mwrite32(mf, obj->age); mwrite32(mf, obj->owornmask); mwrite32(mf, oflags); mwrite16(mf, obj->otyp); mwrite8(mf, obj->ox); mwrite8(mf, obj->oy); mwrite8(mf, obj->spe); mwrite8(mf, obj->oclass); mwrite8(mf, obj->invlet); mwrite8(mf, obj->oartifact); mwrite8(mf, obj->where); mwrite8(mf, obj->timed); /* no need to save the value of the cobj pointer, but we will need to know * if there is something in here that needs to be restored */ mwrite8(mf, obj->cobj ? 1 : 0); if (obj->onamelth) mwrite(mf, ONAME(obj), obj->onamelth); if (obj->oattached == OATTACHED_MONST) save_mon(mf, (struct monst*)obj->oextra); else if (obj->oattached == OATTACHED_M_ID) mwrite32(mf, *(unsigned int*)obj->oextra); }
template <class T> bool Write (const Matrix<T>& M, const std::string& uri = "") { assert (m_file != NULL); dtype dt = CODTraits<T>::dt; size_t n, l; // Dump type if (!mwrite(&dt, 1, m_file, "data type")) return false; n = M.NDim(); if (!mwrite(&n, 1, m_file, "data dimensions")) return false; // Dump dimensions if (!mwrite(M.Dim(), m_file, "dimensions")) return false; // Dump resolutions if (!mwrite(M.Res(), m_file, "resolutions")) return false; // Size of name and name n = uri.size(); if (!mwrite(&n, 1, m_file, "name length")) return false; // Dump name if (!mwrite(uri.c_str(), n, m_file, "name")) return false; // Dump data if (!mwrite(M.Container(), m_file, "data")) return false; if (!mwrite(delim.c_str(), delim.length(), m_file, "delimiter")) return false; return true; }
void save_history(struct memfile *mf) { int i, len; mfmagic_set(mf, HISTORY_MAGIC); mtag(mf, 0, MTAG_HISTORY); mwrite32(mf, histcount); /* don't need tags for individual history events, because they're always added at the end of the list */ for (i = 0; i < histcount; i++) { mwrite32(mf, histevents[i].when); mwrite32(mf, histevents[i].hidden); len = strlen(histevents[i].what) + 1; mwrite32(mf, len); mwrite(mf, histevents[i].what, len); } }
/* save all the fruit names and ID's; this is used only in saving whole games * (not levels) and in saving bones levels. When saving a bones level, * we only want to save the fruits which exist on the bones level; the bones * level routine marks nonexistent fruits by making the fid negative. */ void savefruitchn(struct memfile *mf) { struct fruit *f1; unsigned int count = 0; mfmagic_set(mf, FRUITCHAIN_MAGIC); for (f1 = ffruit; f1; f1 = f1->nextf) if (f1->fid >= 0) count++; mwrite32(mf, count); for (f1 = ffruit; f1; f1 = f1->nextf) { if (f1->fid >= 0) { mwrite(mf, f1->fname, sizeof(f1->fname)); mwrite32(mf, f1->fid); } } }
/* * save_worm() * * Save the worm information for later use. The count is the number * of segments, including the dummy. Called from save.c. */ void save_worm(struct memfile *mf, struct level *lev) { int i, count; struct wseg *curr; for (i = 1; i < MAX_NUM_WORMS; i++) { for (count = 0, curr = lev->wtails[i]; curr; curr = curr->nseg) count++; /* Save number of segments */ mwrite(mf, &count, sizeof(int)); /* Save segment locations of the monster. */ if (count) { for (curr = lev->wtails[i]; curr; curr = curr->nseg) { mwrite8(mf, curr->wx); mwrite8(mf, curr->wy); } mwrite32(mf, lev->wgrowtime[i]); } } }
int main() { // Remote location struct in_addr server_addr; inet_aton(IP, &server_addr); int server_port = htons(PORT); fileloc_t location; location.ipaddress = server_addr; location.port = server_port; location.pathname = FILENAME; // Memory map remote file at offset 0 void *address = rmmap(location, 0); if (address == (void*) -1) { printf("Something didn't go very well\n"); exit(-1); } // Write 1024 bytes to memory mapped region ssize_t length = 1024; char buff[length]; if (mwrite(address, 0, buff, length) != length) { printf("Something doesn't seem right\n"); rmunmap(address); exit(-1); } // All done, clear memory mapping and exit if (!rmunmap(address)) { printf("Couldn't clear memory mapped region\n"); exit(-1); } return 1; }
void mwrite8(struct memfile *mf, int8_t value) { mwrite(mf, &value, 1); }
void savelev(struct memfile *mf, xchar levnum) { int x, y; unsigned int lflags; struct level *lev = levels[levnum]; if (iflags.purge_monsters) { /* purge any dead monsters (necessary if we're starting * a panic save rather than a normal one, or sometimes * when changing levels without taking time -- e.g. * create statue trap then immediately level teleport) */ dmonsfree(lev); } mfmagic_set(mf, LEVEL_MAGIC); mwrite8(mf, lev->z.dnum); mwrite8(mf, lev->z.dlevel); mwrite(mf, lev->levname, sizeof(lev->levname)); for (x = 0; x < COLNO; x++) for (y = 0; y < ROWNO; y++) save_location(mf, &lev->locations[x][y]); mwrite32(mf, lev->lastmoves); mwrite(mf, &lev->upstair, sizeof(stairway)); mwrite(mf, &lev->dnstair, sizeof(stairway)); mwrite(mf, &lev->upladder, sizeof(stairway)); mwrite(mf, &lev->dnladder, sizeof(stairway)); mwrite(mf, &lev->sstairs, sizeof(stairway)); mwrite(mf, &lev->updest, sizeof(dest_area)); mwrite(mf, &lev->dndest, sizeof(dest_area)); mwrite8(mf, lev->flags.nfountains); mwrite8(mf, lev->flags.nsinks); lflags = (lev->flags.has_shop << 31) | (lev->flags.has_vault << 30) | (lev->flags.has_zoo << 29) | (lev->flags.has_court << 28) | (lev->flags.has_morgue << 27) | (lev->flags.has_beehive << 26) | (lev->flags.has_barracks << 25) | (lev->flags.has_temple << 24) | (lev->flags.has_swamp << 23) | (lev->flags.noteleport << 22) | (lev->flags.hardfloor << 21) | (lev->flags.nommap << 20) | (lev->flags.hero_memory << 19) | (lev->flags.shortsighted << 18) | (lev->flags.graveyard << 17) | (lev->flags.is_maze_lev << 16) | (lev->flags.is_cavernous_lev << 15) | (lev->flags.arboreal << 14) | (lev->flags.forgotten << 13); mwrite32(mf, lflags); mwrite(mf, lev->doors, sizeof(lev->doors)); save_rooms(mf, lev); /* no dynamic memory to reclaim */ /* must be saved before mons, objs, and buried objs */ save_timers(mf, lev, RANGE_LEVEL); save_light_sources(mf, lev, RANGE_LEVEL); savemonchn(mf, lev->monlist); save_worm(mf, lev); /* save worm information */ savetrapchn(mf, lev->lev_traps); saveobjchn(mf, lev->objlist); saveobjchn(mf, lev->buriedobjlist); saveobjchn(mf, lev->billobjs); save_engravings(mf, lev); savedamage(mf, lev); save_regions(mf, lev); }