codegenerator/CodeGen.cs

   1 /*
   2  * License: GPLv3+
   3  * Created at ${TIME} ${DATE}
   4  *
   5  * Author: Marcel Hauf
   6  */
   7
   8 using System;
   9 using System.IO;
  10 using System.Xml;
  11 using System.Xml.XPath;
  12 using System.Xml.Serialization;
  13 using System.Collections;
  14 using System.CodeDom;
  15 using System.CodeDom.Compiler;
  16 using Microsoft.CSharp;
  17 using System.Reflection;
  18
  19 namespace CodeGenerator
  20 {
  21         /// <summary>
  22         /// Loads the xml file.
  23         /// </summary>
  24         public class CodeGenerator
  25         {
  26                 /// <summary>
  27                 /// Namespace name of the will be generated code.
  28                 /// </summary>
  29                 public string Namespace = "LibTpProto.Proto";
  30
  31                 /// <summary>
  32                 /// An arraylist of strings which will be included as using statements.
  33                 /// Eg. string: System
  34                 /// </summary>
  35                 public ArrayList UsingStatements = new ArrayList();
  36
  37                 private static TypeHandler typeHandler = new TypeHandler();
  38
  39                 private string outPutPath = ".";
  40
  41                 private string xmlFile = "./protocol";
  42
  43                 private XmlTextReader reader;
  44
  45                 private TextWriter sourceWriter;
  46
  47                 private ArrayList classList = new ArrayList();
  48
  49                 /// <summary>
  50                 /// This will generate the code.
  51                 /// </summary>
  52                 /// <param name="xmlFile">Path to the xml file.</param>
  53                 /// <param name="outputPath">Out put path.</param>
  54                 public CodeGenerator(string xmlFile, string outputPath)
  55                 {
  56                         // TODO: Add choose which language should be used
  57                         // Setup variables
  58                         this.outPutPath = outputPath;
  59                         this.xmlFile = xmlFile;
  60
  61                         // Setup in/out put
  62                         if(File.Exists(xmlFile))
  63                         {
  64                                 reader = new XmlTextReader (xmlFile);
  65                         }
  66                         else
  67                         {
  68                                 throw(new Exception("Could not found xml file."));
  69                         }
  70
  71                         // TODO: Choose the language of the code gen
  72                         CSharpCodeGen();
  73                 }
  74
  75                 private void CSharpCodeGen()
  76                 {
  77                         //Setup code generators for csharp code
  78                         CSharpCodeProvider provider = new CSharpCodeProvider();
  79                         CodeGeneratorOptions options = new CodeGeneratorOptions();
  80
  81                         while (reader.Read())
  82                         {
  83                                 switch (reader.NodeType)
  84                                 {
  85                                         case XmlNodeType.Element: //This node is a element
  86                                                 switch (reader.Depth)
  87                                                 {
  88                                                         case 0: //protocol
  89                                                                 string version = reader.GetAttribute("version");
  90                                                                 if(version != null)
  91                                                                 {
  92                                                                         outPutPath += "/" + version;
  93                                                                         Directory.CreateDirectory(outPutPath);
  94                                                                 }
  95                                                                 break;
  96                                                         case 1: //parameterset and packet
  97                                                                 string name = reader.GetAttribute("name");
  98                                                                 if(name == "OrderParams")
  99                                                                 {
 100                                                                         GenerateParaSet(provider, options, reader.ReadSubtree());
 101                                                                 }
 102                                                                 else if ( name == "Header")
 103                                                                 {
 104                                                                         GenerateHeader(provider, options, reader.ReadSubtree());
 105                                                                 }
 106                                                                 break;
 107                                                         case 2:
 108                                                                 break;
 109                                                         default:
 110                                                                 break;
 111                                                 }
 112                                                 break;
 113                                         case XmlNodeType.Text: //Display the text from each element
 114                                                 break;
 115                                         case XmlNodeType.EndElement: //Display the end of a element
 116                                                 break;
 117                                 }
 118                         }
 119                         reader.Close();
 120                 }
 121
 122                 private void GenerateHeader(CodeDomProvider provider
 123                                             , CodeGeneratorOptions options
 124                                             , XmlReader reader)
 125                 {
 126                         sourceWriter = new StreamWriter(outPutPath + "/Header.cs");
 127                         // --- Starts generating code ---
 128
 129                         //Declare Using Statements
 130                         UsingStatements.Add("System");
 131
 132                         //Setup compile unit
 133                         CodeCompileUnit ccu = new CodeCompileUnit();
 134
 135                         //Create Class Namespaces
 136                         CodeNamespace codeNamespace = new CodeNamespace(Namespace);
 137
 138                         //Create Class Using Statements
 139                         foreach(string s in UsingStatements)
 140                         {
 141                                 codeNamespace.Imports.Add(new CodeNamespaceImport(s));
 142                         }
 143
 144                         while(reader.Read())
 145                         {
 146                                 switch (reader.NodeType)
 147                                 {
 148                                         case XmlNodeType.Element:
 149                                                 if(reader.Name == "structure")
 150                                                 {
 151                                                         Console.WriteLine("Debug: structure will be created.");
 152                                                         typeHandler.AddClass(codeNamespace, reader.ReadSubtree(), "Header");
 153                                                 }
 154                                                 break;
 155                                         case XmlNodeType.Text: //Display the text from each element
 156                                                 break;
 157                                         case XmlNodeType.EndElement: //Display the end of a element
 158                                                 break;
 159                                 }
 160                         }
 161                         ccu.Namespaces.Add(codeNamespace);
 162                         provider.GenerateCodeFromCompileUnit(ccu, sourceWriter, options);
 163                         sourceWriter.Close();
 164                 }
 165
 166
 167                 // TODO: Recode everthing below
 168                 private void GenerateParaSet(CodeDomProvider provider
 169                                              , CodeGeneratorOptions options
 170                                              , XmlReader reader)
 171                 {
 172                         sourceWriter = new StreamWriter(outPutPath + "/OrderParams.cs");
 173                         // --- Starts generating code ---
 174
 175                         //Declare Using Statements
 176                         UsingStatements.Add("System");
 177
 178                         //Setup compile unit
 179                         CodeCompileUnit ccu = new CodeCompileUnit();
 180
 181                         //Create Class Namespaces
 182                         CodeNamespace codeNamespace = new CodeNamespace(Namespace);
 183
 184                         //Create Class Using Statements
 185                         foreach(string s in UsingStatements)
 186                         {
 187                                 codeNamespace.Imports.Add(new CodeNamespaceImport(s));
 188                         }
 189                         CodeTypeDeclaration ctd = new CodeTypeDeclaration("OrderParams");
 190                         string comments = "";
 191                         while(reader.Read())
 192                         {
 193                                 switch (reader.NodeType)
 194                                 {
 195                                         case XmlNodeType.Element:
 196                                                 switch (reader.Depth)
 197                                                 {
 198                                                         case 0:
 199                                                                 break;
 200                                                         case 1: //parameter and name and description
 201                                                                 switch (reader.Name)
 202                                                                 {
 203                                                                                 //Does not work
 204                                                                         case "longname":
 205                                                                                 comments = reader.Value;
 206                                                                                 break;
 207                                                                         case "description":
 208                                                                                 comments += reader.Value;
 209                                                                                 break;
 210                                                                                 // Works
 211                                                                         case "parameter":
 212                                                                                 GenerateParameter(reader.ReadSubtree(), ctd, reader.GetAttribute("name"));
 213                                                                                 break;
 214                                                                         default:
 215                                                                                 break;
 216                                                                 }
 217
 218                                                                 break;
 219                                                         default:
 220                                                                 break;
 221                                                 }
 222                                                 break;
 223                                         case XmlNodeType.Text: //Display the text from each element
 224                                                 break;
 225                                         case XmlNodeType.EndElement: //Display the end of a element
 226                                                 break;
 227                                 }
 228                         }
 229                         Console.WriteLine(comments);
 230                         ctd.Comments.Add(new CodeCommentStatement(comments));
 231                         codeNamespace.Types.Add(ctd);
 232
 233                         ccu.Namespaces.Add(codeNamespace);
 234                         provider.GenerateCodeFromCompileUnit(ccu, sourceWriter, options);
 235                         sourceWriter.WriteLine();
 236                         sourceWriter.Close();
 237                 }
 238
 239                 private void GenerateParameter(XmlReader reader, CodeTypeDeclaration ctd, string name)
 240                 {
 241                         CodeTypeDeclaration pclass = new CodeTypeDeclaration(name);
 242                         while(reader.Read())
 243                         {
 244                                 switch (reader.NodeType)
 245                                 {
 246                                         case XmlNodeType.Element:
 247                                                 switch (reader.Depth)
 248                                                 {
 249                                                         case 0:
 250                                                                 break;
 251                                                         case 1:
 252                                                                 break;
 253                                                         default:
 254                                                                 break;
 255                                                 }
 256                                                 break;
 257                                         default:
 258                                                 break;
 259                                 }
 260                         }
 261                         ctd.Members.Add(pclass);
 262                 }
 263         }
 264 }