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