void DUPFFformal_deriv2(DUPFF fprime, const DUPFF f) /* fprime and f may be identical */ { int df, dans, j, p; p = CurrentFF.prime; df = DUPFFdeg(f); /* find degree of the answer */ for (dans=df; dans >= 1; dans--) if (f->coeffs[dans] != 0 && (dans%p != 0)) break; dans--; if (dans < 0) { fprime->deg = -1; return; } if (fprime->maxdeg < dans) { JERROR(JERROR_DEG_TOO_LOW); return; } fprime->deg = dans; for (j = 1; j <= dans+1; j++) fprime->coeffs[j-1] = FFmul(j%p, f->coeffs[j]); return; }
/* * call-seq: * call_function_property(name, arguments) * * Calls this JavaScript object's +name+ method, passing the given * arguments. * * Equivalent to: * proxy[name].native_call(proxy, *arguments) */ static VALUE call_function_property(int argc, VALUE* argv, VALUE self) { RubyLandProxy* proxy; Data_Get_Struct(self, RubyLandProxy, proxy); JSContext * context = johnson_get_current_context(proxy->runtime); if (argc < 1) rb_raise(rb_eArgError, "Function name required"); PREPARE_RUBY_JROOTS(context, 2); jsval proxy_value; JCHECK(get_jsval_for_proxy(proxy, &proxy_value)); JROOT(proxy_value); jsval function; VALUE name = argv[0]; CALL_RUBY_WRAPPER(rb_string_value_cstr, &name); JCHECK(JS_GetProperty(context, JSVAL_TO_OBJECT(proxy_value), StringValueCStr(name), &function)); JROOT(function); // should never be anything but a function if (!JS_ObjectIsFunction(context, function)) JERROR("Specified property \"%s\" isn't a function.", StringValueCStr(name)); REMOVE_JROOTS; return call_js_function_value(proxy->runtime, proxy_value, function, argc - 1, &(argv[1])); }
static bool js_value_is_symbol(JohnsonRuntime* runtime, jsval maybe_symbol) { jsval nsJohnson, cSymbol; JSContext * context = johnson_get_current_context(runtime); PREPARE_RUBY_JROOTS(context, 3); JROOT(maybe_symbol); JCHECK(JS_GetProperty(context, runtime->global, "Johnson", &nsJohnson)); if (!JSVAL_IS_OBJECT(nsJohnson)) JERROR("Unable to retrieve Johnson from JSLand"); JROOT(nsJohnson); JCHECK(JS_GetProperty(context, JSVAL_TO_OBJECT(nsJohnson), "Symbol", &cSymbol)); if (!JSVAL_IS_OBJECT(cSymbol)) JERROR("Unable to retrieve Johnson.Symbol from JSLand"); JROOT(cSymbol); JSBool is_a_symbol; JCHECK(JS_HasInstance(context, JSVAL_TO_OBJECT(cSymbol), maybe_symbol, &is_a_symbol)); JRETURN_RUBY(is_a_symbol != JS_FALSE); }
VALUE convert_to_ruby(JohnsonRuntime* runtime, jsval js) { if (JSVAL_NULL == js) return Qnil; JSContext * context = johnson_get_current_context(runtime); PREPARE_RUBY_JROOTS(context, 1); JROOT(js); switch (JS_TypeOfValue(context, js)) { case JSTYPE_VOID: JRETURN_RUBY(Qnil); case JSTYPE_FUNCTION: case JSTYPE_OBJECT: if (OBJECT_TO_JSVAL(runtime->global) == js) // global gets special treatment, since the Prelude might not be loaded JRETURN_RUBY(make_ruby_land_proxy(runtime, js, "GlobalProxy")); // this conditional requires the Prelude if (js_value_is_symbol(runtime, js)) JRETURN_RUBY(ID2SYM(rb_intern(JS_GetStringBytes(JS_ValueToString(context, js))))); if (js_value_is_proxy(runtime, js)) JRETURN_RUBY(unwrap_js_land_proxy(runtime, js)); if (js_value_is_regexp(runtime, js)) JRETURN_RUBY(convert_regexp_to_ruby(runtime, js)); JRETURN_RUBY(make_ruby_land_proxy(runtime, js, "RubyLandProxy")); case JSTYPE_BOOLEAN: JRETURN_RUBY(JSVAL_TRUE == js ? Qtrue : Qfalse); case JSTYPE_STRING: JRETURN_RUBY(convert_js_string_to_ruby(runtime, JSVAL_TO_STRING(js))); case JSTYPE_NUMBER: if (JSVAL_IS_INT(js)) JRETURN_RUBY(INT2FIX(JSVAL_TO_INT(js))); else JRETURN_RUBY(rb_float_new(*JSVAL_TO_DOUBLE(js))); default: JERROR("unknown js type in switch"); } JRETURN_RUBY(Qnil); }
JSBool convert_to_js(JohnsonRuntime* runtime, VALUE ruby, jsval* retval) { JSContext * context = johnson_get_current_context(runtime); PREPARE_JROOTS(context, 0); switch(TYPE(ruby)) { case T_NONE: JERROR("I don't know how to handle T_NONE."); JRETURN; case T_ICLASS: JERROR("I don't know how to handle T_ICLASS."); JRETURN; case T_MATCH: JERROR("I don't know how to handle T_MATCH."); JRETURN; case T_BLKTAG: JERROR("I don't know how to handle T_BLKTAG."); JRETURN; case T_NODE: JERROR("I don't know how to handle T_NODE | T_MASK."); JRETURN; case T_UNDEF: JERROR("I don't know how to handle T_UNDEF."); JRETURN; case T_VARMAP: JERROR("I don't know how to handle T_VARMAP."); JRETURN; case T_NIL: *retval = JSVAL_NULL; JRETURN; case T_TRUE: *retval = JSVAL_TRUE; JRETURN; case T_FALSE: *retval = JSVAL_FALSE; JRETURN; case T_STRING: { JSString* str = JS_NewStringCopyN(context, StringValuePtr(ruby), (size_t) StringValueLen(ruby)); JCHECK(str); *retval = STRING_TO_JSVAL(str); JRETURN; } case T_FIXNUM: { long val = NUM2LONG(ruby); if (val >= JSVAL_INT_MIN && val <= JSVAL_INT_MAX) { *retval = INT_TO_JSVAL((jsint)val); JRETURN; } } case T_FLOAT: case T_BIGNUM: JCHECK(convert_float_or_bignum_to_js(runtime, ruby, retval)); JRETURN; case T_SYMBOL: JCHECK(convert_symbol_to_js(runtime, ruby, retval)); JRETURN; case T_CLASS: case T_ARRAY: case T_HASH: case T_MODULE: case T_FILE: case T_STRUCT: case T_OBJECT: JCHECK(make_js_land_proxy(runtime, ruby, retval)); JRETURN; case T_REGEXP: JCHECK(convert_regexp_to_js(runtime, ruby, retval)); JRETURN; case T_DATA: // HEY! keep T_DATA last for fall-through if (ruby_value_is_proxy(ruby)) JCHECK(unwrap_ruby_land_proxy(runtime, ruby, retval)); else // If we can't identify the object, just wrap it JCHECK(make_js_land_proxy(runtime, ruby, retval)); JRETURN; default: JERROR("unknown ruby type in switch"); } *retval = JSVAL_NULL; JRETURN; }