public override void VisitFieldReferenceExpression(IFieldReferenceExpression operation)
{
Visit(operation.Instance);
}
public virtual void VisitFieldReferenceExpression(IFieldReferenceExpression value)
{
this.VisitFieldReference(value.Field);
this.VisitExpression(value.Target);
}
public override void TranslateExpression(IFieldReferenceExpression fieldRefExpression)
{
this.Provider.GenerateCodeFromExpression(fieldRefExpression.GenerateCodeDom(this.Options), base.Target, this.Options.Options);
}
/// <inheritdoc />
public override Expression VisitFieldReferenceExpression(IFieldReferenceExpression operation, LocalBinder argument)
{
return(base.VisitFieldReferenceExpression(operation, argument));
}
public override IdentifierInfo VisitFieldReferenceExpression([NotNull] IFieldReferenceExpression operation,
[CanBeNull] object argument)
{
return(CreateForMemberReferenceExpression(operation, operation.Field.Type));
}
public object Evaluate(IExpression expr)
{
if (expr is IObjectCreateExpression)
{
return(Evaluate((IObjectCreateExpression)expr));
}
else if (expr is ILiteralExpression)
{
return(((ILiteralExpression)expr).Value);
}
else if (expr is ICastExpression)
{
return(Evaluate(((ICastExpression)expr).Expression));
}
else if (expr is ICheckedExpression)
{
return(Evaluate(((ICheckedExpression)expr).Expression));
}
else if (expr is IBinaryExpression)
{
IBinaryExpression ibe = (IBinaryExpression)expr;
object left = Evaluate(ibe.Left);
object right = Evaluate(ibe.Right);
Type type = left.GetType();
return(Microsoft.ML.Probabilistic.Compiler.Reflection.Invoker.InvokeStatic(type, binaryOperatorNames[(int)ibe.Operator], left, right));
}
else if (expr is IUnaryExpression)
{
IUnaryExpression iue = (IUnaryExpression)expr;
object target = Evaluate(iue.Expression);
Type type = target.GetType();
return(Microsoft.ML.Probabilistic.Compiler.Reflection.Invoker.InvokeStatic(type, unaryOperatorNames[(int)iue.Operator], target));
}
else if (expr is IMethodInvokeExpression)
{
IMethodInvokeExpression imie = (IMethodInvokeExpression)expr;
object[] args = EvaluateAll(imie.Arguments);
return(Invoke(imie.Method, args));
}
else if (expr is IArrayCreateExpression)
{
IArrayCreateExpression iace = (IArrayCreateExpression)expr;
Type t = Builder.ToType(iace.Type);
int[] lens = new int[iace.Dimensions.Count];
for (int i = 0; i < lens.Length; i++)
{
lens[i] = (int)Evaluate(iace.Dimensions[i]);
}
// TODO: evaluate initializer
if (iace.Initializer != null)
{
throw new NotImplementedException("IArrayCreateExpression has an initializer block");
}
return(Array.CreateInstance(t, lens));
}
else if (expr is IFieldReferenceExpression)
{
IFieldReferenceExpression ifre = (IFieldReferenceExpression)expr;
if (ifre.Target is ITypeReferenceExpression)
{
ITypeReferenceExpression itre = (ITypeReferenceExpression)ifre.Target;
Type type = Builder.ToType(itre.Type);
FieldInfo info = type.GetField(ifre.Field.Name);
return(info.GetValue(null));
}
else
{
object target = Evaluate(ifre.Target);
FieldInfo info = target.GetType().GetField(ifre.Field.Name);
return(info.GetValue(target));
}
}
else
{
throw new InferCompilerException("Could not evaluate: " + expr);
}
}
//============================================================
// 初期化
//============================================================
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));
});
}
/// <inheritdoc />
public override IOperation VisitFieldReferenceExpression(IFieldReferenceExpression operation, object argument)
{
return(base.VisitFieldReferenceExpression(operation, argument));
}
public abstract TransformationImpact CalculateRefactorImpact(IFieldReferenceExpression expression);
public abstract void Translate(IFieldReferenceExpression expression);
public abstract void Translate <TField, TFieldParent>(IFieldReferenceExpression <TField, TFieldParent> expression)
where TField :
IFieldMember <TField, TFieldParent>
where TFieldParent :
IFieldParent <TField, TFieldParent>;
private void WriteFieldReferenceExpression(IFieldReferenceExpression expression, IFormatter formatter)
{
// TODO bool escape = true;
if (expression.Target != null)
{
this.WriteTargetExpression(expression.Target, formatter);
formatter.Write(".");
// TODO escape = false;
}
this.WriteFieldReference(expression.Field, formatter);
}
public TransformationKind Visit(IFieldReferenceExpression expression, ITransformationContext context)
{
return(TransformationKind.Replace);
}
public TransformationKind Visit <TField, TFieldParent>(IFieldReferenceExpression <TField, TFieldParent> expression, ITransformationContext context)
where TField : IFieldMember <TField, TFieldParent>
where TFieldParent : IFieldParent <TField, TFieldParent>
{
return(TransformationKind.Ignore);
}
public static IYieldReturnStatement YieldReturn(this IBlockStatementParent blockParent, IFieldReferenceExpression returnValue)
{
return(blockParent.YieldReturn((IExpression)returnValue));
}
public abstract TransformationImpact CalculateRefactorImpact <TField, TFieldParent>(IFieldReferenceExpression <TField, TFieldParent> expression)
where TField :
IFieldMember <TField, TFieldParent>
where TFieldParent :
IFieldParent <TField, TFieldParent>;
public override IOperation VisitFieldReferenceExpression(IFieldReferenceExpression operation, object argument)
{
return(new FieldReferenceExpression(operation.Field, operation.IsDeclaration, Visit(operation.Instance), operation.Member, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
public TestLinkerResult Visit <TField, TFieldParent>(IFieldReferenceExpression <TField, TFieldParent> expression, ICompilationContext context)
where TField : IFieldMember <TField, TFieldParent>
where TFieldParent : IFieldParent <TField, TFieldParent>
{
throw new NotImplementedException();
}
public virtual void VisitFieldReferenceExpression(IFieldReferenceExpression value)
{
VisitFieldReference(value.Field);
VisitExpression(value.Target);
}
public TestLinkerResult Visit(IFieldReferenceExpression expression, ICompilationContext context)
{
throw new NotImplementedException();
}
public virtual void VisitFieldReferenceExpression(IFieldReferenceExpression operation)
{
DefaultVisit(operation);
}
public override void VisitFieldReferenceExpression(IFieldReferenceExpression operation)
{
var member = operation.Member;
var field = operation.Field;
base.VisitFieldReferenceExpression(operation);
}
public static bool IsExpressionEqualsDtdProcessingParse(IOperation operation)
{
IFieldReferenceExpression enumRef = operation as IFieldReferenceExpression;
return(enumRef != null && enumRef.HasConstantValue(2)); // DtdProcessing.Parse
}
//===========================================================
// Expression 分岐
//===========================================================
public virtual void WriteExpression(IExpression expression)
{
if (expression == null)
{
return;
}
mwg.Reflector.CppCli.ExpressionWriter.WriteExpression(this, expression, false);
#if FALSE
#pragma warning disable 612
IMemberInitializerExpression expression3 = expression as IMemberInitializerExpression;
if (expression3 != null)
{
this.WriteMemberInitializerExpression(expression3);
return;
}
IAddressOutExpression expression27 = expression as IAddressOutExpression;
if (expression27 != null)
{
this.WriteAddressOutExpression(expression27);
return;
}
IAddressReferenceExpression expression26 = expression as IAddressReferenceExpression;
if (expression26 != null)
{
this.WriteAddressReferenceExpression(expression26);
return;
}
IDelegateCreateExpression iDelegateCreateExpression = expression as IDelegateCreateExpression;
if (iDelegateCreateExpression != null)
{
this.WriteDelegateCreateExpression(iDelegateCreateExpression);
return;
}
IMethodInvokeExpression iMethodInvokeExpression = expression as IMethodInvokeExpression;
if (iMethodInvokeExpression != null)
{
this.WriteMethodInvokeExpression(iMethodInvokeExpression);
return;
}
IVariableDeclarationExpression expression15 = expression as IVariableDeclarationExpression;
if (expression15 != null)
{
this.WriteVariableDeclaration(expression15.Variable);
return;
}
ITypeOfExpression iTypeOfExpression = expression as ITypeOfExpression;
if (iTypeOfExpression != null)
{
this.WriteTypeOfExpression(iTypeOfExpression);
return;
}
ISnippetExpression iSnippetExpression = expression as ISnippetExpression;
if (iSnippetExpression != null)
{
this.WriteSnippetExpression(iSnippetExpression);
return;
}
IUnaryExpression iUnaryExpression = expression as IUnaryExpression;
if (iUnaryExpression != null)
{
this.WriteUnaryExpression(iUnaryExpression);
return;
}
IObjectCreateExpression iObjectCreateExpression = expression as IObjectCreateExpression;
if (iObjectCreateExpression != null)
{
this.WriteObjectCreateExpression(iObjectCreateExpression);
return;
}
IVariableReferenceExpression iVariableReferenceExpression = expression as IVariableReferenceExpression;
if (iVariableReferenceExpression != null)
{
this.WriteVariableReferenceExpression(iVariableReferenceExpression);
return;
}
IThisReferenceExpression expression12 = expression as IThisReferenceExpression;
if (expression12 != null)
{
this.WriteThisReferenceExpression(expression12);
return;
}
ITryCastExpression iTryCastExpression = expression as ITryCastExpression;
if (iTryCastExpression != null)
{
this.WriteTryCastExpression(iTryCastExpression);
return;
}
IConditionExpression expression9 = expression as IConditionExpression;
if (expression9 != null)
{
this.WriteConditionExpression(expression9);
return;
}
IFieldReferenceExpression iFieldReferenceExpression = expression as IFieldReferenceExpression;
if (iFieldReferenceExpression != null)
{
this.WriteFieldReferenceExpression(iFieldReferenceExpression);
return;
}
IPropertyIndexerExpression iPropertyIndexerExpression = expression as IPropertyIndexerExpression;
if (iPropertyIndexerExpression != null)
{
this.WritePropertyIndexerExpression(iPropertyIndexerExpression);
return;
}
ITypeReferenceExpression iTypeReferenceExpression = expression as ITypeReferenceExpression;
if (iTypeReferenceExpression != null)
{
this.WriteTypeReferenceExpression(iTypeReferenceExpression);
return;
}
IMethodReferenceExpression iMethodReferenceExpression = expression as IMethodReferenceExpression;
if (iMethodReferenceExpression != null)
{
this.WriteMethodReferenceExpression(iMethodReferenceExpression);
return;
}
IPropertyReferenceExpression iPropertyReferenceExpression = expression as IPropertyReferenceExpression;
if (iPropertyReferenceExpression != null)
{
this.WritePropertyReferenceExpression(iPropertyReferenceExpression);
return;
}
ICastExpression expression5 = expression as ICastExpression;
if (expression5 != null)
{
this.WriteCastExpression(expression5);
return;
}
ICanCastExpression iCanCastExpression = expression as ICanCastExpression;
if (iCanCastExpression != null)
{
this.WriteCanCastExpression(iCanCastExpression);
return;
}
ICastExpression iCastExpression = expression as ICastExpression;
if (iCastExpression != null)
{
this.WriteCastExpression(iCastExpression);
return;
}
ILiteralExpression literalExpression = expression as ILiteralExpression;
if (literalExpression != null)
{
this.WriteLiteralExpression(literalExpression);
return;
}
IBinaryExpression iBinaryExpression = expression as IBinaryExpression;
if (iBinaryExpression != null)
{
mwg.Reflector.CppCli.ExpressionWriter.WriteExpression(this, expression, true);
//this.WriteBinaryExpression(iBinaryExpression);
return;
}
IArrayIndexerExpression expression30 = expression as IArrayIndexerExpression;
if (expression30 != null)
{
this.WriteArrayIndexerExpression(expression30);
return;
}
IAddressDereferenceExpression expression29 = expression as IAddressDereferenceExpression;
if (expression29 != null)
{
this.WriteAddressDereferenceExpression(expression29);
return;
}
IAddressOfExpression expression28 = expression as IAddressOfExpression;
if (expression28 != null)
{
this.WriteAddressOfExpression(expression28);
return;
}
IArgumentListExpression expression25 = expression as IArgumentListExpression;
if (expression25 != null)
{
this.WriteArgumentListExpression(expression25);
return;
}
IBaseReferenceExpression iBaseReferenceExpression = expression as IBaseReferenceExpression;
if (iBaseReferenceExpression != null)
{
this.WriteBaseReferenceExpression(iBaseReferenceExpression);
return;
}
IArgumentReferenceExpression expression13 = expression as IArgumentReferenceExpression;
if (expression13 != null)
{
this.WriteArgumentReferenceExpression(expression13);
return;
}
IArrayCreateExpression expression10 = expression as IArrayCreateExpression;
if (expression10 != null)
{
this.WriteArrayCreateExpression(expression10);
return;
}
IAssignExpression iAssignExpression = expression as IAssignExpression;
if (iAssignExpression != null)
{
this.WriteAssignExpression(iAssignExpression);
return;
}
IBlockExpression expression2 = expression as IBlockExpression;
if (expression2 != null)
{
this.WriteBlockExpression(expression2);
return;
}
#pragma warning restore 612
this.Write(expression.ToString());
#endif
}
public virtual void VisitFieldReferenceExpression(IFieldReferenceExpression operation)
{
DefaultVisit(operation);
}
public virtual IExpression TransformFieldReferenceExpression(IFieldReferenceExpression value)
{
value.Target = this.TransformExpression(value.Target);
return value;
}
