protected override IPyStatement[] VisitLocalDeclarationStatement(LocalDeclarationStatement src)
{
var s = new List <IPyStatement>();
foreach (var i in src.Declaration.Declarators)
{
// to jest przypadek z c# 'int x;', dla Py można to pominąć
if (i.Value == null)
{
continue;
}
if (i.Value is UnknownIdentifierValue)
{
throw new NotImplementedException();
}
var l = new PyVariableExpression(i.Name, PyVariableKind.Local);
var r = TransValue(i.Value);
var tt = new PyAssignExpression(l, r);
s.Add(new PyExpressionStatement(tt));
//var r = new PyAssignVariable( PyVariableExpression.AddDollar(i.Name), false );
//// r.Name = "$" + i.Name;
//r.Value = TV(i.Value);
//s.Add(r);
}
return(s.ToArray());
}
protected virtual T VisitPyAssignExpression(PyAssignExpression node)
{
if (ThrowNotImplementedException)
{
throw new NotImplementedException(string.Format("Method {0} is not supported in class {1}", "VisitPyAssignExpression", this.GetType().FullName));
}
return(default(T));
}
protected override IPyStatement[] VisitVariableDeclaration(VariableDeclaration src)
{
//throw new Exception("DELETE THIS ??????");
var s = new List <IPyStatement>();
foreach (var i in src.Declarators)
{
var l = new PyVariableExpression(i.Name, PyVariableKind.Local);
var r = TransValue(i.Value);
var tt = new PyAssignExpression(l, r);
s.Add(new PyExpressionStatement(tt));
//var r = new PyAssignVariable(PyVariableExpression.AddDollar(i.Name), false);
//r.Value = TV(i.Value);
//s.Add(r);
}
return(s.ToArray());
}
protected override IPyValue VisitAssignExpression(CsharpAssignExpression src)
{
var l = TransValue(src.Left);
var r = TransValue(src.Right);
var op = src.OptionalOperator;
if (op == "+")
{
var vt = (src as IValue).ValueType;
if (vt == typeof(string))
{
op = ".";
}
}
var a = new PyAssignExpression(l, r, op);
return(SimplifyPyExpression(a));
}
private void TranslateField(PyCodeModule module, PyClassDefinition pyClass, FieldDeclaration field)
{
PyValueTranslator pyValueTranslator = null;
foreach (var item in field.Items)
{
if (item.OptionalFieldInfo == null)
{
continue;
}
var fti = Info.GetOrMakeTranslationInfo(item.OptionalFieldInfo);
switch (fti.Destination)
{
case FieldTranslationDestionations.DefinedConst:
if (item.Value == null)
{
throw new NotSupportedException();
}
if (pyValueTranslator == null)
{
pyValueTranslator = new PyValueTranslator(_state);
}
var definedValue = pyValueTranslator.TransValue(item.Value);
{
if (fti.IncludeModule != module.ModuleName)
{
module = GetOrMakeModuleByName(fti.IncludeModule);
}
}
module.DefinedConsts.Add(new KeyValuePair <string, IPyValue>(fti.ScriptName, definedValue));
break;
case FieldTranslationDestionations.GlobalVariable:
if (item.Value != null)
{
IPyValue value;
// muszę na chwilę wyłączyć current type, bo to jes poza klasą generowane
{
var saveCurrentType = _state.Principles.CurrentType;
_state.Principles.CurrentType = null;
try
{
if (pyValueTranslator == null)
{
pyValueTranslator = new PyValueTranslator(_state);
}
value = pyValueTranslator.TransValue(item.Value);
}
finally
{
_state.Principles.CurrentType = saveCurrentType;
}
}
var assign = new PyAssignExpression(PyVariableExpression.MakeGlobal(fti.ScriptName),
value);
module.TopCode.Statements.Add(new PyExpressionStatement(assign));
}
break;
case FieldTranslationDestionations.JustValue:
continue; // don't define
case FieldTranslationDestionations.NormalField:
case FieldTranslationDestionations.ClassConst:
{
var def = new PyClassFieldDefinition(fti.ScriptName, field.Type.DotnetType);
var cti = _state.Principles.GetTi(_state.Principles.CurrentType, true);
if (cti.IsArray)
{
continue;
}
if (field.Modifiers.Has("const") ^
(fti.Destination == FieldTranslationDestionations.ClassConst))
{
throw new Exception("beige lion");
}
def.IsConst =
fti.Destination ==
FieldTranslationDestionations.ClassConst; // field.Modifiers.Has("const");
def.IsStatic = def.IsConst || field.Modifiers.Has("static");
if (field.Modifiers.Has("public"))
{
def.Visibility = Visibility.Public;
}
else if (field.Modifiers.Has("protected"))
{
def.Visibility = Visibility.Protected;
}
else
{
def.Visibility = Visibility.Private;
}
if (item.Value != null)
{
if (pyValueTranslator == null)
{
pyValueTranslator = new PyValueTranslator(_state);
}
var value = pyValueTranslator.TransValue(item.Value);
/*
* if (!(value is PyConstValue))
* {
* // converts to value
* value = ExpressionEvaluator.Evaluate(value);
* // dificult to translate-move values to additional class
* // var t = new RefactorByMovingToAnotherClass();
* //value = t.ConvertAndRefactor(value);
* }
*
*/
def.ConstValue = value;
}
pyClass.Fields.Add(def);
break;
}
default:
throw new NotSupportedException();
}
}
}
/// <summary>
/// Creates expression based on DirectCallAttribute
/// </summary>
/// <param name="ctx"></param>
/// <param name="directCallAttribute"></param>
/// <param name="targetObject"></param>
/// <param name="arguments"></param>
/// <returns></returns>
public static IPyValue CreateExpressionFromDirectCallAttribute(IExternalTranslationContext ctx, DirectCallAttribute directCallAttribute, IValue targetObject, FunctionArgument[] arguments, MethodBase methodInfo)
{
if (directCallAttribute.CallType == MethodCallStyles.Static)
{
throw new NotSupportedException();
}
if (directCallAttribute.MemberToCall != ClassMembers.Method)
{
throw new NotSupportedException();
}
if (string.IsNullOrEmpty(directCallAttribute.Name))
{
var ma = directCallAttribute.MapArray;
if (ma.Length != 1)
{
throw new NotSupportedException("gray horse 1");
}
if (ma[0] == DirectCallAttribute.This)
{
if (targetObject == null)
{
throw new NotSupportedException("gray horse 2");
}
return(ctx.TranslateValue(targetObject));
}
// return PyMethod.Arguments[ma[0]].Expression
return(ctx.TranslateValue(arguments[ma[0]].MyValue));
}
var name = directCallAttribute.Name;
var PyMethod = new PyMethodCallExpression(name);
if (directCallAttribute.CallType == MethodCallStyles.Instance)
{
if (targetObject == null)
{
throw new NotSupportedException("gray horse 3");
}
PyMethod.TargetObject = ctx.TranslateValue(targetObject);
}
{
List <int> skipRefIndexList = null;
if (methodInfo != null)
{
var skipRefOrOutArray = directCallAttribute.SkipRefOrOutArray;
if (skipRefOrOutArray.Any())
{
var parameters = methodInfo.GetParameters();
for (var index = 0; index < parameters.Length; index++)
{
if (!skipRefOrOutArray.Contains(parameters[index].Name))
{
continue;
}
if (skipRefIndexList == null)
{
skipRefIndexList = new List <int>();
}
skipRefIndexList.Add(index);
}
}
}
CopyArguments(ctx, arguments, PyMethod, skipRefIndexList);
}
if (directCallAttribute.HasMapping)
{
var PyArguments = PyMethod.Arguments.ToArray();
PyMethod.Arguments.Clear();
foreach (var argNr in directCallAttribute.MapArray)
{
if (argNr == DirectCallAttribute.This)
{
if (targetObject == null)
{
throw new NotSupportedException();
}
var v = ctx.TranslateValue(targetObject);
PyMethod.Arguments.Add(new PyMethodInvokeValue(v));
}
else
{
if (argNr < PyArguments.Length)
{
PyMethod.Arguments.Add(PyArguments[argNr]);
}
}
}
}
if (directCallAttribute.OutNr >= 0)
{
var nr = directCallAttribute.OutNr;
var movedExpression = PyMethod.Arguments[nr].Expression;
PyMethod.Arguments.RemoveAt(nr);
var a = new PyAssignExpression(movedExpression, PyMethod);
return(a);
}
return(PyMethod);
}
