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 \r
 421                         output.WriteLine ("Try");\r
 422                         ++Indent;\r
 423                         GenerateStatements (statement.TryStatements);\r
 424                         --Indent;\r
 425                         output.WriteLine ();\r
 426                         \r
 427                         foreach (CodeCatchClause clause in statement.CatchClauses) {\r
 428                                 output.Write ("Catch ");\r
 429                                 OutputTypeNamePair (clause.CatchExceptionType, clause.LocalName);\r
 430                                 output.WriteLine ();\r
 431                                 ++Indent;\r
 432                                 GenerateStatements (clause.Statements);\r
 433                                 --Indent;\r
 434                                 output.WriteLine ();\r
 435                         }\r
 436 \r
 437                         CodeStatementCollection finallies = statement.FinallyStatements;\r
 438                         if (finallies.Count > 0) {\r
 439 \r
 440                                 output.WriteLine ("Finally");\r
 441                                 ++Indent;\r
 442                                 GenerateStatements (finallies);\r
 443                                 --Indent;\r
 444                                 output.WriteLine ();\r
 445                         }\r
 446 \r
 447                         if (Options.ElseOnClosing) {\r
 448                                 if (statement.CatchClauses.Count == 0)\r
 449                                         output.WriteLine ("Catch");\r
 450                                 if (statement.FinallyStatements.Count == 0)\r
 451                                         output.WriteLine ("Finally");\r
 452                         }\r
 453 \r
 454                         output.WriteLine("End Try");\r
 455                 }\r
 456 \r
 457                 protected override void GenerateAssignStatement (CodeAssignStatement statement)\r
 458                 {                       \r
 459                         TextWriter output = Output;\r
 460                         GenerateExpression (statement.Left);\r
 461                         output.Write (" = ");\r
 462                         GenerateExpression (statement.Right);\r
 463                         output.WriteLine ();\r
 464                 }\r
 465 \r
 466                 protected override void GenerateAttachEventStatement (CodeAttachEventStatement statement)\r
 467                 {\r
 468                         TextWriter output = Output;\r
 469 \r
 470                         Output.Write ("AddHandler ");\r
 471                         GenerateEventReferenceExpression (statement.Event);\r
 472                         Output.Write ( ", ");\r
 473                         GenerateExpression (statement.Listener);\r
 474                         output.WriteLine ();\r
 475                 }\r
 476 \r
 477                 protected override void GenerateRemoveEventStatement (CodeRemoveEventStatement statement)\r
 478                 {\r
 479                         TextWriter output = Output;\r
 480 \r
 481                         Output.Write ("RemoveHandler ");\r
 482                         GenerateEventReferenceExpression (statement.Event);\r
 483                         Output.Write ( ", ");\r
 484                         GenerateExpression (statement.Listener);\r
 485                         output.WriteLine ();\r
 486                 }\r
 487 \r
 488                 protected override void GenerateGotoStatement (CodeGotoStatement statement)\r
 489                 {\r
 490                         TextWriter output = Output;\r
 491 \r
 492                         output.Write ("Goto ");\r
 493                         output.Write (statement.Label);\r
 494                         output.WriteLine ();\r
 495                 }\r
 496                 \r
 497                 protected override void GenerateLabeledStatement (CodeLabeledStatement statement)\r
 498                 {\r
 499                         TextWriter output = Output;\r
 500 \r
 501                         output.Write (statement.Label + ":");\r
 502                         GenerateStatement (statement.Statement);\r
 503                 }\r
 504 \r
 505                 protected override void GenerateTypeOfExpression (CodeTypeOfExpression e)\r
 506                 {\r
 507                         TextWriter output = Output;\r
 508 \r
 509                         output.Write ("GetType(");\r
 510                         OutputType (e.Type);\r
 511                         output.Write (")");\r
 512                 }\r
 513 \r
 514                 protected override void GenerateVariableDeclarationStatement( CodeVariableDeclarationStatement statement )\r
 515                 {\r
 516                         TextWriter output = Output;\r
 517 \r
 518                         output.Write ("Dim ");\r
 519                         OutputTypeNamePair (statement.Type, statement.Name);\r
 520 \r
 521                         CodeExpression initExpression = statement.InitExpression;\r
 522                         if (initExpression != null) \r
 523                         {\r
 524                                 output.Write (" = ");\r
 525                                 GenerateExpression (initExpression);\r
 526                         }\r
 527 \r
 528                         output.WriteLine();\r
 529                 }\r
 530 \r
 531                 protected override void GenerateLinePragmaStart (CodeLinePragma linePragma)\r
 532                 {\r
 533                         Output.WriteLine ();\r
 534                         Output.Write ("#ExternalSource(");\r
 535                         Output.Write (linePragma.FileName);\r
 536                         Output.Write (", ");\r
 537                         Output.Write (linePragma.LineNumber);\r
 538                         Output.WriteLine (")");\r
 539                 }\r
 540 \r
 541                 protected override void GenerateLinePragmaEnd (CodeLinePragma linePragma)\r
 542                 {\r
 543                         Output.WriteLine ("#End ExternalSource");\r
 544                 }\r
 545 \r
 546                 protected override void GenerateEvent (CodeMemberEvent eventRef, CodeTypeDeclaration declaration)\r
 547                 {\r
 548                         TextWriter output = Output;\r
 549 \r
 550                         if (eventRef.CustomAttributes.Count > 0)\r
 551                                 OutputAttributeDeclarations (eventRef.CustomAttributes);\r
 552 \r
 553                         MemberAttributes attributes = eventRef.Attributes;\r
 554 \r
 555                         OutputMemberAccessModifier (attributes);\r
 556                         OutputMemberScopeModifier (attributes);\r
 557 \r
 558                         output.Write ("Event ");\r
 559                         OutputTypeNamePair (eventRef.Type, eventRef.Name);\r
 560                         output.WriteLine ();\r
 561                 }\r
 562 \r
 563                 protected override void GenerateField (CodeMemberField field)\r
 564                 {\r
 565                         TextWriter output = Output;\r
 566 \r
 567                         if (field.CustomAttributes.Count > 0)\r
 568                                 OutputAttributeDeclarations (field.CustomAttributes);\r
 569 \r
 570                         MemberAttributes attributes = field.Attributes;\r
 571                         OutputMemberAccessModifier (attributes);\r
 572                         OutputFieldScopeModifier (attributes);\r
 573 \r
 574                         OutputTypeNamePair (field.Type, field.Name);\r
 575 \r
 576                         CodeExpression initExpression = field.InitExpression;\r
 577                         if (initExpression != null) {\r
 578                                 output.Write (" = ");\r
 579                                 GenerateExpression (initExpression);\r
 580                         }\r
 581 \r
 582                         output.WriteLine();\r
 583                 }\r
 584                 \r
 585                 protected override void GenerateSnippetMember (CodeSnippetTypeMember member)\r
 586                 {\r
 587                         Output.Write (member.Text);\r
 588                 }\r
 589                 \r
 590                 protected override void GenerateEntryPointMethod( CodeEntryPointMethod method, CodeTypeDeclaration declaration )\r
 591                 {\r
 592                         method.Name = "Main";\r
 593                         GenerateMethod (method, declaration);\r
 594                 }\r
 595                 \r
 596                 [MonoTODO ("partially implemented")]\r
 597                 protected override void GenerateMethod (CodeMemberMethod method, CodeTypeDeclaration declaration)\r
 598                 {\r
 599                         bool isSub = method.ReturnType == null || method.ReturnType.BaseType == "System.Void";\r
 600 \r
 601                         TextWriter output = Output;\r
 602 \r
 603                         if (method.CustomAttributes.Count > 0)\r
 604                                 OutputAttributeDeclarations (method.CustomAttributes);\r
 605 \r
 606                         MemberAttributes attributes = method.Attributes;\r
 607 \r
 608                         OutputMemberAccessModifier (attributes);\r
 609                         OutputMemberScopeModifier (attributes);\r
 610 \r
 611                         if (isSub)\r
 612                                 output.Write ("Sub ");\r
 613                         else\r
 614                                 output.Write ("Function ");\r
 615 \r
 616                         output.Write (method.Name);\r
 617                         output.Write ('(');\r
 618                         OutputParameters (method.Parameters);\r
 619                         output.Write (')');\r
 620 \r
 621                         if (!isSub) {\r
 622                                 output.Write (" As ");\r
 623                                 OutputType (method.ReturnType);\r
 624                         }\r
 625 \r
 626                         if (method.ImplementationTypes.Count > 0) {\r
 627                                 output.Write (" Implements ");\r
 628                                 foreach (CodeTypeReference type in method.ImplementationTypes)\r
 629                                 {\r
 630                                         OutputType (type);\r
 631                                         output.Write ('.');\r
 632                                         // TODO implementation incomplete\r
 633 \r
 634                                 }\r
 635                         }\r
 636 \r
 637                         // TODO private implementations\r
 638 \r
 639                         if ((attributes & MemberAttributes.ScopeMask) == MemberAttributes.Abstract)\r
 640                                 output.WriteLine ();\r
 641                         else {\r
 642                                 output.WriteLine ();\r
 643                                 ++Indent;\r
 644                                 GenerateStatements (method.Statements);\r
 645                                 --Indent;\r
 646                                 if (isSub)\r
 647                                         output.WriteLine ("End Sub");\r
 648                                 else\r
 649                                         output.WriteLine ("End Function");\r
 650                         }\r
 651                 }\r
 652 \r
 653                 protected override void GenerateProperty (CodeMemberProperty property, CodeTypeDeclaration declaration)\r
 654                 {\r
 655                         TextWriter output = Output;\r
 656 \r
 657                         if (property.CustomAttributes.Count > 0)\r
 658                                 OutputAttributeDeclarations (property.CustomAttributes);\r
 659 \r
 660                         MemberAttributes attributes = property.Attributes;\r
 661                         OutputMemberAccessModifier (attributes);\r
 662                         OutputMemberScopeModifier (attributes);\r
 663 \r
 664                         if (property.HasGet && (!property.HasSet))\r
 665                                 output.Write ("ReadOnly " );\r
 666 \r
 667                         if (property.HasSet && (!property.HasGet))\r
 668                                 output.Write ("WriteOnly " );\r
 669 \r
 670                         output.Write ("Property " );\r
 671                         \r
 672                         OutputTypeNamePair (property.Type, property.Name);\r
 673                         output.WriteLine ();\r
 674                         ++Indent;\r
 675 \r
 676                         if (property.HasGet) {\r
 677                                 output.WriteLine ("Get");\r
 678                                 ++Indent;\r
 679 \r
 680                                 GenerateStatements (property.GetStatements);\r
 681 \r
 682                                 --Indent;\r
 683                                 output.WriteLine ("End Get");\r
 684                         }\r
 685                         \r
 686                         if (property.HasSet) {\r
 687                                 output.Write ("Set (");\r
 688                                 OutputTypeNamePair (property.Type, "Value");
 689                                 output.WriteLine (")");
 690                                 ++Indent;\r
 691 \r
 692                                 GenerateStatements (property.SetStatements);\r
 693 \r
 694                                 --Indent;\r
 695                                 output.WriteLine ("End Set");\r
 696                         }\r
 697 \r
 698                         --Indent;\r
 699                         output.WriteLine ("End Property");\r
 700                 }\r
 701 \r
 702                 [MonoTODO ("not implemented")]\r
 703                 protected override void GenerateConstructor (CodeConstructor constructor, CodeTypeDeclaration declaration)\r
 704                 {\r
 705                         if (constructor.CustomAttributes.Count > 0)\r
 706                                 OutputAttributeDeclarations (constructor.CustomAttributes);\r
 707                         OutputMemberAccessModifier (constructor.Attributes);\r
 708                         Output.Write ("Sub New(");\r
 709                         OutputParameters (constructor.Parameters);\r
 710                         Output.WriteLine (")");\r
 711                         // Handle BaseConstructorArgs, ChainedConstructorArgs, ImplementationTypes\r
 712                         Indent++;\r
 713                         GenerateStatements (constructor.Statements);\r
 714                         Indent--;\r
 715                         Output.WriteLine ("End Sub");\r
 716                 }\r
 717                 \r
 718                 protected override void GenerateTypeConstructor (CodeTypeConstructor constructor)\r
 719                 {\r
 720                         Output.WriteLine ("Shared Sub New()");\r
 721                         Indent++;\r
 722                         GenerateStatements (constructor.Statements);\r
 723                         Indent--;\r
 724                         Output.WriteLine ("End Sub");\r
 725                 }\r
 726 \r
 727                 [MonoTODO ("not implemented")]\r
 728                 protected override void GenerateTypeStart (CodeTypeDeclaration declaration)\r
 729                 {\r
 730                         TextWriter output = Output;\r
 731 \r
 732                         if (declaration.CustomAttributes.Count > 0)\r
 733                                 OutputAttributeDeclarations (declaration.CustomAttributes);\r
 734                         TypeAttributes attributes = declaration.TypeAttributes;\r
 735                         OutputTypeAttributes (attributes,\r
 736                                 declaration.IsStruct,\r
 737                                 declaration.IsEnum);\r
 738 \r
 739                         output.WriteLine (declaration.Name);\r
 740 \r
 741                         ++Indent;\r
 742                         \r
 743                         IEnumerator enumerator = declaration.BaseTypes.GetEnumerator();\r
 744                         if (enumerator.MoveNext()) \r
 745                         {\r
 746                                 CodeTypeReference type = (CodeTypeReference)enumerator.Current;\r
 747                         \r
 748                                 if (type != null)\r
 749                                 {\r
 750                                         output.Write ("Inherits ");\r
 751                                         OutputType (type);\r
 752                                         output.WriteLine ();\r
 753                                 }\r
 754                                 \r
 755                                 while (enumerator.MoveNext()) \r
 756                                 {\r
 757                                         type = (CodeTypeReference)enumerator.Current;\r
 758                                 \r
 759                                         if (type != null)\r
 760                                         {\r
 761                                                 output.Write ("Implements ");\r
 762                                                 OutputType (type);\r
 763                                                 output.WriteLine ();\r
 764                                         }\r
 765                                 }\r
 766                         }                       \r
 767                 }\r
 768 \r
 769                 protected override void GenerateTypeEnd (CodeTypeDeclaration declaration)\r
 770                 {\r
 771                         string output = string.Empty;\r
 772 \r
 773                         --Indent;\r
 774                         if (declaration.IsStruct)\r
 775                                 output = "End Structure";\r
 776                         if (declaration.IsInterface)\r
 777                                 output = "End Interface";\r
 778                         if (declaration.IsEnum)\r
 779                                 output = "End Enum";\r
 780                         if (declaration.IsClass)\r
 781                                 output = "End Class";\r
 782 \r
 783                         Output.WriteLine (output);\r
 784                 }\r
 785 \r
 786                 protected override void GenerateNamespace(CodeNamespace ns)\r
 787                 {\r
 788                         GenerateCommentStatements (ns.Comments);\r
 789                         \r
 790                         bool Imports2MSVBFound;\r
 791                         Imports2MSVBFound = false;\r
 792                         if (null != ns.Imports) \r
 793                         {\r
 794                                 foreach (CodeNamespaceImport import in ns.Imports)\r
 795                                 {\r
 796                                         if (string.Compare (import.Namespace, "Microsoft.VisualBasic", true, System.Globalization.CultureInfo.InvariantCulture) == 0)\r
 797                                                 Imports2MSVBFound = true;\r
 798                                 }\r
 799                         }\r
 800                         // add standard import to Microsoft.VisualBasic if missing\r
 801                         if (Imports2MSVBFound == false)\r
 802                                 Output.WriteLine ("Imports Microsoft.VisualBasic");\r
 803                         // add regular imports\r
 804                         GenerateNamespaceImports (ns);\r
 805 \r
 806                         TextWriter output = Output;\r
 807                         output.WriteLine(); \r
 808                         GenerateNamespaceStart (ns); \r
 809                         GenerateTypes (ns);\r
 810                         GenerateNamespaceEnd (ns);\r
 811                 }\r
 812 \r
 813 \r
 814                 protected override void GenerateNamespaceStart (CodeNamespace ns)\r
 815                 {\r
 816                         TextWriter output = Output;\r
 817                         \r
 818                         string name = ns.Name;\r
 819                         if (name != null && name != string.Empty) {\r
 820                                 output.Write ("Namespace ");\r
 821                                 output.WriteLine (name);\r
 822                                 ++Indent;\r
 823                         }\r
 824                 }\r
 825 \r
 826                 protected override void GenerateNamespaceEnd (CodeNamespace ns)\r
 827                 {\r
 828                         string name = ns.Name;\r
 829                         if (name != null && name != string.Empty) {\r
 830                                 --Indent;\r
 831                                 Output.WriteLine ("End Namespace");\r
 832                         }\r
 833                 }\r
 834 \r
 835                 protected override void GenerateNamespaceImport (CodeNamespaceImport import)\r
 836                 {\r
 837                         TextWriter output = Output;\r
 838 \r
 839                         output.Write ("Imports ");\r
 840                         output.Write (import.Namespace);\r
 841                         output.WriteLine ();\r
 842                 }\r
 843                 \r
 844                 protected override void GenerateAttributeDeclarationsStart (CodeAttributeDeclarationCollection attributes)\r
 845                 {\r
 846                         Output.Write ('<');\r
 847                 }\r
 848                 \r
 849                 protected override void GenerateAttributeDeclarationsEnd (CodeAttributeDeclarationCollection attributes)\r
 850                 {\r
 851                         Output.WriteLine ("> _");\r
 852                 }\r
 853 \r
 854                 protected override void OutputDirection (FieldDirection direction)\r
 855                 {\r
 856                         switch (direction) {\r
 857                         case FieldDirection.In:\r
 858                                 //there is no "In"\r
 859                                 break;\r
 860                         case FieldDirection.Out:\r
 861                                 Output.Write ("ByVal ");\r
 862                                 break;\r
 863                         case FieldDirection.Ref:\r
 864                                 Output.Write ("ByRef ");\r
 865                                 break;\r
 866                         }\r
 867                 }\r
 868 \r
 869                 protected override void OutputFieldScopeModifier (MemberAttributes attributes)\r
 870                 {\r
 871                         if ((attributes & MemberAttributes.VTableMask) == MemberAttributes.New)\r
 872                                 Output.Write ("New ");\r
 873 \r
 874                         switch (attributes & MemberAttributes.ScopeMask) {\r
 875                         case MemberAttributes.Static:\r
 876                                 Output.Write ("Shared ");\r
 877                                 break;\r
 878                         case MemberAttributes.Const:\r
 879                                 Output.Write ("Const ");\r
 880                                 break;\r
 881                         }\r
 882                 }\r
 883 \r
 884                 protected override void OutputMemberAccessModifier (MemberAttributes attributes)\r
 885                 {\r
 886                         switch (attributes & MemberAttributes.AccessMask) {\r
 887                         case MemberAttributes.Assembly:\r
 888                                 Output.Write ("Friend ");\r
 889                                 break;\r
 890                         case MemberAttributes.FamilyAndAssembly:\r
 891                                 Output.Write ("Friend "); \r
 892                                 break;\r
 893                         case MemberAttributes.Family:\r
 894                                 Output.Write ("Protected ");\r
 895                                 break;\r
 896                         case MemberAttributes.FamilyOrAssembly:\r
 897                                 Output.Write ("Protected Friend ");\r
 898                                 break;\r
 899                         case MemberAttributes.Private:\r
 900                                 Output.Write ("Private ");\r
 901                                 break;\r
 902                         case MemberAttributes.Public:\r
 903                                 Output.Write ("Public ");\r
 904                                 break;\r
 905                         }\r
 906                 }\r
 907 \r
 908                 protected override void OutputMemberScopeModifier (MemberAttributes attributes)\r
 909                 {\r
 910                         if ((attributes & MemberAttributes.VTableMask) == MemberAttributes.New)\r
 911                                 Output.Write ("New ");\r
 912 \r
 913                         switch (attributes & MemberAttributes.ScopeMask) {\r
 914                         case MemberAttributes.Abstract:\r
 915                                 Output.Write ("MustOverride ");\r
 916                                 break;\r
 917                         case MemberAttributes.Final:\r
 918                                 //JW 2004-06-03: seems to be the "sealed" keyword in C# and the "NotOverridable" keyword in VB, but conflicts with ASP.NET generation
 919                                 //Output.Write ("NotOverridable ");\r
 920                                 break;\r
 921                         case MemberAttributes.Static:\r
 922                                 Output.Write ("Shared ");\r
 923                                 break;\r
 924                         case MemberAttributes.Override:\r
 925                                 Output.Write ("Overrides ");\r
 926                                 break;\r
 927                         case MemberAttributes.Overloaded:
 928                                 // based on http://gendotnet.com/Code%20Gen%20Articles/codedom.htm
 929                                 Output.Write ("Overloads ");
 930                                 MemberAttributes access_ovl = attributes & MemberAttributes.AccessMask;
 931                                 if ( access_ovl == MemberAttributes.Public ||
 932                                         access_ovl == MemberAttributes.Family )
 933                                         Output.Write ("Overridable ");
 934                                 break;
 935                         default:\r
 936                                 //\r
 937                                 // FUNNY! if the scope value is\r
 938                                 // rubbish (0 or >Const), and access\r
 939                                 // is public or protected, make it\r
 940                                 // "virtual".\r
 941                                 //\r
 942                                 // i'm not sure whether this is 100%\r
 943                                 // correct, but it seems to be MS\r
 944                                 // behavior. \r
 945                                 //\r
 946                                 MemberAttributes access = attributes & MemberAttributes.AccessMask;\r
 947                                 if ( access == MemberAttributes.Public || \r
 948                                         access == MemberAttributes.Family )\r
 949                                         Output.Write ("Overridable ");\r
 950                                 break;\r
 951                         }\r
 952                 }\r
 953 \r
 954                 protected override void OutputOperator (CodeBinaryOperatorType op)\r
 955                 {\r
 956                         switch (op) {\r
 957                         case CodeBinaryOperatorType.Add:\r
 958                                 Output.Write ("+");\r
 959                                 break;\r
 960                         case CodeBinaryOperatorType.Subtract:\r
 961                                 Output.Write ("-");\r
 962                                 break;\r
 963                         case CodeBinaryOperatorType.Multiply:\r
 964                                 Output.Write ("*");\r
 965                                 break;\r
 966                         case CodeBinaryOperatorType.Divide:\r
 967                                 Output.Write ("/");\r
 968                                 break;\r
 969                         case CodeBinaryOperatorType.Modulus:\r
 970                                 Output.Write ("Mod");\r
 971                                 break;\r
 972                         case CodeBinaryOperatorType.Assign:\r
 973                                 Output.Write ("=");\r
 974                                 break;\r
 975                         case CodeBinaryOperatorType.IdentityInequality:\r
 976                                 Output.Write ("<>");\r
 977                                 break;\r
 978                         case CodeBinaryOperatorType.IdentityEquality:\r
 979                                 Output.Write ("Is");\r
 980                                 break;\r
 981                         case CodeBinaryOperatorType.ValueEquality:\r
 982                                 Output.Write ("=");\r
 983                                 break;\r
 984                         case CodeBinaryOperatorType.BitwiseOr:\r
 985                                 Output.Write ("Or");\r
 986                                 break;\r
 987                         case CodeBinaryOperatorType.BitwiseAnd:\r
 988                                 Output.Write ("And");\r
 989                                 break;\r
 990                         case CodeBinaryOperatorType.BooleanOr:\r
 991                                 Output.Write ("OrElse");\r
 992                                 break;\r
 993                         case CodeBinaryOperatorType.BooleanAnd:\r
 994                                 Output.Write ("AndAlso");\r
 995                                 break;\r
 996                         case CodeBinaryOperatorType.LessThan:\r
 997                                 Output.Write ("<");\r
 998                                 break;\r
 999                         case CodeBinaryOperatorType.LessThanOrEqual:\r
1000                                 Output.Write ("<=");\r
1001                                 break;\r
1002                         case CodeBinaryOperatorType.GreaterThan:\r
1003                                 Output.Write (">");\r
1004                                 break;\r
1005                         case CodeBinaryOperatorType.GreaterThanOrEqual:\r
1006                                 Output.Write (">=");\r
1007                                 break;\r
1008                         }\r
1009                 }\r
1010 \r
1011                 protected override void OutputTypeAttributes (TypeAttributes attributes, bool isStruct, bool isEnum)\r
1012                 {\r
1013                         TextWriter output = Output;\r
1014 \r
1015                         switch (attributes & TypeAttributes.VisibilityMask) {\r
1016                         case TypeAttributes.NotPublic:\r
1017                                 // Does this mean friend access?\r
1018                                 output.Write ("Friend ");\r
1019                                 break; \r
1020 \r
1021                         case TypeAttributes.Public:\r
1022                         case TypeAttributes.NestedPublic:\r
1023                                 output.Write ("Public ");\r
1024                                 break;\r
1025 \r
1026                         case TypeAttributes.NestedPrivate:\r
1027                                 output.Write ("Private ");\r
1028                                 break;\r
1029                         case TypeAttributes.NestedAssembly:\r
1030                                 output.Write ("Friend ");\r
1031                                 break;\r
1032                         case TypeAttributes.NestedFamily:\r
1033                                 output.Write ("Protected ");\r
1034                                 break;\r
1035                         case TypeAttributes.NestedFamORAssem:\r
1036                                 output.Write ("Protected Friend ");\r
1037                                 break;\r
1038                         case TypeAttributes.NestedFamANDAssem:\r
1039                                 output.Write ("Friend ");\r
1040                                 break;\r
1041                         }\r
1042 \r
1043                         if (isStruct)\r
1044                                 output.Write ("Structure ");\r
1045 \r
1046                         else if (isEnum)\r
1047                                 output.Write ("Enumeration ");\r
1048 \r
1049                         else {\r
1050                                 if ((attributes & TypeAttributes.Interface) != 0) \r
1051                                         output.Write ("Interface ");\r
1052 \r
1053                                 else {\r
1054                                         if ((attributes & TypeAttributes.Sealed) != 0)\r
1055                                                 output.Write ("NotInheritable ");\r
1056 \r
1057                                         if ((attributes & TypeAttributes.Abstract) != 0)\r
1058                                                 output.Write ("MustInherit ");\r
1059                                         \r
1060                                         output.Write ("Class ");\r
1061                                 }\r
1062                         }\r
1063                 }\r
1064 \r
1065                 protected override void OutputTypeNamePair (CodeTypeReference typeRef, String name)\r
1066                 {\r
1067                         Output.Write (name + " As " + GetTypeOutput (typeRef));\r
1068                 }\r
1069 \r
1070                 protected override void OutputType (CodeTypeReference type)\r
1071                 {\r
1072                         Output.Write (GetTypeOutput (type));\r
1073                 }\r
1074 \r
1075                 protected override string QuoteSnippetString (string value)\r
1076                 {\r
1077                         StringBuilder mySBuilder = new StringBuilder(value.Length);\r
1078                         mySBuilder.Append ("\"");\r
1079                         bool inQuotes = true;\r
1080                         for (int MyCounter = 0; MyCounter < value.Length; MyCounter++)\r
1081                         {\r
1082                                 if (value[MyCounter] == 34) //quotation mark\r
1083                                 {\r
1084                                         if (!inQuotes)\r
1085                                         {\r
1086                                                 mySBuilder.Append ("&\"");\r
1087                                                 inQuotes = true;\r
1088                                         }\r
1089                                         mySBuilder.Append (value[MyCounter]);\r
1090                                         mySBuilder.Append (value[MyCounter]);\r
1091                                 }\r
1092                                 else if (value[MyCounter] >= 32) //standard ansi/unicode characters\r
1093                                 {\r
1094                                         if (!inQuotes)\r
1095                                         {\r
1096                                                 mySBuilder.Append ("&\"");\r
1097                                                 inQuotes = true;\r
1098                                         }\r
1099                                         mySBuilder.Append (value[MyCounter]);\r
1100                                 }\r
1101                                 else //special chars, e.g. line break\r
1102                                 {\r
1103                                         if (inQuotes)\r
1104                                         { \r
1105                                                 mySBuilder.Append ("\"");\r
1106                                                 inQuotes = false;\r
1107                                         }\r
1108                                         mySBuilder.Append ("&Microsoft.VisualBasic.ChrW(");\r
1109                                         mySBuilder.Append ((int)value[MyCounter]); \r
1110                                         mySBuilder.Append (")");\r
1111                                 }                       \r
1112                         }\r
1113                         if (inQuotes)\r
1114                                 mySBuilder.Append ("\"");\r
1115                         return mySBuilder.ToString();\r
1116                 }\r
1117 \r
1118                 private void GenerateDeclaration (CodeTypeReference type, string name, CodeExpression initExpression)\r
1119                 {\r
1120                         TextWriter output = Output;\r
1121 \r
1122                         OutputTypeNamePair (type, name);\r
1123 \r
1124                         if (initExpression != null) {\r
1125                                 output.Write (" = ");\r
1126                                 GenerateExpression (initExpression);\r
1127                         }\r
1128 \r
1129                         output.WriteLine ();\r
1130                 }\r
1131                 \r
1132                 private void GenerateMemberReferenceExpression (CodeExpression targetObject, string memberName)\r
1133                 {\r
1134                         GenerateExpression (targetObject);\r
1135                         Output.Write ('.');\r
1136                         Output.Write (memberName);\r
1137                 }\r
1138                         \r
1139                 /* \r
1140                  * ICodeGenerator\r
1141                  */\r
1142 \r
1143                 protected override string CreateEscapedIdentifier (string value)\r
1144                 {\r
1145                         for (int x = 0; x < Keywords.Length; x++)\r
1146                                 if (value.ToLower().Equals (Keywords[x].ToLower()))\r
1147                                         return "[" + value + "]";\r
1148                         return value;\r
1149                 }\r
1150 \r
1151                 protected override string CreateValidIdentifier (string value)\r
1152                 {\r
1153                         for (int x = 0; x < Keywords.Length; x++)\r
1154                                 if (value.ToLower().Equals (Keywords[x].ToLower()))\r
1155                                         return "_" + value;\r
1156                         return value;\r
1157                 }\r
1158 \r
1159                 protected override string GetTypeOutput (CodeTypeReference type)\r
1160                 {\r
1161                         string output;\r
1162                         CodeTypeReference arrayType;\r
1163 \r
1164                         arrayType = type.ArrayElementType;\r
1165                         if (arrayType != null)\r
1166                                 output = GetTypeOutput (arrayType);\r
1167                         else { \r
1168                                 switch (type.BaseType) {\r
1169 \r
1170                                 case "System.Decimal":\r
1171                                         output = "Decimal";\r
1172                                         break;\r
1173                                 case "System.Double":\r
1174                                         output = "Double";\r
1175                                         break;\r
1176                                 case "System.Single":\r
1177                                         output = "Single";\r
1178                                         break;\r
1179                                 \r
1180                                 case "System.Byte":\r
1181                                         output = "Byte";\r
1182                                         break;\r
1183                                 case "System.SByte":\r
1184                                         output = "SByte";\r
1185                                         break;\r
1186                                 case "System.Int32":\r
1187                                         output = "Integer";\r
1188                                         break;\r
1189                                 case "System.UInt32":\r
1190                                         output = "UInt32";\r
1191                                         break;\r
1192                                 case "System.Int64":\r
1193                                         output = "Long";\r
1194                                         break;\r
1195                                 case "System.UInt64":\r
1196                                         output = "UInt64";\r
1197                                         break;\r
1198                                 case "System.Int16":\r
1199                                         output = "Short";\r
1200                                         break;\r
1201                                 case "System.UInt16":\r
1202                                         output = "UInt16";\r
1203                                         break;\r
1204 \r
1205                                 case "System.Boolean":\r
1206                                         output = "Boolean";\r
1207                                         break;\r
1208                                 \r
1209                                 case "System.Char":\r
1210                                         output = "Char";\r
1211                                         break;\r
1212 \r
1213                                 case "System.String":\r
1214                                         output = "String";\r
1215                                         break;\r
1216                                 case "System.Object":\r
1217                                         output = "Object";\r
1218                                         break;\r
1219 \r
1220                                 case "System.Void":\r
1221                                         output = "Nothing";\r
1222                                         break;\r
1223 \r
1224                                 default:\r
1225                                         output = type.BaseType;\r
1226                                         break;\r
1227                                 }\r
1228                         }\r
1229 \r
1230                         int rank = type.ArrayRank;\r
1231                         if (rank > 0) {\r
1232                                 output += "(";\r
1233                                 for (--rank; rank > 0; --rank)\r
1234                                         output += ",";\r
1235                                 output += ")";\r
1236                         }\r
1237 \r
1238                         return output;\r
1239                 }\r
1240 \r
1241                 protected override bool IsValidIdentifier (string identifier)\r
1242                 {\r
1243                         for (int x = 0; x < Keywords.Length; x++)\r
1244                                 if (identifier.ToLower().Equals (Keywords[x].ToLower()))\r
1245                                         return false;\r
1246                         return true;\r
1247                 }\r
1248 \r
1249                 protected override bool Supports (GeneratorSupport supports)\r
1250                 {\r
1251                         return true;\r
1252                 }\r
1253         }\r
1254 }\r