2 // Microsoft.VisualBasic.VBCodeGenerator.cs
\r
5 // Andreas Nahr (ClassDevelopment@A-SoftTech.com)
\r
6 // (partially based on CSharpCodeGenerator)
\r
7 // Jochen Wezel (jwezel@compumaster.de)
\r
9 // (C) 2003 Andreas Nahr
\r
10 // (C) 2003 Jochen Wezel (http://www.compumaster.de)
\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!
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:
29 // The above copyright notice and this permission notice shall be
30 // included in all copies or substantial portions of the Software.
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.
44 using System.Text.RegularExpressions;
\r
45 using System.CodeDom;
\r
46 using System.CodeDom.Compiler;
\r
48 using System.Reflection;
\r
49 using System.Collections;
\r
51 namespace Microsoft.VisualBasic
\r
53 internal class VBCodeGenerator : CodeGenerator
\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
93 public VBCodeGenerator()
\r
97 protected override string NullToken {
\r
103 protected override void GenerateArrayCreateExpression (CodeArrayCreateExpression expression)
\r
105 TextWriter output = Output;
\r
107 output.Write ("New ");
\r
109 CodeExpressionCollection initializers = expression.Initializers;
\r
110 CodeTypeReference createType = expression.CreateType;
\r
112 if (initializers.Count > 0) {
\r
114 OutputType (createType);
\r
116 output.WriteLine (" {");
\r
118 OutputExpressionList (initializers, true);
\r
120 output.Write ("}");
\r
124 CodeTypeReference arrayType = createType.ArrayElementType;
\r
125 while (arrayType != null)
\r
127 createType = arrayType;
\r
128 arrayType = arrayType.ArrayElementType;
\r
131 OutputType (createType);
\r
133 output.Write ('(');
\r
135 CodeExpression size = expression.SizeExpression;
\r
137 GenerateExpression (size);
\r
139 output.Write (expression.Size);
\r
141 output.Write (')');
\r
145 protected override void GenerateBaseReferenceExpression (CodeBaseReferenceExpression expression)
\r
147 Output.Write ("MyBase");
\r
150 protected override void GenerateCastExpression (CodeCastExpression expression)
\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
161 private bool AsBool(object datavalue)
\r
163 return datavalue != null && datavalue is bool && (bool)datavalue;
\r
166 private string OnOff(bool datavalue)
\r
168 return datavalue?"On":"Off";
\r
171 protected override void GenerateCompileUnitStart (CodeCompileUnit compileUnit)
\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
188 protected override void GenerateDelegateCreateExpression (CodeDelegateCreateExpression expression)
\r
190 TextWriter output = Output;
\r
192 output.Write ("AddressOf ");
\r
194 CodeExpression targetObject = expression.TargetObject;
\r
195 if (targetObject != null) {
\r
196 GenerateExpression (targetObject);
\r
197 Output.Write ('.');
\r
199 output.Write (expression.MethodName);
\r
202 protected override void GenerateFieldReferenceExpression (CodeFieldReferenceExpression expression)
\r
204 CodeExpression targetObject = expression.TargetObject;
\r
205 if (targetObject != null) {
\r
206 GenerateExpression (targetObject);
\r
207 Output.Write ('.');
\r
209 Output.Write (expression.FieldName);
\r
212 protected override void GenerateArgumentReferenceExpression (CodeArgumentReferenceExpression expression)
\r
214 Output.Write (expression.ParameterName);
\r
217 protected override void GenerateVariableReferenceExpression (CodeVariableReferenceExpression expression)
\r
219 Output.Write (expression.VariableName);
\r
222 protected override void GenerateIndexerExpression (CodeIndexerExpression expression)
\r
224 TextWriter output = Output;
\r
226 GenerateExpression (expression.TargetObject);
\r
227 output.Write ('(');
\r
228 OutputExpressionList (expression.Indices);
\r
229 output.Write (')');
\r
232 protected override void GenerateArrayIndexerExpression (CodeArrayIndexerExpression expression)
\r
234 TextWriter output = Output;
\r
236 GenerateExpression (expression.TargetObject);
\r
237 output.Write (".Item(");
\r
238 OutputExpressionList (expression.Indices);
\r
239 output.Write (')');
\r
242 protected override void GenerateSnippetExpression (CodeSnippetExpression expression)
\r
244 Output.Write (expression.Value);
\r
247 protected override void GenerateMethodInvokeExpression (CodeMethodInvokeExpression expression)
\r
249 TextWriter output = Output;
\r
251 GenerateMethodReferenceExpression (expression.Method);
\r
253 output.Write ('(');
\r
254 OutputExpressionList (expression.Parameters);
\r
255 output.Write (')');
\r
258 protected override void GenerateMethodReferenceExpression (CodeMethodReferenceExpression expression)
\r
260 GenerateExpression (expression.TargetObject);
\r
261 Output.Write ('.');
\r
262 Output.Write (expression.MethodName);
\r
265 protected override void GenerateEventReferenceExpression (CodeEventReferenceExpression expression)
\r
267 GenerateExpression (expression.TargetObject);
\r
268 Output.Write ('.');
\r
269 Output.Write (expression.EventName);
\r
272 protected override void GenerateDelegateInvokeExpression (CodeDelegateInvokeExpression expression)
\r
274 Output.Write ("RaiseEvent ");
\r
275 GenerateExpression (expression.TargetObject);
\r
276 Output.Write ('(');
\r
277 OutputExpressionList (expression.Parameters);
\r
278 Output.WriteLine (')');
\r
281 protected override void GenerateObjectCreateExpression (CodeObjectCreateExpression expression)
\r
283 Output.Write( "New " );
\r
284 OutputType (expression.CreateType);
\r
285 Output.Write ('(');
\r
286 OutputExpressionList (expression.Parameters);
\r
287 Output.Write (')');
\r
290 protected override void GenerateParameterDeclarationExpression (CodeParameterDeclarationExpression e)
\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
298 protected override void GeneratePrimitiveExpression (CodePrimitiveExpression e)
\r
300 TextWriter output = Output;
\r
302 if (e.Value == null) {
\r
303 output.Write (NullToken);
\r
307 Type type = e.Value.GetType ();
\r
308 if (type == typeof (bool)) {
\r
310 output.Write ("True");
\r
312 output.Write ("False");
\r
314 else if (type == typeof (char)) {
\r
315 output.Write ("\"" + e.Value.ToString () + "\"c");
\r
317 else if (type == typeof (string)) {
\r
318 output.Write (QuoteSnippetString ((string) e.Value));
\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
326 throw new ArgumentException ("Value type (" + type + ") is not a primitive type");
\r
330 protected override void GeneratePropertyReferenceExpression (CodePropertyReferenceExpression expression)
\r
332 GenerateMemberReferenceExpression (expression.TargetObject, expression.PropertyName);
\r
335 protected override void GeneratePropertySetValueReferenceExpression (CodePropertySetValueReferenceExpression expression)
\r
337 Output.Write ("Value");
\r
340 protected override void GenerateThisReferenceExpression (CodeThisReferenceExpression expression)
\r
342 Output.Write ("Me");
\r
345 protected override void GenerateExpressionStatement (CodeExpressionStatement statement)
\r
347 GenerateExpression (statement.Expression);
\r
348 Output.WriteLine (); //start new line
\r
351 protected override void GenerateIterationStatement (CodeIterationStatement statement)
\r
353 TextWriter output = Output;
\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
364 protected override void GenerateThrowExceptionStatement (CodeThrowExceptionStatement statement)
\r
366 Output.Write ("Throw ");
\r
367 GenerateExpression (statement.ToThrow);
\r
370 protected override void GenerateComment (CodeComment comment)
\r
372 TextWriter output = Output;
\r
374 if (comment.DocComment)
\r
375 output.Write ("''' ");
\r
377 output.Write ("' ");
\r
379 output.WriteLine (comment.Text);
\r
382 protected override void GenerateMethodReturnStatement (CodeMethodReturnStatement statement)
\r
384 TextWriter output = Output;
\r
386 output.Write ("Return ");
\r
387 GenerateExpression (statement.Expression);
\r
388 output.WriteLine ();
\r
391 protected override void GenerateConditionStatement (CodeConditionStatement statement)
\r
393 TextWriter output = Output;
\r
394 output.Write ("If (");
\r
396 GenerateExpression (statement.Condition);
\r
398 output.WriteLine (") Then");
\r
400 GenerateStatements (statement.TrueStatements);
\r
403 CodeStatementCollection falses = statement.FalseStatements;
\r
404 if (falses.Count > 0) {
\r
405 output.WriteLine ("Else");
\r
407 GenerateStatements (falses);
\r
411 if (Options.ElseOnClosing)
\r
412 output.WriteLine ("Else");
\r
414 output.WriteLine ("End If");
\r
417 protected override void GenerateTryCatchFinallyStatement (CodeTryCatchFinallyStatement statement)
\r
419 TextWriter output = Output;
\r
420 CodeGeneratorOptions options = Options;
\r
422 output.WriteLine ("Try");
\r
424 GenerateStatements (statement.TryStatements);
\r
426 output.WriteLine ();
\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
433 GenerateStatements (clause.Statements);
\r
435 output.WriteLine ();
\r
438 CodeStatementCollection finallies = statement.FinallyStatements;
\r
439 if (finallies.Count > 0) {
\r
441 output.WriteLine ("Finally");
\r
443 GenerateStatements (finallies);
\r
445 output.WriteLine ();
\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
455 output.WriteLine("End Try");
\r
458 protected override void GenerateAssignStatement (CodeAssignStatement statement)
\r
460 TextWriter output = Output;
\r
461 GenerateExpression (statement.Left);
\r
462 output.Write (" = ");
\r
463 GenerateExpression (statement.Right);
\r
464 output.WriteLine ();
\r
467 protected override void GenerateAttachEventStatement (CodeAttachEventStatement statement)
\r
469 TextWriter output = Output;
\r
471 Output.Write ("AddHandler ");
\r
472 GenerateEventReferenceExpression (statement.Event);
\r
473 Output.Write ( ", ");
\r
474 GenerateExpression (statement.Listener);
\r
475 output.WriteLine ();
\r
478 protected override void GenerateRemoveEventStatement (CodeRemoveEventStatement statement)
\r
480 TextWriter output = Output;
\r
482 Output.Write ("RemoveHandler ");
\r
483 GenerateEventReferenceExpression (statement.Event);
\r
484 Output.Write ( ", ");
\r
485 GenerateExpression (statement.Listener);
\r
486 output.WriteLine ();
\r
489 protected override void GenerateGotoStatement (CodeGotoStatement statement)
\r
491 TextWriter output = Output;
\r
493 output.Write ("Goto ");
\r
494 output.Write (statement.Label);
\r
495 output.WriteLine ();
\r
498 protected override void GenerateLabeledStatement (CodeLabeledStatement statement)
\r
500 TextWriter output = Output;
\r
502 output.Write (statement.Label + ":");
\r
503 GenerateStatement (statement.Statement);
\r
506 protected override void GenerateTypeOfExpression (CodeTypeOfExpression e)
\r
508 TextWriter output = Output;
\r
510 output.Write ("GetType(");
\r
511 OutputType (e.Type);
\r
512 output.Write (")");
\r
515 protected override void GenerateVariableDeclarationStatement( CodeVariableDeclarationStatement statement )
\r
517 TextWriter output = Output;
\r
519 output.Write ("Dim ");
\r
520 OutputTypeNamePair (statement.Type, statement.Name);
\r
522 CodeExpression initExpression = statement.InitExpression;
\r
523 if (initExpression != null)
\r
525 output.Write (" = ");
\r
526 GenerateExpression (initExpression);
\r
529 output.WriteLine();
\r
532 protected override void GenerateLinePragmaStart (CodeLinePragma linePragma)
\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
542 protected override void GenerateLinePragmaEnd (CodeLinePragma linePragma)
\r
544 Output.WriteLine ("#End ExternalSource");
\r
547 protected override void GenerateEvent (CodeMemberEvent eventRef, CodeTypeDeclaration declaration)
\r
549 TextWriter output = Output;
\r
551 if (eventRef.CustomAttributes.Count > 0)
\r
552 OutputAttributeDeclarations (eventRef.CustomAttributes);
\r
554 MemberAttributes attributes = eventRef.Attributes;
\r
556 OutputMemberAccessModifier (attributes);
\r
557 OutputMemberScopeModifier (attributes);
\r
559 output.Write ("Event ");
\r
560 OutputTypeNamePair (eventRef.Type, eventRef.Name);
\r
561 output.WriteLine ();
\r
564 protected override void GenerateField (CodeMemberField field)
\r
566 TextWriter output = Output;
\r
568 if (field.CustomAttributes.Count > 0)
\r
569 OutputAttributeDeclarations (field.CustomAttributes);
\r
571 MemberAttributes attributes = field.Attributes;
\r
572 OutputMemberAccessModifier (attributes);
\r
573 OutputFieldScopeModifier (attributes);
\r
575 OutputTypeNamePair (field.Type, field.Name);
\r
577 CodeExpression initExpression = field.InitExpression;
\r
578 if (initExpression != null) {
\r
579 output.Write (" = ");
\r
580 GenerateExpression (initExpression);
\r
583 output.WriteLine();
\r
586 protected override void GenerateSnippetMember (CodeSnippetTypeMember member)
\r
588 Output.Write (member.Text);
\r
591 protected override void GenerateEntryPointMethod( CodeEntryPointMethod method, CodeTypeDeclaration declaration )
\r
593 method.Name = "Main";
\r
594 GenerateMethod (method, declaration);
\r
597 [MonoTODO ("partially implemented")]
\r
598 protected override void GenerateMethod (CodeMemberMethod method, CodeTypeDeclaration declaration)
\r
600 bool isSub = method.ReturnType == null || method.ReturnType.BaseType == "System.Void";
\r
602 TextWriter output = Output;
\r
604 if (method.CustomAttributes.Count > 0)
\r
605 OutputAttributeDeclarations (method.CustomAttributes);
\r
607 MemberAttributes attributes = method.Attributes;
\r
609 OutputMemberAccessModifier (attributes);
\r
610 OutputMemberScopeModifier (attributes);
\r
613 output.Write ("Sub ");
\r
615 output.Write ("Function ");
\r
617 output.Write (method.Name);
\r
618 output.Write ('(');
\r
619 OutputParameters (method.Parameters);
\r
620 output.Write (')');
\r
623 output.Write (" As ");
\r
624 OutputType (method.ReturnType);
\r
627 if (method.ImplementationTypes.Count > 0) {
\r
628 output.Write (" Implements ");
\r
629 foreach (CodeTypeReference type in method.ImplementationTypes)
\r
632 output.Write ('.');
\r
633 // TODO implementation incomplete
\r
638 // TODO private implementations
\r
640 if ((attributes & MemberAttributes.ScopeMask) == MemberAttributes.Abstract)
\r
641 output.WriteLine ();
\r
643 output.WriteLine ();
\r
645 GenerateStatements (method.Statements);
\r
648 output.WriteLine ("End Sub");
\r
650 output.WriteLine ("End Function");
\r
654 protected override void GenerateProperty (CodeMemberProperty property, CodeTypeDeclaration declaration)
\r
656 TextWriter output = Output;
\r
658 if (property.CustomAttributes.Count > 0)
\r
659 OutputAttributeDeclarations (property.CustomAttributes);
\r
661 MemberAttributes attributes = property.Attributes;
\r
662 OutputMemberAccessModifier (attributes);
\r
663 OutputMemberScopeModifier (attributes);
\r
665 if (property.HasGet && (!property.HasSet))
\r
666 output.Write ("ReadOnly " );
\r
668 if (property.HasSet && (!property.HasGet))
\r
669 output.Write ("WriteOnly " );
\r
671 output.Write ("Property " );
\r
673 OutputTypeNamePair (property.Type, property.Name);
\r
674 output.WriteLine ();
\r
677 if (property.HasGet) {
\r
678 output.WriteLine ("Get");
\r
681 GenerateStatements (property.GetStatements);
\r
684 output.WriteLine ("End Get");
\r
687 if (property.HasSet) {
\r
688 output.Write ("Set (");
\r
689 OutputTypeNamePair (property.Type, "Value");
690 output.WriteLine (")");
693 GenerateStatements (property.SetStatements);
\r
696 output.WriteLine ("End Set");
\r
700 output.WriteLine ("End Property");
\r
703 [MonoTODO ("not implemented")]
\r
704 protected override void GenerateConstructor (CodeConstructor constructor, CodeTypeDeclaration declaration)
\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
714 GenerateStatements (constructor.Statements);
\r
716 Output.WriteLine ("End Sub");
\r
719 protected override void GenerateTypeConstructor (CodeTypeConstructor constructor)
\r
721 Output.WriteLine ("Shared Sub New()");
\r
723 GenerateStatements (constructor.Statements);
\r
725 Output.WriteLine ("End Sub");
\r
728 [MonoTODO ("not implemented")]
\r
729 protected override void GenerateTypeStart (CodeTypeDeclaration declaration)
\r
731 TextWriter output = Output;
\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
740 output.WriteLine (declaration.Name);
\r
744 IEnumerator enumerator = declaration.BaseTypes.GetEnumerator();
\r
745 if (enumerator.MoveNext())
\r
747 CodeTypeReference type = (CodeTypeReference)enumerator.Current;
\r
751 output.Write ("Inherits ");
\r
753 output.WriteLine ();
\r
756 while (enumerator.MoveNext())
\r
758 type = (CodeTypeReference)enumerator.Current;
\r
762 output.Write ("Implements ");
\r
764 output.WriteLine ();
\r
770 protected override void GenerateTypeEnd (CodeTypeDeclaration declaration)
\r
772 string output = string.Empty;
\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
784 Output.WriteLine (output);
\r
787 protected override void GenerateNamespace(CodeNamespace ns)
\r
789 GenerateCommentStatements (ns.Comments);
\r
791 bool Imports2MSVBFound;
\r
792 Imports2MSVBFound = false;
\r
793 if (null != ns.Imports)
\r
795 foreach (CodeNamespaceImport import in ns.Imports)
\r
797 if (string.Compare (import.Namespace, "Microsoft.VisualBasic", true, System.Globalization.CultureInfo.InvariantCulture) == 0)
\r
798 Imports2MSVBFound = true;
\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
807 TextWriter output = Output;
\r
808 output.WriteLine();
\r
809 GenerateNamespaceStart (ns);
\r
810 GenerateTypes (ns);
\r
811 GenerateNamespaceEnd (ns);
\r
815 protected override void GenerateNamespaceStart (CodeNamespace ns)
\r
817 TextWriter output = Output;
\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
827 protected override void GenerateNamespaceEnd (CodeNamespace ns)
\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());
834 Output.WriteLine ("End Namespace");
\r
835 Output.WriteLine ("'Indent=" + Indent.ToString());
839 protected override void GenerateNamespaceImport (CodeNamespaceImport import)
\r
841 TextWriter output = Output;
\r
843 output.Write ("Imports ");
\r
844 output.Write (import.Namespace);
\r
845 output.WriteLine ();
\r
848 protected override void GenerateAttributeDeclarationsStart (CodeAttributeDeclarationCollection attributes)
\r
850 Output.Write ('<');
\r
853 protected override void GenerateAttributeDeclarationsEnd (CodeAttributeDeclarationCollection attributes)
\r
855 Output.WriteLine ("> _");
\r
858 protected override void OutputDirection (FieldDirection direction)
\r
860 switch (direction) {
\r
861 case FieldDirection.In:
\r
864 case FieldDirection.Out:
\r
865 Output.Write ("ByVal ");
\r
867 case FieldDirection.Ref:
\r
868 Output.Write ("ByRef ");
\r
873 protected override void OutputFieldScopeModifier (MemberAttributes attributes)
\r
875 if ((attributes & MemberAttributes.VTableMask) == MemberAttributes.New)
\r
876 Output.Write ("New ");
\r
878 switch (attributes & MemberAttributes.ScopeMask) {
\r
879 case MemberAttributes.Static:
\r
880 Output.Write ("Shared ");
\r
882 case MemberAttributes.Const:
\r
883 Output.Write ("Const ");
\r
888 protected override void OutputMemberAccessModifier (MemberAttributes attributes)
\r
890 switch (attributes & MemberAttributes.AccessMask) {
\r
891 case MemberAttributes.Assembly:
\r
892 Output.Write ("Friend ");
\r
894 case MemberAttributes.FamilyAndAssembly:
\r
895 Output.Write ("Friend ");
\r
897 case MemberAttributes.Family:
\r
898 Output.Write ("Protected ");
\r
900 case MemberAttributes.FamilyOrAssembly:
\r
901 Output.Write ("Protected Friend ");
\r
903 case MemberAttributes.Private:
\r
904 Output.Write ("Private ");
\r
906 case MemberAttributes.Public:
\r
907 Output.Write ("Public ");
\r
912 protected override void OutputMemberScopeModifier (MemberAttributes attributes)
\r
914 if ((attributes & MemberAttributes.VTableMask) == MemberAttributes.New)
\r
915 Output.Write ("New ");
\r
917 switch (attributes & MemberAttributes.ScopeMask) {
\r
918 case MemberAttributes.Abstract:
\r
919 Output.Write ("MustOverride ");
\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
925 case MemberAttributes.Static:
\r
926 Output.Write ("Shared ");
\r
928 case MemberAttributes.Override:
\r
929 Output.Write ("Overrides ");
\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 ");
941 // FUNNY! if the scope value is
\r
942 // rubbish (0 or >Const), and access
\r
943 // is public or protected, make it
\r
946 // i'm not sure whether this is 100%
\r
947 // correct, but it seems to be MS
\r
950 MemberAttributes access = attributes & MemberAttributes.AccessMask;
\r
951 if ( access == MemberAttributes.Public ||
\r
952 access == MemberAttributes.Family )
\r
953 Output.Write ("Overridable ");
\r
958 protected override void OutputOperator (CodeBinaryOperatorType op)
\r
961 case CodeBinaryOperatorType.Add:
\r
962 Output.Write ("+");
\r
964 case CodeBinaryOperatorType.Subtract:
\r
965 Output.Write ("-");
\r
967 case CodeBinaryOperatorType.Multiply:
\r
968 Output.Write ("*");
\r
970 case CodeBinaryOperatorType.Divide:
\r
971 Output.Write ("/");
\r
973 case CodeBinaryOperatorType.Modulus:
\r
974 Output.Write ("Mod");
\r
976 case CodeBinaryOperatorType.Assign:
\r
977 Output.Write ("=");
\r
979 case CodeBinaryOperatorType.IdentityInequality:
\r
980 Output.Write ("<>");
\r
982 case CodeBinaryOperatorType.IdentityEquality:
\r
983 Output.Write ("Is");
\r
985 case CodeBinaryOperatorType.ValueEquality:
\r
986 Output.Write ("=");
\r
988 case CodeBinaryOperatorType.BitwiseOr:
\r
989 Output.Write ("Or");
\r
991 case CodeBinaryOperatorType.BitwiseAnd:
\r
992 Output.Write ("And");
\r
994 case CodeBinaryOperatorType.BooleanOr:
\r
995 Output.Write ("OrElse");
\r
997 case CodeBinaryOperatorType.BooleanAnd:
\r
998 Output.Write ("AndAlso");
\r
1000 case CodeBinaryOperatorType.LessThan:
\r
1001 Output.Write ("<");
\r
1003 case CodeBinaryOperatorType.LessThanOrEqual:
\r
1004 Output.Write ("<=");
\r
1006 case CodeBinaryOperatorType.GreaterThan:
\r
1007 Output.Write (">");
\r
1009 case CodeBinaryOperatorType.GreaterThanOrEqual:
\r
1010 Output.Write (">=");
\r
1015 protected override void OutputTypeAttributes (TypeAttributes attributes, bool isStruct, bool isEnum)
\r
1017 TextWriter output = Output;
\r
1019 switch (attributes & TypeAttributes.VisibilityMask) {
\r
1020 case TypeAttributes.NotPublic:
\r
1021 // Does this mean friend access?
\r
1022 output.Write ("Friend ");
\r
1025 case TypeAttributes.Public:
\r
1026 case TypeAttributes.NestedPublic:
\r
1027 output.Write ("Public ");
\r
1030 case TypeAttributes.NestedPrivate:
\r
1031 output.Write ("Private ");
\r
1033 case TypeAttributes.NestedAssembly:
\r
1034 output.Write ("Friend ");
\r
1036 case TypeAttributes.NestedFamily:
\r
1037 output.Write ("Protected ");
\r
1039 case TypeAttributes.NestedFamORAssem:
\r
1040 output.Write ("Protected Friend ");
\r
1042 case TypeAttributes.NestedFamANDAssem:
\r
1043 output.Write ("Friend ");
\r
1048 output.Write ("Structure ");
\r
1051 output.Write ("Enumeration ");
\r
1054 if ((attributes & TypeAttributes.Interface) != 0)
\r
1055 output.Write ("Interface ");
\r
1058 if ((attributes & TypeAttributes.Sealed) != 0)
\r
1059 output.Write ("NotInheritable ");
\r
1061 if ((attributes & TypeAttributes.Abstract) != 0)
\r
1062 output.Write ("MustInherit ");
\r
1064 output.Write ("Class ");
\r
1069 protected override void OutputTypeNamePair (CodeTypeReference typeRef, String name)
\r
1071 Output.Write (name + " As " + GetTypeOutput (typeRef));
\r
1074 protected override void OutputType (CodeTypeReference type)
\r
1076 Output.Write (GetTypeOutput (type));
\r
1079 protected override string QuoteSnippetString (string value)
\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
1086 if (value[MyCounter] == 34) //quotation mark
\r
1090 mySBuilder.Append ("&\"");
\r
1093 mySBuilder.Append (value[MyCounter]);
\r
1094 mySBuilder.Append (value[MyCounter]);
\r
1096 else if (value[MyCounter] >= 32) //standard ansi/unicode characters
\r
1100 mySBuilder.Append ("&\"");
\r
1103 mySBuilder.Append (value[MyCounter]);
\r
1105 else //special chars, e.g. line break
\r
1109 mySBuilder.Append ("\"");
\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
1118 mySBuilder.Append ("\"");
\r
1119 return mySBuilder.ToString();
\r
1122 private void GenerateDeclaration (CodeTypeReference type, string name, CodeExpression initExpression)
\r
1124 TextWriter output = Output;
\r
1126 OutputTypeNamePair (type, name);
\r
1128 if (initExpression != null) {
\r
1129 output.Write (" = ");
\r
1130 GenerateExpression (initExpression);
\r
1133 output.WriteLine ();
\r
1136 private void GenerateMemberReferenceExpression (CodeExpression targetObject, string memberName)
\r
1138 GenerateExpression (targetObject);
\r
1139 Output.Write ('.');
\r
1140 Output.Write (memberName);
\r
1147 protected override string CreateEscapedIdentifier (string value)
\r
1149 for (int x = 0; x < Keywords.Length; x++)
\r
1150 if (value.ToLower().Equals (Keywords[x].ToLower()))
\r
1151 return "[" + value + "]";
\r
1155 protected override string CreateValidIdentifier (string value)
\r
1157 for (int x = 0; x < Keywords.Length; x++)
\r
1158 if (value.ToLower().Equals (Keywords[x].ToLower()))
\r
1159 return "_" + value;
\r
1163 protected override string GetTypeOutput (CodeTypeReference type)
\r
1166 CodeTypeReference arrayType;
\r
1168 arrayType = type.ArrayElementType;
\r
1169 if (arrayType != null)
\r
1170 output = GetTypeOutput (arrayType);
\r
1172 switch (type.BaseType) {
\r
1174 case "System.Decimal":
\r
1175 output = "Decimal";
\r
1177 case "System.Double":
\r
1178 output = "Double";
\r
1180 case "System.Single":
\r
1181 output = "Single";
\r
1184 case "System.Byte":
\r
1187 case "System.SByte":
\r
1190 case "System.Int32":
\r
1191 output = "Integer";
\r
1193 case "System.UInt32":
\r
1194 output = "UInt32";
\r
1196 case "System.Int64":
\r
1199 case "System.UInt64":
\r
1200 output = "UInt64";
\r
1202 case "System.Int16":
\r
1205 case "System.UInt16":
\r
1206 output = "UInt16";
\r
1209 case "System.Boolean":
\r
1210 output = "Boolean";
\r
1213 case "System.Char":
\r
1217 case "System.String":
\r
1218 output = "String";
\r
1220 case "System.Object":
\r
1221 output = "Object";
\r
1224 case "System.Void":
\r
1225 output = "Nothing";
\r
1229 output = type.BaseType;
\r
1234 int rank = type.ArrayRank;
\r
1237 for (--rank; rank > 0; --rank)
\r
1245 protected override bool IsValidIdentifier (string identifier)
\r
1247 for (int x = 0; x < Keywords.Length; x++)
\r
1248 if (identifier.ToLower().Equals (Keywords[x].ToLower()))
\r
1253 protected override bool Supports (GeneratorSupport supports)
\r