BOOL PutHash( LPCTSTR lpszFile, LPOPTIONS lpOpt )
{
DWORD w;
LPCTSTR lpszFormat;
if( lpOpt->DispFilename ){
lpszFormat = _T( "%3!s!(%4!s!) : %1!s!-%2!8.8X!.pf\n" );
}else{
if( lpOpt->HashXp && lpOpt->HashVista ){
lpszFormat = _T( "(%4!s!) : %1!s!-%2!8.8X!.pf\n" );
}else{
lpszFormat = _T( "%1!s!-%2!8.8X!.pf\n" );
}
}
if( lpOpt->HashVista ){
w = HashVista( lpszFile );
my_printf( hStdout, lpszFormat, Basename( lpszFile ), w, lpszFile, _T("Vista") );
}
if( lpOpt->HashXp ){
w = HashXp( lpszFile );
my_printf( hStdout, lpszFormat, Basename( lpszFile ), w, lpszFile, _T("XP") );
}
return TRUE;
}
/**
* @brief
*/
static cm_material_t *Cm_LoadBspMaterials(const char *name) {
char base[MAX_QPATH];
StripExtension(Basename(name), base);
return Cm_LoadMaterials(va("materials/%s.mat", base), NULL);
}
bool COption::init(int argc, char** argv)
{
if(m_bInit)
{
return true;
}
m_optNum = sizeof(OptTab)/sizeof(OptTab[0]);
if(!initOption())
{
return false;
}
//获取程序名称
m_myName = Basename(argv[0]);
//获取命令行选项
int oc = -1;
char optString[sizeof(OptTab)/sizeof(OptTab[0]) * 2] = {0};
makeOptString(optString);
//解析命令行
while((oc = getopt(argc, argv, optString)) != -1)
{
if(Unknown_key == oc || Usage_key == oc)
{
usage();
return false;
}
setOption(oc, optarg);
}
return true;
}
static
VOID
ShowUsage(
PCSTR pszProgramName,
BOOLEAN bFull
)
{
printf(
"Usage: %s [ --<object type> ] [ <flags> ] [ --provider name ]\n",
Basename(pszProgramName));
if (bFull)
{
printf(
"\n"
"Object type options:\n"
" --user Return only user objects\n"
" --group Return only group objects\n"
"\n"
"Query flags:\n"
" --nss Omit data not necessary for NSS layer\n"
"\n"
"Other options:\n"
" --domain name Restrict enumeration to the specified NetBIOS domain\n"
" --provider name Direct request to provider with the specified name\n"
"\n");
}
}
/*
* Cl_LoadLocations
*
* Parse a .loc file for the current level.
*/
void Cl_LoadLocations(void) {
const char *c;
char file_name[MAX_QPATH];
FILE *f;
int i;
Cl_ClearLocations(); // clear any resident locations
i = 0;
// load the locations file
c = Basename(cl.config_strings[CS_MODELS + 1]);
snprintf(file_name, sizeof(file_name), "locations/%s", c);
strcpy(file_name + strlen(file_name) - 3, "loc");
if (Fs_OpenFile(file_name, &f, FILE_READ) == -1) {
Com_Debug("Couldn't load %s\n", file_name);
return;
}
while (i < MAX_LOCATIONS) {
const int err = fscanf(f, "%f %f %f %[^\n]", &locations[i].loc[0],
&locations[i].loc[1], &locations[i].loc[2], locations[i].desc);
num_locations = i;
if (err == EOF)
break;
i++;
}
Cl_LoadProgress(100);
Com_Print("Loaded %i locations.\n", num_locations);
Fs_CloseFile(f);
}
/* -------------------------------------------------------------
* do_stat: print all important inode info for the path INODE
* (1) get INODE of path into a minode[] table
* (2) print all important info
*
* Note: This is the lazy way. KC's recommended way utilizes
* the stat struct
--------------------------------------------------------------*/
void do_stat(char* path)
{
MINODE* dir;
char timebuf[256];
int ino;
int dev = running->cwd->dev;
//(1) get INODE of path into a minode[table]
ino = getino(&dev, path); // get ino
dir = iget(dev, ino); // get MINODE*
if(dir == NULL)
{
printf("Error: unable to stat %s\n", path);
return;
}
// Copy dir's modified time into timebuf
ctime_r(&dir->INODE.i_mtime, timebuf);
timebuf[24] = 0; // add NULL terminator
printf("-------------------------------------------------------\n");
printf("file: %s\n", Basename(path));
printf("dev: %d\t\tinode number: %i\tmode:%3x\n", dir->dev, dir->ino, dir->INODE.i_mode);
printf("uid: %i\tgid: %i\tlink count: %d\n", running->uid, running->gid, dir->INODE.i_links_count);
printf("size: %d\t\t%5s\n", dir->INODE.i_size, timebuf);
printf("-------------------------------------------------------\n");
iput(dir);
}
bool RageSound::Load( CString sSoundFilePath, bool bPrecache )
{
LOG->Trace( "RageSound::LoadSound( '%s', %d )", sSoundFilePath.c_str(), bPrecache );
CString error;
SoundReader *pSound = SoundReader_FileReader::OpenFile( sSoundFilePath, error );
if( pSound == NULL )
{
LOG->Warn( "RageSound::Load: error opening sound \"%s\": %s",
sSoundFilePath.c_str(), error.c_str() );
pSound = new RageSoundReader_Silence;
}
LoadSoundReader( pSound );
/* Try to precache. Do this after calling LoadSoundReader() to put the
* sound in this->m_pSource, so we preload after resampling. */
if( bPrecache )
RageSoundReader_Preload::PreloadSound( m_pSource );
m_sFilePath = sSoundFilePath;
m_Mutex.SetName( ssprintf("RageSound (%s)", Basename(sSoundFilePath).c_str() ) );
return true;
}
const char* FileInfo::tail()
{
const char* name = Basename();
const char* pt = strrchr(name, '.');
return (pt == NULL ? "" : pt);
}
void ScreenTestSound::UpdateText(int n)
{
RString fn = Basename( s[n].s.GetLoadedFilePath() );
vector<RageSound *> &snds = m_sSoundCopies[n];
RString pos;
for(unsigned p = 0; p < snds.size(); ++p)
{
if(p) pos += ", ";
pos += ssprintf("%.3f", snds[p]->GetPositionSeconds());
}
s[n].txt.SetText(ssprintf(
"%i: %s\n"
"%s\n"
"%s\n"
"(%s)\n"
"%s",
n+1, fn.c_str(),
s[n].s.IsPlaying()? "Playing":"Stopped",
s[n].s.GetParams().StopMode == RageSoundParams::M_STOP?
"Stop when finished":
s[n].s.GetParams().StopMode == RageSoundParams::M_CONTINUE?
"Continue until stopped":
"Loop",
pos.size()? pos.c_str(): "none playing",
selected == n? "^^^^^^":""
));
}
static RString MakeTempFilename( const RString &sPath )
{
/* "Foo/bar/baz" -> "Foo/bar/new.baz.new". Both prepend and append: we don't
* want a wildcard search for the filename to match (foo.txt.new matches foo.txt*),
* and we don't want to have the same extension (so "new.foo.sm" doesn't show up
* in *.sm). */
return Dirname(sPath) + "new." + Basename(sPath) + ".new";
}
/*
* grpck - verify group file integrity
*/
int main (int argc, char **argv)
{
int errors = 0;
bool changed = false;
/*
* Get my name so that I can use it to report errors.
*/
Prog = Basename (argv[0]);
(void) setlocale (LC_ALL, "");
(void) bindtextdomain (PACKAGE, LOCALEDIR);
(void) textdomain (PACKAGE);
process_root_flag ("-R", argc, argv);
OPENLOG ("grpck");
/* Parse the command line arguments */
process_flags (argc, argv);
open_files ();
if (sort_mode) {
gr_sort ();
#ifdef SHADOWGRP
if (is_shadow) {
sgr_sort ();
}
changed = true;
#endif
} else {
check_grp_file (&errors, &changed);
#ifdef SHADOWGRP
if (is_shadow) {
check_sgr_file (&errors, &changed);
}
#endif
}
/* Commit the change in the database if needed */
close_files (changed);
nscd_flush_cache ("group");
/*
* Tell the user what we did and exit.
*/
if (0 != errors) {
if (changed) {
printf (_("%s: the files have been updated\n"), Prog);
} else {
printf (_("%s: no changes\n"), Prog);
}
}
return ((0 != errors) ? E_BAD_ENTRY : E_OKAY);
}
/**
* return file root name (ie without suffix)
*/
const char* FileInfo::rootname()
{
_rootname = Basename();
unsigned long pos = _rootname.rfind(".");
if ( pos != string::npos )
_rootname.erase(pos, string::npos);
return _rootname.c_str();
}
/*
* main - groupadd command
*/
int main (int argc, char **argv)
{
/*
* Get my name so that I can use it to report errors.
*/
Prog = Basename (argv[0]);
(void) setlocale (LC_ALL, "");
(void) bindtextdomain (PACKAGE, LOCALEDIR);
(void) textdomain (PACKAGE);
process_root_flag ("-R", argc, argv);
prefix = process_prefix_flag ("-P", argc, argv);
OPENLOG ("groupadd");
#ifdef WITH_AUDIT
audit_help_open ();
#endif
if (atexit (do_cleanups) != 0) {
fprintf (stderr,
_("%s: Cannot setup cleanup service.\n"),
Prog);
exit (1);
}
/*
* Parse the command line options.
*/
process_flags (argc, argv);
check_perms ();
#ifdef SHADOWGRP
is_shadow_grp = sgr_file_present ();
#endif
/*
* Do the hard stuff - open the files, create the group entries,
* then close and update the files.
*/
open_files ();
if (!gflg) {
if (find_new_gid (rflg, &group_id, NULL) < 0) {
exit (E_GID_IN_USE);
}
}
grp_update ();
close_files ();
nscd_flush_cache ("group");
return E_SUCCESS;
}
/*!
*
*/
int
main(int argc, char** argv)
{
char *progname = argv[0];
glutInit(&argc, argv);
for(++argv; --argc > 0; ++argv)
{
if( strcmp(*argv, "-help") == 0 || strcmp(*argv, "--help") == 0 )
{
fputs("View a 3DS model file using OpenGL.\n", stderr);
fputs("Usage: 3dsplayer [-nodb|-aa|-flush] <filename>\n", stderr);
#ifndef USE_SDL
fputs("Texture rendering is not available; install SDL_image and recompile.\n", stderr);
#endif
exit(0);
}
else if( strcmp(*argv, "-nodb") == 0 )
dbuf = 0;
else if( strcmp(*argv, "-aa") == 0 )
anti_alias = 1;
else if( strcmp(*argv, "-flush") == 0 )
flush = 1;
else {
filepath = *argv;
decompose_datapath(filepath);
}
}
if (filepath == NULL) {
fputs("3dsplayer: Error: No 3DS file specified\n", stderr);
exit(1);
}
glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | (dbuf ? GLUT_DOUBLE:0) );
glutInitWindowSize(500, 500);
glutInitWindowPosition(100, 100);
glutCreateWindow(filepath != NULL ? Basename(filepath) : progname);
init();
create_icons();
load_model();
build_menu();
glutAttachMenu(2);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse_cb);
glutMotionFunc(drag_cb);
glutTimerFunc(10, timer_cb, 0);
glutMainLoop();
return(0);
}
static string GetDumpLocalID()
{
string localId = Basename(gReporterDumpFile);
string::size_type dot = localId.rfind('.');
if (dot == string::npos)
return "";
return localId.substr(0, dot);
}
void DataFlowTrace::ReadCoverage(const std::string &DirPath) {
Vector<SizedFile> Files;
GetSizedFilesFromDir(DirPath, &Files);
for (auto &SF : Files) {
auto Name = Basename(SF.File);
if (Name == kFunctionsTxt) continue;
std::ifstream IF(SF.File);
Coverage.AppendCoverage(IF);
}
}
void DirectFilenameDB::CacheFile( const RString &sPath )
{
CHECKPOINT_M( root+sPath );
RString sDir = Dirname( sPath );
FileSet *pFileSet = GetFileSet( sDir, false );
if( pFileSet == NULL )
{
// This directory isn't cached so do nothing.
m_Mutex.Unlock(); // Locked by GetFileSet()
return;
}
while( !pFileSet->m_bFilled )
m_Mutex.Wait();
#if defined(WIN32)
// There is almost surely a better way to do this
WIN32_FIND_DATA fd;
HANDLE hFind = DoFindFirstFile( root+sPath, &fd );
if( hFind == INVALID_HANDLE_VALUE )
{
m_Mutex.Unlock(); // Locked by GetFileSet()
return;
}
File f( fd.cFileName );
f.dir = !!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
f.size = fd.nFileSizeLow;
f.hash = fd.ftLastWriteTime.dwLowDateTime;
pFileSet->files.insert( f );
FindClose( hFind );
#else
File f( Basename(sPath) );
struct stat st;
if( DoStat(root+sPath, &st) == -1 )
{
int iError = errno;
/* If it's a broken symlink, ignore it. Otherwise, warn. */
/* Huh? */
WARN( ssprintf("File '%s' is gone! (%s)",
sPath.c_str(), strerror(iError)) );
}
else
{
f.dir = (st.st_mode & S_IFDIR);
f.size = (int)st.st_size;
f.hash = st.st_mtime;
}
pFileSet->files.insert(f);
#endif
m_Mutex.Unlock(); // Locked by GetFileSet()
}
const char* FileInfo::realpath()
{
char* pt = strdup( _path.c_str());
string dir = ::dirname(pt);
free(pt);
_realpath = _path;
if ( dir[0] == '~' )
{
// const char* pt = getenv("HOME");
const gchar* pt = g_get_home_dir() ;
if ( pt != NULL )
dir = pt + dir.substr(1);
}
else if ( dir[0] == '$' )
{
char varname[80];
const char* pt;
int i;
for ( i=0, pt = dir.c_str()+1;
*pt && *pt != ')' && strncmp(pt,_path_delim,1) ; ++pt )
if ( *pt == '(' ) continue;
else varname[i++] = *pt;
varname[i] = 0;
if ( *pt == ')' ) ++pt;
if ( varname[0] ) {
const char* pt2 = getenv(varname);
if ( pt2 != NULL ) {
dir = string(pt2) + string(pt);
} else
Log::err() << "Error in FileInfo::realpath : undefined environment variable " << varname << endl;
}
}
else if ( dir[0] == '.' )
{
char resolved[MAXPATHLEN];
char current[MAXPATHLEN];
if ( getcwd(current, sizeof(current)) == NULL )
return ""; // rep courant indefini
if ( chdir(dir.c_str()) != 0 )
return ""; // path invalide
getcwd(resolved, sizeof(resolved));
chdir (current);
dir=resolved;
}
_realpath = FileInfo(dir).join(Basename());
return _realpath.c_str();
}
void BackgroundUtil::GetGlobalBGAnimations( const Song *pSong, const RString &sMatch, vector<RString> &vsPathsOut, vector<RString> &vsNamesOut )
{
vsPathsOut.clear();
GetDirListing( BG_ANIMS_DIR+sMatch+"*", vsPathsOut, true, true );
GetDirListing( BG_ANIMS_DIR+sMatch+"*.xml", vsPathsOut, false, true );
vsNamesOut.clear();
FOREACH_CONST( RString, vsPathsOut, s )
vsNamesOut.push_back( Basename(*s) );
StripCvsAndSvn( vsPathsOut, vsNamesOut );
}
static bool MoveCrashData(const string& toDir,
string& dumpfile,
string& extrafile,
string& memoryfile)
{
if (!UIEnsurePathExists(toDir)) {
UIError(gStrings[ST_ERROR_CREATEDUMPDIR]);
return false;
}
string newDump = toDir + UI_DIR_SEPARATOR + Basename(dumpfile);
string newExtra = toDir + UI_DIR_SEPARATOR + Basename(extrafile);
string newMemory = toDir + UI_DIR_SEPARATOR + Basename(memoryfile);
if (!UIMoveFile(dumpfile, newDump)) {
UIError(gStrings[ST_ERROR_DUMPFILEMOVE]);
return false;
}
if (!UIMoveFile(extrafile, newExtra)) {
UIError(gStrings[ST_ERROR_EXTRAFILEMOVE]);
return false;
}
if (!memoryfile.empty()) {
// Ignore errors from moving the memory file
if (!UIMoveFile(memoryfile, newMemory)) {
UIDeleteFile(memoryfile);
newMemory.erase();
}
memoryfile = newMemory;
}
dumpfile = newDump;
extrafile = newExtra;
return true;
}
/* -------------------------------------------------------
* make_dir:
* must understand perfectly!!!
*
* Takes a pathname as parameter
*
* (1) set the device
* (2) get parent MINODE by using dirname with
* getino
* Load MINODE using iget
* (3) call my_mkdir(MINODE* parent, char* name)
*
--------------------------------------------------------*/
void make_dir(char* path)
{
MINODE* pip; // parent MINODE*
int dev, pino; // device, parent ino
// parent = path to parent directory, child = basename
char* parent, *child;
// (1) Set device according to relative or absolute path
if(path[0] == '/')
dev = root->dev;
else
dev = running->cwd->dev;
// (2) Separate path into dirname and basename
parent = strdup(Dirname(path)); // make copies
child = strdup(Basename(path));
// Debug print
//printf("parent: %s\n", parent);
//printf("child: %s\n", child);
// (3) get in memory MINODE of parent directory
pino = getino(&dev, parent); // First, get parent ino
pip = iget(dev, pino); // Then use it to load INODE into minode[] table
// (4) Error checking on found MINODE
if(pip == NULL) // (4.1) ensure the MINODE was found
{
printf("Error: unable to locate %s\n", parent);
}
else if(!isdir(pip)) // (4.2) is DIR
{
printf("Error: %s is not a directory\n", parent);
}
else if(search(pip, child) != 0) // (4.3) child does not already exist
{
// the child was already found
printf("Error: %s already exists in %s\n", child, parent);
}
// (5) We've verified that parent path exists, is a directory
// and child does not exist in it, so add to it
else
my_mkdir(pip,child);
// No matter what, dont forget to write back!
// Release parent from minode[] table and write back to disk
iput(pip);
}
int shell (const char *file, /*@null@*/const char *arg, char *const envp[])
{
char arg0[1024];
int err;
if (file == (char *) 0) {
errno = EINVAL;
return errno;
}
/*
* The argv[0]'th entry is usually the path name, but
* for various reasons the invoker may want to override
* that. So, we determine the 0'th entry only if they
* don't want to tell us what it is themselves.
*/
if (arg == (char *) 0) {
(void) snprintf (arg0, sizeof arg0, "-%s", Basename ((char *) file));
arg0[sizeof arg0 - 1] = '\0';
arg = arg0;
}
/*
* First we try the direct approach. The system should be
* able to figure out what we are up to without too much
* grief.
*/
(void) execle (file, arg, (char *) 0, envp);
err = errno;
if (access (file, R_OK|X_OK) == 0) {
/*
* Assume this is a shell script (with no shebang).
* Interpret it with /bin/sh
*/
(void) execle (SHELL, "sh", "-", file, (char *)0, envp);
err = errno;
}
/*
* Obviously something is really wrong - I can't figure out
* how to execute this stupid shell, so I might as well give
* up in disgust ...
*/
(void) snprintf (arg0, sizeof arg0, _("Cannot execute %s"), file);
errno = err;
perror (arg0);
return err;
}
static RString GetNewWindow()
{
HWND h = GetForegroundWindow();
if( h == NULL )
return "(NULL)";
DWORD iProcessID;
GetWindowThreadProcessId( h, &iProcessID );
RString sName;
GetProcessFileName( iProcessID, sName );
sName = Basename(sName);
return sName;
}
void CheckFailure(const char* file, int line,
const char* label, const char* fmt, ...) {
char msg_buf[256];
char file_buf[256];
msg_buf[0] = '\0';
if (fmt != NULL) {
va_list ap;
va_start(ap, fmt);
PrintExtraMessage(fmt, ap, msg_buf, sizeof(msg_buf));
va_end(ap);
}
__android_log_print(ANDROID_LOG_FATAL, DEBUG_TAG,
"Aborted: %s:%d: %s %s",
Basename(file, file_buf, sizeof(file_buf)),
line, label, msg_buf);
abort();
}
/*
* @brief Loads the map or demo file and populates the server-controlled "config
* strings." We hand off the entity string to the game module, which will
* load the rest.
*/
static void Sv_LoadMedia(const char *server, sv_state_t state) {
int32_t i, map_size;
strcpy(sv.name, server);
strcpy(sv.config_strings[CS_NAME], server);
if (state == SV_ACTIVE_DEMO) { // loading a demo
sv.models[0] = Cm_LoadBsp(NULL, &map_size);
sv.demo_file = Fs_OpenRead(va("demos/%s.dem", sv.name));
svs.spawn_count = 0;
Com_Print(" Loaded demo %s.\n", sv.name);
} else { // loading a map
g_snprintf(sv.config_strings[CS_MODELS], MAX_QPATH, "maps/%s.bsp", sv.name);
sv.models[0] = Cm_LoadBsp(sv.config_strings[CS_MODELS], &map_size);
const char *dir = Fs_RealDir(sv.config_strings[CS_MODELS]);
if (g_str_has_suffix(dir, ".zip")) {
g_strlcpy(sv.config_strings[CS_ZIP], Basename(dir), MAX_QPATH);
}
for (i = 1; i < Cm_NumModels(); i++) {
char *s = sv.config_strings[CS_MODELS + i];
g_snprintf(s, MAX_QPATH, "*%d", i);
sv.models[i] = Cm_Model(s);
}
sv.state = SV_LOADING;
Sv_InitWorld();
svs.game->SpawnEntities(sv.name, Cm_EntityString());
Sv_CreateBaseline();
Com_Print(" Loaded map %s, %d entities.\n", sv.name, svs.game->num_edicts);
}
g_snprintf(sv.config_strings[CS_BSP_SIZE], MAX_QPATH, "%i", map_size);
Cvar_FullSet("map_name", sv.name, CVAR_SERVER_INFO | CVAR_NO_SET);
}
/* ---------------------------------------------------------------
* creat_r:
* Given path of a file to be made,
* get the parent's MINODE and ensure that it is a DIR
* and that the new file does not already exist in it
-------------------------------------------------------------------*/
void creat_r(char* path)
{
MINODE* pip;
char* parent, *child;
int dev, pino;
// (1) Set device according to relative or absolute pathname
if(path[0] == '/')
dev = root->dev;
else
dev = running->cwd->dev;
parent = strdup(Dirname(path));
child = strdup(Basename(path));
// (3) get in memory MINODE of parent directory
// First, get parent ino
pino = getino(&dev, parent);
// Then use it to load MINODE into minode[] table
pip = iget(dev, pino);
// (4)Verify pip
// (4.1) was found
if(pip == NULL)
{
printf("Error: unable to locate %s\n", parent);
}
// (4.2) is directory
else if(!isdir(pip))
{
printf("Error: %s is not a directory\n", parent);
}
// (4.3) does not already contain child
else if(search(pip, child) != 0) // the child was already found
{
printf("Error: %s already exists in %s\n", child, parent);
}
// (5) We've verified that parent path exists, is a directory
// and child does not exist in it, so add to it
else
my_creat(pip,child);
iput(pip);
}
void BackgroundUtil::GetSongBGAnimations( const Song *pSong, const RString &sMatch, vector<RString> &vsPathsOut, vector<RString> &vsNamesOut )
{
vsPathsOut.clear();
if( sMatch.empty() )
{
GetDirListing( pSong->GetSongDir()+"*", vsPathsOut, true, true );
}
else
{
GetDirListing( pSong->GetSongDir()+sMatch, vsPathsOut, true, true );
}
vsNamesOut.clear();
FOREACH_CONST( RString, vsPathsOut, s )
vsNamesOut.push_back( Basename(*s) );
StripCvsAndSvn( vsPathsOut, vsNamesOut );
}
void
ImageSymbolLoader::Instrument
(
IMG img
)
{
string ImageName = IMG_Name(img);
string ImageNameExt = Basename(ImageName);
ADDRINT Base = IMG_StartAddress(img);
MemRange Module(Base, IMG_SizeMapped(img));
Symbol::RefreshSymbolByIMG(img);
cerr << "[pintool] Module " << MemRangeToString(Module) << " "
<< ImageNameExt << " "
<< Symbol::SymbolInfoForModuleAtAddress(Base)
<< endl;
}
void BackgroundUtil::GetSongBitmaps( const Song *pSong, const RString &sMatch, vector<RString> &vsPathsOut, vector<RString> &vsNamesOut )
{
vsPathsOut.clear();
if( sMatch.empty() )
{
FILEMAN->GetDirListingWithMultipleExtensions(pSong->GetSongDir()+sMatch,
ActorUtil::GetTypeExtensionList(FT_Bitmap), vsPathsOut, false, true);
}
else
{
GetDirListing( pSong->GetSongDir()+sMatch, vsPathsOut, false, true );
}
vsNamesOut.clear();
FOREACH_CONST( RString, vsPathsOut, s )
vsNamesOut.push_back( Basename(*s) );
StripCvsAndSvn( vsPathsOut, vsNamesOut );
}
int main_fold(const vector<string> &args)
{
if (args.size() < 3 || args[2] == "-h")
{
cout << "usage: " << Basename(args[0]) << " " << args[1] << " <line_width>" << endl;
cout << " Reads from stdin writes folded output to stdout" << endl;
return 0;
}
int line_width = StrTo<int>(args[2]);
FoldedOutStream out(cout, line_width);
string line;
while (getline(cin, line))
{
out.Write(line + '\n');
}
return 0;
}
