public static T[] FastArrayCopy <T>(T[] array)
{
JsFunction function = Jsni.procedure(() => {});
function.prototype = array.As <JsObject>();
return(Jsni.@new(function).As <T[]>());
}
public static JsTypeFunction DefineTypeParameter(JsFunction assembly, string name, JsTypeFunction prototype)
{
var result = Define(assembly, null, name, false, Jsni.array(), prototype, Jsni.procedure(() => {}));
result.memberset(SpecialNames.IsTypeParameter, true);
result.memberset(SpecialNames.CreateType, Jsni.function(() =>
{
var type = Type.CreateTypeParameter(name, prototype);
result.Type = type;
type.thisType = result;
return(result);
}));
return(result);
}
public static JsFunction CreateConstructor(JsTypeFunction enclosingType, JsFunction implementation)
{
implementation.memberset(SpecialNames.TypeField, enclosingType);
implementation.memberset(SpecialNames.New, Jsni.function(() =>
{
/*
* if (!enclosingType.IsPrototypeInitialized)
* {
* enclosingType.IsPrototypeInitialized = true;
* enclosingType.prototype = Jsni.@new(enclosingType.PrototypeFactory.invoke());
* }
*/
return(Jsni.@new(enclosingType, implementation, Jsni.arguments()));
}));
return(implementation);
}
public static JsFunction CreateDelegate(JsObject thisExpression, JsFunction lambda, JsTypeFunction delegateType = null, string delegateKey = null)
{
delegateType = delegateType ?? Jsni.reference("System.Delegate").As <JsTypeFunction>();
JsFunction delegateFunc = null;
delegateFunc = Jsni.function(() =>
{
return(lambda.apply(delegateFunc.As <Delegate>().Target.As <JsObject>(), Jsni.arguments().As <JsArray>()));
});
delegateFunc.prototype = Jsni.@new(delegateType);
delegateFunc.memberset("get_Target", Jsni.function(() => thisExpression));
delegateFunc.memberset("GetType", Jsni.function(() => delegateType.GetTypeFromType.invoke()));
Jsni.memberset(delegateFunc, SpecialNames.TypeField, delegateType);
Jsni.memberset(delegateFunc, "Invoke", delegateFunc);
Jsni.memberset(delegateFunc, "DynamicInvoke", Jsni.function(args => delegateFunc.apply(delegateFunc, args.As <JsArray>())));
Jsni.memberset(delegateFunc, "GetHashCode", Jsni.function(() => lambda.toString().GetHashCode().As <JsObject>()));
Jsni.memberset(delegateFunc, "lambda", lambda);
Jsni.memberset(delegateFunc, "Equals", Jsni.function(x => x != null && lambda == x.member("lambda")));
return(delegateFunc);
}
public static JsFunction CreateDelegate(JsObject thisExpression, JsTypeFunction delegateType, JsFunction lambda, string delegateKey = null)
{
if (delegateKey != null)
{
if (thisExpression[delegateKey])
{
return(thisExpression[delegateKey].As <JsFunction>());
}
}
else
{
if (lambda.member("$delegate") != null)
{
return(lambda.member("$delegate").As <JsFunction>());
}
}
JsFunction delegateFunc = null;
delegateFunc = Jsni.function(() =>
{
return(lambda.apply(delegateFunc.As <Delegate>().Target.As <JsObject>(), Jsni.arguments().As <JsArray>()));
});
delegateFunc.prototype = Jsni.@new(delegateType);
Jsni.type <object>().TypeInitializer.invoke(delegateFunc, delegateFunc);
Jsni.type <Delegate>().TypeInitializer.invoke(delegateFunc, delegateFunc);
Jsni.type <MulticastDelegate>().TypeInitializer.invoke(delegateFunc, delegateFunc);
delegateType.TypeInitializer.invoke(delegateFunc, delegateFunc);
Jsni.invoke(Jsni.member(Jsni.member(Jsni.type <MulticastDelegate>().prototype, "$ctor"), "call"), delegateFunc, thisExpression, new[] { delegateFunc }.As <JsArray>());
Jsni.memberset(delegateFunc, SpecialNames.TypeField, delegateType);
if (delegateKey != null)
{
thisExpression[delegateKey] = delegateFunc;
}
else
{
lambda.memberset("$delegate", delegateFunc);
}
return(delegateFunc);
}
public extern void sort(JsFunction compareFunction);
public Delegate(object target)
{
this.target = target;
this.jsFunction = this.As<JsFunction>();
}
public extern void sort(JsFunction compareFunction);
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Reflection.MethodInfo"/> class.
/// </summary>
public MethodInfo(string name, JsFunction jsMethod, ParameterInfo[] parameters, JsTypeFunction returnType, MethodAttributes methodAttributes, Attribute[] attributes) : base(name, parameters, methodAttributes, attributes)
{
this.jsMethod = jsMethod;
this.returnType = returnType;
}
public static JsTypeFunction Define(JsFunction assembly, JsTypeFunction enclosingType, string name, bool isGenericType, JsArray typeParameters, JsObject prototype, JsFunction typeInitializer)
{
JsTypeFunction typeFunction = null;
var isTypeInitialized = false;
// Create constructor function, which is a superconstructor that takes in the actual
// constructor as the first argument, and the rest of the arguments are passed directly
// to that constructor. These subconstructors are not Javascript constructors -- they
// are not called via new, they exist for initialization only.
typeFunction = Jsni.function((constructor, args) =>
{
if (constructor != null || !(Jsni.instanceof(Jsni.@this(), typeFunction)))
{
if (!isGenericType || typeFunction.UnconstructedType != null)
{
typeFunction.member(SpecialNames.StaticInitializer).invoke();
}
}
if (constructor != null)
{
constructor.apply(Jsni.@this(), args.As <JsArray>());
}
if (!Jsni.instanceof(Jsni.@this(), typeFunction))
{
return(typeFunction);
}
else
{
return(Jsni.@this());
}
}).As <JsTypeFunction>();
typeFunction.GetAssembly = assembly;
assembly.member(SpecialNames.AssemblyTypesArray).member("push").invoke(typeFunction);
typeFunction.memberset("toString", Jsni.function(() => name.As <JsObject>()));
typeFunction.EnclosingType = enclosingType;
typeFunction.TypeName = name;
typeFunction.prototype = Jsni.@new(prototype);
typeFunction.IsPrototypeInitialized = false;
typeFunction.TypeInitializer = Jsni.procedure((_t, p) =>
{
var t = _t.As <JsTypeFunction>();
if (isGenericType)
{
var unconstructedType = t.UnconstructedType ?? t;
t.GenericTypeFunction = Jsni.function(() =>
{
return(Jsni.reference(SpecialNames.MakeGenericTypeConstructor).As <JsFunction>().call(unconstructedType, unconstructedType, Jsni.arguments()).As <JsFunction>().invoke());
});
}
t.GetTypeFromType = Jsni.function(() =>
{
return(Type._GetTypeFromTypeFunc(Jsni.@this().As <JsTypeFunction>()).As <JsObject>());
});
p.memberset(SpecialNames.TypeName, t.member(SpecialNames.TypeName));
p.___type = t;
t.BaseType = prototype.As <JsTypeFunction>();
typeInitializer.apply(Jsni.@this(), Jsni.arguments().As <JsArray>());
});
typeFunction.CallTypeInitializer = Jsni.procedure(() =>
{
typeFunction.TypeInitializer.apply(enclosingType, Jsni.array(typeFunction, typeFunction.prototype).concat(typeParameters));
});
return(typeFunction);
}
public static JsFunction DefineTypeFunction(JsTypeFunction type, JsFunction template)
{
return(template);
}
public static JsFunction DefineStaticConstructor(JsTypeFunction enclosingType, JsFunction implementation)
{
return(Jsni.procedure(() =>
{
if (enclosingType.IsStaticInitialized)
{
return;
}
enclosingType.IsStaticInitialized = true;
implementation.invoke();
}));
}
public static JsObject NullPropagation(JsObject @this, JsObject target, JsObject ifNull, JsFunction ifNotNull)
{
if (target == null)
{
return(ifNull);
}
else
{
return(ifNotNull.call(@this, target));
}
}
