Improve skeleton generator (#59)

Author: josesimoes

source/MetadataProcessor.Core/SkeletonGenerator/AssemblyClassTable.cs

@@ -12,6 +12,7 @@ public class AssemblyClassTable
         public string AssemblyName;
         public string HeaderFileName;
         public string ProjectName;
+        public bool IsInterop;
 
         public List<Class> Classes = new List<Class>();
     }

source/MetadataProcessor.Core/SkeletonGenerator/SkeletonTemplates.cs

@@ -99,9 +99,9 @@ struct Library_{{AssemblyName}}_{{Name}}{{#newline}}
 };{{#newline}}
 {{#newline}}
 
-const CLR_RT_NativeAssemblyData g_CLR_AssemblyNative_{{AssemblyName}} ={{#newline}}
+const CLR_RT_NativeAssemblyData g_CLR_AssemblyNative_{{Name}} ={{#newline}}
 {{{#newline}}
-    ""{{Name}}"",{{#newline}}
+    ""{{AssemblyName}}"",{{#newline}}
     {{NativeCRC32}},{{#newline}}
     method_lookup,{{#newline}}
     { {{NativeVersion.Major}}, {{NativeVersion.Minor}}, {{NativeVersion.Build}}, {{NativeVersion.Revision}} }{{#newline}}
@@ -238,34 +238,42 @@ struct {{ClassName}}
 
         internal const string CMakeModuleTemplate =
 @"#
-# Copyright(c) 2018 The nanoFramework project contributors
+# Copyright(c) 2020 The nanoFramework project contributors
 # See LICENSE file in the project root for full license information.
 #
 
-#################################################################################################
-# make sure that a valid path is set bellow                                                     #
-# if this is for a class library it's OK to leave it as it is                                   #
-# if this is an Interop module the path has to be set where the build can find the source files #
-#################################################################################################
+{{#if IsInterop}}########################################################################################
+# make sure that a valid path is set bellow                                            #
+# this is an Interop module so this file should be placed in the CMakes module folder  #
+# usually CMake\Modules                                                                #
+########################################################################################
 
 # native code directory
+set(BASE_PATH_FOR_THIS_MODULE ${PROJECT_SOURCE_DIR}/InteropAssemblies/{{AssemblyName}})
+{{#else}}# native code directory
 set(BASE_PATH_FOR_THIS_MODULE ${BASE_PATH_FOR_CLASS_LIBRARIES_MODULES}/{{AssemblyName}})
-
+{{/if}}
 
 # set include directories
 list(APPEND {{AssemblyName}}_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/src/CLR/Core)
 list(APPEND {{AssemblyName}}_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/src/CLR/Include)
 list(APPEND {{AssemblyName}}_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/src/HAL/Include)
 list(APPEND {{AssemblyName}}_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/src/PAL/Include)
 list(APPEND {{AssemblyName}}_INCLUDE_DIRS ${BASE_PATH_FOR_THIS_MODULE})
+{{#if IsInterop}}{{#else}}list(APPEND {{AssemblyName}}_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/src/{{AssemblyName}}){{/if}}
 
 # source files
 set({{AssemblyName}}_SRCS
-    {{HeaderFileName}}.cpp
+
+    {{ProjectName}}.cpp
+{{#if IsInterop}}
 {{#each Classes}}
     {{HeaderFileName}}_{{Name}}_mshl.cpp
     {{HeaderFileName}}_{{Name}}.cpp{{/each}}
-
+{{#else}}
+{{#each Classes}}
+    {{HeaderFileName}}_{{Name}}.cpp{{/each}}
+{{/if}}
 )
 
 foreach(SRC_FILE ${{{AssemblyName}}_SRCS})

source/MetadataProcessor.Core/nanoSkeletonGenerator.cs

@@ -64,7 +64,8 @@ private void GenerateStubs()
             var classList = new AssemblyClassTable
             {
                 AssemblyName = _tablesContext.AssemblyDefinition.Name.Name,
-                ProjectName = _safeProjectName
+                ProjectName = _safeProjectName,
+                IsInterop = !_withoutInteropCode
             };
 
             foreach (var c in _tablesContext.TypeDefinitionTable.TypeDefinitions)
@@ -81,22 +82,10 @@ private void GenerateStubs()
                         ClassName = c.Name,
                         ShortNameUpper = $"{_assemblyName}_{_safeProjectName}_{className}".ToUpper(),
                         RootNamespace = _assemblyName,
-                        ProjectName = _safeProjectName
+                        ProjectName = _safeProjectName,
+                        HeaderFileName = _safeProjectName
                     };
 
-                    if (!_withoutInteropCode)
-                    {
-                        // Interop code needs to use the root namespace
-
-                        classStubs.HeaderFileName = $"{_assemblyName}_{_safeProjectName}";
-                    }
-                    else
-                    {
-                        // projects with Interop can use a simplified naming
-
-                        classStubs.HeaderFileName = _safeProjectName;
-                    }
-
                     classList.Classes.Add(new Class()
                     {
                         Name = className
@@ -241,7 +230,7 @@ private void GenerateStubs()
                             // user code stub
                             Generator generator = compiler.Compile(SkeletonTemplates.ClassStubTemplate);
 
-                            using (var headerFile = File.CreateText(Path.Combine(_path, $"{_assemblyName}_{_safeProjectName}_{className}.cpp")))
+                            using (var headerFile = File.CreateText(Path.Combine(_path, $"{_safeProjectName}_{className}.cpp")))
                             {
                                 var output = generator.Render(classStubs);
                                 headerFile.Write(output);
@@ -250,7 +239,7 @@ private void GenerateStubs()
                             // marshal code
                             generator = compiler.Compile(SkeletonTemplates.ClassMarshallingCodeTemplate);
 
-                            using (var headerFile = File.CreateText(Path.Combine(_path, $"{_assemblyName}_{_safeProjectName}_{className}_mshl.cpp")))
+                            using (var headerFile = File.CreateText(Path.Combine(_path, $"{_safeProjectName}_{className}_mshl.cpp")))
                             {
                                 var output = generator.Render(classStubs);
                                 headerFile.Write(output);
@@ -259,7 +248,7 @@ private void GenerateStubs()
                             // class header
                             generator = compiler.Compile(SkeletonTemplates.ClassHeaderTemplate);
 
-                            using (var headerFile = File.CreateText(Path.Combine(_path, $"{_assemblyName}_{_safeProjectName}_{className}.h")))
+                            using (var headerFile = File.CreateText(Path.Combine(_path, $"{_safeProjectName}_{className}.h")))
                             {
                                 var output = generator.Render(classStubs);
                                 headerFile.Write(output);
@@ -269,8 +258,7 @@ private void GenerateStubs()
                 }
             }
 
-            if (!_withoutInteropCode &&
-                classList.Classes.Count > 0)
+            if (classList.Classes.Count > 0)
             {
                 FormatCompiler compiler = new FormatCompiler
                 {
@@ -280,8 +268,20 @@ private void GenerateStubs()
                 // CMake module
                 Generator generator = compiler.Compile(SkeletonTemplates.CMakeModuleTemplate);
 
-                // FindINTEROP-NF.AwesomeLib
-                using (var headerFile = File.CreateText(Path.Combine(_path, $"FindINTEROP-{_safeProjectName}.cmake")))
+                string fileName;
+
+                if (!_withoutInteropCode)
+                {
+                    // this is an Interop library: FindINTEROP-NF.AwesomeLib.cmake
+                    fileName = Path.Combine(_path, $"FindINTEROP-{classList.AssemblyName}.cmake");
+                }
+                else
+                {
+                    // this is a class library: FindWindows.Devices.Gpio.cmake
+                    fileName = Path.Combine(_path, $"Find{classList.AssemblyName}.cmake");
+                }
+
+                using (var headerFile = File.CreateText(fileName))
                 {
                     var output = generator.Render(classList);
                     headerFile.Write(output);
@@ -298,8 +298,8 @@ private void GenerateAssemblyLookup()
             var assemblyLookup = new AssemblyLookupTable()
             {
                 IsCoreLib = _isCoreLib,
-                Name = _name,
-                AssemblyName = _assemblyName,
+                Name = _assemblyName,
+                AssemblyName = _tablesContext.AssemblyDefinition.Name.Name,
                 HeaderFileName = _safeProjectName,
                 NativeVersion = nativeVersion,
                 NativeCRC32 = "0x" + _tablesContext.NativeMethodsCrc.Current.ToString("X")
@@ -373,20 +373,8 @@ private void GenerateAssemblyLookup()
 
             FormatCompiler compiler = new FormatCompiler();
             Generator generator = compiler.Compile(SkeletonTemplates.AssemblyLookupTemplate);
-            string filePath;
-
-            if (!_withoutInteropCode)
-            {
-                // Interop code needs to use the root namespace
-                filePath = Path.Combine(_path, $"{_assemblyName}_{_safeProjectName}.cpp");
-            }
-            else
-            {
-                // projects with Interop can use a simplified naming
-                filePath = Path.Combine(_path, $"{_safeProjectName}.cpp");
-            }
 
-            using (var headerFile = File.CreateText(filePath))
+            using (var headerFile = File.CreateText(Path.Combine(_path, $"{_safeProjectName}.cpp")))
             {
                 var output = generator.Render(assemblyLookup);
                 headerFile.Write(output);
@@ -505,21 +493,11 @@ private void GenerateAssemblyHeader()
             FormatCompiler compiler = new FormatCompiler();
             Generator generator = compiler.Compile(SkeletonTemplates.AssemblyHeaderTemplate);
 
+            // create stubs directory
             Directory.CreateDirectory(_path);
-            string filePath;
-
-            if (!_withoutInteropCode)
-            {
-                // Interop code needs to use the root namespace
-                filePath = Path.Combine(_path, $"{_assemblyName}_{_safeProjectName}.h");
-            }
-            else
-            {
-                // projects with Interop can use a simplified naming
-                filePath = Path.Combine(_path, $"{_safeProjectName}.h");
-            }
 
-            using (var headerFile = File.CreateText(filePath))
+            // output header file
+            using (var headerFile = File.CreateText(Path.Combine(_path, $"{_safeProjectName}.h")))
             {
                 var output = generator.Render(assemblyData);
                 headerFile.Write(output);