static bool ParseProfilesDir()
{
if(!dir)
return false;
char *ext;
struct dirent *entry = NULL;
int i = 0;
while(i < MAX_BROWSER_SIZE)
{
entry = readdir(dir);
if(entry == NULL)
break;
if(entry->d_name[0] == '.' && entry->d_name[1] != '.')
continue;
if(strcmp(entry->d_name, "..") == 0)
continue;
if(entry->d_type==DT_DIR) continue;
ext = GetExt(entry->d_name);
if(ext == NULL || stricmp(ext, "wtp") != 0)
continue;
if(!AddBrowserEntry())
{
break;
}
snprintf(browserList[browser.numEntries+i].filename, MAXJOLIET, "%s", entry->d_name);
StripExt(browserList[browser.numEntries+i].displayname, browserList[browser.numEntries+i].filename); // hide file extension
i++;
}
// Sort the file list
if(i >= 0)
qsort(browserList, browser.numEntries+i, sizeof(BROWSERENTRY), FileSortCallback);
browser.numEntries += i;
if(entry == NULL)
{
closedir(dir); // close directory
dir = NULL;
return false; // no more entries
}
return true; // more entries
}
static void InsertFile(LIST **r, char *name, char *ext)
{
char buf[256], *newbuffer;
LIST *lst;
strcpy(buf, name);
if (!outputFileName[0])
{
strcpy(outputFileName, name);
StripExt(outputFileName);
strcat(outputFileName, ".exe");
}
if (ext)
{
StripExt(buf);
strcat(buf, ext);
}
lst = *r;
while (lst)
{
if (!strcasecmp(lst->data, buf))
return;
lst = lst->next;
}
newbuffer = (char*)malloc(strlen(buf) + 1);
if (!newbuffer)
return ;
strcpy(newbuffer, buf);
/* Insert file */
while (*r)
r = &(*r)->next;
*r = malloc(sizeof(LIST));
if (!r)
return ;
(*r)->next = 0;
(*r)->data = newbuffer;
}
void setfile(char *buf, char *orgbuf, char *ext)
/*
* Get rid of a file path an add an extension to the file name
*/
{
char *p = strrchr(orgbuf, '\\');
if (!p)
p = orgbuf;
else
p++;
strcpy(buf, p);
StripExt(buf);
AddExt(buf, ext);
}
/****************************************************************************
* ParseMCDirectory
*
* Parses a list of all files on the specified memory card
***************************************************************************/
int
ParseMCDirectory (int slot)
{
card_dir CardDir;
int CardError;
int entryNum = 0;
// Try to mount the card
CardError = MountMC(slot, NOTSILENT);
if (CardError == 0)
{
CardError = CARD_FindFirst (slot, &CardDir, TRUE);
while (CardError != CARD_ERROR_NOFILE)
{
BROWSERENTRY * newBrowserList = (BROWSERENTRY *)realloc(browserList, (entryNum+1) * sizeof(BROWSERENTRY));
if(!newBrowserList) // failed to allocate required memory
{
ResetBrowser();
ErrorPrompt("Out of memory: too many files!");
entryNum = -1;
break;
}
else
{
browserList = newBrowserList;
}
memset(&(browserList[entryNum]), 0, sizeof(BROWSERENTRY)); // clear the new entry
strncpy(browserList[entryNum].filename, (char *)CardDir.filename, MAXJOLIET);
StripExt(browserList[entryNum].displayname, browserList[entryNum].filename); // hide file extension
browserList[entryNum].length = CardDir.filelen;
entryNum++;
CardError = CARD_FindNext (&CardDir);
}
CARD_Unmount(slot);
}
// Sort the file list
qsort(browserList, entryNum, sizeof(BROWSERENTRY), FileSortCallback);
CancelAction();
browser.numEntries = entryNum;
return entryNum;
}
/****************************************************************************
* BrowserLoadFile
*
* Loads the selected ROM
***************************************************************************/
int BrowserLoadFile()
{
int loaded = 0;
int device;
if(!FindDevice(browser.dir, &device))
return 0;
// check that this is a valid ROM
if(!IsValidROM())
goto done;
// store the filename (w/o ext) - used for sram/freeze naming
StripExt(Memory.ROMFilename, browserList[browser.selIndex].filename);
snprintf(GCSettings.LastFileLoaded, MAXPATHLEN, "%s", browserList[browser.selIndex].filename);
strncpy(Memory.ROMFilePath, browser.dir, PATH_MAX);
SNESROMSize = 0;
S9xDeleteCheats();
Memory.LoadROM("ROM");
if (SNESROMSize == 0)
{
ErrorPrompt("Error loading game!");
}
else if(bsxBiosLoadFailed) {
ErrorPrompt("BS-X BIOS file not found!");
}
else
{
// load SRAM or snapshot
if (GCSettings.AutoLoad == 1)
LoadSRAMAuto(SILENT);
else if (GCSettings.AutoLoad == 2)
LoadSnapshotAuto(SILENT);
ResetBrowser();
loaded = 1;
}
done:
CancelAction();
return loaded;
}
/****************************************************************************
* BrowserLoadFile
*
* Loads the selected ROM
***************************************************************************/
int BrowserLoadFile()
{
char path[MAXPATHLEN + 1];
int loaded = 0;
int device;
if(!FindDevice(browser.dir, &device))
return 0;
// store the filename (w/o ext) - used for sram/freeze naming
StripExt(ROMFilename, browserList[browser.selIndex].filename);
strcpy(loadedFile, browserList[browser.selIndex].filename);
snprintf(path, MAXPATHLEN, "%s%s", browser.dir, browserList[browser.selIndex].filename);
EmuPrepareLaunch(path);
loaded = 1;
done:
CancelAction();
return loaded;
}
/****************************************************************************
* BrowserLoadFile
*
* Loads the selected ROM
***************************************************************************/
int BrowserLoadFile()
{
int loaded = 0;
int device;
if(!FindDevice(browser.dir, &device))
return 0;
GetFileSize(browser.selIndex);
// check that this is a valid ROM
if(!IsValidROM())
goto done;
// store the filename (w/o ext) - used for sram/freeze naming
StripExt(Memory.ROMFilename, browserList[browser.selIndex].filename);
strcpy(loadedFile, browserList[browser.selIndex].filename);
SNESROMSize = 0;
S9xDeleteCheats();
Memory.LoadROM("ROM");
if (SNESROMSize <= 0)
{
ErrorPrompt("Error loading game!");
}
else
{
// load SRAM or snapshot
if (GCSettings.AutoLoad == 1)
LoadSRAMAuto(SILENT);
else if (GCSettings.AutoLoad == 2)
LoadSnapshotAuto(SILENT);
ResetBrowser();
loaded = 1;
}
done:
CancelAction();
return loaded;
}
/****************************************************************************
* BrowserLoadFile
*
* Loads the selected ROM
***************************************************************************/
int BrowserLoadFile()
{
int device;
if(!FindDevice(browser.dir, &device))
return 0;
// store the filename (w/o ext) - used for sram/freeze naming
StripExt(ROMFilename, browserList[browser.selIndex].filename);
snprintf(GCSettings.LastFileLoaded, MAXPATHLEN, "%s", browserList[browser.selIndex].filename);
loadingFile = true;
ROMLoaded = LoadVBAROM();
loadingFile = false;
if (!ROMLoaded)
{
if(inSz)
{
browser.selIndex = 0;
BrowserChangeFolder();
}
ErrorPrompt("Error loading game!");
}
else
{
if (GCSettings.AutoLoad == 1)
LoadBatteryOrStateAuto(FILE_SRAM, SILENT);
else if (GCSettings.AutoLoad == 2)
LoadBatteryOrStateAuto(FILE_SNAPSHOT, SILENT);
ResetBrowser();
}
CancelAction();
return ROMLoaded;
}
/****************************************************************************
* FileSelector
*
* Let user select a file from the listing
****************************************************************************/
int FileSelector (int method)
{
u32 p = 0;
u32 wp = 0;
u32 ph = 0;
u32 wh = 0;
signed char gc_ay = 0;
signed char gc_sx = 0;
signed char wm_ay = 0;
signed char wm_sx = 0;
int haverom = 0;
int redraw = 1;
int selectit = 0;
int scroll_delay = 0;
bool move_selection = 0;
#define SCROLL_INITIAL_DELAY 15
#define SCROLL_LOOP_DELAY 2
while (haverom == 0)
{
if (redraw)
ShowFiles (filelist, maxfiles, offset, selection);
redraw = 0;
VIDEO_WaitVSync(); // slow things down a bit so we don't overread the pads
gc_ay = PAD_StickY (0);
gc_sx = PAD_SubStickX (0);
p = PAD_ButtonsDown (0);
ph = PAD_ButtonsHeld (0);
#ifdef HW_RVL
wm_ay = WPAD_StickY (0, 0);
wm_sx = WPAD_StickX (0, 1);
wp = WPAD_ButtonsDown (0);
wh = WPAD_ButtonsHeld (0);
#endif
/*** Check for exit combo ***/
if ( (gc_sx < -70) || (wm_sx < -70) || (wp & WPAD_BUTTON_HOME) || (wp & WPAD_CLASSIC_BUTTON_HOME) )
return 0;
/*** Check buttons, perform actions ***/
if ( (p & PAD_BUTTON_A) || selectit || (wp & (WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A)) )
{
if ( selectit )
selectit = 0;
if (filelist[selection].flags) // This is directory
{
/* update current directory and set new entry list if directory has changed */
int status = UpdateDirName(method);
if (status == 1) // ok, open directory
{
switch (method)
{
case METHOD_SD:
case METHOD_USB:
maxfiles = ParseFATdirectory(method);
break;
case METHOD_DVD:
maxfiles = ParseDVDdirectory();
break;
case METHOD_SMB:
maxfiles = ParseSMBdirectory();
break;
}
if (!maxfiles)
{
WaitPrompt ((char*) "Error reading directory !");
haverom = 1; // quit menu
}
}
else if (status == -1) // directory name too long
{
haverom = 1; // quit menu
}
}
else // this is a file
{
// store the filename (w/o ext) - used for state saving
StripExt(romFilename, filelist[selection].filename);
ShowAction ((char *)"Loading...");
switch (method)
{
case METHOD_SD:
case METHOD_USB:
LoadFATFile (filelist[selection].filename,
filelist[selection].length);
break;
case METHOD_DVD:
dvddir = filelist[selection].offset;
dvddirlength = filelist[selection].length;
LoadDVDFile (nesromptr);
break;
case METHOD_SMB:
LoadSMBFile (filelist[selection].filename,
filelist[selection].length);
break;
}
if (GCMemROM() >= 0)
{
//hasloaded = 1; // indicator for memmap.cpp
//Memory.LoadROM ("BLANK.SMC");
//Memory.LoadSRAM ("BLANK");
//haverom = 1;
return 1;
}
else
{
WaitPrompt((char*) "Error loading ROM!");
}
}
redraw = 1;
} // End of A
if ( (p & PAD_BUTTON_B) || (wp & (WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B)) )
{
while ( (PAD_ButtonsDown(0) & PAD_BUTTON_B)
#ifdef HW_RVL
|| (WPAD_ButtonsDown(0) & (WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B))
#endif
)
VIDEO_WaitVSync();
if ( strcmp(filelist[0].filename,"..") == 0 )
{
selection = 0;
selectit = 1;
}
else if ( strcmp(filelist[1].filename,"..") == 0 )
{
selection = selectit = 1;
} else {
return 0;
}
} // End of B
if ( ((p | ph) & PAD_BUTTON_DOWN) || ((wp | wh) & (WPAD_BUTTON_DOWN | WPAD_CLASSIC_BUTTON_DOWN)) || (gc_ay < -PADCAL) || (wm_ay < -PADCAL) )
{
if ( (p & PAD_BUTTON_DOWN) || (wp & (WPAD_BUTTON_DOWN | WPAD_CLASSIC_BUTTON_DOWN)) ) { /*** Button just pressed ***/
scroll_delay = SCROLL_INITIAL_DELAY; // reset scroll delay.
move_selection = 1; //continue (move selection)
}
else if (scroll_delay == 0) { /*** Button is held ***/
scroll_delay = SCROLL_LOOP_DELAY;
move_selection = 1; //continue (move selection)
} else {
scroll_delay--; // wait
}
if (move_selection)
{
selection++;
if (selection == maxfiles)
selection = offset = 0;
if ((selection - offset) >= PAGESIZE)
offset += PAGESIZE;
redraw = 1;
move_selection = 0;
}
} // End of down
if ( ((p | ph) & PAD_BUTTON_UP) || ((wp | wh) & (WPAD_BUTTON_UP | WPAD_CLASSIC_BUTTON_UP)) || (gc_ay > PADCAL) || (wm_ay > PADCAL) )
{
if ( (p & PAD_BUTTON_UP) || (wp & (WPAD_BUTTON_UP | WPAD_CLASSIC_BUTTON_UP)) ) { /*** Button just pressed***/
scroll_delay = SCROLL_INITIAL_DELAY; // reset scroll delay.
move_selection = 1; //continue (move selection)
}
else if (scroll_delay == 0) { /*** Button is held ***/
scroll_delay = SCROLL_LOOP_DELAY;
move_selection = 1; //continue (move selection)
} else {
scroll_delay--; // wait
}
if (move_selection)
{
selection--;
if (selection < 0) {
selection = maxfiles - 1;
offset = selection - PAGESIZE + 1;
}
if (selection < offset)
offset -= PAGESIZE;
if (offset < 0)
offset = 0;
redraw = 1;
move_selection = 0;
}
} // End of Up
if ( (p & PAD_BUTTON_LEFT) || (wp & (WPAD_BUTTON_LEFT | WPAD_CLASSIC_BUTTON_LEFT)) )
{
/*** Go back a page ***/
selection -= PAGESIZE;
if (selection < 0)
{
selection = maxfiles - 1;
offset = selection - PAGESIZE + 1;
}
if (selection < offset)
offset -= PAGESIZE;
if (offset < 0)
offset = 0;
redraw = 1;
}
if ( (p & PAD_BUTTON_RIGHT) || (wp & (WPAD_BUTTON_RIGHT | WPAD_CLASSIC_BUTTON_RIGHT)) )
{
/*** Go forward a page ***/
selection += PAGESIZE;
if (selection > maxfiles - 1)
selection = offset = 0;
if ((selection - offset) >= PAGESIZE)
offset += PAGESIZE;
redraw = 1;
}
}
return 0;
}
static bool ParseDirEntries()
{
if(!dir)
return false;
char *ext;
struct dirent *entry = NULL;
int isdir;
int i = 0;
while(i < 20 && !parseHalt)
{
entry = readdir(dir);
if(entry == NULL)
break;
if(entry->d_name[0] == '.' && entry->d_name[1] != '.')
continue;
if(strcmp(entry->d_name, "..") == 0)
{
isdir = 1;
}
else
{
if(entry->d_type==DT_DIR)
isdir = 1;
else
isdir = 0;
// don't show the file if it's not a valid ROM
if(parseFilter && !isdir)
{
ext = GetExt(entry->d_name);
if(ext == NULL)
continue;
if( stricmp(ext, "agb") != 0 && stricmp(ext, "gba") != 0 &&
stricmp(ext, "bin") != 0 && stricmp(ext, "elf") != 0 &&
stricmp(ext, "mb") != 0 && stricmp(ext, "dmg") != 0 &&
stricmp(ext, "gb") != 0 && stricmp(ext, "gbc") != 0 &&
stricmp(ext, "cgb") != 0 && stricmp(ext, "sgb") != 0 &&
stricmp(ext, "zip") != 0 && stricmp(ext, "7z") != 0)
continue;
}
}
if(!AddBrowserEntry())
{
parseHalt = true;
break;
}
snprintf(browserList[browser.numEntries+i].filename, MAXJOLIET, "%s", entry->d_name);
browserList[browser.numEntries+i].isdir = isdir; // flag this as a dir
if(isdir)
{
if(strcmp(entry->d_name, "..") == 0)
sprintf(browserList[browser.numEntries+i].displayname, "Up One Level");
else
snprintf(browserList[browser.numEntries+i].displayname, MAXJOLIET, "%s", browserList[browser.numEntries+i].filename);
browserList[browser.numEntries+i].icon = ICON_FOLDER;
}
else
{
StripExt(browserList[browser.numEntries+i].displayname, browserList[browser.numEntries+i].filename); // hide file extension
}
i++;
}
if(!parseHalt)
{
// Sort the file list
if(i >= 0)
qsort(browserList, browser.numEntries+i, sizeof(BROWSERENTRY), FileSortCallback);
browser.numEntries += i;
}
if(entry == NULL || parseHalt)
{
closedir(dir); // close directory
dir = NULL;
return false; // no more entries
}
return true; // more entries
}
int main(int argc, char *argv[])
{
char buffer[256];
char *p;
BOOLEAN multipleFiles = FALSE;
int rv;
char realOutFile[260];
char oldOutFile[260];
srand(time(0));
/* signal(SIGSEGV,internalError) ;*/
/* signal(SIGFPE, internalError) ;*/
/* initialize back end */
if (!init_backend(&argc,argv))
fatal("Could not initialize back end");
if (chosenAssembler->Args)
{
CMDLIST *newArgs = calloc(sizeof(Args) + sizeof(Args[0]) * chosenAssembler->ArgCount, 1);
if (newArgs)
{
memcpy(&newArgs[0], chosenAssembler->Args,
chosenAssembler->ArgCount *sizeof(Args[0]));
memcpy(&newArgs[chosenAssembler->ArgCount], &Args[0], sizeof(Args));
ArgList = newArgs;
}
}
/* parse environment variables, command lines, and config files */
ccinit(argc, argv);
/* loop through and preprocess all the files on the file list */
if (clist && clist->next)
multipleFiles = TRUE;
#ifdef PARSER_ONLY
strcpy(buffer, clist->data);
strcpy(realOutFile, outfile);
outputfile(realOutFile, buffer, ".ods");
if (!ccDBOpen(realOutFile))
fatal("Cannot open database file %s", realOutFile);
#else
BitInit();
regInit();
#endif
while (clist)
{
cparams.prm_cplusplus = FALSE;
strcpy(buffer, clist->data);
#ifndef PARSER_ONLY
strcpy(realOutFile, outfile);
if (cparams.prm_asmfile)
outputfile(realOutFile, buffer, chosenAssembler->asmext);
else
outputfile(realOutFile, buffer, chosenAssembler->objext);
strcpy(oldOutFile, realOutFile);
StripExt(oldOutFile);
AddExt(oldOutFile, ".tmp");
#else
ccNewFile(buffer, TRUE);
#endif
AddExt(buffer, ".C");
p = strrchr(buffer, '.');
if (*(p - 1) != '.')
{
if (p[1] == 'h' || p[1] == 'H') // compile H files as C++ for the IDE
cparams.prm_cplusplus = TRUE;
if (p[1] == 'c' || p[1] == 'C')
if (p[2] == 'p' || p[2] == 'P')
{
if (p[3] == 'p' || p[3] == 'P')
cparams.prm_cplusplus = TRUE;
}
else
{
if (p[2] == 'x' || p[2] == 'X')
{
if (p[3] == 'x' || p[3] == 'X')
cparams.prm_cplusplus = TRUE;
}
}
else if ((p[2] == 'c' ||p[2] == 'C' ) && !p[3])
{
cparams.prm_cplusplus = TRUE;
}
else
{
if (p[2] == '+')
{
if (p[3] == '+')
cparams.prm_cplusplus = TRUE;
}
}
}
inputFile = SrchPth2(buffer, "", "r");
if (!inputFile)
fatal("Cannot open input file %s", buffer);
strcpy(infile, buffer);
if (cparams.prm_makestubs)
{
MakeStubs();
}
else
{
#ifndef PARSER_ONLY
unlink(oldOutFile);
rename(realOutFile, oldOutFile);
outputFile = fopen(realOutFile, cparams.prm_asmfile ? "w" : "wb");
if (!outputFile)
{
fclose(inputFile);
fatal("Cannot open output file %s", realOutFile);
}
setvbuf(outputFile,0,_IOFBF,32768);
#endif
if (cparams.prm_cppfile)
{
StripExt(buffer);
AddExt(buffer, ".i");
strcpy(cppfile, buffer);
cppFile = fopen(buffer, "w");
if (!cppFile)
{
fclose(inputFile);
fclose(outputFile);
fatal("Cannot open preprocessor output file %s", buffer);
}
}
if (cparams.prm_listfile)
{
StripExt(buffer);
AddExt(buffer, ".lst");
listFile = fopen(buffer, "w");
if (!listFile)
{
fclose(inputFile);
fclose(cppFile);
fclose(outputFile);
fatal("Cannot open list file %s", buffer);
}
}
if (cparams.prm_errfile)
{
StripExt(buffer);
AddExt(buffer, ".err");
errFile = fopen(buffer, "w");
if (!errFile)
{
fclose(inputFile);
fclose(cppFile);
fclose(listFile);
fclose(outputFile);
fatal("Cannot open error file %s", buffer);
}
}
if (cparams.prm_browse)
{
char name[260];
strcpy(name, outfile);
StripExt(name);
AddExt(name, ".cbr");
browseFile = fopen(name, "wb");
if (!browseFile)
{
fclose(errFile);
fclose(inputFile);
fclose(cppFile);
fclose(listFile);
fclose(outputFile);
fatal("Cannot open browse file %s", buffer);
}
setvbuf(browseFile,0,_IOFBF,32768);
}
if (cparams.prm_icdfile)
{
StripExt(buffer);
AddExt(buffer, ".icd");
icdFile = fopen(buffer, "w");
if (!icdFile)
{
fclose(browseFile);
fclose(errFile);
fclose(inputFile);
fclose(cppFile);
fclose(listFile);
fclose(outputFile);
fatal("Cannot open error file %s", buffer);
}
setvbuf(icdFile,0,_IOFBF,32768);
}
if (multipleFiles && !cparams.prm_quiet)
printf("%s\n", clist->data);
compile();
}
#ifdef PARSER_ONLY
localFree();
#endif
globalFree();
if (cparams.prm_diag)
{
mem_summary();
printf("Intermediate stats:\n");
printf(" Block peak: %d\n", maxBlocks);
printf(" Temp peak: %d\n", maxTemps);
printf(" Allocation Spills: %d\n", maxAllocationSpills);
printf(" Allocation Passes: %d\n", maxAllocationPasses);
printf(" Allocation Accesses: %d\n", maxAllocationAccesses);
}
maxBlocks = maxTemps = maxAllocationSpills = maxAllocationPasses = maxAllocationAccesses = 0;
#ifdef PARSER_ONLY
ccCloseFile(inputFile);
#else
fclose(inputFile);
#endif
if (outputFile)
fclose(outputFile);
if (cppFile)
fclose(cppFile);
if (listFile)
fclose(listFile);
if (errFile)
fclose(errFile);
if (browseFile)
fclose(browseFile);
if (icdFile)
fclose(icdFile);
if (total_errors)
{
unlink(realOutFile);
rename(oldOutFile, realOutFile);
}
else
{
unlink (oldOutFile);
}
/* Flag to stop if there are any errors */
stoponerr |= total_errors;
clist = clist->next;
}
rv = !!stoponerr ;
if (!cparams.prm_makestubs)
{
if (!cparams.prm_compileonly && !stoponerr) {
rv = 0 ;
if (chosenAssembler->compiler_postprocess)
{
char buf[260];
#ifdef MICROSOFT
GetModuleFileNameA(NULL, buffer, sizeof(buffer));
#else
strcpy(buffer, argv[0]);
#endif
rv = chosenAssembler->compiler_postprocess(buffer);
}
}
if (chosenAssembler->rundown)
chosenAssembler->rundown();
}
return rv;
}
int SzParse(char * filepath)
{
if(!filepath)
return 0;
int device;
if(!FindDevice(browser.dir, &device) || !GetFileSize(browser.selIndex))
return 0;
int nbfiles = 0;
// save the length/offset of this file
unsigned int filelen = browserList[browser.selIndex].length;
// setup archive stream
SzArchiveStream.offset = 0;
SzArchiveStream.len = filelen;
SzArchiveStream.pos = 0;
// open file
file = fopen (filepath, "rb");
if(!file)
return 0;
// set szMethod to current chosen load device
szMethod = device;
// set handler functions for reading data from SD/USB/SMB/DVD
SzArchiveStream.InStream.Read = SzFileReadImp;
SzArchiveStream.InStream.Seek = SzFileSeekImp;
// set default 7Zip SDK handlers for allocation and freeing memory
SzAllocImp.Alloc = SzAlloc;
SzAllocImp.Free = SzFree;
SzAllocTempImp.Alloc = SzAllocTemp;
SzAllocTempImp.Free = SzFreeTemp;
// prepare CRC and 7Zip database structures
InitCrcTable();
SzArDbExInit(&SzDb);
// open the archive
SzRes = SzArchiveOpen(&SzArchiveStream.InStream, &SzDb, &SzAllocImp,
&SzAllocTempImp);
if (SzRes != SZ_OK)
{
SzDisplayError(SzRes);
// free memory used by the 7z SDK
SzClose();
}
else // archive opened successfully
{
if(SzDb.Database.NumFiles > 0)
{
// Parses the 7z into a full file listing
HaltParseThread(); // halt parsing
ResetBrowser(); // reset browser
// add '..' folder in case the user wants exit the 7z
AddBrowserEntry();
sprintf(browserList[0].displayname, "Up One Level");
browserList[0].isdir = 1;
browserList[0].length = filelen;
browserList[0].icon = ICON_FOLDER;
// get contents and parse them into file list structure
unsigned int SzI, SzJ;
SzJ = 1;
for (SzI = 0; SzI < SzDb.Database.NumFiles; SzI++)
{
SzF = SzDb.Database.Files + SzI;
// skip directories
if (SzF->IsDirectory)
continue;
if(!AddBrowserEntry())
{
ResetBrowser();
ErrorPrompt("Out of memory: too many files!");
SzClose();
SzJ = 0;
break;
}
// parse information about this file to the file list structure
snprintf(browserList[SzJ].filename, MAXJOLIET, "%s", SzF->Name);
StripExt(browserList[SzJ].displayname, browserList[SzJ].filename);
browserList[SzJ].length = SzF->Size; // filesize
browserList[SzJ].isdir = 0; // only files will be displayed (-> no flags)
browserList[SzJ].filenum = SzI; // the extraction function identifies the file with this number
SzJ++;
}
nbfiles = SzJ;
}
else
{
SzClose();
}
}
CancelAction();
// close file
fclose(file);
return nbfiles;
}
/****************************************************************************
* FileSelector
*
* Let user select a file from the listing
***************************************************************************/
int FileSelector (int method)
{
u32 p = 0;
u32 wp = 0;
u32 ph = 0;
u32 wh = 0;
signed char gc_ay = 0;
signed char gc_sx = 0;
signed char wm_ay = 0;
signed char wm_sx = 0;
int haverom = 0;
int redraw = 1;
int selectit = 0;
int scroll_delay = 0;
bool move_selection = 0;
#define SCROLL_INITIAL_DELAY 15
#define SCROLL_LOOP_DELAY 2
while (haverom == 0)
{
if (redraw)
ShowFiles (filelist, maxfiles, offset, selection);
redraw = 0;
VIDEO_WaitVSync(); // slow things down a bit so we don't overread the pads
gc_ay = PAD_StickY (0);
gc_sx = PAD_SubStickX (0);
p = PAD_ButtonsDown (0);
ph = PAD_ButtonsHeld (0);
#ifdef HW_RVL
wm_ay = WPAD_Stick (0, 0, 0);
wm_sx = WPAD_Stick (0, 1, 1);
wp = WPAD_ButtonsDown (0);
wh = WPAD_ButtonsHeld (0);
#endif
/*** Check for exit combo ***/
if ( (gc_sx < -70) || (wm_sx < -70) || (wp & WPAD_BUTTON_HOME) || (wp & WPAD_CLASSIC_BUTTON_HOME) )
return 0;
/*** Check buttons, perform actions ***/
if ( (p & PAD_BUTTON_A) || selectit || (wp & (WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A)) )
{
if ( selectit )
selectit = 0;
if (filelist[selection].flags) // This is directory
{
/* update current directory and set new entry list if directory has changed */
int status;
if(inSz && selection == 0) // inside a 7z, requesting to leave
{
if(method == METHOD_DVD)
{
// go to directory the 7z was in
dvddir = filelist[0].offset;
dvddirlength = filelist[0].length;
}
inSz = false;
status = 1;
SzClose();
}
else
{
status = UpdateDirName(method);
}
if (status == 1) // ok, open directory
{
switch (method)
{
case METHOD_SD:
case METHOD_USB:
maxfiles = ParseFATdirectory(method);
break;
case METHOD_DVD:
maxfiles = ParseDVDdirectory();
break;
case METHOD_SMB:
maxfiles = ParseSMBdirectory();
break;
}
if (!maxfiles)
{
WaitPrompt ((char*) "Error reading directory !");
haverom = 1; // quit menu
}
}
else if (status == -1) // directory name too long
{
haverom = 1; // quit menu
}
}
else // this is a file
{
// 7z file - let's open it up to select a file inside
if(IsSz())
{
// we'll store the 7z filepath for extraction later
if(!MakeROMPath(szpath, method))
{
WaitPrompt((char*) "Maximum filepath length reached!");
return -1;
}
int szfiles = SzParse(szpath, method);
if(szfiles)
{
maxfiles = szfiles;
inSz = true;
}
else
WaitPrompt((char*) "Error opening archive!");
}
else
{
// store the filename (w/o ext) - used for sram/freeze naming
StripExt(ROMFilename, filelist[selection].filename);
ShowAction ((char *)"Loading...");
ROMLoaded = LoadVBAROM(method);
inSz = false;
if (ROMLoaded)
{
return 1;
}
else
{
WaitPrompt((char*) "Error loading ROM!");
}
}
}
redraw = 1;
} // End of A
if ( (p & PAD_BUTTON_B) || (wp & (WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B)) )
{
while ( (PAD_ButtonsDown(0) & PAD_BUTTON_B)
#ifdef HW_RVL
|| (WPAD_ButtonsDown(0) & (WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B))
#endif
)
VIDEO_WaitVSync();
if ( strcmp(filelist[0].filename,"..") == 0 )
{
selection = 0;
selectit = 1;
}
else if ( strcmp(filelist[1].filename,"..") == 0 )
{
selection = selectit = 1;
} else {
return 0;
}
} // End of B
if ( ((p | ph) & PAD_BUTTON_DOWN) || ((wp | wh) & (WPAD_BUTTON_DOWN | WPAD_CLASSIC_BUTTON_DOWN)) || (gc_ay < -PADCAL) || (wm_ay < -PADCAL) )
{
if ( (p & PAD_BUTTON_DOWN) || (wp & (WPAD_BUTTON_DOWN | WPAD_CLASSIC_BUTTON_DOWN)) ) { /*** Button just pressed ***/
scroll_delay = SCROLL_INITIAL_DELAY; // reset scroll delay.
move_selection = 1; //continue (move selection)
}
else if (scroll_delay == 0) { /*** Button is held ***/
scroll_delay = SCROLL_LOOP_DELAY;
move_selection = 1; //continue (move selection)
} else {
scroll_delay--; // wait
}
if (move_selection)
{
selection++;
if (selection == maxfiles)
selection = offset = 0;
if ((selection - offset) >= PAGESIZE)
offset += PAGESIZE;
redraw = 1;
move_selection = 0;
}
} // End of down
if ( ((p | ph) & PAD_BUTTON_UP) || ((wp | wh) & (WPAD_BUTTON_UP | WPAD_CLASSIC_BUTTON_UP)) || (gc_ay > PADCAL) || (wm_ay > PADCAL) )
{
if ( (p & PAD_BUTTON_UP) || (wp & (WPAD_BUTTON_UP | WPAD_CLASSIC_BUTTON_UP)) ) { /*** Button just pressed***/
scroll_delay = SCROLL_INITIAL_DELAY; // reset scroll delay.
move_selection = 1; //continue (move selection)
}
else if (scroll_delay == 0) { /*** Button is held ***/
scroll_delay = SCROLL_LOOP_DELAY;
move_selection = 1; //continue (move selection)
} else {
scroll_delay--; // wait
}
if (move_selection)
{
selection--;
if (selection < 0) {
selection = maxfiles - 1;
offset = selection - PAGESIZE + 1;
}
if (selection < offset)
offset -= PAGESIZE;
if (offset < 0)
offset = 0;
redraw = 1;
move_selection = 0;
}
} // End of Up
if ( (p & PAD_BUTTON_LEFT) || (wp & (WPAD_BUTTON_LEFT | WPAD_CLASSIC_BUTTON_LEFT)) )
{
/*** Go back a page ***/
selection -= PAGESIZE;
if (selection < 0)
{
selection = maxfiles - 1;
offset = selection - PAGESIZE + 1;
}
if (selection < offset)
offset -= PAGESIZE;
if (offset < 0)
offset = 0;
redraw = 1;
}
if ( (p & PAD_BUTTON_RIGHT) || (wp & (WPAD_BUTTON_RIGHT | WPAD_CLASSIC_BUTTON_RIGHT)) )
{
/*** Go forward a page ***/
selection += PAGESIZE;
if (selection > maxfiles - 1)
selection = offset = 0;
if ((selection - offset) >= PAGESIZE)
offset += PAGESIZE;
redraw = 1;
}
}
return 0;
}
// Shorten a ROM filename by removing the extension, URLs, id numbers and other rubbish
void ShortenFilename(char * returnstring, char * inputstring)
{
if (!inputstring) {
returnstring[0] = '\0';
return;
}
// skip URLs in brackets
char * dotcom = (char *) strstr(inputstring, ".com)");
char * url = NULL;
if (dotcom) {
url = (char *) strchr(inputstring, '(');
if (url >= dotcom) {
url = NULL;
dotcom = NULL;
} else dotcom+= 5; // point to after ')'
}
// skip URLs not in brackets
if (!dotcom) {
dotcom = (char *) strstr(inputstring, ".com");
url = NULL;
if (dotcom) {
url = (char *) strstr(inputstring, "www");
if (url >= dotcom) {
url = NULL;
dotcom = NULL;
} else dotcom+= 4; // point to after ')'
}
}
// skip file extension
char * loc_dot = (char *)strrchr(inputstring,'.');
char * s = (char *)inputstring;
char * r = (char *)returnstring;
// skip initial whitespace, numbers, - and _ ...
while ((*s!='\0' && *s<=' ') || *s=='-' || *s=='_' || *s=='+') s++;
// ... except those that SHOULD begin with numbers
if (strncmp(s,"3D",2)==0) for (int i=0; i<2; i++, r++, s++) *r=*s;
if (strncmp(s,"1st",3)==0 || strncmp(s,"2nd",3)==0 || strncmp(s,"3rd",3)==0 || strncmp(s,"4th",3)==0) for (int i=0; i<3; i++, r++, s++) *r=*s;
if (strncmp(s,"199",3)==0 || strncmp(s,"007",3)==0 || strncmp(s,"4x4",3)==0 || strncmp(s,"720",3)==0 || strncmp(s,"10 ",3)==0) for (int i=0; i<3; i++, r++, s++) *r=*s;
if (strncmp(s,"102 ",4)==0 || strncmp(s,"1942",4)==0 || strncmp(s,"3 Ch",4)==0) for (int i=0; i<4; i++, r++, s++) *r=*s;
if (strncmp(s,"2 in 1",6)==0 || strncmp(s,"3 in 1",6)==0 || strncmp(s,"4 in 1",6)==0) for (int i=0; i<6; i++, r++, s++) *r=*s;
if (strncmp(s,"2-in-1",6)==0 || strncmp(s,"3-in-1",6)==0 || strncmp(s,"4-in-1",6)==0) for (int i=0; i<6; i++, r++, s++) *r=*s;
while (*s>='0' && *s<='9') s++;
if (r==(char *)returnstring) while ((*s!='\0' && *s<=' ') || *s=='-' || *s=='_' || *s=='+') s++;
// now go through rest of string until we get to the end or the extension
while (*s!='\0' && (loc_dot==NULL || s<loc_dot)) {
// skip url
if (s==url) s=dotcom;
// skip whitespace, numbers, - and _ after url
if (s==dotcom) {
while ((*s>'\0' && *s<=' ') || *s=='-' || *s=='_') s++;
while (*s>='0' && *s<='9') s++;
while ((*s>'\0' && *s<=' ') || *s=='-' || *s=='_') s++;
}
// skip all but 1 '-', '_' or space in a row
char c = s[0];
if (c==s[1] && (c=='-' || c=='_' || c==' ')) s++;
// skip space before hyphen
if (*s==' ' && s[1]=='-') s++;
// copy character to result
if (*s=='_') *r=' ';
else *r = *s;
// skip spaces after hyphen
if (*s=='-') while (s[1]==' ') s++;
s++; r++;
}
*r = '\0';
// if the result is too short, abandon what we did and just strip the ext instead
if (strlen(returnstring) <= 4) StripExt(returnstring, inputstring);
}
bool MakeFilePath(char filepath[], int type, char * filename, int filenum)
{
char file[512];
char folder[1024];
char ext[4];
char temppath[MAXPATHLEN];
if(type == FILE_ROM)
{
// Check path length
if ((strlen(browser.dir)+1+strlen(browserList[browser.selIndex].filename)) >= MAXPATHLEN)
{
ErrorPrompt("Maximum filepath length reached!");
filepath[0] = 0;
return false;
}
else
{
sprintf(temppath, "%s%s",browser.dir,browserList[browser.selIndex].filename);
}
}
else if (type == FILE_BORDER_PNG)
{
const char* loadedpath = filename;
if (loadedpath == NULL) loadedpath = "default";
// Ensure that loadedname contains only the filename, not the path
const char* loadedname = strrchr(loadedpath, '/');
if (loadedname == NULL) loadedname = loadedpath;
// Check path length
if ((strlen(pathPrefix[GCSettings.LoadMethod]) + strlen(GCSettings.BorderFolder) + strlen(loadedname)) >= MAXPATHLEN) {
ErrorPrompt("Maximum filepath length reached!");
filepath[0] = 0;
return false;
}
StripExt(file, loadedname);
sprintf(temppath, "%s%s/%s.png", pathPrefix[GCSettings.LoadMethod], GCSettings.BorderFolder, file);
}
else
{
if(GCSettings.SaveMethod == DEVICE_AUTO)
GCSettings.SaveMethod = autoSaveMethod(SILENT);
if(GCSettings.SaveMethod == DEVICE_AUTO)
return false;
switch(type)
{
case FILE_SRAM:
case FILE_SNAPSHOT:
sprintf(folder, GCSettings.SaveFolder);
if(type == FILE_SRAM) sprintf(ext, "sav");
else sprintf(ext, "sgm");
if(filenum >= -1)
{
if(filenum == -1)
sprintf(file, "%s.%s", filename, ext);
else if(filenum == 0)
if (GCSettings.AppendAuto <= 0)
{
sprintf(file, "%s.%s", filename, ext);
}
else
{
sprintf(file, "%s Auto.%s", filename, ext);
}
else
sprintf(file, "%s %i.%s", filename, filenum, ext);
}
else
{
sprintf(file, "%s", filename);
}
break;
}
sprintf (temppath, "%s%s/%s", pathPrefix[GCSettings.SaveMethod], folder, file);
}
CleanupPath(temppath); // cleanup path
snprintf(filepath, MAXPATHLEN, "%s", temppath);
return true;
}
int RunExternalFiles(char *rootPath)
{
char root[260];
char args[1024], *c0;
char spname[2048];
char outName[260] ,*p;
int rv;
char temp[260];
strcpy(root, rootPath);
p = strrchr(root, '\\');
if (!p)
p = root;
else
p++;
*p = 0;
temp[0] = 0;
strcpy(outName, outputFileName);
if (objlist && outName[0] && outName[strlen(outName)-1] == '\\')
{
strcat(outName, objlist->data);
StripExt(outName);
strcat(outName, ".exe");
strcpy(temp, outputFileName);
}
// p = strrchr(outName, '.');
// if (p && p[1] != '\\')
// *p = 0;
while (asmlist)
{
sprintf(spname, "\"%soasm.exe\" %s \"%s\"", root, !showBanner ? "-!" : "", asmlist->data);
rv = system(spname);
if (rv)
return rv;
asmlist = asmlist->next;
}
if (beGetIncludePath)
sprintf(args, "\"-i%s\"", beGetIncludePath);
else
args[0] = 0;
while (rclist)
{
sprintf(spname, "\"%sorc.exe\" -r %s %s \"%s\"", root, !showBanner ? "-!" : "", args, rclist->data);
rv = system(spname);
if (rv)
return rv;
rclist = rclist->next;
}
if (objlist)
{
FILE *fil = fopen(TEMPFILE, "w");
if (!fil)
return 1;
strcpy(args, winflags[prm_targettype]);
c0 = winc0[prm_targettype + prm_lscrtdll * 8];
if (cparams.prm_debug)
{
// strcat(args, " /DEB");
if (prm_targettype == DOS)
c0 = "c0pmd.o";
else if (prm_targettype == DOS32A)
c0 = "c0watd.o";
strcat(args, " /v");
}
fprintf(fil, " %s", c0);
while (objlist)
{
fprintf(fil, " \"%s%s\"", temp, objlist->data);
objlist = objlist->next;
}
fprintf(fil, " \"/o%s\" ", outName);
while (liblist)
{
fprintf(fil, " \"%s\"", liblist->data);
liblist = liblist->next;
}
if (prm_msvcrt)
fprintf(fil," climp.l msvcrt.l ");
else if (prm_lscrtdll)
fprintf(fil," climp.l lscrtl.l ");
else if (prm_crtdll)
fprintf(fil, " climp.l crtdll.l ");
else if (prm_targettype == DOS || prm_targettype == DOS32A || prm_targettype == RAW || prm_targettype == WHXDOS)
{
if (cparams.prm_farkeyword)
fprintf(fil, " farmem");
fprintf(fil, " cldos.l ");
}
else
fprintf(fil, " climp.l clwin.l ");
while (reslist)
{
fprintf(fil, " \"%s\"", reslist->data);
reslist = reslist->next;
}
fclose(fil);
sprintf(spname, "\"%solink.exe\" %s /mx /c+ %s @"TEMPFILE, root, !showBanner ? "-!" : "", args);
rv = system(spname);
unlink(TEMPFILE);
if (rv)
return rv;
if (prm_targettype == WHXDOS)
{
sprintf(spname, "\"%spatchpe\" %s", root, outputFileName);
rv = system(spname);
if (rv)
{
printf("Could not spawn patchpe.exe\n");
}
}
if (rv)
return rv;
}
return 0;
}
