static void Main(string[] args)
{
// read all RhinoCommon classes into memory
const string rhinocommonPath = @"C:\dev\github\mcneel\rhino\src4\DotNetSDK\rhinocommon\dotnet";
Console.WriteLine("[Parse RhinoCommon source]");
Console.ForegroundColor = ConsoleColor.DarkGreen;
RhinoCommonClass.BuildClassDictionary(rhinocommonPath);
Console.ResetColor();
Console.WriteLine("[Parse C++ Bindings]");
Console.ForegroundColor = ConsoleColor.Green;
const string bindingPath = @"../../../../src/bindings";
BindingClass.BuildClassDictionary(bindingPath);
Console.ResetColor();
Console.WriteLine("[END PARSE]");
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("Writing javascript");
JavascriptClass.Write("rh3dm_temp.js");
Console.WriteLine("Writing python");
PythonClass.Write();
}
static void Main(string[] args)
{
// read all RhinoCommon classes into memory
const string rhinocommonPath = @"../../dotnet";
Console.WriteLine("[Parse RhinoCommon source]");
Console.ForegroundColor = ConsoleColor.DarkGreen;
RhinoCommonClass.BuildClassDictionary(rhinocommonPath);
Console.ResetColor();
Console.WriteLine("[Parse C++ Bindings]");
Console.ForegroundColor = ConsoleColor.Green;
const string bindingPath = @"../../bindings";
BindingClass.BuildDictionary(bindingPath);
Console.ResetColor();
Console.WriteLine("[END PARSE]");
var outDir = new DirectoryInfo("../out");
if (!outDir.Exists)
{
outDir.Create();
}
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("Writing javascript API help");
JavascriptClass.GenerateApiHelp(Path.Combine(outDir.FullName, "js_apidocs"));
Console.WriteLine("Writing javascript typescript definition file");
JavascriptClass.GenerateTypescriptDefinition(Path.Combine(outDir.FullName, "js_tsdef"));
Console.WriteLine("Writing python");
PythonClass.Write(Path.Combine(outDir.FullName, "py_apidocs"));
}
static int ClassValue(PythonClass c)
{
if (string.IsNullOrWhiteSpace(c.BaseClass))
{
return(0);
}
if (c.BaseClass.Equals("CommonObject"))
{
return(1);
}
if (c.BaseClass.Equals("GeometryBase"))
{
return(2);
}
if (c.BaseClass.Equals("Curve") || c.BaseClass.Equals("Surface"))
{
return(3);
}
return(4);
}
public override void AddMethod(string name, bool isStatic, string cppFunction, string[] argList)
{
if (!string.IsNullOrWhiteSpace(cppFunction))
{
if (_sisterPythonClass == null)
{
_sisterPythonClass = AllPythonClasses[this.ClassName.ToLowerInvariant()];
}
for (int i = 0; i < _sisterPythonClass.Methods.Count; i++)
{
var pyMethod = _sisterPythonClass.Methods[i];
if (pyMethod.CppFunction.Equals(cppFunction, StringComparison.Ordinal))
{
argList = pyMethod.ArgList;
break;
}
}
}
base.AddMethod(name, isStatic, cppFunction, argList);
}
public static void WriteRst(DirectoryInfo rstDirectory, RhinoCommonClass rhinocommonClass, PythonClass pythonClass)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(pythonClass.ClassName);
sb.AppendLine("".PadLeft(pythonClass.ClassName.Length, '='));
sb.AppendLine();
sb.AppendLine($".. py:module:: rhino3dm");
sb.AppendLine();
sb.AppendLine($".. py:class:: {pythonClass.ClassName}");
foreach (var constructor in pythonClass.Constructors)
{
var rhcommonConstructor = rhinocommonClass.GetConstructor(constructor);
sb.AppendLine();
sb.Append($" .. py:method:: {pythonClass.ClassName}(");
StringBuilder summary = null;
List <ParameterInfo> parameters = new List <ParameterInfo>();
if (rhcommonConstructor != null)
{
DocCommentToPythonDoc(rhcommonConstructor.Item2, rhcommonConstructor.Item1, 2, out summary, out parameters);
}
for (int i = 0; i < parameters.Count; i++)
{
if (i > 0)
{
sb.Append(", ");
}
sb.Append(parameters[i].Name);
}
sb.AppendLine(")");
sb.AppendLine();
if (null == summary)
{
sb.AppendLine(_T(2) + $"{pythonClass.ClassName} constructor");
}
else
{
sb.Append(summary.ToString());
}
//if (parameters.Count > 0 && parameters.Count == args.Length)
{
sb.AppendLine();
foreach (var p in parameters)
{
if (p.Description.Count == 0)
{
continue;
}
string type = ToPythonType(p.Type);
if (type.IndexOf(' ') < 0)
{
sb.Append($" :param {type} {p.Name}: {p.Description[0]}");
}
else
{
sb.Append($" :param {p.Name}: {p.Description[0]}");
}
if (p.Description.Count > 1)
{
sb.AppendLine(" \\");
}
else
{
sb.AppendLine();
}
for (int i = 1; i < p.Description.Count; i++)
{
if (i == (p.Description.Count - 1))
{
sb.AppendLine($" {p.Description[i]}");
}
else
{
sb.AppendLine($" {p.Description[i]} \\");
}
}
if (type.IndexOf(' ') > 0)
{
sb.AppendLine($" :type {p.Name}: {type}");
}
}
}
}
foreach (var property in pythonClass.Properties)
{
sb.AppendLine();
sb.AppendLine($" .. py:attribute:: {property}");
sb.AppendLine();
var rhcommonProperty = rhinocommonClass.GetProperty(property);
if (null == rhcommonProperty)
{
continue;
}
StringBuilder summary = null;
DocCommentToPythonDoc(rhcommonProperty.Item2, rhcommonProperty.Item1, 2, out summary);
sb.Append(summary.ToString());
}
foreach (var pyMethod in pythonClass.Methods)
{
bool isStatic = pyMethod.IsStatic;
string method = pyMethod.Name;
string[] args = pyMethod.ArgList;
sb.AppendLine();
if (isStatic)
{
sb.Append($" .. py:staticmethod:: {method}(");
}
else
{
sb.Append($" .. py:method:: {method}(");
}
for (int i = 0; i < args.Length; i++)
{
if (i > 0)
{
sb.Append(", ");
}
sb.Append(args[i]);
}
sb.AppendLine(")");
sb.AppendLine();
var rhcommonMethod = rhinocommonClass.GetMethod(method);
if (rhcommonMethod == null)
{
sb.AppendLine(" [todo] add documentation");
continue;
}
StringBuilder summary;
List <ParameterInfo> parameters;
ReturnInfo returnInfo;
string s = DocCommentToPythonDoc(rhcommonMethod.Item2, rhcommonMethod.Item1, 2, out summary, out parameters, out returnInfo);
sb.Append(summary.ToString());
if (parameters.Count > 0 && parameters.Count == args.Length)
{
sb.AppendLine();
foreach (var p in parameters)
{
if (p.Description.Count == 0)
{
continue;
}
string type = ToPythonType(p.Type);
if (type.IndexOf(' ') < 0)
{
sb.Append($" :param {type} {p.Name}: {p.Description[0]}");
}
else
{
sb.Append($" :param {p.Name}: {p.Description[0]}");
}
if (p.Description.Count > 1)
{
sb.AppendLine(" \\");
}
else
{
sb.AppendLine();
}
for (int i = 1; i < p.Description.Count; i++)
{
if (i == (p.Description.Count - 1))
{
sb.AppendLine($" {p.Description[i]}");
}
else
{
sb.AppendLine($" {p.Description[i]} \\");
}
}
if (type.IndexOf(' ') > 0)
{
sb.AppendLine($" :type {p.Name}: {type}");
}
}
}
sb.AppendLine();
if (returnInfo.Description.Count > 0)
{
sb.Append($" :return: {returnInfo.Description[0]}");
if (returnInfo.Description.Count > 1)
{
sb.AppendLine(" \\");
}
else
{
sb.AppendLine();
}
for (int i = 1; i < returnInfo.Description.Count; i++)
{
if (i == (returnInfo.Description.Count - 1))
{
sb.AppendLine($" {returnInfo.Description[i]}");
}
else
{
sb.AppendLine($" {returnInfo.Description[i]} \\");
}
}
}
sb.AppendLine($" :rtype: {ToPythonType(returnInfo.Type)}");
}
string path = Path.Combine(rstDirectory.FullName, $"{pythonClass.ClassName}.rst");
File.WriteAllText(path, sb.ToString());
}
public static void BuildDictionary(string sourcePath)
{
BindingClass activeClass = null;
foreach (var file in AllSourceFiles(sourcePath))
{
string[] lines = System.IO.File.ReadAllLines(file);
for (int i = 0; i < lines.Length; i++)
{
string line = lines[i].Trim();
if (line.StartsWith("class_"))
{
string name = (line.Split(new char[] { '"' }))[1];
if (name.StartsWith("__"))
{
continue;
}
var activeJavascriptClass = new JavascriptClass(name);
int baseIndex = line.IndexOf("base<BND_");
if (baseIndex > 0)
{
int baseEnd = line.IndexOf(">", baseIndex);
baseIndex += "base<BND_".Length;
string baseClass = line.Substring(baseIndex, baseEnd - baseIndex);
activeJavascriptClass.BaseClass = baseClass;
}
AllJavascriptClasses.Add(name.ToLowerInvariant(), activeJavascriptClass);
activeClass = activeJavascriptClass;
continue;
}
if (line.StartsWith("py::class_"))
{
string name = (line.Split(new char[] { '"' }))[1];
if (name.StartsWith("__"))
{
continue;
}
var activePythonClass = new PythonClass(name);
int baseIndex = line.IndexOf(",");
if (baseIndex > 0)
{
baseIndex = line.IndexOf("BND_", baseIndex);
}
if (baseIndex > 0)
{
int baseEnd = line.IndexOf(">", baseIndex);
baseIndex += "BND_".Length;
if (baseEnd > baseIndex)
{
string baseClass = line.Substring(baseIndex, baseEnd - baseIndex);
activePythonClass.BaseClass = baseClass;
}
}
AllPythonClasses.Add(name.ToLowerInvariant(), activePythonClass);
activeClass = activePythonClass;
continue;
}
if (line.StartsWith("enum_"))
{
string name = (line.Split(new char[] { '"' }))[1];
if (name.StartsWith("__"))
{
continue;
}
var jsenum = new JavascriptEnum(name);
AllJavascriptEnums.Add(name.ToLowerInvariant(), jsenum);
activeClass = jsenum;
continue;
}
if (activeClass != null)
{
if (line.StartsWith(".constructor"))
{
int startIndex = line.IndexOf("<");
int endIndex = line.IndexOf(">", startIndex);
string types = line.Substring(startIndex + 1, endIndex - startIndex - 1);
activeClass.AddConstructor(types);
continue;
}
if (line.IndexOf("py::init<") > 0)
{
int startIndex = line.IndexOf("py::init<") + "py::init<".Length;
int endIndex = line.IndexOf(">", startIndex);
string types = line.Substring(startIndex, endIndex - startIndex);
activeClass.AddConstructor(types);
continue;
}
if (line.StartsWith(".property") ||
line.StartsWith(".def_property"))
{
string propName = (line.Split(new char[] { '"' }))[1];
activeClass.AddProperty(propName);
continue;
}
if (line.Contains("py::self"))
{
continue;
}
if (line.StartsWith(".function") || line.StartsWith(".def("))
{
string funcName = (line.Split(new char[] { '"' }))[1];
activeClass.AddMethod(funcName, false, GetArgList(line));
}
if (line.StartsWith(".class_function") ||
line.StartsWith(".def_static"))
{
string funcName = (line.Split(new char[] { '"' }))[1];
activeClass.AddMethod(funcName, true, GetArgList(line));
}
if (line.StartsWith(";"))
{
activeClass = null;
}
if (activeClass is JavascriptEnum && line.StartsWith(".value"))
{
string enumValue = (line.Split(new char[] { '"' }))[1];
(activeClass as JavascriptEnum).Elements.Add(enumValue);
}
}
}
Console.WriteLine($"parse: {file}");
}
}
