def GenerateNM(code,
name,
references=None,
outputDirectory=None,
inMemory=False):
CompilerParams = Compiler.CompilerParameters()
if outputDirectory is None:
outputDirectory = Directory.GetCurrentDirectory()
CompilerParams.OutputAssembly = Path.Combine(outputDirectory,
name + ".netmodule")
CompilerParams.GenerateInMemory = False
CompilerParams.TreatWarningsAsErrors = False
CompilerParams.GenerateExecutable = False
CompilerParams.CompilerOptions = "/target:module"
for reference in references or []:
CompilerParams.ReferencedAssemblies.Add(reference)
provider = CSharpCodeProvider()
compile = provider.CompileAssemblyFromSource(CompilerParams, code)
if compile.Errors.HasErrors:
for err in compile.Errors:
print(err)
raise Exception("Compile error(s)")
return "\"%s\"" % compile.PathToAssembly
def Generate(code,
name,
references=None,
outputDirectory=None,
inMemory=False):
CompilerParams = Compiler.CompilerParameters()
if outputDirectory is None:
outputDirectory = Directory.GetCurrentDirectory()
if not inMemory:
CompilerParams.OutputAssembly = Path.Combine(outputDirectory,
name + ".dll")
CompilerParams.GenerateInMemory = False
else:
CompilerParams.GenerateInMemory = True
CompilerParams.TreatWarningsAsErrors = False
CompilerParams.GenerateExecutable = False
CompilerParams.CompilerOptions = "/optimize"
for reference in references or []:
CompilerParams.ReferencedAssemblies.Add(reference)
provider = CSharpCodeProvider()
compile = provider.CompileAssemblyFromSource(CompilerParams, code)
if compile.Errors.HasErrors:
raise Exception("Compile error: %r" % list(compile.Errors.List))
if inMemory:
return compile.CompiledAssembly
return compile.PathToAssembly
def _compile_dotnet(
code_provider,
sourcecode_list,
full_output_file_addr=None,
reference_list=None,
resource_list=None,
):
logger.debug('Compiling source sourcecode_list to: {}'.format(
full_output_file_addr))
logger.debug('References assemblies are: {}'.format(reference_list))
compiler_params = Compiler.CompilerParameters()
if full_output_file_addr is None:
compiler_params.GenerateInMemory = True
else:
compiler_params.GenerateInMemory = False
compiler_params.OutputAssembly = full_output_file_addr
compiler_params.TreatWarningsAsErrors = False
compiler_params.GenerateExecutable = False
compiler_params.CompilerOptions = "/optimize"
for reference in reference_list or []:
logger.debug('Adding reference to compiler: {}'.format(reference))
compiler_params.ReferencedAssemblies.Add(reference)
for resource in resource_list or []:
logger.debug('Adding resource to compiler: {}'.format(resource))
compiler_params.EmbeddedResources.Add(resource)
logger.debug('Compiling source sourcecode_list.')
compiler = code_provider.CompileAssemblyFromSource(
compiler_params, Array[str](sourcecode_list))
if compiler.Errors.HasErrors:
error_list = [str(err) for err in compiler.Errors.GetEnumerator()]
raise PyRevitException("Compile error: {}".format(error_list))
if full_output_file_addr is None:
logger.debug('Compile to memory successful: {}'.format(
compiler.CompiledAssembly))
return compiler.CompiledAssembly
else:
logger.debug('Compile successful: {}'.format(compiler.PathToAssembly))
return compiler.PathToAssembly
def ModulesToAssembly(modules,
name,
code="",
references=None,
outputDirectory=None,
inMemory=False):
CompilerParams = Compiler.CompilerParameters()
if outputDirectory is None:
outputDirectory = Directory.GetCurrentDirectory()
if not inMemory:
CompilerParams.OutputAssembly = Path.Combine(outputDirectory,
name + ".dll")
CompilerParams.GenerateInMemory = False
else:
CompilerParams.GenerateInMemory = True
CompilerParams.TreatWarningsAsErrors = False
CompilerParams.GenerateExecutable = False
modulesListCompiler = ';'.join(map(str, modules))
CompilerParams.CompilerOptions = "/addmodule:" + modulesListCompiler
print(CompilerParams.CompilerOptions)
for reference in references or []:
CompilerParams.ReferencedAssemblies.Add(reference)
provider = CSharpCodeProvider()
compile = provider.CompileAssemblyFromSource(CompilerParams, code)
if compile.Errors.HasErrors:
for err in compile.Errors:
print(err)
raise Exception("Compile error(s)")
if inMemory:
return compile.CompiledAssembly
return compile.PathToAssembly
def script(code, file_name):
"""
Args:
file_name:
code:
Returns:
"""
AddReference("System")
from System import IO
from System import Text
from System import CodeDom as dom
from System.CodeDom import Compiler
nameSpace = dom.CodeNamespace("Client")
comment = dom.CodeCommentStatement(dom.CodeComment(_template))
nameSpace.Comments.Add(comment)
nameSpace.Imports.Add(dom.CodeNamespaceImport("System"))
nameSpace.Imports.Add(dom.CodeNamespaceImport("UnityEngine"))
nameSpace.Imports.Add(dom.CodeNamespaceImport("UnityEditor"))
mainClass = dom.CodeTypeDeclaration("Runtime")
# MonoBehaivor, ScriptableObject, AssetPostprocessror, ShaderGui
# SerializeField
# Node
# AssetDatabase.Reflesh()
mainClass.BaseTypes.Add(
dom.CodeTypeReference(clr.GetClrType(UnityEngine.MonoBehaviour)))
nameSpace.Types.Add(mainClass)
# fields = code.GetFields(
# ref.BindingFlags.GetField | ref.BindingFlags.Public | ref.BindingFlags.Instance
# )
#
# for field in fields:
# variable = dom.CodeMemberField(field.FieldType.Name, field.Name)
# mainClass.Members.Add(variable)
#
# methods = code.GetMethods(
# ref.BindingFlags.Public | ref.BindingFlags.NonPublic |
# ref.BindingFlags.Instance | ref.BindingFlags.Static | ref.BindingFlags.DeclaredOnly
# )
#
# for method in methods:
# mainMethod = dom.CodeMemberMethod()
# mainMethod.ReturnType = dom.CodeTypeReference(method.ReturnType)
# mainMethod.Attributes = dom.MemberAttributes.Public | dom.MemberAttributes.Final
# mainMethod.Name = method.Name
#
# mainMethod.Comments.Add(dom.CodeCommentStatement("doc comment"))
#
# if (method.Attributes & dom.MethodAttributes.Static) != 0:
# target = dom.CodeSnippetExpression(code.FullName)
# else:
# target = dom.CodeObjectCreateExpression(code.FullName)
#
# invoke = dom.CodeMethodInvokeExpression(target, method.Name)
#
# for p in method.GetParameters():
# invoke.Parameters.Add(dom.CodeArgumentReferenceExpression(p.Name))
# exp = dom.CodeParameterDeclarationExpression(p.ParameterType, p.Name)
# mainMethod.Parameters.Add(exp)
#
# if method.ReturnType.Name != "Void":
# mainMethod.Statements.Add(dom.CodeMethodReturnStatement(invoke))
# else:
# mainMethod.Statements.Add(invoke)
#
# mainClass.Members.Add(mainMethod)
codeText = Text.StringBuilder()
compilerOptions = Compiler.CodeGeneratorOptions()
compilerOptions.IndentString = " "
compilerOptions.BracingStyle = "C#"
# Csharp に書き込み
codeWriter = IO.StringWriter(codeText)
Compiler.CodeDomProvider.CreateProvider("C#").GenerateCodeFromNamespace(
nameSpace, codeWriter, compilerOptions)
codeWriter.Close()
writer = IO.StreamWriter(file_name)
writer.Write(codeText)
writer.Close()