gambas-source-code/main/gbx/gbx_subr_misc.c
Benoît Minisini a32166b185 [INTERPRETER]
* OPT: Many optimizations again.
* BUG: Fix an unitialized variable in string to float conversion routine.
* BUG: Handle extern functions that return a pointer.


git-svn-id: svn://localhost/gambas/trunk@3003 867c0c6c-44f3-4631-809d-bfa615b0a4ec
2010-06-13 12:03:29 +00:00

358 lines
6.4 KiB
C

/***************************************************************************
gbx_subr_misc.c
(c) 2000-2009 Benoît Minisini <gambas@users.sourceforge.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***************************************************************************/
#include <sys/wait.h>
#include <time.h>
#include "gb_common.h"
#include "gbx_subr.h"
#include "gbx_class.h"
#include "gambas.h"
#include "gbx_eval.h"
#include "gbx_date.h"
#include "gbx_archive.h"
#include "gbx_api.h"
#include "gbx_c_collection.h"
#include "gbx_c_process.h"
#include "gbx_debug.h"
#include "gbx_watch.h"
#include "gbx_math.h"
static EVAL_INTERFACE EVAL;
static CCOLLECTION *eval_env;
static void init_eval()
{
static bool init = FALSE;
if (init)
return;
COMPONENT_load(COMPONENT_create("gb.eval"));
LIBRARY_get_interface_by_name("gb.eval", EVAL_INTERFACE_VERSION, &EVAL);
init = TRUE;
}
void SUBR_error(void)
{
SP->type = T_BOOLEAN;
SP->_boolean.value = EXEC_got_error ? -1 : 0;
SP++;
}
void SUBR_wait(ushort code)
{
struct timespec rem;
double wait;
double stop, time;
SUBR_ENTER();
if (NPARAM == 0)
{
HOOK_DEFAULT(wait, WATCH_wait)(0);
}
else
{
wait = SUBR_get_float(PARAM);
DATE_timer(&stop, FALSE);
stop += wait;
for(;;)
{
HOOK_DEFAULT(wait, WATCH_wait)((int)(wait * 1000 + 0.5));
if (DATE_timer(&time, FALSE))
break;
wait = stop - time;
if (wait <= 0.0)
break;
rem.tv_sec = 0;
rem.tv_nsec = 1000000;
nanosleep(&rem, &rem);
}
}
SUBR_LEAVE_VOID();
}
void SUBR_sleep(void)
{
double wait;
struct timespec rem;
SUBR_ENTER_PARAM(1);
wait = SUBR_get_float(PARAM);
rem.tv_sec = (time_t)(int)wait;
rem.tv_nsec = (int)(frac(wait) * 1E9);
while (nanosleep(&rem, &rem) < 0);
SUBR_LEAVE();
}
void SUBR_exec(ushort code)
{
void *cmd;
bool wait;
int mode;
CPROCESS *process;
bool ret;
bool shell;
char *name;
CARRAY *env;
SUBR_ENTER_PARAM(4);
shell = (code & 0x1F) != 0;
if (shell)
cmd = (void *)SUBR_get_string(PARAM);
else
{
VALUE_conv_object(PARAM, (TYPE)CLASS_StringArray);
cmd = (void *)(PARAM->_object.object);
}
if (!cmd)
THROW(E_ARG);
if (VALUE_is_null(&PARAM[1]))
env = NULL;
else
{
VALUE_conv_object(&PARAM[1], (TYPE)CLASS_StringArray);
env = (PARAM[1]._object.object);
}
VALUE_conv_integer(&PARAM[2]);
mode = PARAM[2]._integer.value;
wait = mode & PM_WAIT;
name = SUBR_get_string(&PARAM[3]);
ret = !PCODE_is_void(code);
if (shell)
mode |= PM_SHELL;
//STRING_ref(name); ## This should not be needed
process = CPROCESS_create(mode, cmd, name, env);
//STRING_unref(&name);
if (wait)
{
OBJECT_REF(process, "subr_exec");
CPROCESS_wait_for(process);
if (!ret)
{
OBJECT_UNREF(process, "subr_exec");
}
else if (!process->to_string)
{
OBJECT_UNREF_KEEP(process, "subr_exec");
}
}
if (ret)
{
if (process->to_string)
{
RETURN->type = T_STRING;
RETURN->_string.addr = process->result;
RETURN->_string.start = 0;
RETURN->_string.len = STRING_length(process->result);
STRING_unref_keep(&process->result);
process->result = NULL;
OBJECT_UNREF(process, "subr_exec");
}
else
{
RETURN->_object.class = CLASS_Process;
RETURN->_object.object = process;
}
SUBR_LEAVE();
}
else
{
SUBR_LEAVE_VOID();
}
}
static bool get_value(const char *sym, int len, GB_VARIANT *value)
{
if (eval_env)
if (!GB_CollectionGet(eval_env, sym, len, value))
return FALSE;
value->type = GB_T_NULL;
return TRUE;
}
void EVAL_string(char *expr)
{
int len;
EXPRESSION *eval;
init_eval();
len = strlen(expr);
eval_env = NULL;
EVAL.New((void **)(void *)&eval, expr, len);
if (EVAL.Compile(eval, FALSE))
goto _ERROR;
if (!EVAL.Run(eval, get_value))
goto _ERROR;
goto _FREE;
_ERROR:
EVAL.Free((void **)(void *)&eval);
PROPAGATE();
_FREE:
EVAL.Free((void **)(void *)&eval);
VALUE_to_string(RETURN, &expr, &len);
STREAM_write(CSTREAM_stream(CFILE_out), expr, len);
STREAM_write_eol(CSTREAM_stream(CFILE_out));
STREAM_flush(CSTREAM_stream(CFILE_out));
}
void SUBR_eval(ushort code)
{
char *expr;
int len;
EXPRESSION *eval;
SUBR_ENTER();
init_eval();
SUBR_get_string_len(PARAM, &expr, &len);
if (NPARAM == 2)
{
VALUE_conv_object(&PARAM[1], (TYPE)CLASS_Collection);
eval_env = (CCOLLECTION *)(PARAM[1]._object.object);
}
else
eval_env = NULL;
EVAL.New((void **)(void *)&eval, expr, len);
if (EVAL.Compile(eval, (code >> 8) == CODE_ASSIGN))
goto _ERROR;
if (!EVAL.Run(eval, get_value))
goto _ERROR;
goto _FREE;
_ERROR:
EVAL.Free((void **)(void *)&eval);
PROPAGATE();
_FREE:
EVAL.Free((void **)(void *)&eval);
SUBR_LEAVE();
}
void SUBR_array(ushort code)
{
TYPE type;
int i;
GB_ARRAY array;
SUBR_ENTER();
type = SUBR_check_good_type(PARAM, NPARAM);
if (type == T_NULL)
type = T_OBJECT;
GB_ArrayNew(&array, type, NPARAM);
// FIXME: If there is an error, the array is not freed!
for (i = 0; i < NPARAM; i++)
{
VALUE_conv(&PARAM[i], type);
GB_Store(type, (GB_VALUE *)&PARAM[i], GB_ArrayGet(array, i));
RELEASE(&PARAM[i]);
}
OBJECT_REF(array, "SUBR_array");
PARAM->_object.class = OBJECT_class(array); //CLASS_Array;
PARAM->_object.object = array;
SP = PARAM + 1;
}
void SUBR_collection(ushort code)
{
int i;
GB_COLLECTION col;
char *key;
int len;
VALUE *vkey, *vval;
SUBR_ENTER();
GB_CollectionNew(&col, GB_COMP_BINARY);
for (i = 0; i < NPARAM; i += 2)
{
vkey = &PARAM[i];
vval = vkey + 1;
SUBR_get_string_len(vkey, &key, &len);
VALUE_conv_variant(vval);
if (GB_CollectionSet(col, key, len, (GB_VARIANT *)vval))
{
OBJECT_UNREF(col, "SUBR_collection");
THROW(E_VKEY);
}
RELEASE_STRING(&PARAM[i]);
RELEASE(&PARAM[i + 1]);
}
OBJECT_REF(col, "SUBR_collection");
PARAM->_object.class = OBJECT_class(col); //CLASS_Array;
PARAM->_object.object = col;
SP = PARAM + 1;
}