private void Tranlate_MethodOrProperty(PyCodeModule pyModule, [CanBeNull] PyClassDefinition pyClass,
MethodInfo info, IStatement body,
string overrideName)
{
_state.Principles.CurrentMethod = info;
try
{
var mti = _state.Principles.GetOrMakeTranslationInfo(info);
var pyMethod =
new PyClassMethodDefinition(string.IsNullOrEmpty(overrideName) ? mti.ScriptName : overrideName);
if (pyClass == null)
{
pyModule.Methods.Add(pyMethod);
pyMethod.Kind = PyMethodKind.OutOfClass;
}
else
{
pyClass.Methods.Add(pyMethod);
pyMethod.Kind = info.IsStatic ? PyMethodKind.ClassStatic : PyMethodKind.ClassInstance;
}
if (info.IsPublic)
{
pyMethod.Visibility = Visibility.Public;
}
else if (info.IsPrivate)
{
pyMethod.Visibility = Visibility.Private;
}
else
{
pyMethod.Visibility = Visibility.Protected;
}
{
var declaredParameters = info.GetParameters();
foreach (var parameter in declaredParameters)
{
var pyParameter = new PyMethodArgument
{
Name = parameter.Name
};
pyMethod.Arguments.Add(pyParameter);
if (parameter.HasDefaultValue)
{
pyParameter.DefaultValue = new PyConstValue(parameter.DefaultValue);
}
}
}
if (body != null)
{
pyMethod.Statements.AddRange(TranslateStatement(body));
}
}
finally
{
_state.Principles.CurrentMethod = null;
}
}
private void TranslateMethod(PyCodeModule pyModule, [CanBeNull] PyClassDefinition pyClass, MethodDeclaration md)
{
if (pyClass == null)
{
if (!md.Info.IsStatic)
{
throw new Exception(
$"Unable to translate {md.Info} method: Module class can contain only static methods");
}
}
Tranlate_MethodOrProperty(pyModule, pyClass, md.Info, md.Body, null);
}
/// <summary>
/// Gets existing or creates code module for given name
/// </summary>
/// <param name="requiredModuleName"></param>
/// <returns></returns>
private PyCodeModule GetOrMakeModuleByName(PyCodeModuleName requiredModuleName)
{
var mod = Modules.FirstOrDefault(i => i.ModuleName == requiredModuleName);
if (mod != null)
{
return(mod);
}
mod = new PyCodeModule(requiredModuleName);
Modules.Add(mod);
return(mod);
}
private static string AppendImportModuleCodeRequest(PyCodeModuleName import, PyCodeModule targetModule,
IModuleAliasResolver aliasResolver)
{
// returns alias
if (import == targetModule.ModuleName)
{
return(null);
}
var includePath = import.GetImportPath(targetModule.ModuleName);
if (string.IsNullOrEmpty(includePath))
{
return(null);
}
var alias = aliasResolver.FindModuleAlias(import);
return(targetModule.AddRequiredFile(includePath, alias));
}
private void TranslateProperty(PyCodeModule pyModule, [CanBeNull] PyClassDefinition pyClassDefinition,
CsharpPropertyDeclaration propertyDeclaration)
{
var pi = _state.Principles.CurrentType.GetProperty(propertyDeclaration.PropertyName);
var pti = PropertyTranslationInfo.FromPropertyInfo(pi);
if (pti.GetSetByMethod)
{
CsharpPropertyDeclarationAccessor accessor;
if (!string.IsNullOrEmpty(pti.GetMethodName))
{
accessor = propertyDeclaration.Accessors.FirstOrDefault(u => u.Name == "get");
if (accessor != null)
{
Tranlate_MethodOrProperty(pyModule, pyClassDefinition, pi.GetGetMethod(), accessor.Statement,
pti.GetMethodName);
}
}
if (string.IsNullOrEmpty(pti.SetMethodName))
{
return;
}
accessor = propertyDeclaration.Accessors.FirstOrDefault(u => u.Name == "set");
if (accessor != null)
{
Tranlate_MethodOrProperty(pyModule, pyClassDefinition, pi.GetSetMethod(), accessor.Statement,
pti.SetMethodName);
}
}
else
{
pyClassDefinition.Fields.Add(new PyClassFieldDefinition(pti.FieldScriptName, propertyDeclaration.Type.DotnetType)
{
IsStatic = pti.IsStatic
});
}
}
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();
}
}
}
private void TranslateClass_AddModuleRequests(ClassTranslationInfo classTranslationInfo, PyCodeModule pyModule)
{
var moduleCodeRequests = new List <DependsOnModuleCodeRequest>();
var codeRequests = (pyModule as ICodeRelated).GetCodeRequests().ToArray();
{
var classCodeRequests = (from request in codeRequests.OfType <ClassCodeRequest>()
select request.ClassName.FullName)
.Distinct()
.ToArray();
foreach (var req in classCodeRequests)
{
var m = Info.ClassTranslations.Values.Where(i => i.PyName.FullName == req).ToArray();
if (m.Length != 1)
{
throw new NotSupportedException();
}
var mm = m[0];
if (mm.DontIncludeModuleForClassMembers)
{
continue;
}
var includeModule = mm.IncludeModule;
if (includeModule == null || mm.ModuleName == pyModule.ModuleName)
{
continue;
}
var h = new DependsOnModuleCodeRequest(includeModule, "class request: " + req);
moduleCodeRequests.Add(h);
}
}
{
// converts DependsOnModuleCodeRequest
var moduleRequests = (from i in codeRequests.OfType <DependsOnModuleCodeRequest>()
where i.ModuleName != null
select i).Concat(moduleCodeRequests).ToArray();
if (moduleRequests.Any())
{
foreach (var mReq in moduleRequests)
{
var ati = Info.GetOrMakeTranslationInfo(classTranslationInfo.Type.Assembly);
if (mReq.ModuleName == null || mReq.ModuleName == pyModule.ModuleName)
{
continue;
}
var usedAliasWhileImport = AppendImportModuleCodeRequest(mReq.ModuleName, pyModule, ati);
mReq.UseAlias = usedAliasWhileImport;
}
}
}
}
