// Keep this separate from the other TypeClassification computations as it locks in the core assembly name. protected sealed override bool IsPrimitiveImpl() { CoreTypes coreTypes = Loader.GetAllFoundCoreTypes(); foreach (CoreType primitiveType in s_primitiveTypes) { if (this == coreTypes[primitiveType]) { return(true); } } return(false); }
internal static BindingRestrictions GetOptionalVersionAndLanguageCheckForType(DynamicMetaObjectBinder binder, Type targetType, int expectedVersionNumber) { BindingRestrictions empty = BindingRestrictions.Empty; if (CoreTypes.Contains(targetType)) { return(empty); } if (expectedVersionNumber != -1) { empty = empty.Merge(GetVersionCheck(binder, expectedVersionNumber)); } return(empty.Merge(GetLanguageModeCheckIfHasEverUsedConstrainedLanguage())); }
private void dragDrop(object sender, DragEventArgs args) { LibraryTreeNode node = (LibraryTreeNode)args.Data.GetData(typeof(LibraryTreeNode)); FileDescriptor fDesc = FileManager.Instance.lookUp(node.FilePath); TypeDescriptor tDesc = null; if (fDesc is TypeDescriptor) { tDesc = (TypeDescriptor)fDesc; } else if (fDesc is ArtDescriptor) { tDesc = CoreTypes.getType <SimpleObject>(); } if (tDesc != null) { InstanceDescriptor inst = new InstanceDescriptor(Descriptor.Level); inst.Sprite = new Sprite(WhiskeyControl.Renderer, WhiskeyControl.Resources, inst.Sprite); inst.Light.Visible = false; inst.initialize(tDesc); Point p = PointToClient(new Point(args.X, args.Y - ToolStrip.Height)); inst.Position = new Vector(p.X, p.Y);// -inst.Bounds.Size / 2; inst.Position = WhiskeyControl.ActiveCamera.getGameCoordinate(inst.Position); inst.X = inst.Position.X; inst.Y = inst.Position.Y; SelectionManager.Instance.SelectedInstance = inst; Dirty = true; if (fDesc is ArtDescriptor) { ArtDescriptor aDesc = (ArtDescriptor)fDesc; inst.Sprite.ImagePath = aDesc.Name; inst.Sprite.Scale = Vector.One; } Descriptor.Level.updateAll(); } }
internal static bool IsAllowedInConstrainedLanguage(object targetValue, string name, bool isStatic) { if (!string.Equals(name, "ToString", StringComparison.OrdinalIgnoreCase)) { Type inputType = targetValue as Type; if (!isStatic || (inputType == null)) { inputType = targetValue.GetType(); } if (!CoreTypes.Contains(inputType)) { return(false); } } return(true); }
public SystemReferences(global::Fody.TypeSystem typeSystem, ModuleDefinition moduleDefinition, IAssemblyResolver assemblyResolver) { var coreTypes = new CoreTypes(moduleDefinition, assemblyResolver); IEquatable = coreTypes.GetType(typeof(IEquatable <>)); StringEquals = coreTypes.GetMethod <string, string, string, StringComparison>(nameof(string.Equals)); ObjectEquals = coreTypes.GetMethod <object, object, object>(nameof(object.Equals)); ObjectGetHashCode = coreTypes.GetMethod <object>(nameof(object.GetHashCode)); StringComparer = coreTypes.GetType <StringComparer>(); StringComparerGetHashCode = coreTypes.GetMethod <StringComparer, string>(nameof(StringComparer.GetHashCode)); StringComparerEquals = coreTypes.GetMethod <StringComparer, string, string>(nameof(StringComparer.Equals)); GeneratedCodeAttributeCtor = coreTypes.GetMethod <GeneratedCodeAttribute, string, string>(".ctor"); DebuggerNonUserCodeAttributeCtor = coreTypes.GetMethod <DebuggerNonUserCodeAttribute>(".ctor"); TypeSystem = typeSystem; }
/// <summary> /// Create a new MetadataLoadContext object. /// </summary> /// <param name="coreAssemblyName"> /// The name of the assembly that contains the core types such as System.Object. Typically, this would be "mscorlib". /// </param> public MetadataLoadContext(MetadataAssemblyResolver resolver, string coreAssemblyName = null) { if (resolver == null) { throw new ArgumentNullException(nameof(resolver)); } this.resolver = resolver; if (coreAssemblyName != null) { // Validate now that the value is a parsable assembly name. new AssemblyName(coreAssemblyName); } // Resolve the core assembly now _coreTypes = new CoreTypes(this, coreAssemblyName); }
public static IEnumerable <MailDataStructureViewModel> GenerateStructure(object value) { if (value is IDictionary <string, object> duc) { foreach (var prop in duc) { yield return(GenerateSubStructure(prop.Key, prop.Value)); } } else if (value is IEnumerable list && !(value is string)) { var first = list.ToDynamicArray().FirstOrDefault() as object; if (!CoreTypes.ContainsKey(first?.GetType() ?? typeof(object))) { foreach (var item in GenerateStructure(first)) { yield return(item); } } }
private PhpCompilation( string assemblyName, PhpCompilationOptions options, ImmutableArray <MetadataReference> references, //ReferenceManager referenceManager, //SyntaxAndDeclarationManager syntaxAndDeclarations AsyncQueue <CompilationEvent> eventQueue = null ) : base(assemblyName, references, SyntaxTreeCommonFeatures(ImmutableArray <SyntaxTree> .Empty), false, eventQueue) { _wellKnownMemberSignatureComparer = new WellKnownMembersSignatureComparer(this); _options = options; _referenceManager = new ReferenceManager(options.SdkDirectory); _tables = new SourceDeclarations(); _coreTypes = new CoreTypes(this); _coreMethods = new CoreMethods(_coreTypes); _anonymousTypeManager = new AnonymousTypeManager(this); }
private PhpCompilation( string assemblyName, PhpCompilationOptions options, ImmutableArray <MetadataReference> references, bool isSubmission, ReferenceManager referenceManager = null, bool reuseReferenceManager = false, //SyntaxAndDeclarationManager syntaxAndDeclarations AsyncQueue <CompilationEvent> eventQueue = null ) : base(assemblyName, references, SyntaxTreeCommonFeatures(ImmutableArray <SyntaxTree> .Empty), isSubmission, eventQueue) { _wellKnownMemberSignatureComparer = new WellKnownMembersSignatureComparer(this); _options = options; _tables = new SourceSymbolCollection(this); _coreTypes = new CoreTypes(this); _coreMethods = new CoreMethods(_coreTypes); _anonymousTypeManager = new AnonymousTypeManager(this); _referenceManager = (reuseReferenceManager && referenceManager != null) ? referenceManager : new ReferenceManager(MakeSourceAssemblySimpleName(), options.AssemblyIdentityComparer, referenceManager?.ObservedMetadata, options.SdkDirectory); }
private static DirectiveAssignment ExtractDirectives(AttributeAssignment assignment) { var xamlDirective = CoreTypes.GetDirective(assignment.Locator.PropertyName); return(new DirectiveAssignment(xamlDirective, assignment.Value)); }
public PhpAliasHolder(CoreTypes ct) { _value = null; EnsureObject = ct.PhpAlias.Method("EnsureObject"); EnsureArray = ct.PhpAlias.Method("EnsureArray"); }
public PhpNumberHolder(CoreTypes ct) { ToBoolean = ct.PhpNumber.Method("ToBoolean"); ToLong = ct.PhpNumber.Method("ToLong"); ToDouble = ct.PhpNumber.Method("ToDouble"); ToString_Context = ct.PhpNumber.Method("ToString", ct.Context); ToClass = ct.PhpNumber.Method("ToClass"); CompareTo_number = ct.PhpNumber.Method("CompareTo", ct.PhpNumber); CompareTo_long = ct.PhpNumber.Method("CompareTo", ct.Long); CompareTo_double = ct.PhpNumber.Method("CompareTo", ct.Double); Create_Long = ct.PhpNumber.Method("Create", ct.Long); Create_Double = ct.PhpNumber.Method("Create", ct.Double); Default = ct.PhpNumber.Field("Default"); get_Long = ct.PhpNumber.Method("get_Long"); // TODO: special name, property get_Double = ct.PhpNumber.Method("get_Double"); // TODO: special name, property Eq_number_PhpValue = ct.PhpNumber.Operator(WellKnownMemberNames.EqualityOperatorName, ct.PhpNumber, ct.PhpValue); Ineq_number_PhpValue = ct.PhpNumber.Operator(WellKnownMemberNames.InequalityOperatorName, ct.PhpNumber, ct.PhpValue); Eq_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.EqualityOperatorName, ct.PhpNumber, ct.PhpNumber); Ineq_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.InequalityOperatorName, ct.PhpNumber, ct.PhpNumber); Eq_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.EqualityOperatorName, ct.PhpNumber, ct.Long); Ineq_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.InequalityOperatorName, ct.PhpNumber, ct.Long); Eq_number_double = ct.PhpNumber.Operator(WellKnownMemberNames.EqualityOperatorName, ct.PhpNumber, ct.Double); Ineq_number_double = ct.PhpNumber.Operator(WellKnownMemberNames.InequalityOperatorName, ct.PhpNumber, ct.Double); Add_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.AdditionOperatorName, ct.PhpNumber, ct.PhpNumber); Add_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.AdditionOperatorName, ct.PhpNumber, ct.Long); Add_long_number = ct.PhpNumber.Operator(WellKnownMemberNames.AdditionOperatorName, ct.Long, ct.PhpNumber); Add_double_number = ct.PhpNumber.Method("Add", ct.Double, ct.PhpNumber); Add_number_double = ct.PhpNumber.Method("Add", ct.PhpNumber, ct.Double); Add_long_long = ct.PhpNumber.Method("Add", ct.Long, ct.Long); Add_long_double = ct.PhpNumber.Method("Add", ct.Long, ct.Double); Add_value_long = ct.PhpNumber.Method("Add", ct.PhpValue, ct.Long); Add_value_double = ct.PhpNumber.Method("Add", ct.PhpValue, ct.Double); Add_value_string = ct.PhpNumber.Method("Add", ct.PhpValue, ct.String); Add_value_number = ct.PhpNumber.Method("Add", ct.PhpValue, ct.PhpNumber); Add_long_value = ct.PhpNumber.Method("Add", ct.Long, ct.PhpValue); Add_double_value = ct.PhpNumber.Method("Add", ct.Double, ct.PhpValue); Add_number_value = ct.PhpNumber.Method("Add", ct.PhpNumber, ct.PhpValue); Add_value_value = ct.PhpNumber.Method("Add", ct.PhpValue, ct.PhpValue); Subtract_long_long = ct.PhpNumber.Method("Sub", ct.Long, ct.Long); Subtract_number_double = ct.PhpNumber.Method("Sub", ct.PhpNumber, ct.Double); Subtract_long_double = ct.PhpNumber.Method("Sub", ct.Long, ct.Double); Subtract_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.SubtractionOperatorName, ct.PhpNumber, ct.PhpNumber); Subtract_long_number = ct.PhpNumber.Operator(WellKnownMemberNames.SubtractionOperatorName, ct.Long, ct.PhpNumber); Subtract_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.SubtractionOperatorName, ct.PhpNumber, ct.Long); Subtract_value_value = ct.PhpNumber.Method("Sub", ct.PhpValue, ct.PhpValue); Subtract_value_long = ct.PhpNumber.Method("Sub", ct.PhpValue, ct.Long); Subtract_value_double = ct.PhpNumber.Method("Sub", ct.PhpValue, ct.Double); Subtract_value_number = ct.PhpNumber.Method("Sub", ct.PhpValue, ct.PhpNumber); Subtract_long_value = ct.PhpNumber.Method("Sub", ct.Long, ct.PhpValue); Negation = ct.PhpNumber.Operator(WellKnownMemberNames.UnaryNegationOperatorName, ct.PhpNumber); Negation_long = ct.PhpNumber.Method("Minus", ct.Long); Division_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.DivisionOperatorName, ct.PhpNumber, ct.PhpNumber); Division_long_number = ct.PhpNumber.Operator(WellKnownMemberNames.DivisionOperatorName, ct.Long, ct.PhpNumber); Mul_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.PhpNumber, ct.PhpNumber); Mul_number_double = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.PhpNumber, ct.Double); Mul_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.PhpNumber, ct.Long); Mul_long_number = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.Long, ct.PhpNumber); Mul_number_value = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.PhpNumber, ct.PhpValue); Mul_value_number = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.PhpNumber, ct.PhpValue); Mul_long_long = ct.PhpNumber.Method("Multiply", ct.Long, ct.Long); Mul_long_double = ct.PhpNumber.Method("Multiply", ct.Long, ct.Double); Mul_double_value = ct.PhpNumber.Method("Multiply", ct.Double, ct.PhpValue); Mul_long_value = ct.PhpNumber.Method("Multiply", ct.Long, ct.PhpValue); Mul_value_value = ct.PhpNumber.Method("Multiply", ct.PhpValue, ct.PhpValue); Mul_value_long = ct.PhpNumber.Method("Multiply", ct.PhpValue, ct.Long); Mul_value_double = ct.PhpNumber.Method("Multiply", ct.PhpValue, ct.Double); Pow_value_value = ct.PhpNumber.Method("Pow", ct.PhpValue, ct.PhpValue); Pow_number_number = ct.PhpNumber.Method("Pow", ct.PhpNumber, ct.PhpNumber); Pow_number_double = ct.PhpNumber.Method("Pow", ct.PhpNumber, ct.Double); Pow_number_value = ct.PhpNumber.Method("Pow", ct.PhpNumber, ct.PhpValue); Pow_double_double = ct.PhpNumber.Method("Pow", ct.Double, ct.Double); Pow_double_value = ct.PhpNumber.Method("Pow", ct.Double, ct.PhpValue); Pow_long_long = ct.PhpNumber.Method("Pow", ct.Long, ct.Long); Pow_long_double = ct.PhpNumber.Method("Pow", ct.Long, ct.Double); Pow_long_number = ct.PhpNumber.Method("Pow", ct.Long, ct.PhpNumber); Pow_long_value = ct.PhpNumber.Method("Pow", ct.Long, ct.PhpValue); gt_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.GreaterThanOperatorName, ct.PhpNumber, ct.PhpNumber); gt_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.GreaterThanOperatorName, ct.PhpNumber, ct.Long); gt_number_double = ct.PhpNumber.Operator(WellKnownMemberNames.GreaterThanOperatorName, ct.PhpNumber, ct.Double); lt_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.LessThanOperatorName, ct.PhpNumber, ct.PhpNumber); lt_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.LessThanOperatorName, ct.PhpNumber, ct.Long); lt_number_double = ct.PhpNumber.Operator(WellKnownMemberNames.LessThanOperatorName, ct.PhpNumber, ct.Double); }
public virtual string Format(decimal v) { return CoreTypes.CastToString(v); }
public virtual string Format(ulong v) { return CoreTypes.CastToString(v); }
public ConstructorsHolder(CoreTypes ct) { PhpAlias_PhpValue_int = ct.PhpAlias.Ctor(ct.PhpValue, ct.Int32); PhpString = ct.PhpString.Ctor(); PhpString_string = ct.PhpString.Ctor(ct.String); PhpString_string_string = ct.PhpString.Ctor(ct.String, ct.String); PhpArray = ct.PhpArray.Ctor(); PhpArray_int = ct.PhpArray.Ctor(ct.Int32); IntStringKey_int = ct.IntStringKey.Ctor(ct.Int32); IntStringKey_string = ct.IntStringKey.Ctor(ct.String); ScriptAttribute_string = ct.ScriptAttribute.Ctor(ct.String); ScriptDiedException = ct.ScriptDiedException.Ctor(); ScriptDiedException_Long = ct.ScriptDiedException.Ctor(ct.Long); ScriptDiedException_PhpValue = ct.ScriptDiedException.Ctor(ct.PhpValue); }
public PhpStringHolder(CoreTypes ct) { ToBoolean = ct.PhpString.Method("ToBoolean"); ToLong = ct.PhpString.Method("ToLong"); ToDouble = ct.PhpString.Method("ToDouble"); ToString_Context = ct.PhpString.Method("ToString", ct.Context); Append_String = ct.PhpString.Method("Append", ct.String); Append_PhpString = ct.PhpString.Method("Append", ct.PhpString); }
/// <summary> /// Returns a lazily created and cached array containing the resolved CoreTypes, indexed by the CoreType enum cast to an int. /// If the core assembly was not specified, not locatable or if one or more core types aren't present in the core assembly, /// the corresponding elements will be null. /// </summary> internal CoreTypes GetAllFoundCoreTypes() => _lazyCoreTypes ?? (_lazyCoreTypes = new CoreTypes(this));
public IPhpArrayHolder(CoreTypes ct) { var arr = ct.IPhpArray; RemoveKey_IntStringKey = arr.Method("RemoveKey", ct.IntStringKey); GetItemValue_IntStringKey = arr.Method("GetItemValue", ct.IntStringKey); SetItemValue_IntStringKey_PhpValue = arr.Method("SetItemValue", ct.IntStringKey, ct.PhpValue); SetItemAlias_IntStringKey_PhpAlias = arr.Method("SetItemAlias", ct.IntStringKey, ct.PhpAlias); AddValue_PhpValue = arr.Method("AddValue", ct.PhpValue); EnsureItemObject_IntStringKey = arr.Method("EnsureItemObject", ct.IntStringKey); EnsureItemArray_IntStringKey = arr.Method("EnsureItemArray", ct.IntStringKey); EnsureItemAlias_IntStringKey = arr.Method("EnsureItemAlias", ct.IntStringKey); get_Count = arr.Method("get_Count"); }
private bool BlockMethodInLanguageMode(object inputObject) { if (base.Context.LanguageMode.Equals(PSLanguageMode.RestrictedLanguage)) { PSInvalidOperationException exception = new PSInvalidOperationException(InternalCommandStrings.NoMethodInvocationInRestrictedLanguageMode); base.WriteError(new ErrorRecord(exception, "NoMethodInvocationInRestrictedLanguageMode", ErrorCategory.InvalidOperation, null)); return(true); } if (base.Context.LanguageMode.Equals(PSLanguageMode.ConstrainedLanguage) && !CoreTypes.Contains(PSObject.Base(inputObject).GetType())) { PSInvalidOperationException exception2 = new PSInvalidOperationException(ParserStrings.InvokeMethodConstrainedLanguage); base.WriteError(new ErrorRecord(exception2, "MethodInvocationNotSupportedInConstrainedLanguage", ErrorCategory.InvalidOperation, null)); return(true); } return(false); }
public ReflectionHolder(CoreTypes ct) { CreateUserRoutine_string_RuntimeMethodHandle = ct.RoutineInfo.Method("CreateUserRoutine", ct.String, ct.RuntimeMethodHandle); }
public DynamicHolder(CoreTypes ct) { CallBinderFactory_Function = ct.CallBinderFactory.Method("Function", ct.String, ct.String, ct.RuntimeTypeHandle, ct.Int32); CallBinderFactory_InstanceFunction = ct.CallBinderFactory.Method("InstanceFunction", ct.String, ct.RuntimeTypeHandle, ct.RuntimeTypeHandle, ct.Int32); CallBinderFactory_StaticFunction = ct.CallBinderFactory.Method("StaticFunction", ct.RuntimeTypeHandle, ct.String, ct.RuntimeTypeHandle, ct.RuntimeTypeHandle, ct.Int32); GetFieldBinder_ctor = ct.GetFieldBinder.Ctor(ct.String, ct.RuntimeTypeHandle, ct.RuntimeTypeHandle, ct.AccessFlags); SetFieldBinder_ctor = ct.SetFieldBinder.Ctor(ct.String, ct.RuntimeTypeHandle, ct.AccessFlags); GetPhpTypeInfo_T = ct.PhpTypeInfoExtension.Method("GetPhpTypeInfo"); }
public ContextHolder(CoreTypes ct) { AddScriptReference_TScript = ct.Context.Method("AddScriptReference"); Dispose = ct.Context.Method("Dispose"); DeclareFunction_RoutineInfo = ct.Context.Method("DeclareFunction", ct.RoutineInfo); DeclareType_T = ct.Context.Method("DeclareType"); DisableErrorReporting = ct.Context.Method("DisableErrorReporting"); EnableErrorReporting = ct.Context.Method("EnableErrorReporting"); CheckIncludeOnce_TScript = ct.Context.Method("CheckIncludeOnce"); OnInclude_TScript = ct.Context.Method("OnInclude"); Include_string_string_PhpArray_object_bool_bool = ct.Context.Method("Include", ct.String, ct.String, ct.PhpArray, ct.Object, ct.Boolean, ct.Boolean); ScriptPath_TScript = ct.Context.Method("ScriptPath"); GetConstant_string_int32 = ct.Context.Method("GetConstant", ct.String, ct.Int32); GetStatic_T = ct.Context.Method("GetStatic"); GetDeclaredType_string = ct.Context.Method("GetDeclaredType", ct.String); // properties Globals = ct.Context.Property("Globals"); Server = ct.Context.Property("Server"); Request = ct.Context.Property("Request"); Get = ct.Context.Property("Get"); Post = ct.Context.Property("Post"); Cookie = ct.Context.Property("Cookie"); Env = ct.Context.Property("Env"); Files = ct.Context.Property("Files"); Session = ct.Context.Property("Session"); }
protected override void BeginProcessing() { Type result = null; PSArgumentException exception = null; if (string.Compare(base.ParameterSetName, "Net", StringComparison.Ordinal) == 0) { object o = null; if (!LanguagePrimitives.TryConvertTo <Type>(this.typeName, out result)) { exception = PSTraceSource.NewArgumentException("TypeName", "NewObjectStrings", "TypeNotFound", new object[] { this.typeName }); base.ThrowTerminatingError(new ErrorRecord(exception, "TypeNotFound", ErrorCategory.InvalidType, null)); } if ((base.Context.LanguageMode == PSLanguageMode.ConstrainedLanguage) && !CoreTypes.Contains(result)) { base.ThrowTerminatingError(new ErrorRecord(new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null)); } if (WinRTHelper.IsWinRTType(result) && (typeof(Attribute).IsAssignableFrom(result) || typeof(Delegate).IsAssignableFrom(result))) { base.ThrowTerminatingError(new ErrorRecord(new InvalidOperationException(NewObjectStrings.CannotInstantiateWinRTType), "CannotInstantiateWinRTType", ErrorCategory.InvalidOperation, null)); } if ((this.arguments == null) || (this.arguments.Length == 0)) { ConstructorInfo constructor = result.GetConstructor(Type.EmptyTypes); if ((constructor != null) && constructor.IsPublic) { o = this.CallConstructor(result, new ConstructorInfo[] { constructor }, new object[0]); if ((o != null) && (this.property != null)) { o = LanguagePrimitives.SetObjectProperties(o, this.Property, result, new LanguagePrimitives.MemberNotFoundError(this.CreateMemberNotFoundError), new LanguagePrimitives.MemberSetValueError(this.CreateMemberSetValueError), true); } base.WriteObject(o); return; } if (result.IsValueType) { try { o = Activator.CreateInstance(result, false); if ((o != null) && (this.property != null)) { o = LanguagePrimitives.SetObjectProperties(o, this.Property, result, new LanguagePrimitives.MemberNotFoundError(this.CreateMemberNotFoundError), new LanguagePrimitives.MemberSetValueError(this.CreateMemberSetValueError), true); } } catch (TargetInvocationException exception2) { base.ThrowTerminatingError(new ErrorRecord((exception2.InnerException == null) ? exception2 : exception2.InnerException, "ConstructorCalledThrowException", ErrorCategory.InvalidOperation, null)); } base.WriteObject(o); return; } } else { ConstructorInfo[] constructors = result.GetConstructors(); if (constructors.Length != 0) { o = this.CallConstructor(result, constructors, this.arguments); if ((o != null) && (this.property != null)) { o = LanguagePrimitives.SetObjectProperties(o, this.Property, result, new LanguagePrimitives.MemberNotFoundError(this.CreateMemberNotFoundError), new LanguagePrimitives.MemberSetValueError(this.CreateMemberSetValueError), true); } base.WriteObject(o); return; } } exception = PSTraceSource.NewArgumentException("TypeName", "NewObjectStrings", "CannotFindAppropriateCtor", new object[] { this.typeName }); base.ThrowTerminatingError(new ErrorRecord(exception, "CannotFindAppropriateCtor", ErrorCategory.ObjectNotFound, null)); } else { NewObjectNativeMethods.CLSIDFromProgID(this.comObject, out this.comObjectClsId); if (base.Context.LanguageMode == PSLanguageMode.ConstrainedLanguage) { bool flag2 = false; if ((SystemPolicy.GetSystemLockdownPolicy() == SystemEnforcementMode.Enforce) && SystemPolicy.IsClassInApprovedList(this.comObjectClsId)) { flag2 = true; } if (!flag2) { base.ThrowTerminatingError(new ErrorRecord(new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateComTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null)); return; } } PSSQMAPI.IncrementDataPoint((int)0x2099); object targetObject = this.CreateComObject(); string fullName = targetObject.GetType().FullName; if (!fullName.Equals("System.__ComObject")) { exception = PSTraceSource.NewArgumentException("TypeName", "NewObjectStrings", "ComInteropLoaded", new object[] { fullName }); base.WriteVerbose(exception.Message); if (this.Strict != 0) { base.WriteError(new ErrorRecord(exception, "ComInteropLoaded", ErrorCategory.InvalidArgument, targetObject)); } } if ((targetObject != null) && (this.property != null)) { targetObject = LanguagePrimitives.SetObjectProperties(targetObject, this.Property, result, new LanguagePrimitives.MemberNotFoundError(this.CreateMemberNotFoundError), new LanguagePrimitives.MemberSetValueError(this.CreateMemberSetValueError), true); } base.WriteObject(targetObject); } }
public PhpValueHolder(CoreTypes ct) { ToBoolean = ct.PhpValue.Method("ToBoolean"); ToLong = ct.PhpValue.Method("ToLong"); ToDouble = ct.PhpValue.Method("ToDouble"); ToString_Context = ct.PhpValue.Method("ToString", ct.Context); ToClass = ct.PhpValue.Method("ToClass"); EnsureObject = ct.PhpValue.Method("EnsureObject"); EnsureArray = ct.PhpValue.Method("EnsureArray"); EnsureAlias = ct.PhpValue.Method("EnsureAlias"); Eq_PhpValue_PhpValue = ct.PhpValue.Operator(WellKnownMemberNames.EqualityOperatorName, ct.PhpValue, ct.PhpValue); DeepCopy = ct.PhpValue.Method("DeepCopy"); ToArray = ct.PhpValue.Method("ToArray"); AsObject = ct.PhpValue.Method("AsObject"); get_Long = ct.PhpValue.Method("get_Long"); // TODO: special name, property get_Double = ct.PhpValue.Method("get_Double"); // TODO: special name, property get_Boolean = ct.PhpValue.Method("get_Boolean"); // TODO: special name, property get_String = ct.PhpValue.Method("get_String"); // TODO: special name, property get_Object = ct.PhpValue.Method("get_Object"); // TODO: special name, property get_Array = ct.PhpValue.Method("get_Array"); // TODO: special name, property Create_Boolean = ct.PhpValue.Method("Create", ct.Boolean); Create_Long = ct.PhpValue.Method("Create", ct.Long); Create_Double = ct.PhpValue.Method("Create", ct.Double); Create_String = ct.PhpValue.Method("Create", ct.String); Create_PhpString = ct.PhpValue.Method("Create", ct.PhpString); Create_PhpNumber = ct.PhpValue.Method("Create", ct.PhpNumber); Create_PhpArray = ct.PhpValue.Method("Create", ct.PhpArray); Create_PhpAlias = ct.PhpValue.Method("Create", ct.PhpAlias); Create_IntStringKey = ct.PhpValue.Method("Create", ct.IntStringKey); FromClr_Object = ct.PhpValue.Method("FromClr", ct.Object); FromClass_Object = ct.PhpValue.Method("FromClass", ct.Object); Void = ct.PhpValue.Field("Void"); Null = ct.PhpValue.Field("Null"); }
public static bool TryFindRawDefaultValueFromCustomAttributes(this CustomAttributeHandleCollection handles, EcmaModule module, out object rawDefaultValue) { rawDefaultValue = default; MetadataReader reader = module.Reader; foreach (CustomAttributeHandle handle in handles) { CustomAttribute ca = handle.GetCustomAttribute(reader); EntityHandle declaringTypeHandle = ca.TryGetDeclaringTypeHandle(reader); if (declaringTypeHandle.IsNil) { continue; } if (declaringTypeHandle.TypeMatchesNameAndNamespace(Utf8Constants.SystemRuntimeCompilerServices, Utf8Constants.DateTimeConstantAttribute, reader)) { CustomAttributeData cad = handle.ToCustomAttributeData(module); IList <CustomAttributeTypedArgument> cats = cad.ConstructorArguments; if (cats.Count != 1) { return(false); } CoreTypes ct = module.Loader.GetAllFoundCoreTypes(); if (cats[0].ArgumentType != ct[CoreType.Int64]) { return(false); } long ticks = (long)(cats[0].Value); rawDefaultValue = new DateTimeConstantAttribute(ticks).Value; return(true); } if (declaringTypeHandle.TypeMatchesNameAndNamespace(Utf8Constants.SystemRuntimeCompilerServices, Utf8Constants.DecimalConstantAttribute, reader)) { CustomAttributeData cad = handle.ToCustomAttributeData(module); IList <CustomAttributeTypedArgument> cats = cad.ConstructorArguments; if (cats.Count != 5) { return(false); } CoreTypes ct = module.Loader.GetAllFoundCoreTypes(); if (cats[0].ArgumentType != ct[CoreType.Byte] || cats[1].ArgumentType != ct[CoreType.Byte]) { return(false); } byte scale = (byte)cats[0].Value; byte sign = (byte)cats[1].Value; if (cats[2].ArgumentType == ct[CoreType.Int32] && cats[3].ArgumentType == ct[CoreType.Int32] && cats[4].ArgumentType == ct[CoreType.Int32]) { int hi = (int)cats[2].Value; int mid = (int)cats[3].Value; int lo = (int)cats[4].Value; rawDefaultValue = new DecimalConstantAttribute(scale, sign, hi, mid, lo).Value; return(true); } if (cats[2].ArgumentType == ct[CoreType.UInt32] && cats[3].ArgumentType == ct[CoreType.UInt32] && cats[4].ArgumentType == ct[CoreType.UInt32]) { uint hi = (uint)cats[2].Value; uint mid = (uint)cats[3].Value; uint lo = (uint)cats[4].Value; rawDefaultValue = new DecimalConstantAttribute(scale, sign, hi, mid, lo).Value; return(true); } return(false); } // Should we also look for CustomConstantAttribute too? Who uses that (other than DateTimeConstantAttribute which // we handled above?) CustomConstantAttribute is an abstract class which means we have to figure out how a subclass // we've never heard of would set the "Value" property which is kinda hard to do when you can't Invoke(). // Even the CLR doesn't return consistent values for this between the raw and non-raw versions. // Even doing the subclass check would open the door to resolving types and dependency assemblies and their // resulting FileNotFoundExceptions. Which is exactly what we're trying to avoid with this name-based lookup approach. } return(false); }
public OperatorsHolder(CoreTypes ct) { SetValue_PhpValueRef_PhpValue = ct.Operators.Method("SetValue", ct.PhpValue, ct.PhpValue); EnsureObject_ObjectRef = ct.Operators.Method("EnsureObject", ct.Object); EnsureArray_PhpArrayRef = ct.Operators.Method("EnsureArray", ct.PhpArray); EnsureArray_IPhpArrayRef = ct.Operators.Method("EnsureArray", ct.IPhpArray); IsSet_PhpValue = ct.Operators.Method("IsSet", ct.PhpValue); IsEmpty_PhpValue = ct.Operators.Method("IsEmpty", ct.PhpValue); ToString_Bool = ct.Convert.Method("ToString", ct.Boolean); ToString_Int32 = ct.Convert.Method("ToString", ct.Int32); ToString_Long = ct.Convert.Method("ToString", ct.Long); ToString_Double_Context = ct.Convert.Method("ToString", ct.Double, ct.Context); Long_ToString = ct.Long.Method("ToString"); ToBoolean_String = ct.Convert.Method("ToBoolean", ct.String); ToBoolean_PhpValue = new CoreExplicitCast(ct.PhpValue, ct.Boolean); ToBoolean_Object = ct.Convert.Method("ToBoolean", ct.Object); ToLong_PhpValue = new CoreExplicitCast(ct.PhpValue, ct.Long); ToDouble_PhpValue = new CoreExplicitCast(ct.PhpValue, ct.Double); ToNumber_PhpValue = ct.Convert.Method("ToNumber", ct.PhpValue); ToLong_String = ct.Convert.Method("StringToLongInteger", ct.String); ToDouble_String = ct.Convert.Method("StringToDouble", ct.String); AsObject_PhpValue = ct.Convert.Method("AsObject", ct.PhpValue); ToArray_PhpValue = ct.Convert.Method("ToArray", ct.PhpValue); ToClass_PhpValue = ct.Convert.Method("ToClass", ct.PhpValue); ToClass_IPhpArray = ct.Convert.Method("ToClass", ct.IPhpArray); AsCallable_PhpValue = ct.Convert.Method("AsCallable", ct.PhpValue); AsCallable_String = ct.Convert.Method("AsCallable", ct.String); IsInstanceOf_Object_PhpTypeInfo = ct.Convert.Method("IsInstanceOf", ct.Object, ct.PhpTypeInfo); ToIntStringKey_PhpValue = ct.Convert.Method("ToIntStringKey", ct.PhpValue); Echo_String = ct.Context.Method("Echo", ct.String); Echo_PhpString = ct.Context.Method("Echo", ct.PhpString); Echo_PhpNumber = ct.Context.Method("Echo", ct.PhpNumber); Echo_PhpValue = ct.Context.Method("Echo", ct.PhpValue); Echo_Object = ct.Context.Method("Echo", ct.Object); Echo_Double = ct.Context.Method("Echo", ct.Double); Echo_Long = ct.Context.Method("Echo", ct.Long); Echo_Int32 = ct.Context.Method("Echo", ct.Int32); GetForeachEnumerator_PhpValue_Bool_RuntimeTypeHandle = ct.Operators.Method("GetForeachEnumerator", ct.PhpValue, ct.Boolean, ct.RuntimeTypeHandle); Ceq_long_double = ct.Comparison.Method("Ceq", ct.Long, ct.Double); Ceq_long_bool = ct.Comparison.Method("Ceq", ct.Long, ct.Boolean); Ceq_long_string = ct.Comparison.Method("Ceq", ct.Long, ct.String); Ceq_double_string = ct.Comparison.Method("Ceq", ct.Double, ct.String); Ceq_string_long = ct.Comparison.Method("Ceq", ct.String, ct.Long); Ceq_string_double = ct.Comparison.Method("Ceq", ct.String, ct.Double); Ceq_string_bool = ct.Comparison.Method("Ceq", ct.String, ct.Boolean); Clt_long_double = ct.Comparison.Method("Clt", ct.Long, ct.Double); Cgt_long_double = ct.Comparison.Method("Cgt", ct.Long, ct.Double); Compare_bool_bool = ct.Comparison.Method("Compare", ct.Boolean, ct.Boolean); Compare_number_value = ct.Comparison.Method("Compare", ct.PhpNumber, ct.PhpValue); Compare_long_value = ct.Comparison.Method("Compare", ct.Long, ct.PhpValue); Compare_double_value = ct.Comparison.Method("Compare", ct.Double, ct.PhpValue); Compare_bool_value = ct.Comparison.Method("Compare", ct.Boolean, ct.PhpValue); Compare_value_value = ct.Comparison.Method("Compare", ct.PhpValue, ct.PhpValue); Compare_string_string = ct.Comparison.Method("Compare", ct.String, ct.String); Compare_string_long = ct.Comparison.Method("Compare", ct.String, ct.Long); Compare_string_double = ct.Comparison.Method("Compare", ct.String, ct.Double); Compare_string_value = ct.Comparison.Method("Compare", ct.String, ct.PhpValue); StrictCeq_bool_PhpValue = ct.StrictComparison.Method("Ceq", ct.Boolean, ct.PhpValue); StrictCeq_long_PhpValue = ct.StrictComparison.Method("Ceq", ct.Long, ct.PhpValue); StrictCeq_double_PhpValue = ct.StrictComparison.Method("Ceq", ct.Double, ct.PhpValue); StrictCeq_PhpValue_PhpValue = ct.StrictComparison.Method("Ceq", ct.PhpValue, ct.PhpValue); StrictCeq_PhpValue_bool = ct.StrictComparison.Method("Ceq", ct.PhpValue, ct.Boolean); Div_PhpValue_PhpValue = ct.PhpValue.Method(WellKnownMemberNames.DivisionOperatorName, ct.PhpValue, ct.PhpValue); Div_long_PhpValue = ct.PhpValue.Method(WellKnownMemberNames.DivisionOperatorName, ct.Long, ct.PhpValue); Div_double_PhpValue = ct.PhpNumber.Method(WellKnownMemberNames.DivisionOperatorName, ct.Double, ct.PhpValue); BitwiseOr_PhpValue_PhpValue = ct.PhpValue.Method(WellKnownMemberNames.BitwiseOrOperatorName, ct.PhpValue, ct.PhpValue); BitwiseAnd_PhpValue_PhpValue = ct.PhpValue.Method(WellKnownMemberNames.BitwiseAndOperatorName, ct.PhpValue, ct.PhpValue); BitwiseNot_PhpValue = ct.PhpValue.Method(WellKnownMemberNames.OnesComplementOperatorName, ct.PhpValue); }
public PhpArrayHolder(CoreTypes ct) { var t = ct.PhpArray; // ToString_Context = t.Method("ToString", ct.Context); ToClass = t.Method("ToClass"); ToBoolean = t.Method("ToBoolean"); RemoveKey_IntStringKey = t.Method("RemoveKey", ct.IntStringKey); GetItemValue_IntStringKey = t.Method("GetItemValue", ct.IntStringKey); DeepCopy = t.Method("DeepCopy"); GetForeachEnumerator_Boolean = t.Method("GetForeachEnumerator", ct.Boolean); SetItemValue_IntStringKey_PhpValue = t.Method("SetItemValue", ct.IntStringKey, ct.PhpValue); SetItemAlias_IntStringKey_PhpAlias = t.Method("SetItemAlias", ct.IntStringKey, ct.PhpAlias); AddValue_PhpValue = t.Method("AddValue", ct.PhpValue); EnsureItemObject_IntStringKey = t.Method("EnsureItemObject", ct.IntStringKey); EnsureItemArray_IntStringKey = t.Method("EnsureItemArray", ct.IntStringKey); EnsureItemAlias_IntStringKey = t.Method("EnsureItemAlias", ct.IntStringKey); New_PhpValue = t.Method("New", ct.PhpValue); }
/// <summary> Create the object </summary> protected override void BeginProcessing() { Type type = null; PSArgumentException mshArgE = null; if (string.Compare(ParameterSetName, netSetName, StringComparison.Ordinal) == 0) { object _newObject = null; try { type = LanguagePrimitives.ConvertTo(TypeName, typeof(Type), CultureInfo.InvariantCulture) as Type; } catch (Exception e) { // these complications in Exception handling are aim to make error messages better. if (e is InvalidCastException || e is ArgumentException) { if (e.InnerException != null && e.InnerException is TypeResolver.AmbiguousTypeException) { ThrowTerminatingError( new ErrorRecord( e, "AmbiguousTypeReference", ErrorCategory.InvalidType, targetObject: null)); } mshArgE = PSTraceSource.NewArgumentException( "TypeName", NewObjectStrings.TypeNotFound, TypeName); ThrowTerminatingError( new ErrorRecord( mshArgE, "TypeNotFound", ErrorCategory.InvalidType, targetObject: null)); } throw e; } Diagnostics.Assert(type != null, "LanguagePrimitives.TryConvertTo failed but returned true"); if (type.IsByRefLike) { ThrowTerminatingError( new ErrorRecord( PSTraceSource.NewInvalidOperationException( NewObjectStrings.CannotInstantiateBoxedByRefLikeType, type), nameof(NewObjectStrings.CannotInstantiateBoxedByRefLikeType), ErrorCategory.InvalidOperation, targetObject: null)); } if (Context.LanguageMode == PSLanguageMode.ConstrainedLanguage) { if (!CoreTypes.Contains(type)) { ThrowTerminatingError( new ErrorRecord( new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null)); } } // WinRT does not support creating instances of attribute & delegate WinRT types. if (WinRTHelper.IsWinRTType(type) && ((typeof(System.Attribute)).IsAssignableFrom(type) || (typeof(System.Delegate)).IsAssignableFrom(type))) { ThrowTerminatingError(new ErrorRecord(new InvalidOperationException(NewObjectStrings.CannotInstantiateWinRTType), "CannotInstantiateWinRTType", ErrorCategory.InvalidOperation, null)); } if (ArgumentList == null || ArgumentList.Length == 0) { ConstructorInfo ci = type.GetConstructor(Type.EmptyTypes); if (ci != null && ci.IsPublic) { _newObject = CallConstructor(type, new ConstructorInfo[] { ci }, new object[] { }); if (_newObject != null && Property != null) { // The method invocation is disabled for "Hashtable to Object conversion" (Win8:649519), but we need to keep it enabled for New-Object for compatibility to PSv2 _newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true); } WriteObject(_newObject); return; } else if (type.GetTypeInfo().IsValueType) { // This is for default parameterless struct ctor which is not returned by // Type.GetConstructor(System.Type.EmptyTypes). try { _newObject = Activator.CreateInstance(type); if (_newObject != null && Property != null) { // Win8:649519 _newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true); } } catch (TargetInvocationException e) { ThrowTerminatingError( new ErrorRecord( e.InnerException ?? e, "ConstructorCalledThrowException", ErrorCategory.InvalidOperation, null)); } WriteObject(_newObject); return; } } else { ConstructorInfo[] ctorInfos = type.GetConstructors(); if (ctorInfos.Length != 0) { _newObject = CallConstructor(type, ctorInfos, ArgumentList); if (_newObject != null && Property != null) { // Win8:649519 _newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true); } WriteObject(_newObject); return; } } mshArgE = PSTraceSource.NewArgumentException( "TypeName", NewObjectStrings.CannotFindAppropriateCtor, TypeName); ThrowTerminatingError( new ErrorRecord( mshArgE, "CannotFindAppropriateCtor", ErrorCategory.ObjectNotFound, null)); } #if !UNIX else // Parameterset -Com { int result = NewObjectNativeMethods.CLSIDFromProgID(ComObject, out _comObjectClsId); // If we're in ConstrainedLanguage, do additional restrictions if (Context.LanguageMode == PSLanguageMode.ConstrainedLanguage) { bool isAllowed = false; // If it's a system-wide lockdown, we may allow additional COM types if (SystemPolicy.GetSystemLockdownPolicy() == SystemEnforcementMode.Enforce) { if ((result >= 0) && SystemPolicy.IsClassInApprovedList(_comObjectClsId)) { isAllowed = true; } } if (!isAllowed) { ThrowTerminatingError( new ErrorRecord( new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateComTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null)); return; } } object comObject = CreateComObject(); string comObjectTypeName = comObject.GetType().FullName; if (!comObjectTypeName.Equals("System.__ComObject")) { mshArgE = PSTraceSource.NewArgumentException( "TypeName", NewObjectStrings.ComInteropLoaded, comObjectTypeName); WriteVerbose(mshArgE.Message); if (Strict) { WriteError(new ErrorRecord( mshArgE, "ComInteropLoaded", ErrorCategory.InvalidArgument, comObject)); } } if (comObject != null && Property != null) { // Win8:649519 comObject = LanguagePrimitives.SetObjectProperties(comObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true); } WriteObject(comObject); } #endif }
private PhpCompilation( string assemblyName, PhpCompilationOptions options, ImmutableArray<MetadataReference> references, //ReferenceManager referenceManager, //SyntaxAndDeclarationManager syntaxAndDeclarations AsyncQueue<CompilationEvent> eventQueue = null ) : base(assemblyName, references, SyntaxTreeCommonFeatures(ImmutableArray<SyntaxTree>.Empty), false, eventQueue) { _wellKnownMemberSignatureComparer = new WellKnownMembersSignatureComparer(this); _options = options; _referenceManager = new ReferenceManager(options.SdkDirectory); _tables = new SourceDeclarations(); _coreTypes = new CoreTypes(this); _coreMethods = new CoreMethods(_coreTypes); _anonymousTypeManager = new AnonymousTypeManager(this); }
/// <summary> Create the object </summary> protected override void BeginProcessing() { Type type = null; PSArgumentException mshArgE = null; if (string.Equals(ParameterSetName, netSetName, StringComparison.Ordinal)) { object _newObject = null; try { type = LanguagePrimitives.ConvertTo(TypeName, typeof(Type), CultureInfo.InvariantCulture) as Type; } catch (Exception e) { // these complications in Exception handling are aim to make error messages better. if (e is InvalidCastException || e is ArgumentException) { if (e.InnerException != null && e.InnerException is TypeResolver.AmbiguousTypeException) { ThrowTerminatingError( new ErrorRecord( e, "AmbiguousTypeReference", ErrorCategory.InvalidType, targetObject: null)); } mshArgE = PSTraceSource.NewArgumentException( "TypeName", NewObjectStrings.TypeNotFound, TypeName); ThrowTerminatingError( new ErrorRecord( mshArgE, "TypeNotFound", ErrorCategory.InvalidType, targetObject: null)); } throw; } Diagnostics.Assert(type != null, "LanguagePrimitives.TryConvertTo failed but returned true"); if (type.IsByRefLike) { ThrowTerminatingError( new ErrorRecord( PSTraceSource.NewInvalidOperationException( NewObjectStrings.CannotInstantiateBoxedByRefLikeType, type), nameof(NewObjectStrings.CannotInstantiateBoxedByRefLikeType), ErrorCategory.InvalidOperation, targetObject: null)); } if (Context.LanguageMode == PSLanguageMode.ConstrainedLanguage) { if (!CoreTypes.Contains(type)) { ThrowTerminatingError( new ErrorRecord( new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null)); } } // WinRT does not support creating instances of attribute & delegate WinRT types. if (WinRTHelper.IsWinRTType(type) && ((typeof(System.Attribute)).IsAssignableFrom(type) || (typeof(System.Delegate)).IsAssignableFrom(type))) { ThrowTerminatingError(new ErrorRecord(new InvalidOperationException(NewObjectStrings.CannotInstantiateWinRTType), "CannotInstantiateWinRTType", ErrorCategory.InvalidOperation, null)); } if (ArgumentList is null || ArgumentList.Length == 0) { ConstructorInfo ci = type.GetConstructor(Type.EmptyTypes); if (ci != null && ci.IsPublic) { _newObject = CallConstructor(type, new ConstructorInfo[] { ci }, new object[] { }); if (_newObject != null && Property != null) { // The method invocation is disabled for "Hashtable to Object conversion" (Win8:649519), but we need to keep it enabled for New-Object for compatibility to PSv2 _newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true); } WriteObject(_newObject); return; } else if (type.GetTypeInfo().IsValueType) { // This is for default parameterless struct ctor which is not returned by // Type.GetConstructor(System.Type.EmptyTypes). try { _newObject = Activator.CreateInstance(type); if (_newObject != null && Property != null) { // Win8:649519 _newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true); } } catch (TargetInvocationException e) { ThrowTerminatingError( new ErrorRecord( e.InnerException ?? e, "ConstructorCalledThrowException", ErrorCategory.InvalidOperation, null)); } WriteObject(_newObject); return; } } else { ConstructorInfo[] ctorInfos = type.GetConstructors(); if (ctorInfos.Length != 0) { _newObject = CallConstructor(type, ctorInfos, ArgumentList); if (_newObject != null && Property != null) { // Win8:649519 _newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true); } WriteObject(_newObject); return; } } mshArgE = PSTraceSource.NewArgumentException( "TypeName", NewObjectStrings.CannotFindAppropriateCtor, TypeName); ThrowTerminatingError( new ErrorRecord( mshArgE, "CannotFindAppropriateCtor", ErrorCategory.ObjectNotFound, null)); }
public virtual string Format(DateTime v) { return CoreTypes.CastToString(v); }
/// <summary> /// Returns a lazily created and cached Type instance corresponding to the indicated core type. This method returns null /// if the core assembly name wasn't supplied, the core assembly could not be loaded for some reason or if the specified /// type does not exist in the core assembly. /// </summary> internal RoType?TryGetCoreType(CoreType coreType) { CoreTypes coreTypes = GetAllFoundCoreTypes(); return(coreTypes[coreType]); }
public virtual string Format(Duration v) { return CoreTypes.CastToString(v); }
public override string Format(double v) { return CoreTypes.CastToString((long) v); }
public CoreMethods(CoreTypes types) { Contract.ThrowIfNull(types); PhpValue = new PhpValueHolder(types); PhpAlias = new PhpAliasHolder(types); PhpArray = new PhpArrayHolder(types); IPhpArray = new IPhpArrayHolder(types); PhpNumber = new PhpNumberHolder(types); PhpString = new PhpStringHolder(types); Operators = new OperatorsHolder(types); Ctors = new ConstructorsHolder(types); Context = new ContextHolder(types); Dynamic = new DynamicHolder(types); Reflection = new ReflectionHolder(types); }