1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// $ANTLR 2.7.2a2 (20020112-1): "CSharp.g" -> "CSharpParser.cs"$
#define ConditionalSymbol
#warning A message about the warning
#define ConditionalSymbol
#if Symbol1
using System.Globalization.SomeClass;
#endif
using TokenBuffer = antlr.TokenBuffer;
#warning A message about the warning
using AST = antlr.collections.AST;
using ASTArray = antlr.collections.impl.ASTArray;
#warning A message about the warning
#if Symbol1
[assembly: AssemblyTitle("antlr.runtime"), AssemblyDescription("ANTLR Runtime for .NET"), AssemblyCompany("www.antlr.org")]
[assembly: AssemblyTitle("antlr.runtime"), AssemblyDescription("ANTLR Runtime for .NET"), AssemblyCompany("www.antlr.org")]
#elif Symbol1 || Symbol2
[assembly: AssemblyTitle("antlr.runtime"), AssemblyDescription("ANTLR Runtime for .NET"), AssemblyCompany("www.antlr.org")]
#elif Symbol2
[assembly: AssemblyTitle("antlr.runtime"), AssemblyDescription("ANTLR Runtime for .NET"), AssemblyCompany("www.antlr.org")]
#else
[assembly: AssemblyTitle("antlr.runtime"), AssemblyDescription("ANTLR Runtime for .NET"), AssemblyCompany("www.antlr.org")]
#endif
[assembly: AssemblyProduct(true, ( 1 * 25.0 - -12) / (12 ^ 2))]
[assembly: AssemblyCopyright(xyz = (abc = 15*-2-4+7))]
[assembly: AssemblyVersion("2.7.2.*"), AssemblyVersion(true, null)]
namespace Kunle.LanguageProcessors
{
class CompilerController : IController
{
public const int jfk = 1L;
private const object obj = null, camel = null;
protected internal const string str = "<constant>";
#region Implementation of ICloneable
private string str = null;
private string[] sArray = null;
private string[][] arrayOfStrArray = null;
private char* ptr2Str;
private char*[] arrayOfStrPtr = null;
private char*[][] arrayOfArrayOfStrPtr = null;
// these are invalid in ECMA - csc rejects them.
//private char[]* ptr2sArray = null;
//private char[][]* ptr2ArrayOfStrArray = null;
//private char[]*[] arrayOfPtr2StrArray = null;
public static ASTArray ast;
#endregion Implementation of ICloneable
int
i
;
public void SomeMethod()
{
//this.pstring = "Hello";
pstring = "Hello";
}
public void SomeNamespace.ISomeInterface.SomeMethod()
{
//this.pstring = "Hello";
pstring = "Hello";
}
}
namespace Kunle.NET
{
[ClassWithoutBasesAttribute(10L), ClassWithoutBasesAttribute(true, 1.0F), ClassWithoutBasesAttribute(false, "string")]
[ClassWithoutBasesSection2Attribute(50L)]
class ClassWithoutBases
{
[AbstractMethodAttribute(false)]
public int AbstractMethod(int param1, [AbstractMethod_param2Attribute(false)]string param2);
public int AbstractMethod(int param1, string param2, params int[] args);
public int ParameterkindsMethod(int param1, ref int param2, out int param3, params int[] args);
public int ParameterkindsMethod2(int[] param1, ref int[] param2, out int[] param3, params int[] args);
static private int AbstractMethod2(params int[][][] args);
//int AbstractMethod(params int[] args, int i);
// Nested class
[ClassWithManyBasesButFirstIsStringAttribute("<suss>")]
class ClassWithManyBasesButFirstIsString : string, Base1, Base2, Base3, Base4
{
public static IntVector operator++(IntVector iv) {
IntVector temp = new IntVector(iv.Length);
IntVector temp = new IntVector[i];
for (int i = 0; i < iv.Length; ++i)
temp[i] = iv[i] + 1;
return temp;
}
public static IntVector operator--(IntVector iv) ;
}
// Nested Interface
interface InterfaceWithManyBases : Base1, Base2, Base3, Base4
{
}
// Nested Interface
interface InterfaceWithNoBases
{
}
// Nested Struct
[AuthorAttribute(true, 1L)]
struct StructWithManyBases : Base1, Base2, Base3, Base4
{
}
// Nested Struct
[AuthorAttribute(true, 1L)]
struct StructWithNoBases
{
}
// Nested Enum
[AuthorAttribute(true, 1L)]
private enum EnumAsLong : long
{
[AuthorAttribute(true, 1L)]
Enum1,
Enum2,
}
// Nested Enum
private enum EnumWithNoBase
{
Enum1,
Enum2,
}
[AuthorAttribute(true, 1L)]
public delegate string DelegateThatTakesOneIntParam( int myInt );
public delegate void DelegateThatTakesOneIntOneStringParam( int myInt, string myString );
[AuthorAttribute(true, 1L)]
public delegate object DelegateThatTakesNoParams( );
}
class ClassWithManyManyBases : Base1, Base2, Base3, Base4
{
}
}
}
namespace Kunle.Catalania.Parser
{
}
|
