public override void VisitMethodReferenceExpression(IMethodReferenceExpression operation)
{
var member = operation.Member;
var method = operation.Method;
base.VisitMethodReferenceExpression(operation);
}
public ISimpleStatement CallMethod(IMethodReferenceExpression method, params IExpression[] arguments)
{
ISimpleStatement simpleStatement = new SimpleStatement(method.Invoke(arguments), this);
this.Add(simpleStatement);
return(simpleStatement);
}
/// <summary>
/// Get expression type
/// </summary>
public override Type GetExpressionType()
{
IMethodReferenceExpression imre = this.Method;
if (imre != null)
{
MethodInfo mi = (MethodInfo)imre.Method.MethodInfo;
return(mi.ReturnType);
}
return(null);
}
public object Invoke(IMethodReferenceExpression imre, object[] args)
{
object target = null;
if (!(imre.Target is ITypeReferenceExpression))
{
target = Evaluate(imre.Target);
}
MethodBase mb = Builder.ToMethod(imre.Method);
return(Util.Invoke(mb, target, args));
}
public override bool Equals(object obj)
{
if (this == obj)
{
return(true);
}
IMethodReferenceExpression expression = obj as IMethodReferenceExpression;
if (expression == null)
{
return(false);
}
return
(Method.Equals(expression.Method) &&
Target.Equals(expression.Target));
}
public override void VisitMethodReferenceExpression(IMethodReferenceExpression value)
{
bool hasThis = !value.Method.HasThis;
if (value.Target is IBinaryExpression)
{
_formatter.Write("(");
VisitExpression(value.Target);
_formatter.Write(")");
}
else if (hasThis)
{
_formatter.Write("[");
VisitExpression(value.Target);
_formatter.Write("]");
}
else
{
VisitExpression(value.Target);
}
_formatter.Write(hasThis ? "::" : ".");
VisitMethodReference(value.Method);
}
//===========================================================
// 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 VisitMethodReferenceExpression(IMethodReferenceExpression value)
{
VisitExpression(value.Target);
}
private static void WriteTryCatchFinally_try(LanguageWriter w, IBlockStatement _try) //,int skipCount
{
#if FUNC_TRY
if (skipCount == 0)
{
#endif
w.WriteKeyword("try");
w.Write(" {");
w.WriteLine();
w.WriteIndent();
#if FUNC_TRY
}
#endif
//
// try の中身
//
if (_try != null)
{
#if EXTRA_TEMP
IStatementCollection statementCollection = _try.Statements;
int i = 0;
foreach (IStatement state in _try.Statements)
{
#warning try: 何故スキップが入るのか?
// →コンストラクタ内で を全て delegation したから。
// ・delegation の検索は、最初に delegation が適用出来ない物が出た時に終了する
// 但し、その際に、ローカル変数 T var=xxx は無視している?
// ・最後の delegation が skipCount
if (i < skipCount)
{
i++;
IExpressionStatement state_exp = state as IExpressionStatement;
if (state_exp == null)
{
goto write;
}
IAssignExpression exp_assign = state_exp.Expression as IAssignExpression;
if (exp_assign != null)
{
// this 以外の物の field もスキップされてしまう...
if (exp_assign.Target is IFieldReferenceExpression)
{
continue;
}
goto write;
}
IMethodInvokeExpression exp_inv = state_exp.Expression as IMethodInvokeExpression;
if (exp_inv != null)
{
IMethodReferenceExpression method = exp_inv.Method as IMethodReferenceExpression;
if (method != null && method.Target is IBaseReferenceExpression)
{
continue;
}
goto write;
}
}
write:
WriteStatement(w, state);
}
#else
WriteBlock(w, _try);
#endif
}
w.WriteOutdent();
w.Write("}");
}
public virtual void VisitMethodReferenceExpression(IMethodReferenceExpression value)
{
this.VisitExpression(value.Target);
}
public CallExpression(IMethodReferenceExpression method)
{
Method = method;
}
private void WriteMethodReferenceExpression(IMethodReferenceExpression expression, IFormatter formatter)
{
// TODO bool escape = true;
if (expression.Target != null)
{ // TODO escape = false;
if (expression.Target is IBinaryExpression)
{
formatter.Write("(");
this.WriteExpression(expression.Target, formatter);
formatter.Write(")");
}
else
{
//formatter.WriteComment("/* " + expression.Target.GetType() + " */");
this.WriteTargetExpression(expression.Target, formatter);
}
formatter.Write(".");
}
this.WriteMethodReference(expression.Method, formatter);
}
public ISimpleStatement CallMethod(IMethodReferenceExpression method, params IExpression[] arguments)
{
return(this.Statements.CallMethod(method, arguments));
}
public abstract void TranslateExpression(IMethodReferenceExpression methodRefExpression);
public static bool IsCatchAllClause(ref IStatementCollection statements)
{
if (statements == null || statements.Count != 3)
{
return(false);
}
/* uint num1=0;*/ {
IAssignExpression exp_assign = GetAssignExpression(statements[0]);
if (exp_assign == null || null == GetVariableName(exp_assign.Target, "System", "UInt32"))
{
return(false);
}
ILiteralExpression exp_lit = exp_assign.Expression as ILiteralExpression;
if (exp_lit == null || (uint)exp_lit.Value != 0u)
{
return(false);
}
}
// 以下の二通りの場合がある (他にもあるかも知れない)
// (1) int num2=::__CxxRegisterExceptionObject((void*)Marshal::GetExceptionPointers(),(void*)num0);
// (2) ::__CxxRegisterExceptionObject((void*)Marshal::GetExceptionPointers(),(void*)num0);
// 更に __Cxx の部分は ___Cxx だったりもする
{
IExpressionStatement exp_state = statements[1] as IExpressionStatement;
if (exp_state == null)
{
return(false);
}
IMethodInvokeExpression exp_inv;
IAssignExpression exp_assign = exp_state.Expression as IAssignExpression;
if (exp_assign != null)
{
// (1) に挑戦
if (null == GetVariableName(exp_assign.Target, "System", "Int32"))
{
return(false);
}
exp_inv = exp_assign.Expression as IMethodInvokeExpression;
}
else
{
// (2) に挑戦
exp_inv = exp_state.Expression as IMethodInvokeExpression;
}
if (exp_inv == null || exp_inv.Arguments.Count != 2)
{
return(false);
}
IMethodReferenceExpression exp_mref = exp_inv.Method as IMethodReferenceExpression;
if (exp_mref == null || exp_mref.Method == null || exp_mref.Method.Name.TrimStart('_') != "CxxRegisterExceptionObject")
{
return(false);
}
}
// try{
// try{
// }catch when{}
// break;
// if(num!=0u)throw;
// }finally{
// ::__CxxUnregisterExceptionObject(esp0,num);
// }
ITryCatchFinallyStatement state_tcf = statements[2] as ITryCatchFinallyStatement;
{
// try{
if (state_tcf == null ||
state_tcf.Try == null || state_tcf.Try.Statements.Count != 3 ||
state_tcf.Finally == null || state_tcf.Finally.Statements.Count != 1
)
{
return(false);
}
// try{
// <statements>
// }catch when{}
ITryCatchFinallyStatement state_tcf2 = state_tcf.Try.Statements[0] as ITryCatchFinallyStatement;
if (state_tcf2 == null || state_tcf2.Try == null)
{
return(false);
}
// <break;goto;continue;return; 等>
// if(**!=**)throw;
IConditionStatement state_cond = state_tcf.Try.Statements[state_tcf.Try.Statements.Count - 1] as IConditionStatement;
if (state_cond == null || state_cond.Then.Statements.Count != 1)
{
return(false);
}
IBinaryExpression exp_bin = state_cond.Condition as IBinaryExpression;
if (exp_bin == null || exp_bin.Operator != BinaryOperator.ValueInequality)
{
return(false);
}
IThrowExceptionStatement state_exc = state_cond.Then.Statements[0] as IThrowExceptionStatement;
if (state_exc == null)
{
return(false);
}
// } finally {
// ::__CxxUnregisterExceptionObject((void*)num2,(int)num);
// }
IMethodInvokeExpression exp_inv = GetInvokeExpression(state_tcf.Finally.Statements[0]);
if (exp_inv == null || exp_inv.Arguments.Count != 2)
{
return(false);
}
IMethodReferenceExpression exp_mref = exp_inv.Method as IMethodReferenceExpression;
if (exp_mref == null || exp_mref.Method == null || exp_mref.Method.Name.TrimStart('_') != "CxxUnregisterExceptionObject")
{
return(false);
}
// <statements>
statements = state_tcf2.Try.Statements;
return(true);
}
}
private static bool DetectLocalRefVariable(string var_disposable, IStatement next, IStatement next2, out LocalRefVariableStatement ret_lrv)
{
ret_lrv = new LocalRefVariableStatement();
//-------------------------------------------------------
// 第二文
//-------------------------------------------------------
// try{
// ... // null-declarations
// var_name=var_disposable;
// ...
// }fault{
// var_name->Dispose();
// }
ITryCatchFinallyStatement state_next = next as ITryCatchFinallyStatement;
if (state_next == null ||
state_next.Try == null || state_next.Try.Statements.Count == 0 ||
state_next.Fault == null || state_next.Fault.Statements.Count != 1
)
{
return(false);
}
//
// null-declarations を飛ばす
//
int i_assign = 0;
IStatementCollection try_states = state_next.Try.Statements;
while (IsNullDeclaration(try_states[i_assign]))
{
if (++i_assign >= try_states.Count)
{
return(false);
}
}
//
// var_name=var_disposable の var_name を取得
//
IAssignExpression exp_assign = GetAssignExpression(state_next.Try.Statements[i_assign]);
if (exp_assign == null || var_disposable != GetVariableName(exp_assign.Expression))
{
return(false);
}
ret_lrv.var_name = GetVariableName(exp_assign.Target);
if (ret_lrv.var_name == null)
{
return(false);
}
//
// fault 内の形式の確認
//
{
// **->**();
IMethodInvokeExpression exp_inv = GetInvokeExpression(state_next.Fault.Statements[0]);
if (exp_inv == null || exp_inv.Arguments.Count != 0)
{
return(false);
}
// **->Dispose();
IMethodReferenceExpression method = exp_inv.Method as IMethodReferenceExpression;
if (method == null || method.Method == null || method.Method.Name != "Dispose")
{
return(false);
}
// disposable->Dispose();
if (ret_lrv.var_name != GetVariableName(method.Target))
{
return(false);
}
}
//-------------------------------------------------------
// 第三文
//-------------------------------------------------------
// "Label:"?
// var_name->Dispose();
//
ILabeledStatement labeled = next2 as ILabeledStatement;
if (labeled != null)
{
ret_lrv.labelname = labeled.Name;
next2 = labeled.Statement;
}
{
// **->**();
IMethodInvokeExpression exp_inv = GetInvokeExpression(next2);
if (exp_inv == null || exp_inv.Arguments.Count != 0)
{
return(false);
}
// **->Dispose();
IMethodReferenceExpression method = exp_inv.Method as IMethodReferenceExpression;
if (method == null || method.Method == null || method.Method.Name != "Dispose")
{
return(false);
}
// disposable->Dispose();
if (ret_lrv.var_name != GetVariableName(method.Target))
{
return(false);
}
}
ret_lrv.block = state_next.Try;
ret_lrv.block.Statements.RemoveAt(i_assign);
return(true);
}
//===========================================================
// 構文合致
//===========================================================
/// <summary>
///
/// </summary>
/// <param name="var_deleted">削除される予定の変数</param>
/// <param name="next_state">
/// 本当に削除命令なのかを確認する為に、次の文を指定。
/// if(disposable!=nullptr)disposable->Dispose(); なら OK
/// </param>
/// <returns>delete だったら true。そうでなかったら、false。</returns>
private static bool DetectDeleteStatement(string disposable_name, IStatement next_state)
{
//---------------------------------------------------
// if(disposable==nullptr)
//---------------------------------------------------
// if
IConditionStatement cond = next_state as IConditionStatement;
if (cond == null)
{
return(false);
}
// ==
IBinaryExpression exp_bin = cond.Condition as IBinaryExpression;
if (exp_bin == null || exp_bin.Operator != BinaryOperator.IdentityInequality)
{
return(false);
}
// disposable
IVariableReferenceExpression exp_var = exp_bin.Left as IVariableReferenceExpression;
if (exp_var == null || exp_var.Variable.Resolve().Name != disposable_name)
{
return(false);
}
// nullptr
ILiteralExpression exp_lit = exp_bin.Right as ILiteralExpression;
if (exp_lit == null || exp_lit.Value != null)
{
return(false);
}
//---------------------------------------------------
// disposable->Dispose();
//---------------------------------------------------
// 単文
IStatementCollection states_then = cond.Then.Statements;
if (states_then == null || states_then.Count != 1)
{
return(false);
}
IExpressionStatement state_exp = states_then[0] as IExpressionStatement;
if (state_exp == null)
{
return(false);
}
// **->**();
IMethodInvokeExpression exp_inv = state_exp.Expression as IMethodInvokeExpression;
if (exp_inv == null || exp_inv.Arguments.Count != 0)
{
return(false);
}
// **->Dispose();
IMethodReferenceExpression ref_dispose = exp_inv.Method as IMethodReferenceExpression;
if (ref_dispose == null || ref_dispose.Method.Name != "Dispose")
{
return(false);
}
// disposable->Dispose();
exp_var = ref_dispose.Target as IVariableReferenceExpression;
if (exp_var == null || exp_var.Variable.Resolve().Name != disposable_name)
{
return(false);
}
//---------------------------------------------------
// delete disposable
//---------------------------------------------------
return(true);
}
public static void WriteExpression(LanguageWriter w, IExpression exp, bool paren)
{
if (paren)
{
w.Write("(");
}
switch (GetExpressionType(exp))
{
case ExpressionType.AddressDereference:
WriteAddressDereference(w, (IAddressDereferenceExpression)exp);
break;
case ExpressionType.AddressOf:
w.Write("&");
WriteExpression(w, ((IAddressOfExpression)exp).Expression, false);
break;
case ExpressionType.AddressOut: // 引数 out 渡し
WriteExpression(w, ((IAddressOutExpression)exp).Expression, false);
break;
case ExpressionType.AddressReference: // 引数 ref 渡し
WriteExpression(w, ((IAddressReferenceExpression)exp).Expression, false);
break;
case ExpressionType.ArgumentList:
w.WriteKeyword("__arglist");
break;
case ExpressionType.ArgumentReference:
w.WriteParameterReference(((IArgumentReferenceExpression)exp).Parameter);
break;
case ExpressionType.ArrayCreate:
WriteArrayCreate(w, (IArrayCreateExpression)exp);
break;
case ExpressionType.ArrayIndexer:
WriteArrayIndexerExpression(w, (IArrayIndexerExpression)exp);
break;
case ExpressionType.Assign:
WriteAssign(w, (IAssignExpression)exp);
break;
case ExpressionType.BaseReference:
w.baseType.WriteName(w);
break;
case ExpressionType.Binary:
WriteBinary(w, (IBinaryExpression)exp);
break;
case ExpressionType.Block:
WriteBlock(w, (IBlockExpression)exp);
break;
case ExpressionType.CanCast:
WriteCanCast(w, (ICanCastExpression)exp);
break;
case ExpressionType.Cast:
WriteCast(w, (ICastExpression)exp);
break;
case ExpressionType.Condition:
WriteCondition(w, (IConditionExpression)exp);
break;
case ExpressionType.DelegateCreate:
WriteDelegateCreate(w, (IDelegateCreateExpression)exp);
break;
case ExpressionType.Literal:
w.WriteAsLiteral(((ILiteralExpression)exp).Value);
break;
case ExpressionType.MethodInvoke:
WriteMethodInvoke(w, (IMethodInvokeExpression)exp);
break;
case ExpressionType.ObjectCreate:
WriteObjectCreate(w, (IObjectCreateExpression)exp);
break;
case ExpressionType.SizeOf:
w.WriteKeyword("sizeof");
w.Write("(");
new TypeRef(((ISizeOfExpression)exp).Type).WriteName(w);
w.Write(")");
break;
case ExpressionType.Snippet:
w.WriteAsLiteral(((ISnippetExpression)exp).Value);
break;
case ExpressionType.ThisReference:
w.WriteKeyword("this");
break;
case ExpressionType.TryCast:
WriteTryCast(w, (ITryCastExpression)exp);
break;
case ExpressionType.TypeOf:
new TypeRef(((ITypeOfExpression)exp).Type).WriteName(w);
w.Write("::");
w.WriteKeyword("typeid");
break;
case ExpressionType.TypeReference:
WriteTypeReference(w, (ITypeReferenceExpression)exp);
break;
case ExpressionType.Unary:
WriteUnary(w, (IUnaryExpression)exp);
break;
case ExpressionType.VariableDeclaration:
WriteVariableDeclaration(w, ((IVariableDeclarationExpression)exp).Variable);
break;
case ExpressionType.VariableReference:
w.WriteVariableReference(((IVariableReferenceExpression)exp).Variable);
break;
case ExpressionType.MemberInitializer: // 属性の初期化の際のメンバ指定
WriteMemberInitializer(w, (IMemberInitializerExpression)exp);
break;
//---------------------------------------------------
// メンバアクセス
//---------------------------------------------------
case ExpressionType.EventReference:
WriteEventReference(w, (IEventReferenceExpression)exp);
break;
case ExpressionType.FieldReference:
IFieldReferenceExpression exp_fld = (IFieldReferenceExpression)exp;
WriteMemberAccess(w, exp_fld.Target);
w.WriteFieldReference(exp_fld.Field);
break;
case ExpressionType.PropertyReference:
WritePropertyReference(w, (IPropertyReferenceExpression)exp);
break;
case ExpressionType.PropertyIndexer:
IPropertyIndexerExpression exp_pind = (IPropertyIndexerExpression)exp;
WritePropertyReference(w, exp_pind.Target);
w.Write("[");
w.WriteExpressionCollection(exp_pind.Indices);
w.Write("]");
break;
case ExpressionType.MethodReference:
IMethodReferenceExpression exp_meth = (IMethodReferenceExpression)exp;
WriteMemberAccess(w, exp_meth.Target);
w.WriteMethodReference(exp_meth.Method);
break;
//---------------------------------------------------
// 代替
//---------------------------------------------------
case ExpressionType.StackAlloc:
WriteStackAllocate(w, (IStackAllocateExpression)exp);
break;
case ExpressionType.AnonymousMethod:
WriteAnonymousMethod(w, (IAnonymousMethodExpression)exp);
break;
//---------------------------------------------------
// 以下未対応
//---------------------------------------------------
case ExpressionType.NullCoalescing:
WriteBinaryNullCoalescing(w, (INullCoalescingExpression)exp);
break;
case ExpressionType.DelegateInvoke:
case ExpressionType.FieldOf:
case ExpressionType.GenericDefault:
case ExpressionType.Lambda:
case ExpressionType.MethodOf:
case ExpressionType.Query:
goto default;
case ExpressionType.TypedReferenceCreate:
case ExpressionType.TypeOfTypedReference:
case ExpressionType.ValueOfTypedReference:
//throw new System.NotImplementedException("未だ実装していません\r\n");
goto default;
case ExpressionType.Unknown:
default:
ThrowUnknownExpression(exp);
break;
}
if (paren)
{
w.Write(")");
}
}
public override void TranslateExpression(IMethodReferenceExpression methodRefExpression)
{
this.Provider.GenerateCodeFromExpression(methodRefExpression.GenerateCodeDom(this.Options), base.Target, this.Options.Options);
}
protected override IExpression ConvertMethodInvoke(IMethodInvokeExpression imie)
{
// Insert an Increment statement to support Sequential loops
// if we find the pattern:
// forwardExpr = ReplicateOp_Divide.UsesAverageConditional(backwardExpr[index], marginalExpr, index, forwardExpr)
// then when backwardExpr is updated, we insert the following statement:
// MarginalIncrement(marginalExpr, forwardExpr, backwardExpr[index]);
if (Recognizer.IsStaticMethod(imie, typeof(ReplicateOp_Divide), "UsesAverageConditional"))
{
IExpression backwardExpr = imie.Arguments[0];
object backwardDecl = Recognizer.GetArrayDeclaration(backwardExpr);
IExpression marginalExpr = imie.Arguments[1];
IExpression indexExpr = imie.Arguments[2];
IVariableDeclaration indexVar = Recognizer.GetVariableDeclaration(indexExpr);
IExpression forwardExpr = imie.Arguments[3];
if (indexVar != null && context.InputAttributes.Has <Sequential>(indexVar))
{
if (!compiler.UseSerialSchedules)
{
context.Warning(indexVar.Name + " is marked Sequential but engine.Compiler.UseSerialSchedules = false");
}
IMethodReferenceExpression imre = imie.Method;
ITypeReference itr = ((ITypeReferenceExpression)imre.Target).Type;
MethodInfo method = itr.DotNetType.GetMethod("MarginalIncrement");
method = method.MakeGenericMethod(imre.Method.MethodInfo.GetGenericArguments());
IExpression rhs = Builder.StaticGenericMethod(method, marginalExpr, forwardExpr, backwardExpr);
IStatement increment = Builder.AssignStmt(marginalExpr, rhs);
var seq = context.InputAttributes.Get <Sequential>(indexVar);
var attr = new IncrementStatement(indexVar, seq.BackwardPass);
context.OutputAttributes.Set(increment, attr);
onUpdate[backwardDecl] = increment;
}
}
// if we find the pattern:
// forwardExpr = Replicate2BufferOp.UsesAverageConditional(backwardExpr, *, marginalExpr, index, forwardExpr)
// then when backwardExpr is updated, we insert the following statement:
// marginalExpr = MarginalIncrement(marginalExpr, forwardExpr, backwardExpr[index]);
if (Recognizer.IsStaticMethod(imie, typeof(Replicate2BufferOp), "UsesAverageConditional"))
{
IExpression backwardExpr = imie.Arguments[0];
object backwardDecl = Recognizer.GetArrayDeclaration(backwardExpr);
IExpression marginalExpr = imie.Arguments[2];
IExpression indexExpr = imie.Arguments[3];
IVariableDeclaration indexVar = Recognizer.GetVariableDeclaration(indexExpr);
IExpression forwardExpr = imie.Arguments[4];
if (indexVar != null && context.InputAttributes.Has <Sequential>(indexVar))
{
if (!compiler.UseSerialSchedules)
{
context.Warning(indexVar.Name + " is marked Sequential but engine.Compiler.UseSerialSchedules = false");
}
IMethodReferenceExpression imre = imie.Method;
ITypeReference itr = ((ITypeReferenceExpression)imre.Target).Type;
MethodInfo method = itr.DotNetType.GetMethod("MarginalIncrement");
method = method.MakeGenericMethod(imre.Method.MethodInfo.GetGenericArguments());
IExpression rhs = Builder.StaticGenericMethod(method, marginalExpr, forwardExpr, Builder.ArrayIndex(backwardExpr, indexExpr));
IStatement increment = Builder.AssignStmt(marginalExpr, rhs);
var seq = context.InputAttributes.Get <Sequential>(indexVar);
var attr = new IncrementStatement(indexVar, seq.BackwardPass);
context.OutputAttributes.Set(increment, attr);
onUpdate[backwardDecl] = increment;
}
}
// if we find the pattern:
// forwardExpr = JaggedSubarrayOp<>.ItemsAverageConditional(backwardExpr[index], *, marginalExpr, indices, index, forwardExpr)
// then when backwardExpr is updated, we insert the following statement:
// MarginalIncrement(marginalExpr, forwardExpr, backwardExpr[index], indices, index)
if (Recognizer.IsStaticGenericMethod(imie, typeof(JaggedSubarrayOp <>), "ItemsAverageConditional"))
{
IExpression backwardExpr = imie.Arguments[0];
object backwardDecl = Recognizer.GetArrayDeclaration(backwardExpr);
IExpression marginalExpr = imie.Arguments[2];
IExpression indicesExpr = imie.Arguments[3];
IExpression indexExpr = imie.Arguments[4];
IVariableDeclaration indexVar = Recognizer.GetVariableDeclaration(indexExpr);
IExpression forwardExpr = imie.Arguments[5];
if (indexVar != null && context.InputAttributes.Has <Sequential>(indexVar))
{
if (!compiler.UseSerialSchedules)
{
context.Warning(indexVar.Name + " is marked Sequential but engine.Compiler.UseSerialSchedules = false");
}
IMethodReferenceExpression imre = imie.Method;
ITypeReference itr = ((ITypeReferenceExpression)imre.Target).Type;
IExpression[] args2 = new IExpression[] { marginalExpr, forwardExpr, backwardExpr, indicesExpr, indexExpr };
Type[] argTypes = Array.ConvertAll(args2, e => e.GetExpressionType());
Exception exception;
MethodInfo method = (MethodInfo)Reflection.Invoker.GetBestMethod(itr.DotNetType, "MarginalIncrement",
BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy, null, argTypes, out exception);
if (method == null)
{
Error("Cannot find a compatible MarginalIncrement method for JaggedSubarrayOp", exception);
}
else
{
IExpression rhs = Builder.StaticGenericMethod(method, args2);
IStatement increment = Builder.AssignStmt(marginalExpr, rhs);
var seq = context.InputAttributes.Get <Sequential>(indexVar);
var attr = new IncrementStatement(indexVar, seq.BackwardPass);
context.OutputAttributes.Set(increment, attr);
onUpdate[backwardDecl] = increment;
}
}
}
// if we find the pattern:
// forwardExpr = JaggedSubarrayWithMarginalOp<>.ItemsAverageConditional(backwardExpr[index], *, marginalExpr, indices, index, forwardExpr)
// then when backwardExpr is updated, we insert the following statement:
// MarginalIncrementItems(backwardExpr[index], forwardExpr, indices, index, marginalExpr)
if (Recognizer.IsStaticGenericMethod(imie, typeof(JaggedSubarrayWithMarginalOp <>), "ItemsAverageConditional"))
{
IExpression backwardExpr = imie.Arguments[0];
IExpression marginalExpr = imie.Arguments[2];
IExpression indicesExpr = imie.Arguments[3];
IExpression indexExpr = imie.Arguments[4];
IVariableDeclaration indexVar = Recognizer.GetVariableDeclaration(indexExpr);
IExpression forwardExpr = imie.Arguments[5];
if (indexVar != null && context.InputAttributes.Has <Sequential>(indexVar))
{
if (!compiler.UseSerialSchedules)
{
context.Warning(indexVar.Name + " is marked Sequential but engine.Compiler.UseSerialSchedules = false");
}
IMethodReferenceExpression imre = imie.Method;
ITypeReference itr = ((ITypeReferenceExpression)imre.Target).Type;
IExpression[] args2 = new IExpression[] { backwardExpr, forwardExpr, indicesExpr, indexExpr, marginalExpr };
Type[] argTypes = Array.ConvertAll(args2, e => e.GetExpressionType());
Exception exception;
MethodInfo method = (MethodInfo)Reflection.Invoker.GetBestMethod(itr.DotNetType, "MarginalIncrementItems",
BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy, null, argTypes, out exception);
if (method == null)
{
Error("Cannot find a compatible MarginalIncrementItems method for JaggedSubarrayWithMarginalOp", exception);
}
else
{
IExpression rhs = Builder.StaticGenericMethod(method, args2);
IStatement increment = Builder.AssignStmt(marginalExpr, rhs);
var seq = context.InputAttributes.Get <Sequential>(indexVar);
var attr = new IncrementStatement(indexVar, seq.BackwardPass);
context.OutputAttributes.Set(increment, attr);
object backwardDecl = Recognizer.GetArrayDeclaration(backwardExpr);
onUpdate[backwardDecl] = increment;
IVariableDeclaration marginalVar = Recognizer.GetVariableDeclaration(marginalExpr);
suppressUpdate[marginalVar] = attr;
}
var indicesVar = Recognizer.GetDeclaration(indicesExpr);
if (indicesVar != null)
{
DistributedCommunicationExpression dce = context.GetAttribute <DistributedCommunicationExpression>(indicesVar);
if (dce != null)
{
context.OutputAttributes.Set(imie, dce);
}
}
}
}
// if we find the pattern:
// backwardExpr = JaggedSubarrayWithMarginalOp<>.ArrayAverageConditional(forwardExpr, marginalExpr, backwardExpr)
// then when forwardExpr is updated, we insert the following statement:
// MarginalIncrementArray
if (Recognizer.IsStaticGenericMethod(imie, typeof(JaggedSubarrayWithMarginalOp <>), "ArrayAverageConditional"))
{
IExpression forwardExpr = imie.Arguments[0];
IExpression marginalExpr = imie.Arguments[1];
IExpression backwardExpr = imie.Arguments[2];
if (true)
{
IMethodReferenceExpression imre = imie.Method;
ITypeReference itr = ((ITypeReferenceExpression)imre.Target).Type;
IExpression[] args2 = new IExpression[] { forwardExpr, backwardExpr, marginalExpr };
Type[] argTypes = Array.ConvertAll(args2, e => e.GetExpressionType());
Exception exception;
MethodInfo method = (MethodInfo)Reflection.Invoker.GetBestMethod(itr.DotNetType, "MarginalIncrementArray",
BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy, null, argTypes, out exception);
if (method == null)
{
Error("Cannot find a compatible MarginalIncrementArray method for JaggedSubarrayWithMarginalOp", exception);
}
else
{
IExpression rhs = Builder.StaticGenericMethod(method, args2);
IStatement increment = Builder.AssignStmt(marginalExpr, rhs);
var attr = new IncrementStatement(null, false);
context.OutputAttributes.Set(increment, attr);
object forwardDecl = Recognizer.GetArrayDeclaration(forwardExpr);
onUpdate[forwardDecl] = increment;
}
IVariableDeclaration marginalVar = Recognizer.GetVariableDeclaration(marginalExpr);
// only suppress when we also have MarginalIncrementItems
//suppressUpdate.Add(marginalVar);
}
}
// if we find the pattern:
// forwardExpr = GetItemsOp<>.ItemsAverageConditional(backwardExpr[index], *, marginalExpr, indices, index, forwardExpr)
// then when backwardExpr is updated, we insert the following statement:
// MarginalIncrement(marginalExpr, forwardExpr, backwardExpr[index], indices, index)
if (Recognizer.IsStaticGenericMethod(imie, typeof(GetItemsOp <>), "ItemsAverageConditional") ||
Recognizer.IsStaticGenericMethod(imie, typeof(GetJaggedItemsOp <>), "ItemsAverageConditional") ||
Recognizer.IsStaticGenericMethod(imie, typeof(GetDeepJaggedItemsOp <>), "ItemsAverageConditional"))
{
IExpression backwardExpr = imie.Arguments[0];
object backwardDecl = Recognizer.GetArrayDeclaration(backwardExpr);
IExpression marginalExpr = imie.Arguments[2];
IExpression indicesExpr = imie.Arguments[3];
IExpression indexExpr = imie.Arguments[4];
IVariableDeclaration indexVar = Recognizer.GetVariableDeclaration(indexExpr);
IExpression forwardExpr = imie.Arguments[5];
if (indexVar != null && context.InputAttributes.Has <Sequential>(indexVar))
{
if (!compiler.UseSerialSchedules)
{
context.Warning(indexVar.Name + " is marked Sequential but engine.Compiler.UseSerialSchedules = false");
}
IMethodReferenceExpression imre = imie.Method;
ITypeReference itr = ((ITypeReferenceExpression)imre.Target).Type;
MethodInfo method = itr.GenericType.DotNetType.GetMethod("MarginalIncrement");
method = method.MakeGenericMethod(imre.Method.MethodInfo.GetGenericArguments());
IExpression rhs = Builder.StaticGenericMethod(method, marginalExpr, forwardExpr, backwardExpr, indicesExpr, indexExpr);
//IStatement increment = Builder.ExprStatement(rhs);
IStatement increment = Builder.AssignStmt(marginalExpr, rhs);
var seq = context.InputAttributes.Get <Sequential>(indexVar);
var attr = new IncrementStatement(indexVar, seq.BackwardPass);
context.OutputAttributes.Set(increment, attr);
onUpdate[backwardDecl] = increment;
}
}
// if we find the pattern:
// forwardExpr = GetItemsOp<>.ItemsAverageConditional(backwardExpr[index], *, marginalExpr, indices, index, forwardExpr)
// then when backwardExpr is updated, we insert the following statement:
// MarginalIncrement(marginalExpr, forwardExpr, backwardExpr[index], indices, index)
if (Recognizer.IsStaticGenericMethod(imie, typeof(GetItemsWithDictionaryOp <>), "ItemsAverageConditional"))
{
IExpression backwardExpr = imie.Arguments[0];
object backwardDecl = Recognizer.GetArrayDeclaration(backwardExpr);
IExpression marginalExpr = imie.Arguments[2];
IExpression indicesExpr = imie.Arguments[3];
IExpression dictExpr = imie.Arguments[4];
IExpression indexExpr = imie.Arguments[5];
IVariableDeclaration indexVar = Recognizer.GetVariableDeclaration(indexExpr);
IExpression forwardExpr = imie.Arguments[6];
if (indexVar != null && context.InputAttributes.Has <Sequential>(indexVar))
{
if (!compiler.UseSerialSchedules)
{
context.Warning(indexVar.Name + " is marked Sequential but engine.Compiler.UseSerialSchedules = false");
}
IMethodReferenceExpression imre = imie.Method;
ITypeReference itr = ((ITypeReferenceExpression)imre.Target).Type;
MethodInfo method = itr.GenericType.DotNetType.GetMethod("MarginalIncrement");
method = method.MakeGenericMethod(imre.Method.MethodInfo.GetGenericArguments());
IExpression rhs = Builder.StaticGenericMethod(method, marginalExpr, forwardExpr, backwardExpr, indicesExpr, dictExpr, indexExpr);
IStatement increment = Builder.AssignStmt(marginalExpr, rhs);
var seq = context.InputAttributes.Get <Sequential>(indexVar);
var attr = new IncrementStatement(indexVar, seq.BackwardPass);
context.OutputAttributes.Set(increment, attr);
onUpdate[backwardDecl] = increment;
}
}
// if we find the pattern:
// partialExpr = GetItemsOp2<>.Partial(backwardExpr[index], to_array, indices, index, partialExpr);
// then when backwardExpr is updated, we insert the following statement:
// to_array[indices[index]] = ArrayIncrement(partialExpr, backwardExpr[index])
if (Recognizer.IsStaticGenericMethod(imie, typeof(GetItemsOp2 <>), "Partial"))
{
IExpression backwardExpr = imie.Arguments[0];
object backwardDecl = Recognizer.GetArrayDeclaration(backwardExpr);
IExpression to_array = imie.Arguments[1];
IExpression indicesExpr = imie.Arguments[2];
IExpression indexExpr = imie.Arguments[3];
IVariableDeclaration indexVar = Recognizer.GetVariableDeclaration(indexExpr);
IExpression forwardExpr = imie.Arguments[4];
if (indexVar != null && context.InputAttributes.Has <Sequential>(indexVar))
{
if (!compiler.UseSerialSchedules)
{
context.Warning(indexVar.Name + " is marked Sequential but engine.Compiler.UseSerialSchedules = false");
}
IMethodReferenceExpression imre = imie.Method;
ITypeReference itr = ((ITypeReferenceExpression)imre.Target).Type;
MethodInfo method = itr.GenericType.DotNetType.GetMethod("ArrayIncrement");
method = method.MakeGenericMethod(imre.Method.MethodInfo.GetGenericArguments());
IExpression resultExpr = Builder.ArrayIndex(to_array, Builder.ArrayIndex(indicesExpr, indexExpr));
IExpression rhs = Builder.StaticGenericMethod(method, forwardExpr, backwardExpr, resultExpr);
IStatement increment = Builder.AssignStmt(resultExpr, rhs);
var seq = context.InputAttributes.Get <Sequential>(indexVar);
var attr = new IncrementStatement(indexVar, seq.BackwardPass);
context.OutputAttributes.Set(increment, attr);
onUpdate[backwardDecl] = increment;
}
}
// if we find the pattern:
// forwardExpr = GetItemsJaggedOp<>.ItemsAverageConditional(backwardExpr[index], *, marginalExpr, indices, indices2, index, forwardExpr)
// then when backwardExpr is updated, we insert the following statement:
// MarginalIncrement(marginalExpr, forwardExpr, backwardExpr[index], indices, indices2, index)
if (Recognizer.IsStaticGenericMethod(imie, typeof(GetItemsFromJaggedOp <>), "ItemsAverageConditional"))
{
IExpression backwardExpr = imie.Arguments[0];
object backwardDecl = Recognizer.GetArrayDeclaration(backwardExpr);
IExpression marginalExpr = imie.Arguments[2];
IExpression indicesExpr = imie.Arguments[3];
IExpression indices2Expr = imie.Arguments[4];
IExpression indexExpr = imie.Arguments[5];
IVariableDeclaration indexVar = Recognizer.GetVariableDeclaration(indexExpr);
IExpression forwardExpr = imie.Arguments[6];
if (indexVar != null && context.InputAttributes.Has <Sequential>(indexVar))
{
if (!compiler.UseSerialSchedules)
{
context.Warning(indexVar.Name + " is marked Sequential but engine.Compiler.UseSerialSchedules = false");
}
IMethodReferenceExpression imre = imie.Method;
ITypeReference itr = ((ITypeReferenceExpression)imre.Target).Type;
MethodInfo method = itr.GenericType.DotNetType.GetMethod("MarginalIncrement");
method = method.MakeGenericMethod(imre.Method.MethodInfo.GetGenericArguments());
IExpression rhs = Builder.StaticGenericMethod(method, marginalExpr, forwardExpr, backwardExpr, indicesExpr, indices2Expr, indexExpr);
IStatement increment = Builder.AssignStmt(marginalExpr, rhs);
var seq = context.InputAttributes.Get <Sequential>(indexVar);
var attr = new IncrementStatement(indexVar, seq.BackwardPass);
context.OutputAttributes.Set(increment, attr);
onUpdate[backwardDecl] = increment;
}
}
// if we find the pattern:
// forwardExpr = GetItemsDeepJaggedOp<>.ItemsAverageConditional(backwardExpr[index], *, marginalExpr, indices, indices2, indices3, index, forwardExpr)
// then when backwardExpr is updated, we insert the following statement:
// MarginalIncrement(marginalExpr, forwardExpr, backwardExpr[index], indices, indices2, indices3, index)
if (Recognizer.IsStaticGenericMethod(imie, typeof(GetItemsFromDeepJaggedOp <>), "ItemsAverageConditional"))
{
IExpression backwardExpr = imie.Arguments[0];
object backwardDecl = Recognizer.GetArrayDeclaration(backwardExpr);
IExpression marginalExpr = imie.Arguments[2];
IExpression indicesExpr = imie.Arguments[3];
IExpression indices2Expr = imie.Arguments[4];
IExpression indices3Expr = imie.Arguments[5];
IExpression indexExpr = imie.Arguments[6];
IVariableDeclaration indexVar = Recognizer.GetVariableDeclaration(indexExpr);
IExpression forwardExpr = imie.Arguments[7];
if (indexVar != null && context.InputAttributes.Has <Sequential>(indexVar))
{
if (!compiler.UseSerialSchedules)
{
context.Warning(indexVar.Name + " is marked Sequential but engine.Compiler.UseSerialSchedules = false");
}
IMethodReferenceExpression imre = imie.Method;
ITypeReference itr = ((ITypeReferenceExpression)imre.Target).Type;
MethodInfo method = itr.GenericType.DotNetType.GetMethod("MarginalIncrement");
method = method.MakeGenericMethod(imre.Method.MethodInfo.GetGenericArguments());
IExpression rhs = Builder.StaticGenericMethod(method, marginalExpr, forwardExpr, backwardExpr, indicesExpr, indices2Expr, indices3Expr, indexExpr);
IStatement increment = Builder.AssignStmt(marginalExpr, rhs);
var seq = context.InputAttributes.Get <Sequential>(indexVar);
var attr = new IncrementStatement(indexVar, seq.BackwardPass);
context.OutputAttributes.Set(increment, attr);
onUpdate[backwardDecl] = increment;
}
}
return(base.ConvertMethodInvoke(imie));
}
public override IOperation VisitMethodReferenceExpression(IMethodReferenceExpression operation, object argument)
{
return(new MethodReferenceExpression(operation.Method, operation.IsVirtual, Visit(operation.Instance), operation.Member, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
public virtual void VisitMethodReferenceExpression(IMethodReferenceExpression operation)
{
DefaultVisit(operation);
}
public MethodInvokeExpression(IMethodReferenceExpression method, List <IExpression> arguments)
{
_method = method;
_arguments = arguments;
}
public virtual void VisitMethodReferenceExpression(IMethodReferenceExpression e)
{
}
public NewDelegateExpression(IType type, IMethodReferenceExpression method)
{
DelegateType = type;
Method = method;
}
public MethodInvokeExpression(IMethodReferenceExpression reference, IExpressionCollection argumentExpressions)
{
this.reference = reference;
this.argumentExpressions = argumentExpressions;
}
public virtual IExpression TransformMethodReferenceExpression(IMethodReferenceExpression value)
{
value.Target = this.TransformExpression(value.Target);
return value;
}
