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                         method.Name = "Main";\r
 634                         GenerateMethod (method, declaration);\r
 635                 }\r
 636                 \r
 637                 [MonoTODO ("partially implemented")]\r
 638                 protected override void GenerateMethod (CodeMemberMethod method, CodeTypeDeclaration declaration)\r
 639                 {\r
 640                         if (IsCurrentDelegate || IsCurrentEnum) {\r
 641                                 return;\r
 642                         }\r
 643 \r
 644                         bool isSub = method.ReturnType.BaseType == typeof(void).FullName;\r
 645 \r
 646                         TextWriter output = Output;\r
 647 \r
 648                         OutputAttributes (method.CustomAttributes, null, \r
 649                                 LineHandling.ContinueLine);\r
 650 \r
 651                         MemberAttributes attributes = method.Attributes;\r
 652 \r
 653                         if (!IsCurrentInterface) {\r
 654                                 if (method.PrivateImplementationType == null) {\r
 655                                         OutputMemberAccessModifier (attributes);\r
 656                                         if (IsOverloaded (method, declaration)) {\r
 657                                                 output.Write ("Overloads ");\r
 658                                         }\r
 659                                 }\r
 660                                 OutputVTableModifier (attributes);\r
 661                                 OutputMemberScopeModifier (attributes);\r
 662                         } else {\r
 663                                 OutputVTableModifier (attributes);\r
 664                         }\r
 665 \r
 666                         if (isSub)\r
 667                                 output.Write ("Sub ");\r
 668                         else\r
 669                                 output.Write ("Function ");\r
 670 \r
 671                         output.Write (GetMethodName(method));\r
 672                         output.Write ('(');\r
 673                         OutputParameters (method.Parameters);\r
 674                         output.Write (')');\r
 675 \r
 676                         if (!isSub) {\r
 677                                 output.Write (" As ");\r
 678                                 OutputAttributes (method.ReturnTypeCustomAttributes, null,\r
 679                                         LineHandling.InLine);\r
 680                                 OutputType (method.ReturnType);\r
 681                         }\r
 682 \r
 683                         if (method.ImplementationTypes.Count > 0) {\r
 684                                 OutputImplementationTypes (method.ImplementationTypes, method.Name);\r
 685                         } else if (method.PrivateImplementationType != null) {\r
 686                                 output.Write (" Implements ");\r
 687                                 OutputType (method.PrivateImplementationType);\r
 688                                 output.Write ('.');\r
 689                                 output.Write (method.Name);\r
 690                         }\r
 691 \r
 692                         output.WriteLine ();\r
 693                         if (!IsCurrentInterface) {\r
 694                                 if ((attributes & MemberAttributes.ScopeMask) != MemberAttributes.Abstract) {\r
 695                                         ++Indent;\r
 696                                         GenerateStatements (method.Statements);\r
 697                                         --Indent;\r
 698                                         if (isSub)\r
 699                                                 output.WriteLine ("End Sub");\r
 700                                         else\r
 701                                                 output.WriteLine ("End Function");\r
 702                                 }\r
 703                         }\r
 704                 }\r
 705 \r
 706                 protected override void GenerateProperty (CodeMemberProperty property, CodeTypeDeclaration declaration)\r
 707                 {\r
 708                         if (IsCurrentDelegate || IsCurrentEnum) {\r
 709                                 return;\r
 710                         }\r
 711 \r
 712                         TextWriter output = Output;\r
 713 \r
 714                         OutputAttributes (property.CustomAttributes, null, \r
 715                                 LineHandling.ContinueLine);\r
 716 \r
 717                         MemberAttributes attributes = property.Attributes;\r
 718 \r
 719                         if (!IsCurrentInterface) {\r
 720                                 if (property.PrivateImplementationType == null) {\r
 721                                         OutputMemberAccessModifier (attributes);\r
 722                                         if (IsOverloaded (property, declaration)) {\r
 723                                                 output.Write ("Overloads ");\r
 724                                         }\r
 725                                 }\r
 726                                 OutputVTableModifier (attributes);\r
 727                                 OutputMemberScopeModifier (attributes);\r
 728                         } else {\r
 729                                 OutputVTableModifier (attributes);\r
 730                         }\r
 731 \r
 732                         // mark property as default property if we're dealing with an indexer\r
 733                         if (string.Compare (GetPropertyName(property), "Item", true, CultureInfo.InvariantCulture) == 0 && property.Parameters.Count > 0) {\r
 734                                 output.Write ("Default ");\r
 735                         }\r
 736 \r
 737                         if (property.HasGet && (!property.HasSet))\r
 738                                 output.Write ("ReadOnly " );\r
 739 \r
 740                         if (property.HasSet && (!property.HasGet))\r
 741                                 output.Write ("WriteOnly " );\r
 742 \r
 743                         output.Write ("Property ");\r
 744                         Output.Write (GetPropertyName (property));\r
 745 #if NET_2_0\r
 746                         // in .NET 2.0, always output parantheses (whether or not there \r
 747                         // are any parameters to output\r
 748                         Output.Write ('(');\r
 749                         OutputParameters (property.Parameters);\r
 750                         Output.Write (')');\r
 751 #else\r
 752                         if (property.Parameters.Count > 0) {\r
 753                                 Output.Write ('(');\r
 754                                 OutputParameters (property.Parameters);\r
 755                                 Output.Write (')');\r
 756                         }\r
 757 #endif\r
 758                         Output.Write (" As ");\r
 759                         Output.Write (GetTypeOutput(property.Type));\r
 760 \r
 761                         if (property.ImplementationTypes.Count > 0) {\r
 762                                 OutputImplementationTypes (property.ImplementationTypes, property.Name);\r
 763                         } else if (property.PrivateImplementationType != null) {\r
 764                                 output.Write (" Implements ");\r
 765                                 OutputType (property.PrivateImplementationType);\r
 766                                 output.Write ('.');\r
 767                                 output.Write (property.Name);\r
 768                         }\r
 769 \r
 770                         output.WriteLine ();\r
 771 \r
 772                         if (!IsCurrentInterface) {\r
 773                                 ++Indent;\r
 774                                 if (property.HasGet) {\r
 775                                         output.WriteLine ("Get");\r
 776                                         ++Indent;\r
 777                                         GenerateStatements (property.GetStatements);\r
 778                                         --Indent;\r
 779                                         output.WriteLine ("End Get");\r
 780                                 }\r
 781 \r
 782                                 if (property.HasSet) {\r
 783                                         output.WriteLine ("Set");\r
 784                                         ++Indent;\r
 785                                         GenerateStatements (property.SetStatements);\r
 786                                         --Indent;\r
 787                                         output.WriteLine ("End Set");\r
 788                                 }\r
 789 \r
 790                                 --Indent;\r
 791                                 output.WriteLine ("End Property");\r
 792                         }\r
 793                 }\r
 794 \r
 795                 protected override void GenerateConstructor (CodeConstructor constructor, CodeTypeDeclaration declaration)\r
 796                 {\r
 797                         if (IsCurrentDelegate || IsCurrentEnum || IsCurrentInterface) {\r
 798                                 return;\r
 799                         }\r
 800 \r
 801                         OutputAttributes (constructor.CustomAttributes, null,\r
 802                                 LineHandling.ContinueLine);\r
 803                         OutputMemberAccessModifier (constructor.Attributes);\r
 804                         Output.Write ("Sub New(");\r
 805                         OutputParameters (constructor.Parameters);\r
 806                         Output.WriteLine (")");\r
 807                         Indent++;\r
 808                         // check if ctor passes args on to other ctor in class\r
 809                         CodeExpressionCollection ctorArgs = constructor.ChainedConstructorArgs;\r
 810                         if (ctorArgs.Count > 0) {\r
 811                                 Output.Write ("Me.New(");\r
 812                                 OutputExpressionList (ctorArgs);\r
 813                                 Output.WriteLine (")");\r
 814                         } else {\r
 815                                 // check if ctor passes args on to ctor in base class\r
 816                                 ctorArgs = constructor.BaseConstructorArgs;\r
 817                                 if (ctorArgs.Count > 0) {\r
 818                                         Output.Write ("MyBase.New(");\r
 819                                         OutputExpressionList (ctorArgs);\r
 820                                         Output.WriteLine (")");\r
 821 #if NET_2_0\r
 822                                 } else if (IsCurrentClass) {\r
 823 #else\r
 824                                 } else {\r
 825 #endif\r
 826                                         // call default base ctor\r
 827                                         Output.WriteLine ("MyBase.New");\r
 828                                 }\r
 829                         }\r
 830                         GenerateStatements (constructor.Statements);\r
 831                         Indent--;\r
 832                         Output.WriteLine ("End Sub");\r
 833                 }\r
 834                 \r
 835                 protected override void GenerateTypeConstructor (CodeTypeConstructor constructor)\r
 836                 {\r
 837                         if (IsCurrentDelegate || IsCurrentEnum || IsCurrentInterface) {\r
 838                                 return;\r
 839                         }\r
 840 \r
 841 #if NET_2_0\r
 842                         OutputAttributes (constructor.CustomAttributes, null,\r
 843                                 LineHandling.ContinueLine);\r
 844 #endif\r
 845 \r
 846                         Output.WriteLine ("Shared Sub New()");\r
 847                         Indent++;\r
 848                         GenerateStatements (constructor.Statements);\r
 849                         Indent--;\r
 850                         Output.WriteLine ("End Sub");\r
 851                 }\r
 852 \r
 853                 [MonoTODO ("not implemented")]\r
 854                 protected override void GenerateTypeStart (CodeTypeDeclaration declaration)\r
 855                 {\r
 856                         TextWriter output = Output;\r
 857 \r
 858                         OutputAttributes (declaration.CustomAttributes, null, \r
 859                                 LineHandling.ContinueLine);\r
 860 \r
 861                         TypeAttributes attributes = declaration.TypeAttributes;\r
 862 \r
 863                         if (IsCurrentDelegate) {\r
 864                                 CodeTypeDelegate delegateDecl = (CodeTypeDelegate) declaration;\r
 865 \r
 866                                 if ((attributes & TypeAttributes.VisibilityMask) == TypeAttributes.Public) {\r
 867                                         output.Write ("Public ");\r
 868                                 }\r
 869 \r
 870                                 bool isSub = delegateDecl.ReturnType.BaseType == typeof (void).FullName;\r
 871                                 if (isSub) {\r
 872                                         output.Write ("Delegate Sub ");\r
 873                                 } else {\r
 874                                         output.Write ("Delegate Function ");\r
 875                                 }\r
 876 \r
 877                                 output.Write (delegateDecl.Name);\r
 878                                 output.Write ("(");\r
 879                                 Output.Write (")");\r
 880                                 if (!isSub) {\r
 881                                         Output.Write (" As ");\r
 882                                         OutputType (delegateDecl.ReturnType);\r
 883                                 }\r
 884                                 Output.WriteLine ("");\r
 885                         } else {\r
 886                                 OutputTypeAttributes (declaration);\r
 887 \r
 888                                 output.Write (declaration.Name);\r
 889 \r
 890                                 if (IsCurrentEnum) {\r
 891                                         if (declaration.BaseTypes.Count > 0) {\r
 892                                                 output.Write (" As ");\r
 893                                                 OutputType (declaration.BaseTypes[0]);\r
 894                                         }\r
 895                                         output.WriteLine ();\r
 896                                         ++Indent;\r
 897                                 } else {\r
 898                                         ++Indent;\r
 899 \r
 900                                         bool firstInherits = true;\r
 901                                         bool firstImplements = true;\r
 902 \r
 903                                         for (int i = 0; i < declaration.BaseTypes.Count; i++) {\r
 904                                                 // a struct can only implement interfaces\r
 905                                                 // an interface can only inherit from other interface\r
 906 \r
 907                                                 CodeTypeReference typeRef = declaration.BaseTypes[i];\r
 908                                                 \r
 909                                                 if (firstInherits && !declaration.IsStruct && !typeRef.IsInterface) {\r
 910                                                         output.WriteLine ();\r
 911                                                         output.Write ("Inherits ");\r
 912                                                         firstInherits = false;\r
 913                                                 } else if (!declaration.IsInterface && firstImplements) {\r
 914                                                         output.WriteLine ();\r
 915                                                         output.Write ("Implements ");\r
 916                                                         firstImplements = false;\r
 917                                                 } else {\r
 918                                                         output.Write (", ");\r
 919                                                 }\r
 920                                                 OutputType (typeRef);\r
 921                                         }\r
 922                                         output.WriteLine ();\r
 923                                 }\r
 924                         }\r
 925                 }\r
 926 \r
 927                 protected override void GenerateTypeEnd (CodeTypeDeclaration declaration)\r
 928                 {\r
 929                         if (IsCurrentDelegate) {\r
 930                                 return;\r
 931                         }\r
 932                         string output = string.Empty;\r
 933 \r
 934                         --Indent;\r
 935                         if (declaration.IsStruct)\r
 936                                 output = "End Structure";\r
 937                         if (declaration.IsInterface)\r
 938                                 output = "End Interface";\r
 939                         if (declaration.IsEnum)\r
 940                                 output = "End Enum";\r
 941                         if (declaration.IsClass)\r
 942                                 output = "End Class";\r
 943 \r
 944                         Output.WriteLine (output);\r
 945                 }\r
 946 \r
 947                 protected override void GenerateNamespace(CodeNamespace ns)\r
 948                 {\r
 949                         GenerateCommentStatements (ns.Comments);\r
 950                         \r
 951                         // add regular imports\r
 952                         GenerateNamespaceImports (ns);\r
 953 \r
 954                         Output.WriteLine (); \r
 955                         GenerateNamespaceStart (ns); \r
 956                         GenerateTypes (ns);\r
 957                         GenerateNamespaceEnd (ns);\r
 958                 }\r
 959 \r
 960 \r
 961                 protected override void GenerateNamespaceStart (CodeNamespace ns)\r
 962                 {\r
 963                         TextWriter output = Output;\r
 964                         \r
 965                         string name = ns.Name;\r
 966                         if (name != null && name != string.Empty) {\r
 967                                 output.Write ("Namespace ");\r
 968                                 output.WriteLine (name);\r
 969                                 ++Indent;\r
 970                         }\r
 971                 }\r
 972 \r
 973                 protected override void GenerateNamespaceEnd (CodeNamespace ns)\r
 974                 {\r
 975                         string name = ns.Name;\r
 976                         if (name != null && name != string.Empty) {\r
 977                                 --Indent;\r
 978                                 Output.WriteLine ("End Namespace");\r
 979                         }\r
 980                 }\r
 981 \r
 982                 protected override void GenerateNamespaceImport (CodeNamespaceImport import)\r
 983                 {\r
 984                         TextWriter output = Output;\r
 985 \r
 986                         output.Write ("Imports ");\r
 987                         output.Write (import.Namespace);\r
 988                         output.WriteLine ();\r
 989                 }\r
 990                 \r
 991                 protected override void GenerateAttributeDeclarationsStart (CodeAttributeDeclarationCollection attributes)\r
 992                 {\r
 993                         Output.Write ('<');\r
 994                 }\r
 995                 \r
 996                 protected override void GenerateAttributeDeclarationsEnd (CodeAttributeDeclarationCollection attributes)\r
 997                 {\r
 998                         Output.Write (">");\r
 999                 }\r
