mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs

   1 //\r
   2 // Microsoft.VisualBasic.VBCodeGenerator.cs\r
   3 //\r
   4 // Author:\r
   5 //   Andreas Nahr (ClassDevelopment@A-SoftTech.com)\r
   6 //   (partially based on CSharpCodeGenerator)\r
   7 //   Jochen Wezel (jwezel@compumaster.de)\r
   8 //\r
   9 // (C) 2003 Andreas Nahr\r
  10 // (C) 2003 Jochen Wezel (http://www.compumaster.de)\r
  11 //\r
  12 // Modifications:\r
  13 // 2003-11-06 JW: some corrections regarding missing spaces in generated code (e. g. "Property ")\r
  14 // 2003-11-06 JW: QuoteSnippetString implemented\r
  15 // 2003-11-08 JW: automatically add Microsoft.VisualBasic\r
  16 // 2003-11-12 JW: some corrections to allow correct compilation\r
  17 // 2003-11-28 JW: implementing code differences into current build of this file\r
  18 // 2003-12-10 JW: added "String." for the ChrW method because mbas doesn't support it without the String currently / TODO: remove it ASAP!\r
  19 \r
  20 //\r
  21 // Permission is hereby granted, free of charge, to any person obtaining\r
  22 // a copy of this software and associated documentation files (the\r
  23 // "Software"), to deal in the Software without restriction, including\r
  24 // without limitation the rights to use, copy, modify, merge, publish,\r
  25 // distribute, sublicense, and/or sell copies of the Software, and to\r
  26 // permit persons to whom the Software is furnished to do so, subject to\r
  27 // the following conditions:\r
  28 // \r
  29 // The above copyright notice and this permission notice shall be\r
  30 // included in all copies or substantial portions of the Software.\r
  31 // \r
  32 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
  33 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
  34 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
  35 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
  36 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
  37 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
  38 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  39 //\r
  40 \r
  41 \r
  42 using System;\r
  43 using System.Globalization;\r
  44 using System.Text;\r
  45 using System.Text.RegularExpressions;\r
  46 using System.CodeDom;\r
  47 using System.CodeDom.Compiler;\r
  48 using System.IO;\r
  49 using System.Reflection;\r
  50 using System.Collections;\r
  51 \r
  52 namespace Microsoft.VisualBasic\r
  53 {\r
  54         internal class VBCodeGenerator : CodeGenerator\r
  55         {\r
  56                 private string[] Keywords = new string[] {\r
  57                         "AddHandler", "AddressOf", "Alias", "And",\r
  58                         "AndAlso", "Ansi", "As", "Assembly",\r
  59                         "Auto", "Boolean", "ByRef", "Byte", \r
  60                         "ByVal", "Call", "Case", "Catch", \r
  61                         "CBool", "CByte", "CChar", "CDate", \r
  62                         "CDec", "CDbl", "Char", "CInt", \r
  63                         "Class", "CLng", "CObj", "Const", \r
  64                         "CShort", "CSng", "CStr", "CType", \r
  65                         "Date", "Decimal", "Declare", "Default", \r
  66                         "Delegate", "Dim", "DirectCast", "Do", \r
  67                         "Double", "Each", "Else", "ElseIf", \r
  68                         "End", "Enum", "Erase", "Error", \r
  69                         "Event", "Exit", "False", "Finally", \r
  70                         "For", "Friend", "Function", "Get", \r
  71                         "GetType", "GoSub", "GoTo", "Handles", \r
  72                         "If", "Implements", "Imports", "In", \r
  73                         "Inherits", "Integer", "Interface", "Is", \r
  74                         "Let", "Lib", "Like", "Long", \r
  75                         "Loop", "Me", "Mod", "Module", \r
  76                         "MustInherit", "MustOverride", "MyBase", "MyClass", \r
  77                         "Namespace", "New", "Next", "Not", \r
  78                         "Nothing", "NotInheritable", "NotOverridable", "Object", \r
  79                         "On", "Option", "Optional", "Or", \r
  80                         "OrElse", "Overloads", "Overridable", "Overrides", \r
  81                         "ParamArray", "Preserve", "Private", "Property", \r
  82                         "Protected", "Public", "RaiseEvent", "ReadOnly", \r
  83                         "ReDim", "REM", "RemoveHandler", "Resume", \r
  84                         "Return", "Select", "Set", "Shadows", \r
  85                         "Shared", "Short", "Single", "Static", \r
  86                         "Step", "Stop", "String", "Structure", \r
  87                         "Sub", "SyncLock", "Then", "Throw", \r
  88                         "To", "True", "Try", "TypeOf", \r
  89                         "Unicode", "Until", "Variant", "When", \r
  90                         "While", "With", "WithEvents", "WriteOnly", \r
  91                         "Xor" \r
  92                 };\r
  93 \r
  94                 public VBCodeGenerator()\r
  95                 {\r
  96                 }\r
  97 \r
  98                 protected override string NullToken {\r
  99                         get {\r
 100                                 return "Nothing";\r
 101                         }\r
 102                 }\r
 103 \r
 104                 protected override void ContinueOnNewLine (string st)\r
 105                 {\r
 106                         Output.Write (st);\r
 107                         Output.WriteLine (" _");\r
 108                 }\r
 109 \r
 110                 protected override void GenerateArrayCreateExpression (CodeArrayCreateExpression expression)\r
 111                 {\r
 112                         TextWriter output = Output;\r
 113 \r
 114                         output.Write ("New ");\r
 115 \r
 116                         CodeExpressionCollection initializers = expression.Initializers;\r
 117                         CodeTypeReference createType = expression.CreateType;\r
 118 \r
 119                         if (initializers.Count > 0) {\r
 120 \r
 121                                 OutputType (createType);\r
 122                                 \r
 123                                 output.WriteLine (" {");\r
 124                                 ++Indent;\r
 125                                 OutputExpressionList (initializers, true);\r
 126                                 --Indent;\r
 127                                 output.Write ("}");\r
 128 \r
 129                         } \r
 130                         else {\r
 131                                 CodeTypeReference arrayType = createType.ArrayElementType;\r
 132                                 while (arrayType != null) \r
 133                                 {\r
 134                                         createType = arrayType;\r
 135                                         arrayType = arrayType.ArrayElementType;\r
 136                                 }\r
 137 \r
 138                                 OutputType (createType);\r
 139 \r
 140                                 output.Write ('(');\r
 141 \r
 142                                 CodeExpression size = expression.SizeExpression;\r
 143                                 if (size != null)\r
 144                                         GenerateExpression (size);\r
 145                                 else\r
 146                                         output.Write (expression.Size);\r
 147 \r
 148                                 output.Write (')');\r
 149                         }\r
 150                 }\r
 151 \r
 152                 protected override void GenerateBaseReferenceExpression (CodeBaseReferenceExpression expression)\r
 153                 {\r
 154                         Output.Write ("MyBase");\r
 155                 }\r
 156 \r
 157                 protected override void GenerateCastExpression (CodeCastExpression expression)\r
 158                 {\r
 159                         TextWriter output = Output;\r
 160                         // ENHANCE: Use a DirectCast if it is known that expression.Expression is no Value-Type\r
 161                         output.Write ("CType(");\r
 162                         GenerateExpression (expression.Expression);\r
 163                         output.Write (", ");\r
 164                         OutputType (expression.TargetType);\r
 165                         output.Write (")");\r
 166                 }\r
 167 \r
 168                 private bool AsBool(object datavalue)\r
 169                 {\r
 170                         return datavalue != null && datavalue is bool && (bool)datavalue;\r
 171                 }\r
 172                 \r
 173                 private string OnOff(bool datavalue)\r
 174                 {\r
 175                         return datavalue?"On":"Off";\r
 176                 }\r
 177 \r
 178                 protected override void GenerateCompileUnitStart (CodeCompileUnit compileUnit)\r
 179                 {\r
 180                         GenerateComment (new CodeComment ("------------------------------------------------------------------------------"));\r
 181                         GenerateComment (new CodeComment (" <autogenerated>"));\r
 182                         GenerateComment (new CodeComment ("     This code was generated by a tool."));\r
 183                         GenerateComment (new CodeComment ("     Mono Runtime Version: " + System.Environment.Version));\r
 184                         GenerateComment (new CodeComment (""));\r
 185                         GenerateComment (new CodeComment ("     Changes to this file may cause incorrect behavior and will be lost if "));\r
 186                         GenerateComment (new CodeComment ("     the code is regenerated."));\r
 187                         GenerateComment (new CodeComment (" </autogenerated>"));\r
 188                         GenerateComment (new CodeComment ("------------------------------------------------------------------------------"));\r
 189                         Output.WriteLine ();\r
 190                         if (AsBool(compileUnit.UserData["AllowLateBound"])) {\r
 191                                 Output.WriteLine("Option Explicit {0}",OnOff(AsBool(compileUnit.UserData["RequireVariableDeclaration"])));\r
 192                                 Output.WriteLine("Option Strict Off");\r
 193                         } else {\r
 194                                 Output.WriteLine("Option Explicit On"); // Strict On implies Explicit On\r
 195                                 Output.WriteLine("Option Strict On");\r
 196                         }\r
 197                         Output.WriteLine ();\r
 198                 }\r
 199 \r
 200                 protected override void GenerateCompileUnit (CodeCompileUnit compileUnit)\r
 201                 {\r
 202                         GenerateCompileUnitStart (compileUnit);\r
 203 \r
 204                         OutputAttributes (compileUnit.AssemblyCustomAttributes,\r
 205                                 "Assembly: ", LineHandling.NewLine);\r
 206 \r
 207                         GenerateNamespaces (compileUnit);\r
 208 \r
 209                         GenerateCompileUnitEnd (compileUnit);\r
 210                 }\r
 211 \r
 212                 protected override void GenerateDelegateCreateExpression (CodeDelegateCreateExpression expression)\r
 213                 {\r
 214                         TextWriter output = Output;\r
 215 \r
 216                         output.Write ("AddressOf ");\r
 217 \r
 218                         CodeExpression targetObject = expression.TargetObject;\r
 219                         if (targetObject != null) {\r
 220                                 GenerateExpression (targetObject);\r
 221                                 Output.Write ('.');\r
 222                         }\r
 223                         output.Write (expression.MethodName);\r
 224                 }\r
 225 \r
 226                 protected override void GenerateFieldReferenceExpression (CodeFieldReferenceExpression expression)\r
 227                 {\r
 228                         CodeExpression targetObject = expression.TargetObject;\r
 229                         if (targetObject != null) {\r
 230                                 GenerateExpression (targetObject);\r
 231                                 Output.Write ('.');\r
 232                         }\r
 233                         Output.Write (expression.FieldName);\r
 234                 }\r
 235                 \r
 236                 protected override void GenerateArgumentReferenceExpression (CodeArgumentReferenceExpression expression)\r
 237                 {\r
 238                         Output.Write (expression.ParameterName);\r
 239                 }\r
 240 \r
 241                 protected override void GenerateVariableReferenceExpression (CodeVariableReferenceExpression expression)\r
 242                 {\r
 243                         Output.Write (expression.VariableName);\r
 244                 }\r
 245                 \r
 246                 protected override void GenerateIndexerExpression (CodeIndexerExpression expression)\r
 247                 {\r
 248                         TextWriter output = Output;\r
 249 \r
 250                         GenerateExpression (expression.TargetObject);\r
 251                         output.Write ('(');\r
 252                         OutputExpressionList (expression.Indices);\r
 253                         output.Write (')');\r
 254                 }\r
 255                 \r
 256                 protected override void GenerateArrayIndexerExpression (CodeArrayIndexerExpression expression)\r
 257                 {\r
 258                         TextWriter output = Output;\r
 259 \r
 260                         GenerateExpression (expression.TargetObject);\r
 261                         output.Write (".Item(");\r
 262                         OutputExpressionList (expression.Indices);\r
 263                         output.Write (')');\r
 264                 }\r
 265                 \r
 266                 protected override void GenerateSnippetExpression (CodeSnippetExpression expression)\r
 267                 {\r
 268                         Output.Write (expression.Value);\r
 269                 }\r
 270                 \r
 271                 protected override void GenerateMethodInvokeExpression (CodeMethodInvokeExpression expression)\r
 272                 {\r
 273                         TextWriter output = Output;\r
 274 \r
 275                         GenerateMethodReferenceExpression (expression.Method);\r
 276 \r
 277                         output.Write ('(');\r
 278                         OutputExpressionList (expression.Parameters);\r
 279                         output.Write (')');\r
 280                 }\r
 281 \r
 282                 protected override void GenerateMethodReferenceExpression (CodeMethodReferenceExpression expression)\r
 283                 {\r
 284                         GenerateExpression (expression.TargetObject);\r
 285                         Output.Write ('.');\r
 286                         Output.Write (expression.MethodName);\r
 287                 }\r
 288 \r
 289                 protected override void GenerateEventReferenceExpression (CodeEventReferenceExpression expression)\r
 290                 {\r
 291                         GenerateExpression (expression.TargetObject);\r
 292                         Output.Write ('.');\r
 293                         Output.Write (expression.EventName);\r
 294                 }\r
 295 \r
 296                 protected override void GenerateDelegateInvokeExpression (CodeDelegateInvokeExpression expression)\r
 297                 {\r
 298                         Output.Write ("RaiseEvent ");\r
 299                         GenerateExpression (expression.TargetObject);\r
 300                         Output.Write ('(');\r
 301                         OutputExpressionList (expression.Parameters);\r
 302                         Output.WriteLine (')');\r
 303                 }\r
 304                 \r
 305                 protected override void GenerateObjectCreateExpression (CodeObjectCreateExpression expression)\r
 306                 {\r
 307                         Output.Write( "New " );\r
 308                         OutputType (expression.CreateType);\r
 309                         Output.Write ('(');\r
 310                         OutputExpressionList (expression.Parameters);\r
 311                         Output.Write (')');\r
 312                 }\r
 313 \r
 314                 protected override void GenerateParameterDeclarationExpression (CodeParameterDeclarationExpression e)\r
 315                 {\r
 316                         OutputAttributes (e.CustomAttributes, null, LineHandling.InLine);\r
 317                         OutputDirection (e.Direction);\r
 318                         OutputTypeNamePair (e.Type, e.Name);\r
 319                 }\r
 320 \r
 321                 protected override void GeneratePrimitiveExpression (CodePrimitiveExpression e)\r
 322                 {\r
 323                         TextWriter output = Output;\r
 324 \r
 325                         if (e.Value == null) {\r
 326                                 output.Write (NullToken);\r
 327                                 return;\r
 328                         }\r
 329 \r
 330                         Type type = e.Value.GetType ();\r
 331                         if (type == typeof (bool)) {\r
 332                                 output.Write (e.Value.ToString ().ToLower (CultureInfo.InvariantCulture));\r
 333                         } \r
 334                         else if (type == typeof (char)) {\r
 335                                 output.Write ("\"" + e.Value.ToString () + "\"c");\r
 336                         } \r
 337                         else if (type == typeof (string)) {\r
 338                                 output.Write (QuoteSnippetString ((string) e.Value));\r
 339                         } \r
 340                         else if (type == typeof (byte) || type == typeof (sbyte) || type == typeof (short) ||\r
 341                                 type == typeof (int) || type == typeof (long) || type == typeof (float) ||\r
 342                                 type == typeof (double) || type == typeof (decimal)) {\r
 343                                 output.Write (e.Value.ToString ());\r
 344                         } \r
 345                         else {\r
 346                                 throw new ArgumentException ("Value type (" + type + ") is not a primitive type");\r
 347                         }\r
 348                 }\r
 349 \r
 350                 protected override void GeneratePropertyReferenceExpression (CodePropertyReferenceExpression expression)\r
 351                 {\r
 352                         GenerateMemberReferenceExpression (expression.TargetObject, expression.PropertyName);\r
 353                 }\r
 354 \r
 355                 protected override void GeneratePropertySetValueReferenceExpression (CodePropertySetValueReferenceExpression expression)\r
 356                 {\r
 357                         Output.Write ("Value"); \r
 358                 }\r
 359 \r
 360                 protected override void GenerateThisReferenceExpression (CodeThisReferenceExpression expression)\r
 361                 {\r
 362                         Output.Write ("Me");\r
 363                 }\r
 364 \r
 365                 protected override void GenerateExpressionStatement (CodeExpressionStatement statement)\r
 366                 {\r
 367                         GenerateExpression (statement.Expression);\r
 368                         Output.WriteLine (); //start new line\r
 369                 }\r
 370 \r
 371                 protected override void GenerateIterationStatement (CodeIterationStatement statement)\r
 372                 {\r
 373                         TextWriter output = Output;\r
 374 \r
 375                         GenerateStatement (statement.InitStatement);\r
 376                         output.Write ("Do While ");\r
 377                         GenerateExpression (statement.TestExpression);\r
 378                         output.WriteLine ();\r
 379                         GenerateStatements (statement.Statements);\r
 380                         GenerateStatement (statement.IncrementStatement);\r
 381                         output.WriteLine ("Loop");\r
 382                 }\r
 383 \r
 384                 protected override void GenerateThrowExceptionStatement (CodeThrowExceptionStatement statement)\r
 385                 {\r
 386                         Output.Write ("Throw ");\r
 387                         GenerateExpression (statement.ToThrow);\r
 388                 }\r
 389 \r
 390                 protected override void GenerateComment (CodeComment comment)\r
 391                 {\r
 392                         TextWriter output = Output;\r
 393 \r
 394                         if (comment.DocComment)\r
 395                                 output.Write ("''' ");\r
 396                         else\r
 397                                 output.Write ("' ");\r
 398 \r
 399                         output.WriteLine (comment.Text);\r
 400                 }\r
 401 \r
 402                 protected override void GenerateMethodReturnStatement (CodeMethodReturnStatement statement)\r
 403                 {\r
 404                         TextWriter output = Output;\r
 405 \r
 406                         output.Write ("Return ");\r
 407                         GenerateExpression (statement.Expression);\r
 408                         output.WriteLine ();\r
 409                 }\r
 410 \r
 411                 protected override void GenerateConditionStatement (CodeConditionStatement statement)\r
 412                 {\r
 413                         TextWriter output = Output;\r
 414                         output.Write ("If (");\r
 415 \r
 416                         GenerateExpression (statement.Condition);\r
 417 \r
 418                         output.WriteLine (") Then");\r
 419                         ++Indent;\r
 420                         GenerateStatements (statement.TrueStatements);\r
 421                         --Indent;\r
 422 \r
 423                         CodeStatementCollection falses = statement.FalseStatements;\r
 424                         if (falses.Count > 0) {\r
 425                                 output.WriteLine ("Else");\r
 426                                 ++Indent;\r
 427                                 GenerateStatements (falses);\r
 428                                 --Indent;\r
 429                         }\r
 430                         else {\r
 431                                 if (Options.ElseOnClosing)\r
 432                                         output.WriteLine ("Else");\r
 433                         }\r
 434                         output.WriteLine ("End If");\r
 435                 }\r
 436 \r
 437                 protected override void GenerateTryCatchFinallyStatement (CodeTryCatchFinallyStatement statement)\r
 438                 {\r
 439                         TextWriter output = Output;\r
 440 \r
 441                         output.WriteLine ("Try");\r
 442                         ++Indent;\r
 443                         GenerateStatements (statement.TryStatements);\r
 444                         --Indent;\r
 445                         output.WriteLine ();\r
 446                         \r
 447                         foreach (CodeCatchClause clause in statement.CatchClauses) {\r
 448                                 output.Write ("Catch ");\r
 449                                 OutputTypeNamePair (clause.CatchExceptionType, clause.LocalName);\r
 450                                 output.WriteLine ();\r
 451                                 ++Indent;\r
 452                                 GenerateStatements (clause.Statements);\r
 453                                 --Indent;\r
 454                                 output.WriteLine ();\r
 455                         }\r
 456 \r
 457                         CodeStatementCollection finallies = statement.FinallyStatements;\r
 458                         if (finallies.Count > 0) {\r
 459 \r
 460                                 output.WriteLine ("Finally");\r
 461                                 ++Indent;\r
 462                                 GenerateStatements (finallies);\r
 463                                 --Indent;\r
 464                                 output.WriteLine ();\r
 465                         }\r
 466 \r
 467                         if (Options.ElseOnClosing) {\r
 468                                 if (statement.CatchClauses.Count == 0)\r
 469                                         output.WriteLine ("Catch");\r
 470                                 if (statement.FinallyStatements.Count == 0)\r
 471                                         output.WriteLine ("Finally");\r
 472                         }\r
 473 \r
 474                         output.WriteLine("End Try");\r
 475                 }\r
 476 \r
 477                 protected override void GenerateAssignStatement (CodeAssignStatement statement)\r
 478                 {                       \r
 479                         TextWriter output = Output;\r
 480                         GenerateExpression (statement.Left);\r
 481                         output.Write (" = ");\r
 482                         GenerateExpression (statement.Right);\r
 483                         output.WriteLine ();\r
 484                 }\r
 485 \r
 486                 protected override void GenerateAttachEventStatement (CodeAttachEventStatement statement)\r
 487                 {\r
 488                         TextWriter output = Output;\r
 489 \r
 490                         Output.Write ("AddHandler ");\r
 491                         GenerateEventReferenceExpression (statement.Event);\r
 492                         Output.Write ( ", ");\r
 493                         GenerateExpression (statement.Listener);\r
 494                         output.WriteLine ();\r
 495                 }\r
 496 \r
 497                 protected override void GenerateRemoveEventStatement (CodeRemoveEventStatement statement)\r
 498                 {\r
 499                         TextWriter output = Output;\r
 500 \r
 501                         Output.Write ("RemoveHandler ");\r
 502                         GenerateEventReferenceExpression (statement.Event);\r
 503                         Output.Write ( ", ");\r
 504                         GenerateExpression (statement.Listener);\r
 505                         output.WriteLine ();\r
 506                 }\r
 507 \r
 508                 protected override void GenerateGotoStatement (CodeGotoStatement statement)\r
 509                 {\r
 510                         TextWriter output = Output;\r
 511 \r
 512                         output.Write ("Goto ");\r
 513                         output.Write (statement.Label);\r
 514                         output.WriteLine ();\r
 515                 }\r
 516                 \r
 517                 protected override void GenerateLabeledStatement (CodeLabeledStatement statement)\r
 518                 {\r
 519                         TextWriter output = Output;\r
 520 \r
 521                         output.Write (statement.Label + ":");\r
 522                         GenerateStatement (statement.Statement);\r
 523                 }\r
 524 \r
 525                 protected override void GenerateTypeOfExpression (CodeTypeOfExpression e)\r
 526                 {\r
 527                         TextWriter output = Output;\r
 528 \r
 529                         output.Write ("GetType(");\r
 530                         OutputType (e.Type);\r
 531                         output.Write (")");\r
 532                 }\r
 533 \r
 534                 protected override void GenerateVariableDeclarationStatement( CodeVariableDeclarationStatement statement )\r
 535                 {\r
 536                         TextWriter output = Output;\r
 537 \r
 538                         output.Write ("Dim ");\r
 539                         OutputTypeNamePair (statement.Type, statement.Name);\r
 540 \r
 541                         CodeExpression initExpression = statement.InitExpression;\r
 542                         if (initExpression != null) \r
 543                         {\r
 544                                 output.Write (" = ");\r
 545                                 GenerateExpression (initExpression);\r
 546                         }\r
 547 \r
 548                         output.WriteLine();\r
 549                 }\r
 550 \r
 551                 protected override void GenerateLinePragmaStart (CodeLinePragma linePragma)\r
 552                 {\r
 553                         Output.WriteLine ();\r
 554                         Output.Write ("#ExternalSource(");\r
 555                         Output.Write (linePragma.FileName);\r
 556                         Output.Write (", ");\r
 557                         Output.Write (linePragma.LineNumber);\r
 558                         Output.WriteLine (")");\r
 559                 }\r
 560 \r
 561                 protected override void GenerateLinePragmaEnd (CodeLinePragma linePragma)\r
 562                 {\r
 563                         Output.WriteLine ("#End ExternalSource");\r
 564                 }\r
 565 \r
 566                 protected override void GenerateEvent (CodeMemberEvent eventRef, CodeTypeDeclaration declaration)\r
 567                 {\r
 568                         if (IsCurrentDelegate || IsCurrentEnum) {\r
 569                                 return;\r
 570                         }\r
 571 \r
 572                         TextWriter output = Output;\r
 573 \r
 574                         OutputAttributes (eventRef.CustomAttributes, null, \r
 575                                 LineHandling.ContinueLine);\r
 576 \r
 577                         OutputMemberAccessModifier (eventRef.Attributes);\r
 578 \r
 579                         output.Write ("Event ");\r
 580                         OutputTypeNamePair (eventRef.Type, GetEventName(eventRef));\r
 581 \r
 582 #if NET_2_0\r
 583                         if (eventRef.ImplementationTypes.Count > 0) {\r
 584                                 OutputImplementationTypes (eventRef.ImplementationTypes, eventRef.Name);\r
 585                         } else if (eventRef.PrivateImplementationType != null) {\r
 586                                 output.Write (" Implements ");\r
 587                                 OutputType (eventRef.PrivateImplementationType);\r
 588                                 output.Write ('.');\r
 589                                 output.Write (eventRef.Name);\r
 590                         }\r
 591 #endif\r
 592 \r
 593                         output.WriteLine ();\r
 594                 }\r
 595 \r
 596                 protected override void GenerateField (CodeMemberField field)\r
 597                 {\r
 598                         if (IsCurrentDelegate || IsCurrentInterface) {\r
 599                                 return;\r
 600                         }\r
 601 \r
 602                         TextWriter output = Output;\r
 603 \r
 604                         OutputAttributes (field.CustomAttributes, null, \r
 605                                 LineHandling.ContinueLine);\r
 606 \r
 607                         if (IsCurrentEnum) {\r
 608                                 output.Write (field.Name);\r
 609                         } else {\r
 610                                 MemberAttributes attributes = field.Attributes;\r
 611                                 OutputMemberAccessModifier (attributes);\r
 612                                 OutputVTableModifier (attributes);\r
 613                                 OutputFieldScopeModifier (attributes);\r
 614                                 OutputTypeNamePair (field.Type, field.Name);\r
 615                         }\r
 616 \r
 617                         CodeExpression initExpression = field.InitExpression;\r
 618                         if (initExpression != null) {\r
 619                                 output.Write (" = ");\r
 620                                 GenerateExpression (initExpression);\r
 621                         }\r
 622 \r
 623                         output.WriteLine();\r
 624                 }\r
 625                 \r
 626                 protected override void GenerateSnippetMember (CodeSnippetTypeMember member)\r
 627                 {\r
 628                         Output.Write (member.Text);\r
 629                 }\r
 630                 \r
 631                 protected override void GenerateEntryPointMethod (CodeEntryPointMethod method, CodeTypeDeclaration declaration)\r
 632                 {\r
 633 #if NET_2_0\r
 634                         OutputAttributes (method.CustomAttributes, null, \r
 635                                 LineHandling.ContinueLine);\r
 636 #endif\r
 637 \r
 638                         Output.WriteLine ("Public Shared Sub Main()");\r
 639                         Indent++;\r
 640                         GenerateStatements (method.Statements);\r
 641                         Indent--;\r
 642                         Output.WriteLine ("End Sub");\r
 643                 }\r
 644                 \r
 645                 [MonoTODO ("partially implemented")]\r
 646                 protected override void GenerateMethod (CodeMemberMethod method, CodeTypeDeclaration declaration)\r
 647                 {\r
 648                         if (IsCurrentDelegate || IsCurrentEnum) {\r
 649                                 return;\r
 650                         }\r
 651 \r
 652                         bool isSub = method.ReturnType.BaseType == typeof(void).FullName;\r
 653 \r
 654                         TextWriter output = Output;\r
 655 \r
 656                         OutputAttributes (method.CustomAttributes, null, \r
 657                                 LineHandling.ContinueLine);\r
 658 \r
 659                         MemberAttributes attributes = method.Attributes;\r
 660 \r
 661                         if (!IsCurrentInterface) {\r
 662                                 if (method.PrivateImplementationType == null) {\r
 663                                         OutputMemberAccessModifier (attributes);\r
 664                                         if (IsOverloaded (method, declaration)) {\r
 665                                                 output.Write ("Overloads ");\r
 666                                         }\r
 667                                 }\r
 668                                 OutputVTableModifier (attributes);\r
 669                                 OutputMemberScopeModifier (attributes);\r
 670                         } else {\r
 671                                 OutputVTableModifier (attributes);\r
 672                         }\r
 673 \r
 674                         if (isSub)\r
 675                                 output.Write ("Sub ");\r
 676                         else\r
 677                                 output.Write ("Function ");\r
 678 \r
 679                         output.Write (GetMethodName(method));\r
 680                         output.Write ('(');\r
 681                         OutputParameters (method.Parameters);\r
 682                         output.Write (')');\r
 683 \r
 684                         if (!isSub) {\r
 685                                 output.Write (" As ");\r
 686                                 OutputAttributes (method.ReturnTypeCustomAttributes, null,\r
 687                                         LineHandling.InLine);\r
 688                                 OutputType (method.ReturnType);\r
 689                         }\r
 690 \r
 691                         if (method.ImplementationTypes.Count > 0) {\r
 692                                 OutputImplementationTypes (method.ImplementationTypes, method.Name);\r
 693                         } else if (method.PrivateImplementationType != null) {\r
 694                                 output.Write (" Implements ");\r
 695                                 OutputType (method.PrivateImplementationType);\r
 696                                 output.Write ('.');\r
 697                                 output.Write (method.Name);\r
 698                         }\r
 699 \r
 700                         output.WriteLine ();\r
 701                         if (!IsCurrentInterface) {\r
 702                                 if ((attributes & MemberAttributes.ScopeMask) != MemberAttributes.Abstract) {\r
 703                                         ++Indent;\r
 704                                         GenerateStatements (method.Statements);\r
 705                                         --Indent;\r
 706                                         if (isSub)\r
 707                                                 output.WriteLine ("End Sub");\r
 708                                         else\r
 709                                                 output.WriteLine ("End Function");\r
 710                                 }\r
 711                         }\r
 712                 }\r
 713 \r
 714                 protected override void GenerateProperty (CodeMemberProperty property, CodeTypeDeclaration declaration)\r
 715                 {\r
 716                         if (IsCurrentDelegate || IsCurrentEnum) {\r
 717                                 return;\r
 718                         }\r
 719 \r
 720                         TextWriter output = Output;\r
 721 \r
 722                         OutputAttributes (property.CustomAttributes, null, \r
 723                                 LineHandling.ContinueLine);\r
 724 \r
 725                         MemberAttributes attributes = property.Attributes;\r
 726 \r
 727                         if (!IsCurrentInterface) {\r
 728                                 if (property.PrivateImplementationType == null) {\r
 729                                         OutputMemberAccessModifier (attributes);\r
 730                                         if (IsOverloaded (property, declaration)) {\r
 731                                                 output.Write ("Overloads ");\r
 732                                         }\r
 733                                 }\r
 734                                 OutputVTableModifier (attributes);\r
 735                                 OutputMemberScopeModifier (attributes);\r
 736                         } else {\r
 737                                 OutputVTableModifier (attributes);\r
 738                         }\r
 739 \r
 740                         // mark property as default property if we're dealing with an indexer\r
 741                         if (string.Compare (GetPropertyName(property), "Item", true, CultureInfo.InvariantCulture) == 0 && property.Parameters.Count > 0) {\r
 742                                 output.Write ("Default ");\r
 743                         }\r
 744 \r
 745                         if (property.HasGet && (!property.HasSet))\r
 746                                 output.Write ("ReadOnly " );\r
 747 \r
 748                         if (property.HasSet && (!property.HasGet))\r
 749                                 output.Write ("WriteOnly " );\r
 750 \r
 751                         output.Write ("Property ");\r
 752                         Output.Write (GetPropertyName (property));\r
 753 #if NET_2_0\r
 754                         // in .NET 2.0, always output parantheses (whether or not there \r
 755                         // are any parameters to output\r
 756                         Output.Write ('(');\r
 757                         OutputParameters (property.Parameters);\r
 758                         Output.Write (')');\r
 759 #else\r
 760                         if (property.Parameters.Count > 0) {\r
 761                                 Output.Write ('(');\r
 762                                 OutputParameters (property.Parameters);\r
 763                                 Output.Write (')');\r
 764                         }\r
 765 #endif\r
 766                         Output.Write (" As ");\r
 767                         Output.Write (GetTypeOutput(property.Type));\r
 768 \r
 769                         if (property.ImplementationTypes.Count > 0) {\r
 770                                 OutputImplementationTypes (property.ImplementationTypes, property.Name);\r
 771                         } else if (property.PrivateImplementationType != null) {\r
 772                                 output.Write (" Implements ");\r
 773                                 OutputType (property.PrivateImplementationType);\r
 774                                 output.Write ('.');\r
 775                                 output.Write (property.Name);\r
 776                         }\r
 777 \r
 778                         output.WriteLine ();\r
 779 \r
 780                         if (!IsCurrentInterface) {\r
 781                                 ++Indent;\r
 782                                 if (property.HasGet) {\r
 783                                         output.WriteLine ("Get");\r
 784                                         ++Indent;\r
 785                                         GenerateStatements (property.GetStatements);\r
 786                                         --Indent;\r
 787                                         output.WriteLine ("End Get");\r
 788                                 }\r
 789 \r
 790                                 if (property.HasSet) {\r
 791                                         output.WriteLine ("Set");\r
 792                                         ++Indent;\r
 793                                         GenerateStatements (property.SetStatements);\r
 794                                         --Indent;\r
 795                                         output.WriteLine ("End Set");\r
 796                                 }\r
 797 \r
 798                                 --Indent;\r
 799                                 output.WriteLine ("End Property");\r
 800                         }\r
 801                 }\r
 802 \r
 803                 protected override void GenerateConstructor (CodeConstructor constructor, CodeTypeDeclaration declaration)\r
 804                 {\r
 805                         if (IsCurrentDelegate || IsCurrentEnum || IsCurrentInterface) {\r
 806                                 return;\r
 807                         }\r
 808 \r
 809                         OutputAttributes (constructor.CustomAttributes, null,\r
 810                                 LineHandling.ContinueLine);\r
 811                         OutputMemberAccessModifier (constructor.Attributes);\r
 812                         Output.Write ("Sub New(");\r
 813                         OutputParameters (constructor.Parameters);\r
 814                         Output.WriteLine (")");\r
 815                         Indent++;\r
 816                         // check if ctor passes args on to other ctor in class\r
 817                         CodeExpressionCollection ctorArgs = constructor.ChainedConstructorArgs;\r
 818                         if (ctorArgs.Count > 0) {\r
 819                                 Output.Write ("Me.New(");\r
 820                                 OutputExpressionList (ctorArgs);\r
 821                                 Output.WriteLine (")");\r
 822                         } else {\r
 823                                 // check if ctor passes args on to ctor in base class\r
 824                                 ctorArgs = constructor.BaseConstructorArgs;\r
 825                                 if (ctorArgs.Count > 0) {\r
 826                                         Output.Write ("MyBase.New(");\r
 827                                         OutputExpressionList (ctorArgs);\r
 828                                         Output.WriteLine (")");\r
 829 #if NET_2_0\r
 830                                 } else if (IsCurrentClass) {\r
 831 #else\r
 832                                 } else {\r
 833 #endif\r
 834                                         // call default base ctor\r
 835                                         Output.WriteLine ("MyBase.New()");\r
 836                                 }\r
 837                         }\r
 838                         GenerateStatements (constructor.Statements);\r
 839                         Indent--;\r
 840                         Output.WriteLine ("End Sub");\r
 841                 }\r
 842                 \r
 843                 protected override void GenerateTypeConstructor (CodeTypeConstructor constructor)\r
 844                 {\r
 845                         if (IsCurrentDelegate || IsCurrentEnum || IsCurrentInterface) {\r
 846                                 return;\r
 847                         }\r
 848 \r
 849 #if NET_2_0\r
 850                         OutputAttributes (constructor.CustomAttributes, null,\r
 851                                 LineHandling.ContinueLine);\r
 852 #endif\r
 853 \r
 854                         Output.WriteLine ("Shared Sub New()");\r
 855                         Indent++;\r
 856                         GenerateStatements (constructor.Statements);\r
 857                         Indent--;\r
 858                         Output.WriteLine ("End Sub");\r
 859                 }\r
 860 \r
 861                 [MonoTODO ("not implemented")]\r
 862                 protected override void GenerateTypeStart (CodeTypeDeclaration declaration)\r
 863                 {\r
 864                         TextWriter output = Output;\r
 865 \r
 866                         OutputAttributes (declaration.CustomAttributes, null, \r
 867                                 LineHandling.ContinueLine);\r
 868 \r
 869                         TypeAttributes attributes = declaration.TypeAttributes;\r
 870 \r
 871                         if (IsCurrentDelegate) {\r
 872                                 CodeTypeDelegate delegateDecl = (CodeTypeDelegate) declaration;\r
 873 \r
 874                                 if ((attributes & TypeAttributes.VisibilityMask) == TypeAttributes.Public) {\r
 875                                         output.Write ("Public ");\r
 876                                 }\r
 877 \r
 878                                 bool isSub = delegateDecl.ReturnType.BaseType == typeof (void).FullName;\r
 879                                 if (isSub) {\r
 880                                         output.Write ("Delegate Sub ");\r
 881                                 } else {\r
 882                                         output.Write ("Delegate Function ");\r
 883                                 }\r
 884 \r
 885                                 output.Write (delegateDecl.Name);\r
 886                                 output.Write ("(");\r
 887                                 Output.Write (")");\r
 888                                 if (!isSub) {\r
 889                                         Output.Write (" As ");\r
 890                                         OutputType (delegateDecl.ReturnType);\r
 891                                 }\r
 892                                 Output.WriteLine ("");\r
 893                         } else {\r
 894                                 OutputTypeAttributes (declaration);\r
 895 \r
 896                                 output.Write (declaration.Name);\r
 897 \r
 898                                 if (IsCurrentEnum) {\r
 899                                         if (declaration.BaseTypes.Count > 0) {\r
 900                                                 output.Write (" As ");\r
 901                                                 OutputType (declaration.BaseTypes[0]);\r
 902                                         }\r
 903                                         output.WriteLine ();\r
 904                                         ++Indent;\r
 905                                 } else {\r
 906                                         ++Indent;\r
 907 \r
 908                                         bool firstInherits = true;\r
 909                                         bool firstImplements = true;\r
 910 \r
 911                                         for (int i = 0; i < declaration.BaseTypes.Count; i++) {\r
 912                                                 // a struct can only implement interfaces\r
 913                                                 // an interface can only inherit from other interface\r
 914 \r
 915                                                 CodeTypeReference typeRef = declaration.BaseTypes[i];\r
 916                                                 \r
 917                                                 if (firstInherits && !declaration.IsStruct && !typeRef.IsInterface) {\r
 918                                                         output.WriteLine ();\r
 919                                                         output.Write ("Inherits ");\r
 920                                                         firstInherits = false;\r
 921                                                 } else if (!declaration.IsInterface && firstImplements) {\r
 922                                                         output.WriteLine ();\r
 923                                                         output.Write ("Implements ");\r
 924                                                         firstImplements = false;\r
 925                                                 } else {\r
 926                                                         output.Write (", ");\r
 927                                                 }\r
 928                                                 OutputType (typeRef);\r
 929                                         }\r
 930                                         output.WriteLine ();\r
 931                                 }\r
 932                         }\r
 933                 }\r
 934 \r
 935                 protected override void GenerateTypeEnd (CodeTypeDeclaration declaration)\r
 936                 {\r
 937                         if (IsCurrentDelegate) {\r
 938                                 return;\r
 939                         }\r
 940                         string output = string.Empty;\r
 941 \r
 942                         --Indent;\r
 943                         if (declaration.IsStruct)\r
 944                                 output = "End Structure";\r
 945                         if (declaration.IsInterface)\r
 946                                 output = "End Interface";\r
 947                         if (declaration.IsEnum)\r
 948                                 output = "End Enum";\r
 949                         if (declaration.IsClass)\r
 950                                 output = "End Class";\r
 951 \r
 952                         Output.WriteLine (output);\r
 953                 }\r
 954 \r
 955                 protected override void GenerateNamespace(CodeNamespace ns)\r
 956                 {\r
 957                         GenerateCommentStatements (ns.Comments);\r
 958                         \r
 959                         // add regular imports\r
 960                         GenerateNamespaceImports (ns);\r
 961 \r
 962                         Output.WriteLine (); \r
 963                         GenerateNamespaceStart (ns); \r
 964                         GenerateTypes (ns);\r
 965                         GenerateNamespaceEnd (ns);\r
 966                 }\r
 967 \r
 968 \r
 969                 protected override void GenerateNamespaceStart (CodeNamespace ns)\r
 970                 {\r
 971                         TextWriter output = Output;\r
 972                         \r
 973                         string name = ns.Name;\r
 974                         if (name != null && name != string.Empty) {\r
 975                                 output.Write ("Namespace ");\r
 976                                 output.WriteLine (name);\r
 977                                 ++Indent;\r
 978                         }\r
 979                 }\r
 980 \r
 981                 protected override void GenerateNamespaceEnd (CodeNamespace ns)\r
 982                 {\r
 983                         string name = ns.Name;\r
 984                         if (name != null && name != string.Empty) {\r
 985                                 --Indent;\r
 986                                 Output.WriteLine ("End Namespace");\r
 987                         }\r
 988                 }\r
 989 \r
 990                 protected override void GenerateNamespaceImport (CodeNamespaceImport import)\r
 991                 {\r
 992                         TextWriter output = Output;\r
 993 \r
 994                         output.Write ("Imports ");\r
 995                         output.Write (import.Namespace);\r
 996                         output.WriteLine ();\r
 997                 }\r
 998                 \r
 999                 protected override void GenerateAttributeDeclarationsStart (CodeAttributeDeclarationCollection attributes)\r
1000                 {\r
1001                         Output.Write ('<');\r
1002                 }\r
1003                 \r
1004                 protected override void GenerateAttributeDeclarationsEnd (CodeAttributeDeclarationCollection attributes)\r
1005                 {\r
1006                         Output.Write (">");\r
1007                 }\r
1008 \r
1009                 private void OutputAttributes (CodeAttributeDeclarationCollection attributes, string prefix, LineHandling lineHandling) {\r
1010                         if (attributes.Count == 0) {\r
1011                                 return;\r
1012                         }\r
1013 \r
1014                         GenerateAttributeDeclarationsStart (attributes);\r
1015 \r
1016                         IEnumerator enumerator = attributes.GetEnumerator ();\r
1017                         if (enumerator.MoveNext ()) {\r
1018                                 CodeAttributeDeclaration att = (CodeAttributeDeclaration) enumerator.Current;\r
1019                                 if (prefix != null) {\r
1020                                         Output.Write (prefix);\r
1021                                 }\r
1022                                 OutputAttributeDeclaration (att);\r
1023 \r
1024                                 while (enumerator.MoveNext ()) {\r
1025                                         Output.Write (", ");\r
1026                                         if (lineHandling != LineHandling.InLine) {\r
1027                                                 ContinueOnNewLine ("");\r
1028                                                 Output.Write (" ");\r
1029                                         }\r
1030                                         att = (CodeAttributeDeclaration) enumerator.Current;\r
1031                                         if (prefix != null) {\r
1032                                                 Output.Write (prefix);\r
1033                                         }\r
1034                                         OutputAttributeDeclaration (att);\r
1035                                 }\r
1036                         }\r
1037                         GenerateAttributeDeclarationsEnd (attributes);\r
1038                         Output.Write (" ");\r
1039 \r
1040                         switch (lineHandling) {\r
1041                                 case LineHandling.ContinueLine:\r
1042                                         ContinueOnNewLine ("");\r
1043                                         break;\r
1044                                 case LineHandling.NewLine:\r
1045                                         Output.WriteLine ();\r
1046                                         break;\r
1047                         }\r
1048                 }\r
1049 \r
1050                 protected override void OutputAttributeArgument (CodeAttributeArgument argument)\r
1051                 {\r
1052                         string name = argument.Name;\r
1053                         if (name != null && name.Length > 0) {\r
1054                                 Output.Write (name);\r
1055                                 Output.Write (":=");\r
1056                         }\r
1057                         GenerateExpression (argument.Value);\r
1058                 }\r
1059 \r
1060                 private void OutputAttributeDeclaration (CodeAttributeDeclaration attribute)\r
1061                 {\r
1062                         Output.Write (attribute.Name.Replace ('+', '.'));\r
1063                         Output.Write ('(');\r
1064                         IEnumerator enumerator = attribute.Arguments.GetEnumerator ();\r
1065                         if (enumerator.MoveNext ()) {\r
1066                                 CodeAttributeArgument argument = (CodeAttributeArgument) enumerator.Current;\r
1067                                 OutputAttributeArgument (argument);\r
1068 \r
1069                                 while (enumerator.MoveNext ()) {\r
1070                                         Output.Write (", ");\r
1071                                         argument = (CodeAttributeArgument) enumerator.Current;\r
1072                                         OutputAttributeArgument (argument);\r
1073                                 }\r
1074                         }\r
1075                         Output.Write (')');\r
1076                 }\r
1077 \r
1078                 protected override void OutputDirection (FieldDirection direction)\r
1079                 {\r
1080                         switch (direction) {\r
1081                         case FieldDirection.In:\r
1082                                 Output.Write ("ByVal ");\r
1083                                 break;\r
1084                         case FieldDirection.Out:\r
1085                         case FieldDirection.Ref:\r
1086                                 Output.Write ("ByRef ");\r
1087                                 break;\r
1088                         }\r
1089                 }\r
1090 \r
1091                 protected override void OutputFieldScopeModifier (MemberAttributes attributes)\r
1092                 {\r
1093                         switch (attributes & MemberAttributes.ScopeMask) {\r
1094                                 case MemberAttributes.Static:\r
1095                                         Output.Write ("Shared ");\r
1096                                         break;\r
1097                                 case MemberAttributes.Const:\r
1098                                         Output.Write ("Const ");\r
1099                                         break;\r
1100                         }\r
1101                 }\r
1102 \r
1103                 private void OutputImplementationTypes (CodeTypeReferenceCollection implementationTypes, string member)\r
1104                 {\r
1105                         IEnumerator enumerator = implementationTypes.GetEnumerator ();\r
1106                         if (enumerator.MoveNext ()) {\r
1107                                 Output.Write (" Implements ");\r
1108 \r
1109                                 CodeTypeReference typeReference = (CodeTypeReference) enumerator.Current;\r
1110                                 OutputType (typeReference);\r
1111                                 Output.Write ('.');\r
1112                                 OutputIdentifier (member);\r
1113 \r
1114                                 while (enumerator.MoveNext ()) {\r
1115                                         Output.Write (" , ");\r
1116                                         typeReference = (CodeTypeReference) enumerator.Current;\r
1117                                         OutputType (typeReference);\r
1118                                         Output.Write ('.');\r
1119                                         OutputIdentifier (member);\r
1120                                 }\r
1121                         }\r
1122                 }\r
1123 \r
1124                 protected override void OutputMemberAccessModifier (MemberAttributes attributes)\r
1125                 {\r
1126                         switch (attributes & MemberAttributes.AccessMask) {\r
1127                                 case MemberAttributes.Assembly:\r
1128                                 case MemberAttributes.FamilyAndAssembly:\r
1129                                         Output.Write ("Friend "); \r
1130                                         break;\r
1131                                 case MemberAttributes.Family:\r
1132                                         Output.Write ("Protected ");\r
1133                                         break;\r
1134                                 case MemberAttributes.FamilyOrAssembly:\r
1135                                         Output.Write ("Protected Friend ");\r
1136                                         break;\r
1137                                 case MemberAttributes.Private:\r
1138                                         Output.Write ("Private ");\r
1139                                         break;\r
1140                                 case MemberAttributes.Public:\r
1141                                         Output.Write ("Public ");\r
1142                                         break;\r
1143                         }\r
1144                 }\r
1145 \r
1146                 private void OutputVTableModifier (MemberAttributes attributes)\r
1147                 {\r
1148                         if ((attributes & MemberAttributes.VTableMask) == MemberAttributes.New) {\r
1149                                 Output.Write ("Shadows ");\r
1150                         }\r
1151                 }\r
1152 \r
1153                 protected override void OutputMemberScopeModifier (MemberAttributes attributes)\r
1154                 {\r
1155                         switch (attributes & MemberAttributes.ScopeMask) {\r
1156                                 case MemberAttributes.Abstract:\r
1157                                         Output.Write ("MustOverride ");\r
1158                                         break;\r
1159                                 case MemberAttributes.Final:\r
1160                                         // do nothing\r
1161                                         break;\r
1162                                 case MemberAttributes.Static:\r
1163                                         Output.Write ("Shared ");\r
1164                                         break;\r
1165                                 case MemberAttributes.Override:\r
1166                                         Output.Write ("Overrides ");\r
1167                                         break;\r
1168                                 case MemberAttributes.Overloaded:\r
1169                                         // based on http://gendotnet.com/Code%20Gen%20Articles/codedom.htm\r
1170                                         Output.Write ("Overloads ");\r
1171 \r
1172                                         MemberAttributes access_ovl = attributes & MemberAttributes.AccessMask;\r
1173                                         if (access_ovl == MemberAttributes.Public || access_ovl == MemberAttributes.Family) {\r
1174                                                 Output.Write ("Overridable ");\r
1175                                         }\r
1176                                         break;\r
1177                                 default:\r
1178                                         //\r
1179                                         // FUNNY! if the scope value is\r
1180                                         // rubbish (0 or >Const), and access\r
1181                                         // is public, protected make it\r
1182                                         // "virtual".\r
1183                                         //\r
1184                                         // i'm not sure whether this is 100%\r
1185                                         // correct, but it seems to be MS\r
1186                                         // behavior.\r
1187                                         //\r
1188                                         // On MS.NET 2.0, internal properties\r
1189                                         // are also marked "virtual".\r
1190                                         //\r
1191                                         MemberAttributes access = attributes & MemberAttributes.AccessMask;\r
1192                                         if (access == MemberAttributes.Public || \r
1193 #if NET_2_0\r
1194                                                 access == MemberAttributes.Family || access == MemberAttributes.Assembly)\r
1195 #else\r
1196                                                 access == MemberAttributes.Family)\r
1197 #endif\r
1198                                                 Output.Write ("Overridable ");\r
1199                                         break;\r
1200                         }\r
1201                 }\r
1202 \r
1203                 protected override void OutputOperator (CodeBinaryOperatorType op)\r
1204                 {\r
1205                         switch (op) {\r
1206                         case CodeBinaryOperatorType.Add:\r
1207                                 Output.Write ("+");\r
1208                                 break;\r
1209                         case CodeBinaryOperatorType.Subtract:\r
1210                                 Output.Write ("-");\r
1211                                 break;\r
1212                         case CodeBinaryOperatorType.Multiply:\r
1213                                 Output.Write ("*");\r
1214                                 break;\r
1215                         case CodeBinaryOperatorType.Divide:\r
1216                                 Output.Write ("/");\r
1217                                 break;\r
1218                         case CodeBinaryOperatorType.Modulus:\r
1219                                 Output.Write ("Mod");\r
1220                                 break;\r
1221                         case CodeBinaryOperatorType.Assign:\r
1222                                 Output.Write ("=");\r
1223                                 break;\r
1224                         case CodeBinaryOperatorType.IdentityInequality:\r
1225                                 Output.Write ("<>");\r
1226                                 break;\r
1227                         case CodeBinaryOperatorType.IdentityEquality:\r
1228                                 Output.Write ("Is");\r
1229                                 break;\r
1230                         case CodeBinaryOperatorType.ValueEquality:\r
1231                                 Output.Write ("=");\r
1232                                 break;\r
1233                         case CodeBinaryOperatorType.BitwiseOr:\r
1234                                 Output.Write ("Or");\r
1235                                 break;\r
1236                         case CodeBinaryOperatorType.BitwiseAnd:\r
1237                                 Output.Write ("And");\r
1238                                 break;\r
1239                         case CodeBinaryOperatorType.BooleanOr:\r
1240                                 Output.Write ("OrElse");\r
1241                                 break;\r
1242                         case CodeBinaryOperatorType.BooleanAnd:\r
1243                                 Output.Write ("AndAlso");\r
1244                                 break;\r
1245                         case CodeBinaryOperatorType.LessThan:\r
1246                                 Output.Write ("<");\r
1247                                 break;\r
1248                         case CodeBinaryOperatorType.LessThanOrEqual:\r
1249                                 Output.Write ("<=");\r
1250                                 break;\r
1251                         case CodeBinaryOperatorType.GreaterThan:\r
1252                                 Output.Write (">");\r
1253                                 break;\r
1254                         case CodeBinaryOperatorType.GreaterThanOrEqual:\r
1255                                 Output.Write (">=");\r
1256                                 break;\r
1257                         }\r
1258                 }\r
1259 \r
1260                 private void OutputTypeAttributes (CodeTypeDeclaration declaration)\r
1261                 {\r
1262                         TextWriter output = Output;\r
1263                         TypeAttributes attributes = declaration.TypeAttributes;\r
1264 \r
1265                         switch (attributes & TypeAttributes.VisibilityMask) {\r
1266                                 case TypeAttributes.Public:\r
1267                                 case TypeAttributes.NestedPublic:\r
1268                                         output.Write ("Public ");\r
1269                                         break;\r
1270                                 case TypeAttributes.NestedPrivate:\r
1271                                         output.Write ("Private ");\r
1272                                         break;\r
1273 #if NET_2_0\r
1274                                 case TypeAttributes.NotPublic:\r
1275                                 case TypeAttributes.NestedFamANDAssem:\r
1276                                 case TypeAttributes.NestedAssembly:\r
1277                                         output.Write ("Friend ");\r
1278                                         break; \r
1279                                 case TypeAttributes.NestedFamily:\r
1280                                         output.Write ("Protected ");\r
1281                                         break;\r
1282                                 case TypeAttributes.NestedFamORAssem:\r
1283                                         output.Write ("Protected Friend ");\r
1284                                         break;\r
1285 #endif\r
1286                         }\r
1287 \r
1288                         if (declaration.IsStruct) {\r
1289                                 output.Write ("Structure ");\r
1290                         } else if (declaration.IsEnum) {\r
1291                                 output.Write ("Enum ");\r
1292                         } else {\r
1293                                 if ((attributes & TypeAttributes.Interface) != 0) {\r
1294                                         output.Write ("Interface ");\r
1295                                 } else {\r
1296                                         if ((attributes & TypeAttributes.Sealed) != 0)\r
1297                                                 output.Write ("NotInheritable ");\r
1298 \r
1299                                         if ((attributes & TypeAttributes.Abstract) != 0)\r
1300                                                 output.Write ("MustInherit ");\r
1301 \r
1302                                         output.Write ("Class ");\r
1303                                 }\r
1304                         }\r
1305                 }\r
1306 \r
1307                 protected override void OutputTypeNamePair (CodeTypeReference typeRef, String name)\r
1308                 {\r
1309                         Output.Write (name + " As " + GetTypeOutput (typeRef));\r
1310                 }\r
1311 \r
1312                 protected override void OutputType (CodeTypeReference type)\r
1313                 {\r
1314                         Output.Write (GetTypeOutput (type));\r
1315                 }\r
1316 \r
1317                 protected override string QuoteSnippetString (string value)\r
1318                 {\r
1319                         StringBuilder mySBuilder = new StringBuilder(value.Length);\r
1320                         mySBuilder.Append ("\"");\r
1321                         bool inQuotes = true;\r
1322                         for (int MyCounter = 0; MyCounter < value.Length; MyCounter++)\r
1323                         {\r
1324                                 if (value[MyCounter] == 34) //quotation mark\r
1325                                 {\r
1326                                         if (!inQuotes)\r
1327                                         {\r
1328                                                 mySBuilder.Append ("&\"");\r
1329                                                 inQuotes = true;\r
1330                                         }\r
1331                                         mySBuilder.Append (value[MyCounter]);\r
1332                                         mySBuilder.Append (value[MyCounter]);\r
1333                                 }\r
1334                                 else if (value[MyCounter] >= 32) //standard ansi/unicode characters\r
1335                                 {\r
1336                                         if (!inQuotes)\r
1337                                         {\r
1338                                                 mySBuilder.Append ("&\"");\r
1339                                                 inQuotes = true;\r
1340                                         }\r
1341                                         mySBuilder.Append (value[MyCounter]);\r
1342                                 }\r
1343                                 else //special chars, e.g. line break\r
1344                                 {\r
1345                                         if (inQuotes)\r
1346                                         { \r
1347                                                 mySBuilder.Append ("\"");\r
1348                                                 inQuotes = false;\r
1349                                         }\r
1350                                         mySBuilder.Append ("&Microsoft.VisualBasic.ChrW(");\r
1351                                         mySBuilder.Append ((int)value[MyCounter]); \r
1352                                         mySBuilder.Append (")");\r
1353                                 }                       \r
1354                         }\r
1355                         if (inQuotes)\r
1356                                 mySBuilder.Append ("\"");\r
1357                         return mySBuilder.ToString();\r
1358                 }\r
1359 \r
1360                 private void GenerateMemberReferenceExpression (CodeExpression targetObject, string memberName)\r
1361                 {\r
1362                         GenerateExpression (targetObject);\r
1363                         Output.Write ('.');\r
1364                         Output.Write (memberName);\r
1365                 }\r
1366                         \r
1367                 /* \r
1368                  * ICodeGenerator\r
1369                  */\r
1370 \r
1371                 protected override string CreateEscapedIdentifier (string value)\r
1372                 {\r
1373                         for (int x = 0; x < Keywords.Length; x++)\r
1374                                 if (value.ToLower().Equals (Keywords[x].ToLower()))\r
1375                                         return "[" + value + "]";\r
1376                         return value;\r
1377                 }\r
1378 \r
1379                 protected override string CreateValidIdentifier (string value)\r
1380                 {\r
1381                         for (int x = 0; x < Keywords.Length; x++)\r
1382                                 if (value.ToLower().Equals (Keywords[x].ToLower()))\r
1383                                         return "_" + value;\r
1384                         return value;\r
1385                 }\r
1386 \r
1387                 protected override string GetTypeOutput (CodeTypeReference type)\r
1388                 {\r
1389                         string output;\r
1390                         CodeTypeReference arrayType;\r
1391 \r
1392                         arrayType = type.ArrayElementType;\r
1393                         if (arrayType != null)\r
1394                                 output = GetTypeOutput (arrayType);\r
1395                         else { \r
1396                                 switch (type.BaseType) {\r
1397                                 case "System.DateTime":\r
1398                                         output = "Date";\r
1399                                         break;\r
1400                                 case "System.Decimal":\r
1401                                         output = "Decimal";\r
1402                                         break;\r
1403                                 case "System.Double":\r
1404                                         output = "Double";\r
1405                                         break;\r
1406                                 case "System.Single":\r
1407                                         output = "Single";\r
1408                                         break;\r
1409                                 case "System.Byte":\r
1410                                         output = "Byte";\r
1411                                         break;\r
1412                                 case "System.Int32":\r
1413                                         output = "Integer";\r
1414                                         break;\r
1415                                 case "System.Int64":\r
1416                                         output = "Long";\r
1417                                         break;\r
1418                                 case "System.Int16":\r
1419                                         output = "Short";\r
1420                                         break;\r
1421                                 case "System.Boolean":\r
1422                                         output = "Boolean";\r
1423                                         break;\r
1424                                 case "System.Char":\r
1425                                         output = "Char";\r
1426                                         break;\r
1427                                 case "System.String":\r
1428                                         output = "String";\r
1429                                         break;\r
1430                                 case "System.Object":\r
1431                                         output = "Object";\r
1432                                         break;\r
1433 #if NET_2_0\r
1434                                 case "System.SByte":\r
1435                                         output = "SByte";\r
1436                                         break;\r
1437                                 case "System.UInt16":\r
1438                                         output = "UShort";\r
1439                                         break;\r
1440                                 case "System.UInt32":\r
1441                                         output = "UInteger";\r
1442                                         break;\r
1443                                 case "System.UInt64":\r
1444                                         output = "ULong";\r
1445                                         break;\r
1446 #endif\r
1447                                 default:\r
1448                                         output = type.BaseType.Replace('+', '.');\r
1449                                         break;\r
1450                                 }\r
1451                         }\r
1452 \r
1453                         int rank = type.ArrayRank;\r
1454                         if (rank > 0) {\r
1455                                 output += "(";\r
1456                                 for (--rank; rank > 0; --rank)\r
1457                                         output += ",";\r
1458                                 output += ")";\r
1459                         }\r
1460 \r
1461                         return output;\r
1462                 }\r
1463 \r
1464                 protected override bool IsValidIdentifier (string identifier)\r
1465                 {\r
1466                         for (int x = 0; x < Keywords.Length; x++)\r
1467                                 if (identifier.ToLower().Equals (Keywords[x].ToLower()))\r
1468                                         return false;\r
1469                         return true;\r
1470                 }\r
1471 \r
1472                 protected override bool Supports (GeneratorSupport supports)\r
1473                 {\r
1474                         return true;\r
1475                 }\r
1476 \r
1477                 private bool IsOverloaded (CodeMemberProperty property, CodeTypeDeclaration type)\r
1478                 {\r
1479                         if ((property.Attributes & MemberAttributes.Overloaded) == MemberAttributes.Overloaded) {\r
1480                                 return true;\r
1481                         }\r
1482 \r
1483                         foreach (CodeTypeMember member in type.Members) {\r
1484                                 CodeMemberProperty p = member as CodeMemberProperty;\r
1485                                 if (p == null) {\r
1486                                         // member is not a property\r
1487                                         continue;\r
1488                                 }\r
1489 \r
1490                                 if (p != property && p.Name == property.Name && p.PrivateImplementationType == null) {\r
1491                                         return true;\r
1492                                 }\r
1493                         }\r
1494                         return false;\r
1495                 }\r
1496 \r
1497                 private bool IsOverloaded (CodeMemberMethod method, CodeTypeDeclaration type)\r
1498                 {\r
1499                         if ((method.Attributes & MemberAttributes.Overloaded) == MemberAttributes.Overloaded) {\r
1500                                 return true;\r
1501                         }\r
1502 \r
1503                         foreach (CodeTypeMember member in type.Members) {\r
1504                                 CodeMemberMethod m = member as CodeMemberMethod;\r
1505                                 if (m == null) {\r
1506                                         // member is not a method\r
1507                                         continue;\r
1508                                 }\r
1509 \r
1510                                 if (!(m is CodeTypeConstructor) && !(m is CodeConstructor) && m != method && m.Name == method.Name && m.PrivateImplementationType == null) {\r
1511                                         return true;\r
1512                                 }\r
1513                         }\r
1514                         return false;\r
1515                 }\r
1516 \r
1517                 private string GetEventName (CodeMemberEvent evt)\r
1518                 {\r
1519 #if NET_2_0\r
1520                         if (evt.PrivateImplementationType == null) {\r
1521                                 return evt.Name;\r
1522                         }\r
1523 \r
1524                         string baseType = evt.PrivateImplementationType.BaseType.Replace ('.', '_');\r
1525                         return baseType + "_" + evt.Name;\r
1526 #else\r
1527                         return evt.Name;\r
1528 #endif\r
1529                 }\r
1530 \r
1531                 private string GetMethodName (CodeMemberMethod method)\r
1532                 {\r
1533                         if (method.PrivateImplementationType == null) {\r
1534                                 return method.Name;\r
1535                         }\r
1536 \r
1537                         string baseType = method.PrivateImplementationType.BaseType.Replace ('.', '_');\r
1538                         return baseType + "_" + method.Name;\r
1539                 }\r
1540 \r
1541                 private string GetPropertyName (CodeMemberProperty property)\r
1542                 {\r
1543                         if (property.PrivateImplementationType == null) {\r
1544                                 return property.Name;\r
1545                         }\r
1546 \r
1547                         string baseType = property.PrivateImplementationType.BaseType.Replace ('.', '_');\r
1548                         return baseType + "_" + property.Name;\r
1549                 }\r
1550 \r
1551                 private enum LineHandling\r
1552                 {\r
1553                         InLine,\r
1554                         ContinueLine,\r
1555                         NewLine\r
1556                 }\r
1557         }\r
1558 }\r