← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/Debugger/Debugger.Core/Interop/CorSymExtensionMethods.generated.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/Debugger/Debugger.Core/Interop/CorSymExtensionMethods.generated.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.Runtime.CompilerServices;
 
6
using System.Runtime.InteropServices;
 
7
 
 
8
namespace Debugger.Interop.CorSym
 
9
{
 
10
        public static partial class CorSymExtensionMethods
 
11
        {
 
12
                public static int GetReaderForFile(this CorSymBinder_SxSClass instance, object importer, IntPtr filename, IntPtr searchPath, ref object retVal)
 
13
                {
 
14
                        int returnValue = instance.__GetReaderForFile(importer, filename, searchPath, ref retVal);
 
15
                        ProcessOutParameter(retVal);
 
16
                        return returnValue;
 
17
                }
 
18
                
 
19
                public static ISymUnmanagedReader GetReaderFromStream(this CorSymBinder_SxSClass instance, object importer, IStream pstream)
 
20
                {
 
21
                        ISymUnmanagedReader returnValue = instance.__GetReaderFromStream(importer, pstream);
 
22
                        ProcessOutParameter(returnValue);
 
23
                        return returnValue;
 
24
                }
 
25
                
 
26
                public static ISymUnmanagedDocument GetDocument(this CorSymReader_SxSClass instance, IntPtr url, Guid language, Guid languageVendor, Guid documentType)
 
27
                {
 
28
                        ISymUnmanagedDocument returnValue = instance.__GetDocument(url, language, languageVendor, documentType);
 
29
                        ProcessOutParameter(returnValue);
 
30
                        return returnValue;
 
31
                }
 
32
                
 
33
                public static void GetDocuments(this CorSymReader_SxSClass instance, uint cDocs, out uint pcDocs, ISymUnmanagedDocument[] pDocs)
 
34
                {
 
35
                        instance.__GetDocuments(cDocs, out pcDocs, pDocs);
 
36
                        ProcessOutParameter(pDocs);
 
37
                }
 
38
                
 
39
                public static void GetDocumentVersion(this CorSymReader_SxSClass instance, ISymUnmanagedDocument pDoc, out int version, out int pbCurrent)
 
40
                {
 
41
                        instance.__GetDocumentVersion(pDoc, out version, out pbCurrent);
 
42
                }
 
43
                
 
44
                public static void GetGlobalVariables(this CorSymReader_SxSClass instance, uint cVars, out uint pcVars, IntPtr pVars)
 
45
                {
 
46
                        instance.__GetGlobalVariables(cVars, out pcVars, pVars);
 
47
                }
 
48
                
 
49
                public static ISymUnmanagedMethod GetMethod(this CorSymReader_SxSClass instance, uint token)
 
50
                {
 
51
                        ISymUnmanagedMethod returnValue = instance.__GetMethod(token);
 
52
                        ProcessOutParameter(returnValue);
 
53
                        return returnValue;
 
54
                }
 
55
                
 
56
                public static ISymUnmanagedMethod GetMethodByVersion(this CorSymReader_SxSClass instance, uint token, int version)
 
57
                {
 
58
                        ISymUnmanagedMethod returnValue = instance.__GetMethodByVersion(token, version);
 
59
                        ProcessOutParameter(returnValue);
 
60
                        return returnValue;
 
61
                }
 
62
                
 
63
                public static ISymUnmanagedMethod GetMethodFromDocumentPosition(this CorSymReader_SxSClass instance, ISymUnmanagedDocument document, uint line, uint column)
 
64
                {
 
65
                        ISymUnmanagedMethod returnValue = instance.__GetMethodFromDocumentPosition(document, line, column);
 
66
                        ProcessOutParameter(returnValue);
 
67
                        return returnValue;
 
68
                }
 
69
                
 
70
                public static void GetMethodsFromDocumentPosition(this CorSymReader_SxSClass instance, ISymUnmanagedDocument document, uint line, uint column, uint cMethod, out uint pcMethod, IntPtr pRetVal)
 
71
                {
 
72
                        instance.__GetMethodsFromDocumentPosition(document, line, column, cMethod, out pcMethod, pRetVal);
 
73
                }
 
74
                
 
75
                public static int GetMethodVersion(this CorSymReader_SxSClass instance, ISymUnmanagedMethod pMethod)
 
76
                {
 
77
                        int version;
 
78
                        instance.__GetMethodVersion(pMethod, out version);
 
79
                        return version;
 
80
                }
 
81
                
 
82
                public static void GetNamespaces(this CorSymReader_SxSClass instance, uint cNameSpaces, out uint pcNameSpaces, ISymUnmanagedNamespace[] namespaces)
 
83
                {
 
84
                        instance.__GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
 
85
                        ProcessOutParameter(namespaces);
 
86
                }
 
87
                
 
88
                public static void GetSymAttribute(this CorSymReader_SxSClass instance, uint parent, IntPtr name, uint cBuffer, out uint pcBuffer, IntPtr buffer)
 
89
                {
 
90
                        instance.__GetSymAttribute(parent, name, cBuffer, out pcBuffer, buffer);
 
91
                }
 
92
                
 
93
                public static void GetSymbolStoreFileName(this CorSymReader_SxSClass instance, uint cchName, out uint pcchName, IntPtr szName)
 
94
                {
 
95
                        instance.__GetSymbolStoreFileName(cchName, out pcchName, szName);
 
96
                }
 
97
                
 
98
                public static uint GetUserEntryPoint(this CorSymReader_SxSClass instance)
 
99
                {
 
100
                        return instance.__GetUserEntryPoint();
 
101
                }
 
102
                
 
103
                public static void GetVariables(this CorSymReader_SxSClass instance, uint parent, uint cVars, out uint pcVars, IntPtr pVars)
 
104
                {
 
105
                        instance.__GetVariables(parent, cVars, out pcVars, pVars);
 
106
                }
 
107
                
 
108
                public static void Initialize(this CorSymReader_SxSClass instance, object importer, IntPtr filename, IntPtr searchPath, IStream pIStream)
 
109
                {
 
110
                        instance.__Initialize(importer, filename, searchPath, pIStream);
 
111
                }
 
112
                
 
113
                public static void ReplaceSymbolStore(this CorSymReader_SxSClass instance, IntPtr filename, IStream pIStream)
 
114
                {
 
115
                        instance.__ReplaceSymbolStore(filename, pIStream);
 
116
                }
 
117
                
 
118
                public static void UpdateSymbolStore(this CorSymReader_SxSClass instance, IntPtr filename, IStream pIStream)
 
119
                {
 
120
                        instance.__UpdateSymbolStore(filename, pIStream);
 
121
                }
 
122
                
 
123
                public static void Abort(this CorSymWriter_SxSClass instance)
 
124
                {
 
125
                        instance.__Abort();
 
126
                }
 
127
                
 
128
                public static void Close(this CorSymWriter_SxSClass instance)
 
129
                {
 
130
                        instance.__Close();
 
131
                }
 
132
                
 
133
                public static void CloseMethod(this CorSymWriter_SxSClass instance)
 
134
                {
 
135
                        instance.__CloseMethod();
 
136
                }
 
137
                
 
138
                public static void CloseNamespace(this CorSymWriter_SxSClass instance)
 
139
                {
 
140
                        instance.__CloseNamespace();
 
141
                }
 
142
                
 
143
                public static void CloseScope(this CorSymWriter_SxSClass instance, uint endOffset)
 
144
                {
 
145
                        instance.__CloseScope(endOffset);
 
146
                }
 
147
                
 
148
                public static void DefineConstant(this CorSymWriter_SxSClass instance, IntPtr name, object value, uint cSig, ref byte signature)
 
149
                {
 
150
                        instance.__DefineConstant(name, value, cSig, ref signature);
 
151
                        ProcessOutParameter(signature);
 
152
                }
 
153
                
 
154
                public static ISymUnmanagedDocumentWriter DefineDocument(this CorSymWriter_SxSClass instance, IntPtr url, ref Guid language, ref Guid languageVendor, ref Guid documentType)
 
155
                {
 
156
                        ISymUnmanagedDocumentWriter returnValue = instance.__DefineDocument(url, ref language, ref languageVendor, ref documentType);
 
157
                        ProcessOutParameter(returnValue);
 
158
                        return returnValue;
 
159
                }
 
160
                
 
161
                public static void DefineField(this CorSymWriter_SxSClass instance, uint parent, IntPtr name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
 
162
                {
 
163
                        instance.__DefineField(parent, name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
 
164
                        ProcessOutParameter(signature);
 
165
                }
 
166
                
 
167
                public static void DefineGlobalVariable(this CorSymWriter_SxSClass instance, IntPtr name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
 
168
                {
 
169
                        instance.__DefineGlobalVariable(name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
 
170
                        ProcessOutParameter(signature);
 
171
                }
 
172
                
 
173
                public static void DefineLocalVariable(this CorSymWriter_SxSClass instance, IntPtr name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3, uint startOffset,
 
174
                uint endOffset)
 
175
                {
 
176
                        instance.__DefineLocalVariable(name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3, startOffset, endOffset);
 
177
                        ProcessOutParameter(signature);
 
178
                }
 
179
                
 
180
                public static void DefineParameter(this CorSymWriter_SxSClass instance, IntPtr name, uint attributes, uint sequence, uint addrKind, uint addr1, uint addr2, uint addr3)
 
181
                {
 
182
                        instance.__DefineParameter(name, attributes, sequence, addrKind, addr1, addr2, addr3);
 
183
                }
 
184
                
 
185
                public static void DefineSequencePoints(this CorSymWriter_SxSClass instance, ISymUnmanagedDocumentWriter document, uint spCount, ref uint offsets, ref uint lines, ref uint columns, ref uint endLines, ref uint endColumns)
 
186
                {
 
187
                        instance.__DefineSequencePoints(document, spCount, ref offsets, ref lines, ref columns, ref endLines, ref endColumns);
 
188
                }
 
189
                
 
190
                public static void GetDebugInfo(this CorSymWriter_SxSClass instance, ref uint pIDD, uint cData, out uint pcData, IntPtr data)
 
191
                {
 
192
                        instance.__GetDebugInfo(ref pIDD, cData, out pcData, data);
 
193
                }
 
194
                
 
195
                public static void Initialize(this CorSymWriter_SxSClass instance, object emitter, IntPtr filename, IStream pIStream, int fFullBuild)
 
196
                {
 
197
                        instance.__Initialize(emitter, filename, pIStream, fFullBuild);
 
198
                }
 
199
                
 
200
                public static void Initialize2(this CorSymWriter_SxSClass instance, object emitter, IntPtr tempfilename, IStream pIStream, int fFullBuild, IntPtr finalfilename)
 
201
                {
 
202
                        instance.__Initialize2(emitter, tempfilename, pIStream, fFullBuild, finalfilename);
 
203
                }
 
204
                
 
205
                public static void OpenMethod(this CorSymWriter_SxSClass instance, uint method)
 
206
                {
 
207
                        instance.__OpenMethod(method);
 
208
                }
 
209
                
 
210
                public static void OpenNamespace(this CorSymWriter_SxSClass instance, IntPtr name)
 
211
                {
 
212
                        instance.__OpenNamespace(name);
 
213
                }
 
214
                
 
215
                public static uint OpenScope(this CorSymWriter_SxSClass instance, uint startOffset)
 
216
                {
 
217
                        return instance.__OpenScope(startOffset);
 
218
                }
 
219
                
 
220
                public static void RemapToken(this CorSymWriter_SxSClass instance, uint oldToken, uint newToken)
 
221
                {
 
222
                        instance.__RemapToken(oldToken, newToken);
 
223
                }
 
224
                
 
225
                public static void SetMethodSourceRange(this CorSymWriter_SxSClass instance, ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, ISymUnmanagedDocumentWriter endDoc, uint endLine, uint endColumn)
 
226
                {
 
227
                        instance.__SetMethodSourceRange(startDoc, startLine, startColumn, endDoc, endLine, endColumn);
 
228
                }
 
229
                
 
230
                public static void SetScopeRange(this CorSymWriter_SxSClass instance, uint scopeID, uint startOffset, uint endOffset)
 
231
                {
 
232
                        instance.__SetScopeRange(scopeID, startOffset, endOffset);
 
233
                }
 
234
                
 
235
                public static void SetSymAttribute(this CorSymWriter_SxSClass instance, uint parent, IntPtr name, uint cData, ref byte data)
 
236
                {
 
237
                        instance.__SetSymAttribute(parent, name, cData, ref data);
 
238
                        ProcessOutParameter(data);
 
239
                }
 
240
                
 
241
                public static void SetUserEntryPoint(this CorSymWriter_SxSClass instance, uint entryMethod)
 
242
                {
 
243
                        instance.__SetUserEntryPoint(entryMethod);
 
244
                }
 
245
                
 
246
                public static void UsingNamespace(this CorSymWriter_SxSClass instance, IntPtr fullName)
 
247
                {
 
248
                        instance.__UsingNamespace(fullName);
 
249
                }
 
250
                
 
251
                public static int GetReaderForFile(this ISymUnmanagedBinder instance, object importer, IntPtr filename, IntPtr searchPath, ref object retVal)
 
252
                {
 
253
                        int returnValue = instance.__GetReaderForFile(importer, filename, searchPath, ref retVal);
 
254
                        ProcessOutParameter(retVal);
 
255
                        return returnValue;
 
256
                }
 
257
                
 
258
                public static ISymUnmanagedReader GetReaderFromStream(this ISymUnmanagedBinder instance, object importer, IStream pstream)
 
259
                {
 
260
                        ISymUnmanagedReader returnValue = instance.__GetReaderFromStream(importer, pstream);
 
261
                        ProcessOutParameter(returnValue);
 
262
                        return returnValue;
 
263
                }
 
264
                
 
265
                public static void Destroy(this ISymUnmanagedDispose instance)
 
266
                {
 
267
                        instance.__Destroy();
 
268
                }
 
269
                
 
270
                public static void GetURL(this ISymUnmanagedDocument instance, uint cchUrl, out uint pcchUrl, IntPtr szUrl)
 
271
                {
 
272
                        instance.__GetURL(cchUrl, out pcchUrl, szUrl);
 
273
                }
 
274
                
 
275
                public static Guid GetDocumentType(this ISymUnmanagedDocument instance)
 
276
                {
 
277
                        return instance.__GetDocumentType();
 
278
                }
 
279
                
 
280
                public static Guid GetLanguage(this ISymUnmanagedDocument instance)
 
281
                {
 
282
                        return instance.__GetLanguage();
 
283
                }
 
284
                
 
285
                public static Guid GetLanguageVendor(this ISymUnmanagedDocument instance)
 
286
                {
 
287
                        return instance.__GetLanguageVendor();
 
288
                }
 
289
                
 
290
                public static Guid GetCheckSumAlgorithmId(this ISymUnmanagedDocument instance)
 
291
                {
 
292
                        return instance.__GetCheckSumAlgorithmId();
 
293
                }
 
294
                
 
295
                public static void GetCheckSum(this ISymUnmanagedDocument instance, uint cData, out uint pcData, IntPtr data)
 
296
                {
 
297
                        instance.__GetCheckSum(cData, out pcData, data);
 
298
                }
 
299
                
 
300
                public static uint FindClosestLine(this ISymUnmanagedDocument instance, uint line)
 
301
                {
 
302
                        return instance.__FindClosestLine(line);
 
303
                }
 
304
                
 
305
                public static int HasEmbeddedSource(this ISymUnmanagedDocument instance)
 
306
                {
 
307
                        return instance.__HasEmbeddedSource();
 
308
                }
 
309
                
 
310
                public static uint GetSourceLength(this ISymUnmanagedDocument instance)
 
311
                {
 
312
                        return instance.__GetSourceLength();
 
313
                }
 
314
                
 
315
                public static void GetSourceRange(this ISymUnmanagedDocument instance, uint startLine, uint startColumn, uint endLine, uint endColumn, uint cSourceBytes, out uint pcSourceBytes, IntPtr source)
 
316
                {
 
317
                        instance.__GetSourceRange(startLine, startColumn, endLine, endColumn, cSourceBytes, out pcSourceBytes, source);
 
318
                }
 
319
                
 
320
                public static void SetSource(this ISymUnmanagedDocumentWriter instance, uint sourceSize, ref byte source)
 
321
                {
 
322
                        instance.__SetSource(sourceSize, ref source);
 
323
                        ProcessOutParameter(source);
 
324
                }
 
325
                
 
326
                public static void SetCheckSum(this ISymUnmanagedDocumentWriter instance, Guid algorithmId, uint checkSumSize, ref byte checkSum)
 
327
                {
 
328
                        instance.__SetCheckSum(algorithmId, checkSumSize, ref checkSum);
 
329
                        ProcessOutParameter(checkSum);
 
330
                }
 
331
                
 
332
                public static uint GetToken(this ISymUnmanagedMethod instance)
 
333
                {
 
334
                        return instance.__GetToken();
 
335
                }
 
336
                
 
337
                public static uint GetSequencePointCount(this ISymUnmanagedMethod instance)
 
338
                {
 
339
                        return instance.__GetSequencePointCount();
 
340
                }
 
341
                
 
342
                public static ISymUnmanagedScope GetRootScope(this ISymUnmanagedMethod instance)
 
343
                {
 
344
                        ISymUnmanagedScope returnValue = instance.__GetRootScope();
 
345
                        ProcessOutParameter(returnValue);
 
346
                        return returnValue;
 
347
                }
 
348
                
 
349
                public static ISymUnmanagedScope GetScopeFromOffset(this ISymUnmanagedMethod instance, uint offset)
 
350
                {
 
351
                        ISymUnmanagedScope returnValue = instance.__GetScopeFromOffset(offset);
 
352
                        ProcessOutParameter(returnValue);
 
353
                        return returnValue;
 
354
                }
 
355
                
 
356
                public static uint GetOffset(this ISymUnmanagedMethod instance, ISymUnmanagedDocument document, uint line, uint column)
 
357
                {
 
358
                        return instance.__GetOffset(document, line, column);
 
359
                }
 
360
                
 
361
                public static void GetRanges(this ISymUnmanagedMethod instance, ISymUnmanagedDocument document, uint line, uint column, uint cRanges, out uint pcRanges, IntPtr ranges)
 
362
                {
 
363
                        instance.__GetRanges(document, line, column, cRanges, out pcRanges, ranges);
 
364
                }
 
365
                
 
366
                public static void GetParameters(this ISymUnmanagedMethod instance, uint cParams, out uint pcParams, IntPtr @params)
 
367
                {
 
368
                        instance.__GetParameters(cParams, out pcParams, @params);
 
369
                }
 
370
                
 
371
                public static ISymUnmanagedNamespace GetNamespace(this ISymUnmanagedMethod instance)
 
372
                {
 
373
                        ISymUnmanagedNamespace pRetVal;
 
374
                        instance.__GetNamespace(out pRetVal);
 
375
                        ProcessOutParameter(pRetVal);
 
376
                        return pRetVal;
 
377
                }
 
378
                
 
379
                public static int GetSourceStartEnd(this ISymUnmanagedMethod instance, ISymUnmanagedDocument[] docs, uint[] lines, uint[] columns)
 
380
                {
 
381
                        int pRetVal;
 
382
                        instance.__GetSourceStartEnd(docs, lines, columns, out pRetVal);
 
383
                        ProcessOutParameter(docs);
 
384
                        return pRetVal;
 
385
                }
 
386
                
 
387
                public static void GetSequencePoints(this ISymUnmanagedMethod instance, uint cPoints, out uint pcPoints, uint[] offsets, ISymUnmanagedDocument[] documents, uint[] lines, uint[] columns, uint[] endLines, uint[] endColumns)
 
388
                {
 
389
                        instance.__GetSequencePoints(cPoints, out pcPoints, offsets, documents, lines, columns, endLines, endColumns);
 
390
                        ProcessOutParameter(documents);
 
391
                }
 
392
                
 
393
                public static void GetName(this ISymUnmanagedNamespace instance, uint cchName, out uint pcchName, IntPtr szName)
 
394
                {
 
395
                        instance.__GetName(cchName, out pcchName, szName);
 
396
                }
 
397
                
 
398
                public static void GetNamespaces(this ISymUnmanagedNamespace instance, uint cNameSpaces, out uint pcNameSpaces, IntPtr namespaces)
 
399
                {
 
400
                        instance.__GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
 
401
                }
 
402
                
 
403
                public static void GetVariables(this ISymUnmanagedNamespace instance, uint cVars, out uint pcVars, IntPtr pVars)
 
404
                {
 
405
                        instance.__GetVariables(cVars, out pcVars, pVars);
 
406
                }
 
407
                
 
408
                public static ISymUnmanagedDocument GetDocument(this ISymUnmanagedReader instance, IntPtr url, Guid language, Guid languageVendor, Guid documentType)
 
409
                {
 
410
                        ISymUnmanagedDocument returnValue = instance.__GetDocument(url, language, languageVendor, documentType);
 
411
                        ProcessOutParameter(returnValue);
 
412
                        return returnValue;
 
413
                }
 
414
                
 
415
                public static void GetDocuments(this ISymUnmanagedReader instance, uint cDocs, out uint pcDocs, ISymUnmanagedDocument[] pDocs)
 
416
                {
 
417
                        instance.__GetDocuments(cDocs, out pcDocs, pDocs);
 
418
                        ProcessOutParameter(pDocs);
 
419
                }
 
420
                
 
421
                public static uint GetUserEntryPoint(this ISymUnmanagedReader instance)
 
422
                {
 
423
                        return instance.__GetUserEntryPoint();
 
424
                }
 
425
                
 
426
                public static ISymUnmanagedMethod GetMethod(this ISymUnmanagedReader instance, uint token)
 
427
                {
 
428
                        ISymUnmanagedMethod returnValue = instance.__GetMethod(token);
 
429
                        ProcessOutParameter(returnValue);
 
430
                        return returnValue;
 
431
                }
 
432
                
 
433
                public static ISymUnmanagedMethod GetMethodByVersion(this ISymUnmanagedReader instance, uint token, int version)
 
434
                {
 
435
                        ISymUnmanagedMethod returnValue = instance.__GetMethodByVersion(token, version);
 
436
                        ProcessOutParameter(returnValue);
 
437
                        return returnValue;
 
438
                }
 
439
                
 
440
                public static void GetVariables(this ISymUnmanagedReader instance, uint parent, uint cVars, out uint pcVars, IntPtr pVars)
 
441
                {
 
442
                        instance.__GetVariables(parent, cVars, out pcVars, pVars);
 
443
                }
 
444
                
 
445
                public static void GetGlobalVariables(this ISymUnmanagedReader instance, uint cVars, out uint pcVars, IntPtr pVars)
 
446
                {
 
447
                        instance.__GetGlobalVariables(cVars, out pcVars, pVars);
 
448
                }
 
449
                
 
450
                public static ISymUnmanagedMethod GetMethodFromDocumentPosition(this ISymUnmanagedReader instance, ISymUnmanagedDocument document, uint line, uint column)
 
451
                {
 
452
                        ISymUnmanagedMethod returnValue = instance.__GetMethodFromDocumentPosition(document, line, column);
 
453
                        ProcessOutParameter(returnValue);
 
454
                        return returnValue;
 
455
                }
 
456
                
 
457
                public static void GetSymAttribute(this ISymUnmanagedReader instance, uint parent, IntPtr name, uint cBuffer, out uint pcBuffer, IntPtr buffer)
 
458
                {
 
459
                        instance.__GetSymAttribute(parent, name, cBuffer, out pcBuffer, buffer);
 
460
                }
 
461
                
 
462
                public static void GetNamespaces(this ISymUnmanagedReader instance, uint cNameSpaces, out uint pcNameSpaces, ISymUnmanagedNamespace[] namespaces)
 
463
                {
 
464
                        instance.__GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
 
465
                        ProcessOutParameter(namespaces);
 
466
                }
 
467
                
 
468
                public static void Initialize(this ISymUnmanagedReader instance, object importer, IntPtr filename, IntPtr searchPath, IStream pIStream)
 
469
                {
 
470
                        instance.__Initialize(importer, filename, searchPath, pIStream);
 
471
                }
 
472
                
 
473
                public static void UpdateSymbolStore(this ISymUnmanagedReader instance, IntPtr filename, IStream pIStream)
 
474
                {
 
475
                        instance.__UpdateSymbolStore(filename, pIStream);
 
476
                }
 
477
                
 
478
                public static void ReplaceSymbolStore(this ISymUnmanagedReader instance, IntPtr filename, IStream pIStream)
 
479
                {
 
480
                        instance.__ReplaceSymbolStore(filename, pIStream);
 
481
                }
 
482
                
 
483
                public static void GetSymbolStoreFileName(this ISymUnmanagedReader instance, uint cchName, out uint pcchName, IntPtr szName)
 
484
                {
 
485
                        instance.__GetSymbolStoreFileName(cchName, out pcchName, szName);
 
486
                }
 
487
                
 
488
                public static void GetMethodsFromDocumentPosition(this ISymUnmanagedReader instance, ISymUnmanagedDocument document, uint line, uint column, uint cMethod, out uint pcMethod, IntPtr pRetVal)
 
489
                {
 
490
                        instance.__GetMethodsFromDocumentPosition(document, line, column, cMethod, out pcMethod, pRetVal);
 
491
                }
 
492
                
 
493
                public static void GetDocumentVersion(this ISymUnmanagedReader instance, ISymUnmanagedDocument pDoc, out int version, out int pbCurrent)
 
494
                {
 
495
                        instance.__GetDocumentVersion(pDoc, out version, out pbCurrent);
 
496
                }
 
497
                
 
498
                public static int GetMethodVersion(this ISymUnmanagedReader instance, ISymUnmanagedMethod pMethod)
 
499
                {
 
500
                        int version;
 
501
                        instance.__GetMethodVersion(pMethod, out version);
 
502
                        return version;
 
503
                }
 
504
                
 
505
                public static uint GetSymbolSearchInfoCount(this ISymUnmanagedReaderSymbolSearchInfo instance)
 
506
                {
 
507
                        uint pcSearchInfo;
 
508
                        instance.__GetSymbolSearchInfoCount(out pcSearchInfo);
 
509
                        return pcSearchInfo;
 
510
                }
 
511
                
 
512
                public static void GetSymbolSearchInfo(this ISymUnmanagedReaderSymbolSearchInfo instance, uint cSearchInfo, out uint pcSearchInfo, out ISymUnmanagedSymbolSearchInfo rgpSearchInfo)
 
513
                {
 
514
                        instance.__GetSymbolSearchInfo(cSearchInfo, out pcSearchInfo, out rgpSearchInfo);
 
515
                        ProcessOutParameter(rgpSearchInfo);
 
516
                }
 
517
                
 
518
                public static ISymUnmanagedMethod GetMethod(this ISymUnmanagedScope instance)
 
519
                {
 
520
                        ISymUnmanagedMethod returnValue = instance.__GetMethod();
 
521
                        ProcessOutParameter(returnValue);
 
522
                        return returnValue;
 
523
                }
 
524
                
 
525
                public static ISymUnmanagedScope GetParent(this ISymUnmanagedScope instance)
 
526
                {
 
527
                        ISymUnmanagedScope returnValue = instance.__GetParent();
 
528
                        ProcessOutParameter(returnValue);
 
529
                        return returnValue;
 
530
                }
 
531
                
 
532
                public static void GetChildren(this ISymUnmanagedScope instance, uint cChildren, out uint pcChildren, ISymUnmanagedScope[] children)
 
533
                {
 
534
                        instance.__GetChildren(cChildren, out pcChildren, children);
 
535
                        ProcessOutParameter(children);
 
536
                }
 
537
                
 
538
                public static uint GetStartOffset(this ISymUnmanagedScope instance)
 
539
                {
 
540
                        return instance.__GetStartOffset();
 
541
                }
 
542
                
 
543
                public static uint GetEndOffset(this ISymUnmanagedScope instance)
 
544
                {
 
545
                        return instance.__GetEndOffset();
 
546
                }
 
547
                
 
548
                public static uint GetLocalCount(this ISymUnmanagedScope instance)
 
549
                {
 
550
                        return instance.__GetLocalCount();
 
551
                }
 
552
                
 
553
                public static void GetLocals(this ISymUnmanagedScope instance, uint cLocals, out uint pcLocals, ISymUnmanagedVariable[] locals)
 
554
                {
 
555
                        instance.__GetLocals(cLocals, out pcLocals, locals);
 
556
                        ProcessOutParameter(locals);
 
557
                }
 
558
                
 
559
                public static void GetNamespaces(this ISymUnmanagedScope instance, uint cNameSpaces, out uint pcNameSpaces, ISymUnmanagedNamespace[] namespaces)
 
560
                {
 
561
                        instance.__GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
 
562
                        ProcessOutParameter(namespaces);
 
563
                }
 
564
                
 
565
                public static uint GetSearchPathLength(this ISymUnmanagedSymbolSearchInfo instance)
 
566
                {
 
567
                        uint pcchPath;
 
568
                        instance.__GetSearchPathLength(out pcchPath);
 
569
                        return pcchPath;
 
570
                }
 
571
                
 
572
                public static void GetSearchPath(this ISymUnmanagedSymbolSearchInfo instance, uint cchPath, out uint pcchPath, IntPtr szPath)
 
573
                {
 
574
                        instance.__GetSearchPath(cchPath, out pcchPath, szPath);
 
575
                }
 
576
                
 
577
                public static int GetHRESULT(this ISymUnmanagedSymbolSearchInfo instance)
 
578
                {
 
579
                        int phr;
 
580
                        instance.__GetHRESULT(out phr);
 
581
                        return phr;
 
582
                }
 
583
                
 
584
                public static void GetName(this ISymUnmanagedVariable instance, uint cchName, out uint pcchName, IntPtr szName)
 
585
                {
 
586
                        instance.__GetName(cchName, out pcchName, szName);
 
587
                }
 
588
                
 
589
                public static uint GetAttributes(this ISymUnmanagedVariable instance)
 
590
                {
 
591
                        return instance.__GetAttributes();
 
592
                }
 
593
                
 
594
                public static void GetSignature(this ISymUnmanagedVariable instance, uint cSig, out uint pcSig, IntPtr sig)
 
595
                {
 
596
                        instance.__GetSignature(cSig, out pcSig, sig);
 
597
                }
 
598
                
 
599
                public static uint GetAddressKind(this ISymUnmanagedVariable instance)
 
600
                {
 
601
                        return instance.__GetAddressKind();
 
602
                }
 
603
                
 
604
                public static uint GetAddressField1(this ISymUnmanagedVariable instance)
 
605
                {
 
606
                        return instance.__GetAddressField1();
 
607
                }
 
608
                
 
609
                public static uint GetAddressField2(this ISymUnmanagedVariable instance)
 
610
                {
 
611
                        return instance.__GetAddressField2();
 
612
                }
 
613
                
 
614
                public static uint GetAddressField3(this ISymUnmanagedVariable instance)
 
615
                {
 
616
                        return instance.__GetAddressField3();
 
617
                }
 
618
                
 
619
                public static uint GetStartOffset(this ISymUnmanagedVariable instance)
 
620
                {
 
621
                        return instance.__GetStartOffset();
 
622
                }
 
623
                
 
624
                public static uint GetEndOffset(this ISymUnmanagedVariable instance)
 
625
                {
 
626
                        return instance.__GetEndOffset();
 
627
                }
 
628
                
 
629
                public static ISymUnmanagedDocumentWriter DefineDocument(this ISymUnmanagedWriter instance, IntPtr url, ref Guid language, ref Guid languageVendor, ref Guid documentType)
 
630
                {
 
631
                        ISymUnmanagedDocumentWriter returnValue = instance.__DefineDocument(url, ref language, ref languageVendor, ref documentType);
 
632
                        ProcessOutParameter(returnValue);
 
633
                        return returnValue;
 
634
                }
 
635
                
 
636
                public static void SetUserEntryPoint(this ISymUnmanagedWriter instance, uint entryMethod)
 
637
                {
 
638
                        instance.__SetUserEntryPoint(entryMethod);
 
639
                }
 
640
                
 
641
                public static void OpenMethod(this ISymUnmanagedWriter instance, uint method)
 
642
                {
 
643
                        instance.__OpenMethod(method);
 
644
                }
 
645
                
 
646
                public static void CloseMethod(this ISymUnmanagedWriter instance)
 
647
                {
 
648
                        instance.__CloseMethod();
 
649
                }
 
650
                
 
651
                public static uint OpenScope(this ISymUnmanagedWriter instance, uint startOffset)
 
652
                {
 
653
                        return instance.__OpenScope(startOffset);
 
654
                }
 
655
                
 
656
                public static void CloseScope(this ISymUnmanagedWriter instance, uint endOffset)
 
657
                {
 
658
                        instance.__CloseScope(endOffset);
 
659
                }
 
660
                
 
661
                public static void SetScopeRange(this ISymUnmanagedWriter instance, uint scopeID, uint startOffset, uint endOffset)
 
662
                {
 
663
                        instance.__SetScopeRange(scopeID, startOffset, endOffset);
 
664
                }
 
665
                
 
666
                public static void DefineLocalVariable(this ISymUnmanagedWriter instance, IntPtr name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3, uint startOffset,
 
667
                uint endOffset)
 
668
                {
 
669
                        instance.__DefineLocalVariable(name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3, startOffset, endOffset);
 
670
                        ProcessOutParameter(signature);
 
671
                }
 
672
                
 
673
                public static void DefineParameter(this ISymUnmanagedWriter instance, IntPtr name, uint attributes, uint sequence, uint addrKind, uint addr1, uint addr2, uint addr3)
 
674
                {
 
675
                        instance.__DefineParameter(name, attributes, sequence, addrKind, addr1, addr2, addr3);
 
676
                }
 
677
                
 
678
                public static void DefineField(this ISymUnmanagedWriter instance, uint parent, IntPtr name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
 
679
                {
 
680
                        instance.__DefineField(parent, name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
 
681
                        ProcessOutParameter(signature);
 
682
                }
 
683
                
 
684
                public static void DefineGlobalVariable(this ISymUnmanagedWriter instance, IntPtr name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
 
685
                {
 
686
                        instance.__DefineGlobalVariable(name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
 
687
                        ProcessOutParameter(signature);
 
688
                }
 
689
                
 
690
                public static void Close(this ISymUnmanagedWriter instance)
 
691
                {
 
692
                        instance.__Close();
 
693
                }
 
694
                
 
695
                public static void SetSymAttribute(this ISymUnmanagedWriter instance, uint parent, IntPtr name, uint cData, ref byte data)
 
696
                {
 
697
                        instance.__SetSymAttribute(parent, name, cData, ref data);
 
698
                        ProcessOutParameter(data);
 
699
                }
 
700
                
 
701
                public static void OpenNamespace(this ISymUnmanagedWriter instance, IntPtr name)
 
702
                {
 
703
                        instance.__OpenNamespace(name);
 
704
                }
 
705
                
 
706
                public static void CloseNamespace(this ISymUnmanagedWriter instance)
 
707
                {
 
708
                        instance.__CloseNamespace();
 
709
                }
 
710
                
 
711
                public static void UsingNamespace(this ISymUnmanagedWriter instance, IntPtr fullName)
 
712
                {
 
713
                        instance.__UsingNamespace(fullName);
 
714
                }
 
715
                
 
716
                public static void SetMethodSourceRange(this ISymUnmanagedWriter instance, ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, ISymUnmanagedDocumentWriter endDoc, uint endLine, uint endColumn)
 
717
                {
 
718
                        instance.__SetMethodSourceRange(startDoc, startLine, startColumn, endDoc, endLine, endColumn);
 
719
                }
 
720
                
 
721
                public static void Initialize(this ISymUnmanagedWriter instance, object emitter, IntPtr filename, IStream pIStream, int fFullBuild)
 
722
                {
 
723
                        instance.__Initialize(emitter, filename, pIStream, fFullBuild);
 
724
                }
 
725
                
 
726
                public static void GetDebugInfo(this ISymUnmanagedWriter instance, ref uint pIDD, uint cData, out uint pcData, IntPtr data)
 
727
                {
 
728
                        instance.__GetDebugInfo(ref pIDD, cData, out pcData, data);
 
729
                }
 
730
                
 
731
                public static void DefineSequencePoints(this ISymUnmanagedWriter instance, ISymUnmanagedDocumentWriter document, uint spCount, ref uint offsets, ref uint lines, ref uint columns, ref uint endLines, ref uint endColumns)
 
732
                {
 
733
                        instance.__DefineSequencePoints(document, spCount, ref offsets, ref lines, ref columns, ref endLines, ref endColumns);
 
734
                }
 
735
                
 
736
                public static void RemapToken(this ISymUnmanagedWriter instance, uint oldToken, uint newToken)
 
737
                {
 
738
                        instance.__RemapToken(oldToken, newToken);
 
739
                }
 
740
                
 
741
                public static void Initialize2(this ISymUnmanagedWriter instance, object emitter, IntPtr tempfilename, IStream pIStream, int fFullBuild, IntPtr finalfilename)
 
742
                {
 
743
                        instance.__Initialize2(emitter, tempfilename, pIStream, fFullBuild, finalfilename);
 
744
                }
 
745
                
 
746
                public static void DefineConstant(this ISymUnmanagedWriter instance, IntPtr name, object value, uint cSig, ref byte signature)
 
747
                {
 
748
                        instance.__DefineConstant(name, value, cSig, ref signature);
 
749
                        ProcessOutParameter(signature);
 
750
                }
 
751
                
 
752
                public static void Abort(this ISymUnmanagedWriter instance)
 
753
                {
 
754
                        instance.__Abort();
 
755
                }
 
756
                
 
757
                public static ISymUnmanagedDocumentWriter DefineDocument(this ISymUnmanagedWriter2 instance, IntPtr url, ref Guid language, ref Guid languageVendor, ref Guid documentType)
 
758
                {
 
759
                        ISymUnmanagedDocumentWriter returnValue = instance.__DefineDocument(url, ref language, ref languageVendor, ref documentType);
 
760
                        ProcessOutParameter(returnValue);
 
761
                        return returnValue;
 
762
                }
 
763
                
 
764
                public static void SetUserEntryPoint(this ISymUnmanagedWriter2 instance, uint entryMethod)
 
765
                {
 
766
                        instance.__SetUserEntryPoint(entryMethod);
 
767
                }
 
768
                
 
769
                public static void OpenMethod(this ISymUnmanagedWriter2 instance, uint method)
 
770
                {
 
771
                        instance.__OpenMethod(method);
 
772
                }
 
773
                
 
774
                public static void CloseMethod(this ISymUnmanagedWriter2 instance)
 
775
                {
 
776
                        instance.__CloseMethod();
 
777
                }
 
778
                
 
779
                public static uint OpenScope(this ISymUnmanagedWriter2 instance, uint startOffset)
 
780
                {
 
781
                        return instance.__OpenScope(startOffset);
 
782
                }
 
783
                
 
784
                public static void CloseScope(this ISymUnmanagedWriter2 instance, uint endOffset)
 
785
                {
 
786
                        instance.__CloseScope(endOffset);
 
787
                }
 
788
                
 
789
                public static void SetScopeRange(this ISymUnmanagedWriter2 instance, uint scopeID, uint startOffset, uint endOffset)
 
790
                {
 
791
                        instance.__SetScopeRange(scopeID, startOffset, endOffset);
 
792
                }
 
793
                
 
794
                public static void DefineLocalVariable(this ISymUnmanagedWriter2 instance, IntPtr name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3, uint startOffset,
 
795
                uint endOffset)
 
796
                {
 
797
                        instance.__DefineLocalVariable(name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3, startOffset, endOffset);
 
798
                        ProcessOutParameter(signature);
 
799
                }
 
800
                
 
801
                public static void DefineParameter(this ISymUnmanagedWriter2 instance, IntPtr name, uint attributes, uint sequence, uint addrKind, uint addr1, uint addr2, uint addr3)
 
802
                {
 
803
                        instance.__DefineParameter(name, attributes, sequence, addrKind, addr1, addr2, addr3);
 
804
                }
 
805
                
 
806
                public static void DefineField(this ISymUnmanagedWriter2 instance, uint parent, IntPtr name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
 
807
                {
 
808
                        instance.__DefineField(parent, name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
 
809
                        ProcessOutParameter(signature);
 
810
                }
 
811
                
 
812
                public static void DefineGlobalVariable(this ISymUnmanagedWriter2 instance, IntPtr name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
 
813
                {
 
814
                        instance.__DefineGlobalVariable(name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
 
815
                        ProcessOutParameter(signature);
 
816
                }
 
817
                
 
818
                public static void Close(this ISymUnmanagedWriter2 instance)
 
819
                {
 
820
                        instance.__Close();
 
821
                }
 
822
                
 
823
                public static void SetSymAttribute(this ISymUnmanagedWriter2 instance, uint parent, IntPtr name, uint cData, ref byte data)
 
824
                {
 
825
                        instance.__SetSymAttribute(parent, name, cData, ref data);
 
826
                        ProcessOutParameter(data);
 
827
                }
 
828
                
 
829
                public static void OpenNamespace(this ISymUnmanagedWriter2 instance, IntPtr name)
 
830
                {
 
831
                        instance.__OpenNamespace(name);
 
832
                }
 
833
                
 
834
                public static void CloseNamespace(this ISymUnmanagedWriter2 instance)
 
835
                {
 
836
                        instance.__CloseNamespace();
 
837
                }
 
838
                
 
839
                public static void UsingNamespace(this ISymUnmanagedWriter2 instance, IntPtr fullName)
 
840
                {
 
841
                        instance.__UsingNamespace(fullName);
 
842
                }
 
843
                
 
844
                public static void SetMethodSourceRange(this ISymUnmanagedWriter2 instance, ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, ISymUnmanagedDocumentWriter endDoc, uint endLine, uint endColumn)
 
845
                {
 
846
                        instance.__SetMethodSourceRange(startDoc, startLine, startColumn, endDoc, endLine, endColumn);
 
847
                }
 
848
                
 
849
                public static void Initialize(this ISymUnmanagedWriter2 instance, object emitter, IntPtr filename, IStream pIStream, int fFullBuild)
 
850
                {
 
851
                        instance.__Initialize(emitter, filename, pIStream, fFullBuild);
 
852
                }
 
853
                
 
854
                public static void GetDebugInfo(this ISymUnmanagedWriter2 instance, ref uint pIDD, uint cData, out uint pcData, IntPtr data)
 
855
                {
 
856
                        instance.__GetDebugInfo(ref pIDD, cData, out pcData, data);
 
857
                }
 
858
                
 
859
                public static void DefineSequencePoints(this ISymUnmanagedWriter2 instance, ISymUnmanagedDocumentWriter document, uint spCount, ref uint offsets, ref uint lines, ref uint columns, ref uint endLines, ref uint endColumns)
 
860
                {
 
861
                        instance.__DefineSequencePoints(document, spCount, ref offsets, ref lines, ref columns, ref endLines, ref endColumns);
 
862
                }
 
863
                
 
864
                public static void RemapToken(this ISymUnmanagedWriter2 instance, uint oldToken, uint newToken)
 
865
                {
 
866
                        instance.__RemapToken(oldToken, newToken);
 
867
                }
 
868
                
 
869
                public static void Initialize2(this ISymUnmanagedWriter2 instance, object emitter, IntPtr tempfilename, IStream pIStream, int fFullBuild, IntPtr finalfilename)
 
870
                {
 
871
                        instance.__Initialize2(emitter, tempfilename, pIStream, fFullBuild, finalfilename);
 
872
                }
 
873
                
 
874
                public static void DefineConstant(this ISymUnmanagedWriter2 instance, IntPtr name, object value, uint cSig, ref byte signature)
 
875
                {
 
876
                        instance.__DefineConstant(name, value, cSig, ref signature);
 
877
                        ProcessOutParameter(signature);
 
878
                }
 
879
                
 
880
                public static void Abort(this ISymUnmanagedWriter2 instance)
 
881
                {
 
882
                        instance.__Abort();
 
883
                }
 
884
                
 
885
                public static void DefineLocalVariable2(this ISymUnmanagedWriter2 instance, IntPtr name, uint attributes, uint sigToken, uint addrKind, uint addr1, uint addr2, uint addr3, uint startOffset, uint endOffset)
 
886
                {
 
887
                        instance.__DefineLocalVariable2(name, attributes, sigToken, addrKind, addr1, addr2, addr3, startOffset, endOffset);
 
888
                }
 
889
                
 
890
                public static void DefineGlobalVariable2(this ISymUnmanagedWriter2 instance, IntPtr name, uint attributes, uint sigToken, uint addrKind, uint addr1, uint addr2, uint addr3)
 
891
                {
 
892
                        instance.__DefineGlobalVariable2(name, attributes, sigToken, addrKind, addr1, addr2, addr3);
 
893
                }
 
894
                
 
895
                public static void DefineConstant2(this ISymUnmanagedWriter2 instance, IntPtr name, object value, uint sigToken)
 
896
                {
 
897
                        instance.__DefineConstant2(name, value, sigToken);
 
898
                }
 
899
                
 
900
        }
 
901
}