/// <summary> /// Writes the code to string in the specific language /// and returns the string /// </summary> public static string Create(Language language, string expression, RegexOptions options) { CodeCompileUnit unit = Create(expression, options); System.Text.StringBuilder builder = new System.Text.StringBuilder(); using (System.IO.StringWriter stringWriter = new System.IO.StringWriter(builder)) { System.CodeDom.Compiler.ICodeGenerator generator; switch (language) { case Language.CSharp: System.CodeDom.Compiler.CodeGeneratorOptions genOptions = new System.CodeDom.Compiler.CodeGeneratorOptions(); genOptions.BracingStyle = "C"; generator = new Microsoft.CSharp.CSharpCodeProvider().CreateGenerator(); generator.GenerateCodeFromCompileUnit(unit, stringWriter, genOptions); break; case Language.VisualBasic: generator = new Microsoft.VisualBasic.VBCodeProvider().CreateGenerator(); generator.GenerateCodeFromCompileUnit(unit, stringWriter, null); break; } return builder.ToString(); } }
public void Generate(IEnumerable <string> files) { var schemas = files.Select(f => XmlSchema.Read(XmlReader.Create(f, new XmlReaderSettings { DtdProcessing = DtdProcessing.Ignore }), (s, e) => { Trace.TraceError(e.Message); })); foreach (var s in schemas) { Set.Add(s.TargetNamespace, s.SourceUri); } Set.Compile(); BuildModel(); var namespaces = GenerateCode(); var provider = new Microsoft.CSharp.CSharpCodeProvider(); var outputFolder = this.OutputFolder ?? "."; foreach (var ns in namespaces) { var compileUnit = new CodeCompileUnit(); compileUnit.Namespaces.Add(ns); var title = ((AssemblyTitleAttribute)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(AssemblyTitleAttribute))).Title; var version = Assembly.GetExecutingAssembly().GetName().Version.ToString(); ns.Comments.Add(new CodeCommentStatement(string.Format("This code was generated by {0} version {1}.", title, version))); using (StringWriter sw = new StringWriter()) { provider.GenerateCodeFromCompileUnit(compileUnit, sw, new CodeGeneratorOptions { VerbatimOrder = true, BracingStyle = "C" }); var s = sw.ToString().Replace("};", "}"); // remove ';' at end of automatic properties var path = Path.Combine(outputFolder, ns.Name + ".cs"); Log?.Invoke(path); File.WriteAllText(path, s); } } }
public void Execute( CodeGenSettings config, List <EntityMetadata> entitMetadatas, Dictionary <string, PicklistAttributeMetadata> picklists, Dictionary <string, string> referencedEntities ) { var provider = new Microsoft.CSharp.CSharpCodeProvider(); var codeGeneratorOptions = new CodeGeneratorOptions(); var ns = CreateNameSpace(config.Namespace); foreach (var entitMetadata in entitMetadatas.OrderBy(p => p.SchemaName)) { MakeEntity(entitMetadata, ns, picklists, referencedEntities); } var generatedOptionsets = new List <string>(); foreach (var picklist in picklists.Values.OrderBy(p => p.LogicalName)) { if (generatedOptionsets.Contains(picklist.OptionSet.Name)) { continue; } generatedOptionsets.Add(picklist.OptionSet.Name); MakOptionSet(picklist, ns); } var cu = new CodeCompileUnit(); cu.Namespaces.Add(ns); codeGeneratorOptions.BlankLinesBetweenMembers = false; codeGeneratorOptions.BracingStyle = "C"; codeGeneratorOptions.IndentString = " "; var code = new StringBuilder(); var stringWriter = new StringWriter(code); provider.GenerateCodeFromCompileUnit(cu, stringWriter, codeGeneratorOptions); var result = code.ToString().Replace("PowerAppsWebApiUtils.Entities.", ""); System.IO.File.WriteAllText(config.FileName, result); }
static void ImportSchemas(XmlSchemaSet schemas) { Console.WriteLine("Now doing schema import."); // The following code demonstrates schema import with // a surrogate. The surrogate is used to indicate that // the Person class already exists and that there is no // need to generate a new class when importing the // PersonSurrogated data contract. If the surrogate // was not used, schema import would generate a // PersonSurrogated class, and the person field // of Employee would be imported as // PersonSurrogated and not Person. XsdDataContractImporter xsdimp = new XsdDataContractImporter(); xsdimp.Options = new ImportOptions(); xsdimp.Options.DataContractSurrogate = new LegacyPersonTypeSurrogate(); xsdimp.Import(schemas); // Write out the imported schema to a C-Sharp file. // The code contains data contract types. FileStream fs4 = new FileStream("sample.cs", FileMode.Create); try { StreamWriter tw = new StreamWriter(fs4); Microsoft.CSharp.CSharpCodeProvider cdp = new Microsoft.CSharp.CSharpCodeProvider(); cdp.GenerateCodeFromCompileUnit(xsdimp.CodeCompileUnit, tw, null); tw.Flush(); } finally { fs4.Dispose(); } Console.WriteLine("\t To see the results of schema export and import,"); Console.WriteLine(" see SAMPLE.XSD and SAMPLE.CS."); Console.WriteLine(" Press ENTER to terminate the sample."); Console.ReadLine(); }
public void SaveAssembly(Diagram diagram, String path) { myassembly = new CodeCompileUnit(); myassembly.Namespaces.Add(mynamespace); Microsoft.CSharp.CSharpCodeProvider ccp = new Microsoft.CSharp.CSharpCodeProvider(); String sourceFile; if (ccp.FileExtension[0] == '.') { sourceFile = diagram.className.Name + ccp.FileExtension; } else { sourceFile = diagram.className.Name + "." + ccp.FileExtension; } var tw1 = new IndentedTextWriter(new StreamWriter(Path.Combine(path, sourceFile), false), " "); ccp.GenerateCodeFromCompileUnit(myassembly, tw1, new CodeGeneratorOptions()); tw1.Close(); }
CodeCompileUnit ParseForm() { ParseInformation parseInfo = ParserService.ParseFile(this.Generator.ViewContent.DesignerCodeFile.FileName, this.Generator.ViewContent.DesignerCodeFileContent, false); Module module = ParseFormAsModule(); #if DEBUG Console.WriteLine(module.ToCodeString()); #endif CodeDomVisitor visitor = new CodeDomVisitor(parseInfo.MostRecentCompilationUnit.ProjectContent); module.Accept(visitor); #if DEBUG // output generated CodeDOM to the console : ICSharpCode.NRefactory.Visitors.CodeDomVerboseOutputGenerator outputGenerator = new ICSharpCode.NRefactory.Visitors.CodeDomVerboseOutputGenerator(); outputGenerator.GenerateCodeFromMember(visitor.OutputCompileUnit.Namespaces[0].Types[0], Console.Out, null); CodeDomProvider cSharpProvider = new Microsoft.CSharp.CSharpCodeProvider(); cSharpProvider.GenerateCodeFromCompileUnit(visitor.OutputCompileUnit, Console.Out, null); #endif return(visitor.OutputCompileUnit); }
CodeCompileUnit ParseForm() { ParseInformation parseInfo = ParserService.ParseFile(this.Generator.ViewContent.DesignerCodeFile.FileName, this.Generator.ViewContent.DesignerCodeFileContent, false); Module module = ParseFormAsModule(); #if DEBUG Console.WriteLine(module.ToCodeString()); #endif CodeDomVisitor visitor = new CodeDomVisitor(parseInfo.MostRecentCompilationUnit.ProjectContent); module.Accept(visitor); #if DEBUG // output generated CodeDOM to the console : ICSharpCode.NRefactory.Visitors.CodeDomVerboseOutputGenerator outputGenerator = new ICSharpCode.NRefactory.Visitors.CodeDomVerboseOutputGenerator(); outputGenerator.GenerateCodeFromMember(visitor.OutputCompileUnit.Namespaces[0].Types[0], Console.Out, null); CodeDomProvider cSharpProvider = new Microsoft.CSharp.CSharpCodeProvider(); cSharpProvider.GenerateCodeFromCompileUnit(visitor.OutputCompileUnit, Console.Out, null); #endif return visitor.OutputCompileUnit; }
/// <summary> /// Generates a C# designer class. /// </summary> /// <param name="resXFile">The source resx file.</param> /// <param name="className">The base class name.</param> /// <param name="namespaceName">The namespace for the generated code.</param> /// <param name="internalClass">Specifies if the class has internal or public access level.</param> /// <returns>false if generation of at least one property failed.</returns> public static bool GenerateDesignerFile(string resXFile, string className, string namespaceName, bool internalClass) { if (!File.Exists(resXFile)) { throw new FileNotFoundException($"The file '{resXFile}' could not be found"); } if (string.IsNullOrEmpty(className)) { throw new ArgumentException($"The class name must not be empty or null"); } if (string.IsNullOrEmpty(namespaceName)) { throw new ArgumentException($"The namespace name must not be empty or null"); } string[] unmatchedElements; var codeProvider = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.CodeCompileUnit code = System.Resources.Tools.StronglyTypedResourceBuilder.Create( resXFile, className, namespaceName, codeProvider, internalClass, out unmatchedElements); var designerFileName = Path.Combine(Path.GetDirectoryName(resXFile), $"{className}.Designer.cs"); using (StreamWriter writer = new StreamWriter(designerFileName, false, System.Text.Encoding.UTF8)) { codeProvider.GenerateCodeFromCompileUnit(code, writer, new System.CodeDom.Compiler.CodeGeneratorOptions()); } return(unmatchedElements.Length == 0); }
public static byte[] GenerateAssembly(string namespaceName, string className, params CodeMemberMethod[] methods) { CodeCompileUnit unit = new CodeCompileUnit(); CodeNamespace space = new CodeNamespace(namespaceName); CodeTypeDeclaration type = new CodeTypeDeclaration(className); type.Attributes = MemberAttributes.Static | MemberAttributes.Public; type.TypeAttributes = System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Sealed; type.Members.AddRange(methods); space.Types.Add(type); unit.Namespaces.Add(space); Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.CompilerParameters options = new System.CodeDom.Compiler.CompilerParameters(); options.IncludeDebugInformation = false; options.GenerateExecutable = false; options.ReferencedAssemblies.Add(typeof(int).Assembly.Location); options.ReferencedAssemblies.Add(typeof(Vector2).Assembly.Location); System.CodeDom.Compiler.CompilerResults results = provider.CompileAssemblyFromDom(options,unit); System.CodeDom.Compiler.CodeGeneratorOptions ops = new System.CodeDom.Compiler.CodeGeneratorOptions(); ops.IndentString = "\t"; ops.VerbatimOrder = true; ops.BracingStyle = "C"; StringWriter text = new StringWriter(); provider.GenerateCodeFromCompileUnit(unit, text, ops); string code = text.ToString(); if (results.Errors.HasErrors) { string errors = ""; foreach (System.CodeDom.Compiler.CompilerError error in results.Errors) { errors += error.ToString() + Environment.NewLine; } throw new InvalidOperationException(errors); } byte[] data = File.ReadAllBytes(results.PathToAssembly); File.Delete(results.PathToAssembly); return data; }
public void Generate(string filepath, CompiledShaderReader reader) { string classname = Path.GetFileNameWithoutExtension(filepath); string outputfilename = Path.ChangeExtension(filepath, ".cs"); CodeCompileUnit targetUnit = new CodeCompileUnit(); CodeNamespace targetNamespace = new CodeNamespace("ShaderClasses"); SetCommonImports(targetNamespace); CodeTypeDeclaration targetClass = new CodeTypeDeclaration(Path.GetFileNameWithoutExtension(filepath)); targetClass.IsClass = true; targetClass.TypeAttributes = TypeAttributes.Public; CodeMemberMethod disposeMethod = ClassHelper.MakeDisposable(targetClass); if (reader.IsVertexShader) { //create a class to store vertex information CodeTypeDeclaration vertexClass = new CodeTypeDeclaration(targetClass.Name + "_Vertex"); vertexClass.IsStruct = true; //a list to store the codemembers that are vectors so we can write the serialization code List<CodeTypeMember> Vectors = new List<CodeTypeMember>(); // vectors are not serializable List<CodeTypeMember> OtherMembers = new List<CodeTypeMember>(); //get the input parameters to build our Vertex type ShaderParameterDescription[] paramdesciptions = reader.GetParameterDescription(); int sizeInBytes = 0; //test for SV_VertexID only if (paramdesciptions.All(a => a.SemanticName == "SV_VertexID")) { //no buffer needed } else { //add a the input layout field CodeMemberField inputLayoutMemberField = new CodeMemberField("InputLayout", "inputLayout"); targetClass.Members.Add(inputLayoutMemberField); ClassHelper.AddDisposalOfMember(disposeMethod, inputLayoutMemberField.Name); //read the vertex input parameters foreach (ShaderParameterDescription paramdesc in paramdesciptions) { string propertyname = new string(paramdesc.SemanticName.Take(1).ToArray()) + new string(paramdesc.SemanticName.ToLower().Skip(1).ToArray()) + paramdesc.SemanticIndex.ToString();//this may change if I find a better way to generate unique names that make sense string fieldName = "_" + propertyname; //NOTE: this contains the constructor code for all the fields as well //Usage Mask was not set-up correctly in SharpDX so we need to mask it to get the expected results //https://github.com/sharpdx/SharpDX/issues/565 int UsageMask = ((int)paramdesc.UsageMask) & (int)RegisterComponentMaskFlags.All; CodeMemberField iFX = new CodeMemberField(typeof(float), fieldName + "_X"); iFX.UserData.Add("Type", "float"); iFX.UserData.Add("Name", fieldName + "_X"); CodeMemberProperty iFXProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final,//final removes the virtual attribute Name = propertyname + "_X", Type = new CodeTypeReference(typeof(float)), HasSet = false, HasGet = true, }; iFXProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, iFX.Name))); iFXProp.UserData.Add("Type", "int"); iFXProp.UserData.Add("Name", fieldName + "_X"); CodeMemberField iSX = new CodeMemberField(typeof(int), fieldName + "_X"); iSX.UserData.Add("Type", "int"); iSX.UserData.Add("Name", fieldName + "_X"); CodeMemberProperty iSXProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final,//final removes the virtual attribute Name = propertyname + "_X", Type = new CodeTypeReference(typeof(int)), HasSet = false, HasGet = true }; iSXProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, iSX.Name))); iSXProp.UserData.Add("Type", "int"); iSXProp.UserData.Add("Name", fieldName + "_X"); CodeMemberField iSY = new CodeMemberField(typeof(int), fieldName + "_Y"); iSY.UserData.Add("Type", "int"); iSY.UserData.Add("Name", fieldName + "_Y"); CodeMemberProperty iSYProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final,//final removes the virtual attribute Name = propertyname + "_Y", Type = new CodeTypeReference(typeof(int)), HasSet = false, HasGet = true }; iSYProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, iSY.Name))); iSYProp.UserData.Add("Type", "int"); iSYProp.UserData.Add("Name", fieldName + "_Y"); CodeMemberField iSZ = new CodeMemberField(typeof(int), fieldName + "_Z"); iSZ.UserData.Add("Type", "int"); iSZ.UserData.Add("Name", fieldName + "_Z"); CodeMemberProperty iSZProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final,//final removes the virtual attribute Name = propertyname + "_Z", Type = new CodeTypeReference(typeof(int)), HasSet = false, HasGet = true }; iSZProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, iSZ.Name))); iSZProp.UserData.Add("Type", "int"); iSZProp.UserData.Add("Name", fieldName + "_Z"); CodeMemberField iSW = new CodeMemberField(typeof(int), fieldName + "_W"); iSW.UserData.Add("Type", "int"); iSW.UserData.Add("Name", fieldName + "_W"); CodeMemberProperty iSWProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final,//final removes the virtual attribute Name = propertyname + "_W", Type = new CodeTypeReference(typeof(int)), HasSet = false, HasGet = true }; iSWProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, iSW.Name))); iSWProp.UserData.Add("Type", "int"); iSWProp.UserData.Add("Name", fieldName + "_W"); CodeMemberField iUX = new CodeMemberField(typeof(uint), fieldName + "_X"); iUX.UserData.Add("Type", "uint"); iUX.UserData.Add("Name", fieldName + "_X"); CodeMemberProperty iUXProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final,//final removes the virtual attribute Name = propertyname + "_X", Type = new CodeTypeReference(typeof(uint)), HasSet = false, HasGet = true }; iUXProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, iUX.Name))); iUXProp.UserData.Add("Type", "uint"); iUXProp.UserData.Add("Name", fieldName + "_X"); CodeMemberField iUY = new CodeMemberField(typeof(uint), fieldName + "_Y"); iUY.UserData.Add("Type", "uint"); iUY.UserData.Add("Name", fieldName + "_Y"); CodeMemberProperty iUYProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final,//final removes the virtual attribute Name = propertyname + "_Y", Type = new CodeTypeReference(typeof(uint)), HasSet = false, HasGet = true }; iUYProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, iUY.Name))); iUYProp.UserData.Add("Type", "uint"); iUYProp.UserData.Add("Name", fieldName + "_Y"); CodeMemberField iUZ = new CodeMemberField(typeof(uint), fieldName + "_Z"); iUZ.UserData.Add("Type", "uint"); iUZ.UserData.Add("Name", fieldName + "_Z"); CodeMemberProperty iUZProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final,//final removes the virtual attribute Name = propertyname + "_Z", Type = new CodeTypeReference(typeof(uint)), HasSet = false, HasGet = true }; iUZProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, iUZ.Name))); iUZProp.UserData.Add("Type", "uint"); iUZProp.UserData.Add("Name", fieldName + "_Z"); CodeMemberField iUW = new CodeMemberField(typeof(uint), fieldName + "_W"); iUW.UserData.Add("Type", "uint"); iUW.UserData.Add("Name", fieldName + "_W"); CodeMemberProperty iUWProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final,//final removes the virtual attribute Name = propertyname + "_W", Type = new CodeTypeReference(typeof(uint)), HasSet = false, HasGet = true }; iUWProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, iUW.Name))); iUWProp.UserData.Add("Type", "uint"); iUWProp.UserData.Add("Name", fieldName + "_W"); switch (UsageMask) { case (int)RegisterComponentMaskFlags.ComponentX: switch (paramdesc.ComponentType) { case RegisterComponentType.Float32: vertexClass.Members.Add(iFX); vertexClass.Members.Add(iFXProp); sizeInBytes += 4; OtherMembers.Add(iFX); break; case RegisterComponentType.SInt32: vertexClass.Members.Add(iSX); vertexClass.Members.Add(iSXProp); sizeInBytes += 4; OtherMembers.Add(iSX); break; case RegisterComponentType.UInt32: vertexClass.Members.Add(iUX); vertexClass.Members.Add(iUXProp); sizeInBytes += 4; OtherMembers.Add(iUX); break; case RegisterComponentType.Unknown: default: break; } break; case (int)(RegisterComponentMaskFlags.ComponentX | RegisterComponentMaskFlags.ComponentY): switch (paramdesc.ComponentType) { case RegisterComponentType.Float32: CodeMemberField vector = new CodeMemberField("Vector2", fieldName); vector.UserData.Add("Type", "Vector2"); vector.UserData.Add("Name", fieldName); CodeMemberProperty vectorProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = propertyname, Type = new CodeTypeReference(typeof(Vector2)), HasGet = true, HasSet = false, }; vectorProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, fieldName))); vectorProp.UserData.Add("Type", "Vector2"); vectorProp.UserData.Add("Name", fieldName); vertexClass.Members.Add(vector); vertexClass.Members.Add(vectorProp); sizeInBytes += 8; Vectors.Add(vector); break; case RegisterComponentType.SInt32: vertexClass.Members.Add(iSX); vertexClass.Members.Add(iSXProp); vertexClass.Members.Add(iSY); vertexClass.Members.Add(iSYProp); sizeInBytes += 8; OtherMembers.Add(iSX); OtherMembers.Add(iSY); break; case RegisterComponentType.UInt32: vertexClass.Members.Add(iUX); vertexClass.Members.Add(iUXProp); vertexClass.Members.Add(iUY); vertexClass.Members.Add(iUYProp); sizeInBytes += 8; OtherMembers.Add(iUX); OtherMembers.Add(iUY); break; case RegisterComponentType.Unknown: default: break; } break; case (int)(RegisterComponentMaskFlags.ComponentX | RegisterComponentMaskFlags.ComponentY | RegisterComponentMaskFlags.ComponentZ): switch (paramdesc.ComponentType) { case RegisterComponentType.Float32: CodeMemberField vector = new CodeMemberField("Vector3", fieldName); vector.UserData.Add("Type", "Vector3"); vector.UserData.Add("Name", fieldName); CodeMemberProperty vectorProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = propertyname, Type = new CodeTypeReference(typeof(Vector3)), HasGet = true, HasSet = false, }; vectorProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, fieldName))); vectorProp.UserData.Add("Type", "Vector3"); vectorProp.UserData.Add("Name", fieldName); vertexClass.Members.Add(vector); vertexClass.Members.Add(vectorProp); sizeInBytes += 12; Vectors.Add(vector); break; case RegisterComponentType.SInt32: vertexClass.Members.Add(iSX); vertexClass.Members.Add(iSY); vertexClass.Members.Add(iSZ); vertexClass.Members.Add(iSXProp); vertexClass.Members.Add(iSYProp); vertexClass.Members.Add(iSZProp); sizeInBytes += 12; OtherMembers.Add(iSX); OtherMembers.Add(iSY); OtherMembers.Add(iSZ); break; case RegisterComponentType.UInt32: vertexClass.Members.Add(iUX); vertexClass.Members.Add(iUY); vertexClass.Members.Add(iUZ); vertexClass.Members.Add(iUXProp); vertexClass.Members.Add(iUYProp); vertexClass.Members.Add(iUZProp); sizeInBytes += 12; OtherMembers.Add(iUX); OtherMembers.Add(iUY); OtherMembers.Add(iUZ); break; case RegisterComponentType.Unknown: default: break; } break; case (int)RegisterComponentMaskFlags.All: switch (paramdesc.ComponentType) { case RegisterComponentType.Float32: CodeMemberField vector = new CodeMemberField("Vector4", fieldName); vector.UserData.Add("Type", "Vector4"); vector.UserData.Add("Name", fieldName); CodeMemberProperty vectorProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = propertyname, Type = new CodeTypeReference(typeof(Vector4)), HasGet = true, HasSet = false, }; vectorProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, fieldName))); vectorProp.UserData.Add("Type", "Vector4"); vectorProp.UserData.Add("Name", fieldName); vertexClass.Members.Add(vector); vertexClass.Members.Add(vectorProp); sizeInBytes += 16; Vectors.Add(vector); break; case RegisterComponentType.SInt32: vertexClass.Members.Add(iSX); vertexClass.Members.Add(iSY); vertexClass.Members.Add(iSZ); vertexClass.Members.Add(iSW); vertexClass.Members.Add(iSXProp); vertexClass.Members.Add(iSYProp); vertexClass.Members.Add(iSZProp); vertexClass.Members.Add(iSWProp); sizeInBytes += 16; OtherMembers.Add(iSX); OtherMembers.Add(iSY); OtherMembers.Add(iSZ); OtherMembers.Add(iSW); break; case RegisterComponentType.UInt32: vertexClass.Members.Add(iUX); vertexClass.Members.Add(iUY); vertexClass.Members.Add(iUZ); vertexClass.Members.Add(iUW); vertexClass.Members.Add(iUXProp); vertexClass.Members.Add(iUYProp); vertexClass.Members.Add(iUZProp); vertexClass.Members.Add(iUWProp); sizeInBytes += 16; OtherMembers.Add(iUX); OtherMembers.Add(iUY); OtherMembers.Add(iUZ); OtherMembers.Add(iUW); break; case RegisterComponentType.Unknown: default://not sure what to do here break; } break; case (int)RegisterComponentMaskFlags.None: default://not sure what to do here break; } } //calculate size of input struct and add attributes vertexClass.CustomAttributes = new CodeAttributeDeclarationCollection( new CodeAttributeDeclaration[] { new CodeAttributeDeclaration("Serializable"), new CodeAttributeDeclaration("StructLayout",new CodeAttributeArgument[] { new CodeAttributeArgument(new CodeSnippetExpression("LayoutKind.Sequential")), new CodeAttributeArgument("Size",new CodeSnippetExpression(sizeInBytes.ToString()))//this will need normalized to a multiple of 16(BYTE) }), }); //build serialization method if (Vectors.Count > 0) { ClassHelper.MakeSerilizable(vertexClass); } //generate Equality code ClassHelper.GenerateEqualityCode(vertexClass); //add input type to namespace targetNamespace.Types.Add(vertexClass); } } //add constant buffer classes CodeTypeDeclaration[] cBufferClasses = ClassHelper.GenerateConstantBufferClasses(reader.GetConsttantBuffers()); targetNamespace.Types.AddRange(cBufferClasses); //add samplers to the shaderclass //add directX objects //add the correct Shader class string shaderName = "NULL"; switch (reader.TypePrefix) { case "vs": { shaderName = "vertexShader"; targetClass.Members.Add(new CodeMemberField(vertexShaderRef, shaderName)); break; } case "ps": { shaderName = "pixelShader"; targetClass.Members.Add(new CodeMemberField(pixelShaderRef, shaderName)); break; } case "ds": { shaderName = "domainShader"; targetClass.Members.Add(new CodeMemberField(domainShaderRef, shaderName)); break; } case "hs": { shaderName = "hullShader"; targetClass.Members.Add(new CodeMemberField(hullShaderRef, shaderName)); break; } case "gs": { shaderName = "geometryShader"; targetClass.Members.Add(new CodeMemberField(geometryShaderRef, shaderName)); break; } } if (shaderName != "NULL") { ClassHelper.AddDisposalOfMember(disposeMethod, shaderName); } else throw new Exception("unrecognized Shader prefix. check the shader profile in the reader code"); foreach (CodeTypeDeclaration cbuffer in cBufferClasses) { string bufferName = cbuffer.Name.ToLower() + "Buffer"; targetClass.Members.Add(new CodeMemberField(bufferRef, bufferName)); ClassHelper.AddDisposalOfMember(disposeMethod, bufferName); } //add buffer assignment methods //add others //add dispose method targetClass.Members.Add(disposeMethod); //wrap up ///////////////////////////////////////////////////////////////////////////////////////////////////// targetNamespace.Types.Add(targetClass); targetUnit.Namespaces.Add(targetNamespace); using (Microsoft.CSharp.CSharpCodeProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider()) { CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; using (StreamWriter sourceWriter = new StreamWriter(outputfilename)) { codeProvider.GenerateCodeFromCompileUnit( targetUnit, sourceWriter, options); } } }
private static void GenerateCode(Options options) { var packageTransform = new NMF.Models.Meta.Meta2ClassesTransformation(); var stopWatch = new Stopwatch(); packageTransform.ForceGeneration = options.Force; packageTransform.CreateOperations = options.Operations; packageTransform.DefaultNamespace = options.OverallNamespace; Dictionary<Uri, string> mappings = null; if (options.NamespaceMappings != null && options.NamespaceMappings.Count > 0) { mappings = new Dictionary<Uri, string>(); foreach (var mapping in options.NamespaceMappings) { if (string.IsNullOrEmpty(mapping)) continue; var lastIdx = mapping.LastIndexOf('='); if (lastIdx == -1) { Console.WriteLine("Namespace mapping {0} is missing required separator =", mapping); continue; } Uri uri; if (!Uri.TryCreate(mapping.Substring(0, lastIdx), UriKind.Absolute, out uri)) { uri = new Uri(mapping.Substring(0, lastIdx), UriKind.Relative); } mappings.Add(uri, mapping.Substring(lastIdx + 1)); } } var metaPackage = LoadPackageFromFiles(options.InputFiles, options.OverallNamespace, mappings); if (options.Uri != null) { Uri uri; if (Uri.TryCreate(options.Uri, UriKind.Absolute, out uri)) { metaPackage.Uri = uri; } else { Console.Error.WriteLine("The provided string {0} could not be parsed as an absolute URI.", options.Uri); } } if (metaPackage.Uri == null) { Console.Error.WriteLine("Warning: There is no base Uri for the provided metamodels. Some features of the generated code will be disabled."); } var model = metaPackage.Model; if (model == null) { model = new Model(); model.RootElements.Add(metaPackage); } model.ModelUri = metaPackage.Uri; if (options.NMeta != null) { using (var fs = File.Create(options.NMeta)) { MetaRepository.Instance.Serializer.Serialize(model, fs); } } stopWatch.Start(); var compileUnit = TransformationEngine.Transform<INamespace, CodeCompileUnit>(metaPackage, options.Parallel ? (ITransformationEngineContext)new ParallelTransformationContext(packageTransform) : new TransformationContext(packageTransform)); stopWatch.Stop(); Console.WriteLine("Operation took {0}ms", stopWatch.Elapsed.TotalMilliseconds); CodeDomProvider generator = null; switch (options.Language) { case SupportedLanguage.CS: generator = new Microsoft.CSharp.CSharpCodeProvider(); break; case SupportedLanguage.VB: generator = new Microsoft.VisualBasic.VBCodeProvider(); break; case SupportedLanguage.CPP: generator = new Microsoft.VisualC.CppCodeProvider(); break; case SupportedLanguage.JS: generator = new Microsoft.JScript.JScriptCodeProvider(); break; default: Console.WriteLine("Unknown language detected. Falling back to default C#"); generator = new Microsoft.CSharp.CSharpCodeProvider(); break; } var genOptions = new System.CodeDom.Compiler.CodeGeneratorOptions() { BlankLinesBetweenMembers = true, VerbatimOrder = false, ElseOnClosing = false, BracingStyle = "C", IndentString = " " }; if (options.UseFolders) { foreach (var file in MetaFacade.SplitCompileUnit(compileUnit)) { var fileInfo = new FileInfo(Path.Combine(options.OutputFile, file.Key) + "." + generator.FileExtension); CheckDirectoryExists(fileInfo.Directory); using (var fs = fileInfo.Create()) { using (var sw = new StreamWriter(fs)) { generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions); } } } } else { using (var sw = new StreamWriter(options.OutputFile)) { generator.GenerateCodeFromCompileUnit(compileUnit, sw, genOptions); } } Console.WriteLine("Code generated successfully!"); }
public void WriteCode(string mainFileName, string stubFileName) { Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "Writing code to {0} and {1}", mainFileName, stubFileName)); string mainTempFile = Path.GetTempFileName(); string stubTempFile = Path.GetTempFileName(); try { using (CodeDomProvider provider = new Microsoft.CSharp.CSharpCodeProvider()) { StreamWriter mainFileWriter = null; try { mainFileWriter = new StreamWriter(mainTempFile); using (IndentedTextWriter mainFileTextWriter = new IndentedTextWriter(mainFileWriter, " ")) { mainFileWriter = null; CodeGeneratorOptions cgo = new CodeGeneratorOptions(); cgo.BracingStyle = "C"; cgo.IndentString = IndentString; try { provider.GenerateCodeFromCompileUnit(this.mainCcu, mainFileTextWriter, cgo); } catch (ArgumentException ae) { Regex r = new Regex(@"Invalid Primitive Type: (?<DataType>\S+). Consider using CodeObjectCreateExpression."); Match m = r.Match(ae.Message); if (m.Success) { throw new UserException(string.Format(CultureInfo.CurrentCulture, Messages.UTGenerator_TypeNotSupported, m.Result("${DataType}"))); } else { throw; } } mainFileTextWriter.Close(); } } finally { if (mainFileWriter != null) { mainFileWriter.Dispose(); } } // Any namespaces in the main class to be copied across to the stub as they will be needed there too. foreach (CodeNamespaceImport n in this.mainTestNamespace.Imports) { this.stubTestNamespace.Imports.Add(n); } StreamWriter stubFileWriter = null; try { stubFileWriter = new StreamWriter(stubTempFile); using (IndentedTextWriter stubTextFileWriter = new IndentedTextWriter(stubFileWriter, " ")) { stubFileWriter = null; CodeGeneratorOptions cgo = new CodeGeneratorOptions(); cgo.BracingStyle = "C"; provider.GenerateCodeFromCompileUnit(this.stubCcu, stubTextFileWriter, cgo); stubTextFileWriter.Close(); } } finally { if (stubFileWriter != null) { stubFileWriter.Dispose(); } } File.Copy(mainTempFile, mainFileName, true); File.Copy(stubTempFile, stubFileName, true); } } finally { File.Delete(mainTempFile); File.Delete(stubTempFile); } Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "Completed writing code to {0} and {1}", mainFileName, stubFileName)); }
static void Main3() { CodeMemberMethod Calc = new CodeMemberMethod() { Name = "Calc", Attributes = MemberAttributes.Public | MemberAttributes.Static }; Calc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "x")); Calc.Statements.Add( new CodeConditionStatement( new CodeBinaryOperatorExpression( new CodeArgumentReferenceExpression("x"), CodeBinaryOperatorType.LessThanOrEqual, new CodeSnippetExpression("1") ), new CodeMethodReturnStatement(new CodeSnippetExpression("1")) ) ); Calc.Statements.Add( new CodeMethodReturnStatement( new CodeBinaryOperatorExpression( new CodeMethodInvokeExpression(null, "Calc", new CodeBinaryOperatorExpression( new CodeArgumentReferenceExpression("x"), CodeBinaryOperatorType.Subtract, new CodeSnippetExpression("1") ) ), CodeBinaryOperatorType.Add, new CodeMethodInvokeExpression(null, "Calc", new CodeBinaryOperatorExpression( new CodeArgumentReferenceExpression("x"), CodeBinaryOperatorType.Subtract, new CodeSnippetExpression("2") ) ) ) ) ); CodeTypeDeclaration Fibonacci = new CodeTypeDeclaration(); Fibonacci.Members.Add(Calc); CodeNamespace ns = new CodeNamespace("TestNS"); ns.Types.Add(Fibonacci); CodeCompileUnit unit = new CodeCompileUnit(); unit.Namespaces.Add(ns); using (TextWriter tw = new IndentedTextWriter(Console.Out)) { using (CodeDomProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider()) { codeProvider.GenerateCodeFromCompileUnit(unit, tw, new CodeGeneratorOptions()); } } }
private static void writeSource(string outputFile, CodeCompileUnit cu) { Microsoft.CSharp.CSharpCodeProvider csp = new Microsoft.CSharp.CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; options.BlankLinesBetweenMembers = false; using (StreamWriter writer = new StreamWriter(outputFile, false)) { csp.GenerateCodeFromCompileUnit(cu, writer, options); } }
// Emit byte code for the expression tree owned by this root. // Accepts the compiler parameters that were given to PieCodeProvider // since it will be needed for the CSharpCodeProvider. public CompilerResults Emit(CompilerParameters compilerParams, Root root) { // Emit the code compile unit, the top of the codedom tree. // This method will cal emit method for all child expressions // until all expressions have had byte code emitted. var codeCompileUnit = RootEmitter.Emit(root); // Create the C# compiler. var csProvider = new Microsoft.CSharp.CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; // Compile the codedom tree into an assembly var sw = new StringWriter(); csProvider.GenerateCodeFromCompileUnit(codeCompileUnit, sw, options); // Display the C# code for debugging purposes. string ccode = sw.GetStringBuilder().ToString(); Console.WriteLine(ccode); // Get the results of the compilation: the assembly and error list CompilerResults results = csProvider.CompileAssemblyFromSource(compilerParams, ccode); // Store all C# compiler errors, so that they can be included with Pie compiler errors.. foreach (CompilerError e in root.CompilerErrors) results.Errors.Add(e); root.CompilerErrors.Clear(); return results; }
private void generateResourceMenuItem_Click(object sender, EventArgs e) { Point origStart = GetOriginalXY(selStartMousePos); Point origEnd = GetOriginalXY(selEndMousePos); if (selStartMousePos.X != 0 || selStartMousePos.Y != 0) { int top = origStart.Y < origEnd.Y ? origStart.Y : origEnd.Y; int left = origStart.X < origEnd.X ? origStart.X : origEnd.X; int width = Math.Abs(origEnd.X - origStart.X); int height = Math.Abs(origEnd.Y - origStart.Y); Rectangle box = new Rectangle(left, top, width, height); Bitmap bitmap = ((Bitmap)image).Clone(box, ((Bitmap)image).PixelFormat); if (Statics.DTE.Solution.IsOpen) { foreach (EnvDTE.Project proj in Statics.DTE.Solution.Projects) { if (proj.Name.Contains("Test")) { try { ImageInputForm inputForm = new ImageInputForm(); inputForm.ShowDialog(); Microsoft.CSharp.CSharpCodeProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider(); string resFile = Path.GetDirectoryName(proj.FileName) + @"\Properties\Resources.resx"; string resDesginFile = Path.GetDirectoryName(proj.FileName) + @"\Properties\Resources.Designer.cs"; System.Resources.ResXResourceReader reader = new System.Resources.ResXResourceReader(resFile); using (System.Resources.ResXResourceWriter writer = new System.Resources.ResXResourceWriter(resFile + ".new")) { System.Collections.IDictionaryEnumerator iterator = reader.GetEnumerator(); while (iterator.MoveNext()) { writer.AddResource(iterator.Key.ToString(), iterator.Value); } writer.AddResource(inputForm.Input, bitmap); writer.Generate(); } File.Copy(resFile + ".new", resFile, true); File.Delete(resFile + ".new"); string[] unMatched; System.CodeDom.CodeCompileUnit unit = System.Resources.Tools.StronglyTypedResourceBuilder.Create(resFile, "Resources", proj.Properties.Item("DefaultNamespace").Value + ".Properties", codeProvider, true, out unMatched); using (StreamWriter designWriter = new StreamWriter(resDesginFile)) { codeProvider.GenerateCodeFromCompileUnit(unit, designWriter, new System.CodeDom.Compiler.CodeGeneratorOptions()); } MessageBox.Show("Image generation succeeded", "Resources Updated"); return; } catch (Exception ex) { MessageBox.Show("Image generation failed\n" + ex.Message, "Resources Did Not Update"); } } } MessageBox.Show("You need to have a project open, named *Test*", "Resources Did Not Update"); return; } MessageBox.Show("You need to have a solution open with a project named *Test*", "Resources Did Not Update"); return; } }
private void SaveAssembly(string Path) { //Create a new object of the global CodeCompileUnit class. myassembly = new CodeCompileUnit(); //Add the namespace to the assembly. myassembly.Namespaces.Add(mynamespace); //Add the following compiler parameters. (The references to the //standard .net dll(s) and framework library). CompilerParameters comparam = new CompilerParameters(new string[] { "mscorlib.dll" }); comparam.ReferencedAssemblies.Add("System.dll"); comparam.ReferencedAssemblies.Add("System.Core.dll"); comparam.ReferencedAssemblies.Add("System.Data.dll"); comparam.ReferencedAssemblies.Add("System.Data.DataSetExtensions.dll"); comparam.ReferencedAssemblies.Add("System.Xml.dll"); comparam.ReferencedAssemblies.Add("System.Xml.Linq.dll"); comparam.ReferencedAssemblies.Add("System.Core.dll"); //comparam.ReferencedAssemblies.Add("System.Collections.Generic.dll"); comparam.ReferencedAssemblies.Add("Driver.dll"); comparam.ReferencedAssemblies.Add("SupportLibrary.dll"); comparam.ReferencedAssemblies.Add("log4net.dll"); //Indicates Whether the compiler has to generate the output in //memory comparam.GenerateInMemory = false; //Indicates whether the output is an executable. comparam.GenerateExecutable = true; //provide the name of the class which contains the Main Entry //point method comparam.MainClass = "mynamespace.myclass"; //provide the path where the generated assembly would be placed comparam.OutputAssembly = @Path; //Create an instance of the c# compiler and pass the assembly to //compile Microsoft.CSharp.CSharpCodeProvider ccp = new Microsoft.CSharp.CSharpCodeProvider(); //Build to cs file CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; using (StreamWriter sourceWriter = new StreamWriter( @"release.cs")) { ccp.GenerateCodeFromCompileUnit( myassembly, sourceWriter, options); } ICodeCompiler icc = ccp.CreateCompiler(); ////The CompileAssemblyFromDom would either return the list of ////compile time errors (if any), or would create the ////assembly in the respective path in case of successful //compilation CompilerResults compres = icc.CompileAssemblyFromDom(comparam, myassembly); if (compres == null || compres.Errors.Count > 0) { for (int i = 0; i < compres.Errors.Count; i++) { //Console.WriteLine(compres.Errors[i]); MessageShow.Writelog("CCodeGenerator.cs::", compres.Errors[i].ToString()); } } }
static void Main(string[] args) { if (args.Length != 1) { Console.WriteLine("Usage:\n\t{0} <idl file>", Path.GetFileName(Environment.GetCommandLineArgs()[0])); return; } string in_filename = args[0]; if (!File.Exists(in_filename)) { Console.WriteLine("{0} not exists.", in_filename); return; } string out_filename = Path.ChangeExtension(in_filename, ".cs"); try { string idl = File.ReadAllText(in_filename); if (idl == null || idl.Length == 0) { Console.WriteLine("Fail reading input file."); return; } MatchCollection r; #region Process include //while (ProcessInclude(ref idl)) { } #endregion #region Prepare mapping hash table Dictionary<string, string> type_def_table = new Dictionary<string, string>(); Dictionary<string, string> type_mapping_table = new Dictionary<string, string>(); type_mapping_table.Add("int", "int"); type_mapping_table.Add("short", "short"); type_mapping_table.Add("long", "int"); type_mapping_table.Add("double", "double"); type_mapping_table.Add("LONGLONG", "Int64"); type_mapping_table.Add("unsigned long", "uint"); type_mapping_table.Add("unsigned char", "byte"); type_mapping_table.Add("void", "IntPtr"); type_mapping_table.Add("HRESULT", "int"); type_mapping_table.Add("BOOL", "bool"); type_mapping_table.Add("bool", "bool"); type_mapping_table.Add("BSTR", "string"); type_mapping_table.Add("interface", "interface"); type_mapping_table.Add("enum", "enum"); #endregion StreamWriter w = new StreamWriter(out_filename, false); w.WriteLine("// Auto generated by idl2cs /(c) toki, 2009/ @ {0}", DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")); w.WriteLine("using System;"); w.WriteLine("using System.Collections.Generic;"); w.WriteLine("using System.Text;"); w.WriteLine("using System.Runtime.InteropServices;"); w.WriteLine(""); w.WriteLine("namespace {0}\n{{", Path.GetFileNameWithoutExtension(in_filename)); #if USE_DOM StreamWriter code_writer = new StreamWriter(Path.ChangeExtension(out_filename, ".code.cs"), false); CodeCompileUnit code_root = new CodeCompileUnit(); CodeNamespace code_imports = new CodeNamespace(); code_root.Namespaces.Add(code_imports); code_imports.Comments.Add(new CodeCommentStatement(String.Format("Auto generated by idl2cs /(c) toki, 2009/ @ {0}", DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")))); code_imports.Imports.Add(new CodeNamespaceImport("System")); code_imports.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); code_imports.Imports.Add(new CodeNamespaceImport("System.Text")); code_imports.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices")); CodeNamespace code = new CodeNamespace(Path.GetFileNameWithoutExtension(in_filename)); code_root.Namespaces.Add(code); CodeTypeDeclaration test_enum = new CodeTypeDeclaration("BMDTestEnum"); test_enum.IsEnum = true; CodeMemberField mt = new CodeMemberField("", "TEST03"); mt.InitExpression = new CodePrimitiveExpression(0xFFFF); test_enum.Members.Add(new CodeMemberField("", "TEST01")); test_enum.Members.Add(new CodeMemberField("", "TEST02")); test_enum.Members.Add(mt); code.Types.Add(test_enum); #endif r = null; #region typedef Console.WriteLine("Process typedef ..."); r = find_typedef.Matches(idl); foreach (Match m in r) { try { string key = m.Groups["key"].Value; string value = m.Groups["value"].Value; //Console.WriteLine("Adding: {0} => {1}", key, value); if (type_def_table.ContainsKey(key)) { if (value.StartsWith("enum ")) { type_def_table.Remove(key); type_def_table.Add(key, "enum"); type_def_table.Add(value.Substring(5).Trim(), key); } } else { type_def_table.Add(m.Groups["key"].Value, m.Groups["value"].Value); } } catch (Exception) { Console.WriteLine("Error when add: {0} => {1}", m.Groups["key"].Value, m.Groups["value"].Value); } } foreach (KeyValuePair<string, string> p in type_def_table) { Console.WriteLine("\t{0} => {1}", p.Key, p.Value); } Console.WriteLine("Total {0} typedef processed.", r.Count); #endregion #region enum Console.WriteLine("Process enum ..."); r = find_enum.Matches(idl); w.Write("#region enum"); foreach (Match m in r) { string enum_name = m.Groups["name2"].Value.Trim() == String.Empty ? m.Groups["name1"].Value.Trim() : m.Groups["name2"].Value.Trim(); string def_name; type_def_table.TryGetValue(enum_name, out def_name); if (!String.IsNullOrEmpty(def_name)) enum_name = def_name; Console.WriteLine("\t{0}", enum_name); w.WriteLine(); if (enum_name.EndsWith("s")) { w.WriteLine("// idl2cs warning: possible flag enum\n[Flags]"); } w.WriteLine("public enum {0}\n{{{1}}}", enum_name, m.Groups["body"].Value); if (!type_def_table.ContainsKey(enum_name)) type_def_table.Add(enum_name, "enum"); } w.WriteLine("#endregion"); Console.WriteLine("Total {0} enum processed.", r.Count); #endregion #region coclass Console.WriteLine("Process coclass ..."); // r = find_coclass.Matches(idl); w.Write("\n#region coclass"); while (true) { Match m = find_coclass.Match(idl); if (!m.Success) break; w.WriteLine(); string cc_name = m.Groups["name"].Value.Trim(); string cc_attr = m.Groups["attr"].Value.Trim(); string cc_declear = m.Groups["declear"].Value.Trim(); string cc_uuid = string.Empty; Console.WriteLine("\tProcess coclass {0}", cc_name); Match mm = null; mm = find_helpstring.Match(cc_attr); if (mm.Success) w.WriteLine("/// <summary>\n/// {0}\n/// </summary>", mm.Groups["value"].Value); mm = null; mm = find_uuid.Match(cc_attr); if (mm.Success) { cc_uuid = mm.Groups["value"].Value; w.WriteLine(@"[ComImport, Guid(""{0}"")]", cc_uuid); } w.WriteLine("public class {0}\n{{\n/*\nidl2cs warning: edit this block for helper\n{1}\n*/\n}}", cc_name, cc_declear); idl = idl.Remove(m.Captures[0].Index, m.Captures[0].Length); } //foreach (Match m in r) //{ // w.WriteLine(); // string cc_name = m.Groups["name"].Value.Trim(); // string cc_attr = m.Groups["attr"].Value.Trim(); // string cc_declear = m.Groups["declear"].Value.Trim(); // string cc_uuid = string.Empty; // Console.WriteLine("\tProcess coclass {0}", cc_name); // Match mm = null; // mm = find_helpstring.Match(cc_attr); // if (mm.Success) // w.WriteLine("/// <summary>\n/// {0}\n/// </summary>", mm.Groups["value"].Value); // mm = null; // mm = find_uuid.Match(cc_attr); // if (mm.Success) // { // cc_uuid = mm.Groups["value"].Value; // w.WriteLine(@"[ComImport, Guid(""{0}"")]", cc_uuid); // } // w.WriteLine("public class {0}\n{{\n/*\nidl2cs warning: edit this block for helper\n{1}\n*/\n}}", cc_name, cc_declear); // idl = idl.Remove(m.Captures[0].Index, m.Captures[0].Length); //} w.WriteLine("#endregion"); Console.WriteLine("Total {0} coclass processed.", r.Count); #endregion #region pre-scan interrface Console.WriteLine("Pre-scan interface ..."); r = find_interface.Matches(idl); foreach (Match m in r) { string interface_name = m.Groups["name"].Value.Trim(); if (!type_def_table.ContainsKey(interface_name)) { type_def_table.Add(interface_name, "interface"); Console.WriteLine("\tAdd {0} to def hash table.", interface_name); } } Console.WriteLine("Total {0} interface scanned.", r.Count); #endregion #region interface Console.WriteLine("Process interface ..."); r = find_interface.Matches(idl); w.Write("\n#region interface"); foreach (Match m in r) { string interface_name = m.Groups["name"].Value.Trim(); string interface_type = m.Groups["type"].Value.Trim(); string interface_comtype = interface_type == "IDispatch" ? "InterfaceIsIDispatch" : "InterfaceIsIUnknown"; string interface_attr = m.Groups["attr"].Value.Trim(); Console.WriteLine("\tProcess interface: {0} => type: {1}", interface_name, interface_type); Match uuid; uuid = find_uuid.Match(interface_attr); Match helpstring; helpstring = find_helpstring.Match(interface_attr); w.WriteLine(); w.WriteLine("/// <summary>\n/// {0}\n/// </summary>", helpstring.Groups["value"].Value); w.WriteLine(@"[ComImport, Guid(""{0}""), InterfaceType(ComInterfaceType.{1})]", uuid.Groups["value"].Value, interface_comtype); if (interface_type == "IUnknown" || interface_type == "IDispatch") w.WriteLine("public interface {0}\n{{", interface_name); else w.WriteLine("public interface {0} : {1}\n{{", interface_name, interface_type); if (!type_def_table.ContainsKey(interface_name)) type_def_table.Add(interface_name, "interface"); MatchCollection rr = find_function.Matches(m.Groups["function"].Value); foreach (Match mm in rr) { string func_type = mm.Groups["func_type"].Value.Trim(); string func_name = mm.Groups["func_name"].Value.Trim(); //Console.WriteLine("\t{0} {1}", func_type, func_name); string func_native_type = string.Empty; if (!type_mapping_table.TryGetValue(func_type, out func_native_type)) if (!type_def_table.TryGetValue(func_type, out func_native_type)) { Console.WriteLine("[warning] unable to mapping {0} to c# native type.", func_type); w.WriteLine("// idl2cs warning: unmapped type: {0}", func_type); } if (!type_mapping_table.ContainsValue(func_native_type)) { if (!type_mapping_table.TryGetValue(func_native_type, out func_native_type)) { Console.WriteLine("[warning] unable to mapping {0} to c# native type.", func_native_type); w.WriteLine("// idl2cs warning: unmapped type: {0}", func_native_type); } } if (!string.IsNullOrEmpty(func_native_type) && func_native_type != "enum") func_type = func_native_type; string func_paras = string.Empty; if (mm.Groups["func_para"].Value.Trim() != "void") { string[] paras = mm.Groups["func_para"].Value.Split(new char[] { ',' }); for (int i = 0; i < paras.Length; i++) { string pa = paras[i].Trim(); string para_attr; //Console.WriteLine(pa); Match ma = find_func_attr.Match(pa.Trim()); string[] pa_split = null; if (ma.Success) { para_attr = ma.Groups["attr"].Value; pa_split = ma.Groups["para"].Value.Trim().Split(); } else { para_attr = string.Empty; pa_split = pa.Split(); } if (pa_split.Length < 2) continue; int j = pa_split.Length - 1; string para_type = string.Empty; string para_native_type = string.Empty; string para_name = pa_split[j]; int para_ptr_count = 0; foreach (char c in para_name) { if (c == '*') para_ptr_count++; else break; } j--; para_type = pa_split[j]; if (para_ptr_count != 0) { para_name = para_name.Substring(para_ptr_count); } else { for (int ii = para_type.Length - 1; ii != 0; ii--) { if (para_type[ii] == '*') para_ptr_count++; else break; } if (para_ptr_count != 0) { para_type = para_type.Substring(0, para_type.Length - para_ptr_count); } } j--; while (j >= 0) { para_type = pa_split[j] + " " + para_type; j--; } if (!type_mapping_table.TryGetValue(para_type, out para_native_type)) if (!type_def_table.TryGetValue(para_type, out para_native_type)) { Console.WriteLine("[warning] unable to mapping {0} to c# natvie type.", para_type); w.WriteLine("// idl2cs warning: unmapped type: {0}", para_type); } if (!type_mapping_table.ContainsValue(para_native_type)) { if (!type_mapping_table.TryGetValue(para_native_type, out para_native_type)) { Console.WriteLine("[warning] unable to mapping {0} to c# native type.", para_native_type); w.WriteLine("// idl2cs warning: unmapped type: {0}", para_native_type); } } string final_para = string.Empty; bool is_out = false; switch (para_attr) { case "in": final_para += "[In"; break; case "out": final_para += "[Out"; is_out = true; break; default: break; } if (final_para != string.Empty) { if (para_type == "BSTR") final_para += ", MarshalAs(UnmanagedType.BStr)"; final_para += "] "; } switch (para_ptr_count) { case 0: goto normal_final_para_type; case 1: if (!is_out) { if (para_native_type == "interface") final_para += para_type + " "; else if (para_type == "void") final_para += para_native_type + " "; else Console.WriteLine("[warning] {0}/{1}* with [In] attr in {2}:{3}", para_type, para_native_type, interface_name, func_name); goto after_normal_final_para_type; } else { final_para += "out "; goto normal_final_para_type; } case 2: if (is_out) { if (para_native_type == "interface") { final_para += string.Format("out {0} ", para_type); goto after_normal_final_para_type; } else if (para_type == "void") { final_para += string.Format("out {0} ", para_native_type); goto after_normal_final_para_type; } } Console.WriteLine("[warning] {0}/{1}** in {2}:{3}", para_type, para_native_type, interface_name, func_name); goto after_normal_final_para_type; default: break; } normal_final_para_type: if (para_native_type == "interface" || para_native_type == "enum") final_para += para_type + " "; else final_para += para_native_type + " "; after_normal_final_para_type: final_para += para_name; //Console.WriteLine(final_para); func_paras += final_para + ", "; } } if (!string.IsNullOrEmpty(func_paras)) func_paras = func_paras.Substring(0, func_paras.Length - 2); w.WriteLine("\t[PreserveSig]\n\t{0} {1} ({2});", func_type, func_name, func_paras); } w.WriteLine("}}", interface_name); } w.WriteLine("#endregion"); Console.WriteLine("Total {0} interface processed.", r.Count); #endregion w.WriteLine("}"); w.Close(); #if USE_DOM Microsoft.CSharp.CSharpCodeProvider code_provider = new Microsoft.CSharp.CSharpCodeProvider(); CodeGeneratorOptions code_opts = new CodeGeneratorOptions(); code_opts.BlankLinesBetweenMembers = false; code_opts.VerbatimOrder = true; code_opts.BracingStyle = "C"; code_provider.GenerateCodeFromCompileUnit(code_root, code_writer, code_opts); code_writer.Close(); #endif } catch (Exception e) { Console.WriteLine(e); return; } #if AUTO_DUMP_OUTPUT Console.WriteLine("\nDumping output file: {0}\n", out_filename); StreamReader o = new StreamReader(out_filename); while (!o.EndOfStream) { Console.WriteLine(o.ReadLine()); } o.Close(); #endif }
private static void OutputGeneratedCode(CodeCompileUnit compileUnit) { Microsoft.CSharp.CSharpCodeProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider(); using (MemoryStream stream = new MemoryStream()) using (TextWriter textWriter = new StreamWriter(stream)) { codeProvider.GenerateCodeFromCompileUnit(compileUnit, textWriter, new System.CodeDom.Compiler.CodeGeneratorOptions()); textWriter.Flush(); stream.Seek(0, SeekOrigin.Begin); using (StreamReader reader = new StreamReader(stream)) { string output = reader.ReadToEnd(); //Trace.WriteLine(output); } } }
private void OutputGeneratedCode(CodeCompileUnit compileUnit) { CodeDomProvider generator = null; switch (options.Language) { case SupportedLanguage.CS: generator = new Microsoft.CSharp.CSharpCodeProvider(); break; case SupportedLanguage.VB: generator = new Microsoft.VisualBasic.VBCodeProvider(); break; case SupportedLanguage.CPP: generator = new Microsoft.VisualC.CppCodeProvider(); break; case SupportedLanguage.JS: generator = new Microsoft.JScript.JScriptCodeProvider(); break; case SupportedLanguage.PY: generator = new PythonProvider(); break; default: Console.WriteLine("Unknown language detected. Falling back to default C#"); generator = new Microsoft.CSharp.CSharpCodeProvider(); break; } var genOptions = new CodeGeneratorOptions() { BlankLinesBetweenMembers = true, VerbatimOrder = false, ElseOnClosing = false, BracingStyle = "C", IndentString = " " }; if (options.UseFolders) { foreach (var file in MetaFacade.SplitCompileUnit(compileUnit)) { var fileInfo = new FileInfo(Path.Combine(options.OutputFile, file.Key) + "." + generator.FileExtension); CheckDirectoryExists(fileInfo.Directory); using (var sw = new StreamWriter(fileInfo.Create())) { generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions); } } } else { using (var sw = new StreamWriter(options.OutputFile)) { generator.GenerateCodeFromCompileUnit(compileUnit, sw, genOptions); } } }
static void Main() { Inventory store1 = new Inventory(); store1.pencils = 5; store1.pens = 10; store1.paper = 15; DataContractSerializer surrogateDcs = new DataContractSerializer(typeof(Inventory), null, int.MaxValue, false, false, new InventoryTypeSurrogate()); // Plug in the surrogate in order to use the serializer. Console.WriteLine("Plug in a surrogate for the Inventory class\n"); StringWriter sw2 = new StringWriter(); XmlWriter xw2 = XmlWriter.Create(sw2); try { surrogateDcs.WriteObject(xw2, store1); } catch (InvalidDataContractException) { Console.WriteLine(" We should never get here"); } xw2.Flush(); sw2.Flush(); Console.Write(sw2.ToString()); Console.WriteLine("\n\n Serialization succeeded. Now doing deserialization...\n"); StringReader tr = new StringReader(sw2.ToString()); XmlReader xr = XmlReader.Create(tr); Inventory newstore = (Inventory)surrogateDcs.ReadObject(xr); Console.Write("Deserialized Inventory data: \nPens:" + newstore.pens + "\nPencils: " + newstore.pencils + "\nPaper: " + newstore.paper); Console.WriteLine("\n\n Deserialization succeeded. Now doing schema export/import...\n"); //The following code demonstrates schema export with a surrogate. //The surrogate indicates how to export the non-DataContract Inventory type. //Without the surrogate, schema export would fail. XsdDataContractExporter xsdexp = new XsdDataContractExporter(); xsdexp.Options = new ExportOptions(); xsdexp.Options.DataContractSurrogate = new InventoryTypeSurrogate(); try { xsdexp.Export(typeof(Inventory)); } catch (Exception) { } //Write out exported schema to a file using (FileStream fs = new FileStream("sample.xsd", FileMode.Create)) { foreach (XmlSchema sch in xsdexp.Schemas.Schemas()) { sch.Write(fs); } } //The following code demonstrates schema import with a surrogate. //The surrogate is used to indicate that the Inventory class already exists //and that there is no need to generate a new class when importing the //"InventorySurrogated" data contract. XsdDataContractImporter xsdimp = new XsdDataContractImporter(); xsdimp.Options = new ImportOptions(); xsdimp.Options.DataContractSurrogate = new InventoryTypeSurrogate(); xsdimp.Import(xsdexp.Schemas); //Write out the imported schema to a C-Sharp file using (FileStream fs = new FileStream("sample.cs", FileMode.Create)) { TextWriter tw = new StreamWriter(fs); CodeDomProvider cdp = new Microsoft.CSharp.CSharpCodeProvider(); cdp.GenerateCodeFromCompileUnit(xsdimp.CodeCompileUnit, tw, null); tw.Flush(); } Console.WriteLine("\n\n To see the results of schema export and import,"); Console.WriteLine(" see SAMPLE.XSD and SAMPLE.CS.\n"); Console.WriteLine(" Press ENTER to terminate the sample.\n"); Console.ReadLine(); }
public void Generate(IEnumerable<string> files) { var schemas = files.Select(f => XmlSchema.Read(XmlReader.Create(f, new XmlReaderSettings { DtdProcessing = DtdProcessing.Ignore }), (s, e) => { Trace.TraceError(e.Message); })); foreach (var s in schemas) { Set.Add(s); } Set.Compile(); BuildModel(); var namespaces = GenerateCode(); var provider = new Microsoft.CSharp.CSharpCodeProvider(); foreach (var ns in namespaces) { var compileUnit = new CodeCompileUnit(); compileUnit.Namespaces.Add(ns); var title = ((AssemblyTitleAttribute)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(AssemblyTitleAttribute))).Title; var version = Assembly.GetExecutingAssembly().GetName().Version.ToString(); ns.Comments.Add(new CodeCommentStatement(string.Format("This code was generated by {0} version {1}.", title, version))); using (StringWriter sw = new StringWriter()) { provider.GenerateCodeFromCompileUnit(compileUnit, sw, new CodeGeneratorOptions { VerbatimOrder = true, BracingStyle = "C" }); var s = sw.ToString().Replace("};", "}"); // remove ';' at end of automatic properties var path = Path.Combine(OutputFolder, ns.Name + ".cs"); if (Log != null) Log(path); File.WriteAllText(path, s); } } }
private static void GenerateCode(Options options) { var packageTransform = new NMF.Models.Meta.Meta2ClassesTransformation(); var stopWatch = new Stopwatch(); packageTransform.ForceGeneration = options.Force; packageTransform.CreateOperations = options.Operations; packageTransform.DefaultNamespace = options.OverallNamespace; Dictionary <Uri, string> mappings = null; if (options.NamespaceMappings != null && options.NamespaceMappings.Count > 0) { mappings = new Dictionary <Uri, string>(); foreach (var mapping in options.NamespaceMappings) { if (string.IsNullOrEmpty(mapping)) { continue; } var lastIdx = mapping.LastIndexOf('='); if (lastIdx == -1) { Console.WriteLine("Namespace mapping {0} is missing required separator =", mapping); continue; } Uri uri; if (!Uri.TryCreate(mapping.Substring(0, lastIdx), UriKind.Absolute, out uri)) { uri = new Uri(mapping.Substring(0, lastIdx), UriKind.Relative); } mappings.Add(uri, mapping.Substring(lastIdx + 1)); } } var metaPackage = LoadPackageFromFiles(options.InputFiles, options.OverallNamespace, mappings); if (options.Uri != null) { Uri uri; if (Uri.TryCreate(options.Uri, UriKind.Absolute, out uri)) { metaPackage.Uri = uri; } else { Console.Error.WriteLine("The provided string {0} could not be parsed as an absolute URI.", options.Uri); } } if (metaPackage.Uri == null) { Console.Error.WriteLine("Warning: There is no base Uri for the provided metamodels. Some features of the generated code will be disabled."); } var model = metaPackage.Model; if (model == null) { model = new Model(); model.RootElements.Add(metaPackage); } model.ModelUri = metaPackage.Uri; if (options.NMeta != null) { using (var fs = File.Create(options.NMeta)) { MetaRepository.Instance.Serializer.Serialize(model, fs); } } stopWatch.Start(); var compileUnit = TransformationEngine.Transform <INamespace, CodeCompileUnit>(metaPackage, options.Parallel ? (ITransformationEngineContext) new ParallelTransformationContext(packageTransform) : new TransformationContext(packageTransform)); stopWatch.Stop(); Console.WriteLine("Operation took {0}ms", stopWatch.Elapsed.TotalMilliseconds); CodeDomProvider generator = null; switch (options.Language) { case SupportedLanguage.CS: generator = new Microsoft.CSharp.CSharpCodeProvider(); break; case SupportedLanguage.VB: generator = new Microsoft.VisualBasic.VBCodeProvider(); break; case SupportedLanguage.CPP: generator = new Microsoft.VisualC.CppCodeProvider(); break; case SupportedLanguage.JS: generator = new Microsoft.JScript.JScriptCodeProvider(); break; default: Console.WriteLine("Unknown language detected. Falling back to default C#"); generator = new Microsoft.CSharp.CSharpCodeProvider(); break; } var genOptions = new System.CodeDom.Compiler.CodeGeneratorOptions() { BlankLinesBetweenMembers = true, VerbatimOrder = false, ElseOnClosing = false, BracingStyle = "C", IndentString = " " }; if (options.UseFolders) { foreach (var file in MetaFacade.SplitCompileUnit(compileUnit)) { var fileInfo = new FileInfo(Path.Combine(options.OutputFile, file.Key) + "." + generator.FileExtension); CheckDirectoryExists(fileInfo.Directory); using (var fs = fileInfo.Create()) { using (var sw = new StreamWriter(fs)) { generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions); } } } } else { using (var sw = new StreamWriter(options.OutputFile)) { generator.GenerateCodeFromCompileUnit(compileUnit, sw, genOptions); } } Console.WriteLine("Code generated successfully!"); }
public void Generate(IEnumerable <string> names, string targetDirectory) { CodeNamespaceImportCollection imports = new CodeNamespaceImportCollection(); // Generate the ILibiMobileDevice interface CodeTypeDeclaration interfaceType = new CodeTypeDeclaration(); interfaceType.Name = "ILibiMobileDevice"; interfaceType.IsInterface = true; foreach (var name in names) { interfaceType.Members.Add( new CodeMemberProperty() { Name = name, Type = new CodeTypeReference($"I{name}Api"), HasGet = true }); imports.Add(new CodeNamespaceImport($"iMobileDevice.{name}")); } // Generate the interface implementation CodeTypeDeclaration classType = new CodeTypeDeclaration(); classType.Name = "LibiMobileDevice"; classType.BaseTypes.Add("ILibiMobileDevice"); var constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; classType.Members.Add(constructor); var instanceField = new CodeMemberField(); instanceField.Attributes = MemberAttributes.Static; instanceField.Name = "instance"; instanceField.Type = new CodeTypeReference("ILibiMobileDevice"); instanceField.InitExpression = new CodeObjectCreateExpression( new CodeTypeReference("LibiMobileDevice")); classType.Members.Add(instanceField); var instanceProperty = new CodeMemberProperty(); instanceProperty.Attributes = MemberAttributes.Static | MemberAttributes.Public; instanceProperty.Name = "Instance"; instanceProperty.HasGet = true; instanceProperty.Type = new CodeTypeReference("ILibiMobileDevice"); instanceProperty.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeTypeReferenceExpression("LibiMobileDevice"), "instance"))); instanceProperty.SetStatements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeTypeReferenceExpression("LibiMobileDevice"), "instance"), new CodeArgumentReferenceExpression("value"))); classType.Members.Add(instanceProperty); foreach (var name in names) { string camelCased = null; if (name[0] != 'i') { camelCased = char.ToLower(name[0]) + name.Substring(1); } else { camelCased = "i" + char.ToLower(name[1]) + name.Substring(2); } // Add the backing field classType.Members.Add( new CodeMemberField() { Name = camelCased, Type = new CodeTypeReference($"I{name}Api") }); // Add the property + getter var property = new CodeMemberProperty() { Name = name, Type = new CodeTypeReference($"I{name}Api"), HasGet = true, HasSet = true, Attributes = MemberAttributes.Public }; property.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), camelCased))); property.SetStatements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), camelCased), new CodeArgumentReferenceExpression("value"))); classType.Members.Add(property); constructor.Statements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), camelCased), new CodeObjectCreateExpression( new CodeTypeReference($"{name}Api"), new CodeThisReferenceExpression()))); } // Add the LibraryFound property var libraryFoundInterfaceProperty = new CodeMemberProperty(); libraryFoundInterfaceProperty.Name = "LibraryFound"; libraryFoundInterfaceProperty.Type = new CodeTypeReference(typeof(bool)); libraryFoundInterfaceProperty.HasGet = true; interfaceType.Members.Add(libraryFoundInterfaceProperty); var libraryFoundClassProperty = new CodeMemberProperty(); libraryFoundClassProperty.Name = "LibraryFound"; libraryFoundClassProperty.Attributes = MemberAttributes.Public; libraryFoundClassProperty.Type = new CodeTypeReference(typeof(bool)); libraryFoundClassProperty.HasGet = true; libraryFoundClassProperty.GetStatements.Add( new CodeMethodReturnStatement( new CodePropertyReferenceExpression( new CodeTypeReferenceExpression("NativeLibraries"), "LibraryFound"))); classType.Members.Add(libraryFoundClassProperty); foreach (var type in new CodeTypeDeclaration[] { interfaceType, classType }) { // Generate the container unit CodeCompileUnit program = new CodeCompileUnit(); // Generate the namespace CodeNamespace ns = new CodeNamespace($"iMobileDevice"); ns.Imports.AddRange(imports.OfType <CodeNamespaceImport>().ToArray()); ns.Types.Add(type); program.Namespaces.Add(ns); string path = Path.Combine(targetDirectory, $"{type.Name}.cs"); using (var outFile = File.Open(path, FileMode.Create)) using (var fileWriter = new StreamWriter(outFile)) using (var indentedTextWriter = new IndentedTextWriter(fileWriter, " ")) { // Generate source code using the code provider. var provider = new Microsoft.CSharp.CSharpCodeProvider(); provider.GenerateCodeFromCompileUnit( program, indentedTextWriter, new CodeGeneratorOptions() { BracingStyle = "C" }); } } }
private static void GenerateCode(Options options) { var packageTransform = new NMF.Models.Meta.Meta2ClassesTransformation(); var stopWatch = new Stopwatch(); packageTransform.ForceGeneration = options.Force; packageTransform.CreateOperations = options.Operations; packageTransform.DefaultNamespace = options.OverallNamespace; var metaPackage = LoadPackageFromFiles(options.InputFiles, options.OverallNamespace); var model = metaPackage.Model; if (model == null) { model = new Model(); model.RootElements.Add(metaPackage); } model.ModelUri = metaPackage.Uri; if (options.NMeta != null) { using (var fs = File.OpenWrite(options.NMeta)) { MetaRepository.Instance.Serializer.Serialize(model, fs); } } stopWatch.Start(); var compileUnit = TransformationEngine.Transform<INamespace, CodeCompileUnit>(metaPackage, options.Parallel ? (ITransformationEngineContext)new ParallelTransformationContext(packageTransform) : new TransformationContext(packageTransform)); stopWatch.Stop(); Console.WriteLine("Operation took {0}ms", stopWatch.Elapsed.TotalMilliseconds); CodeDomProvider generator = null; switch (options.Language) { case SupportedLanguage.CS: generator = new Microsoft.CSharp.CSharpCodeProvider(); break; case SupportedLanguage.VB: generator = new Microsoft.VisualBasic.VBCodeProvider(); break; case SupportedLanguage.FS: generator = new Microsoft.FSharp.Compiler.CodeDom.FSharpCodeProvider(); break; case SupportedLanguage.CPP: generator = new Microsoft.VisualC.CppCodeProvider(); break; case SupportedLanguage.JS: generator = new Microsoft.JScript.JScriptCodeProvider(); break; default: Console.WriteLine("Unknown language detected. Falling back to default C#"); generator = new Microsoft.CSharp.CSharpCodeProvider(); break; } var genOptions = new System.CodeDom.Compiler.CodeGeneratorOptions() { BlankLinesBetweenMembers = true, VerbatimOrder = false, ElseOnClosing = false, BracingStyle = "C", IndentString = " " }; if (options.UseFolders) { foreach (var file in MetaFacade.SplitCompileUnit(compileUnit)) { var fileInfo = new FileInfo(Path.Combine(options.OutputFile, file.Key) + "." + generator.FileExtension); CheckDirectoryExists(fileInfo.Directory); using (var fs = fileInfo.Create()) { using (var sw = new StreamWriter(fs)) { generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions); } } } } else { using (var sw = new StreamWriter(options.OutputFile)) { generator.GenerateCodeFromCompileUnit(compileUnit, sw, genOptions); } } Console.WriteLine("Code generated successfully!"); }
public static void Generate( string output_path, List <CodeTypeDelegate> delegates, List <CodeMemberMethod> functions, List <CodeMemberField> constants ) { string filename = Path.Combine(output_path, Properties.Bind.Default.OutputClass + ".cs"); if (!Directory.Exists(Properties.Bind.Default.OutputPath)) { Directory.CreateDirectory(Properties.Bind.Default.OutputPath); } CodeNamespace ns = new CodeNamespace(Properties.Bind.Default.OutputNamespace); ns.Imports.Add(new CodeNamespaceImport("System")); ns.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices")); ns.Imports.Add(new CodeNamespaceImport("System.Text")); foreach (string key in SpecTranslator.CSTypes.Keys) { ns.Imports.Add(new CodeNamespaceImport(key + " = System." + SpecTranslator.CSTypes[key].BaseType)); } constants.Sort(new CodeTypeNameComparer <CodeMemberField>()); functions.Sort(new CodeTypeNameComparer <CodeMemberMethod>()); delegates.Sort(new CodeTypeNameComparer <CodeTypeDelegate>()); ns.Types.Add(GenerateGlClass(functions, constants)); ns.Types.Add(GenerateDelegatesClass(delegates)); ns.Types.Add(GenerateImportsClass(delegates)); CodeCompileUnit cu = new CodeCompileUnit(); /* * cu.AssemblyCustomAttributes.Add( * new CodeAttributeDeclaration( * "System.CLSCompliant", * new CodeAttributeArgument[] { * new CodeAttributeArgument( * new CodeSnippetExpression("true") * ) * } * ) * ); */ cu.StartDirectives.Add(new CodeDirective()); cu.Namespaces.Add(ns); using (StreamWriter sw = new StreamWriter(filename, false)) { Console.WriteLine("Writing Tao.OpenGl.Gl class to {0}", filename); Microsoft.CSharp.CSharpCodeProvider cs = new Microsoft.CSharp.CSharpCodeProvider(); System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions(); options.BracingStyle = "C"; options.BlankLinesBetweenMembers = false; options.VerbatimOrder = true; cs.GenerateCodeFromCompileUnit(cu, sw, options); sw.Flush(); } }