public override IPyValue TranslateToPython(IExternalTranslationContext ctx, CsharpMethodCallExpression src)
{
var dt = src.GenericDeclaringType;
if (!IsDictionary(dt))
{
return(null);
}
switch (src.MethodName)
{
case nameof(DictionaryReplacer <int, int> .Remove):
// del myDict['key']
var args = MapNamedParameters(src);
var key = ctx.TranslateValue(args.GetArgumentValue(0));
var target = ctx.TranslateValue(src.TargetObject);
IPyValue arg = new PyArrayAccessExpression(target, key);
var m = new PyMethodCallExpression("del", arg);
m.OnSkipBracketRequest += (mce, args2) =>
{
args2.CanSkipBrackets = GeneralRulesForMetodBrackets.Bla(mce);
};
return(m);
}
return(null);
}
protected override IPyValue VisitInstanceFieldAccessExpression(InstanceFieldAccessExpression src)
{
var fti = _state.Principles.GetOrMakeTranslationInfo(src.Member);
var to = TransValue(src.TargetObject);
if (src.Member.DeclaringType.IsDefined(typeof(AsArrayAttribute)))
{
switch (fti.Destination)
{
case FieldTranslationDestionations.NormalField:
IPyValue index;
if (fti.IsScriptNamePyEncoded)
{
index = PyConstValue.FromPyValue(fti.ScriptName);
}
else
{
index = new PyConstValue(fti.ScriptName);
}
var tmp = new PyArrayAccessExpression(to, index);
return(SimplifyPyExpression(tmp));
case FieldTranslationDestionations.DefinedConst:
break; // obsłużę to dalej jak dla zwykłej klasy
default:
throw new NotSupportedException();
}
}
var a = new PyInstanceFieldAccessExpression(fti.ScriptName, to, fti.IncludeModule);
return(a);
}
protected virtual T VisitPyArrayAccessExpression(PyArrayAccessExpression node)
{
if (ThrowNotImplementedException)
{
throw new NotImplementedException(string.Format("Method {0} is not supported in class {1}", "VisitPyArrayAccessExpression", this.GetType().FullName));
}
return(default(T));
}
protected override IPyValue VisitInstancePropertyAccessExpression(CsharpInstancePropertyAccessExpression src)
{
var pri = PropertyTranslationInfo.FromPropertyInfo(src.Member);
var ownerInfo = _state.Principles.GetOrMakeTranslationInfo(src.Member.DeclaringType);
if (src.TargetObject == null)
{
throw new NotImplementedException("statyczny");
}
var translatedByExternalNodeTranslator = _state.Principles.NodeTranslators.Translate(_state, src);
if (translatedByExternalNodeTranslator != null)
{
return(SimplifyPyExpression(translatedByExternalNodeTranslator));
}
var pyTargetObject = TransValue(src.TargetObject);
if (ownerInfo.IsArray)
{
var idx = new PyConstValue(pri.FieldScriptName);
var arrayExpr = new PyArrayAccessExpression(pyTargetObject, idx);
return(arrayExpr);
}
{
var propertyInfo = src.Member;
var classReplacer = _state.FindOneClassReplacer(propertyInfo.DeclaringType);
if (classReplacer != null)
{
var newPropertyInfo = classReplacer.ReplaceBy.GetProperty(src.Member.Name,
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (newPropertyInfo == null)
{
throw new Exception(string.Format("Klasa {0} nie zawiera własności {1}",
classReplacer.ReplaceBy, src.Member));
}
if (newPropertyInfo.GetIndexParameters().Length > 0)
{
throw new NotSupportedException("energetic gecko, Property with index");
}
propertyInfo = newPropertyInfo;
}
{
var ats = propertyInfo.GetCustomAttribute <DirectCallAttribute>(true);
if (ats != null)
{
if (string.IsNullOrEmpty(ats.Name))
{
var tmp = ats.MapArray;
if (tmp == null || tmp.Length <= 0)
{
return(pyTargetObject);
}
if (tmp.Length > 1 || tmp[0] != DirectCallAttribute.This)
{
throw new NotSupportedException(string.Format(
"Property {1}.{0} has invalid 'Map' parameter in DirectCallAttribute",
propertyInfo.Name, propertyInfo.DeclaringType));
}
return(pyTargetObject);
}
switch (ats.MemberToCall)
{
case ClassMembers.Method:
if (ats.Name == "this")
{
return(pyTargetObject);
}
var pyMethodCall = new PyMethodCallExpression(ats.Name);
switch (ats.CallType)
{
case MethodCallStyles.Procedural:
pyMethodCall.Arguments.Add(new PyMethodInvokeValue(pyTargetObject));
return(pyMethodCall);
case MethodCallStyles.Instance:
pyMethodCall.TargetObject = pyTargetObject;
return(pyMethodCall);
}
throw new NotImplementedException();
case ClassMembers.Field:
switch (ats.CallType)
{
case MethodCallStyles.Instance:
if (ats.Name == "this")
{
return(pyTargetObject);
}
var includeModule = ownerInfo.IncludeModule;
var field = new PyInstanceFieldAccessExpression(ats.Name,
pyTargetObject,
includeModule);
return(field);
default:
throw new NotSupportedException();
}
//var f = new PyMethodCallExpression(ats.Name);
//method.Arguments.Add(new PyMethodInvokeValue(PyTargetObject));
//return method;
default:
throw new NotSupportedException();
}
}
}
{
var ats = propertyInfo.GetCustomAttribute <UseBinaryExpressionAttribute>(true);
if (ats != null)
{
var left = GetValueForExpression(pyTargetObject, ats.Left);
var right = GetValueForExpression(pyTargetObject, ats.Right);
var method = new PyBinaryOperatorExpression(ats.Operator, left, right);
return(method);
}
}
{
pri = PropertyTranslationInfo.FromPropertyInfo(src.Member);
var to = TransValue(src.TargetObject);
var a = new PyPropertyAccessExpression(pri, to);
return(a);
}
}
}
