public static object Default(object T) { if (T == JsContext.undefined) { return(null); } Type type = Typeof(T); JsType jsType = type.GetJsType(); if (jsType != null && jsType != null && (jsType.Kind == JsTypeKind.Struct || (jsType.baseTypeName != null && jsType.baseTypeName.indexOf("ValueType") != -1))) { switch (type.Name) { case "Boolean": return(false); case "Byte": case "Int16": case "Int32": case "Int64": case "Double": case "Decimal": return(null); default: return(Activator.CreateInstance(jsType.As <Type>())); } } //TODO: return(null); }
private static object NewWithInitializer(JsType type, JsObject json) { var obj = JsCompiler.NewByFunc(type.ctor); if (@typeof(json) == "array") { throw new Exception("not implemented"); } else { foreach (var p in json) { var setter = obj.As <JsObject>()["set_" + p]; if (@typeof(setter) == "function") { setter.As <JsFunction>().call(obj, json[p]); } else { obj.As <JsObject>()[p] = json[p]; } } } return(obj); }
//checkes if the [objType] is of a certain [type] static bool TypeIs(JsType objType, JsType type) { if (objType == type) { return(true); } if (type.Kind == JsTypeKind.Interface) { var testedInterfaces = new JsObject(); while (objType != null) { if (objType == type) { return(true); } if (_TestTypeInterfacesIs(objType, type, testedInterfaces)) { return(true); } objType = objType.baseType; } return(false); } if (type.Kind == JsTypeKind.Delegate && objType.fullname == "System.Delegate") { //for now, casting between any delegate type is permitted return(true); } if (objType.fullname == "System.Int32") { if (type.fullname == "System.Decimal") { return(true); } if (type.fullname == "System.Double") { return(true); } if (type.fullname == "System.Single") { return(true); } if (type.fullname == "System.Nullable$1") { return(true); } } var t = objType.baseType; while (t != null) { if (t == type) { return(true); } t = t.baseType; } return(false); }
public static Type _TypeOf(JsType jsType) { if (jsType == null) { throw new Exception("Cannot resovle type"); } if (jsType._ClrType == null) { jsType._ClrType = CreateClrType(jsType); } return(jsType._ClrType); }
public static string GetAssemblyQualifiedName(this JsType type) { if (type._AssemblyQualifiedName == null) { var name = type.fullname; if (type.assemblyName != null) { name += ", " + type.assemblyName; } type._AssemblyQualifiedName = name; } return(type._AssemblyQualifiedName); }
private static void ResolveBaseType(JsType type, JsType currentType) { var baseType = JsTypeHelper.GetType(type.baseTypeName); if (baseType == null) { baseType = JsTypeHelper.GetTypeIgnoreNamespace(type.baseTypeName, true); } if (!baseType.isCompiled) { CompileType(baseType); } currentType.baseType = baseType; baseType.derivedTypes.push(currentType); }
public static JsType GetTypeIgnoreNamespace(string name, bool throwIfNotFound) { JsType type = null; var cache = GetTypeIgnoreNamespaceCache;//arguments.callee.cache; if (cache != null) { type = cache[name].As <JsType>(); if (JsContext.@typeof(type) != "undefined") { if (throwIfNotFound && type == null) { throw new JsError("type " + name + " was not found with (with IgnoreNamespace).").As <Exception>(); } return(type); } } if (name.As <JsString>().search(".") > -1) { var tokens = name.As <JsString>().split(".").As <JsArray>(); name = tokens[tokens.length - 1].As <string>(); } type = JsCompiler.Types[name].As <JsType>(); var nameAfterNs = "." + name; if (type == null) { foreach (var p in JsCompiler.Types) { if (p == name || p.As <JsString>().endsWith(nameAfterNs)) { type = JsCompiler.Types[p].As <JsType>(); break; } } } if (throwIfNotFound && type == null) { throw new JsError("type " + name + " was not found with (with IgnoreNamespace).").As <Exception>(); } if (cache != null) { cache[name] = type ?? null; } return(type); }
private static void CompileEnum(JsType currentType) { if (currentType.Kind == JsTypeKind.Enum) { currentType.tryParse = _EnumTryParse; foreach (var p in currentType.staticDefinition) { if (@typeof(currentType.staticDefinition[p]) == "string") { var x = NewByFunc(currentType.ctor); x.As <JsObject>()["_Name"] = p; currentType.staticDefinition[p] = x; currentType.As <JsObject>()[p] = x; } } } }
static bool _TestTypeInterfacesIs(JsType testType, JsType iface, JsObject testedInterfaces) { if (testedInterfaces[iface.name].As <bool>()) { return(false); } for (var i = 0; i < testType.interfaces.length; i++) { var testIface = testType.interfaces[i].As <JsType>(); if (testIface == iface) { return(true); } testedInterfaces[testIface.name] = true; if (_TestTypeInterfacesIs(testIface, iface, testedInterfaces)) { return(true); } } return(false); }
private static void ResolveInterfaces(JsType type, JsType currentType) { if (type.interfaceNames == null) { return; } for (var i = 0; i < type.interfaceNames.length; i++) { var iName = type.interfaceNames[i].As <string>(); var iface = JsTypeHelper.GetType(iName); if (iface == null) { iface = JsTypeHelper.GetTypeIgnoreNamespace(iName, true); } if (!iface.isCompiled) { CompileType(iface); } currentType.interfaces.push(iface); } }
private static void Compile_Phase2_TmpType(JsType tmpType) { var p = tmpType.fullname; var type = CompileType(tmpType); if (type != null) { bool result = CopyMemberIfNotDefined(type, type.fullname, window); if (result) { _NewJsTypes.push(type); } } if (type.ns != null) { var ns = ResolveNamespace(type.ns); if (type != null) { ns[type.name] = type; } } }
private static Type CreateClrType(JsType jsType) { return(null); }
internal static JsDelegateFunction CreateClrDelegate(JsType type, JsArray <JsType> genericArgs, object target, JsFunction func) { return(JsTypeHelper.GetDelegate(target, func).As <JsDelegateFunction>()); //TODO: support delegate.getType() }
static JsFunction CreateBaseCtor(JsType type) { throw new NotImplementedException(); }
private static JsType CompileType(JsType type) { var currentType = Types[type.fullname].As <JsType>() ?? type; if (currentType.ctors == null) { currentType.ctors = new JsObject(); } if (!type.isCompiled) { var baseTypeResolved = false; if (currentType.baseType == null && currentType.baseTypeName != null) { ResolveBaseType(type, currentType); if (currentType.baseType != null) { baseTypeResolved = true; } } ResolveInterfaces(type, currentType); foreach (var p in type.definition) { if (p.As <JsString>().search("ctor") == 0) //isCtor { currentType.As <JsObject>()[p] = type.definition[p]; delete(type.definition[p]); if (@typeof(currentType.commonPrototype) == "undefined") { currentType.commonPrototype = currentType.As <JsObject>()[p].As <JsFunction>().prototype.As <JsCompilerPrototype>(); } else { currentType.As <JsObject>()[p].As <JsFunction>().prototype = currentType.commonPrototype; } currentType.ctors[p] = currentType.As <JsObject>()[p]; } if (p == "cctor") { currentType.cctor = p.As <JsFunction>(); } } if (currentType.ctor == null) { if (currentType.ns == null || currentType.ns == "") { var jsCtor = window[currentType.name].As <JsFunction>(); currentType.ctor = jsCtor; } if (currentType.ctor == null && currentType.ctors != null) { //create default ctor anyway for generic argument passing, etc... //var createCtor = true; //foreach (var p in currentType.ctors) //{ // createCtor = false; // break; //} //if (createCtor) //{ if (currentType.baseType != null) { currentType.ctor = CreateBaseCtor(currentType); } else { currentType.ctor = CreateEmptyCtor(); } //} } if (currentType.ctor != null) { currentType.ctors["ctor"] = currentType.ctor; if (@typeof(currentType.commonPrototype) == "undefined") { currentType.commonPrototype = currentType.ctor.prototype.As <JsCompilerPrototype>(); } else { currentType.ctor.prototype = currentType.commonPrototype; } } } foreach (var p in currentType.ctors) { var ctor = currentType.ctors[p].As <JsCompilerFunction>(); if (ctor._type == null) { ctor._type = currentType; } } if (baseTypeResolved) { _CopyObject(currentType.baseType.commonPrototype, currentType.commonPrototype); } foreach (var p in type.definition) { var member = type.definition[p]; currentType.commonPrototype[p] = member; if (JsContext.@typeof(member) == "function") { member.As <JsCompilerFunction>()._name = p; member.As <JsCompilerFunction>()._type = currentType; } } if (type.definition.As <JsCompilerPrototype>().toString != JsCompilerObject.prototype.toString) { currentType.commonPrototype.toString = type.definition.As <JsCompilerPrototype>().toString; //currentType.commonPrototype.toString.name = "toString"; //It's always readonly! (and forbidden in strict mode) currentType.commonPrototype.toString._type = currentType; } foreach (var p in type.staticDefinition) { var member = type.staticDefinition[p]; //TODO: if (@typeof(currentType.As<JsObject>()[p]) != "undefined") //TODO: throw new JsError("Reserved static member name " + p).As<Exception>(); currentType.As <JsObject>()[p] = member; if (JsContext.@typeof(member) == "function") { member.As <JsCompilerFunction>()._name = p; member.As <JsCompilerFunction>()._type = currentType; } } type.isCompiled = true; } CompileEnum(currentType); if (currentType != type && type.customAttributes != null) { if (currentType.customAttributes != null) { for (var i = 0; i < type.customAttributes.length; i++) { currentType.customAttributes.push(type.customAttributes[i]); } } else { currentType.customAttributes = type.customAttributes; } } return(currentType); }
private static object TryImplicitConvert(object obj, JsType type) { throw new NotImplementedException(); }
public static string GetName(this JsType type) { return(type.name); }