← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/Libraries/NRefactory/Project/Src/Visitors/CodeDOMVerboseOutputGenerator.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/Libraries/NRefactory/Project/Src/Visitors/CodeDOMVerboseOutputGenerator.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.CodeDom;
 
6
using System.CodeDom.Compiler;
 
7
using System.IO;
 
8
using System.Security.Permissions;
 
9
 
 
10
namespace ICSharpCode.NRefactory.Visitors
 
11
{
 
12
        [PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]
 
13
        [PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
 
14
        public class CodeDomVerboseOutputGenerator : System.CodeDom.Compiler.CodeGenerator
 
15
        {
 
16
                #region System.CodeDom.Compiler.CodeGenerator abstract class implementation
 
17
                protected override string NullToken {
 
18
                        get {
 
19
                                return "[NULL]";
 
20
                        }
 
21
                }
 
22
 
 
23
                protected override void OutputType(CodeTypeReference typeRef)
 
24
                {
 
25
                        Output.Write("[CodeTypeReference: {0}", typeRef.BaseType);
 
26
                        if (typeRef.ArrayRank > 0) {
 
27
                                Output.Write(" Rank:" + typeRef.ArrayRank);
 
28
                        }
 
29
                        Output.Write("]");
 
30
                }
 
31
                
 
32
                protected override void GenerateArrayCreateExpression(CodeArrayCreateExpression e)
 
33
                {
 
34
                        Output.Write("[CodeArrayCreateExpression: {0}]", e.ToString());
 
35
                }
 
36
                
 
37
                protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e)
 
38
                {
 
39
                        Output.Write("[CodeBaseReferenceExpression: {0}]", e.ToString());
 
40
                }
 
41
                
 
42
                protected override void GenerateCastExpression(CodeCastExpression e)
 
43
                {
 
44
                        Output.Write("[CodeCastExpression: {0}]", e.ToString());
 
45
                }
 
46
                
 
47
                protected override void GenerateDelegateCreateExpression(CodeDelegateCreateExpression e)
 
48
                {
 
49
                        Output.Write("[CodeDelegateCreateExpression: {0}]", e.ToString());
 
50
                }
 
51
                
 
52
                protected override void GenerateFieldReferenceExpression(CodeFieldReferenceExpression e)
 
53
                {
 
54
                        Output.Write("[CodeFieldReferenceExpression: Name={0}, Target=", e.FieldName);
 
55
                        this.GenerateExpression(e.TargetObject);
 
56
                        Output.Write("]");
 
57
                }
 
58
                
 
59
                protected override void GenerateMethodReferenceExpression(CodeMethodReferenceExpression e)
 
60
                {
 
61
                        Output.Write("[CodeMethodReferenceExpression: Name={0}, Target=", e.MethodName);
 
62
                        this.GenerateExpression(e.TargetObject);
 
63
                        Output.Write("]");
 
64
                }
 
65
                
 
66
                protected override void GenerateEventReferenceExpression(CodeEventReferenceExpression e)
 
67
                {
 
68
                        Output.Write("[CodeEventReferenceExpression: Name={0}, Target=", e.EventName);
 
69
                        this.GenerateExpression(e.TargetObject);
 
70
                        Output.Write("]");
 
71
                }
 
72
                
 
73
                protected override void GenerateArgumentReferenceExpression(CodeArgumentReferenceExpression e)
 
74
                {
 
75
                        Output.Write("[CodeArgumentReferenceExpression: {0}]", e.ToString());
 
76
                }
 
77
                
 
78
                protected override void GenerateVariableReferenceExpression(CodeVariableReferenceExpression e)
 
79
                {
 
80
                        Output.Write("[CodeVariableReferenceExpression: Name={0}]", e.VariableName);
 
81
                }
 
82
                
 
83
                protected override void GenerateIndexerExpression(CodeIndexerExpression e)
 
84
                {
 
85
                        Output.Write("[CodeIndexerExpression: {0}]", e.ToString());
 
86
                }
 
87
                
 
88
                protected override void GenerateArrayIndexerExpression(CodeArrayIndexerExpression e)
 
89
                {
 
90
                        Output.Write("[CodeArrayIndexerExpression: {0}]", e.ToString());
 
91
                }
 
92
                
 
93
                protected override void GenerateSnippetExpression(CodeSnippetExpression e)
 
94
                {
 
95
                        Output.Write("[CodeSnippetExpression: {0}]", e.ToString());
 
96
                }
 
97
                
 
98
                protected override void GenerateMethodInvokeExpression(CodeMethodInvokeExpression e)
 
99
                {
 
100
                        Output.Write("[CodeMethodInvokeExpression: Method=");
 
101
                        GenerateMethodReferenceExpression(e.Method);
 
102
                        Output.Write(", Parameters=");
 
103
                        bool first = true;
 
104
                        foreach (CodeExpression expr in e.Parameters) {
 
105
                                if (first) first = false; else Output.Write(", ");
 
106
                                this.GenerateExpression(expr);
 
107
                        }
 
108
                        Output.Write("]");
 
109
                }
 
110
                
 
111
                protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
 
112
                {
 
113
                        Output.Write("[CodeDelegateInvokeExpression: {0}]", e.ToString());
 
114
                }
 
115
                
 
116
                protected override void GenerateObjectCreateExpression(CodeObjectCreateExpression e)
 
117
                {
 
118
                        Output.Write("[CodeObjectCreateExpression: Type={0}, Parameters=", e.CreateType.BaseType);
 
119
                        bool first = true;
 
120
                        foreach (CodeExpression expr in e.Parameters) {
 
121
                                if (first) first = false; else Output.Write(", ");
 
122
                                this.GenerateExpression(expr);
 
123
                        }
 
124
                        Output.Write("]");
 
125
                }
 
126
                
 
127
                protected override void GeneratePropertyReferenceExpression(CodePropertyReferenceExpression e)
 
128
                {
 
129
                        Output.Write("[CodePropertyReferenceExpression: Name={0}, Target=", e.PropertyName);
 
130
                        this.GenerateExpression(e.TargetObject);
 
131
                        Output.Write("]");
 
132
                }
 
133
                
 
134
                protected override void GeneratePropertySetValueReferenceExpression(CodePropertySetValueReferenceExpression e)
 
135
                {
 
136
                        Output.Write("[CodePropertySetValueReferenceExpression: {0}]", e.ToString());
 
137
                }
 
138
                
 
139
                protected override void GenerateThisReferenceExpression(CodeThisReferenceExpression e)
 
140
                {
 
141
                        Output.Write("[CodeThisReferenceExpression]");
 
142
                }
 
143
                
 
144
                protected override void GenerateExpressionStatement(CodeExpressionStatement e)
 
145
                {
 
146
                        Output.Write("[CodeExpressionStatement:");
 
147
                        base.GenerateExpression(e.Expression);
 
148
                        Output.WriteLine("]");
 
149
                }
 
150
                
 
151
                protected override void GenerateIterationStatement(CodeIterationStatement e)
 
152
                {
 
153
                        Output.WriteLine("[CodeIterationStatement: {0}]", e.ToString());
 
154
                }
 
155
                
 
156
                protected override void GenerateThrowExceptionStatement(CodeThrowExceptionStatement e)
 
157
                {
 
158
                        Output.WriteLine("[CodeThrowExceptionStatement: {0}]", e.ToString());
 
159
                }
 
160
                
 
161
                protected override void GenerateComment(CodeComment e)
 
162
                {
 
163
                        Output.WriteLine("[CodeComment: {0}]", e.ToString());
 
164
                }
 
165
                
 
166
                protected override void GenerateMethodReturnStatement(CodeMethodReturnStatement e)
 
167
                {
 
168
                        Output.WriteLine("[CodeMethodReturnStatement: {0}]", e.ToString());
 
169
                }
 
170
                
 
171
                protected override void GenerateConditionStatement(CodeConditionStatement e)
 
172
                {
 
173
                        Output.WriteLine("[GenerateConditionStatement: {0}]", e.ToString());
 
174
                }
 
175
                
 
176
                protected override void GenerateTryCatchFinallyStatement(CodeTryCatchFinallyStatement e)
 
177
                {
 
178
                        Output.WriteLine("[CodeTryCatchFinallyStatement: {0}]", e.ToString());
 
179
                }
 
180
                
 
181
                protected override void GenerateAssignStatement(CodeAssignStatement e)
 
182
                {
 
183
                        Output.Write("[CodeAssignStatement: Left=");
 
184
                        base.GenerateExpression(e.Left);
 
185
                        Output.Write(", Right=");
 
186
                        base.GenerateExpression(e.Right);
 
187
                        Output.WriteLine("]");
 
188
                }
 
189
                
 
190
                protected override void GenerateAttachEventStatement(CodeAttachEventStatement e)
 
191
                {
 
192
                        Output.WriteLine("[CodeAttachEventStatement: {0}]", e.ToString());
 
193
                }
 
194
                
 
195
                protected override void GenerateRemoveEventStatement(CodeRemoveEventStatement e)
 
196
                {
 
197
                        Output.WriteLine("[CodeRemoveEventStatement: {0}]", e.ToString());
 
198
                }
 
199
                
 
200
                protected override void GenerateGotoStatement(CodeGotoStatement e)
 
201
                {
 
202
                        Output.WriteLine("[CodeGotoStatement: {0}]", e.ToString());
 
203
                }
 
204
                
 
205
                protected override void GenerateLabeledStatement(CodeLabeledStatement e)
 
206
                {
 
207
                        Output.WriteLine("[CodeLabeledStatement: {0}]", e.ToString());
 
208
                }
 
209
                
 
210
                protected override void GenerateVariableDeclarationStatement(CodeVariableDeclarationStatement e)
 
211
                {
 
212
                        Output.WriteLine("[CodeVariableDeclarationStatement: {0}]", e.ToString());
 
213
                }
 
214
                
 
215
                protected override void GenerateLinePragmaStart(CodeLinePragma e)
 
216
                {
 
217
                        Output.WriteLine("[CodeLinePragma: {0}]", e.ToString());
 
218
                }
 
219
                
 
220
                protected override void GenerateLinePragmaEnd(CodeLinePragma e)
 
221
                {
 
222
                        Output.WriteLine("[CodeLinePragma: {0}]", e.ToString());
 
223
                }
 
224
                
 
225
                protected override void GenerateEvent(CodeMemberEvent e, CodeTypeDeclaration c)
 
226
                {
 
227
                        Output.WriteLine("[CodeMemberEvent: {0}]", e.ToString());
 
228
                }
 
229
                
 
230
                protected override void GenerateField(CodeMemberField e)
 
231
                {
 
232
                        Output.Write("[CodeMemberField: Name={0}, Type=", e.Name);
 
233
                        Output.Write(e.Type.BaseType);
 
234
                        Output.WriteLine("]");
 
235
                }
 
236
                
 
237
                protected override void GenerateSnippetMember(CodeSnippetTypeMember e)
 
238
                {
 
239
                        Output.WriteLine("[CodeSnippetTypeMember: {0}]", e.ToString());
 
240
                }
 
241
                
 
242
                protected override void GenerateEntryPointMethod(CodeEntryPointMethod e, CodeTypeDeclaration c)
 
243
                {
 
244
                        Output.WriteLine("[CodeEntryPointMethod: {0}]", e.ToString());
 
245
                }
 
246
                
 
247
                public void PublicGenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o)
 
248
                {
 
249
                        ((ICodeGenerator)this).GenerateCodeFromStatement(e, w, o);
 
250
                }
 
251
                
 
252
                protected override void GenerateMethod(CodeMemberMethod e, CodeTypeDeclaration c)
 
253
                {
 
254
                        Output.WriteLine("[CodeMemberMethod: Name={0}, Parameterns={1}]", e.Name, e.Parameters.Count);
 
255
                        ++Indent;
 
256
                        GenerateStatements(e.Statements);
 
257
                        --Indent;
 
258
                }
 
259
                
 
260
                protected override void GenerateProperty(CodeMemberProperty e, CodeTypeDeclaration c)
 
261
                {
 
262
                        Output.WriteLine("[CodeMemberProperty : {0}]", e.ToString());
 
263
                }
 
264
                
 
265
                protected override void GenerateConstructor(CodeConstructor e, CodeTypeDeclaration c)
 
266
                {
 
267
                        Output.WriteLine("[CodeConstructor : {0}]", e.ToString());
 
268
                        ++Indent;
 
269
                        GenerateStatements(e.Statements);
 
270
                        --Indent;
 
271
                }
 
272
                
 
273
                protected override void GenerateTypeConstructor(CodeTypeConstructor e)
 
274
                {
 
275
                        Output.WriteLine("[CodeTypeConstructor : {0}]", e.ToString());
 
276
                }
 
277
                
 
278
                protected override void GenerateTypeStart(CodeTypeDeclaration e)
 
279
                {
 
280
                        Output.WriteLine("[CodeTypeDeclaration : {0}]", e.ToString());
 
281
                }
 
282
                
 
283
                protected override void GenerateTypeEnd(CodeTypeDeclaration e)
 
284
                {
 
285
                        Output.WriteLine("[CodeTypeDeclaration: {0}]", e.ToString());
 
286
                }
 
287
                
 
288
                protected override void GenerateNamespaceStart(CodeNamespace e)
 
289
                {
 
290
                        Output.WriteLine("[CodeNamespaceStart: {0}]", e.ToString());
 
291
                }
 
292
                
 
293
                protected override void GenerateNamespaceEnd(CodeNamespace e)
 
294
                {
 
295
                        Output.WriteLine("[CodeNamespaceEnd: {0}]", e.ToString());
 
296
                }
 
297
                
 
298
                protected override void GenerateNamespaceImport(CodeNamespaceImport e)
 
299
                {
 
300
                        Output.WriteLine("[CodeNamespaceImport: {0}]", e.ToString());
 
301
                }
 
302
                
 
303
                protected override void GenerateAttributeDeclarationsStart(CodeAttributeDeclarationCollection attributes)
 
304
                {
 
305
                        Output.WriteLine("[CodeAttributeDeclarationCollection: {0}]", attributes.ToString());
 
306
                }
 
307
                
 
308
                protected override void GenerateAttributeDeclarationsEnd(CodeAttributeDeclarationCollection attributes)
 
309
                {
 
310
                        Output.WriteLine("[CodeAttributeDeclarationCollection: {0}]", attributes.ToString());
 
311
                }
 
312
                
 
313
                protected override void GeneratePrimitiveExpression(CodePrimitiveExpression e)
 
314
                {
 
315
                        if (e.Value == null) {
 
316
                                Output.WriteLine("[CodePrimitiveExpression: null]");
 
317
                        } else {
 
318
                                Output.Write("[CodePrimitiveExpression: ");
 
319
                                base.GeneratePrimitiveExpression(e);
 
320
                                Output.WriteLine(" (" + e.Value.GetType().Name + ")]");
 
321
                        }
 
322
                }
 
323
                
 
324
                protected override bool Supports(GeneratorSupport support)
 
325
                {
 
326
                        return true;
 
327
                }
 
328
                
 
329
                protected override bool IsValidIdentifier(string value)
 
330
                {
 
331
                        return true;
 
332
                }
 
333
                
 
334
                protected override string CreateEscapedIdentifier(string value)
 
335
                {
 
336
                        return value;
 
337
                }
 
338
                
 
339
                protected override string CreateValidIdentifier(string value)
 
340
                {
 
341
                        return value;
 
342
                }
 
343
                
 
344
                protected override string GetTypeOutput(CodeTypeReference value)
 
345
                {
 
346
                        return value.ToString();
 
347
                }
 
348
                
 
349
                protected override string QuoteSnippetString(string value)
 
350
                {
 
351
                        return "\"" + value + "\"";
 
352
                }
 
353
                
 
354
                #endregion
 
355
        }
 
356
}