void emu_options::update_cached_options()
{
m_coin_impulse = int_value(OPTION_COIN_IMPULSE);
m_joystick_contradictory = bool_value(OPTION_JOYSTICK_CONTRADICTORY);
m_sleep = bool_value(OPTION_SLEEP);
m_refresh_speed = bool_value(OPTION_REFRESHSPEED);
}
void emu_options::update_cached_options()
{
m_coin_impulse = int_value(OPTION_COIN_IMPULSE);
m_joystick_contradictory = bool_value(OPTION_JOYSTICK_CONTRADICTORY);
m_sleep = bool_value(OPTION_SLEEP);
m_refresh_speed = bool_value(OPTION_REFRESHSPEED);
auto ui_option_string = value(OPTION_UI);
if (!strcmp(ui_option_string, "simple"))
m_ui = UI_SIMPLE;
else
m_ui = UI_CABINET;
}
/*
* call-seq: LocalMemCache.drop(*args)
*
* Deletes a memory pool. If the :force option is set, locked semaphores are
* removed as well.
*
* WARNING: Do only call this method with the :force option if you are sure
* that you really want to remove this memory pool and no more processes are
* still using it.
*
* If you delete a pool and other processes still have handles open on it, the
* status of these handles becomes undefined. There's no way for a process to
* know when a handle is not valid anymore, so only delete a memory pool if
* you are sure that all handles are closed.
*
* valid options for drop are
* [:namespace]
* [:filename]
* [:force]
*
* The memory pool must be specified by either setting the :filename or
* :namespace option. The default for :force is false.
*/
static VALUE LocalMemCache__drop(VALUE klass, VALUE o) {
lmc_check_dict(o);
lmc_error_t e;
if (!local_memcache_drop_namespace(
rstring_ptr_null(rb_hash_aref(o, lmc_rb_sym_namespace)),
rstring_ptr_null(rb_hash_aref(o, lmc_rb_sym_filename)),
bool_value(rb_hash_aref(o, lmc_rb_sym_force)), &e)) {
rb_lmc_raise_exception(&e);
}
return Qnil;
}
/*
* call-seq: Cache.drop(*args)
*
* Deletes a memory pool. If the :force option is set, locked semaphores are
* removed as well.
*
* WARNING: Do only call this method with the :force option if you are sure
* that you really want to remove this memory pool and no more processes are
* still using it.
*
* If you delete a pool and other processes still have handles open on it, the
* status of these handles becomes undefined. There's no way for a process to
* know when a handle is not valid anymore, so only delete a memory pool if
* you are sure that all handles are closed.
*
* valid options for drop are
* [:namespace]
* [:filename]
* [:force]
*
* The memory pool must be specified by either setting the :filename or
* :namespace option. The default for :force is false.
*/
static mrb_value Cache__drop(mrb_state *mrb, mrb_value self)
{
mrb_value o;
mrb_get_args(mrb, "o", &o);
lmc_check_dict(mrb, o);
lmc_error_t e;
if (!local_memcache_drop_namespace(rstring_ptr_null(mrb_hash_get(mrb, o, lmc_rb_sym_namespace(mrb))),
rstring_ptr_null(mrb_hash_get(mrb, o, lmc_rb_sym_filename(mrb))),
bool_value(mrb_hash_get(mrb, o, lmc_rb_sym_force(mrb))), &e)) {
rb_lmc_raise_exception(mrb, &e);
}
return mrb_nil_value();
}
void display(LISP_OBJ_PTR objp) {
switch (objp->form) {
case INT_FORM:
fprintf(out_stream, "%d", int_value(objp));
break;
case FLOAT_FORM:
fprintf(out_stream, "%g", float_value(objp));
break;
case CHAR_FORM:
fprintf(out_stream, "%c", char_value(objp));
break;
case STRING_FORM:
fprintf(out_stream, "%s", string_value(objp));
break;
case SYMBOL_FORM:
fprintf(out_stream, "%s", symbol_value(objp));
break;
case PROCEDURE_FORM:
fprintf(out_stream, "<PROCEDURE>");
break;
case BOOLEAN_FORM:
fprintf(out_stream, "#%c", bool_value(objp) ? 't' : 'f');
break;
case CONS_FORM:
fprintf(out_stream, "(");
while (TRUE) {
print_lispobj(car(objp));
objp = cdr(objp);
if (objp == nil_ptr)
break;
if (!(is_pair(objp))) {
printf(" . ");
print_lispobj(objp);
break;
}
fprintf(out_stream, " ");
}
fprintf(out_stream, ")");
break;
case NO_FORM:
fprintf(out_stream, "no form, boss");
break;
default:
fprintf(out_stream, "dunno that form %d", form(objp));
}
}
Value is_even(Value i)
{
return bool_value(i.i % 2 == 0);
}
static bool assign_xml_value_to_protobuf_field(const std::string &value, xmltype xtype, ::google::protobuf::Message* msg, const ::google::protobuf::FieldDescriptor* field)
{
if (xtype==duration)
return assign_xml_duration_value_to_protobuf_field(value,msg,field);
// handle xmltype 'automatic'
const ::google::protobuf::Reflection* reflection = msg->GetReflection();
switch (field->cpp_type()) {
case ::google::protobuf::FieldDescriptor::CPPTYPE_INT32: {
long longval;
if (long_value(value,longval))
reflection->SetInt32(msg, field, longval);
else
printf("ERROR:\n");
break;
}
case ::google::protobuf::FieldDescriptor::CPPTYPE_INT64: {
long longval;
if (long_value(value,longval))
reflection->SetInt64(msg, field, longval);
else
printf("ERROR:\n");
break;
}
case ::google::protobuf::FieldDescriptor::CPPTYPE_UINT32: {
unsigned long ulongval;
if (ulong_value(value,ulongval))
reflection->SetUInt32(msg, field, ulongval);
else
printf("ERROR:\n");
break;
}
case ::google::protobuf::FieldDescriptor::CPPTYPE_UINT64: {
unsigned long ulongval;
if (ulong_value(value,ulongval))
reflection->SetUInt64(msg, field, ulongval);
else
printf("ERROR:\n");
break;
}
case ::google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE: {
double doubleval;
if (double_value(value,doubleval))
reflection->SetDouble(msg, field, doubleval);
else
printf("ERROR:\n");
break;
}
case ::google::protobuf::FieldDescriptor::CPPTYPE_FLOAT: {
double floatval;
if (float_value(value,floatval))
reflection->SetFloat(msg, field, floatval);
else
printf("ERROR:\n");
break;
}
case ::google::protobuf::FieldDescriptor::CPPTYPE_BOOL: {
bool boolval;
if (bool_value(value,boolval))
reflection->SetBool(msg, field, boolval);
else
printf("ERROR:\n");
break;
}
case ::google::protobuf::FieldDescriptor::CPPTYPE_ENUM: {
const ::google::protobuf::EnumDescriptor *enu = field->enum_type();
const ::google::protobuf::EnumValueDescriptor *enuval = enu->FindValueByName(value);
if (!enuval) {
printf("ERROR: '%s' not a valid value for %s !\n",value.c_str(),enu->name().c_str());
} else {
//printf("SUCCESS: '%s' is a valid value for %s !\n",value.c_str(),enu->name().c_str());
reflection->SetEnum(msg, field, enuval);
}
break;
}
case ::google::protobuf::FieldDescriptor::CPPTYPE_STRING:
reflection->SetString(msg, field, value);
break;
case ::google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE:
printf("ERROR: element should not contain text data but we got '%s' !\n",value.c_str());
return false;
default:
printf("ERROR: Unsupported field type '%d' !\n", field->cpp_type());
return false;
}
return true;
}
static svn_error_t *
entries_dump(const char *dir_path, svn_wc_adm_access_t *related, apr_pool_t *pool)
{
svn_wc_adm_access_t *adm_access = NULL;
apr_hash_t *entries;
apr_hash_index_t *hi;
svn_boolean_t locked;
svn_error_t *err;
svn_wc_context_t *wc_ctx = NULL;
const char *dir_abspath;
err = svn_wc_adm_open3(&adm_access, related, dir_path, FALSE, 0,
NULL, NULL, pool);
if (!err)
{
SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
svn_wc__adm_get_db(adm_access),
pool));
SVN_ERR(svn_dirent_get_absolute(&dir_abspath, dir_path, pool));
SVN_ERR(svn_wc_locked2(NULL, &locked, wc_ctx, dir_abspath, pool));
SVN_ERR(svn_wc_entries_read(&entries, adm_access, TRUE, pool));
}
else if (err && err->apr_err == SVN_ERR_WC_LOCKED
&& related
&& ! strcmp(dir_path, svn_wc_adm_access_path(related)))
{
/* Common caller error: Can't open a baton when there is one. */
svn_error_clear(err);
SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
svn_wc__adm_get_db(related),
pool));
SVN_ERR(svn_dirent_get_absolute(&dir_abspath, dir_path, pool));
SVN_ERR(svn_wc_locked2(NULL, &locked, wc_ctx, dir_abspath, pool));
SVN_ERR(svn_wc_entries_read(&entries, related, TRUE, pool));
}
else
{
const char *lockfile_path;
svn_node_kind_t kind;
/* ### Should svn_wc_adm_open3 be returning UPGRADE_REQUIRED? */
if (err->apr_err != SVN_ERR_WC_NOT_DIRECTORY)
return err;
svn_error_clear(err);
adm_access = NULL;
SVN_ERR(svn_dirent_get_absolute(&dir_abspath, dir_path, pool));
SVN_ERR(svn_wc__read_entries_old(&entries, dir_abspath, pool, pool));
lockfile_path = svn_dirent_join_many(pool, dir_path,
svn_wc_get_adm_dir(pool),
"lock", SVN_VA_NULL);
SVN_ERR(svn_io_check_path(lockfile_path, &kind, pool));
locked = (kind == svn_node_file);
}
for (hi = apr_hash_first(pool, entries); hi; hi = apr_hash_next(hi))
{
const char *key = apr_hash_this_key(hi);
const svn_wc_entry_t *entry = apr_hash_this_val(hi);
SVN_ERR_ASSERT(strcmp(key, entry->name) == 0);
printf("e = Entry()\n");
str_value("name", entry->name);
int_value("revision", entry->revision);
str_value("url", entry->url);
str_value("repos", entry->repos);
str_value("uuid", entry->uuid);
int_value("kind", entry->kind);
int_value("schedule", entry->schedule);
bool_value("copied", entry->copied);
bool_value("deleted", entry->deleted);
bool_value("absent", entry->absent);
bool_value("incomplete", entry->incomplete);
str_value("copyfrom_url", entry->copyfrom_url);
int_value("copyfrom_rev", entry->copyfrom_rev);
str_value("conflict_old", entry->conflict_old);
str_value("conflict_new", entry->conflict_new);
str_value("conflict_wrk", entry->conflict_wrk);
str_value("prejfile", entry->prejfile);
/* skip: text_time */
/* skip: prop_time */
/* skip: checksum */
int_value("cmt_rev", entry->cmt_rev);
/* skip: cmt_date */
str_value("cmt_author", entry->cmt_author);
str_value("lock_token", entry->lock_token);
str_value("lock_owner", entry->lock_owner);
str_value("lock_comment", entry->lock_comment);
/* skip: lock_creation_date */
/* skip: has_props */
/* skip: has_prop_mods */
/* skip: cachable_props */
/* skip: present_props */
str_value("changelist", entry->changelist);
/* skip: working_size */
/* skip: keep_local */
int_value("depth", entry->depth);
/* skip: tree_conflict_data */
bool_value("file_external", entry->file_external_path != NULL);
/* skip: file_external_peg_rev */
/* skip: file_external_rev */
bool_value("locked", locked && *entry->name == '\0');
printf("entries['%s'] = e\n", (const char *)key);
}
if (wc_ctx)
SVN_ERR(svn_wc_context_destroy(wc_ctx));
if (adm_access)
SVN_ERR(svn_wc_adm_close2(adm_access, pool));
return SVN_NO_ERROR;
}
CS_IMPLEMENT_APPLICATION
int main (int argc, char *argv[])
{
iObjectRegistry* objreg = csInitializer::CreateEnvironment (argc, argv);
if (! objreg)
{
csFPrintf (stderr, "Failed to create environment!\n");
return 1;
}
bool ok = csInitializer::RequestPlugins (objreg,
CS_REQUEST_REPORTER,
CS_REQUEST_REPORTERLISTENER,
CS_REQUEST_PLUGIN ("crystalspace.script.perl5", iScript),
CS_REQUEST_END);
if (! ok)
{
csFPrintf (stderr, "Failed to load plugins!\n");
return 2;
}
if (csCommandLineHelper::CheckHelp (objreg))
{
csCommandLineHelper::Help (objreg);
return 0;
}
{
csRef<iScript> script = csQueryRegistry<iScript> (objreg);
if (! script)
{
csFPrintf (stderr, "Failed to find perl5 plugin!\n");
return 3;
}
ok = script->LoadModule ("cspace");
//ok = script->LoadModule ("scripts/perl5", "cspace.pm");
if (! ok)
{
csFPrintf (stderr, "Failed to load perl5 cspace module!\n");
return 4;
}
csInitializer::OpenApplication (objreg);
//====================================================================//
csPrintf ("Testing RValue/Store/Retrieve:\n");
int test_int = 3;
float test_float = 3.0;
double test_double = 3.0;
bool test_bool = true;
const char *test_str = "hello";
csPrintf (" Int: ");
csRef<iScriptValue> int_value (script->RValue (test_int));
ok = script->Store("i", int_value);
int_value.AttachNew (script->Retrieve ("i"));
csPrintf ("%d == %d\n", test_int, int_value->GetInt ());
csPrintf (" Float: ");
csRef<iScriptValue> float_value (script->RValue (test_float));
ok = script->Store("f", float_value);
float_value.AttachNew (script->Retrieve ("f"));
csPrintf ("%f == %f\n", test_float, float_value->GetFloat ());
csPrintf (" Double: ");
csRef<iScriptValue> double_value (script->RValue (test_double));
ok = script->Store("d", double_value);
double_value.AttachNew (script->Retrieve ("d"));
csPrintf ("%lf == %lf\n", test_double, double_value->GetDouble ());
csPrintf (" String: ");
csRef<iScriptValue> str_value (script->RValue (test_str));
ok = script->Store("s", str_value);
str_value.AttachNew (script->Retrieve ("s"));
csPrintf ("%s == %s\n", test_str, str_value->GetString ()->GetData ());
csPrintf (" Bool: ");
csRef<iScriptValue> bool_value (script->RValue (test_bool));
ok = script->Store("b", bool_value);
bool_value.AttachNew (script->Retrieve ("b"));
csPrintf ("%s == %s\n\n", test_bool ? "true" : "false",
bool_value->GetBool () ? "true" : "false");
//====================================================================//
csPrintf ("Testing Remove:\n");
ok = script->Remove ("i") && script->Remove ("f") && script->Remove ("d")
&& script->Remove ("s") && script->Remove ("b");
csPrintf (" %s\n", ok ? "ok" : "failed");
int_value.AttachNew (script->Retrieve ("i"));
csPrintf (" %s\n", int_value.IsValid () ? "failed" : "ok");
//====================================================================//
csPrintf ("Testing New(csVector3):\n");
csRef<iScriptObject> obj (script->New ("csVector3"));
csPrintf (" %s\n", obj.IsValid () ? "ok" : "failed");
//====================================================================//
csPrintf ("Testing GetClass/IsA:\n");
csRef<iString> classname (obj->GetClass ());
csPrintf (" %s\n", classname->GetData ());
csPrintf (" %s\n", obj->IsA ("csVector3") ? "ok" : "failed");
//====================================================================//
csPrintf ("Testing Set/Get:\n");
csPrintf (" %f == ", float_value->GetFloat ());
ok = obj->Set ("x", float_value);
float_value.AttachNew (obj->Get ("x"));
csPrintf ("%f\n", float_value->GetFloat ());
//====================================================================//
csPrintf ("Testing Call(csVector3::Set):\n");
csRefArray<iScriptValue> args;
args.Push (float_value);
csRef<iScriptValue> ret (obj->Call ("Set", args));
csPrintf (" %f\n", float_value->GetFloat ());
//====================================================================//
csPrintf ("Testing Call(csVector3::Norm):\n");
ret.AttachNew (obj->Call ("Norm"));
csPrintf (" %f\n", ret->GetFloat ());
//====================================================================//
csPrintf ("Testing GetPointer:\n");
csVector3 &vector = * (csVector3 *) obj->GetPointer ();
vector.Normalize ();
csPrintf (" %f %f %f\n", vector[0], vector[1], vector[2]);
csPrintf (" ok\n");
csPrintf ("All Done!\n");
}
csInitializer::DestroyApplication (objreg);
return 0;
}
void print_ast(struct ast* node) {
if (node != NULL) {
switch(node->node_type) {
case N_NIL : {
printf("nil");
break;
};
case N_BOOL : {
if (bool_value(node) == 1) {
printf("true");
} else {
printf("false");
};
break;
};
case N_INTEGER : {
printf("%d", int_value(node));
break;
};
case N_DOUBLE : {
printf("%f", double_value(node));
break;
};
case N_STRING_1: {
printf("%s", string_value(node));
break;
};
case N_STRING_2: {
printf("%s", string_value(node));
break;
};
case N_IDENTIFIER : {
struct identifier_node* i = (struct identifier_node*)node;
printf("%s", i->name);
break;
};
case N_OBJECT : {
struct object_node* o = (struct object_node*)node;
printf("Class: %s\n", o->class_ptr->name);
printf("Inst Vars:\n");
print_sym_list(o->sym_list);
break;
};
case N_OP_EQUAL : {
print_ast(node->left);
printf(" = ");
print_ast(node->right);
break;
};
case N_OP_PLUS_EQ : {
print_ast(node->left);
printf(" += ");
print_ast(node->right);
break;
};
case N_OP_MINUS_EQ : {
print_ast(node->left);
printf(" -= ");
print_ast(node->right);
break;
};
case N_OP_MUL_EQ : {
print_ast(node->left);
printf(" *= ");
print_ast(node->right);
break;
};
case N_OP_DIV_EQ : {
print_ast(node->left);
printf(" /= ");
print_ast(node->right);
break;
};
case N_OP_MODULO_EQ : {
print_ast(node->left);
printf(" mod= ");
print_ast(node->right);
break;
};
case N_ARG_LIST : {
struct list_node* l = (struct list_node*)node;
print_list(l);
break;
};
case N_OP_MUL : {
print_ast(node->left);
printf(" * ");
print_ast(node->right);
break;
};
case N_OP_DIV : {
print_ast(node->left);
printf(" / ");
print_ast(node->right);
break;
};
case N_OP_MODULO : {
print_ast(node->left);
printf(" mod ");
print_ast(node->right);
break;
};
case N_OP_PLUS : {
print_ast(node->left);
printf(" + ");
print_ast(node->right);
break;
};
case N_OP_MINUS : {
print_ast(node->left);
printf(" - ");
print_ast(node->right);
break;
};
case N_OP_CMP_GT : {
print_ast(node->left);
printf(" > ");
print_ast(node->right);
break;
};
case N_OP_CMP_GT_EQ : {
print_ast(node->left);
printf(" >= ");
print_ast(node->right);
break;
};
case N_OP_CMP_LE : {
print_ast(node->left);
printf(" < ");
print_ast(node->right);
break;
};
case N_OP_CMP_LE_EQ : {
print_ast(node->left);
printf(" <= ");
print_ast(node->right);
break;
};
case N_OP_CMP_EQ : {
print_ast(node->left);
printf(" == ");
print_ast(node->right);
break;
};
case N_OP_CMP_EQ_EQ : {
print_ast(node->left);
printf(" === ");
print_ast(node->right);
break;
};
case N_OP_CMP_INEQ : {
print_ast(node->left);
printf(" <=> ");
print_ast(node->right);
break;
};
case N_OP_CMP_NEG : {
print_ast(node->left);
printf(" != ");
print_ast(node->right);
break;
};
case N_OP_CMP_AND : {
print_ast(node->left);
printf(" && ");
print_ast(node->right);
break;
};
case N_OP_CMP_OR : {
print_ast(node->left);
printf(" || ");
print_ast(node->right);
break;
};
case N_OP_PLUS_UN : {
printf("+");
print_ast(node->left);
break;
};
case N_OP_MINUS_UN : {
printf("+");
print_ast(node->left);
break;
};
case N_OP_NOT : {
printf("+");
print_ast(node->left);
break;
};
case N_STMT_LIST : {
print_ast(node->right);
print_ast(node->left);
break;
};
case N_FUNCTION : {
struct function_node* f = (struct function_node*)node;
printf("def %s", f->name); // def function name
print_list(f->args); // function parameters
print_ast(f->stmts); // comp_statements
printf("end");
break;
};
case N_RETURN : {
printf("return ");
print_ast(node->left); // expression
printf("\n");
break;
};
case N_WHILE : {
printf("while ");
print_ast(node->left); // expression
printf("\n");
print_ast(node->right); // comp_statements
printf("\nend");
break;
};
case N_CLASS : {
struct class_node* c = (struct class_node*)node;
printf("class %s\n", c->name); // class name
print_list(c->stmts); // comp_statements
printf("end");
break;
};
case N_METHOD_CALL_2 : {
struct method_call_node* m = (struct method_call_node*) node;
printf("%s ", m->method_name);
print_list(m->args);
break;
};
default : {
printf("%i\n", node->node_type);
printf("ERROR: when printing %c.\n", node->node_type);
};
};
};
};
struct ast* rputs(struct ast* a){
if (a->node_type == N_METHOD_CALL_0 || a->node_type == N_METHOD_CALL_1 || a->node_type == N_METHOD_CALL_2) {
struct method_call_node* m = (struct method_call_node*)a;
struct list_node* arg_node = m->args;
// caso especial: puts() sin parámetros imprime salto de línea
if (arg_node == NULL) {
printf("\n");
// comportamiento normal
} else {
while(arg_node != NULL){
struct ast* evaluated = eval_ast(arg_node->arg);
rputs(evaluated);
arg_node = arg_node->next;
};
};
} else if (a->node_type == N_ARRAY) {
int arr_size = array_tree_size(a->left);
struct ast* result[arr_size];
struct ast* ptr = a->left;
int i;
for (i = 0; i < arr_size; i++) {
result[i] = ptr;
ptr = ptr->right;
};
ptr = result[arr_size-1];
for (i = arr_size-1; i >= 0; i--) {
rputs(eval_ast(result[i]));
};
} else if (a->node_type == N_ARRAY_CONTENT) {
rputs(eval_ast(a->left));
} else if (a->node_type == N_STRING_1) {
printf("%s\n", string_value(a));
} else if (a->node_type == N_STRING_2) {
char * str = malloc(sizeof( strlen(string_value(a)) ));
strcpy(str, string_value(a));
str = build_end_of_lines(str);
printf("%s\n", str);
} else if (a->node_type == N_INTEGER) {
printf("%d\n", int_value(a));
} else if (a->node_type == N_DOUBLE) {
double d = double_value(a);
if ( d - floor(d) == 0.0 ) {
printf( "%g.0\n", d );
} else {
printf( "%g\n", d );
};
} else if (a->node_type == N_BOOL) {
printf("%s\n", bool_value(a) ? "true" : "false");
} else if (a->node_type == N_NIL) {
printf("\n");
} else if (a->node_type == N_OBJECT) {
struct object_node * object = (struct object_node *) a;
printf("<#%s:%p>\n", object->class_ptr->name, (void *)object);
} else {
printf("Puts doesn't support %s type, sorry :D\n", type_name(a->node_type));
};
return new_nil_node();
};
