int cmd_cd(int argc, const char** argv)
{
char dir[256] = "";
if (argc == 2)
{
if (set_current_directory(argv[1]))
msgf(STR_CHDIR_ERROR);
}
else
{
if (get_current_directory(dir, sizeof(dir)) == 0)
printf("%s\n", dir);
}
return 0;
}
static int parse_args(ArgumentInfo *ai, int argc, const char **argv)
{
if (argc >= 2) {
const char *srcfile = NULL;
const char *arg_file = argv[1];
char *pwd;
if (is_absolute_path(arg_file, -1)) {
Str curdir_s = base_dir_with_sep(arg_file, -1);
char *curdir_p = str_dup_p(curdir_s.p, curdir_s.size, NULL);
set_current_directory(curdir_p);
free(curdir_p);
pwd = get_current_directory();
srcfile = arg_file;
} else {
// 相対パス
pwd = get_current_directory();
srcfile = str_printf("%s" SEP_S "%s", pwd, arg_file);
}
{
// カレントディレクトリの末尾に/を付ける
int pwd_len = strlen(pwd);
RefStr *rs = refstr_new_n(fs->cls_file, pwd_len + 1);
memcpy(rs->c, pwd, pwd_len);
if (rs->c[pwd_len - 1] != SEP_C) {
rs->c[pwd_len] = SEP_C;
rs->c[pwd_len + 1] = '\0';
} else {
rs->size = pwd_len;
rs->c[pwd_len] = '\0';
}
fv->cur_dir = rs;
free(pwd);
}
ai->srcfile = srcfile;
fv->argc = argc - 2;
fv->argv = argv + 2;
return TRUE;
} else {
print_foxinfo();
return FALSE;
}
}
/*
* Name: list_and_pick
* Purpose: To show matching file names and let user pick a file
* Date: February 13, 1992
* Passed: dname: directory search pattern
* stem: stem of directory search pattern
* window: pointer to current window
* Returns: return code from pick. rc = OK, then edit a new file.
* Notes: real work routine of this function. save the cwd and let the
* user search upwards or downwards thru the directory structure.
* since we are doing DOS directory functions, we need to check the
* return code after each DOS call for critical errors.
*/
int list_and_pick( char *dname, char *stem, WINDOW *window )
{
int rc;
DTA dta; /* disk transfer address for findfirst */
DIRECTORY dir; /* contains all info for dir display */
unsigned int cnt; /* number of matching files */
FTYPE *flist, *p; /* pointer to list of matching files */
char cwd[MAX_COLS]; /* save the current working directory in this buff */
char dbuff[MAX_COLS]; /* temporary directory buff */
char prefix[MAX_COLS]; /* directory prefix */
int change_directory = FALSE;
int stop;
int len;
int drive;
/*
* Some algorithms alloc the maximum possible number of files in
* a directory, eg. 256 or 512. Let's count the number of matching
* files so we know egxactly how much memory to request from calloc.
* Depending on the op system, disk media, disk format, or version of DOS,
* the max number of files may vary, anyway, also, additionally.
*/
rc = my_findfirst( &dta, dname, NORMAL | READ_ONLY | HIDDEN | SYSTEM |
SUBDIRECTORY | ARCHIVE );
if (rc != ERROR) {
for (cnt=1; (rc = my_findnext( &dta )) == OK;)
++cnt;
flist = (FTYPE *)calloc( cnt, sizeof(FTYPE) );
} else
flist = NULL;
if (rc != ERROR && flist != NULL) {
stop = FALSE;
/*
* If user entered drive name in search pattern, find out the drive and
* directory stem.
*/
if (stem[1] == ':') {
/*
* If the second character of the search pattern is a ':', the
* the first character of the pattern should be the drive.
* Convert drive to lower case and get a numerical representation.
* CAVEAT: In DOS v 2.x, there may be up to 63 logical drives.
* my algorithm may blow up if the number of logical drives
* is greater than 'Z'.
* For DOS >= 3, the number of drives is limited to 26, I think.
*/
drive = stem[0];
if (drive < 'a')
drive += 32;
drive = drive - 'a' + 1;
rc = get_current_directory( dbuff, drive );
if (rc == ERROR)
stop = TRUE;
else {
/*
* Put drive letter, ':', and '\' in front of current directory.
*/
prefix[0] = (char)(drive - 1 + 'a');
prefix[1] = ':';
prefix[2] = '\\';
prefix[3] = '\0';
assert( strlen( prefix ) + strlen( dbuff ) < MAX_COLS );
strcpy( cwd, prefix );
strcat( cwd, dbuff );
}
/*
* else get current directory from default drive
*/
} else {
/*
* 0 = default drive.
*/
drive = 0;
rc = get_current_directory( dbuff, drive );
if (rc == ERROR)
stop = TRUE;
else {
/*
* Put a '\' in front of the current directory.
*/
prefix[0] = '\\';
prefix[1] = '\0';
assert( strlen( prefix ) + strlen( dbuff ) < MAX_COLS );
strcpy( cwd, prefix );
strcat( cwd, dbuff );
}
}
while (stop == FALSE) {
/*
* If we had enough memory, find all matching file names. Append
* '\\' at the end of subdirectory names so user will know if
* name is a directory. Might as well find everything, because
* i also forget subdirectory names, too.
*
* when we get here, we have already done: 1) my_findfirst and
* my_findnext, 2) counted the number of matching files, and
* 3) allocated space.
*/
p = flist;
cnt = 0;
rc = my_findfirst( &dta, dname, NORMAL | READ_ONLY | HIDDEN | SYSTEM |
SUBDIRECTORY | ARCHIVE );
if (rc != ERROR) {
/*
* p is pointer that walks down the file info structure.
* save the file name, file size, and directory character,
* if needed, for each matching file we find.
*/
assert( strlen( dta.name ) < 14 );
strcpy( p->fname, dta.name );
p->fsize = dta.size;
if (dta.attrib & SUBDIRECTORY)
strcat( p->fname, "\\" );
for (cnt=1; (rc = my_findnext( &dta )) == OK; ) {
++p;
assert( strlen( dta.name ) < 14 );
strcpy( p->fname, dta.name );
p->fsize = dta.size;
if (dta.attrib & SUBDIRECTORY)
strcat( p->fname, "\\" );
cnt++;
}
}
if (rc != ERROR) {
shell_sort( flist, cnt );
/*
* figure out number of rows, cols, etc... then display dir list
*/
setup_directory_window( &dir, cnt );
write_directory_list( flist, dir );
/*
* Let user select file name or another search directory.
* Save the choice in dbuff. rc == OK if user selected file or dir.
*/
rc = select_file( flist, stem, &dir );
assert( strlen( flist[dir.select].fname ) < MAX_COLS );
strcpy( dbuff, flist[dir.select].fname );
}
/*
* give memory back.
*/
free( flist );
if (rc == ERROR)
stop = TRUE;
else {
len = strlen( dbuff );
/*
* If the last character in a file name is '\' then let's
* do a dir on selected directory. See the matching
* else when the user selects a file.
*/
if (dbuff[len-1] == '\\') {
/*
* Stem has subdirectory path. dbuff has selected path.
* Create a new dname with stem and dbuff.
*/
assert( strlen( stem ) + strlen( dbuff ) < MAX_COLS );
strcpy( dname, stem );
strcat( dname, dbuff );
len = strlen( dname );
strcpy( dbuff, dname );
/*
* The last character in dbuff is '\', because we append the
* '\' to every directory entry in the file list. Replace
* it with a NULL char then we will have a valid path name.
*/
dbuff[len-1] = '\0';
/*
* now let's change to the selected subdirectory.
*/
rc = set_current_directory( dbuff );
if (rc == OK) {
/*
* Every time we change directories, we need to get the
* current directory so we will be sure to have the
* correct path.
*/
rc = get_current_directory( dbuff, drive );
if (rc == OK) {
assert( strlen( prefix ) + strlen( dbuff ) < MAX_COLS );
strcpy( dname, prefix );
strcat( dname, dbuff );
change_directory = TRUE;
}
}
/*
* Validate the new path and allocate memory for the
* matching files.
*/
if (rc == OK)
rc = validate_path( dname, stem );
if (rc == OK) {
rc = my_findfirst( &dta, dname, NORMAL | READ_ONLY | HIDDEN |
SYSTEM | SUBDIRECTORY | ARCHIVE );
if (rc != ERROR) {
for (cnt=1; (rc = my_findnext( &dta )) == OK;)
++cnt;
flist = (FTYPE *)calloc( cnt, sizeof(FTYPE) );
}
}
if (flist == NULL || rc == ERROR) {
stop = TRUE;
rc = ERROR;
}
} else {
/*
* user selected a file. store fname in dname and return.
*/
rc = OK;
stop = TRUE;
assert( strlen( stem ) + strlen( dbuff ) < MAX_COLS );
strcpy( dname, stem );
strcat( dname, dbuff );
}
}
}
/*
* Go back to the current directory if needed.
*/
if (change_directory)
set_current_directory( cwd );
if (window != NULL)
redraw_screen( window );
} else {
/*
* out of memory
*/
error( WARNING, window != NULL ? window->bottom_line : g_display.nlines,
dir3 );
rc = ERROR;
}
return( rc );
}
