/* If path looks like: A/B/C/D/whatever, it returns A/B/C/D as a malloced
* string.
*/
char *SLpath_dirname (SLFUTURE_CONST char *file)
{
SLCONST char *b;
if (file == NULL) return NULL;
b = file + strlen (file);
while (b != file)
{
b--;
if (IS_PATH_SEP(*b))
{
#ifdef VMS
b++; /* make sure final ] is included */
#else
if (b == file) b++;
#endif
break;
}
#ifdef DRIVE_SPECIFIER
if (*b == DRIVE_SPECIFIER)
{
b++;
break;
}
#endif
}
if (b == file)
return SLmake_string (THIS_DIR_STRING);
return SLmake_nstring (file, (unsigned int) (b - file));
}
/* Returns a malloced string */
char *SLpath_pathname_sans_extname (SLFUTURE_CONST char *drivefile)
{
char *b;
char *file;
drivefile = SLmake_string (drivefile);
if (drivefile == NULL)
return NULL;
file = (char *)skip_drive (drivefile);
b = file + strlen (file);
while (b != file)
{
b--;
if (IS_PATH_SEP(*b))
break;
if (*b == '.')
{
*b = 0;
break;
}
}
return drivefile;
}
/* Returns a malloced string */
char *SLpath_pathname_sans_extname (SLFUTURE_CONST char *file)
{
char *b;
file = SLmake_string (file);
if (file == NULL)
return NULL;
b = (char *) file + strlen (file);
while (b != file)
{
b--;
if (IS_PATH_SEP(*b))
break;
#ifdef DRIVE_SPECIFIER
if (*b == DRIVE_SPECIFIER)
{
b++;
break;
}
#endif
if (*b == '.')
{
*b = 0;
return (char *) file;
}
}
return (char *) file;
}
int SLrline_set_line (SLrline_Type *rli, SLFUTURE_CONST char *buf)
{
unsigned int len;
if (rli == NULL)
return -1;
if (buf == NULL)
buf = "";
len = strlen (buf);
buf = SLmake_string (buf);
if (buf == NULL)
return -1;
SLfree ((char *)rli->buf);
rli->buf = (unsigned char *)buf;
rli->buf_len = len;
rli->point = len;
rli->len = len;
rli->state = RLI_LINE_SET;
return 0;
}
static char *arith_string (SLtype type, VOID_STAR v)
{
char buf [1024];
char *s;
s = buf;
switch (type)
{
default:
s = (char *) SLclass_get_datatype_name (type);
break;
case SLANG_CHAR_TYPE:
sprintf (s, "%d", *(char *) v);
break;
case SLANG_UCHAR_TYPE:
sprintf (s, "%u", *(unsigned char *) v);
break;
case SLANG_SHORT_TYPE:
sprintf (s, "%d", *(short *) v);
break;
case SLANG_USHORT_TYPE:
sprintf (s, "%u", *(unsigned short *) v);
break;
case SLANG_INT_TYPE:
sprintf (s, "%d", *(int *) v);
break;
case SLANG_UINT_TYPE:
sprintf (s, "%u", *(unsigned int *) v);
break;
case SLANG_LONG_TYPE:
sprintf (s, "%ld", *(long *) v);
break;
case SLANG_ULONG_TYPE:
sprintf (s, "%lu", *(unsigned long *) v);
break;
#ifdef HAVE_LONG_LONG
case SLANG_LLONG_TYPE:
sprintf (s, "%lld", *(long long *) v);
break;
case SLANG_ULLONG_TYPE:
sprintf (s, "%llu", *(unsigned long long *) v);
break;
#endif
#if SLANG_HAS_FLOAT
case SLANG_FLOAT_TYPE:
if (EOF == SLsnprintf (buf, sizeof (buf), Double_Format, *(float *) v))
sprintf (s, "%e", *(float *) v);
break;
case SLANG_DOUBLE_TYPE:
if (EOF == SLsnprintf (buf, sizeof (buf), Double_Format, *(double *) v))
sprintf (s, "%e", *(double *) v);
break;
#endif
}
return SLmake_string (s);
}
int SLrline_init (SLFUTURE_CONST char *appname, SLFUTURE_CONST char *user_initfile, SLFUTURE_CONST char *sys_initfile)
{
#ifdef __WIN32__
char *home_dir = getenv ("USERPROFILE");
#else
# ifdef VMS
char *home_dir = "SYS$LOGIN:"******"HOME");
# endif
#endif
char *file = NULL;
int status;
static char *appname_malloced;
if (sys_initfile == NULL)
sys_initfile = SLRLINE_SYS_INIT_FILE;
if (user_initfile == NULL)
user_initfile = SLRLINE_USER_INIT_FILE;
if (appname == NULL)
appname = "Unknown";
if (NULL == (appname_malloced = SLmake_string (appname)))
return -1;
if (-1 == SLadd_intrinsic_variable ("__RL_APP__", &appname_malloced, SLANG_STRING_TYPE, 1))
return -1;
if (-1 == SLadd_intrin_fun_table (Intrinsics, NULL))
return -1;
if (-1 == init_keymap ())
return -1;
if (user_initfile != NULL)
{
file = SLpath_find_file_in_path (home_dir, user_initfile);
if (file != NULL)
{
status = SLns_load_file (file, NULL);
SLfree (file);
return status;
}
}
if (sys_initfile != NULL)
{
file = _pSLpath_find_file (sys_initfile, 0);
if (file != NULL)
{
status = SLns_load_file (file, NULL);
SLang_free_slstring (file);
return status;
}
}
return 0;
}
static char *ref_string (SLtype type, VOID_STAR ptr)
{
SLang_Ref_Type *ref;
(void) type;
ref = *(SLang_Ref_Type **) ptr;
if (ref->string != NULL)
return ref->string (ref->data);
return SLmake_string ("Ref_Type");
}
static char *string_method (SLtype type, VOID_STAR p)
{
SLang_List_Type *list;
char buf[256];
(void) type;
list = *(SLang_List_Type **) p;
sprintf (buf, "List_Type with %ld elements", (long)list->length);
return SLmake_string (buf);
}
static char *read_with_no_readline (char *prompt, int noecho)
{
char *line;
#ifdef REAL_UNIX_SYSTEM
int stdin_is_noecho = 0;
#endif
char buf[1024];
char *b;
fprintf (stdout, "%s", prompt);
fflush (stdout);
if (noecho)
{
#ifdef REAL_UNIX_SYSTEM
if (isatty (fileno(stdin)))
{
(void) SLsystem ("stty -echo"); /* yuk */
stdin_is_noecho = 1;
}
#endif
}
line = buf;
while (NULL == fgets (buf, sizeof (buf), stdin))
{
#ifdef EINTR
if (errno == EINTR)
{
if (-1 == SLang_handle_interrupt ())
{
line = NULL;
break;
}
continue;
}
#endif
line = NULL;
break;
}
#ifdef REAL_UNIX_SYSTEM
if (stdin_is_noecho)
(void) SLsystem ("stty echo");
#endif
if (line == NULL)
return NULL;
/* Remove the final newline */
b = line;
while (*b && (*b != '\n'))
b++;
*b = 0;
return SLmake_string (line);
}
static char *bstring_string (unsigned char type, VOID_STAR v)
{
SLang_BString_Type *s;
unsigned char buf[128];
unsigned char *bytes, *bytes_max;
unsigned char *b, *bmax;
(void) type;
s = *(SLang_BString_Type **) v;
bytes = BS_GET_POINTER(s);
bytes_max = bytes + s->len;
b = buf;
bmax = buf + (sizeof (buf) - 4);
while (bytes < bytes_max)
{
unsigned char ch = *bytes;
if ((ch < 32) || (ch >= 127) || (ch == '\\'))
{
if (b + 4 > bmax)
break;
sprintf ((char *) b, "\\%03o", ch);
b += 4;
}
else
{
if (b == bmax)
break;
*b++ = ch;
}
bytes++;
}
if (bytes < bytes_max)
{
*b++ = '.';
*b++ = '.';
*b++ = '.';
}
*b = 0;
return SLmake_string ((char *)buf);
}
int SLpop_string (char **s) /*{{{*/
{
char *sls;
*s = NULL;
if (-1 == SLang_pop_slstring (&sls))
return -1;
if (NULL == (*s = SLmake_string (sls)))
{
SLang_free_slstring (sls);
return -1;
}
SLang_free_slstring (sls);
return 0;
}
static File_Line_Type *create_line (char *buf)
{
File_Line_Type *line;
line = (File_Line_Type *) malloc (sizeof (File_Line_Type));
if (line == NULL) return NULL;
memset ((char *) line, 0, sizeof (File_Line_Type));
line->data = SLmake_string (buf); /* use a slang routine */
if (line->data == NULL)
{
free (line);
return NULL;
}
return line;
}
static char *default_string (SLtype stype, VOID_STAR v)
{
char buf [256];
char *s;
#if SLANG_HAS_COMPLEX
double *cplx;
#endif
s = buf;
switch (stype)
{
case SLANG_STRING_TYPE:
s = *(char **) v;
break;
case SLANG_NULL_TYPE:
s = (char *) "NULL";
break;
case SLANG_DATATYPE_TYPE:
s = (char *) SLclass_get_datatype_name ((SLtype) *(int *)v);
break;
#if SLANG_HAS_COMPLEX
case SLANG_COMPLEX_TYPE:
cplx = *(double **) v;
if (cplx[1] < 0)
sprintf (s, "(%g - %gi)", cplx [0], -cplx [1]);
else
sprintf (s, "(%g + %gi)", cplx [0], cplx [1]);
break;
#endif
default:
s = (char *) SLclass_get_datatype_name (stype);
}
return SLmake_string (s);
}
int
sys_System(char *command_line1)
{
int ret = -1, handles, argc = 0;
char *fname = NULL, **argv = NULL, *command_line;
if (NULL == (command_line = SLmake_string (command_line1)))
return -1;
handles = parse_command_line( &argc, &argv, &fname, command_line );
/* Note: The argc that is passed bacl has nothing to do with the
* actual number of arguments in argv if there are redirections involved.
* However, if it is non-zero then argv was malloced.
*/
if (argc)
{
ret = execute_the_command (argv, handles, fname);
SLfree((char *)argv);
}
SLfree (command_line);
return ret;
}
static char *read_input_line (SLang_RLine_Info_Type *rline, char *prompt, int noecho)
{
char *line;
#ifdef REAL_UNIX_SYSTEM
int stdin_is_noecho = 0;
#endif
if (Use_Readline == 0)
{
char buf[1024];
char *b;
fprintf (stdout, "%s", prompt); fflush (stdout);
if (noecho)
{
#ifdef REAL_UNIX_SYSTEM
if (isatty (fileno(stdin)))
{
(void) SLsystem ("stty -echo"); /* yuk */
stdin_is_noecho = 1;
}
#endif
}
line = buf;
while (NULL == fgets (buf, sizeof (buf), stdin))
{
#ifdef EINTR
if (errno == EINTR)
{
if (-1 == SLang_handle_interrupt ())
{
line = NULL;
break;
}
continue;
}
#endif
line = NULL;
break;
}
#ifdef REAL_UNIX_SYSTEM
if (stdin_is_noecho)
(void) SLsystem ("stty echo");
#endif
if (line == NULL)
return NULL;
/* Remove the final newline */
b = line;
while (*b && (*b != '\n'))
b++;
*b = 0;
return SLmake_string (line);
}
#if SYSTEM_SUPPORTS_SIGNALS
init_tty ();
#endif
#if USE_GNU_READLINE
(void) rline;
if (noecho == 0)
rl_redisplay_function = rl_redisplay;
else
{
/* FIXME: What is the proper way to implement this in GNU readline? */
(void) fputs (prompt, stdout); (void) fflush (stdout);
rl_redisplay_function = redisplay_dummy;
}
line = readline (prompt);
rl_redisplay_function = rl_redisplay;
#else
SLtt_get_screen_size ();
SLrline_set_display_width (rline, SLtt_Screen_Cols);
(void) add_sigwinch_handlers ();
Active_Rline_Info = rline;
(void) SLrline_set_echo (rline, (noecho == 0));
line = SLrline_read_line (rline, prompt, NULL);
Active_Rline_Info = NULL;
#endif
#if SYSTEM_SUPPORTS_SIGNALS
reset_tty ();
#else
fputs ("\r\n", stdout);
fflush (stdout);
#endif
return line;
}
static Handle_Type *dynamic_link_module (SLFUTURE_CONST char *module)
{
Handle_Type *h;
VOID_STAR handle;
SLFUTURE_CONST char *err;
char filebuf[1024];
char *save_file;
char *save_err;
int api_version;
int *api_version_ptr;
#define MAX_MODULE_NAME_SIZE 256
char module_so[MAX_MODULE_NAME_SIZE + 32];
char *module_name;
char *file, *pathfile;
if (strlen (module) >= MAX_MODULE_NAME_SIZE)
{
_pSLang_verror (SL_LimitExceeded_Error, "module name too long");
return NULL;
}
SLsnprintf (module_so, sizeof(module_so), "%s-module.%s", module, SO_SUFFIX);
if (Module_Path != NULL)
pathfile = SLpath_find_file_in_path (Module_Path, module_so);
else pathfile = NULL;
if ((pathfile == NULL)
&& (NULL != (pathfile = _pSLsecure_getenv (MODULE_PATH_ENV_NAME))))
pathfile = SLpath_find_file_in_path (pathfile, module_so);
if (pathfile == NULL)
pathfile = SLpath_find_file_in_path (MODULE_INSTALL_DIR, module_so);
if (pathfile != NULL)
file = pathfile;
else
file = module_so;
save_err = NULL;
save_file = file;
while (1)
{
#ifndef RTLD_GLOBAL
# define RTLD_GLOBAL 0
#endif
#ifdef RTLD_NOW
handle = (VOID_STAR) dlopen (file, RTLD_NOW | RTLD_GLOBAL);
#else
handle = (VOID_STAR) dlopen (file, RTLD_LAZY | RTLD_GLOBAL);
#endif
if (handle != NULL)
{
if (_pSLang_Load_File_Verbose & SLANG_LOAD_MODULE_VERBOSE)
SLang_vmessage ("Importing %s", file);
if (save_err != NULL)
SLfree (save_err);
break;
}
/* Purify reports that dlerror returns a pointer that generates UMR
* errors. There is nothing that I can do about that....
*/
if ((NULL == strchr (file, '/'))
&& (strlen(file) < sizeof(filebuf)))
{
err = (char *) dlerror ();
if (err != NULL)
save_err = SLmake_string (err);
SLsnprintf (filebuf, sizeof (filebuf), "./%s", file);
file = filebuf;
continue;
}
if ((NULL == (err = save_err))
&& (NULL == (err = (char *) dlerror ())))
err = "UNKNOWN";
_pSLang_verror (SL_Import_Error,
"Error linking to %s: %s", save_file, err);
if (save_err != NULL)
SLfree (save_err);
if (pathfile != NULL)
SLfree (pathfile);
return NULL;
}
/* Using SLpath_basename allows, e.g., import ("/path/to/module"); */
module_name = SLpath_basename (module);
api_version_ptr = (int *) do_dlsym (handle, file, 0, "SLmodule_%s_api_version", module_name);
if (api_version_ptr == NULL)
api_version_ptr = (int *) do_dlsym (handle, file, 0, "_SLmodule_%s_api_version", module_name);
if (api_version_ptr == NULL)
api_version = 0;
else
api_version = *api_version_ptr;
if ((-1 == check_api_version (file, api_version))
|| (NULL == (h = allocate_handle_type (module, handle))))
{
SLfree (pathfile); /* NULL ok */
dlclose (handle);
return NULL;
}
if (NULL == (h->ns_init_fun = (int (*)(SLCONST char *)) do_dlsym (handle, file, 1, "init_%s_module_ns", module_name)))
{
SLfree (pathfile);
free_handle_type (h);
dlclose (handle);
return NULL;
}
h->deinit_fun = (void (*)(void)) do_dlsym (handle, file, 0, "deinit_%s_module", module_name);
SLfree (pathfile); /* NULL ok */
h->next = Handle_List;
Handle_List = h;
return h;
}
int main (int argc, char **argv)
{
int i;
int utf8 = 0;
for (i = 1; i < argc; i++)
{
char *arg = argv[i];
if (*arg != '-')
break;
if (0 == strcmp (arg, "-utf8"))
{
utf8 = 1;
continue;
}
i = argc;
}
if (i >= argc)
{
fprintf (stderr, "Usage: %s [-utf8] FILE...\n", argv[0]);
return 1;
}
(void) SLutf8_enable (utf8);
if ((-1 == SLang_init_all ())
|| (-1 == SLang_init_array_extra ())
|| (-1 == SLadd_intrin_fun_table (Intrinsics, NULL))
|| (-1 == add_test_classes ()))
return 1;
SLang_Traceback = 1;
if (-1 == SLang_set_argc_argv (argc, argv))
return 1;
#ifdef HAVE_FPSETMASK
# ifndef FP_X_OFL
# define FP_X_OFL 0
# endif
# ifndef FP_X_INV
# define FP_X_INV 0
# endif
# ifndef FP_X_DZ
# define FP_X_DZ 0
# endif
# ifndef FP_X_DNML
# define FP_X_DNML 0
# endif
# ifndef FP_X_UFL
# define FP_X_UFL 0
# endif
# ifndef FP_X_IMP
# define FP_X_IMP 0
# endif
fpsetmask (~(FP_X_OFL|FP_X_INV|FP_X_DZ|FP_X_DNML|FP_X_UFL|FP_X_IMP));
#endif
if (i + 1 < argc)
Ignore_Exit = 1;
while (i < argc)
{
char *file = argv[i];
if (0 == strncmp (SLpath_extname (file), ".slc", 4))
{
char *file_sl = SLmake_string (file);
file_sl[strlen(file_sl)-1] = 0;
if (-1 == SLang_byte_compile_file (file_sl, 0))
{
SLfree (file_sl);
return 1;
}
SLfree (file_sl);
}
if (-1 == SLang_load_file (file))
return 1;
i++;
}
return SLang_get_error ();
}
static int get_doc_string (char *file, char *topic)
{
FILE *fp;
char line[1024];
unsigned int topic_len, str_len;
char *str;
char ch;
if (NULL == (fp = fopen (file, "r")))
return -1;
topic_len = strlen (topic);
ch = *topic;
while (1)
{
if (NULL == fgets (line, sizeof(line), fp))
{
fclose (fp);
return -1;
}
if ((ch == *line)
&& (0 == strncmp (line, topic, topic_len))
&& ((line[topic_len] == '\n') || (line [topic_len] == 0)
|| (line[topic_len] == ' ') || (line[topic_len] == '\t')))
break;
}
if (NULL == (str = SLmake_string (line)))
{
fclose (fp);
return -1;
}
str_len = strlen (str);
while (NULL != fgets (line, sizeof (line), fp))
{
unsigned int len;
char *new_str;
ch = *line;
if (ch == '#') continue;
if (ch == '-') break;
len = strlen (line);
if (NULL == (new_str = SLrealloc (str, str_len + len + 1)))
{
SLfree (str);
str = NULL;
break;
}
str = new_str;
strcpy (str + str_len, line);
str_len += len;
}
fclose (fp);
(void) SLang_push_malloced_string (str);
return 0;
}
int SLcmd_execute_string (char *str, SLcmd_Cmd_Table_Type *table)
{
char *s, *arg_type, *last_str, *cmd_name;
SLcmd_Cmd_Type *cmd;
char *buf;
int token_present;
int i;
int status;
unsigned int len;
int argc;
unsigned int space;
table->argc = 0;
table->string_args = NULL;
table->int_args = NULL;
table->double_args = NULL;
table->arg_type = NULL;
buf = SLmake_string (str);
if (buf == NULL)
return -1;
status = extract_token (&str, buf);
if (status <= 0)
{
SLfree (buf);
return status;
}
if (((len = strlen (buf)) >= 32)
|| (NULL == (cmd = SLcmd_find_command (buf, table->table))))
{
SLang_verror (SL_UNDEFINED_NAME,"%s: invalid command", buf);
SLfree (buf);
return -1;
}
if (NULL == (cmd_name = SLmake_string (buf)))
{
SLfree (buf);
return -1;
}
space = 0;
argc = 0;
if (-1 == allocate_arg_space (table, argc, &space))
{
SLfree (buf);
return -1;
}
table->arg_type[argc] = SLANG_STRING_TYPE;
table->string_args[argc++] = cmd_name;
arg_type = cmd->arg_type;
status = -1;
while (*arg_type)
{
int guess_type = 0;
last_str = str;
if (-1 == allocate_arg_space (table, argc, &space))
goto error;
if (-1 == (token_present = extract_token (&str, buf)))
goto error;
table->string_args[argc] = NULL;
if (token_present)
{
char *b = buf;
len = strlen (b);
if ((*b == '"') && (len > 1))
{
b++;
len -= 2;
b[len] = 0;
guess_type = SLANG_STRING_TYPE;
SLexpand_escaped_string (buf, b, b + len);
len = strlen (buf);
}
else if ((*b == '\'') && (len > 1))
{
char ch;
b++;
len -= 2;
b[len] = 0;
guess_type = SLANG_INT_TYPE;
ch = *b;
if (ch == '\\')
(void) _SLexpand_escaped_char (b, &ch);
sprintf (buf, "%d", (unsigned char) ch);
len = strlen (buf);
}
else guess_type = SLang_guess_type (buf);
}
switch (*arg_type++)
{
/* variable argument number */
case 'v':
if (token_present == 0) break;
case 'V':
if (token_present == 0)
{
SLang_verror (SL_INVALID_PARM, "%s: Expecting argument", cmd_name);
goto error;
}
while (*last_str == ' ') last_str++;
len = strlen (last_str);
str = last_str + len;
s = SLmake_nstring (last_str, len);
if (s == NULL) goto error;
table->arg_type[argc] = SLANG_STRING_TYPE;
table->string_args[argc++] = s;
break;
case 's':
if (token_present == 0) break;
case 'S':
if (token_present == 0)
{
SLang_verror (SL_TYPE_MISMATCH, "%s: Expecting string argument", cmd_name);
goto error;
}
s = SLmake_nstring (buf, len);
if (s == NULL) goto error;
table->arg_type[argc] = SLANG_STRING_TYPE;
table->string_args[argc++] = s;
break;
/* integer argument */
case 'i':
if (token_present == 0) break;
case 'I':
if ((token_present == 0) || (SLANG_INT_TYPE != guess_type))
{
SLang_verror (SL_TYPE_MISMATCH, "%s: Expecting integer argument", cmd_name);
goto error;
}
table->arg_type[argc] = SLANG_INT_TYPE;
table->int_args[argc++] = SLatoi((unsigned char *) buf);
break;
/* floating point arg */
#if SLANG_HAS_FLOAT
case 'f':
if (token_present == 0) break;
case 'F':
if ((token_present == 0) || (SLANG_STRING_TYPE == guess_type))
{
SLang_verror (SL_TYPE_MISMATCH, "%s: Expecting double argument", cmd_name);
goto error;
}
table->arg_type[argc] = SLANG_DOUBLE_TYPE;
table->double_args[argc++] = atof(buf);
break;
#endif
/* Generic type */
case 'g':
if (token_present == 0) break;
case 'G':
if (token_present == 0)
{
SLang_verror (SL_TYPE_MISMATCH, "%s: Expecting argument", cmd_name);
goto error;
}
switch (guess_type)
{
case SLANG_INT_TYPE:
table->arg_type[argc] = SLANG_INT_TYPE;
table->int_args[argc++] = SLatoi((unsigned char *) buf);
break;
case SLANG_STRING_TYPE:
s = SLmake_nstring (buf, len);
if (s == NULL) goto error;
table->arg_type[argc] = SLANG_STRING_TYPE;
table->string_args[argc++] = s;
break;
#if SLANG_HAS_FLOAT
case SLANG_DOUBLE_TYPE:
table->arg_type[argc] = SLANG_DOUBLE_TYPE;
table->double_args[argc++] = atof(buf);
#endif
}
break;
}
}
/* call function */
status = (*cmd->cmdfun)(argc, table);
error:
if (table->string_args != NULL) for (i = 0; i < argc; i++)
{
if (NULL != table->string_args[i])
{
SLfree (table->string_args[i]);
table->string_args[i] = NULL;
}
}
SLfree ((char *)table->string_args); table->string_args = NULL;
SLfree ((char *)table->double_args); table->double_args = NULL;
SLfree ((char *)table->int_args); table->int_args = NULL;
SLfree ((char *)table->arg_type); table->arg_type = NULL;
SLfree (buf);
return status;
}
char *SLpath_find_file_in_path (SLFUTURE_CONST char *path, SLFUTURE_CONST char *name)
{
unsigned int max_path_len;
unsigned int this_path_len;
char *file, *dir;
SLCONST char *p;
unsigned int nth;
if ((path == NULL) || (*path == 0)
|| (name == NULL) || (*name == 0))
return NULL;
if (is_relatively_absolute (name))
{
if (0 == SLpath_file_exists (name))
return NULL;
return SLmake_string (name);
}
/* Allow "." to mean the current directory on all systems */
if ((path[0] == '.') && (path[1] == 0))
{
if (0 == SLpath_file_exists (name))
return NULL;
return SLpath_dircat (THIS_DIR_STRING, name);
}
max_path_len = 0;
this_path_len = 0;
p = path;
while (*p != 0)
{
if (*p++ == Path_Delimiter)
{
if (this_path_len > max_path_len) max_path_len = this_path_len;
this_path_len = 0;
}
else this_path_len++;
}
if (this_path_len > max_path_len) max_path_len = this_path_len;
max_path_len++;
if (NULL == (dir = (char *)SLmalloc (max_path_len)))
return NULL;
nth = 0;
while (-1 != SLextract_list_element ((char *) path, nth, Path_Delimiter,
dir, max_path_len))
{
nth++;
if (*dir == 0)
continue;
if (NULL == (file = SLpath_dircat (dir, name)))
{
SLfree (dir);
return NULL;
}
if (1 == SLpath_file_exists (file))
{
SLfree (dir);
return file;
}
SLfree (file);
}
SLfree (dir);
return NULL;
}
char *SLrline_read_line (SLrline_Type *rli, SLFUTURE_CONST char *prompt, unsigned int *lenp)
{
unsigned char *p, *pmax;
SLang_Key_Type *key;
int last_input_char;
unsigned int dummy_len_buf;
if (lenp == NULL)
lenp = &dummy_len_buf;
*lenp = 0;
if (rli == NULL)
return NULL;
if (rli->state == RLI_LINE_IN_PROGRESS)
{
*lenp = 0;
return NULL;
}
if (prompt == NULL)
prompt = "";
if ((rli->prompt == NULL)
|| strcmp (rli->prompt, prompt))
{
if (NULL == (prompt = SLmake_string (prompt)))
return NULL;
SLfree ((char *)rli->prompt);
rli->prompt = prompt;
}
SLang_Rline_Quit = 0;
p = rli->old_upd; pmax = p + rli->edit_width;
while (p < pmax) *p++ = ' ';
if (rli->state != RLI_LINE_SET)
{
rli->len = 0;
rli->point = 0;
*rli->buf = 0;
}
rli->state = RLI_LINE_IN_PROGRESS;
rli->curs_pos = rli->start_column = 0;
rli->new_upd_len = rli->old_upd_len = 0;
rli->last_fun = NULL;
if (rli->update_hook == NULL)
putc ('\r', stdout);
rli->is_modified = 0;
rli->last = NULL;
RLupdate (rli);
last_input_char = 0;
while (1)
{
SLrline_Type *save_rli = Active_Rline_Info;
key = SLang_do_key (RL_Keymap, (int (*)(void)) rli->getkey);
if ((key == NULL) || (key->f.f == NULL))
{
rl_beep ();
continue;
}
if ((*key->str != 2) || (key->str[1] != rli->eof_char))
last_input_char = 0;
else
{
if ((rli->len == 0) && (last_input_char != rli->eof_char))
{
rli->buf[rli->len] = 0;
rli->state = RLI_LINE_READ;
*lenp = 0;
return NULL; /* EOF */
}
last_input_char = rli->eof_char;
}
Active_Rline_Info = rli;
if (key->type == SLKEY_F_INTRINSIC)
{
int (*func)(SLrline_Type *);
func = (int (*)(SLrline_Type *)) key->f.f;
(void) (*func)(rli);
RLupdate (rli);
if ((rli->flags & SL_RLINE_BLINK_MATCH)
&& (rli->input_pending != NULL))
blink_match (rli);
}
else if (key->type == SLKEY_F_SLANG)
{
(void) SLexecute_function (key->f.slang_fun);
RLupdate (rli);
}
Active_Rline_Info = save_rli;
if ((SLang_Rline_Quit) || _pSLang_Error)
{
if (_pSLang_Error)
{
rli->len = 0;
}
rli->buf[rli->len] = 0;
rli->state = RLI_LINE_READ;
*lenp = rli->len;
free_history_item (rli->saved_line);
rli->saved_line = NULL;
if (_pSLang_Error)
return NULL;
return SLmake_nstring ((char *)rli->buf, rli->len);
}
if (key != NULL)
rli->last_fun = key->f.f;
}
}
