developer/VSSDK/Samples/Single_File_Generator/C#/SourceCodeGenerator.cs

   1 /***************************************************************************
   2
   3 Copyright (c) Microsoft Corporation. All rights reserved.
   4 This code is licensed under the Visual Studio SDK license terms.
   5 THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
   6 ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
   7 IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
   8 PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
   9
  10 ***************************************************************************/
  11
  12 using System;
  13 using System.Collections.Generic;
  14 using System.Text;
  15 using System.Xml;
  16 using System.CodeDom;
  17 using System.CodeDom.Compiler;
  18 using System.Reflection;
  19
  20 namespace Microsoft.Samples.VisualStudio.GeneratorSample
  21 {
  22     // In order to be compatible with this single file generator, the input file has to
  23     // follow the schema in XMLClassGeneratorSchema.xsd
  24
  25     /// <summary>
  26     /// Generates source code based on a XML document
  27     /// </summary>
  28     public static class SourceCodeGenerator
  29     {
  30         /// <summary>
  31         /// Create a CodeCompileUnit based on the XmlDocument doc
  32         /// In order to be compatible with this single file generator, the input XmlDocument has to
  33         /// follow the schema in XMLClassGeneratorSchema.xsd
  34         /// </summary>
  35         /// <param name="doc">An XML document that contains the description of the code to be generated</param>
  36         /// <param name="namespaceName">If the root node of doc does not have a namespace attribute, use this instead</param>
  37         /// <returns>The generated CodeCompileUnit</returns>
  38         public static CodeCompileUnit CreateCodeCompileUnit(XmlDocument doc, string namespaceName)
  39         {
  40             XmlElement root = doc.DocumentElement;
  41
  42             if (root.Name != "Types")
  43             {
  44                 throw new ArgumentException(string.Format(Strings.InvalidRoot, root.Name));
  45             }
  46
  47             if (root.ChildNodes.Count == 0)
  48             {
  49                 throw new ArgumentException(Strings.NoTypes);
  50             }
  51
  52             if (root.Attributes.GetNamedItem("namespace") != null)
  53             {
  54                 namespaceName = root.Attributes.GetNamedItem("namespace").Value;
  55             }
  56
  57             CodeCompileUnit code = new CodeCompileUnit();
  58
  59             // Just for VB.NET:
  60             // Option Strict On (controls whether implicit type conversions are allowed)
  61             code.UserData.Add("AllowLateBound", false);
  62             // Option Explicit On (controls whether variable declarations are required)
  63             code.UserData.Add("RequireVariableDeclaration", true);
  64
  65             CodeNamespace codeNamespace = new CodeNamespace(namespaceName);
  66
  67             foreach (XmlNode node in root.ChildNodes)
  68             {
  69                 switch (node.Name)
  70                 {
  71                     case "Class":
  72                         codeNamespace.Types.Add(CreateClass(node));
  73                         break;
  74                     case "Enum":
  75                         codeNamespace.Types.Add(CreateEnum(node));
  76                         break;
  77                     default:
  78                         throw new ArgumentException(string.Format(Strings.InvalidType, node.Name));
  79                 }
  80             }
  81
  82             code.Namespaces.Add(codeNamespace);
  83             return code;
  84         }
  85
  86         private static CodeTypeDeclaration CreateClass(XmlNode node)
  87         {
  88             string className;
  89             string classAccess;
  90             bool isPartial;
  91
  92             GetClassInfo(node, out className, out classAccess, out isPartial);
  93
  94             CodeTypeDeclaration typeDeclaration = new CodeTypeDeclaration(className);
  95
  96             TypeAttributes attrib;
  97
  98             switch (classAccess)
  99             {
 100                 case "public":
 101                     attrib = TypeAttributes.Public;
 102                     break;
 103                 case "internal":
 104                     attrib = TypeAttributes.NotPublic;
 105                     break;
 106                 default:
 107                     throw new ArgumentException(string.Format(Strings.BadTypeAccess, classAccess));
 108             }
 109
 110             typeDeclaration.IsPartial = isPartial;
 111             typeDeclaration.IsClass = true;
 112             typeDeclaration.TypeAttributes = attrib | TypeAttributes.Class;
 113
 114             foreach (XmlNode n in node.ChildNodes)
 115             {
 116                 CodeMemberField field = CreateField(n);
 117                 typeDeclaration.Members.Add(field);
 118             }
 119
 120             return typeDeclaration;
 121         }
 122
 123         private static void GetClassInfo(XmlNode node, out string className, out string classAccess, out bool isPartial)
 124         {
 125             if (node.Attributes != null && node.Attributes.GetNamedItem("name") != null && node.Attributes.GetNamedItem("name").Value != string.Empty)
 126             {
 127                 className = node.Attributes.GetNamedItem("name").Value;
 128             }
 129             else
 130             {
 131                 throw new ArgumentException(Strings.ClassNodeNoName);
 132             }
 133
 134             if (node.Attributes.GetNamedItem("access") != null)
 135             {
 136                 classAccess = node.Attributes.GetNamedItem("access").Value;
 137             }
 138             else
 139             {
 140                 classAccess = "public";
 141             }
 142
 143             if (node.Attributes.GetNamedItem("partial") != null)
 144             {
 145                 isPartial = bool.Parse(node.Attributes.GetNamedItem("partial").Value);
 146             }
 147             else
 148             {
 149                 isPartial = false;
 150             }
 151         }
 152
 153         private static CodeMemberField CreateField(XmlNode n)
 154         {
 155             string fieldName;
 156             string fieldAccess;
 157             string fieldValue;
 158             string fieldType;
 159             bool fieldIsStatic;
 160
 161             GetFieldInfo(n, out fieldName, out fieldAccess, out fieldValue, out fieldType, out fieldIsStatic);
 162
 163             CodeMemberField field = new CodeMemberField(fieldType, fieldName);
 164
 165             if (n.Name == "Constant")
 166             {
 167                 // Set the correct attributes for a constant field
 168                 field.Attributes = (field.Attributes & ~MemberAttributes.AccessMask & ~MemberAttributes.ScopeMask) | MemberAttributes.Public | MemberAttributes.Const;
 169
 170                 if (fieldType == "System.String")
 171                 {
 172                     field.InitExpression = new CodePrimitiveExpression(fieldValue);
 173                 }
 174                 else
 175                 {
 176                     field.InitExpression = new CodeSnippetExpression(fieldValue);
 177                 }
 178             }
 179             else
 180             {
 181                 switch (fieldAccess)
 182                 {
 183                     case "public":
 184                         field.Attributes = MemberAttributes.Public;
 185                         break;
 186                     case "protected":
 187                         field.Attributes = MemberAttributes.Family;
 188                         break;
 189                     case "private":
 190                         field.Attributes = MemberAttributes.Private;
 191                         break;
 192                     default:
 193                         throw new ArgumentException(string.Format(Strings.BadVariableAccess, fieldAccess));
 194                 }
 195
 196                 if (fieldIsStatic)
 197                 {
 198                     field.Attributes |= MemberAttributes.Static;
 199                 }
 200             }
 201
 202             return field;
 203         }
 204
 205         private static void GetFieldInfo(XmlNode n, out string memberName, out string memberAccess, out string memberValue, out string memberType, out bool memberIsStatic)
 206         {
 207             if (n.Name != "Variable" && n.Name != "Constant")
 208             {
 209                 throw new ArgumentException(string.Format(Strings.BadClassMemberName, n.Name));
 210             }
 211
 212             if (n.Attributes != null && n.Attributes.GetNamedItem("name") != null && n.Attributes.GetNamedItem("name").Value != string.Empty)
 213             {
 214                 memberName = n.Attributes.GetNamedItem("name").Value;
 215             }
 216             else
 217             {
 218                 throw new ArgumentException(Strings.ClassMemberNoName);
 219             }
 220
 221             if (n.Attributes.GetNamedItem("type") != null)
 222             {
 223                 memberType = n.Attributes.GetNamedItem("type").Value;
 224             }
 225             else
 226             {
 227                 throw new ArgumentException(Strings.ClassMemberNoType);
 228             }
 229
 230             if (n.Attributes.GetNamedItem("value") != null)
 231             {
 232                 memberValue = n.Attributes.GetNamedItem("value").Value;
 233             }
 234             else
 235             {
 236                 if (n.Name == "Constant")
 237                 {
 238                     throw new ArgumentException(Strings.ConstantNoValue);
 239                 }
 240                 else
 241                 {
 242                     memberValue = null;
 243                 }
 244             }
 245
 246             if (n.Attributes.GetNamedItem("access") != null)
 247             {
 248                 memberAccess = n.Attributes.GetNamedItem("access").Value;
 249             }
 250             else
 251             {
 252                 memberAccess = "public";
 253             }
 254
 255             if (n.Attributes.GetNamedItem("static") != null)
 256             {
 257                 if (n.Name == "Constant")
 258                 {
 259                     throw new ArgumentException(Strings.ConstantNoValue);
 260                 }
 261                 else
 262                 {
 263                     memberIsStatic = bool.Parse(n.Attributes.GetNamedItem("static").Value);
 264                 }
 265             }
 266             else
 267             {
 268                 memberIsStatic = false;
 269             }
 270         }
 271
 272         private static CodeTypeDeclaration CreateEnum(XmlNode node)
 273         {
 274             string enumName;
 275             string enumAccess;
 276             bool enumFlagsAttribute;
 277
 278             GetEnumInfo(node, out enumName, out enumAccess, out enumFlagsAttribute);
 279
 280             CodeTypeDeclaration typeDeclaration = new CodeTypeDeclaration(enumName);
 281             typeDeclaration.IsEnum = true;
 282
 283             if (enumFlagsAttribute)
 284             {
 285                 typeDeclaration.CustomAttributes.Add(new CodeAttributeDeclaration("System.FlagsAttribute"));
 286             }
 287
 288             TypeAttributes attrib;
 289             switch (enumAccess)
 290             {
 291                 case "public":
 292                     attrib = TypeAttributes.Public;
 293                     break;
 294                 case "internal":
 295                     attrib = TypeAttributes.NotPublic;
 296                     break;
 297                 default:
 298                     throw new ArgumentException(string.Format(Strings.BadTypeAccess, enumAccess));
 299             }
 300
 301             typeDeclaration.TypeAttributes = attrib;
 302
 303             foreach (XmlNode n in node.ChildNodes)
 304             {
 305                 string memberName;
 306                 int memberValue;
 307                 bool hasValue;
 308
 309                 GetEnumMemberInfo(enumFlagsAttribute, n, out memberName, out memberValue, out hasValue);
 310
 311                 CodeMemberField field = new CodeMemberField("System.Int32", memberName);
 312                 if (hasValue)
 313                 {
 314                     field.InitExpression = new CodePrimitiveExpression(memberValue);
 315                 }
 316
 317                 typeDeclaration.Members.Add(field);
 318             }
 319
 320             return typeDeclaration;
 321         }
 322
 323         private static void GetEnumMemberInfo(bool enumFlagsAttribute, XmlNode n, out string memberName, out int memberValue, out bool hasValue)
 324         {
 325             if (n.Name != "EnumMember")
 326             {
 327                 throw new ArgumentException(string.Format(Strings.EnumNodeNoName, n.Name));
 328             }
 329
 330             if (n.Attributes != null && n.Attributes.GetNamedItem("name") != null && n.Attributes.GetNamedItem("name").Value != string.Empty)
 331             {
 332                 memberName = n.Attributes.GetNamedItem("name").Value;
 333             }
 334             else
 335             {
 336                 throw new ArgumentException(Strings.EnumMemberNodeNoName);
 337             }
 338
 339             if (n.Attributes.GetNamedItem("value") != null)
 340             {
 341                 memberValue = System.Int32.Parse(n.Attributes.GetNamedItem("value").Value);
 342                 hasValue = true;
 343             }
 344             else
 345             {
 346                 if (enumFlagsAttribute)
 347                 {
 348                     throw new ArgumentException(Strings.EnumMemberValueMissing);
 349                 }
 350                 else
 351                 {
 352                     memberValue = 0;
 353                     hasValue = false;
 354                 }
 355             }
 356         }
 357
 358         private static void GetEnumInfo(XmlNode node, out string enumName, out string enumAccess, out bool enumFlagsAttribute)
 359         {
 360             if (node.Attributes != null && node.Attributes.GetNamedItem("name") != null && node.Attributes.GetNamedItem("name").Value != string.Empty)
 361             {
 362                 enumName = node.Attributes.GetNamedItem("name").Value;
 363             }
 364             else
 365             {
 366                 throw new ArgumentException(Strings.EnumNodeNoName);
 367             }
 368
 369             if (node.ChildNodes.Count == 0)
 370             {
 371                 throw new ArgumentException(Strings.EnumNoMembers);
 372             }
 373
 374             if (node.Attributes.GetNamedItem("access") != null)
 375             {
 376                 enumAccess = node.Attributes.GetNamedItem("access").Value;
 377             }
 378             else
 379             {
 380                 enumAccess = "public";
 381             }
 382
 383             if (node.Attributes.GetNamedItem("flagsAttribute") != null)
 384             {
 385                 enumFlagsAttribute = bool.Parse(node.Attributes.GetNamedItem("flagsAttribute").Value);
 386             }
 387             else
 388             {
 389                 enumFlagsAttribute = false;
 390             }
 391         }
 392     }
 393 }