// see if we have a lexical we could update
// either update already existing lexical value
// or if flag is set, we create one if no lexical found
void set_lexical(const string& key, T val)
{
auto cur = this;
while (cur->is_lexical()) {
if (cur->has_local(key)) {
cur->set_local(key, val);
return;
}
cur = cur->parent_;
}
set_local(key, val);
}
void Environment<T>::set_lexical(const std::string& key, T val)
{
auto cur = this; bool shadow = false;
while (cur->is_lexical() || shadow) {
if (cur->has_local(key)) {
cur->set_local(key, val);
return;
}
shadow = cur->is_shadow();
cur = cur->parent_;
}
set_local(key, val);
}
void team::change_controller_by_wml(const std::string& new_controller_string)
{
CONTROLLER new_controller;
if(!new_controller.parse(new_controller_string)) {
WRN_NG << "ignored attempt to change controller to " << new_controller_string << std::endl;
return;
}
if(new_controller == CONTROLLER::EMPTY && resources::controller->current_side() == this->side()) {
WRN_NG << "ignored attempt to change the currently playing side's controller to 'null'" << std::endl;
return;
}
config choice = synced_context::ask_server_choice(controller_server_choice(new_controller, *this));
if(!new_controller.parse(choice["controller"])) {
// TODO: this should be more than a ERR_NG message.
// GL-2016SEP02 Oh? So why was ERR_NG defined as warning level? Making the call fit the definition.
WRN_NG << "Received an invalid controller string from the server" << choice["controller"] << std::endl;
}
if(!resources::controller->is_replay()) {
set_local(choice["is_local"].to_bool());
}
change_controller(new_controller);
}
void VariableScope::set_local_internal(STATE, int pos, Object* val) {
if(isolated()) {
heap_locals()->put(state, pos, val);
} else {
set_local(pos, val);
}
}
int SdaccelSgd::setup_kernel() {
set_global(GLOBAL_WORK_GROUP_SIZE); //sets global work group size
set_local(LOCAL_WORK_GROUP_SIZE); //sets local work group size
// Execute the kernel over the entire range of our 1d input data set
// using the maximum number of work group items for this device
return EXIT_SUCCESS;
}
void
AST_Array::set_base_type(AST_Type *nbt)
{
if (local() == I_FALSE)
{
set_local(nbt->local());
}
pd_base_type = nbt;
}
static void set_global(su_state *s, const char *var, unsigned hash, int size, value_t *val) {
value_t key, m;
key.type = SU_STRING;
key.obj.gc_object = string_from_cache(s, var, size);
m = unref_local(s, s->stack[SU_GLOBAL_INDEX].obj.loc);
m = map_insert(s, m.obj.m, &key, hash, val);
set_local(s, s->stack[SU_GLOBAL_INDEX].obj.loc, &m);
}
jvmtiError JNICALL
jvmtiSetLocalObject(jvmtiEnv* env,
jthread thread,
jint depth,
jint slot,
jobject value)
{
TRACE("SetLocalObject called");
return set_local(env, thread, depth, slot, VM_DATA_TYPE_CLASS, (void*) &value);
}
jvmtiError JNICALL
jvmtiSetLocalDouble(jvmtiEnv* env,
jthread thread,
jint depth,
jint slot,
jdouble value)
{
TRACE("SetLocalDouble called");
return set_local(env, thread, depth, slot, VM_DATA_TYPE_F8, (void*) &value);
}
jvmtiError JNICALL
jvmtiSetLocalLong(jvmtiEnv* env,
jthread thread,
jint depth,
jint slot,
jlong value)
{
TRACE("SetLocalLong called");
return set_local(env, thread, depth, slot, VM_DATA_TYPE_INT64, (void*) &value);
}
jvmtiError JNICALL
jvmtiSetLocalFloat(jvmtiEnv* env,
jthread thread,
jint depth,
jint slot,
jfloat value)
{
TRACE("SetLocalFloat called");
return set_local(env, thread, depth, slot, VM_DATA_TYPE_F4, (void*) &value);
}
Object* VariableScope::set_local_prim(STATE, Fixnum* number, Object* object) {
int num = number->to_int();
if(num < 0) {
Exception::raise_argument_error(state, "negative local index");
} else if(num >= number_of_locals()) {
Exception::raise_argument_error(state, "index larger than number of locals");
}
set_local(state, num, object);
return cNil;
}
static value_t init_globals(su_state *s) {
value_t key, m, tmp;
key.type = SU_STRING;
key.obj.gc_object = string_from_cache(s, "_G", 2);
tmp.type = SU_NIL;
m = map_create_empty(s);
tmp = ref_local(s, &tmp);
m = map_insert(s, m.obj.m, &key, hash_value(&key), &tmp);
set_local(s, tmp.obj.loc, &m);
return tmp;
}
static int open_device(const char *tty, GHashTable *options)
{
struct termios ti;
int fd;
/* Switch TTY to raw mode */
memset(&ti, 0, sizeof(ti));
cfmakeraw(&ti);
if (options) {
GHashTableIter iter;
const char *key;
const char *value;
g_hash_table_iter_init (&iter, options);
while (g_hash_table_iter_next(&iter, (void *) &key,
(void *) &value)) {
gboolean ok = FALSE;
if (g_str_equal(key, "Baud"))
ok = set_baud(value, &ti);
else if (g_str_equal(key, "StopBits"))
ok = set_stop_bits(value, &ti);
else if (g_str_equal(key, "DataBits"))
ok = set_data_bits(value, &ti);
else if (g_str_equal(key, "Parity"))
ok = set_parity(value, &ti);
else if (g_str_equal(key, "XonXoff"))
ok = set_xonxoff(value, &ti);
else if (g_str_equal(key, "RtsCts"))
ok = set_rtscts(value, &ti);
else if (g_str_equal(key, "Local"))
ok = set_local(value, &ti);
else if (g_str_equal(key, "Read"))
ok = set_read(value, &ti);
if (ok == FALSE)
return -1;
}
}
fd = open(tty, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (fd < 0)
return -1;
tcflush(fd, TCIOFLUSH);
tcsetattr(fd, TCSANOW, &ti);
return fd;
}
void SceneGraph::set_local_rotation(TransformInstance i, const Quaternion& rot)
{
_data.local[i.i].rotation = matrix3x3(rot);
set_local(i);
}
void SceneGraph::set_local_position(TransformInstance i, const Vector3& pos)
{
_data.local[i.i].position = pos;
set_local(i);
}
int
main(int argc, const char **argv)
{
const char *sysname, *speed;
char sysfile[FILENAME_MAX];
char deblogname[FILENAME_MAX];
FILE *f;
header_p sys, ich, p;
int i;
initlog("call");
if (0 == strcmp(argv[0], "-h")) usage();
if (argc < 4 || argc > 5) usage();
gmodem=-1;
atexit(cleanup);
sysname = strlwr( dstrdup( argv[1] ));
if (!strchr(argv[2], '/'))
snprintf(tty, sizeof(tty), "/dev/%s", argv[2]);
else
strcpy(tty, argv[2]);
speed = argv[3];
maxtry = 1;
if (argc > 4)
maxtry = atoi(argv[4]);
minireadstat();
sprintf(deblogname, "%s/" DEBUGLOG_FILE, logdir);
if(debuglevel>0) {
deblogfile = fopen(deblogname, "w");
if (!deblogfile) {
printf("Ich kann das Logfile nicht oeffnen. "
"Probiere /dev/null...\n");
deblogfile = fopen("/dev/null", "w");
if (!deblogfile) {
printf("Hmm... - /dev/null "
"nicht schreibbar??\n");
return 10;
}
}
} else {
deblogfile = fopen("/dev/null", "w");
if (!deblogfile) {
printf("Arghl! - kann /dev/null "
"nicht zum Schreiben oeffnen!\n\n");
return 10;
}
}
sprintf(sysfile, "%s/%s", systemedir, sysname);
f = fopen(sysfile, "r");
if (!f) {
perror(sysfile);
newlog(ERRLOG, "File <%s> not readable: %s",
sysfile, strerror(errno));
return 1;
}
sys = rd_para(f);
fclose(f);
ich = get_myself();
for (i=maxtry; i; i--) {
if (lock_device(1, tty)) break;
fputs(" ... unser Modem ist belegt\n", stderr);
sleep(60);
}
if (!i) {
newlog(ERRLOG, "Cannot lock device: %s", tty);
return 9;
}
#ifdef LEAVE_CTRL_TTY
/*
* Bisheriges Controlling-TTY verlassen, damit "modem" das neue
* wird.
*/
#ifdef BSD
setpgrp(0, getpid()); /* set process group id to process id */
#ifdef SIGTTOU
signal(SIGTTOU, SIG_IGN);
#endif
#ifdef SIGTTIN
signal(SIGTTIN, SIG_IGN);
#endif
#ifdef SIGTSTP
signal(SIGTSTP, SIG_IGN);
#endif
#else /* !BSD */
#if !defined(USE_SETSID) && !defined(USE_SETPGRP)
#error Controlling TTY kann nicht verlassen werden: definieren Sie eine Methode dazu
#endif /* !BSD und keine SysV-Methode definiert */
#ifdef USE_SETSID
#error Dies funktioniert nicht!
setsid();
#endif /* USE_SETSID */
#ifdef USE_SETPGRP
setpgrp();
#endif /* USE_SETPGRP */
#endif /* !BSD */
#endif /* LEAVE_CTRL_TTY */
gmodem = open(tty,
#if !defined(__NetBSD__)
O_RDWR | O_NDELAY
#else
O_RDWR
#endif
); DMLOG("open modem");
if (gmodem < 0) {
newlog(ERRLOG,
"Can not access device %s: %s", tty, strerror(errno));
return 10;
}
#if !defined(__NetBSD__)
else {
/* Nonblock abschalten */
int n;
n=fcntl(gmodem, F_GETFL, 0);
(void)fcntl(gmodem, F_SETFL, n & ~O_NDELAY);
}
#endif
save_linesettings(gmodem); DMLOG("saving modem parameters");
set_rawmode(gmodem); DMLOG("set modem to rawmode");
set_local(gmodem, 1);
set_speed(gmodem, speed); DMLOG("set modem speed");
#ifdef TIOCSCTTY
ioctl(gmodem, TIOCSCTTY, NULL);
#endif
files = 0;
online_start = 0;
fprintf(stderr, "Netcall bei %s [%s]\n", sysname, tty);
fclose(stdin);
fclose(stdout);
dup(gmodem); dup(gmodem); DMLOG("dup modem 2x to stdin and stdout");
if (setjmp(timeout)) {
newlog(ERRLOG, "ABBRUCH: Timeout");
lock_device(0, tty);
anrufdauer();
if (files) aufraeumen();
return 11;
}
if (setjmp(nocarrier)) {
if (!auflegen) {
newlog(ERRLOG, "ABBRUCH: Gegenstelle hat aufgelegt");
}
lock_device(0, tty);
anrufdauer();
if (files) aufraeumen();
return auflegen ? 0 : 12;
}
signal(SIGHUP, handle_nocarrier);
signal(SIGALRM, handle_timeout);
setup_dial_info(ortsnetz, g_int_prefix, g_ovst, NULL);
p = find(HD_TEL, sys);
if (!p) {
newlog(ERRLOG,
"Keine Telefonnummer fuer %s gefunden",
sysname);
return 2;
}
anruf(sys, ich, gmodem, maxtry);
if (online_start) {
anrufdauer();
} else {
fprintf(stderr, "Keine Verbindung hergestellt.\n");
}
lock_device(0, tty);
/* Device ist freigegeben, aber wir warten noch auf das Ende
der Importphase, bevor wir zurueckkehren. */
wait(NULL);
return 0;
}
int
anruf( header_p sys, header_p ich, int lmodem, int tries )
{
char dialstr[80];
char lockname[FILENAME_MAX];
header_p p;
char *name, *pw;
const char **v;
int i, err;
int dial_cnt = 1;
/* fuer Janus */
char *arcer=NULL, *arcerin=NULL, *transfer=NULL, *domain;
header_p t, d;
int netcall_error;
char filename[FILENAME_MAX];
char tmpname[FILENAME_MAX];
char outname[FILENAME_MAX];
char inname[FILENAME_MAX];
char sysname[FILENAME_MAX];
struct stat st;
/* ende fuer Janus */
t = find(HD_ARCEROUT, sys);
if (!t) {
newlog(ERRLOG,
"Kein ausgehender Packer definiert");
return 1;
}
arcer = t->text;
strlwr(arcer);
t = find(HD_ARCERIN, sys);
if (!t) {
newlog(ERRLOG,
"Kein eingehender Packer definiert");
return 1;
}
arcerin = t->text;
strlwr(arcerin);
t = find(HD_PROTO, sys);
if (!t) {
newlog(ERRLOG,
"Kein Uebertragungsprotokoll definiert");
return 1;
}
transfer = t->text;
strlwr(transfer);
name = NULL;
p = find(HD_SYS, ich);
if (p) name = p->text;
pw = NULL;
p = find(HD_PASSWD, sys);
if (p) pw = p->text;
p = find(HD_X_CALL, sys);
if (!p) {
fprintf(stderr, "Welches Netcall-Verfahren????\n");
exit(20);
}
for (i = 0, v = verf; *v; i++, v++)
if (stricmp(*v, p->text) == 0)
break;
if (!*v) return 1;
if (i < ZCONNECT) {
t = find(HD_SYS, sys);
if (!t) {
newlog(ERRLOG,
"Illegale Systemdatei: Kein " HN_SYS
": Header oder falscher Name: %s", filename);
return 1;
}
d = find(HD_DOMAIN, sys);
if (!d) {
newlog(ERRLOG,
"Illegale Systemdatei: Kein " HN_DOMAIN
": Header: %s", filename);
return 1;
}
for (domain = strtok(d->text, " ;,:");
domain;
domain = strtok(NULL, " ;,:")) {
sprintf(sysname, "%s.%s", t->text, domain);
strlwr(sysname);
sprintf(tmpname, "%s/%s", netcalldir, sysname);
newlog(logname,
"Suche Verzeichnis, versuche %s...", tmpname);
if (access(tmpname, R_OK|X_OK) == 0)
break;
}
if(access(tmpname, R_OK|X_OK)) {
/* Problem: temp. Verzeichnis nicht zu haben */
newlog(logname,
"Problem beim Netcall: Verzeichnis "
"nicht gefunden");
return 1;
}
}
/* ##### HIER WIRD ANGEWAEHLT ##### */
p = find(HD_TEL, sys);
while(tries) {
if(!p) p = find(HD_TEL, sys);
make_dialstr(dialstr, sizeof(dialstr), p->text);
fprintf(stderr, "%3d. Anwahlversuch (noch %d): %-.25s\n",
dial_cnt++, tries, dialstr);
if (redial(dialstr, lmodem, 1) != 0 ) {
tries--;
p = p->other;
} else {
/* connect */
break;
}
}
set_local(lmodem, 0);
time(&online_start);
if (i < ZCONNECT) {
if (name) dfree(name);
name = dstrdup(boxstat.boxname);
strupr(name);
#ifdef ENABLE_CAPS_IN_PASSWORD
strupr(pw);
#endif
}
if(login(lmodem, i, name, pw)) return 0;
if (i < ZCONNECT) { /* JANUS */
int have_file = 0;
netcall_error = 0;
if ( janus_wait(lmodem) != 0 )
return 0;
sprintf(tmpname, "%s/%s.%d.dir", netcalldir, sysname, getpid());
mkdir(tmpname, 0755);
chdir(tmpname);
/* outname: ausgehendes Archiv
* filename: */
sprintf(outname, "%s/caller.%s", tmpname, arcer);
sprintf(filename, "%s/%s.%s", netcalldir, sysname, arcer);
sprintf(lockname, "%s/%s/" PREARC_LOCK, netcalldir, sysname);
if (access(filename, R_OK) != 0) {
FILE *f;
if(access(filename, F_OK) == 0) {
newlog(ERRLOG,
"Leerer Puffer, weil keine Erlaubnis "
"zum Lesen von %s: %s",
outname, strerror(errno));
}
f = fopen(outname, "wb");
if (!f) {
newlog(ERRLOG,
"Kann Netcall %s nicht erzeugen: %s",
outname, strerror(errno));
fclose(deblogfile);
return 1;
}
fputs("\r\n", f);
fclose(f);
} else { /* can read filename */
if (waitnolock(lockname, 180)) {
fclose(deblogfile);
newlog(OUTGOING, "System %s Prearc LOCK: %s",
sysname, lockname );
return 1;
}
fprintf(stderr, "Link: %s -> %s\n",
filename, outname);
if(link(filename, outname)) {
fclose(deblogfile);
newlog(ERRLOG,
"Linken: %s -> %s fehlgeschlagen: %s",
filename, outname, strerror(errno));
netcall_error = 1;
goto finish;
}
have_file = 1;
}
sprintf(inname, "called.%s", arcer);
st.st_size = 0;
if(stat(outname, &st)) {
fprintf(stderr,
"Zugriff auf %s fehlgeschlagen: %s\n",
outname, strerror(errno));
netcall_error = 1;
goto finish;
}
newlog(logname, "Sende %s (%ld Bytes) per %s",
outname, (long)st.st_size, transfer);
err = sendfile(transfer, outname);
if (err) {
newlog(logname,
"Versand der Daten fehlgeschlagen");
netcall_error = 1;
goto finish;
}
newlog(logname, "Empfange mit %s", transfer);
if (recvfile(transfer, inname)) {
newlog(logname,
"Empfang der Daten fehlgeschlagen");
netcall_error = 1;
goto finish;
}
st.st_size = 0;
if(stat(inname, &st)) {
newlog(logname,
"Zugriff auf %s fehlgeschlagen: %s",
inname, strerror(errno));
}
newlog(logname, "%ld Bytes empfangen", (long)st.st_size);
finish:
/* Fertig, Modem auflegen */
signal(SIGHUP, SIG_IGN);
fclose(stdin);
fclose(stdout);
hayes_hangup(lmodem); DMLOG("hayes hangup modem");
hangup(lmodem); DMLOG("hangup modem");
anrufdauer();
restore_linesettings(lmodem);
DMLOG("restoring modem parameters");
close(lmodem); lmodem=-1; DMLOG("close modem");
/* neuer stdin */
fopen("/dev/null", "r");
/* stderr wird in stdout kopiert */
dup2(fileno(stderr),fileno(stdout));
if(!netcall_error) {
/* Netcall war erfolgreich, also Daten loeschen */
if(have_file) {
/* Backups von Nullpuffern sind
uninteressant */
backup3(backoutdir,filename,sysname,arcer);
}
/* das ist nur ein Link, den putzen wir weg */
if ( unlink(outname)) {
newlog(ERRLOG,
"Loeschen von %s fehlgeschlagen: %s",
outname, strerror(errno));
}
fclose(deblogfile);
/*
* Und empfangene Daten (im Hintergrund) einlesen,
* das Modem wird sofort wieder freigegeben.
*/
switch(fork()) {
case -1:
{ /* cannot fork */
perror("forking import");
newlog(ERRLOG,
"Forken des Importteils "
"fehlgeschlagen: %s",
strerror(errno));
break;
}
case 0:
{
/* Ich bin child */
deblogfile=fopen("/tmp/import.deblogfile", "a");
DMLOG("child forked");
import_all(arcerin, sysname);
chdir ("/");
if(rmdir(tmpname)) {
newlog(ERRLOG,
"Loeschen von %s "
"fehlgeschlagen: %s",
tmpname, strerror(errno));
}
fclose(deblogfile);
exit(0);
}
default: /* parent */
break;
}
}
return(1);
} else {
/* ZCONNECT */
system_master(ich, sys);
if (auflegen) return 1;
bereitstellen();
files = 1;
senden_queue = todo;
todo = NULL;
while (!auflegen) {
datei_master(ich, sys);
}
anrufdauer();
close(lmodem); DMLOG("close modem");
aufraeumen();
exit (0);
}
return 1;
}
void set_global(int global_i, int global_j, double value)
{
if ((is_gindex_myrow(global_i)) && (is_gindex_mycol(global_j)))
set_local(translate_g2l_row(global_i), translate_g2l_col(global_j), value);
}
// Evolve method.
void base_nlopt::evolve(population &pop) const
{
// Useful variables.
const problem::base &problem = pop.problem();
if (problem.get_f_dimension() != 1) {
pagmo_throw(value_error,"this algorithm does not support multi-objective optimisation");
}
const problem::base::c_size_type c_size = problem.get_c_dimension();
const problem::base::c_size_type ec_size = problem.get_c_dimension() - problem.get_ic_dimension();
if (c_size && !m_constrained) {
pagmo_throw(value_error,"this algorithm does not support constraints");
}
if (ec_size && m_only_ineq) {
pagmo_throw(value_error,"this algorithm does not support equality constraints");
}
const problem::base::size_type cont_size = problem.get_dimension() - problem.get_i_dimension();
if (!cont_size) {
pagmo_throw(value_error,"the problem has no continuous part");
}
// Do nothing if the population is empty.
if (!pop.size()) {
return;
}
// Extract the best individual and set the inital point
const population::size_type best_ind_idx = pop.get_best_idx();
const population::individual_type &best_ind = pop.get_individual(best_ind_idx);
// Structure to pass data to the objective function wrapper.
nlopt_wrapper_data data_objfun;
data_objfun.prob = &problem;
data_objfun.x.resize(problem.get_dimension());
data_objfun.dx.resize(problem.get_dimension());
data_objfun.f.resize(1);
// Structure to pass data to the constraint function wrapper.
std::vector<nlopt_wrapper_data> data_constrfun(boost::numeric_cast<std::vector<nlopt_wrapper_data>::size_type>(c_size));
for (problem::base::c_size_type i = 0; i < c_size; ++i) {
data_constrfun[i].prob = &problem;
data_constrfun[i].x.resize(problem.get_dimension());
data_constrfun[i].dx.resize(problem.get_dimension());
data_constrfun[i].c.resize(problem.get_c_dimension());
data_constrfun[i].c_comp = i;
}
// Main NLopt call.
nlopt::opt opt(m_algo, problem.get_dimension());
m_opt = opt;
// Sets local optimizer for aug_lag methods, do nothing otherwise
set_local(problem.get_dimension());
m_opt.set_lower_bounds(problem.get_lb());
m_opt.set_upper_bounds(problem.get_ub());
m_opt.set_min_objective(objfun_wrapper, &data_objfun);
for (problem::base::c_size_type i =0; i<ec_size; ++i) {
m_opt.add_equality_constraint(constraints_wrapper, &data_constrfun[i], problem.get_c_tol().at(i));
}
for (problem::base::c_size_type i =ec_size; i<c_size; ++i) {
m_opt.add_inequality_constraint(constraints_wrapper, &data_constrfun[i], problem.get_c_tol().at(i));
}
m_opt.set_ftol_abs(m_ftol);
m_opt.set_xtol_abs(m_xtol);
m_opt.set_maxeval(m_max_iter);
//nlopt::result result;
double dummy;
decision_vector x0(best_ind.cur_x);
m_opt.optimize(x0, dummy);
pop.set_x(best_ind_idx,x0);
}
void set_global(int gi, double value) {
if (is_gindex(gi)) set_local(gi - offset_, value);
}
void SceneGraph::set_local_scale(TransformInstance i, const Vector3& scale)
{
_data.local[i.i].scale = scale;
set_local(i);
}
static void vm_loop(su_state *s, function_t *func) {
value_t tmpv, tmpv2;
instruction_t inst;
int tmp, narg, i, j, k;
const char *tmpcs;
su_debug_data dbg;
s->frame = FRAME();
s->prot = func->prot;
#define ARITH_OP(op) \
su_check_type(s, -2, SU_NUMBER); \
su_check_type(s, -1, SU_NUMBER); \
STK(-2)->obj.num = STK(-2)->obj.num op STK(-1)->obj.num; \
su_pop(s, 1); \
break;
#define LOG_OP(op) \
su_check_type(s, -2, SU_NUMBER); \
su_check_type(s, -1, SU_NUMBER); \
STK(-2)->type = SU_BOOLEAN; \
STK(-2)->obj.b = STK(-2)->obj.num op STK(-1)->obj.num; \
su_pop(s, 1); \
break;
for (s->pc = 0; s->pc < s->prot->num_inst; s->pc++) {
tmp = s->interrupt | atomic_get(&s->msi->interrupt);
if (tmp) {
if ((tmp & ISCOLLECT) == ISCOLLECT) {
su_thread_indisposable(s);
su_thread_disposable(s);
}
if ((tmp & IGC) == IGC) {
unmask_thread_interrupt(s, IGC);
gc_trace(s);
}
if ((tmp & IBREAK) == IBREAK) {
unmask_thread_interrupt(s, IBREAK);
dbg.file = s->prot->name->str;
dbg.line = s->prot->lineinf[s->pc];
s->debug_cb(s, &dbg, s->debug_cb_data);
}
}
inst = s->prot->inst[s->pc];
switch (inst.id) {
case OP_PUSH:
push_value(s, &func->constants[inst.a]);
break;
case OP_POP:
su_pop(s, inst.a);
break;
case OP_ADD: ARITH_OP(+)
case OP_SUB: ARITH_OP(-)
case OP_MUL: ARITH_OP(*)
case OP_DIV:
su_check_type(s, -2, SU_NUMBER);
su_check_type(s, -1, SU_NUMBER);
su_assert(s, STK(-1)->obj.num != 0.0, "Division by zero!");
STK(-2)->obj.num = STK(-2)->obj.num / STK(-1)->obj.num;
su_pop(s, 1);
break;
case OP_MOD:
su_check_type(s, -2, SU_NUMBER);
su_check_type(s, -1, SU_NUMBER);
STK(-2)->obj.num = (double)((int)STK(-2)->obj.num % (int)STK(-1)->obj.num);
su_pop(s, 1);
break;
case OP_POW:
su_check_type(s, -2, SU_NUMBER);
su_check_type(s, -1, SU_NUMBER);
STK(-2)->obj.num = pow(STK(-2)->obj.num, STK(-1)->obj.num);
su_pop(s, 1);
break;
case OP_UNM:
su_check_type(s, -1, SU_NUMBER);
STK(-1)->obj.num = -STK(-1)->obj.num;
break;
case OP_EQ:
STK(-2)->obj.b = value_eq(STK(-2), STK(-1));
STK(-2)->type = SU_BOOLEAN;
su_pop(s, 1);
break;
case OP_LESS: LOG_OP(<);
case OP_LEQUAL: LOG_OP(<=);
case OP_NOT:
if (STK(-1)->type == SU_BOOLEAN) {
STK(-1)->obj.b = !STK(-1)->obj.b;
} else {
STK(-1)->obj.b = (STK(-1)->type == SU_NIL) ? 1 : 0;
STK(-1)->type = SU_BOOLEAN;
}
break;
case OP_AND:
tmp = STK(-2)->type != SU_NIL && (STK(-2)->type != SU_BOOLEAN || STK(-2)->obj.b);
if (tmp && STK(-1)->type != SU_NIL && (STK(-1)->type != SU_BOOLEAN || STK(-1)->obj.b)) {
s->stack[s->stack_top - 2] = *STK(-1);
} else {
STK(-2)->obj.b = 0;
STK(-2)->type = SU_BOOLEAN;
}
su_pop(s, 1);
break;
case OP_OR:
if (STK(-2)->type != SU_NIL && (STK(-2)->type != SU_BOOLEAN || STK(-2)->obj.b)) {
/* return -2 */
} else if (STK(-1)->type != SU_NIL && (STK(-1)->type != SU_BOOLEAN || STK(-1)->obj.b)) {
s->stack[s->stack_top - 2] = *STK(-1);
} else {
STK(-2)->obj.b = 0;
STK(-2)->type = SU_BOOLEAN;
}
su_pop(s, 1);
break;
case OP_TEST:
if (STK(-1)->type != SU_NIL && (STK(-1)->type != SU_BOOLEAN || STK(-1)->obj.b))
s->pc = inst.b - 1;
su_pop(s, 1);
break;
case OP_FOR:
if (STK(-2)->type == SU_NIL) {
su_swap(s, -2, -1);
s->stack_top--;
s->pc = inst.b - 1;
} else {
s->stack_top--;
su_check_type(s, -1, SU_SEQ);
su_rest(s, -1);
su_swap(s, -2, -1);
su_first(s, -1);
su_swap(s, -2, -1);
s->stack_top--;
}
break;
case OP_JMP:
s->pc = inst.b - 1;
break;
case OP_RETURN:
s->pc = s->frame->ret_addr - 1;
s->prot = s->frame->func->prot;
func = s->frame->func;
s->stack[s->frame->stack_top] = *STK(-1);
s->stack_top = s->frame->stack_top + 1;
s->frame_top--;
s->frame = FRAME();
break;
case OP_TCALL:
s->pc = s->frame->ret_addr - 1;
s->prot = s->frame->func->prot;
func = s->frame->func;
memmove(&s->stack[s->frame->stack_top], &s->stack[s->stack_top - (inst.a + 1)], sizeof(value_t) * (inst.a + 1));
s->stack_top = s->frame->stack_top + inst.a + 1;
s->frame_top--;
s->frame = FRAME();
/* Do a normal call. */
case OP_CALL:
tmp = s->stack_top - inst.a - 1;
switch (s->stack[tmp].type) {
case SU_FUNCTION:
s->frame = &s->frames[s->frame_top++];
assert(s->frame_top <= MAX_CALLS);
s->frame->ret_addr = s->pc + 1;
s->frame->func = func;
s->frame->stack_top = tmp;
func = s->stack[tmp].obj.func;
if (func->narg < 0)
su_vector(s, inst.a);
else if (func->narg != inst.a)
su_error(s, "Bad number of arguments to function! Expected %i, but got %i.", (int)func->narg, (int)inst.a);
s->prot = func->prot;
s->pc = -1;
break;
case SU_NATIVEFUNC:
narg = s->narg;
s->narg = inst.a;
if (s->stack[tmp].obj.nfunc(s, inst.a)) {
s->stack[tmp] = *STK(-1);
} else {
s->stack[tmp].type = SU_NIL;
}
s->stack_top = tmp + 1;
s->narg = narg;
break;
case SU_VECTOR:
if (inst.a == 1) {
su_check_type(s, -1, SU_NUMBER);
tmpv = vector_index(s, s->stack[tmp].obj.vec, su_tointeger(s, -1));
su_pop(s, 2);
push_value(s, &tmpv);
} else {
for (i = -inst.a, j = 0; i; i++, j++) {
su_check_type(s, i - j, SU_NUMBER);
tmpv = vector_index(s, s->stack[tmp].obj.vec, su_tointeger(s, i - j));
push_value(s, &tmpv);
}
su_vector(s, inst.a);
s->stack[tmp] = s->stack[s->stack_top - 1];
s->stack_top -= inst.a + 1;
}
break;
case SU_MAP:
if (inst.a == 1) {
tmpv2 = *STK(-1);
tmpv = map_get(s, s->stack[tmp].obj.m, &tmpv2, hash_value(&tmpv2));
su_assert(s, tmpv.type != SU_INV, "No value with key: %s", stringify(s, &tmpv2));
su_pop(s, 2);
push_value(s, &tmpv);
} else {
for (i = -inst.a, j = 0; i; i++, j += 2) {
tmpv2 = *STK(i - j);
push_value(s, &tmpv2);
tmpv = map_get(s, s->stack[tmp].obj.m, &tmpv2, hash_value(&tmpv2));
su_assert(s, tmpv.type != SU_INV, "No value with key: %s", stringify(s, &tmpv2));
push_value(s, &tmpv);
}
su_map(s, inst.a);
s->stack[tmp] = s->stack[s->stack_top - 1];
s->stack_top -= inst.a + 1;
}
break;
case SU_STRING:
if (inst.a == 1) {
su_check_type(s, -1, SU_NUMBER);
j = su_tointeger(s, -1);
su_assert(s, j < s->stack[tmp].obj.str->size, "Out of range!");
s->scratch_pad[0] = s->stack[tmp].obj.str->str[j];
su_pop(s, 2);
su_pushbytes(s, s->scratch_pad, 1);
} else {
k = 0;
for (i = -inst.a; i; i++) {
su_check_type(s, i, SU_NUMBER);
j = su_tointeger(s, i);
su_assert(s, j < s->stack[tmp].obj.str->size, "Out of range!");
s->scratch_pad[k++] = s->stack[tmp].obj.str->str[j];
assert(k < SU_SCRATCHPAD_SIZE);
}
su_pushbytes(s, s->scratch_pad, k);
s->stack[tmp] = s->stack[s->stack_top - 1];
s->stack_top -= inst.a + 1;
}
break;
case SU_NATIVEDATA:
tmpv = s->stack[tmp];
if (tmpv.obj.data->vt && tmpv.obj.data->vt->call) {
narg = s->narg;
s->narg = inst.a;
if (tmpv.obj.data->vt->call(s, (void*)tmpv.obj.data->data, inst.a))
s->stack[tmp] = *STK(-1);
else
s->stack[tmp].type = SU_NIL;
s->stack_top = tmp + 1;
s->narg = narg;
break;
}
default:
if (inst.a == 1 && isseq(s, &s->stack[tmp])) {
su_check_type(s, -1, SU_STRING);
tmpcs = su_tostring(s, -1, NULL);
if (!strcmp(tmpcs, "first")) {
s->stack[(--s->stack_top) - 1] = seq_first(s, STK(-1)->obj.q);
break;
} else if (!strcmp(tmpcs, "rest")) {
s->stack[(--s->stack_top) - 1] = seq_rest(s, STK(-1)->obj.q);
break;
}
}
su_error(s, "Can't apply '%s'.", type_name(s->stack[tmp].type));
}
break;
case OP_LAMBDA:
assert(inst.a < s->prot->num_prot);
lambda(s, &s->prot->prot[inst.a], inst.b);
break;
case OP_GETGLOBAL:
tmpv = func->constants[inst.a];
su_assert(s, tmpv.type == SU_STRING, "Global key must be a string!");
tmpv = map_get(s, unref_local(s, s->stack[SU_GLOBAL_INDEX].obj.loc).obj.m, &tmpv, hash_value(&tmpv));
if (tmpv.type == SU_INV)
global_error(s, "Undefined global variable", &func->constants[inst.a]);
push_value(s, &tmpv);
break;
case OP_SETGLOBAL:
tmpv = func->constants[inst.a];
su_assert(s, tmpv.type == SU_STRING, "Global key must be a string!");
i = hash_value(&tmpv);
tmpv2 = unref_local(s, s->stack[SU_GLOBAL_INDEX].obj.loc);
tmpv = map_insert(s, tmpv2.obj.m, &tmpv, i, STK(-1));
set_local(s, s->stack[SU_GLOBAL_INDEX].obj.loc, &tmpv);
break;
case OP_SHIFT:
s->stack[s->stack_top - (inst.a + 1)] = *STK(-1);
s->stack_top -= inst.a;
break;
case OP_LOAD:
assert(FRAME()->stack_top + inst.a < s->stack_top);
push_value(s, &s->stack[FRAME()->stack_top + inst.a]);
break;
case OP_LUP:
assert(inst.a < func->num_ups);
push_value(s, &func->upvalues[inst.a]);
break;
case OP_LCL:
assert(inst.b < s->msi->num_c_lambdas);
push_value(s, &s->msi->c_lambdas[inst.b]);
break;
default:
assert(0);
}
#undef ARITH_OP
#undef LOG_OP
}
}
void SceneGraph::set_local_pose(TransformInstance i, const Matrix4x4& pose)
{
_data.local[i.i] = pose;
set_local(i);
}
void set_pair_local(int i, Node* lval) {
// longs are stored in locals as a value/half pair (like doubles)
set_local(i+0, lval);
set_local(i+1, top());
}
