public CDimensionCollection(IExpressionCollection c) : base(c.Count) { for (int i = 0, iM = c.Count; i < iM; i++) { this[i] = new CDimension(); // 今のところは全て 0 } }
public override void TranslateExpressionGroup(IExpressionCollection expressions) { foreach (CodeExpression cexp in expressions.GenerateCodeDom(this.Options)) { this.Provider.GenerateCodeFromExpression(cexp, base.Target, this.Options.Options); } }
public void AddRange(IExpressionCollection expressions) { foreach (var item in expressions) { this.Add(item); } }
public ISwitchStatementCase AddNew(bool lastIsDefaultCase, IExpressionCollection caseTargets) { ISwitchStatementCase @case = new SwitchStatementCase(this.sourceBlock, caseTargets, lastIsDefaultCase); this.baseList.Add(@case); return(@case); }
/// <summary> /// Creates a new instnace of <see cref="ArrayIndexerExpression"/> with the /// <paramref name="target"/> and <parmaref name="indices"/> provided /// </summary> /// <param name="target">The array expression that needs accessed because it is an /// array.</param> /// <param name="indices">The Indices that are needed to access the member of the /// array.</param> public ArrayIndexerExpression(IExpression target, IExpressionCollection indices) { this.target = target; foreach (IExpression ie in indices) { this.Indices.Add(ie); } }
public void AddRange <T>(IExpressionCollection <T> expressions) where T : IExpression { foreach (var item in expressions) { this.Add(item); } }
public IndexerReferenceExpression(IMemberParentExpression reference, IExpressionCollection indices) : base(Resources.IndexerName, reference) { if (indices != null) { foreach (IExpression exp in indices) { this.Indices.Add(exp); } } }
public SwitchStatementCase(IStatementBlock parentBlock, IExpressionCollection cases, bool lastIsDefault) { if (parentBlock == null) { throw new ArgumentNullException("parentBlock"); } if (cases == null) { throw new ArgumentNullException("cases"); } this.parentBlock = parentBlock; this.lastIsDefault = lastIsDefault; foreach (IExpression expression in cases) { this.Cases.Add(expression); } }
public IConstructorMember AddNew(IExpressionCollection cascadeMembers, ConstructorCascadeTarget cascadeExpressionsTarget, params TypedName[] parameters) { IConstructorMember result = new ConstructorMember(this.TargetDeclaration); foreach (TypedName param in parameters) { result.Parameters.AddNew(param); } if ((cascadeExpressionsTarget != ConstructorCascadeTarget.Undefined) && (cascadeMembers != null)) { foreach (IExpression cascParam in cascadeMembers) { result.CascadeMembers.Add(cascParam); } } result.CascadeExpressionsTarget = cascadeExpressionsTarget; this._Add(result.GetUniqueIdentifier(), result); return(result); }
protected CreateArrayExpression(SerializationInfo info, StreamingContext context) { SerializationType method = (SerializationType)info.GetValue("SerializationMeans", typeof(SerializationType)); bool sizeExp = ((method & SerializationType.SizeExpression) == SerializationType.SizeExpression); bool sizePrim = ((method & SerializationType.SizePrimitive) == SerializationType.SizePrimitive) && !sizeExp; bool initializers = ((method & SerializationType.Initializers) == SerializationType.Initializers); if (sizeExp) { this.sizeExpression = _SerializationMethods.DeserializeExpression("SizeExpression", info); } else if (sizePrim) { this.size = info.GetInt32("Size"); } if (initializers) { this.initializers = _SerializationMethods.DeserializeExpressionCollection("Initializers", info); } this.arrayType = _SerializationMethods.DeserializeTypeReference("ArrayType", info); }
private void WriteExpressionList(IExpressionCollection expressions, IFormatter formatter) { // Indent++; for (int i = 0; i < expressions.Count; i++) { if (i != 0) { formatter.Write(", "); } this.WriteExpression(expressions[i], formatter); } // Indent--; }
public virtual IExpressionCollection TransformExpressionCollection(IExpressionCollection expressions) { IExpression[] array = new IExpression[expressions.Count]; for (int i = 0; i < expressions.Count; i++) { array[i] = this.TransformExpression(expressions[i]); } IExpressionCollection target = new ExpressionCollection(); target.AddRange(array); return target; }
public MethodInvokeExpression(IMethodReferenceExpression reference, IExpressionCollection argumentExpressions) { this.reference = reference; this.argumentExpressions = argumentExpressions; }
public static bool Compare(this IExpressionCollection source, IExpressionCollection n, Func <IExpression, IExpression, bool> checkitem) { return(Compare <IExpression>(source, n, checkitem)); }
//============================================================ // 初期化 //============================================================ public AttributeCollection(LanguageWriter writer, ICustomAttributeProvider provider, IType type) { this.writer = writer; this.provider = provider; this.type = type; // 属性の対象 if (provider is IAssembly) { attr_class = "assembly"; isAsmOrModule = true; } else if (provider is IModule) { attr_class = "module"; isAsmOrModule = true; } else if (provider is IMethodReturnType) { attr_class = "returnvalue"; } // 個々の属性に対して走査 foreach (ICustomAttribute attr in provider.Attributes) { if (attr == null) { continue; } string attrname = GetCustomAttributeName(attr); switch (attrname) { case "ParamArray": case "System::ParamArray": containsParams = true; continue; case "MarshalAs": case "System::Runtime::InteropServices::MarshalAs": IExpressionCollection arguments = attr.Arguments; if (arguments == null) { break; } IFieldReferenceExpression exp_fld = arguments[0] as IFieldReferenceExpression; if (exp_fld == null) { break; } ITypeReferenceExpression target = exp_fld.Target as ITypeReferenceExpression; if (target == null || target.Type.Name != "UnmanagedType") { break; } IFieldReference field = exp_fld.Field; if (field.Name == "U1") { if (LanguageWriter.Type(type, "System", "Boolean")) { continue; } } else if (field.Name == "U2" && LanguageWriter.Type(type, "System", "Char")) { continue; } break; } attrs.Add(new AttrPair(attrname, attr)); } // 名前空間順に並び替え attrs.Sort(delegate(AttrPair l, AttrPair r){ string l_name = ((ITypeReference)l.Value.Constructor.DeclaringType).Namespace; string r_name = ((ITypeReference)r.Value.Constructor.DeclaringType).Namespace; return(l_name.CompareTo(r_name)); }); }
/// <summary> /// Obtains a <see cref="IConstructorInvokeExpression"/> /// by evaluating the <paramref name="parameters"/> /// provided. /// </summary> /// <param name="parameters">A series of /// <see cref="IExpression"/> elements /// which relate to the data of the /// parameters of the invoke, and the /// types of the parameters.</param> /// <returns>A new <see cref="IConstructorInvokeExpression"/> /// relative to the signature and data of /// the <paramref name="parameters"/> /// provided.</returns> public IConstructorInvokeExpression Invoke(IExpressionCollection parameters) { return(new ConstructorInvokeExpression(new ConstructorPointerReferenceExpression(this), parameters)); }
protected CreateNewObjectExpression(SerializationInfo info, StreamingContext context) { this.newType = _SerializationMethods.DeserializeTypeReference("NewType", info); this.arguments = _SerializationMethods.DeserializeExpressionCollection("Arguments", info); }
public CreateNewObjectExpression(ITypeReference newType, IEnumerable <IExpression> arguments) { this.newType = newType; this.arguments = new ExpressionCollection(arguments); }
public CreateNewObjectExpression(ITypeReference newType, IExpressionCollection arguments) : this(newType, (IEnumerable <IExpression>)(arguments)) { }
/// <summary> /// Obtains a <see cref="IConstructorInvokeExpression"/> /// by evaluating the <paramref name="parameters"/> /// provided. /// </summary> /// <param name="parameters">A series of /// <see cref="IExpression"/> elements /// which relate to the data of the /// parameters of the invoke, and the /// types of the parameters.</param> /// <returns>A new <see cref="IConstructorInvokeExpression"/> /// relative to the signature and data of /// the <paramref name="parameters"/> /// provided.</returns> public IConstructorInvokeExpression Invoke(IExpressionCollection parameters) { return(new ConstructorInvokeExpression(this, parameters)); }
public static bool Compare(this IExpressionCollection source, IExpressionCollection n, Func <IExpression, IExpression, Action <string, string>, bool> checkitem, Action <string, string> errAct) { return(Compare <IExpression>(source, n, checkitem, errAct)); }
public CreateArrayExpression(ITypeReference arrayType, IExpression[] initializers) { this.initializers = new ExpressionCollection(initializers); this.ArrayType = arrayType; }
/// <summary> /// Creates a new <see cref="MethodInvokeExpression{TSignatureParameter, TSignature, TParent}"/> with /// the <paramref name="parameters"/>, and <paramref name="reference"/> /// provided. /// </summary> /// <param name="reference">A <see cref="IMethodReferenceStub"/> /// which created the <see cref="MethodInvokeExpression{TSignatureParameter, TSignature, TParent}"/> and designates /// the method target whose signature is inferred by the framework /// if needed.</param> /// <param name="parameters">The series of <see cref="IExpression"/> /// elements which relate to the values to send /// the method when calling it.</param> /// <exception cref="System.ArgumentNullException">thrown when <paramref name="reference"/> /// or <paramref name="parameters"/> is null.</exception> public MethodInvokeExpression(IMethodReferenceStub <TSignatureParameter, TSignature, TParent> reference, IExpressionCollection <IExpression> parameters) : base(reference, parameters) { }
public virtual void VisitExpressionCollection(IExpressionCollection value) { for (int i = 0; i < value.Count; i++) { this.VisitExpression(value[i]); } }
public CreateInstanceExpression(IConstructorPointerReferenceExpression reference, IExpressionCollection parameters) : base(reference, parameters) { }
/// <summary> /// Obtains a <see cref="IMethodInvokeExpression"/> /// by evaluating the <paramref name="parameters"/> /// provided. /// </summary> /// <param name="parameters">A series of /// <see cref="IExpression"/> elements /// which relate to the data of the /// parameters of the invoke, and the /// types of the parameters.</param> /// <returns>A new <see cref="IMethodInvokeExpression"/> /// relative to the signature and data of /// the <paramref name="parameters"/> /// provided.</returns> public IMethodInvokeExpression Invoke(IExpressionCollection <IExpression> parameters) { return(GetPointerReference().Invoke(parameters)); }
public static bool Compare(this IExpressionCollection source, IExpressionCollection n) { return(Compare <IExpression>(source, n)); }
public abstract void TranslateExpressionGroup(IExpressionCollection expressions);
public static bool Compare(this IExpressionCollection source, IExpressionCollection n) { return Compare<IExpression>(source,n); }
public ConstructorInvokeExpression(IConstructorPointerReferenceExpression reference, IExpressionCollection parameters) : this(reference) { this.Arguments.AddRange(parameters); }
public static bool Compare(this IExpressionCollection source, IExpressionCollection n, Func<IExpression, IExpression, bool> checkitem) { return Compare<IExpression>(source,n,checkitem); }
internal static void SerializeExpressionCollection(string baseName, SerializationInfo info, IExpressionCollection collection) { if (collection == null) { info.AddValue(baseName, -1); return; } info.AddValue(baseName, collection.Count); for (int i = 0; i < collection.Count; i++) { string itemBaseName = string.Format("{0}.[{1}]", baseName, i); SerializeExpression(itemBaseName, info, collection[i]); } }
public static bool Compare(this IExpressionCollection source, IExpressionCollection n, Func<IExpression, IExpression, Action<string, string>, bool> checkitem, Action<string, string> errAct) { return Compare<IExpression>(source,n,checkitem,errAct); }
internal static CreateInstanceExpression GetByExpressionCollection <T>(IConstructorPointerReferenceExpression reference, IExpressionCollection <T> parameters) where T : IExpression { var result = new CreateInstanceExpression(reference); result.Arguments.AddRange(parameters); return(result); }
protected ArrayIndexerExpression(SerializationInfo info, StreamingContext context) { this.target = _SerializationMethods.DeserializeExpression("Target", info); this.indices = _SerializationMethods.DeserializeExpressionCollection("Indices", info); }
public ICreateNewObjectExpression GetNewExpression(IExpressionCollection arguments) { return(new CreateNewObjectExpression(this, arguments)); }
private void InsituTransformExpressionCollection(IExpressionCollection value) { for (int i = 0; i < value.Count; i++) { value[i] = this.TransformExpression(value[i]); } }