← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitorGlobal.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitorGlobal.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections.Generic;
 
6
using ICSharpCode.NRefactory.Ast;
 
7
using B = Boo.Lang.Compiler.Ast;
 
8
 
 
9
namespace NRefactoryToBooConverter
 
10
{
 
11
        partial class ConvertVisitor
 
12
        {
 
13
                public object VisitCompilationUnit(CompilationUnit compilationUnit, object data)
 
14
                {
 
15
                        module = new B.Module();
 
16
                        module.LexicalInfo = new B.LexicalInfo(fileName, 1, 1);
 
17
                        compilationUnit.AcceptChildren(this, data);
 
18
                        if (entryPointMethod != null) {
 
19
                                bool allMembersAreStatic = true;
 
20
                                foreach (B.TypeMember member in entryPointMethod.DeclaringType.Members) {
 
21
                                        allMembersAreStatic &= member.IsStatic;
 
22
                                }
 
23
                                if (allMembersAreStatic) {
 
24
                                        entryPointMethod.DeclaringType.Attributes.Add(MakeAttribute(("module")));
 
25
                                } else {
 
26
                                        lastLexicalInfo = entryPointMethod.LexicalInfo;
 
27
                                        B.Expression expr = MakeReferenceExpression(entryPointMethod.DeclaringType.Name + ".Main");
 
28
                                        B.MethodInvocationExpression mie = new B.MethodInvocationExpression(lastLexicalInfo, expr);
 
29
                                        if (entryPointMethod.Parameters.Count > 0) {
 
30
                                                mie.Arguments.Add(MakeReferenceExpression("argv"));
 
31
                                        }
 
32
                                        B.SimpleTypeReference ret = entryPointMethod.ReturnType as B.SimpleTypeReference;
 
33
                                        if (ret.Name == "void" || ret.Name == "System.Void")
 
34
                                                module.Globals.Add(new B.ExpressionStatement(mie));
 
35
                                        else
 
36
                                                module.Globals.Add(new B.ReturnStatement(lastLexicalInfo, mie, null));
 
37
                                }
 
38
                        }
 
39
                        B.Module tmp = module;
 
40
                        module = null;
 
41
                        return tmp;
 
42
                }
 
43
                
 
44
                public object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
 
45
                {
 
46
                        if (module.Namespace != null) {
 
47
                                AddError(namespaceDeclaration, "Only one namespace declaration per file is supported.");
 
48
                                return null;
 
49
                        }
 
50
                        module.Namespace = new B.NamespaceDeclaration(GetLexicalInfo(namespaceDeclaration));
 
51
                        module.Namespace.Name = namespaceDeclaration.Name;
 
52
                        return namespaceDeclaration.AcceptChildren(this, data);
 
53
                }
 
54
                
 
55
                public object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
 
56
                {
 
57
                        foreach (Using u in usingDeclaration.Usings) {
 
58
                                VisitUsing(u, data);
 
59
                        }
 
60
                        return null;
 
61
                }
 
62
                
 
63
                public object VisitUsing(Using @using, object data)
 
64
                {
 
65
                        B.Import import;
 
66
                        if (@using.IsAlias) {
 
67
                                import = new B.Import(@using.Alias.Type, null, new B.ReferenceExpression(@using.Name));
 
68
                                import.LexicalInfo = GetLexicalInfo(@using);
 
69
                        } else {
 
70
                                import = new B.Import(GetLexicalInfo(@using), @using.Name);
 
71
                        }
 
72
                        module.Imports.Add(import);
 
73
                        return import;
 
74
                }
 
75
                
 
76
                B.TypeDefinition currentType;
 
77
                
 
78
                public object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
 
79
                {
 
80
                        if (typeDeclaration.Templates.Count > 0) {
 
81
                                AddError(typeDeclaration, "Generic type definitions are not supported.");
 
82
                        }
 
83
                        B.TypeDefinition oldType = currentType;
 
84
                        B.TypeDefinition typeDef;
 
85
                        switch (typeDeclaration.Type) {
 
86
                                case ClassType.Class:
 
87
                                        typeDef = new B.ClassDefinition(GetLexicalInfo(typeDeclaration));
 
88
                                        break;
 
89
                                case ClassType.Interface:
 
90
                                        typeDef = new B.InterfaceDefinition(GetLexicalInfo(typeDeclaration));
 
91
                                        break;
 
92
                                case ClassType.Enum:
 
93
                                        typeDef = new B.EnumDefinition(GetLexicalInfo(typeDeclaration));
 
94
                                        break;
 
95
                                case ClassType.Struct:
 
96
                                        typeDef = new B.StructDefinition(GetLexicalInfo(typeDeclaration));
 
97
                                        break;
 
98
                                case ClassType.Module:
 
99
                                        typeDef = new B.ClassDefinition(GetLexicalInfo(typeDeclaration));
 
100
                                        typeDeclaration.Modifier |= Modifiers.Static;
 
101
                                        break;
 
102
                                default:
 
103
                                        AddError(typeDeclaration, "Unknown class type.");
 
104
                                        return null;
 
105
                        }
 
106
                        if (currentType != null)
 
107
                                typeDef.Modifiers = ConvertModifier(typeDeclaration, B.TypeMemberModifiers.Private);
 
108
                        else
 
109
                                typeDef.Modifiers = ConvertModifier(typeDeclaration, B.TypeMemberModifiers.Internal);
 
110
                        typeDef.Name = typeDeclaration.Name;
 
111
                        typeDef.EndSourceLocation = GetLocation(typeDeclaration.EndLocation);
 
112
                        ConvertAttributes(typeDeclaration.Attributes, typeDef.Attributes);
 
113
                        ConvertTypeReferences(typeDeclaration.BaseTypes, typeDef.BaseTypes);
 
114
                        
 
115
                        if (currentType != null)
 
116
                                currentType.Members.Add(typeDef);
 
117
                        else
 
118
                                module.Members.Add(typeDef);
 
119
                        currentType = typeDef;
 
120
                        typeDeclaration.AcceptChildren(this, data);
 
121
                        currentType = oldType;
 
122
                        return typeDef;
 
123
                }
 
124
                
 
125
                public object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data)
 
126
                {
 
127
                        B.CallableDefinition cd = new B.CallableDefinition(GetLexicalInfo(delegateDeclaration));
 
128
                        cd.Name = delegateDeclaration.Name;
 
129
                        ConvertAttributes(delegateDeclaration.Attributes, cd.Attributes);
 
130
                        cd.Modifiers = ConvertModifier(delegateDeclaration, B.TypeMemberModifiers.Private);
 
131
                        ConvertParameters(delegateDeclaration.Parameters, cd.Parameters);
 
132
                        cd.ReturnType = ConvertTypeReference(delegateDeclaration.ReturnType);
 
133
                        if (currentType != null)
 
134
                                currentType.Members.Add(cd);
 
135
                        else
 
136
                                module.Members.Add(cd);
 
137
                        return cd;
 
138
                }
 
139
                
 
140
                void ConvertAttributes(List<AttributeSection> sections, B.AttributeCollection col)
 
141
                {
 
142
                        foreach (AttributeSection s in sections) {
 
143
                                if (s.AttributeTarget.Length > 0) {
 
144
                                        AddError(s, "Attribute target not supported");
 
145
                                        continue;
 
146
                                }
 
147
                                foreach (ICSharpCode.NRefactory.Ast.Attribute a in s.Attributes) {
 
148
                                        col.Add((B.Attribute)VisitAttribute(a, null));
 
149
                                }
 
150
                        }
 
151
                }
 
152
                
 
153
                public object VisitAttribute(ICSharpCode.NRefactory.Ast.Attribute a, object data)
 
154
                {
 
155
                        B.Attribute att = new B.Attribute(GetLexicalInfo(a), a.Name);
 
156
                        att.EndSourceLocation = GetLocation(a.EndLocation);
 
157
                        ConvertExpressions(a.PositionalArguments, att.Arguments);
 
158
                        foreach (NamedArgumentExpression nae in a.NamedArguments) {
 
159
                                B.Expression expr = ConvertExpression(nae.Expression);
 
160
                                if (expr != null) {
 
161
                                        att.NamedArguments.Add(new B.ExpressionPair(new B.ReferenceExpression(nae.Name), expr));
 
162
                                }
 
163
                        }
 
164
                        return att;
 
165
                }
 
166
                
 
167
                public object VisitAttributeSection(AttributeSection s, object data)
 
168
                {
 
169
                        if (s.AttributeTarget.Equals("assembly", StringComparison.OrdinalIgnoreCase)) {
 
170
                                foreach (ICSharpCode.NRefactory.Ast.Attribute a in s.Attributes) {
 
171
                                        module.AssemblyAttributes.Add((B.Attribute)VisitAttribute(a, null));
 
172
                                }
 
173
                        } else {
 
174
                                AddError(s, "Attribute must have the target 'assembly'");
 
175
                        }
 
176
                        return null;
 
177
                }
 
178
                
 
179
                // Some classes are handled by their parent (TemplateDefinition by TypeDeclaration/MethodDeclaration etc.)
 
180
                // so we don't need to implement Visit for them.
 
181
                public object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data)
 
182
                {
 
183
                        throw new ApplicationException("Visited TemplateDefinition.");
 
184
                }
 
185
                
 
186
                public object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data)
 
187
                {
 
188
                        throw new ApplicationException("Visited InterfaceImplementation.");
 
189
                }
 
190
                
 
191
                public object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data)
 
192
                {
 
193
                        AddError(optionDeclaration, "Option statement is not supported.");
 
194
                        return null;
 
195
                }
 
196
                
 
197
                public object VisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data)
 
198
                {
 
199
                        AddError(externAliasDirective, "'extern alias' directive is not supported.");
 
200
                        return null;
 
201
                }
 
202
        }
 
203
}