← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to contrib/NRefactory/Project/Src/Visitors/CodeDOMVerboseOutputGenerator.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

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