Lisp_Object jitcompilemen(Lisp_Object def, int nargs, ...)
{
Lisp_Object name = name_from(def);
va_list a;
/*
* Ought I to check the number of args here? Quite probably!!!!
*/
char *jitcode = Jcompile(def, nargs);
if (jitcode != NULL)
{ if (set_jit_mem(jitcode)==0)
{ ifnn(name) = (intptr_t)jit_space_p;
jit_space_p += codep;
}
else ifnn(name) = (intptr_t)bytecodedn;
}
else ifnn(name) = (intptr_t)bytecodedn;
/*
* I have a feeling that nargs should never be zero here....
*/
if (nargs != 0)
{ va_start(a, nargs);
push_args(a, nargs); /* FIXME stack ok? or pushed too much */
}
#ifndef NO_BYTECOUNT
name_of_caller = "JIT compiler";
#endif
return apply(name, nargs, qenv(name), name, 0);
}
Lisp_Object MS_CDECL Lgcd_n(Lisp_Object nil, int nargs, ...)
{
va_list a;
int i;
Lisp_Object r;
if (nargs == 0) return fixnum_of_int(0);
va_start(a, nargs);
push_args(a, nargs);
/*
* The actual args have been passed a C args - I can not afford to
* risk garbage collection until they have all been moved somewhere safe,
* and here that safe place is the Lisp stack. I have to delay checking for
* overflow on same until all args have been pushed.
*/
stackcheck0(nargs);
pop(r);
for (i = 1; i<nargs; i++)
{ Lisp_Object w;
if (r == fixnum_of_int(1))
{ popv(nargs-i);
break;
}
pop(w);
r = gcd(r, w);
errexitn(nargs-i-1);
}
return onevalue(r);
}
Variable* run_function(Interpretator *interpretator, Function *f, Array *args)
{
Variable *return_var=undefined;
int i;
int *current_base;
if(f->return_var)
{
return_var=interpretator->stack_head;
return_var->type=UNDEFINED;
return_var->shift=-1;
return_var->name=f->return_var->name;
return_var->is_closed=f->return_var->is_closed;
interpretator->stack_head++;
interpretator->stack_head=(int*)interpretator->stack_head+1;
}
current_base=interpretator->stack_head;
*current_base=interpretator->stack_base;
interpretator->stack_head=(int*)interpretator->stack_head+f->variables->length+1; //+base
if(args)
push_args(interpretator, args, f->args, current_base);
interpretator->stack_base=current_base;
if(f->return_var)
current_base[f->return_var->shift]=return_var;//инициализация return var
execute(interpretator, f->body);
if(f->return_var)
to_const(return_var, interpretator);
interpretator->stack_head=(int*)interpretator->stack_head-f->variables->length-1;
interpretator->stack_head-=f->args->length;
interpretator->stack_base=*interpretator->stack_base;
if(f->return_var)
{
printf("\n<function ");
str_print(f->name);
printf(" return ");
str_print(f->return_var->name);
printf(">\n");
}
if(f->return_var)
{
interpretator->stack_head=(int*)interpretator->stack_head-1;
interpretator->stack_head--;
return return_var;
}
return undefined;
}
Lisp_Object MS_CDECL Llcm_n(Lisp_Object nil, int nargs, ...)
{
va_list a;
int i;
Lisp_Object r;
if (nargs == 0) return onevalue(fixnum_of_int(1));
va_start(a, nargs);
push_args(a, nargs);
stackcheck0(nargs);
pop(r);
for (i = 1; i<nargs; i++)
{ Lisp_Object w;
pop(w);
r = lcm(r, w);
errexitn(nargs-i-1);
}
return onevalue(r);
}
inline int push_args(lua_State *l, const Arg& arg, Args&&... args)
{
int c = lua_type_traits<Arg>::push(l, arg);
return c + push_args(l, std::forward<Args>(args)...);
}
inline int push_args(lua_State *l, Arg&& arg, Args&&... args)
{
int c = lua_type_traits<typename traits::remove_reference<Arg>::type>::push(l, std::forward<Arg>(arg));
return c + push_args(l, std::forward<Args>(args)...);
}
