bool vic10_expansion_slot_device::call_load() { if (m_card) { size_t size; if (software_entry() == nullptr) { size = length(); if (!core_stricmp(filetype(), "80")) { fread(m_card->m_lorom, 0x2000); if (size == 0x4000) { fread(m_card->m_uprom, 0x2000); } } else if (!core_stricmp(filetype(), "e0")) { fread(m_card->m_uprom, size); } else if (!core_stricmp(filetype(), "crt")) { size_t roml_size = 0; size_t romh_size = 0; int exrom = 1; int game = 1; if (cbm_crt_read_header(m_file, &roml_size, &romh_size, &exrom, &game)) { UINT8 *roml = nullptr; UINT8 *romh = nullptr; m_card->m_lorom.allocate(roml_size); m_card->m_uprom.allocate(romh_size); if (roml_size) roml = m_card->m_lorom; if (romh_size) romh = m_card->m_lorom; cbm_crt_read_data(m_file, roml, romh); } } } else { load_software_region("lorom", m_card->m_lorom); load_software_region("exram", m_card->m_exram); load_software_region("uprom", m_card->m_uprom); } } return IMAGE_INIT_PASS; }
bool vic10_expansion_slot_device::call_load() { if (m_cart) { size_t size = 0; if (software_entry() == NULL) { size = length(); if (!mame_stricmp(filetype(), "80")) { fread(m_cart->vic10_lorom_pointer(machine(), 0x2000), 0x2000); if (size == 0x4000) { fread(m_cart->vic10_uprom_pointer(machine(), 0x2000), 0x2000); } } else if (!mame_stricmp(filetype(), "e0")) fread(m_cart->vic10_uprom_pointer(machine(), size), size); else if (!mame_stricmp(filetype(), "crt")) { size_t roml_size = 0; size_t romh_size = 0; int exrom = 1; int game = 1; if (cbm_crt_read_header(m_file, &roml_size, &romh_size, &exrom, &game)) { UINT8 *roml = NULL; UINT8 *romh = NULL; if (roml_size) roml = m_cart->vic10_lorom_pointer(machine(), roml_size); if (romh_size) romh = m_cart->vic10_uprom_pointer(machine(), romh_size); cbm_crt_read_data(m_file, roml, romh); } } } else { size = get_software_region_length("lorom"); if (size) memcpy(m_cart->vic10_lorom_pointer(machine(), size), get_software_region("lorom"), size); size = get_software_region_length("uprom"); if (size) memcpy(m_cart->vic10_uprom_pointer(machine(), size), get_software_region("uprom"), size); size = get_software_region_length("exram"); if (size) m_cart->vic10_exram_pointer(machine(), size); } } return IMAGE_INIT_PASS; }
/* * Displays file status. */ int main(int argc, char *const argv[]) { struct stat st; readargs(argc, argv); /* Get file status. */ if (stat(filename, &st) < 0) { printf("stat: cannot stat()\n"); return (errno); } /* Print file status. */ printf(" Name: %s\n", filename); printf(" Type: %s\n", filetype(st.st_mode)); printf(" Size: %d bytes\n", (signed)st.st_size); printf(" Inode: %u\n", (unsigned)st.st_ino); printf(" Device: %xh\n", (unsigned)st.st_dev); printf(" Links: %d\n", (signed)st.st_nlink); printf(" Access: %s\n", fileacc(st.st_mode)); printf(" User ID: %d\n", st.st_uid); printf("Group ID: %d\n", st.st_gid); return (EXIT_SUCCESS); }
static int aux_files(lua_State *L) { DIR *d = lua_touserdata(L, lua_upvalueindex(1)); struct dirent *entry; if (d == NULL) luaL_error(L, "attempt to use closed dir"); entry = readdir(d); if (entry == NULL) { closedir(d); lua_pushnil(L); lua_replace(L, lua_upvalueindex(1)); lua_pushnil(L); } else { lua_pushstring(L, entry->d_name); #if 0 #ifdef _DIRENT_HAVE_D_TYPE lua_pushstring(L, filetype(DTTOIF(entry->d_type))); return 2; #endif #endif } return 1; }
void MwIniImporter::importGameFiles(multistrmap &cfg, const multistrmap &ini) const { std::vector<std::string> contentFiles; std::string baseGameFile("Game Files:GameFile"); std::string gameFile(""); multistrmap::const_iterator it = ini.begin(); for(int i=0; it != ini.end(); i++) { gameFile = baseGameFile; gameFile.append(this->numberToString(i)); it = ini.find(gameFile); if(it == ini.end()) { break; } for(std::vector<std::string>::const_iterator entry = it->second.begin(); entry!=it->second.end(); ++entry) { std::string filetype(entry->substr(entry->length()-3)); Misc::StringUtils::toLower(filetype); if(filetype.compare("esm") == 0 || filetype.compare("esp") == 0) { contentFiles.push_back(*entry); } } gameFile = ""; } cfg.erase("content"); cfg.insert( std::make_pair("content", std::vector<std::string>() ) ); for(std::vector<std::string>::const_iterator it=contentFiles.begin(); it!=contentFiles.end(); ++it) { cfg["content"].push_back(*it); } }
int main(int argc, char *argv[]) { struct stat st; if (argc != 2) { fprintf(stderr, "%s: wrong arguments\n", argv[0]); exit(1); } if (lstat(argv[1], &st) < 0) { perror(argv[1]); exit(1); } printf("type\t%o (%s)\n", (st.st_mode & S_IFMT), filetype(st.st_mode)); printf("mode\t%o\n", st.st_mode & ~S_IFMT); printf("dev\t%llu\n", (unsigned long long)st.st_dev); printf("ino\t%lu\n", (unsigned long)st.st_ino); printf("rdev\t%llu\n", (unsigned long long)st.st_rdev); printf("nlink\t%d\n", st.st_nlink); printf("uid\t%d\n", st.st_uid); printf("gid\t%d\n", st.st_gid); printf("size\t%lld\n", st.st_size); printf("blksize\t%lu\n", (unsigned long)st.st_blksize); printf("blocks\t%lu\n", (unsigned long)st.st_blocks); printf("atime\t%s", ctime(&st.st_atime)); printf("mtime\t%s", ctime(&st.st_mtime)); printf("ctime\t%s", ctime(&st.st_ctime)); exit(0); }
int main(int argc, char *argv[]) { if (argc != 2) { fprintf(stderr, "Usage %s file\n", argv[0]); exit(EXIT_FAILURE); } struct stat sbuf; printf("Filename:%s\n", argv[1]); if (lstat(argv[1], &sbuf) == -1) ERR_EXIT("stat error"); printf("File number:major %d,minor %d inode %d\n", MAJOR(sbuf.st_dev), MINOR(sbuf.st_dev), (int)sbuf.st_ino); if (filetype(&sbuf)) { printf("Device number:major %d,minor %d\n", MAJOR(sbuf.st_rdev), MINOR(sbuf.st_rdev)); } char perm[11] = {0}; fileperm(&sbuf, perm); printf("File permission bits=%o %s\n", sbuf.st_mode & 07777, perm); return 0; }
/* * Print sorted down columns */ static void print_by_column(Char *dir, Char *items[], int count) { int i, rows, r, c, maxwidth = 0, columns; if (ioctl(SHOUT, TIOCGWINSZ, (ioctl_t) & win) < 0 || win.ws_col == 0) win.ws_col = 80; for (i = 0; i < count; i++) maxwidth = maxwidth > (r = Strlen(items[i])) ? maxwidth : r; maxwidth += 2; /* for the file tag and space */ columns = win.ws_col / maxwidth; if (columns == 0) columns = 1; rows = (count + (columns - 1)) / columns; for (r = 0; r < rows; r++) { for (c = 0; c < columns; c++) { i = c * rows + r; if (i < count) { int w; (void) fprintf(cshout, "%s", vis_str(items[i])); (void) fputc(dir ? filetype(dir, items[i]) : ' ', cshout); if (c < columns - 1) { /* last column? */ w = Strlen(items[i]) + 1; for (; w < maxwidth; w++) (void) fputc(' ', cshout); } } } (void) fputc('\r', cshout); (void) fputc('\n', cshout); } }
int main(int argc,char **argv) { if(argc!=2) { printf("Usage:%s file \n",argv[0]); exit(EXIT_FAILURE); } struct stat statbuf; printf("file name:%s \n",argv[1]); if(lstat(argv[1],&statbuf)<0) ERR_EXIT("stat"); printf("主设备号(块号):%d,次设备号:%d\n",MAJOR(statbuf.st_dev),MINOR(statbuf.st_dev)); printf("i节点号:%d\n",(int)statbuf.st_ino); printf("硬链接数:%d\n",(int)statbuf.st_nlink); printf("用户名:%s,(%d)\n",getuname(&statbuf),(int)statbuf.st_uid); printf("组名:%s,(%d)\n",getgname(&statbuf),(int)statbuf.st_gid); printf("磁盘id:%d\n",(int)statbuf.st_rdev); printf("文件大小:%d\n",(int)statbuf.st_size); filetype(&statbuf); printf("文件的权限:%o ",statbuf.st_mode & 00777); char permission[11]="----------"; filepermission(&statbuf,permission); printf("%s\n",permission); return 0; }
std::shared_ptr<Sound_Engine::Sound> Sound_Engine::LoadSound(std::string file){ std::string::size_type po = file.find_last_of('\\'); if(po == std::string::npos) po = file.find_last_of('/');// couldnt find it with the double slashes, try a single forward slash if(po == std::string::npos) {// no slashes.. there must be no path on this string so append our asset directory to where the sounds are stored file = Internal::Asset_Dir + "Sound\\" + file; }// else the user specified some sort of directory, so use that instead. std::ifstream f(file.c_str(), std::ios::beg | std::ios::binary); assert(f); // see if the sound data has been loaded already std::map<std::string, std::weak_ptr<Internal::Sub_Sound>>::iterator soundloaded = Internal::LoadedSounds.find(file); if(soundloaded != Internal::LoadedSounds.end()) {// the data exists std::shared_ptr<Internal::Sub_Sound> ptr(soundloaded->second.lock()); if(ptr){// the sound data still exists std::shared_ptr<Sound_Engine::Sound> sound_ptr = std::make_shared<Sound_Engine::Sound>();// create a new source sound_ptr->InternalSound = ptr; Internal::Sources[sound_ptr.get()] = sound_ptr;// insert into the sources return sound_ptr; } } std::shared_ptr<Sound_Engine::Sound> retsound = std::make_shared<Sound_Engine::Sound>(); Internal::Sources[retsound.get()] = retsound; retsound->InternalSound = std::make_shared<Internal::Sub_Sound>(); Internal::LoadedSounds[file]=retsound->InternalSound; retsound->InternalSound->buffer.Flags = XAUDIO2_END_OF_STREAM; // tell the source voice not to expect any data after this buffer DWORD dwChunkSize(0); DWORD dwChunkPosition(0); //check the file type, should be fourccWAVE or 'XWMA' FindChunk(f,fourccRIFF,dwChunkSize, dwChunkPosition ); DWORD filetype(0); ReadChunkData(f, &filetype, sizeof(DWORD), dwChunkPosition); if (filetype != fourccWAVE){ if(filetype != fourccXWMA){ f.close(); OUTPUT_DEBUG_MSG("File is not a .wav, or a xwma file... uh oh"); assert(true); } } FindChunk(f,fourccFMT, dwChunkSize, dwChunkPosition ); ReadChunkData(f, &retsound->InternalSound->wfx, dwChunkSize, dwChunkPosition ); FindChunk(f,fourccDATA,dwChunkSize, dwChunkPosition ); retsound->InternalSound->buffer.AudioBytes = dwChunkSize; //buffer containing audio data BYTE *temp = new BYTE[dwChunkSize]; //size of the audio buffer in bytes retsound->InternalSound->buffer.pAudioData = temp; ReadChunkData(f, temp, dwChunkSize, dwChunkPosition); if(filetype == fourccXWMA){// the file is an xwma file... we need an extra peice of data FindChunk(f,fourccDPDS, dwChunkSize, dwChunkPosition ); // the chunksize is how many bytess there are, so we have to divide by sizeof(uint32t) to get the number of uint32's in the buffer //so chunksize will be like 24, but that is how many bytes, we need 24/4 which is 6. Because there are 6 uint32's retsound->InternalSound->wmaBuffer.PacketCount = dwChunkSize / sizeof(UINT32); UINT32 *temp2 = new UINT32[retsound->InternalSound->wmaBuffer.PacketCount]; ReadChunkData(f, temp2, dwChunkSize, dwChunkPosition); retsound->InternalSound->wmaBuffer.pDecodedPacketCumulativeBytes= temp2; } f.close(); return retsound; }
void snapshot_image_device::timer_callback() { /* invoke the load */ (*m_load)(*this, filetype(), length()); /* unload the device */ unload(); }
bool vic20_expansion_slot_device::call_load() { if (m_cart) { size_t size = 0; if (software_entry() == NULL) { if (!mame_stricmp(filetype(), "20")) fread(m_cart->vic20_blk1_pointer(machine(), 0x2000), 0x2000); else if (!mame_stricmp(filetype(), "40")) fread(m_cart->vic20_blk2_pointer(machine(), 0x2000), 0x2000); else if (!mame_stricmp(filetype(), "60")) fread(m_cart->vic20_blk3_pointer(machine(), 0x2000), 0x2000); else if (!mame_stricmp(filetype(), "70")) fread(m_cart->vic20_blk3_pointer(machine(), 0x2000) + 0x1000, 0x1000); else if (!mame_stricmp(filetype(), "a0")) fread(m_cart->vic20_blk5_pointer(machine(), 0x2000), 0x2000); else if (!mame_stricmp(filetype(), "b0")) fread(m_cart->vic20_blk5_pointer(machine(), 0x2000) + 0x1000, 0x1000); else if (!mame_stricmp(filetype(), "crt")) { // read the header UINT8 header[2]; fread(&header, 2); UINT16 address = pick_integer_le(header, 0, 2); if (LOG) logerror("Address %04x\n", address); switch (address) { case 0x2000: fread(m_cart->vic20_blk1_pointer(machine(), 0x2000), 0x2000); break; case 0x4000: fread(m_cart->vic20_blk2_pointer(machine(), 0x2000), 0x2000); break; case 0x6000: fread(m_cart->vic20_blk3_pointer(machine(), 0x2000), 0x2000); break; case 0x7000: fread(m_cart->vic20_blk3_pointer(machine(), 0x2000) + 0x1000, 0x1000); break; case 0xa000: fread(m_cart->vic20_blk5_pointer(machine(), 0x2000), 0x2000); break; case 0xb000: fread(m_cart->vic20_blk5_pointer(machine(), 0x2000) + 0x1000, 0x1000); break; default: return IMAGE_INIT_FAIL; } } } else { size = get_software_region_length("blk1"); if (size) memcpy(m_cart->vic20_blk1_pointer(machine(), size), get_software_region("blk1"), size); size = get_software_region_length("blk2"); if (size) memcpy(m_cart->vic20_blk2_pointer(machine(), size), get_software_region("blk2"), size); size = get_software_region_length("blk3"); if (size) memcpy(m_cart->vic20_blk3_pointer(machine(), size), get_software_region("blk3"), size); size = get_software_region_length("blk5"); if (size) memcpy(m_cart->vic20_blk5_pointer(machine(), size), get_software_region("blk5"), size); size = get_software_region_length("ram"); if (size) memcpy(m_cart->vic20_ram_pointer(machine(), size), get_software_region("ram"), size); size = get_software_region_length("nvram"); if (size) memcpy(m_cart->vic20_nvram_pointer(machine(), size), get_software_region("nvram"), size); } } return IMAGE_INIT_PASS; }
/* Buffer Function to arrange function parameters*/ int passarray(char* path,http_response_t *response,http_request_t *request,int newfd) { time_date(response); filetype(request,response); filesize(&path,response,request); build_response(request, response); send_response(response,&path,newfd); return 0; }
static int Pstat(lua_State *L) /** stat(path,[selector]) */ { struct mystat s; const char *path=luaL_checkstring(L, 1); if (lstat(path,&s.s)==-1) return pusherror(L, path); s.type=filetype(s.s.st_mode); modechopper(s.s.st_mode, s.mode); return doselection(L, 2, Sstat, Fstat, &s); }
bool cbm2_expansion_slot_device::call_load() { size_t size = 0; if (m_card) { if (software_entry() == NULL) { size = length(); if (!mame_stricmp(filetype(), "20")) { fread(m_card->cbm2_bank1_pointer(machine(), size), size); } else if (!mame_stricmp(filetype(), "40")) { fread(m_card->cbm2_bank2_pointer(machine(), size), size); } else if (!mame_stricmp(filetype(), "60")) { fread(m_card->cbm2_bank3_pointer(machine(), size), size); } } else { size = get_software_region_length("bank1"); if (size) memcpy(m_card->cbm2_bank1_pointer(machine(), size), get_software_region("bank1"), size); size = get_software_region_length("bank2"); if (size) memcpy(m_card->cbm2_bank2_pointer(machine(), size), get_software_region("bank2"), size); size = get_software_region_length("bank3"); if (size) memcpy(m_card->cbm2_bank3_pointer(machine(), size), get_software_region("bank3"), size); size = get_software_region_length("ram"); if (size) memset(m_card->cbm2_ram_pointer(machine(), size), 0, size); size = get_software_region_length("nvram"); if (size) memset(m_card->cbm2_nvram_pointer(machine(), size), 0, size); } } return IMAGE_INIT_PASS; }
/* * Uncompress a file and return the new file name, if the file doesn't * appear to be compressed or the uncompression fails, the original * file name will be returned. In all cases, the return value is * allocated with XtNewString(). * * We use "system()" in here to avoid the hassle of converting the * decompression commands from strings to argv's but this means that * some kludging is needed to grab the error output. This would be * "cleaner" (in some sense) if pipe/dup2/fork/exec/XtAppAddInput * were used instead but sometimes laziness is good. */ char * mgv_unmangle(MGV *m, char *file) { # define CMD_FMT "%s <%s >%s 2>%s" char *cmd, *out, *tmp, *s; int t, cmd_size; MGV_APP *r = mgv_appres(m->main); if((t = filetype(file)) == FT_NORM || (tempdir == NULL && !mk_tmp(r->temp_dir))) return XtNewString(file); if((s = strrchr(file, '/')) == NULL) s = file; else ++s; out = XtCalloc(strlen(tempdir) + 1 + strlen(s) + 1 + 64 + 1, 1); tmp = XtCalloc(strlen(tempdir) + 1 + 64 + 1 + 1, 1); sprintf(out, "%s/%s.%ld.%d", tempdir, s, (long)XtWindow(m->main), m->inst_num); sprintf(tmp, "%s/%ld.%d", tempdir, (long)getpid(), m->inst_num); cmd_size = strlen(file) + strlen(out) + strlen(tmp) + sizeof(CMD_FMT); switch(t) { case FT_GZIP: cmd = XtCalloc(cmd_size + strlen(r->gunzip), 1); sprintf(cmd, "%s <%s >%s 2>%s", r->gunzip, file, out, tmp); break; case FT_BZIP: cmd = XtCalloc(cmd_size + strlen(r->bunzip), 1); sprintf(cmd, "%s <%s >%s 2>%s", r->bunzip, file, out, tmp); break; default: assert("mgv_unmangle(): confused by file type!" != NULL); XtFree(out); XtFree(tmp); return XtNewString(file); break; } errno = 0; if(system(cmd) != 0 && errno != 0) { XtFree(out); out = XtNewString(file); } showmsg(m, file, &tmp[0]); XtFree(tmp); XtFree(cmd); return out; # undef CMD_FMT }
static void catcb(char *dir, char *file,struct stat *stdat,void *ext) { FILE *fp = (FILE *)ext; fprintf(fp, "%d %s %03o n:%d u:%d g:%d s:%llu b:%d ts:%d %s%s%s\n", (int)stdat->st_ino, filetype(stdat->st_mode), stdat->st_mode & ~S_IFMT, (int)stdat->st_nlink, stdat->st_uid, stdat->st_gid, (unsigned long long)stdat->st_size, (int)stdat->st_blocks, (int)stdat->st_mtime, dir, dir[0] ? "/" : "", file); }
static int stat_f( int argc, char **argv) { struct dioattr dio; struct fsxattr fsx, fsxa; struct stat64 st; int verbose = (argc == 2 && !strcmp(argv[1], "-v")); printf(_("fd.path = \"%s\"\n"), file->name); printf(_("fd.flags = %s,%s,%s%s%s%s%s\n"), file->flags & IO_OSYNC ? _("sync") : _("non-sync"), file->flags & IO_DIRECT ? _("direct") : _("non-direct"), file->flags & IO_READONLY ? _("read-only") : _("read-write"), file->flags & IO_REALTIME ? _(",real-time") : "", file->flags & IO_APPEND ? _(",append-only") : "", file->flags & IO_NONBLOCK ? _(",non-block") : "", file->flags & IO_TMPFILE ? _(",tmpfile") : ""); if (fstat64(file->fd, &st) < 0) { perror("fstat64"); } else { printf(_("stat.ino = %lld\n"), (long long)st.st_ino); printf(_("stat.type = %s\n"), filetype(st.st_mode)); printf(_("stat.size = %lld\n"), (long long)st.st_size); printf(_("stat.blocks = %lld\n"), (long long)st.st_blocks); if (verbose) { printf(_("stat.atime = %s"), ctime(&st.st_atime)); printf(_("stat.mtime = %s"), ctime(&st.st_mtime)); printf(_("stat.ctime = %s"), ctime(&st.st_ctime)); } } if (file->flags & IO_FOREIGN) return 0; if ((xfsctl(file->name, file->fd, XFS_IOC_FSGETXATTR, &fsx)) < 0 || (xfsctl(file->name, file->fd, XFS_IOC_FSGETXATTRA, &fsxa)) < 0) { perror("XFS_IOC_FSGETXATTR"); } else { printf(_("fsxattr.xflags = 0x%x "), fsx.fsx_xflags); printxattr(fsx.fsx_xflags, verbose, 0, file->name, 1, 1); printf(_("fsxattr.projid = %u\n"), fsx.fsx_projid); printf(_("fsxattr.extsize = %u\n"), fsx.fsx_extsize); printf(_("fsxattr.nextents = %u\n"), fsx.fsx_nextents); printf(_("fsxattr.naextents = %u\n"), fsxa.fsx_nextents); } if ((xfsctl(file->name, file->fd, XFS_IOC_DIOINFO, &dio)) < 0) { perror("XFS_IOC_DIOINFO"); } else { printf(_("dioattr.mem = 0x%x\n"), dio.d_mem); printf(_("dioattr.miniosz = %u\n"), dio.d_miniosz); printf(_("dioattr.maxiosz = %u\n"), dio.d_maxiosz); } return 0; }
std::string vic10_expansion_slot_device::get_default_card_software() { if (open_image_file(mconfig().options())) { if (!core_stricmp(filetype(), "crt")) return cbm_crt_get_card(m_file); clear(); } return software_get_default_slot("standard"); }
const char * c64_expansion_slot_device::get_default_card_software(const machine_config &config, emu_options &options) { if (open_image_file(options)) { if (!mame_stricmp(filetype(), "crt")) { return cbm_crt_get_card(m_file); } clear(); } return software_get_default_slot(config, options, this, "standard"); }
static PyObject * stat_filemode(PyObject *self, PyObject *omode) { char buf[10]; mode_t mode; mode = _PyLong_AsMode_t(omode); if ((mode == (mode_t)-1) && PyErr_Occurred()) return NULL; buf[0] = filetype(mode); fileperm(mode, &buf[1]); return PyUnicode_FromStringAndSize(buf, 10); }
int main(int argc, char * * argv) { ftype_t in_type, out_type; int in_index, out_index; long bytes = -1; //optional, <0=copy entire file int i; if (argc < 4) { printf("Usage: %s -i <infile> -o <outfile> [optional args]\n" "-i\tInput file\n" "-o\tOutput file\n" "-c\tNumber of bytes to copy\n", argv[0]); for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-i") == 0) { in_index = i + 1; i++; } if (strcmp(argv[i], "-o") == 0) { out_index = i + 1; i++; } if (strcmp(argv[i], "-c") == 0) { bytes = atol(argv[i + 1]); i++; } } } out_type = filetype(argv[out_index]); in_type = filetype(argv[in_index]); printf("Input\tType: %x\tSize: %llub\n", in_type, getsize(argv[in_index], in_type)); printf("Outut\tType: %x\tSize: %llub\n", out_type, getsize(argv[out_index], out_type)); }
void c64_expansion_slot_device::get_default_card_software(astring &result) { if (open_image_file(mconfig().options())) { if (!mame_stricmp(filetype(), "crt")) { cbm_crt_get_card(result, m_file); return; } clear(); } software_get_default_slot(result, "standard"); }
bool cbm2_expansion_slot_device::call_load() { size_t size = 0; if (m_card) { if (software_entry() == NULL) { size = length(); if (!core_stricmp(filetype(), "20")) { m_card->m_bank1.allocate(size); fread(m_card->m_bank1, size); } else if (!core_stricmp(filetype(), "40")) { m_card->m_bank2.allocate(size); fread(m_card->m_bank2, size); } else if (!core_stricmp(filetype(), "60")) { m_card->m_bank3.allocate(size); fread(m_card->m_bank3, size); } } else { load_software_region("bank1", m_card->m_bank1); load_software_region("bank2", m_card->m_bank2); load_software_region("bank3", m_card->m_bank3); } } return IMAGE_INIT_PASS; }
static bool macho_dump_32(char *img, size_t size, lambchop_logger *logger) { char *ptr = img; struct mach_header *hdr; hdr = (struct mach_header*)ptr; ptr += sizeof(struct mach_header); lambchop_debug(logger, "cputype = %s\n", cputype(hdr->cputype)); lambchop_debug(logger, "cpusubtype = 0x%x\n", hdr->cpusubtype); lambchop_debug(logger, "filetype = %s\n", filetype(hdr->filetype)); lambchop_debug(logger, "ncmds = %d\n", hdr->ncmds); lambchop_debug(logger, "sizeofcmds = %d\n", hdr->sizeofcmds); lambchop_debug(logger, "flags = 0x%x\n", hdr->flags); return macho_dump(img, hdr->ncmds, ptr, true, logger); }
image_init_result legacy_floppy_image_device::internal_floppy_device_load(bool is_create, int create_format, util::option_resolution *create_args) { floperr_t err; const struct FloppyFormat *floppy_options; int floppy_flags, i; device_image_interface *image = nullptr; interface(image); /* figure out the floppy options */ floppy_options = m_config->formats; if (is_create) { /* creating an image */ assert(create_format >= 0); err = floppy_create((void *) image, &image_ioprocs, &floppy_options[create_format], create_args, &m_floppy); if (err) goto error; } else { /* opening an image */ floppy_flags = !is_readonly() ? FLOPPY_FLAGS_READWRITE : FLOPPY_FLAGS_READONLY; err = floppy_open_choices((void *) image, &image_ioprocs, filetype(), floppy_options, floppy_flags, &m_floppy); if (err) goto error; } if (floppy_callbacks(m_floppy)->get_heads_per_disk && floppy_callbacks(m_floppy)->get_tracks_per_disk) { floppy_drive_set_geometry_absolute(floppy_get_tracks_per_disk(m_floppy),floppy_get_heads_per_disk(m_floppy)); } /* disk changed */ m_dskchg = CLEAR_LINE; // If we have one of our hacky load procs, call it if (m_load_proc) m_load_proc(*this, is_create); return image_init_result::PASS; error: for (i = 0; i < ARRAY_LENGTH(errmap); i++) { if (err == errmap[i].ferr) seterror(errmap[i].ierr, errmap[i].message); } return image_init_result::FAIL; }
void MwIniImporter::importGameFiles(multistrmap &cfg, multistrmap &ini) { std::vector<std::string> esmFiles; std::vector<std::string> espFiles; std::string baseGameFile("Game Files:GameFile"); std::string gameFile(""); multistrmap::iterator it = ini.begin(); for(int i=0; it != ini.end(); i++) { gameFile = baseGameFile; gameFile.append(this->numberToString(i)); it = ini.find(gameFile); if(it == ini.end()) { break; } for(std::vector<std::string>::iterator entry = it->second.begin(); entry!=it->second.end(); ++entry) { std::string filetype(entry->substr(entry->length()-4, 3)); std::transform(filetype.begin(), filetype.end(), filetype.begin(), ::tolower); if(filetype.compare("esm") == 0) { esmFiles.push_back(*entry); } else if(filetype.compare("esp") == 0) { espFiles.push_back(*entry); } } gameFile = ""; } cfg.erase("master"); cfg.insert( std::make_pair<std::string, std::vector<std::string> > ("master", std::vector<std::string>() ) ); for(std::vector<std::string>::iterator it=esmFiles.begin(); it!=esmFiles.end(); ++it) { cfg["master"].push_back(*it); } cfg.erase("plugin"); cfg.insert( std::make_pair<std::string, std::vector<std::string> > ("plugin", std::vector<std::string>() ) ); for(std::vector<std::string>::iterator it=espFiles.begin(); it!=espFiles.end(); ++it) { cfg["plugin"].push_back(*it); } }
int legacy_floppy_image_device::internal_floppy_device_load(int create_format, util::option_resolution *create_args) { floperr_t err; const struct FloppyFormat *floppy_options; int floppy_flags, i; const char *extension; device_image_interface *image = nullptr; interface(image); /* figure out the floppy options */ floppy_options = m_config->formats; if (has_been_created()) { /* creating an image */ assert(create_format >= 0); err = floppy_create((void *) image, &image_ioprocs, &floppy_options[create_format], create_args, &m_floppy); if (err) goto error; } else { /* opening an image */ floppy_flags = !is_readonly() ? FLOPPY_FLAGS_READWRITE : FLOPPY_FLAGS_READONLY; extension = filetype(); err = floppy_open_choices((void *) image, &image_ioprocs, extension, floppy_options, floppy_flags, &m_floppy); if (err) goto error; } if (floppy_callbacks(m_floppy)->get_heads_per_disk && floppy_callbacks(m_floppy)->get_tracks_per_disk) { floppy_drive_set_geometry_absolute(floppy_get_tracks_per_disk(m_floppy),floppy_get_heads_per_disk(m_floppy)); } /* disk changed */ m_dskchg = CLEAR_LINE; return IMAGE_INIT_PASS; error: for (i = 0; i < ARRAY_LENGTH(errmap); i++) { if (err == errmap[i].ferr) seterror(errmap[i].ierr, errmap[i].message); } return IMAGE_INIT_FAIL; }
void lsdir(char *d, char *b) { struct dir_entry *e; char fn[19]; // Includes null & quotes fn[0]= '"'; while (b) { for (int i=0; i<BLK_SIZE; i+=sizeof(*e)) { e = (struct dir_entry*)(&b[i]); if (e->type) { int size = e->file_size_low + 256*e->file_size_high; trim(&fn[1], e->filename, sizeof(fn)-2); strcat(fn, "\""); printf("%-4d %-18s %s%s (%d,%d) [%d bytes]\n", size, fn, filetype(e->type), filebits(e->type), e->track, e->sector, file_size(d, e->track, e->sector)); } } b = nextblock(d, b); } }
main() { register int i, j = getdtablesize(); struct stat sb; char *filetype(); for (i = 0; i < j; i++) { if (fstat(i, &sb) < 0) continue; fprintf(stderr, "%d: %s, inode #%d, mode %o, dev (%d,%d)", i, filetype(sb.st_mode & S_IFMT), sb.st_ino, sb.st_mode &~ S_IFMT, major(sb.st_dev), minor(sb.st_dev)); if ((sb.st_mode & S_IFMT) == S_IFCHR || (sb.st_mode & S_IFMT) == S_IFBLK) fprintf(stderr, ", rdev (%d, %d)", major(sb.st_rdev), minor(sb.st_rdev)); putc('\n', stderr); } exit(0); }