diff options
author | Andreas N <andreas@mono-cvs.ximian.com> | 2003-07-07 02:11:57 +0400 |
---|---|---|
committer | Andreas N <andreas@mono-cvs.ximian.com> | 2003-07-07 02:11:57 +0400 |
commit | 8ff319769c1627d53afccc898223a9924055da90 (patch) | |
tree | d03a0411a159323e9b210998488654d7dbf141e4 /mcs/class/System/Microsoft.VisualBasic | |
parent | a571f257dfab2865f54e84c439c87e700e05e637 (diff) |
2003-06-25 Andreas Nahr <ClassDevelopment@A-SoftTech.com>
* VBCodeGenerator.cs: Added and nearly completely implemented
(it compiles, but the functionallity is completely untested)
(also without a working mbas the compilaton options will fail)
(once all command line arguments for mbas are final and the warning output is final
change the apropriate code to generate these options)
* VBCodeProvider.cs: Added and implemented
svn path=/trunk/mcs/; revision=15995
Diffstat (limited to 'mcs/class/System/Microsoft.VisualBasic')
3 files changed, 1266 insertions, 0 deletions
diff --git a/mcs/class/System/Microsoft.VisualBasic/ChangeLog b/mcs/class/System/Microsoft.VisualBasic/ChangeLog new file mode 100644 index 00000000000..80a8232d5c7 --- /dev/null +++ b/mcs/class/System/Microsoft.VisualBasic/ChangeLog @@ -0,0 +1,8 @@ +2003-06-25 Andreas Nahr <ClassDevelopment@A-SoftTech.com> + + * VBCodeGenerator.cs: Added and nearly completely implemented + (it compiles, but the functionallity is completely untested) + (also without a working mbas the compilaton options will fail) + (once all command line arguments for mbas are final and the warning output is final + change the apropriate code to generate these options) + * VBCodeProvider.cs: Added and implemented diff --git a/mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs b/mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs new file mode 100644 index 00000000000..a2c815d0e62 --- /dev/null +++ b/mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs @@ -0,0 +1,1207 @@ +// +// Microsoft.VisualBasic.VBCodeGenerator.cs +// +// Author: +// Andreas Nahr (ClassDevelopment@A-SoftTech.com) +// (partially based on CSharpCodeGenerator) +// +// (C) 2003 Andreas Nahr +// + +using System; +using System.Text; +using System.Text.RegularExpressions; +using System.CodeDom; +using System.CodeDom.Compiler; +using System.IO; +using System.Reflection; +using System.Collections; + +namespace Microsoft.VisualBasic +{ + internal class VBCodeGenerator : CodeCompiler + { + private string[] Keywords = new string[] { + "AddHandler", "AddressOf", "Alias", "And", + "AndAlso", "Ansi", "As", "Assembly", + "Auto", "Boolean", "ByRef", "Byte", + "ByVal", "Call", "Case", "Catch", + "CBool", "CByte", "CChar", "CDate", + "CDec", "CDbl", "Char", "CInt", + "Class", "CLng", "CObj", "Const", + "CShort", "CSng", "CStr", "CType", + "Date", "Decimal", "Declare", "Default", + "Delegate", "Dim", "DirectCast", "Do", + "Double", "Each", "Else", "ElseIf", + "End", "Enum", "Erase", "Error", + "Event", "Exit", "False", "Finally", + "For", "Friend", "Function", "Get", + "GetType", "GoSub", "GoTo", "Handles", + "If", "Implements", "Imports", "In", + "Inherits", "Integer", "Interface", "Is", + "Let", "Lib", "Like", "Long", + "Loop", "Me", "Mod", "Module", + "MustInherit", "MustOverride", "MyBase", "MyClass", + "Namespace", "New", "Next", "Not", + "Nothing", "NotInheritable", "NotOverridable", "Object", + "On", "Option", "Optional", "Or", + "OrElse", "Overloads", "Overridable", "Overrides", + "ParamArray", "Preserve", "Private", "Property", + "Protected", "Public", "RaiseEvent", "ReadOnly", + "ReDim", "REM", "RemoveHandler", "Resume", + "Return", "Select", "Set", "Shadows", + "Shared", "Short", "Single", "Static", + "Step", "Stop", "String", "Structure", + "Sub", "SyncLock", "Then", "Throw", + "To", "True", "Try", "TypeOf", + "Unicode", "Until", "Variant", "When", + "While", "With", "WithEvents", "WriteOnly", + "Xor" + }; + + public VBCodeGenerator() + { + } + + protected override string NullToken { + get { + return "Nothing"; + } + } + + protected override void GenerateArrayCreateExpression (CodeArrayCreateExpression expression) + { + TextWriter output = Output; + + output.Write ("New "); + + CodeExpressionCollection initializers = expression.Initializers; + CodeTypeReference createType = expression.CreateType; + + if (initializers.Count > 0) { + + OutputType (createType); + + output.WriteLine (" {"); + ++Indent; + OutputExpressionList (initializers, true); + --Indent; + output.Write ("}"); + + } + else { + CodeTypeReference arrayType = createType.ArrayElementType; + while (arrayType != null) + { + createType = arrayType; + arrayType = arrayType.ArrayElementType; + } + + OutputType (createType); + + output.Write ('('); + + CodeExpression size = expression.SizeExpression; + if (size != null) + GenerateExpression (size); + else + output.Write (expression.Size); + + output.Write (')'); + } + } + + protected override void GenerateBaseReferenceExpression (CodeBaseReferenceExpression expression) + { + Output.Write ("MyBase"); + } + + protected override void GenerateCastExpression (CodeCastExpression expression) + { + TextWriter output = Output; + // ENHANCE: Use a DirectCast if it is known that expression.Expression is no Value-Type + output.Write ("CType("); + GenerateExpression (expression.Expression); + output.Write (", "); + OutputType (expression.TargetType); + output.Write (")"); + } + + protected override void GenerateCompileUnitStart (CodeCompileUnit compileUnit) + { + GenerateComment (new CodeComment ("------------------------------------------------------------------------------")); + GenerateComment (new CodeComment (" <autogenerated>")); + GenerateComment (new CodeComment (" This code was generated by a tool.")); + GenerateComment (new CodeComment (" Mono Runtime Version: " + System.Environment.Version)); + GenerateComment (new CodeComment ("")); + GenerateComment (new CodeComment (" Changes to this file may cause incorrect behavior and will be lost if ")); + GenerateComment (new CodeComment (" the code is regenerated.")); + GenerateComment (new CodeComment (" </autogenerated>")); + GenerateComment (new CodeComment ("------------------------------------------------------------------------------")); + Output.WriteLine (); + } + + protected override void GenerateDelegateCreateExpression (CodeDelegateCreateExpression expression) + { + TextWriter output = Output; + + output.Write ("AddressOf "); + + CodeExpression targetObject = expression.TargetObject; + if (targetObject != null) { + GenerateExpression (targetObject); + Output.Write ('.'); + } + output.Write (expression.MethodName); + } + + protected override void GenerateFieldReferenceExpression (CodeFieldReferenceExpression expression) + { + CodeExpression targetObject = expression.TargetObject; + if (targetObject != null) { + GenerateExpression (targetObject); + Output.Write ('.'); + } + Output.Write (expression.FieldName); + } + + protected override void GenerateArgumentReferenceExpression (CodeArgumentReferenceExpression expression) + { + Output.Write (expression.ParameterName); + } + + protected override void GenerateVariableReferenceExpression (CodeVariableReferenceExpression expression) + { + Output.Write (expression.VariableName); + } + + protected override void GenerateIndexerExpression (CodeIndexerExpression expression) + { + TextWriter output = Output; + + GenerateExpression (expression.TargetObject); + output.Write ('('); + OutputExpressionList (expression.Indices); + output.Write (')'); + } + + protected override void GenerateArrayIndexerExpression (CodeArrayIndexerExpression expression) + { + TextWriter output = Output; + + GenerateExpression (expression.TargetObject); + output.Write ('('); + OutputExpressionList (expression.Indices); + output.Write (')'); + } + + protected override void GenerateSnippetExpression (CodeSnippetExpression expression) + { + Output.Write (expression.Value); + } + + protected override void GenerateMethodInvokeExpression (CodeMethodInvokeExpression expression) + { + TextWriter output = Output; + + GenerateMethodReferenceExpression (expression.Method); + + output.Write ('('); + OutputExpressionList (expression.Parameters); + output.Write (')'); + } + + protected override void GenerateMethodReferenceExpression (CodeMethodReferenceExpression expression) + { + GenerateExpression (expression.TargetObject); + Output.Write ('.'); + Output.Write (expression.MethodName); + } + + protected override void GenerateEventReferenceExpression (CodeEventReferenceExpression expression) + { + GenerateExpression (expression.TargetObject); + Output.Write ('.'); + Output.Write (expression.EventName); + } + + protected override void GenerateDelegateInvokeExpression (CodeDelegateInvokeExpression expression) + { + Output.Write ("RaiseEvent "); + GenerateExpression (expression.TargetObject); + Output.Write ('('); + OutputExpressionList (expression.Parameters); + Output.WriteLine (')'); + } + + protected override void GenerateObjectCreateExpression (CodeObjectCreateExpression expression) + { + Output.Write( "New " ); + OutputType (expression.CreateType); + Output.Write ('('); + OutputExpressionList (expression.Parameters); + Output.Write (')'); + } + + protected override void GenerateParameterDeclarationExpression (CodeParameterDeclarationExpression e) + { + if (e.CustomAttributes != null && e.CustomAttributes.Count > 0) + OutputAttributeDeclarations (e.CustomAttributes); + OutputDirection (e.Direction); + OutputTypeNamePair (e.Type, e.Name); + } + + protected override void GeneratePrimitiveExpression (CodePrimitiveExpression e) + { + TextWriter output = Output; + + if (e.Value == null) { + output.Write (NullToken); + return; + } + + Type type = e.Value.GetType (); + if (type == typeof (bool)) { + if ((bool)e.Value) + output.Write ("True"); + else + output.Write ("False"); + } + else if (type == typeof (char)) { + output.Write ("\"" + e.Value.ToString () + "\"c"); + } + else if (type == typeof (string)) { + output.Write (QuoteSnippetString ((string) e.Value)); + } + else if (type == typeof (byte) || type == typeof (sbyte) || type == typeof (short) || + type == typeof (int) || type == typeof (long) || type == typeof (float) || + type == typeof (double) || type == typeof (decimal)) { + output.Write (e.Value.ToString ()); + } + else { + throw new ArgumentException ("Value type (" + type + ") is not a primitive type"); + } + } + + protected override void GeneratePropertyReferenceExpression (CodePropertyReferenceExpression expression) + { + GenerateMemberReferenceExpression (expression.TargetObject, expression.PropertyName); + } + + protected override void GeneratePropertySetValueReferenceExpression (CodePropertySetValueReferenceExpression expression) + { + Output.Write ("Value"); + } + + protected override void GenerateThisReferenceExpression (CodeThisReferenceExpression expression) + { + Output.Write ("Me"); + } + + protected override void GenerateExpressionStatement (CodeExpressionStatement statement) + { + GenerateExpression (statement.Expression); + Output.WriteLine (); //start new line + } + + protected override void GenerateIterationStatement (CodeIterationStatement statement) + { + TextWriter output = Output; + + GenerateStatement (statement.InitStatement); + output.Write ("Do While "); + GenerateExpression (statement.TestExpression); + output.WriteLine (); + GenerateStatements (statement.Statements); + GenerateStatement (statement.IncrementStatement); + output.WriteLine ("Loop"); + } + + protected override void GenerateThrowExceptionStatement (CodeThrowExceptionStatement statement) + { + Output.Write ("Throw "); + GenerateExpression (statement.ToThrow); + } + + protected override void GenerateComment (CodeComment comment) + { + TextWriter output = Output; + + if (comment.DocComment) + output.Write ("''' "); + else + output.Write ("' "); + + output.WriteLine (comment.Text); + } + + protected override void GenerateMethodReturnStatement (CodeMethodReturnStatement statement) + { + TextWriter output = Output; + + output.Write ("Return "); + GenerateExpression (statement.Expression); + output.WriteLine (); + } + + protected override void GenerateConditionStatement (CodeConditionStatement statement) + { + TextWriter output = Output; + output.Write ("If ("); + + GenerateExpression (statement.Condition); + + output.WriteLine (") Then"); + ++Indent; + GenerateStatements (statement.TrueStatements); + --Indent; + + CodeStatementCollection falses = statement.FalseStatements; + if (falses.Count > 0) { + output.WriteLine ("Else"); + ++Indent; + GenerateStatements (falses); + --Indent; + } + else { + if (Options.ElseOnClosing) + output.WriteLine ("Else"); + } + output.WriteLine ("End If"); + } + + protected override void GenerateTryCatchFinallyStatement (CodeTryCatchFinallyStatement statement) + { + TextWriter output = Output; + CodeGeneratorOptions options = Options; + + output.WriteLine ("Try"); + ++Indent; + GenerateStatements (statement.TryStatements); + --Indent; + output.WriteLine (); + + foreach (CodeCatchClause clause in statement.CatchClauses) { + output.Write ("Catch "); + OutputTypeNamePair (clause.CatchExceptionType, clause.LocalName); + output.WriteLine (); + ++Indent; + GenerateStatements (clause.Statements); + --Indent; + output.WriteLine (); + } + + CodeStatementCollection finallies = statement.FinallyStatements; + if (finallies.Count > 0) { + + output.WriteLine ("Finally"); + ++Indent; + GenerateStatements (finallies); + --Indent; + output.WriteLine (); + } + + if (Options.ElseOnClosing) { + if (statement.CatchClauses.Count == 0) + output.WriteLine ("Catch"); + if (statement.FinallyStatements.Count == 0) + output.WriteLine ("Finally"); + } + + output.WriteLine("End Try"); + } + + protected override void GenerateAssignStatement (CodeAssignStatement statement) + { + TextWriter output = Output; + GenerateExpression (statement.Left); + output.Write (" = "); + GenerateExpression (statement.Right); + output.WriteLine (); + } + + protected override void GenerateAttachEventStatement (CodeAttachEventStatement statement) + { + TextWriter output = Output; + + Output.Write ("AddHandler "); + GenerateEventReferenceExpression (statement.Event); + Output.Write ( ", "); + GenerateExpression (statement.Listener); + output.WriteLine (); + } + + protected override void GenerateRemoveEventStatement (CodeRemoveEventStatement statement) + { + TextWriter output = Output; + + Output.Write ("RemoveHandler "); + GenerateEventReferenceExpression (statement.Event); + Output.Write ( ", "); + GenerateExpression (statement.Listener); + output.WriteLine (); + } + + protected override void GenerateGotoStatement (CodeGotoStatement statement) + { + TextWriter output = Output; + + output.Write ("Goto "); + output.Write (statement.Label); + output.WriteLine (); + } + + protected override void GenerateLabeledStatement (CodeLabeledStatement statement) + { + TextWriter output = Output; + + output.Write (statement.Label + ":"); + GenerateStatement (statement.Statement); + } + + protected override void GenerateTypeOfExpression (CodeTypeOfExpression e) + { + TextWriter output = Output; + + output.Write ("GetType("); + OutputType (e.Type); + output.Write (")"); + } + + protected override void GenerateVariableDeclarationStatement( CodeVariableDeclarationStatement statement ) + { + TextWriter output = Output; + + output.Write ("Dim "); + OutputTypeNamePair (statement.Type, statement.Name); + + CodeExpression initExpression = statement.InitExpression; + if (initExpression != null) + { + output.Write (" = "); + GenerateExpression (initExpression); + } + + output.WriteLine(); + } + + protected override void GenerateLinePragmaStart (CodeLinePragma linePragma) + { + Output.WriteLine (); + Output.Write ("#ExternalSource("); + Output.Write (linePragma.FileName); + Output.Write (", "); + Output.Write (linePragma.LineNumber); + Output.WriteLine (")"); + } + + protected override void GenerateLinePragmaEnd (CodeLinePragma linePragma) + { + Output.WriteLine ("#End ExternalSource"); + } + + protected override void GenerateEvent (CodeMemberEvent eventRef, CodeTypeDeclaration declaration) + { + TextWriter output = Output; + + if (eventRef.CustomAttributes.Count > 0) + OutputAttributeDeclarations (eventRef.CustomAttributes); + + MemberAttributes attributes = eventRef.Attributes; + + OutputMemberAccessModifier (attributes); + OutputMemberScopeModifier (attributes); + + output.Write ("Event "); + OutputTypeNamePair (eventRef.Type, eventRef.Name); + output.WriteLine (); + } + + protected override void GenerateField (CodeMemberField field) + { + TextWriter output = Output; + + if (field.CustomAttributes.Count > 0) + OutputAttributeDeclarations (field.CustomAttributes); + + MemberAttributes attributes = field.Attributes; + OutputMemberAccessModifier (attributes); + OutputFieldScopeModifier (attributes); + + OutputTypeNamePair (field.Type, field.Name); + + CodeExpression initExpression = field.InitExpression; + if (initExpression != null) { + output.Write (" = "); + GenerateExpression (initExpression); + } + + output.WriteLine(); + } + + protected override void GenerateSnippetMember (CodeSnippetTypeMember member) + { + Output.Write (member.Text); + } + + protected override void GenerateEntryPointMethod( CodeEntryPointMethod method, CodeTypeDeclaration declaration ) + { + method.Name = "Main"; + GenerateMethod (method, declaration); + } + + [MonoTODO ("partially implemented")] + protected override void GenerateMethod (CodeMemberMethod method, CodeTypeDeclaration declaration) + { + TextWriter output = Output; + + if (method.CustomAttributes.Count > 0) + OutputAttributeDeclarations (method.CustomAttributes); + + MemberAttributes attributes = method.Attributes; + + OutputMemberAccessModifier (attributes); + OutputMemberScopeModifier (attributes); + + if (method.ReturnType == null) + output.Write ("Sub "); + else + output.Write ("Function "); + + output.Write (method.Name); + output.Write ('('); + OutputParameters (method.Parameters); + output.Write (')'); + + if (method.ReturnType != null) { + output.Write (" As "); + OutputType (method.ReturnType); + } + + if (method.ImplementationTypes.Count > 0) { + output.Write (" Implements "); + foreach (CodeTypeReference type in method.ImplementationTypes) + { + OutputType (type); + output.Write ('.'); + // TODO implementation incomplete + + } + } + + // TODO private implementations + + if ((attributes & MemberAttributes.ScopeMask) == MemberAttributes.Abstract) + output.WriteLine (); + else { + output.WriteLine (); + ++Indent; + GenerateStatements (method.Statements); + --Indent; + if (method.ReturnType == null) + output.WriteLine ("End Sub"); + else + output.WriteLine ("End Function"); + } + } + + protected override void GenerateProperty (CodeMemberProperty property, CodeTypeDeclaration declaration) + { + TextWriter output = Output; + + if (property.CustomAttributes.Count > 0) + OutputAttributeDeclarations (property.CustomAttributes); + + MemberAttributes attributes = property.Attributes; + OutputMemberAccessModifier (attributes); + OutputMemberScopeModifier (attributes); + + if (property.HasGet && (property.HasSet = false)) + output.Write ("ReadOnly" ); + + if (property.HasSet && (property.HasGet = false)) + output.Write ("WriteOnly" ); + + output.Write ("Property" ); + + OutputTypeNamePair (property.Type, property.Name); + output.WriteLine (); + ++Indent; + + if (property.HasGet) { + output.WriteLine ("Get"); + ++Indent; + + GenerateStatements (property.GetStatements); + + --Indent; + output.WriteLine ("End Get"); + } + + if (property.HasSet) { + output.WriteLine ("Set"); + ++Indent; + + GenerateStatements (property.SetStatements); + + --Indent; + output.WriteLine ("End Set"); + } + + --Indent; + output.WriteLine ("End Property"); + } + + [MonoTODO ("not implemented")] + protected override void GenerateConstructor (CodeConstructor constructor, CodeTypeDeclaration declaration) + { + if (constructor.CustomAttributes.Count > 0) + OutputAttributeDeclarations (constructor.CustomAttributes); + OutputMemberAccessModifier (constructor.Attributes); + Output.Write ("Sub New("); + OutputParameters (constructor.Parameters); + Output.WriteLine (")"); + // Handle BaseConstructorArgs, ChainedConstructorArgs, ImplementationTypes + Indent++; + GenerateStatements (constructor.Statements); + Indent--; + Output.WriteLine ("End Sub"); + } + + protected override void GenerateTypeConstructor (CodeTypeConstructor constructor) + { + Output.WriteLine ("Shared Sub New()"); + Indent++; + GenerateStatements (constructor.Statements); + Indent--; + Output.WriteLine ("End Sub"); + } + + [MonoTODO ("not implemented")] + protected override void GenerateTypeStart (CodeTypeDeclaration declaration) + { + TextWriter output = Output; + + if (declaration.CustomAttributes.Count > 0) + OutputAttributeDeclarations (declaration.CustomAttributes); + TypeAttributes attributes = declaration.TypeAttributes; + OutputTypeAttributes (attributes, + declaration.IsStruct, + declaration.IsEnum); + + output.WriteLine (declaration.Name); + + ++Indent; + + IEnumerator enumerator = declaration.BaseTypes.GetEnumerator(); + if (enumerator.MoveNext()) + { + CodeTypeReference type = (CodeTypeReference)enumerator.Current; + + if (type != null) + { + output.Write ("Inherits "); + OutputType (type); + output.WriteLine (); + } + + while (enumerator.MoveNext()) + { + type = (CodeTypeReference)enumerator.Current; + + if (type != null) + { + output.Write ("Implements "); + OutputType (type); + output.WriteLine (); + } + } + } + } + + protected override void GenerateTypeEnd (CodeTypeDeclaration declaration) + { + string output = string.Empty; + + --Indent; + if (declaration.IsStruct) + output = "End Structure"; + if (declaration.IsInterface) + output = "End Interface"; + if (declaration.IsEnum) + output = "End Enum"; + if (declaration.IsClass) + output = "End Class"; + + Output.WriteLine (output); + } + + protected override void GenerateNamespaceStart (CodeNamespace ns) + { + TextWriter output = Output; + + string name = ns.Name; + if (name != null && name != string.Empty) { + output.Write ("Namespace "); + output.WriteLine (name); + ++Indent; + } + } + + protected override void GenerateNamespaceEnd (CodeNamespace ns) + { + string name = ns.Name; + if (name != null && name != string.Empty) { + --Indent; + Output.WriteLine ("End Namespace"); + } + } + + protected override void GenerateNamespaceImport (CodeNamespaceImport import) + { + TextWriter output = Output; + + output.Write ("Imports "); + output.Write (import.Namespace); + output.WriteLine (); + } + + protected override void GenerateAttributeDeclarationsStart (CodeAttributeDeclarationCollection attributes) + { + Output.Write ('<'); + } + + protected override void GenerateAttributeDeclarationsEnd (CodeAttributeDeclarationCollection attributes) + { + Output.WriteLine ('>'); + } + + protected override void OutputDirection (FieldDirection direction) + { + switch (direction) { + case FieldDirection.In: + //there is no "In" + break; + case FieldDirection.Out: + Output.Write ("ByVal "); + break; + case FieldDirection.Ref: + Output.Write ("ByRef "); + break; + } + } + + protected override void OutputFieldScopeModifier (MemberAttributes attributes) + { + if ((attributes & MemberAttributes.VTableMask) == MemberAttributes.New) + Output.Write ("New "); + + switch (attributes & MemberAttributes.ScopeMask) { + case MemberAttributes.Static: + Output.Write ("Shared "); + break; + case MemberAttributes.Const: + Output.Write ("Const "); + break; + } + } + + protected override void OutputMemberAccessModifier (MemberAttributes attributes) + { + switch (attributes & MemberAttributes.AccessMask) { + case MemberAttributes.Assembly: + Output.Write ("Friend "); + break; + case MemberAttributes.FamilyAndAssembly: + Output.Write ("Friend "); + break; + case MemberAttributes.Family: + Output.Write ("Protected "); + break; + case MemberAttributes.FamilyOrAssembly: + Output.Write ("Protected Friend "); + break; + case MemberAttributes.Private: + Output.Write ("Private "); + break; + case MemberAttributes.Public: + Output.Write ("Public "); + break; + } + } + + protected override void OutputMemberScopeModifier (MemberAttributes attributes) + { + if ((attributes & MemberAttributes.VTableMask) == MemberAttributes.New) + Output.Write ("New "); + + switch (attributes & MemberAttributes.ScopeMask) { + case MemberAttributes.Abstract: + Output.Write ("MustOverride "); + break; + case MemberAttributes.Final: + Output.Write ("NotOverridable "); + break; + case MemberAttributes.Static: + Output.Write ("Shared "); + break; + case MemberAttributes.Override: + Output.Write ("Overrides "); + break; + default: + // + // FUNNY! if the scope value is + // rubbish (0 or >Const), and access + // is public or protected, make it + // "virtual". + // + // i'm not sure whether this is 100% + // correct, but it seems to be MS + // behavior. + // + MemberAttributes access = attributes & MemberAttributes.AccessMask; + if ( access == MemberAttributes.Public || + access == MemberAttributes.Family ) + Output.Write ("Overridable "); + break; + } + } + + protected override void OutputOperator (CodeBinaryOperatorType op) + { + switch (op) { + case CodeBinaryOperatorType.Add: + Output.Write ("+"); + break; + case CodeBinaryOperatorType.Subtract: + Output.Write ("-"); + break; + case CodeBinaryOperatorType.Multiply: + Output.Write ("*"); + break; + case CodeBinaryOperatorType.Divide: + Output.Write ("/"); + break; + case CodeBinaryOperatorType.Modulus: + Output.Write ("Mod"); + break; + case CodeBinaryOperatorType.Assign: + Output.Write ("="); + break; + case CodeBinaryOperatorType.IdentityInequality: + Output.Write ("<>"); + break; + case CodeBinaryOperatorType.IdentityEquality: + Output.Write ("Is"); + break; + case CodeBinaryOperatorType.ValueEquality: + Output.Write ("="); + break; + case CodeBinaryOperatorType.BitwiseOr: + Output.Write ("Or"); + break; + case CodeBinaryOperatorType.BitwiseAnd: + Output.Write ("And"); + break; + case CodeBinaryOperatorType.BooleanOr: + Output.Write ("OrElse"); + break; + case CodeBinaryOperatorType.BooleanAnd: + Output.Write ("AndAlso"); + break; + case CodeBinaryOperatorType.LessThan: + Output.Write ("<"); + break; + case CodeBinaryOperatorType.LessThanOrEqual: + Output.Write ("<="); + break; + case CodeBinaryOperatorType.GreaterThan: + Output.Write (">"); + break; + case CodeBinaryOperatorType.GreaterThanOrEqual: + Output.Write (">="); + break; + } + } + + protected override void OutputTypeAttributes (TypeAttributes attributes, bool isStruct, bool isEnum) + { + TextWriter output = Output; + + switch (attributes & TypeAttributes.VisibilityMask) { + case TypeAttributes.NotPublic: + // Does this mean friend access? + output.Write ("Friend "); + break; + + case TypeAttributes.Public: + case TypeAttributes.NestedPublic: + output.Write ("Public "); + break; + + case TypeAttributes.NestedPrivate: + output.Write ("Private "); + break; + case TypeAttributes.NestedAssembly: + output.Write ("Friend "); + break; + case TypeAttributes.NestedFamily: + output.Write ("Protected "); + break; + case TypeAttributes.NestedFamORAssem: + output.Write ("Protected Friend"); + break; + case TypeAttributes.NestedFamANDAssem: + output.Write ("Friend "); + break; + } + + if (isStruct) + output.Write ("Structure "); + + else if (isEnum) + output.Write ("Enumeration "); + + else { + if ((attributes & TypeAttributes.Interface) != 0) + output.Write ("Interface "); + + else { + if ((attributes & TypeAttributes.Sealed) != 0) + output.Write ("NotInheritable "); + + if ((attributes & TypeAttributes.Abstract) != 0) + output.Write ("MustInherit "); + + output.Write ("Class "); + } + } + } + + protected override void OutputTypeNamePair (CodeTypeReference typeRef, String name) + { + Output.Write (name + " As " + GetTypeOutput (typeRef)); + } + + protected override void OutputType (CodeTypeReference type) + { + Output.Write (GetTypeOutput (type)); + } + + [MonoTODO ("not implemented")] + protected override string QuoteSnippetString (string value) + { + // FIXME: escape ASCII chars that are not code compatible (e.g. vbcrlf) + return value; + } + + private void GenerateDeclaration (CodeTypeReference type, string name, CodeExpression initExpression) + { + TextWriter output = Output; + + OutputTypeNamePair (type, name); + + if (initExpression != null) { + output.Write (" = "); + GenerateExpression (initExpression); + } + + output.WriteLine (); + } + + private void GenerateMemberReferenceExpression (CodeExpression targetObject, string memberName) + { + GenerateExpression (targetObject); + Output.Write ('.'); + Output.Write (memberName); + } + + /* + * ICodeGenerator + */ + + protected override string CreateEscapedIdentifier (string value) + { + for (int x = 0; x < Keywords.Length; x++) + if (value.ToLower().Equals (Keywords[x].ToLower())) + return "[" + value + "]"; + return value; + } + + protected override string CreateValidIdentifier (string value) + { + for (int x = 0; x < Keywords.Length; x++) + if (value.ToLower().Equals (Keywords[x].ToLower())) + return "_" + value; + return value; + } + + protected override string GetTypeOutput (CodeTypeReference type) + { + string output; + CodeTypeReference arrayType; + + arrayType = type.ArrayElementType; + if (arrayType != null) + output = GetTypeOutput (arrayType); + else { + switch (type.BaseType) { + + case "System.Decimal": + output = "Decimal"; + break; + case "System.Double": + output = "Double"; + break; + case "System.Single": + output = "Single"; + break; + + case "System.Byte": + output = "Byte"; + break; + case "System.SByte": + output = "SByte"; + break; + case "System.Int32": + output = "Integer"; + break; + case "System.UInt32": + output = "UInt32"; + break; + case "System.Int64": + output = "Long"; + break; + case "System.UInt64": + output = "UInt64"; + break; + case "System.Int16": + output = "Short"; + break; + case "System.UInt16": + output = "UInt16"; + break; + + case "System.Boolean": + output = "Boolean"; + break; + + case "System.Char": + output = "Char"; + break; + + case "System.String": + output = "String"; + break; + case "System.Object": + output = "Object"; + break; + + case "System.Void": + output = "Nothing"; + break; + + default: + output = type.BaseType; + break; + } + } + + int rank = type.ArrayRank; + if (rank > 0) { + output += "("; + for (--rank; rank > 0; --rank) + output += ","; + output += ")"; + } + + return output; + } + + protected override bool IsValidIdentifier (string identifier) + { + for (int x = 0; x < Keywords.Length; x++) + if (identifier.ToLower().Equals (Keywords[x].ToLower())) + return false; + return true; + } + + protected override bool Supports (GeneratorSupport supports) + { + return true; + } + + protected override string CompilerName { + get { + return "mbas.exe"; + } + } + + protected override string FileExtension { + get { + return "vb"; + } + } + + [MonoTODO ("check")] + protected override string CmdArgsFromParameters (CompilerParameters options) + { + //FIXME correct this agains mbas parameters if parameters are complete + StringBuilder args = new StringBuilder(); + if (options.GenerateExecutable) + args.Append ("/target:exe "); + else + args.Append ("/target:library "); + + if (options.IncludeDebugInformation) + args.Append ("/debug "); + + if (options.TreatWarningsAsErrors) + args.Append ("/warnaserror "); + args.AppendFormat ("/warn:{0} ", options.WarningLevel); + if (options.OutputAssembly == null) + options.OutputAssembly = Path.ChangeExtension (Path.GetTempFileName(), "dll"); + + args.AppendFormat ("/out:'{0}' ", options.OutputAssembly); + + if (null != options.ReferencedAssemblies) { + foreach (string import in options.ReferencedAssemblies) + args.AppendFormat ("/r:'{0}' ", import); + } + + if (options.Win32Resource != null) + args.AppendFormat ("/Win32Resource:{0} ", options.Win32Resource); + + foreach (string source in options.TempFiles) + args.AppendFormat ("'{0}' ", source); + + return args.ToString(); + } + + [MonoTODO ("check")] + protected override void ProcessCompilerOutputLine (CompilerResults results, string line) + { + CompilerError error = new CompilerError(); + //FIXME check this Regex against mbas compiler if the output there is complete + Regex reg = new Regex (@"^(\s*(?<file>.*)\((?<line>\d*)(,(?<column>\d*))?\)\s+)*(?<level>\w+)\s*(?<number>.*):\s(?<message>.*)", + RegexOptions.Compiled | RegexOptions.ExplicitCapture); + Match match = reg.Match (line); + if (!match.Success) { + return; + } + if (String.Empty != match.Result ("${file}")) + error.FileName = match.Result ("${file}"); + if (String.Empty != match.Result ("${line}")) + error.Line = Int32.Parse (match.Result ("${line}")); + if (String.Empty != match.Result ("${column}")) + error.Column = Int32.Parse (match.Result ("${column}")); + if (match.Result ("${level}") == "warning") + error.IsWarning=true; + error.ErrorNumber = match.Result ("${number}"); + error.ErrorText = match.Result ("${message}"); + + results.Errors.Add (error); + return; + } + } +} diff --git a/mcs/class/System/Microsoft.VisualBasic/VBCodeProvider.cs b/mcs/class/System/Microsoft.VisualBasic/VBCodeProvider.cs new file mode 100644 index 00000000000..04b00dd795e --- /dev/null +++ b/mcs/class/System/Microsoft.VisualBasic/VBCodeProvider.cs @@ -0,0 +1,51 @@ +// +// Microsoft.VisualBasic.VBCodeProvider.cs +// +// Author: +// Andreas Nahr (ClassDevelopment@A-SoftTech.com) +// +// (C) 2003 Andreas Nahr +// + +using System; +using System.CodeDom.Compiler; +using System.ComponentModel; + +namespace Microsoft.VisualBasic +{ + [ToolboxItem (""), DesignerCategory ("Component")] + public class VBCodeProvider : CodeDomProvider + { + + public VBCodeProvider() + { + } + + public override string FileExtension { + get { + return "vb"; + } + } + + public override LanguageOptions LanguageOptions { + get { + return LanguageOptions.CaseInsensitive; + } + } + + public override ICodeCompiler CreateCompiler() + { + return new Microsoft.VisualBasic.VBCodeGenerator(); + } + + public override ICodeGenerator CreateGenerator() + { + return new Microsoft.VisualBasic.VBCodeGenerator(); + } + + public override TypeConverter GetConverter (Type type) + { + return TypeDescriptor.GetConverter (type); + } + } +} |