Exemple #1
0
/* The values returned by this function are meaningful only after readline
 * has been used once.
 */
static void get_screen_size (void)
{
    int rows, cols;

#if USE_SLANG_READLINE
    rows = SLtt_Screen_Rows;
    cols = SLtt_Screen_Cols;
#else
    rl_get_screen_size (&rows, &cols);
#endif

    (void) SLang_push_int (rows);
    (void) SLang_push_int (cols);
}
Exemple #2
0
static void check_intrin_int_qualifier (char *name, int *def)
{
   int q;
   if (-1 == SLang_get_int_qualifier (name, &q, *def))
     return;
   SLang_push_int (q);
}
Exemple #3
0
static void rline_call_update_hook (SLrline_Type *rli,
                                    SLFUTURE_CONST char *prompt,
                                    SLFUTURE_CONST char *buf,
                                    unsigned int len,
                                    unsigned int point, VOID_STAR cd)
{
    Rline_CB_Type *cb;

    (void) rli;
    (void) len;
    cb = (Rline_CB_Type *)cd;

    if (-1 == SLang_start_arg_list ())
        return;

    if ((-1 == SLang_push_mmt (cb->mmt))
            || (-1 == SLang_push_string (prompt))
            || (-1 == SLang_push_string (buf))
            || (-1 == SLang_push_int ((int) point))
            || ((cb->cd != NULL) && (-1 == SLang_push_anytype (cb->cd))))
    {
        (void) SLang_end_arg_list ();
        return;
    }

    (void) SLexecute_function (cb->update_hook);
}
Exemple #4
0
static int get_int_sockopt (Socket_Type *s, int level, int optname)
{
   int val;
   socklen_t len;

   len = sizeof (int);
   if (-1 == do_getsockopt (s->fd, level, optname, (void *)&val, &len))
     return -1;

   return SLang_push_int (val);
}
Exemple #5
0
static void getpriority_intrin (int *which, int *who)
{
   int ret;
   errno = 0;
   ret = getpriority (*which, *who);
   if ((ret == -1) && (errno != 0))
     {
	_pSLerrno_errno = errno;
	(void) SLang_push_null ();
	return;
     }
   (void) SLang_push_int (ret);
}
Exemple #6
0
static int test_type_sget (SLtype type, SLFUTURE_CONST char *name)
{
   Test_Type *t;
   int status;

   (void) type;
   if (-1 == pop_test_type (&t))
     return -1;

   status = -1;
   if (0 == strcmp (name, "field1"))
     status = SLang_push_int (t->field1);
   else if (0 == strcmp (name, "field2"))
     status = SLang_push_int (t->field2);
   else if (0 == strcmp (name, "any"))
     status = SLang_push_anytype (t->any);
   else
     SLang_verror (SL_INVALID_PARM,
		   "Test_Type.%s is invalid", name);

   free_test_type (t);
   return status;
}
Exemple #7
0
static int call_simple_update_cb (SLang_Name_Type *f, Rline_CB_Type *cb, int *opt)
{
    if (f == NULL)
        return 0;

    if (-1 == SLang_start_arg_list ())
        return -1;
    if ((-1 == SLang_push_mmt (cb->mmt))
            || ((opt != NULL) && (-1 == SLang_push_int (*opt)))
            || ((cb->cd != NULL) && (-1 == SLang_push_anytype (cb->cd))))
    {
        (void) SLang_end_arg_list ();
        return -1;
    }
    return SLexecute_function (f);
}
Exemple #8
0
void sl_ioctl (void)
{
   char *argp = NULL;
   int fd, retval;
   unsigned int length, request;
   SLFile_FD_Type *f;
   SLang_BString_Type *bstr;
 
   if (SLang_Num_Function_Args == 3)
     {
	if (SLang_pop_bstring (&bstr) == -1)
	  goto usage_error;
	if (SLang_pop_uint ((unsigned int *) &request) == -1)
	  goto usage_error;
	if (SLfile_pop_fd (&f) == -1)
	  goto usage_error;
	argp = SLbstring_get_pointer (bstr, &length);
     }
   else if (SLang_Num_Function_Args == 2)
     {
	if (SLang_pop_uint ((unsigned int *) &request) == -1)
	  goto usage_error;
	if (SLfile_pop_fd (&f) == -1)
	  goto usage_error;
     }
   else
     goto usage_error;
 
   if (SLfile_get_fd (f, &fd) == -1)
     return;
 
   if ((retval = ioctl (fd, request, argp)) == -1)
     {
	SLang_set_error (SL_OS_Error);
	(void) SLerrno_set_errno (errno);
	return;
     }
 
   (void) SLang_push_int (retval);
   if (argp != NULL)
     (void) SLang_push_bstring (bstr);
   return;
 
   usage_error :
   SLang_set_error (SL_Usage_Error);
   return;
}
Exemple #9
0
static void nint_intrin (void)
{
   double x;
   SLang_Array_Type *at, *bt;
   int (*at_to_int_fun)(SLang_Array_Type *, SLang_Array_Type *);

   if (SLang_peek_at_stack () != SLANG_ARRAY_TYPE)
     {
	if (-1 == SLang_pop_double (&x))
	  return;
	(void) SLang_push_int (do_nint (x));
	return;
     }
   switch (SLang_peek_at_stack1 ())
     {
      case -1:
	return;

      case SLANG_INT_TYPE:
	return;

      case SLANG_FLOAT_TYPE:
	if (-1 == SLang_pop_array_of_type (&at, SLANG_FLOAT_TYPE))
	  return;
	at_to_int_fun = float_to_nint;
	break;

      case SLANG_DOUBLE_TYPE:
      default:
	if (-1 == SLang_pop_array_of_type (&at, SLANG_DOUBLE_TYPE))
	  return;
	at_to_int_fun = double_to_nint;
	break;
     }
   
   if (NULL == (bt = SLang_create_array1 (SLANG_INT_TYPE, 0, NULL, at->dims, at->num_dims, 1)))
     {
	SLang_free_array (at);
	return;
     }
   if (0 == (*at_to_int_fun) (at, bt))
     (void) SLang_push_array (bt, 0);
   
   SLang_free_array (bt);
   SLang_free_array (at);
}
Exemple #10
0
static int apply_line_modifier (Model_t *m, Model_Info_Type *info, DB_line_t *line, double *emis) /*{{{*/
{
   Plasma_State_Type lm_state;

   lm_state.temperature = m->temperature;
   lm_state.ndensity = m->density;

   SLang_start_arg_list ();
   SLang_push_array (info->line_emis_modifier_params, 0);
   SLang_push_int (line->indx);
   if (-1 == SLang_push_cstruct ((VOID_STAR)&lm_state, Plasma_State_Layout))
     return -1;
   SLang_push_double (*emis);
   if (info->line_emis_modifier_args != NULL)
     isis_push_args (info->line_emis_modifier_args);

   if (info->line_emis_modifier_qualifiers == NULL)
     {
        SLang_end_arg_list ();

        if (-1 == SLexecute_function (info->line_emis_modifier))
          return -1;
     }
   else
     {
        if ((-1 == SLang_push_function (info->line_emis_modifier))
            || (-1 == SLang_push_struct (info->line_emis_modifier_qualifiers)))
          return -1;

        SLang_end_arg_list ();

        if (-1 == SLang_execute_function ("_isis->do_eval_with_qualifiers"))
          return -1;
     }

   if (-1 == SLang_pop_double (emis))
     return -1;

   return 0;
}
Exemple #11
0
int _pSLbstring_foreach (SLtype type, SLang_Foreach_Context_Type *c)
{
   unsigned char ch;
   SLwchar_Type wch;
   unsigned char *s, *s1, *smax;

   (void) type;

   s = c->s;
   smax = c->smax;
   if (s == smax)
     return 0;

   if (c->using_chars == 0)
     {
	ch = (unsigned char) *s++;
	c->s = s;

	if (-1 == SLclass_push_char_obj (SLANG_UCHAR_TYPE, ch))
	  return -1;

	return 1;
     }
   s1 = SLutf8_decode (s, smax, &wch, NULL);
   if (s1 == NULL)
     {
	int iwch = (int) *s;
	c->s = s + 1;
	/* Invalid encoded char-- return it as a negative int */
	if (-1 == SLang_push_int (-iwch))
	  return -1;

	return 1;
     }
   c->s = s1;
   if (-1 == SLang_push_wchar (wch))
     return -1;

   return 1;
}
Exemple #12
0
static int rl_complete (SLrline_Type *rli)
{
   char *line;
   unsigned int i, n, nbytes;
   char **strings, *str0, ch0;
   int start_point, delta;
   SLang_Array_Type *at;
   SLang_Name_Type *completion_callback;
   SLang_Name_Type *list_completions_callback;

   if (NULL == (completion_callback = rli->completion_callback))
     {
	completion_callback = Default_Completion_Callback;
	if (completion_callback == NULL)
	  return SLrline_ins (rli, "\t", 1);
     }
   if (NULL == (list_completions_callback = rli->list_completions_callback))
     list_completions_callback = Default_List_Completions_Callback;

   if (NULL == (line = SLrline_get_line (rli)))
     return -1;

   if ((-1 == SLang_start_arg_list ())
       || (-1 == SLang_push_string (line))
       || (-1 == SLang_push_int (rli->point))
       || (-1 == SLang_end_arg_list ())
       || (-1 == SLexecute_function (completion_callback)))
     {
	SLfree (line);
	return -1;
     }

   SLfree (line);

   if (-1 == SLang_pop_int (&start_point))
     return -1;
   
   if (start_point < 0)
     start_point = 0;

   if (-1 == SLang_pop_array_of_type (&at, SLANG_STRING_TYPE))
     return -1;

   strings = (char **) at->data;
   n = at->num_elements;
   
   if (n == 0)
     {
	SLang_free_array (at);
	return 0;
     }

   if ((n != 1) && (list_completions_callback != NULL))
     {
	if ((-1 == SLang_start_arg_list ())
	    || (-1 == SLang_push_array (at, 0))
	    || (-1 == SLang_end_arg_list ())
	    || (-1 == SLexecute_function (list_completions_callback)))
	  {
	     SLang_free_array (at);
	     return -1;
	  }
	(void) SLrline_redraw (rli);
     }
	
   str0 = strings[0];
   nbytes = 0;
   while (0 != (ch0 = str0[nbytes]))
     {
	for (i = 1; i < n; i++)
	  {
	     char ch1 = strings[i][nbytes];
	     if (ch0 != ch1)
	       break;
	  }
	if (i != n)
	  break;
	nbytes++;
     }

   delta = start_point - rli->point;
   if (delta < 0)
     {
	(void) SLrline_move (rli, delta);
	delta = -delta;
     }
   (void) SLrline_del (rli, (unsigned int) delta);
   (void) SLrline_ins (rli, str0, nbytes);

   /* How should the completion be ended?
    *   "foo/     -->  "foo/
    *   "foo/bar  -->  "foo/bar"
    *   "foo      -->  "foo"
    *   foo       -->  fooSPACE
    *   foo/bar   -->  fooSPACE
    */
   if ((n == 1) 
       && nbytes && (str0[nbytes-1] != '/') && (str0[nbytes-1] != '\\'))
     {
	char qch = ' ';

	if (start_point > 0)
	  {
	     ch0 = rli->buf[start_point-1];
	     if ((ch0 == '"') || (ch0 == '\''))
	       qch = ch0;
	  }
	if (qch != 0)
	  (void) SLrline_ins (rli, &qch, 1);
     }

   SLang_free_array (at);
   return 0;
}
Exemple #13
0
/* Returns a malloced value */
static char *get_input_line (SLang_Load_Type *x)
{
    char *line;
    int parse_level;
    int free_prompt = 0;
    char *prompt;

    parse_level = x->parse_level;
    if (Prompt_Hook != NULL)
    {
        if ((-1 == SLang_start_arg_list ())
                || (-1 == SLang_push_int (parse_level))
                || (-1 == SLang_end_arg_list ())
                || (-1 == SLexecute_function (Prompt_Hook))
                || (-1 == SLang_pop_slstring (&prompt)))
        {
            SLang_verror (SL_RunTime_Error, "Disabling prompt hook");
            SLang_free_function (Prompt_Hook);
            Prompt_Hook = NULL;
            return NULL;
        }
        free_prompt = 1;
    }
    else if (parse_level == 0)
        prompt = (char *) "slsh> ";
    else
        prompt = (char *) "       ";

    if (parse_level == 0)
    {
        if (-1 == SLang_run_hooks ("slsh_interactive_before_hook", 0))
        {
            if (free_prompt)
                SLang_free_slstring (prompt);
            return NULL;
        }
    }

    line = read_input_line (Default_Readline_Info, prompt, 0);

    if (free_prompt)
        SLang_free_slstring (prompt);

    if ((line == NULL)
            && (parse_level == 0)
            && (SLang_get_error() == 0))
    {
        Slsh_Quit = 1;
        return NULL;
    }

    if (line == NULL)
    {
        return NULL;
    }

    /* This hook is used mainly for logging input */
    (void) SLang_run_hooks ("slsh_interactive_after_hook", 1, line);

    (void) save_input_line (Default_Readline_Info, line);

    return line;
}