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;
}
