public ShellEnumOptionsGenerator(string shortTypeName, CsNamespace targetNamespace, [CanBeNull] ShellEnumOptions enumOptions) { ShortTypeName = shortTypeName; TargetNamespace = targetNamespace; EnumOptions = enumOptions; }
private static void AddEnumToOutput(string[] parts, CsNamespace ns, CsEnum en) { if (!parts.Any()) { ns.AddEnum(en); return; } CsClass cl = null; foreach (var ii in parts) { CsClass newClass; if (cl is null) { newClass = ns.GetOrCreateClass(ii); } else { newClass = cl.GetOrCreateNested(ii); } cl = newClass; } throw new NotSupportedException("Need nested enum which is not supported by isukces.code yet"); }
private static string getNamespace(CsNamespace pNamespace) { string name = pNamespace.qualified_identifier.Aggregate(string.Empty, (pCurrent, pIdentifier) => pCurrent + (pIdentifier.identifier.identifier + ".")); return(name.Substring(0, name.Length - 1)); }
public void Parse(CsNamespace pNameSpace, IEnumerable<CsUsingDirective> pUsing, string pOutputFolder) { if (pNameSpace == null) { return; } _outputFolder = pOutputFolder; string name = getNamespace(pNameSpace); string packDir = pOutputFolder + name.Replace('.', '\\'); Directory.CreateDirectory(packDir); CodeBuilder builder = new CodeBuilder(); foreach (CsNode cn in pNameSpace.member_declarations) { builder.Append("package "); builder.Append(name); builder.AppendLineAndIndent(" {"); StringBuilder usings = new StringBuilder(); parseUsing(pUsing, usings); parseUsing(pNameSpace.using_directives, usings); Using = usings.ToString(); builder.Append(usings); builder.AppendLine(ClassParser.IMPORT_MARKER); ImportStatementList.Init(); CsClass csClass = cn as CsClass; if (csClass != null) { ClassParser.Parse(csClass, builder, _creator); if (ClassParser.IsExtension) { File.WriteAllText(packDir + "\\" + ClassParser.ExtensionName + ".as", builder.ToString()); } else { File.WriteAllText(packDir + "\\" + csClass.identifier.identifier + ".as", builder.ToString()); } builder.Length = 0; continue; } CsInterface csInterface = cn as CsInterface; if (csInterface != null) { InterfaceParser.Parse(csInterface, builder, _creator); File.WriteAllText(packDir + "\\" + csInterface.identifier.identifier + ".as", builder.ToString()); builder.Length = 0; continue; } if (csClass == null) { throw new Exception("Unknown type"); } } }
/// <summary> /// Gets the C# namespace by its name and its assembly name. /// </summary> /// <param name="assemblyName">Name of the assembly.</param> /// <param name="namespaceName">Name of the namespace.</param> /// <returns>A C# namespace</returns> public CsNamespace GetOrCreateNamespace(string namespaceName) { if (_namespaces.TryGetValue(namespaceName, out var selectedNamespace)) { return(selectedNamespace); } selectedNamespace = new CsNamespace(namespaceName); _namespaces.Add(namespaceName, selectedNamespace); return(selectedNamespace); }
/// <summary> /// Gets the C# namespace by its name and its assembly name. /// </summary> /// <param name="assemblyName">Name of the assembly.</param> /// <param name="namespaceName">Name of the namespace.</param> /// <returns>A C# namespace</returns> public CsNamespace GetOrCreateNamespace(string assemblyName, string namespaceName) { if (assemblyName == null) { assemblyName = namespaceName; } var selectedAssembly = GetOrCreateAssembly(assemblyName); var selectedCsNamespace = selectedAssembly.Namespaces.FirstOrDefault(nameSpaceObject => nameSpaceObject.Name == namespaceName); if (selectedCsNamespace == null) { selectedCsNamespace = new CsNamespace(namespaceName); selectedAssembly.Add(selectedCsNamespace); } return(selectedCsNamespace); }
public Oid() { _dna = new CsCompileUnit(); CsNamespace ns = new CsNamespace(new CsIdentifier("System")); CsUsing u1 = new CsUsing(ns); _dna.Usings.Usings.Add(u1); CsNamespace cn = new CsNamespace(new CsIdentifier(ECsNames.Namespace)); _dna.UnitMembers.Members.Add(cn); CsClass cl = new CsClass(); ((ICsModifiersProvider)cl).Modifiers = null; ((ICsClass)cl).ClassName = new CsIdentifier("Program"); cn.NamespaceMembers.Members.Add(cl); CsMethod m1 = new CsMethod(new CsIdentifier("Main"), null, null, null, null, null, null, null, null); ((ICsModifiersProvider)m1).Modifiers = new CsModifiers(ECsModifiers.Static); ((ICsMethod)m1).TypeResult = new CsTypeReference(new CsVoid()); cl.Body.Members.Add(m1); CsMethod m2 = new CsMethod((new CsIdentifier("WriteLine")), null, null, null, null, null, null, null, null); CsExpressionCall cm1 = new CsExpressionCall(new CsMethodReference(m2), null); CsExpressionLiteral l1 = new CsExpressionLiteral(new CsLiteralString("message")); CsArgument a1 = new CsArgument(null, l1); ((ICsArgument)a1).ArgumentInitialisationType = ECsInitialisationType.Expression; cm1.Arguments.Arguments.Add(a1); CsExpressionName n1 = new CsExpressionName("Console"); CsExpressionType t1 = new CsExpressionType(new CsTypeReference(typeof(System.Console), ECsReflectInfoStatus.ExternalDll), null); CsExpressionQualifiedExpression e1 = new CsExpressionQualifiedExpression(t1, cm1); ((ICsExpressionQualifiedExpression)e1).Access = ECsObjectAccess.Reference; CsStatementExpression s1 = new CsStatementExpression(e1); m1.Body.Statements.Statements.Add(s1); CsMethod m3 = new CsMethod(new CsIdentifier("ReadLine"), null, null, null, null, null, null, null, null); CsExpressionCall cm2 = new CsExpressionCall(new CsMethodReference(m3), null); CsExpressionQualifiedExpression e2 = new CsExpressionQualifiedExpression(t1, cm2); ((ICsExpressionQualifiedExpression)e2).Access = ECsObjectAccess.Reference; CsStatementExpression s2 = new CsStatementExpression(e2); m1.Body.Statements.Statements.Add(s2); }
/// <summary> /// Prepares the specified C++ element to a C# element. /// </summary> /// <param name="cppElement">The C++ element.</param> /// <returns>The C# element created and registered to the <see cref="TransformManager"/></returns> public override CsBase Prepare(CppElement cppElement) { var cppInterface = (CppInterface)cppElement; // IsFullyMapped to false => The structure is being mapped var cSharpInterface = new CsInterface(cppInterface) { IsFullyMapped = false }; CsNamespace nameSpace = Manager.ResolveNamespace(cppInterface); cSharpInterface.Name = NamingRules.Rename(cppInterface); nameSpace.Add(cSharpInterface); Manager.BindType(cppInterface.Name, cSharpInterface); return(cSharpInterface); }
public CsCompileUnit Make1() { var ccu = new CsCompileUnit(); // установить единицу компиляции var ns = new CsNamespace(new CsIdentifier("System")); // объявить пространство имен, которые будут включены в приложение var u1 = new CsUsing(ns); // установить директиву использования пространства имен ccu.Usings.Usings.Add(u1); // добавить его в модуль компиляции var cn = new CsNamespace(new CsIdentifier(ECsNames.Namespace)); // объявить главное пространство имен ccu.UnitMembers.Members.Add(cn); // привязать пространство имен к единице компиляции var cl = new CsClass(); // оздать новый класс ((ICsClass)cl).ClassName = new CsIdentifier(nameof(Program)); // установить его имя как предопределенное для главного класса // it is in principle optional, see. System.CodeDom-entry point cn.NamespaceMembers.Members.Add(cl); // внедрить созданный класс в пространство имен программы var m1 = new CsMethod(new CsIdentifier(nameof(Program.Main))); // создать основной метод - точку входа в основной класс программы (m1 as ICsModifiersProvider).Modifiers = new CsModifiers(ECsModifiers.Static); // указать, что он static ((ICsMethod)m1).TypeResult = new CsTypeReference(new CsVoid()); // задать возвращаемый тип cl.Body.Members.Add(m1); // добавить метод в тело класса (1) var m2 = new CsMethod(new CsIdentifier("WriteLine")); // добавить внешний метод (он указан по своему имени) // здесь предполагаем, что разбор внешних сборок выполнен // на которые указана ссылка в атрибутах компиляции var cm1 = new CsExpressionCall(new CsMethodReference(m2)); // декларация вызова метода var l1 = new CsExpressionLiteral(new CsLiteralString("message")); // декларация значения аргумента вызова var a1 = new CsArgument(null, l1); // расположение аргумента в списке аргументов ((ICsArgument)a1).ArgumentInitialisationType = ECsInitialisationType.Expression; // указывают на то, что аргумент содержит простое выражение, и это его значение cm1.Arguments.Arguments.Add(a1); // в коде вызова добавить этот аргумент var n1 = new CsExpressionName("Console"); // указать имя вызываемого внешнего метода var e1 = new CsExpressionQualifiedExpression(n1, cm1); // указание необходимости создать квалифицированное имя (e1 as ICsExpressionQualifiedExpression).Access = ECsObjectAccess.Reference; // фрагменты квалифицированного имени сочленяются через "." var s1 = new CsStatementExpression(e1); // создаем предложение кода m1.Body.Statements.Statements.Add(s1); // и помещаем его в тело метода return(ccu); }
private static string GetNamespaceDirectory(string generatedDirectoryForAssembly, CsNamespace csNamespace) { var subDirectory = csNamespace.OutputDirectory ?? "."; var nameSpaceDirectory = Path.Combine(generatedDirectoryForAssembly, subDirectory); return nameSpaceDirectory; }
public bool TryGetNamespaceForInclude(string includeName, out CsNamespace cSharpNamespace) { return(_mapIncludeToNamespace.TryGetValue(includeName, out cSharpNamespace)); }
public FileHolder(CsFile file, CsNamespace ns, CsClass cl) { File = file; Ns = ns; Cl = cl; }
public TheClass(CsInterface pCsInterface, FactoryExpressionCreator pCreator) { IsInterface = true; List <string> name = new List <string>(); CsNamespace parent = pCsInterface.parent as CsNamespace; if (parent != null) { name.AddRange(parent.qualified_identifier.Select(pArt => pArt.identifier.identifier)); } NameSpace = string.Join(".", name.ToArray()); Name = pCsInterface.identifier.identifier; FullName = NameSpace + "." + Name; if (pCsInterface.type_base != null && pCsInterface.type_base.base_list.Count != 0) { foreach (CsTypeRef typeRef in pCsInterface.type_base.base_list) { object u = typeRef.entity_typeref.u; if (u == null) { continue; } if (u is CsEntityClass) { Extends.Add(Helpers.GetType(typeRef.type_name)); _baseTyperef = typeRef; } else if (u is CsEntityInterface) { Implements.Add(Helpers.GetType(typeRef.type_name)); } else if (u is CsEntityInstanceSpecifier) { Implements.Add(Helpers.GetType(typeRef.type_name)); } else { throw new NotSupportedException(); } } } Dictionary <string, int> methodNames = new Dictionary <string, int>(); bool methodsDone = false; if (pCsInterface.member_declarations != null) { foreach (CsNode memberDeclaration in pCsInterface.member_declarations) { CsMethod m = memberDeclaration as CsMethod; if (m != null) { if (m.interface_type != null) { continue; } TheMethod tm = new TheMethod(m, this, pCreator); if (methodNames.ContainsKey(tm.Name)) { methodNames[tm.Name]++; int index = tm._index = methodNames[tm.Name]; if (!methodsDone) { methodsDone = true; foreach (KeyValuePair <CsMethod, TheMethod> method in _methods) { method.Value._isUnique = false; method.Value._index = --index; } } tm._isUnique = false; } else { methodNames[tm.Name] = tm._index = 1; } _methods.Add(m, tm); continue; } CsIndexer i = memberDeclaration as CsIndexer; if (i != null) { _indexers.Add(i, new TheIndexer(i, this, pCreator)); continue; } CsVariableDeclaration v = memberDeclaration as CsVariableDeclaration; if (v != null) { _variables.Add(v, new TheVariable(v, this, pCreator)); continue; } CsProperty p = memberDeclaration as CsProperty; if (p != null) { if (p.interface_type == null) { _properties.Add(p, new TheProperty(p, this, pCreator)); } continue; } throw new NotImplementedException("Unknown type not implemented"); } } Modifiers.AddRange(Helpers.GetModifiers(pCsInterface.modifiers)); }
private static string getNamespace(CsNamespace pNamespace) { string name = pNamespace.qualified_identifier.Aggregate(string.Empty, (pCurrent, pIdentifier) => pCurrent + (pIdentifier.identifier.identifier + ".")); return name.Substring(0, name.Length - 1); }
public void Parse(CsNamespace pNameSpace, IEnumerable <CsUsingDirective> pUsing, string pOutputFolder) { if (pNameSpace == null) { return; } _outputFolder = pOutputFolder; string name = getNamespace(pNameSpace); string packDir = pOutputFolder + name.Replace('.', '\\'); Directory.CreateDirectory(packDir); CodeBuilder builder = new CodeBuilder(); foreach (CsNode cn in pNameSpace.member_declarations) { builder.Append("package "); builder.Append(name); builder.AppendLineAndIndent(" {"); StringBuilder usings = new StringBuilder(); parseUsing(pUsing, usings); parseUsing(pNameSpace.using_directives, usings); Using = usings.ToString(); builder.Append(usings); builder.AppendLine(ClassParser.IMPORT_MARKER); ImportStatementList.Init(); CsClass csClass = cn as CsClass; if (csClass != null) { ClassParser.Parse(csClass, builder, _creator); if (ClassParser.IsExtension) { File.WriteAllText(packDir + "\\" + ClassParser.ExtensionName + ".as", builder.ToString()); } else { File.WriteAllText(packDir + "\\" + csClass.identifier.identifier + ".as", builder.ToString()); } builder.Length = 0; continue; } CsInterface csInterface = cn as CsInterface; if (csInterface != null) { InterfaceParser.Parse(csInterface, builder, _creator); File.WriteAllText(packDir + "\\" + csInterface.identifier.identifier + ".as", builder.ToString()); builder.Length = 0; continue; } if (csClass == null) { throw new Exception("Unknown type"); } } }