private RootFolderDefinition ReadRootFolder(XmlReader reader)
{
RootFolderDefinition rootFolder = null;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
var name = reader.GetAttribute("Name");
var isExcluded = "true".Equals(reader.GetAttribute("IsExcluded"));
if (reader.Name.Equals("RootFolder"))
{
var uri = new Uri(Path.GetDirectoryName(new Uri(reader.BaseURI).LocalPath) + '\\' + name);
rootFolder = new RootFolderDefinition(uri.AbsolutePath)
{
IsExcluded = isExcluded
};
ReadSourceItems(reader, rootFolder);
}
}
}
return(rootFolder);
}
public void ReplaceRootNode()
{
string path = Assembly.GetExecutingAssembly().Location;
path = Path.GetDirectoryName(path);
var root = new RootFolderDefinition(Path.Combine(path, "CppTestProject"));
var header = new HeaderDefinition("header1.h");
root.AddChild(header);
var @class = new ClassDefinition("CppClass");
header.AddNode(@class);
var replacement = new RootFolderDefinition(Path.Combine(path, "CppTestProject2"));
StructureNodeReplacer.Replace(root, replacement);
Assert.IsNull(root.Parent);
Assert.AreEqual(0, root.Children.Count);
Assert.IsNull(replacement.Parent);
Assert.AreEqual(1, replacement.Children.Count);
Assert.AreEqual(replacement, header.Parent);
}
public void TransformAsync()
{
WorkAsync((s, e) =>
{
SetStatus(WrapperStatus.TransformingCpp);
try
{
var cloner = new StructureCloner();
cloner.Clone(GlobalNamespaceCpp);
GlobalNamespaceCSharp = cloner.RootNamespaceClone;
var csharpRootFolderPath = RootFolder.FullPath + "/CS-Wrapper";
RootFolderCSharp = new RootFolderDefinition(csharpRootFolderPath);
StructureNodeReplacer.Replace(cloner.RootFolderClone, RootFolderCSharp);
new DotNetTransformer().Transform(GlobalNamespaceCSharp, RootFolderCSharp);
new BulletTransformer().Transform(GlobalNamespaceCSharp, RootFolderCSharp);
}
catch (Exception ex)
{
//WrapperEvent.Invoke(this, new WrapperProjectEventArgs(WrapperProjectEvent.LogMessage, ex.ToString()));
}
SetStatus(WrapperStatus.TransformingCppDone);
});
}
public void Clone()
{
string path = Assembly.GetExecutingAssembly().Location;
path = Path.GetDirectoryName(path);
var root = new RootFolderDefinition(Path.Combine(path, "CppTestProject"));
var header = new HeaderDefinition("header1.h");
var @namespace = new NamespaceDefinition();
var @class = new ClassDefinition("CppClass");
var @enum = new EnumDefinition("CppEnum");
root.AddChild(header);
@namespace.AddChild(@class);
header.AddNode(@class);
@namespace.AddChild(@enum);
header.AddNode(@enum);
var cloner = new StructureCloner();
cloner.Clone(@namespace);
var rootClone = cloner.RootFolderClone;
var rootNamespaceClone = cloner.RootNamespaceClone;
Assert.AreNotSame(root, rootClone);
Assert.AreEqual(root.FullPath, rootClone.FullPath);
Assert.AreEqual(root.Children.Count, rootClone.Children.Count);
var headerClone = (HeaderDefinition)rootClone.Children.First();
Assert.AreNotSame(header, headerClone);
Assert.AreSame(rootClone, headerClone.Parent);
Assert.AreEqual(2, headerClone.Nodes.Count);
var classClone = (ClassDefinition)headerClone.Nodes[0];
Assert.AreNotSame(@class, classClone);
Assert.AreSame(headerClone, classClone.Header);
Assert.AreEqual(@class.Name, classClone.Name);
Assert.AreEqual(@class.Children.Count, classClone.Children.Count);
Assert.AreSame(rootNamespaceClone, classClone.Parent);
var enumClone = (EnumDefinition)headerClone.Nodes[1];
Assert.AreNotSame(@enum, enumClone);
Assert.AreSame(headerClone, enumClone.Header);
Assert.AreEqual(@enum.Name, enumClone.Name);
Assert.AreEqual(@enum.Children.Count, enumClone.Children.Count);
Assert.AreSame(rootNamespaceClone, enumClone.Parent);
Assert.AreNotSame(@namespace, rootNamespaceClone);
Assert.AreEqual(@namespace.Children.Count, rootNamespaceClone.Children.Count);
}
public void Transform(NamespaceDefinition globalNamespace, RootFolderDefinition rootFolder)
{
new PropertyGenerator().Transform(globalNamespace);
new NativeMethodImporter().Transform(globalNamespace, rootFolder);
RenameCodeFiles(rootFolder);
MoveGlobalSymbolsToClasses(globalNamespace);
new OperatorTransformer().Transform(globalNamespace, rootFolder);
new EnumTransformer().Transform(globalNamespace, rootFolder);
new NodeOrderer().Transform(globalNamespace, rootFolder);
}
public void Transform(NamespaceDefinition globalNamespace, RootFolderDefinition rootFolder)
{
var methodsHeader = new HeaderDefinition("UnsafeNativeMethods.cs");
var methodsClass = new ClassDefinition("UnsafeNativeMethods");
CreateExternMethods(globalNamespace, methodsClass);
methodsHeader.AddNode(methodsClass);
globalNamespace.AddChild(methodsClass);
rootFolder.AddChild(methodsHeader);
}
public void CodeStructureParse()
{
string path = Assembly.GetExecutingAssembly().Location;
path = Path.GetDirectoryName(path);
path = Path.Combine(path, "CppTestProject");
RootFolderDefinition rootFolder = CodeStructureParser.Parse(path);
Assert.AreEqual(1, rootFolder.Children.Count);
Assert.AreEqual("header1.h", rootFolder.Children[0].Name);
}
public void SetData(RootFolderDefinition rootFolder)
{
_rootFolder = rootFolder;
if (rootFolder != null)
{
RefreshItemNodes(new[] { rootFolder }, fileTree.Nodes);
fileTree.Nodes[0].Expand();
}
else
{
fileTree.Nodes.Clear();
}
}
public NamespaceDefinition ParseRootFolder(RootFolderDefinition rootFolder)
{
InitializeContext(rootFolder);
using (_context.Index = new Index())
{
foreach (var sourceItem in rootFolder.Children)
{
ParseSourceItem(sourceItem);
}
_context.Index = null;
}
return(_context.Namespace);
}
public RootFolderDefinition Load(string inputPath)
{
RootFolderDefinition rootFolder = null;
using (var reader = XmlReader.Create(inputPath))
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name.Equals("WrapperProject"))
{
rootFolder = ReadProject(reader);
}
}
}
return(rootFolder);
}
private RootFolderDefinition ReadProject(XmlReader reader)
{
RootFolderDefinition rootFolder = null;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name.Equals("CppCodeModel"))
{
rootFolder = ReadRootFolder(reader);
}
}
}
return(rootFolder);
}
public void CodeModelParse()
{
string path = Assembly.GetExecutingAssembly().Location;
path = Path.GetDirectoryName(path);
path = Path.Combine(path, "CppTestProject");
var rootFolder = new RootFolderDefinition(path);
var header = new HeaderDefinition("header1.h");
rootFolder.AddChild(header);
NamespaceDefinition globalNamespace = new CppParser().ParseRootFolder(rootFolder);
Assert.AreEqual(1, globalNamespace.Children.Count);
}
private SourceItemDefinition CloneSourceItem(SourceItemDefinition item)
{
if (item == null)
{
return(null);
}
if (_oldToNewMapping.TryGetValue(item, out SourceItemDefinition clone))
{
return(clone);
}
if (item is HeaderDefinition)
{
clone = new HeaderDefinition(item.Name);
}
else if (item is FolderDefinition)
{
clone = new FolderDefinition(item.Name);
}
else if (item is RootFolderDefinition)
{
clone = new RootFolderDefinition(item.Name);
RootFolderClone = RootFolderClone ?? clone as RootFolderDefinition;
}
else
{
throw new NotSupportedException();
}
_oldToNewMapping[item] = clone;
clone.Parent = CloneSourceItem(item.Parent);
foreach (SourceItemDefinition child in item.Children.Where(c => !c.IsExcluded))
{
var childClone = CloneSourceItem(child);
clone.Children.Add(childClone);
}
return(clone);
}
public void CreatesNativeMethodImports()
{
var @namespace = new NamespaceDefinition();
var @class = new ClassDefinition("CppClass");
var method = new MethodDefinition("method");
@namespace.AddChild(@class);
@class.AddChild(method);
var rootFolder = new RootFolderDefinition("root");
var header = new HeaderDefinition("header.h");
rootFolder.AddChild(header);
header.AddNode(@class);
new DotNetTransformer().Transform(@namespace, rootFolder);
var methodsHeader = rootFolder.Children.FirstOrDefault(c => c.Name == "UnsafeNativeMethods.cs");
Assert.IsNotNull(methodsHeader);
var methodsClass = @namespace.Children.FirstOrDefault(c => c.Name == "UnsafeNativeMethods") as ClassDefinition;
Assert.IsNotNull(methodsClass);
Assert.That(methodsClass.Children, Has.Count.EqualTo(1));
var nativeMethod = methodsClass.Methods.First();
Assert.AreEqual("CppClass_method", nativeMethod.Name);
Assert.IsTrue(nativeMethod.IsStatic);
Assert.IsTrue(nativeMethod.IsExtern);
Assert.That(nativeMethod.Parameters, Has.Length.EqualTo(1));
var objParameter = nativeMethod.Parameters[0];
Assert.AreEqual("obj", objParameter.Name);
}
private void InitializeContext(RootFolderDefinition rootFolder)
{
_context = new CppParserContext(rootFolder)
{
NodeVisitor = HeaderVisitor
};
var classParser = new ClassParser();
var methodParser = new MethodParser();
_context.DefinitionParsers.Add(CursorKind.ClassDecl, classParser);
_context.DefinitionParsers.Add(CursorKind.ClassTemplate, classParser);
_context.DefinitionParsers.Add(CursorKind.StructDecl, classParser);
_context.DefinitionParsers.Add(CursorKind.EnumDecl, new EnumParser());
_context.DefinitionParsers.Add(CursorKind.Namespace, new NamespaceParser());
_context.DeclarationParsers.Add(CursorKind.FieldDecl, new FieldParser());
_context.DeclarationParsers.Add(CursorKind.CxxMethod, methodParser);
_context.DeclarationParsers.Add(CursorKind.Constructor, methodParser);
var globalNamespace = new NamespaceDefinition("");
_context.Namespace = globalNamespace;
}
public CppParserContext(RootFolderDefinition rootFolder)
{
RootFolder = rootFolder;
}
public void Transform(NamespaceDefinition globalNamespace, RootFolderDefinition rootFolder)
{
Order(globalNamespace);
}
public void Transform(NamespaceDefinition globalNamespace, RootFolderDefinition rootFolder)
{
RenameHeaders(rootFolder);
RenameClasses(globalNamespace);
MoveGlobalNodes(globalNamespace);
}
