/*!
\brief Finds absolute path.
\details Defined in dmzSystemFile.h.
\param[in] Path String containing path used to find the absolute (a.k.a. canonical) path
\param[out] absPath String in which the found absolute path is stored.
\return Returns dmz::True if absolute path is found.
*/
dmz::Boolean
dmz::get_absolute_path (const String &Path, String &absPath) {
Boolean result (False);
if (is_valid_path (Path)) {
if (is_directory (Path)) {
const PushDirectory Push (Path);
if (Push.is_valid ()) { result = True; absPath = get_current_directory (); }
}
else {
String spath, file, ext;
split_path_file_ext (Path, spath, file, ext);
if (!spath) { spath = "."; }
const PushDirectory Push (spath);
if (Push.is_valid ()) {
result = True;
absPath.flush () << get_current_directory () << file << ext;
}
}
absPath = format_path (absPath);
}
else { absPath.flush (); }
return result;
}
char *cibyl_select_game(char *base_dir)
{
NOPH_Display_t display = NOPH_Display_getDisplay(NOPH_MIDlet_get());
NOPH_Displayable_t cur = NOPH_Display_getCurrent(display);
NOPH_CommandMgr_t cm = NOPH_CommandMgr_getInstance();
char **p;
all_games = read_directory(get_current_directory());
if (!all_games)
return NULL;
game_list = NOPH_List_new("Select game", NOPH_Choice_IMPLICIT);
for (p = all_games; *p; p++)
{
NOPH_List_append(game_list, *p, 0);
}
NOPH_Display_setCurrent(display, game_list);
printf("Setting list\n");
NOPH_CommandMgr_setList(cm, game_list, select_game_callback, NULL);
while(selected_game == NULL)
{
NOPH_Thread_sleep(250);
}
free(all_games);
NOPH_Display_setCurrent(display, cur);
NOPH_delete(game_list);
game_list = 0;
return get_game_directory(selected_game);
}
// Check core dump limit and report possible place where core can be found
void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char* buffer, size_t bufferSize) {
struct rlimit rlim;
static char cwd[O_BUFLEN];
bool success;
get_current_directory(cwd, sizeof(cwd));
if (getrlimit(RLIMIT_CORE, &rlim) != 0) {
jio_snprintf(buffer, bufferSize, "%s/core or core.%d (may not exist)", cwd, current_process_id());
success = true;
} else {
switch(rlim.rlim_cur) {
case RLIM_INFINITY:
jio_snprintf(buffer, bufferSize, "%s/core or core.%d", cwd, current_process_id());
success = true;
break;
case 0:
jio_snprintf(buffer, bufferSize, "Core dumps have been disabled. To enable core dumping, try \"ulimit -c unlimited\" before starting Java again");
success = false;
break;
default:
jio_snprintf(buffer, bufferSize, "%s/core or core.%d (max size %lu kB). To ensure a full core dump, try \"ulimit -c unlimited\" before starting Java again", cwd, current_process_id(), (unsigned long)(rlim.rlim_cur >> 10));
success = true;
break;
}
}
VMError::report_coredump_status(buffer, success);
}
BOOL FileSystem::Initialize()
{
Log(TAG "Initializing...");
IFileSystem::Initialize();
if (!this->pWorkDir)
{
char dir[1024];
char dir2[1024];
memset(dir2, '\0', 1024);
memset(dir, '\0', 1024);
get_current_directory(dir, 1024);
snprintf(dir2, 1024, "%s/%s", dir, FILESYSTEM_DEFAULT_PATH);
Info(TAG "Working dir is: %s", dir2);
if (change_directory(dir2))
{
Log(TAG "Could not change current directory.");
}
}
this->BuildFileTable();
this->Reset();
Log(TAG "Initialization completed. Free Memory: %d.", pMemoryManager->GetFreeMemory());
return TRUE;
}
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;
}
}
void init_platform(platform *p) {
p->name = "Windows";
p->cwd = (char *)malloc(MAX_PATH * sizeof(char));
if (NULL == p->cwd) {
fprintf(stderr, "Error: Out of memory\n");
exit(EXIT_FAILURE);
}
get_current_directory();
}
/*!
\brief Returns user's home directory.
\details Defined in dmzSystemFile.h.
\return Returns String containing users home directory.
*/
dmz::String
dmz::get_home_directory () {
String result (get_env ("HOME"));
if (!result) {
const String StartDir (get_current_directory ());
if (change_directory ("~")) { result = get_current_directory (); }
change_directory (StartDir);
}
return result;
}
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;
}
bool set_current_directory(const Path& path)
{
auto nwd = path.is_absolute() ? path : get_current_directory() / path;
#ifdef PLATFORM_WIN32
auto wstring_path = to_win32(nwd.c_str());
if( !SetCurrentDirectoryW(wstring_path.c_str()) )
#else
if( chdir(nwd.c_str()) != 0 )
#endif
{
LOGW("failed to set working directory to \"%s\".", nwd.c_str());
return false;
}
s_current_dir = std::move(nwd);
return true;
}
/* Comando cd do lado do servidor */
void kermit_server_cd(int socket, const char *params, unsigned int params_length) {
char error;
fprintf(stdout, "CHANGING DIRECTORY to \"%s\"\n", params);
/* Altera o diretório corrente para o especificado */
error = change_directory(params, 0);
/* Se não houve erro durante a mudança de diretório */
if(error == KERMIT_ERROR_SUCCESS) {
/* Envia um pacote indicando que a operação foi realizada com sucesso para o cliente */
fprintf(stdout, "Directory now is \"%s\", sending OK message over network...\n", get_current_directory());
send_kermit_packet(socket, "", 0, PACKET_TYPE_OK);
fprintf(stdout, "CD operation successfully done!\n");
/* Caso ocorra algum erro durante a mudança de diretório */
} else {
/* Envia um pacote contendo o código do erro para o cliente */
fprintf(stdout, "CD operation not possible, sending error over network... ");
send_kermit_packet(socket, &error, sizeof(char), PACKET_TYPE_ERROR);
fprintf(stdout, "Done!\n");
}
}
/*
* 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 );
}
void _cdecl main (SHORT argc, char *argv[])
{
// bool ok = FALSE;
// char test[5]; // test for trap 05 errors
ULONG ulTimes; // need for Trap Ctrl-Break Signal
#ifdef TESTING
if(!dout) {
DosBeep(500,300);
}
if(!memout) {
DosBeep(1000,300);
}
#endif
#ifdef ERR_HAND
rc = set_int24();
if(rc != 0) {
err_exit("Error initializing error handler", 3);
}
MYEXCEPTIONREGISTRATIONRECORD myExceptionRegRecord;
myExceptionRegRecord.prev_structure = NULL;
myExceptionRegRecord.ExceptionHandler = MyExceptionHandler;
DosSetExceptionHandler((PEXCEPTIONREGISTRATIONRECORD) &myExceptionRegRecord);
DosSetSignalExceptionFocus(SIG_SETFOCUS, &ulTimes);
if(setjmp(myExceptionRegRecord.env))
goto OnException;
#endif
DBG_INI(dout<<"file "<<__FILE__<<" line "<<__LINE__<<" settings.numlock_on = "<<settings.numlock_on<<endl);
filesys_init();
get_current_directory(cwd); // init cur dir
Mem::vmem_setup();
strcpy(exe_dir, *argv); // assume loaded via X:\subdir\KED.EXE
DBG_FILE(dout << "EXE_DIR = " << exe_dir <<endl);
DBG_MEM(memout<< " main after except setup "<< checkmem2 << endl);
assure_windows_ready();
if(!thread_init()) {
err_exit("Error creating initial threads", 5);
}
process_env_string ("EDITOR"); /* do parameters from environment string */
strcpy (progname,*argv);
argc--; /* don't count program name */
argv++;
while (argc--) { /* process each parameter */
process_arg (*argv);
argv++;
}
if (!*settings.help_path) { /* help is usually in same dir as program */
delta_filename (settings.help_path, progname, "*.HLP");
}
//#ifdef TESTING
//if(!debug_on) {
// dout.close();
// memout.close();
//}
//#endif
assure_1_view();
DBG_INI(dout<<"edit.cpp line "<<__LINE__<<" shell_command.s = °"<<settings.shell_command.s<<"°"<<endl);
DBG_INI(dout<<"file "<<__FILE__<<" line "<<__LINE__<<" settings.numlock_on = "<<settings.numlock_on<<endl);
// ok = load_keys(); // Version 2.08
// if(!ok)
// err_exit("Failed to load Keyboard driver", 10);
edit_loop();
// test[5000] = 'A'; // test trap array bounds
goto Ked_Exit;
OnException:
#ifdef ERR_HAND
DosUnsetExceptionHandler((PEXCEPTIONREGISTRATIONRECORD) &myExceptionRegRecord);
// Screen.term_mess = "application trapped";
err_exit(" application trapped", 20);
#endif
Ked_Exit:
#ifdef ERR_HAND
if(ORG_NUMLOCK) {
DBG_NUML(dout<<" exit - setting NUMLOCK on"<<endl);
numlock_set(TRUE);
}
else {
DBG_NUML(dout<<" exit - setting NUMLOCK off"<<endl);
numlock_set(FALSE);
}
DosUnsetExceptionHandler((PEXCEPTIONREGISTRATIONRECORD) &myExceptionRegRecord);
#endif
DBG_MEM(memout<< " main after except setup "<< checkmem2 << endl);
DBG_BUGS(dout<<'\n'<<" Normal Closedown in LOGFILE "<<endl);
}
