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; } } } }