1000 \r
1001                 private void OutputAttributes (CodeAttributeDeclarationCollection attributes, string prefix, LineHandling lineHandling) {\r
1002                         if (attributes.Count == 0) {\r
1003                                 return;\r
1004                         }\r
1005 \r
1006                         GenerateAttributeDeclarationsStart (attributes);\r
1007 \r
1008                         IEnumerator enumerator = attributes.GetEnumerator ();\r
1009                         if (enumerator.MoveNext ()) {\r
1010                                 CodeAttributeDeclaration att = (CodeAttributeDeclaration) enumerator.Current;\r
1011                                 if (prefix != null) {\r
1012                                         Output.Write (prefix);\r
1013                                 }\r
1014                                 OutputAttributeDeclaration (att);\r
1015 \r
1016                                 while (enumerator.MoveNext ()) {\r
1017                                         Output.Write (", ");\r
1018                                         if (lineHandling != LineHandling.InLine) {\r
1019                                                 ContinueOnNewLine ("");\r
1020                                                 Output.Write (" ");\r
1021                                         }\r
1022                                         att = (CodeAttributeDeclaration) enumerator.Current;\r
1023                                         if (prefix != null) {\r
1024                                                 Output.Write (prefix);\r
1025                                         }\r
1026                                         OutputAttributeDeclaration (att);\r
1027                                 }\r
1028                         }\r
1029                         GenerateAttributeDeclarationsEnd (attributes);\r
1030                         Output.Write (" ");\r
1031 \r
1032                         switch (lineHandling) {\r
1033                                 case LineHandling.ContinueLine:\r
1034                                         ContinueOnNewLine ("");\r
1035                                         break;\r
1036                                 case LineHandling.NewLine:\r
1037                                         Output.WriteLine ();\r
1038                                         break;\r
1039                         }\r
1040                 }\r
1041 \r
1042                 protected override void OutputAttributeArgument (CodeAttributeArgument argument)\r
1043                 {\r
1044                         string name = argument.Name;\r
1045                         if (name != null) {\r
1046                                 Output.Write (name);\r
1047                                 Output.Write (":=");\r
1048                         }\r
1049                         GenerateExpression (argument.Value);\r
1050                 }\r
1051 \r
1052                 private void OutputAttributeDeclaration (CodeAttributeDeclaration attribute)\r
1053                 {\r
1054                         Output.Write (attribute.Name.Replace ('+', '.'));\r
1055                         Output.Write ('(');\r
1056                         IEnumerator enumerator = attribute.Arguments.GetEnumerator ();\r
1057                         if (enumerator.MoveNext ()) {\r
1058                                 CodeAttributeArgument argument = (CodeAttributeArgument) enumerator.Current;\r
1059                                 OutputAttributeArgument (argument);\r
1060 \r
1061                                 while (enumerator.MoveNext ()) {\r
1062                                         Output.Write (", ");\r
1063                                         argument = (CodeAttributeArgument) enumerator.Current;\r
1064                                         OutputAttributeArgument (argument);\r
1065                                 }\r
1066                         }\r
1067                         Output.Write (')');\r
1068                 }\r
1069 \r
1070                 protected override void OutputDirection (FieldDirection direction)\r
1071                 {\r
1072                         switch (direction) {\r
1073                         case FieldDirection.In:\r
1074                                 Output.Write ("ByVal ");\r
1075                                 break;\r
1076                         case FieldDirection.Out:\r
1077                         case FieldDirection.Ref:\r
1078                                 Output.Write ("ByRef ");\r
1079                                 break;\r
1080                         }\r
1081                 }\r
1082 \r
1083                 protected override void OutputFieldScopeModifier (MemberAttributes attributes)\r
1084                 {\r
1085                         switch (attributes & MemberAttributes.ScopeMask) {\r
1086                                 case MemberAttributes.Static:\r
1087                                         Output.Write ("Shared ");\r
1088                                         break;\r
1089                                 case MemberAttributes.Const:\r
1090                                         Output.Write ("Const ");\r
1091                                         break;\r
1092                         }\r
1093                 }\r
1094 \r
1095                 private void OutputImplementationTypes (CodeTypeReferenceCollection implementationTypes, string member)\r
1096                 {\r
1097                         IEnumerator enumerator = implementationTypes.GetEnumerator ();\r
1098                         if (enumerator.MoveNext ()) {\r
1099                                 Output.Write (" Implements ");\r
1100 \r
1101                                 CodeTypeReference typeReference = (CodeTypeReference) enumerator.Current;\r
1102                                 OutputType (typeReference);\r
1103                                 Output.Write ('.');\r
1104                                 OutputIdentifier (member);\r
1105 \r
1106                                 while (enumerator.MoveNext ()) {\r
1107                                         Output.Write (" , ");\r
1108                                         typeReference = (CodeTypeReference) enumerator.Current;\r
1109                                         OutputType (typeReference);\r
1110                                         Output.Write ('.');\r
1111                                         OutputIdentifier (member);\r
1112                                 }\r
1113                         }\r
1114                 }\r
1115 \r
1116                 protected override void OutputMemberAccessModifier (MemberAttributes attributes)\r
1117                 {\r
1118                         switch (attributes & MemberAttributes.AccessMask) {\r
1119                                 case MemberAttributes.Assembly:\r
1120                                 case MemberAttributes.FamilyAndAssembly:\r
1121                                         Output.Write ("Friend "); \r
1122                                         break;\r
1123                                 case MemberAttributes.Family:\r
1124                                         Output.Write ("Protected ");\r
1125                                         break;\r
1126                                 case MemberAttributes.FamilyOrAssembly:\r
1127                                         Output.Write ("Protected Friend ");\r
1128                                         break;\r
1129                                 case MemberAttributes.Private:\r
1130                                         Output.Write ("Private ");\r
1131                                         break;\r
1132                                 case MemberAttributes.Public:\r
1133                                         Output.Write ("Public ");\r
1134                                         break;\r
1135                         }\r
1136                 }\r
1137 \r
1138                 private void OutputVTableModifier (MemberAttributes attributes)\r
1139                 {\r
1140                         if ((attributes & MemberAttributes.VTableMask) == MemberAttributes.New) {\r
1141                                 Output.Write ("Shadows ");\r
1142                         }\r
1143                 }\r
1144 \r
1145                 protected override void OutputMemberScopeModifier (MemberAttributes attributes)\r
1146                 {\r
1147                         switch (attributes & MemberAttributes.ScopeMask) {\r
1148                                 case MemberAttributes.Abstract:\r
1149                                         Output.Write ("MustOverride ");\r
1150                                         break;\r
1151                                 case MemberAttributes.Final:\r
1152                                         // do nothing\r
1153                                         break;\r
1154                                 case MemberAttributes.Static:\r
1155                                         Output.Write ("Shared ");\r
1156                                         break;\r
1157                                 case MemberAttributes.Override:\r
1158                                         Output.Write ("Overrides ");\r
1159                                         break;\r
1160                                 case MemberAttributes.Overloaded:\r
1161                                         // based on http://gendotnet.com/Code%20Gen%20Articles/codedom.htm\r
1162                                         Output.Write ("Overloads ");\r
1163 \r
1164                                         MemberAttributes access_ovl = attributes & MemberAttributes.AccessMask;\r
1165                                         if (access_ovl == MemberAttributes.Public || access_ovl == MemberAttributes.Family) {\r
1166                                                 Output.Write ("Overridable ");\r
1167                                         }\r
1168                                         break;\r
1169                                 default:\r
1170                                         //\r
1171                                         // FUNNY! if the scope value is\r
1172                                         // rubbish (0 or >Const), and access\r
1173                                         // is public, protected make it\r
1174                                         // "virtual".\r
1175                                         //\r
1176                                         // i'm not sure whether this is 100%\r
1177                                         // correct, but it seems to be MS\r
1178                                         // behavior.\r
1179                                         //\r
1180                                         // On MS.NET 2.0, internal properties\r
1181                                         // are also marked "virtual".\r
1182                                         //\r
1183                                         MemberAttributes access = attributes & MemberAttributes.AccessMask;\r
1184                                         if (access == MemberAttributes.Public || \r
1185 #if NET_2_0\r
1186                                                 access == MemberAttributes.Family || access == MemberAttributes.Assembly)\r
1187 #else\r
1188                                                 access == MemberAttributes.Family)\r
1189 #endif\r
1190                                                 Output.Write ("Overridable ");\r
1191                                         break;\r
1192                         }\r
1193                 }\r
1194 \r
1195                 protected override void OutputOperator (CodeBinaryOperatorType op)\r
1196                 {\r
1197                         switch (op) {\r
1198                         case CodeBinaryOperatorType.Add:\r
1199                                 Output.Write ("+");\r
1200                                 break;\r
1201                         case CodeBinaryOperatorType.Subtract:\r
1202                                 Output.Write ("-");\r
1203                                 break;\r
1204                         case CodeBinaryOperatorType.Multiply:\r
1205                                 Output.Write ("*");\r
1206                                 break;\r
1207                         case CodeBinaryOperatorType.Divide:\r
1208                                 Output.Write ("/");\r
1209                                 break;\r
1210                         case CodeBinaryOperatorType.Modulus:\r
1211                                 Output.Write ("Mod");\r
1212                                 break;\r
1213                         case CodeBinaryOperatorType.Assign:\r
1214                                 Output.Write ("=");\r
1215                                 break;\r
1216                         case CodeBinaryOperatorType.IdentityInequality:\r
1217                                 Output.Write ("<>");\r
1218                                 break;\r
1219                         case CodeBinaryOperatorType.IdentityEquality:\r
1220                                 Output.Write ("Is");\r
1221                                 break;\r
1222                         case CodeBinaryOperatorType.ValueEquality:\r
1223                                 Output.Write ("=");\r
1224                                 break;\r
1225                         case CodeBinaryOperatorType.BitwiseOr:\r
1226                                 Output.Write ("Or");\r
1227                                 break;\r
1228                         case CodeBinaryOperatorType.BitwiseAnd:\r
1229                                 Output.Write ("And");\r
1230                                 break;\r
1231                         case CodeBinaryOperatorType.BooleanOr:\r
1232                                 Output.Write ("OrElse");\r
1233                                 break;\r
1234                         case CodeBinaryOperatorType.BooleanAnd:\r
1235                                 Output.Write ("AndAlso");\r
1236                                 break;\r
1237                         case CodeBinaryOperatorType.LessThan:\r
1238                                 Output.Write ("<");\r
1239                                 break;\r
1240                         case CodeBinaryOperatorType.LessThanOrEqual:\r
1241                                 Output.Write ("<=");\r
1242                                 break;\r
1243                         case CodeBinaryOperatorType.GreaterThan:\r
1244                                 Output.Write (">");\r
1245                                 break;\r
1246                         case CodeBinaryOperatorType.GreaterThanOrEqual:\r
1247                                 Output.Write (">=");\r
1248                                 break;\r
1249                         }\r
1250                 }\r
1251 \r
1252                 private void OutputTypeAttributes (CodeTypeDeclaration declaration)\r
1253                 {\r
1254                         TextWriter output = Output;\r
1255                         TypeAttributes attributes = declaration.TypeAttributes;\r
1256 \r
1257                         switch (attributes & TypeAttributes.VisibilityMask) {\r
1258                                 case TypeAttributes.Public:\r
1259                                 case TypeAttributes.NestedPublic:\r
1260                                         output.Write ("Public ");\r
1261                                         break;\r
1262                                 case TypeAttributes.NestedPrivate:\r
1263                                         output.Write ("Private ");\r
1264                                         break;\r
1265 #if NET_2_0\r
1266                                 case TypeAttributes.NotPublic:\r
1267                                 case TypeAttributes.NestedFamANDAssem:\r
1268                                 case TypeAttributes.NestedAssembly:\r
1269                                         output.Write ("Friend ");\r
1270                                         break; \r
1271                                 case TypeAttributes.NestedFamily:\r
1272                                         output.Write ("Protected ");\r
1273                                         break;\r
1274                                 case TypeAttributes.NestedFamORAssem:\r
1275                                         output.Write ("Protected Friend ");\r
1276                                         break;\r
1277 #endif\r
1278                         }\r
1279 \r
1280                         if (declaration.IsStruct) {\r
1281                                 output.Write ("Structure ");\r
1282                         } else if (declaration.IsEnum) {\r
1283                                 output.Write ("Enum ");\r
1284                         } else {\r
1285                                 if ((attributes & TypeAttributes.Interface) != 0) {\r
1286                                         output.Write ("Interface ");\r
1287                                 } else {\r
1288                                         if ((attributes & TypeAttributes.Sealed) != 0)\r
1289                                                 output.Write ("NotInheritable ");\r
1290 \r
1291                                         if ((attributes & TypeAttributes.Abstract) != 0)\r
1292                                                 output.Write ("MustInherit ");\r
1293 \r
1294                                         output.Write ("Class ");\r
1295                                 }\r
1296                         }\r
1297                 }\r
1298 \r
1299                 protected override void OutputTypeNamePair (CodeTypeReference typeRef, String name)\r
1300                 {\r
1301                         Output.Write (name + " As " + GetTypeOutput (typeRef));\r
1302                 }\r
1303 \r
1304                 protected override void OutputType (CodeTypeReference type)\r
1305                 {\r
1306                         Output.Write (GetTypeOutput (type));\r
1307                 }\r
1308 \r
1309                 protected override string QuoteSnippetString (string value)\r
1310                 {\r
1311                         StringBuilder mySBuilder = new StringBuilder(value.Length);\r
1312                         mySBuilder.Append ("\"");\r
1313                         bool inQuotes = true;\r
1314                         for (int MyCounter = 0; MyCounter < value.Length; MyCounter++)\r
1315                         {\r
1316                                 if (value[MyCounter] == 34) //quotation mark\r
1317                                 {\r
1318                                         if (!inQuotes)\r
1319                                         {\r
1320                                                 mySBuilder.Append ("&\"");\r
1321                                                 inQuotes = true;\r
1322                                         }\r
1323                                         mySBuilder.Append (value[MyCounter]);\r
1324                                         mySBuilder.Append (value[MyCounter]);\r
1325                                 }\r
1326                                 else if (value[MyCounter] >= 32) //standard ansi/unicode characters\r
1327                                 {\r
1328                                         if (!inQuotes)\r
1329                                         {\r
1330                                                 mySBuilder.Append ("&\"");\r
1331                                                 inQuotes = true;\r
1332                                         }\r
1333                                         mySBuilder.Append (value[MyCounter]);\r
1334                                 }\r
1335                                 else //special chars, e.g. line break\r
1336                                 {\r
1337                                         if (inQuotes)\r
1338                                         { \r
1339                                                 mySBuilder.Append ("\"");\r
1340                                                 inQuotes = false;\r
1341                                         }\r
1342                                         mySBuilder.Append ("&Microsoft.VisualBasic.ChrW(");\r
1343                                         mySBuilder.Append ((int)value[MyCounter]); \r
1344                                         mySBuilder.Append (")");\r
1345                                 }                       \r
1346                         }\r
1347                         if (inQuotes)\r
1348                                 mySBuilder.Append ("\"");\r
1349                         return mySBuilder.ToString();\r
1350                 }\r
1351 \r
1352                 private void GenerateMemberReferenceExpression (CodeExpression targetObject, string memberName)\r
1353                 {\r
1354                         GenerateExpression (targetObject);\r
1355                         Output.Write ('.');\r
1356                         Output.Write (memberName);\r
1357                 }\r
1358                         \r
1359                 /* \r
1360                  * ICodeGenerator\r
1361                  */\r
1362 \r
1363                 protected override string CreateEscapedIdentifier (string value)\r
1364                 {\r
1365                         for (int x = 0; x < Keywords.Length; x++)\r
1366                                 if (value.ToLower().Equals (Keywords[x].ToLower()))\r
1367                                         return "[" + value + "]";\r
1368                         return value;\r
1369                 }\r
1370 \r
1371                 protected override string CreateValidIdentifier (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 GetTypeOutput (CodeTypeReference type)\r
1380                 {\r
1381                         string output;\r
1382                         CodeTypeReference arrayType;\r
1383 \r
1384                         arrayType = type.ArrayElementType;\r
1385                         if (arrayType != null)\r
1386                                 output = GetTypeOutput (arrayType);\r
1387                         else { \r
1388                                 switch (type.BaseType) {\r
1389                                 case "System.DateTime":\r
1390                                         output = "Date";\r
1391                                         break;\r
1392                                 case "System.Decimal":\r
1393                                         output = "Decimal";\r
1394                                         break;\r
1395                                 case "System.Double":\r
1396                                         output = "Double";\r
1397                                         break;\r
1398                                 case "System.Single":\r
1399                                         output = "Single";\r
1400                                         break;\r
1401                                 case "System.Byte":\r
1402                                         output = "Byte";\r
1403                                         break;\r
1404                                 case "System.Int32":\r
1405                                         output = "Integer";\r
1406                                         break;\r
1407                                 case "System.Int64":\r
1408                                         output = "Long";\r
1409                                         break;\r
1410                                 case "System.Int16":\r
1411                                         output = "Short";\r
1412                                         break;\r
1413                                 case "System.Boolean":\r
1414                                         output = "Boolean";\r
1415                                         break;\r
1416                                 case "System.Char":\r
1417                                         output = "Char";\r
1418                                         break;\r
1419                                 case "System.String":\r
1420                                         output = "String";\r
1421                                         break;\r
1422                                 case "System.Object":\r
1423                                         output = "Object";\r
1424                                         break;\r
1425 #if NET_2_0\r
1426                                 case "System.SByte":\r
1427                                         output = "SByte";\r
1428                                         break;\r
1429                                 case "System.UInt16":\r
1430                                         output = "UShort";\r
1431                                         break;\r
1432                                 case "System.UInt32":\r
1433                                         output = "UInteger";\r
1434                                         break;\r
1435                                 case "System.UInt64":\r
1436                                         output = "ULong";\r
1437                                         break;\r
1438 #endif\r
1439                                 default:\r
1440                                         output = type.BaseType;\r
1441                                         break;\r
1442                                 }\r
1443                         }\r
1444 \r
1445                         int rank = type.ArrayRank;\r
1446                         if (rank > 0) {\r
1447                                 output += "(";\r
1448                                 for (--rank; rank > 0; --rank)\r
1449                                         output += ",";\r
1450                                 output += ")";\r
1451                         }\r
1452 \r
1453                         return output;\r
1454                 }\r
1455 \r
1456                 protected override bool IsValidIdentifier (string identifier)\r
1457                 {\r
1458                         for (int x = 0; x < Keywords.Length; x++)\r
1459                                 if (identifier.ToLower().Equals (Keywords[x].ToLower()))\r
1460                                         return false;\r
1461                         return true;\r
1462                 }\r
1463 \r
1464                 protected override bool Supports (GeneratorSupport supports)\r
1465                 {\r
1466                         return true;\r
1467                 }\r
1468 \r
1469                 private bool IsOverloaded (CodeMemberProperty property, CodeTypeDeclaration type)\r
1470                 {\r
1471                         if ((property.Attributes & MemberAttributes.Overloaded) == MemberAttributes.Overloaded) {\r
1472                                 return true;\r
1473                         }\r
1474 \r
1475                         foreach (CodeTypeMember member in type.Members) {\r
1476                                 CodeMemberProperty p = member as CodeMemberProperty;\r
1477                                 if (p == null) {\r
1478                                         // member is not a property\r
1479                                         continue;\r
1480                                 }\r
1481 \r
1482                                 if (p != property && p.Name == property.Name && p.PrivateImplementationType == null) {\r
1483                                         return true;\r
1484                                 }\r
1485                         }\r
1486                         return false;\r
1487                 }\r
1488 \r
1489                 private bool IsOverloaded (CodeMemberMethod method, CodeTypeDeclaration type)\r
1490                 {\r
1491                         if ((method.Attributes & MemberAttributes.Overloaded) == MemberAttributes.Overloaded) {\r
1492                                 return true;\r
1493                         }\r
1494 \r
1495                         foreach (CodeTypeMember member in type.Members) {\r
1496                                 CodeMemberMethod m = member as CodeMemberMethod;\r
1497                                 if (m == null) {\r
1498                                         // member is not a method\r
1499                                         continue;\r
1500                                 }\r
1501 \r
1502                                 if (!(m is CodeTypeConstructor) && !(m is CodeConstructor) && m != method && m.Name == method.Name && m.PrivateImplementationType == null) {\r
1503                                         return true;\r
1504                                 }\r
1505                         }\r
1506                         return false;\r
1507                 }\r
1508 \r
1509                 private string GetEventName (CodeMemberEvent evt)\r
1510                 {\r
1511 #if NET_2_0\r
1512                         if (evt.PrivateImplementationType == null) {\r
1513                                 return evt.Name;\r
1514                         }\r
1515 \r
1516                         string baseType = evt.PrivateImplementationType.BaseType.Replace ('.', '_');\r
1517                         return baseType + "_" + evt.Name;\r
1518 #else\r
1519                         return evt.Name;\r
1520 #endif\r
1521                 }\r
1522 \r
1523                 private string GetMethodName (CodeMemberMethod method)\r
1524                 {\r
1525                         if (method.PrivateImplementationType == null) {\r
1526                                 return method.Name;\r
1527                         }\r
1528 \r
1529                         string baseType = method.PrivateImplementationType.BaseType.Replace ('.', '_');\r
1530                         return baseType + "_" + method.Name;\r
1531                 }\r
1532 \r
1533                 private string GetPropertyName (CodeMemberProperty property)\r
1534                 {\r
1535                         if (property.PrivateImplementationType == null) {\r
1536                                 return property.Name;\r
1537                         }\r
1538 \r
1539                         string baseType = property.PrivateImplementationType.BaseType.Replace ('.', '_');\r
1540                         return baseType + "_" + property.Name;\r
1541                 }\r
1542 \r
1543                 private enum LineHandling\r
1544                 {\r
1545                         InLine,\r
1546                         ContinueLine,\r
1547                         NewLine\r
1548                 }\r
1549         }\r
1550 }\r