bool ScriptContainer::runScript(const Common::UString &script, const Aurora::NWScript::ScriptState &state, Aurora::NWScript::Object *owner, Aurora::NWScript::Object *triggerer) { if (script.empty()) return true; try { Aurora::NWScript::NCSFile ncs(script); const Aurora::NWScript::Variable &retVal = ncs.run(state, owner, triggerer); if (retVal.getType() == Aurora::NWScript::kTypeInt) return retVal.getInt() != 0; if (retVal.getType() == Aurora::NWScript::kTypeFloat) return retVal.getFloat() != 0.0f; return true; } catch (Common::Exception &e) { e.add("Failed running script \"%s\"", script.c_str()); Common::printException(e, "WARNING: "); return false; } return true; }
void Functions::executeScript(Aurora::NWScript::FunctionContext &ctx) { Common::UString script = ctx.getParams()[0].getString(); // Max resource name length is 16, and ExecuteScript should truncate accordingly script.truncate(16); if (!ResMan.hasResource(script, Aurora::kFileTypeNCS)) return; Aurora::NWScript::Object *object = getParamObject(ctx, 1); try { Aurora::NWScript::NCSFile ncs(script); // Let the child script inherit the environment of this parent script Aurora::NWScript::VariableContainer *env = ctx.getCurrentEnvironment(); if (env) ncs.setEnvironment(*env); ncs.run(object); } catch (Common::Exception &e) { e.add("Failed ExecuteScript(\"%s\", %s)", script.c_str(), Aurora::NWScript::formatTag(object).c_str()); Common::printException(e, "WARNING: "); } }
int main(){ node<int> ni(5); node<const char*> ncs("const char*"); node<std::string> ns("std::string"); std::cout << ni << std::endl; std::cout << ncs << std::endl; std::cout << ns << std::endl; }
void Functions::executeScript(Aurora::NWScript::FunctionContext &ctx) { Common::UString script = ctx.getParams()[1].getString(); // Max resource name length is 16, and ExecuteScript should truncate accordingly script.truncate(16); if (!ResMan.hasResource(script, Aurora::kFileTypeNCS)) return; Aurora::NWScript::Object *object = getParamObject(ctx, 0); try { Aurora::NWScript::NCSFile ncs(script); ncs.run(object); } catch (Common::Exception &e) { e.add("Failed ExecuteScript(\"%s\", %s)", script.c_str(), formatTag(object).c_str()); Common::printException(e, "WARNING: "); } }
bool DLGFile::runScript(const Common::UString &script) const { if (script.empty()) return true; try { NWScript::NCSFile ncs(script); const NWScript::Variable &retVal = ncs.run(_owner); if (retVal.getType() == NWScript::kTypeInt) return retVal.getInt() != 0; if (retVal.getType() == NWScript::kTypeFloat) return retVal.getFloat() != 0.0; return true; } catch (Common::Exception &e) { e.add("Failed running dialog script \"%s\"", script.c_str()); Common::printException(e, "WARNING: "); return false; } return true; }
int ri_inter (void) { /* This is the shortest version of the interpreter, containing only those RASL operators which * are produced by the REFAL compiler. */ /* July, 27, 1985. D.T. */ /* Some macros have been expanded because the PC compiler can't handle too many macros. (its stack overflows.) * DT July 1 1986. */ /* Some other macros have been replaced by functions to reduce the size of object module. March 7 1987. DT. */ register short n; int error; char c, ins = 0; long mdig, bifnum; char *arg; /* short m;*/ error = 0; restart: while (error == 0) { ins = *p; # if MDEBUG if (dump_toggle) printf ("%lx: %d\n", p, ins); # endif switch (ins) { case ACT1: ASGN_CHARP (++p, arg); p += sizeof (char *); act1 (arg); curk ++; break; case BL: p++; bl; break; case BLR: p++; ri_blr (); break; case BR: p++; br; break; case CL: p++; cl; break; case SYM: c = (unsigned char) * ++p; p++; sym (c); break; case SYMR: c = (unsigned char) * ++p; p++; symr (c); break; case EMP: p++; emp; break; case EST: curk --; est; p = break0; break; case MULE: /* n = * ++p; ++p; mule ((int) n); */ ASGN_LONG (++p, mdig); p += sizeof (long); mule (mdig); break; case MULS: /*n = * ++p; muls (n); p++; break;*/ ASGN_LONG (++p, mdig); p += sizeof (long); muls (mdig); break; case PLEN: p++; plen; p++; break; case PLENS: p++; plens; break; case PLENP: p++; plenp; break; case PS: ++p; ps; break; case PSR: ++p; psr; break; case OEXP: n = (unsigned char) * ++p; ++p; oexp (n); break; case OEXPR: n = (unsigned char) * ++p; ++p; oexpr (n); break; case OVSYM: n = (unsigned char) * ++p; ovsym (n); ++p; break; case OVSYMR: n = (unsigned char) * ++p; ovsymr (n); p++; break; case TERM: p++; term; break; case TERMR: p++; termr; break; case RDY: n = (unsigned char) * ++p; ++p; rdy (n); break; case SETB: /* n = (unsigned char) * ++p; m = (unsigned char) * ++p; ++p; setb (n,m); break; */ { long l_n, l_m; ASGN_LONG (++p, l_n); p += sizeof (long); ASGN_LONG (p, l_m); p += sizeof (long); setb (l_n, l_m); } break; case LEN: p++; len; break; case LENS: c = (unsigned char) *++p; p++; lens (c); break; case LENP: ++p; lenp; break; case SYMS: n = (unsigned char) * ++p; p++; syms (n); break; case SYMSR: n = (unsigned char) * ++p; p++; symsr (n) break; case TEXT: n = (unsigned char) * ++p; p++; text (n); break; case NS: c = (unsigned char) * ++p; ++p; ns (c); break; case TPLE: /* n = * ++p; p++; tple (n); break; */ ASGN_LONG (++p, mdig); p += sizeof (long); tple (mdig); break; case TPLS: /* n = * ++p; p++; tpls (n); break; */ ASGN_LONG (++p, mdig); p += sizeof (long); tpls (mdig); break; case TRAN: ASGN_CHARP (++p, arg); p += sizeof (char *); tran (arg); break; case VSYM: p++; vsym; break; case VSYMR: ++p; vsymr; break; case OUTEST: curk --; out (2); est; p = break0; break; case ECOND: if (tel - te + nel + 100 >= size_table_element) { if (fp_debugInfo != NULL) ri_print_error_code(fp_debugInfo,13); ri_error (13); } ASGN_CHARP (++p, arg); b = st[sp].b1; b = st[sp].b1; act1 (arg); tel += (teoff = nel); est; p = break0; break; case POPVF: ++p; tel -= teoff; nel = teoff + 3; sp = stoff-1; teoff = st[sp].nel; stoff = (long) st[sp].b2; break; case PUSHVF: if (sp + 20 >= size_local_stack) { if (fp_debugInfo != NULL) ri_print_error_code(fp_debugInfo,14); ri_error (14); } ++p; b = tbel (2) -> prec; blr; pushst (b->prec,b,NULL,NULL); sp++; pushst (b,stoff,teoff, IMP_); b = b -> prec; stoff = sp + 1; break; case STLEN: ++p; sp = stoff; break; case CSYM: ASGN_CHARP (++p, arg); p += sizeof (char *); csym (arg); break; case CSYMR: ASGN_CHARP (++p, arg); p += sizeof (char *); csymr (arg); break; case NSYM: ASGN_LONG (++p, mdig); p += sizeof (long); nsym (mdig); break; case NSYMR: ASGN_LONG (++p, mdig); p += sizeof (long); nsymr (mdig); break; case NCS: ASGN_CHARP (++p, arg); p += sizeof (char *); ncs (arg); break; case NNS: ASGN_LONG (++p, mdig); p += sizeof (long); nns (mdig); break; /* builtin functions: R.N. - 20 Jul 85 */ case BUILT_IN: /* a call to a built in function no arguments. */ curk --; ASGN_LONG (p+1, bifnum); error = ri_bif (bifnum,NULL); p = break0; break; /* builtin functions with one argument: D.T. - July 27, 1985. */ case BUILT_IN1: /* a call to a function with one argument. */ /* Arguments are stored before function address. */ curk --; ASGN_CHARP(++p, arg); ASGN_LONG (p + (sizeof (char *)), bifnum); error = ri_bif (bifnum, arg); p = break0; break; default: ri_default (ins, &error); break; } } if (error != 0) { fprintf (stderr,"RASL instruction: %4d at address: %lx\n", *p, (unsigned long) p); if (fp_debugInfo != NULL) fprintf (fp_debugInfo,"RASL instruction: %4d at address: %lx\n", *p, (unsigned long) p); ri_error(4); } return 0; }