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