1 * MCS: The Ximian C# compiler
3 MCS began as an experiment to learn the features of C# by
4 writing a large C# program. MCS is currently able to parse C#
5 programs and create an internal tree representation of the
6 program. MCS can parse itself.
8 Work is progressing quickly on various fronts in the C#
9 compiler. Recently I started using the System.Reflection API
10 to load system type definitions and avoid self-population of
11 types in the compiler and dropped my internal Type
12 representation in favor of using the CLI's System.Type.
14 ** Phases of the compiler
16 The compiler has a number of phases:
19 * Lexical analyzer: hand-coded lexical analyzer that
20 provides tokens to the parser.
22 * The Parser: the parser is implemented using Jay (A
23 Berkeley Yacc port to Java, that I ported to C#).
24 The parser does minimal work and syntax checking,
25 and only constructs a parsed tree.
27 Each language element gets its own class. The code
28 convention is to use an uppercase name for the
29 language element. So a C# class and its associated
30 information is kept in a "Class" class, a "struct"
31 in a "Struct" class and so on. Statements derive
32 from the "Statement" class, and Expressions from the
35 * Parent class resolution: before the actual code
36 generation, we need to resolve the parents and
37 interfaces for interface, classe and struct
40 * Semantic analysis: since C# can not resolve in a
41 top-down pass what identifiers actually mean, we
42 have to postpone this decision until the above steps
45 * Code generation: nothing done so far, but I do not
46 expect this to be hard, as I will just use
47 System.Reflection.Emit to generate the code.
52 ** Current pending tasks
57 * Array declarations are currently being ignored,
59 * PInvoke declarations are not supported.
61 * Pre-processing is not supported.
63 * Attribute declarations and passing currently ignored.
65 * Compiler does not pass around line/col information from tokenizer for error reporting.
67 * Jay does not work correctly with `error'
68 productions, making parser errors hard to point. It
69 would be best to port the Bison-To-Java compiler to
70 become Bison-to-C# compiler (bjepson@oreilly.com
71 might have more information)
77 * Resolve "base" classes and "base" interfaces for
78 classes, structs and interfaces.
80 Once this is done, we can actually do the semantic
81 analysis, because otherwise we do not know who our
85 Interesting and Fun hacks to the compiler:
88 * Finishing the JB port from Java to C#. If you are
89 interested in working on this, please contact Brian
90 Jepson (bjepson at oreilly d-o-t com).
92 More on JB at: <a href="http://www.cs.colorado.edu/~dennis/software/jb.html">
93 http://www.cs.colorado.edu/~dennis/software/jb.html</a>
95 JB will allow us to move from the Berkeley Yacc
96 based Jay to a Bison-based compiler (better error
97 reporting and recovery).
99 * Semantic Analysis: Return path coverage and
100 initialization before use coverage are two great
101 features of C# that help reduce the number of bugs
102 in applications. It is one interesting hack.
104 * TypeRefManager. This exists currently in its infancy only.
106 * Enum resolutions: it is another fun hack, as enums can be defined
107 in terms of themselves (<tt>enum X { a = b + 1, b = 5 }</tt>).
111 ** Questions and Answers
113 Q: Why not write a C# front-end for GCC?
115 A: I wanted to learn about C#, and this was an exercise in this
116 task. The resulting compiler is highly object-oriented, which has
117 lead to a very nice, easy to follow and simple implementation of
120 I found that the design of this compiler is very similar to
121 Guavac's implementation.
123 Targeting the CIL/MSIL byte codes would require to re-architecting
124 GCC, as GCC is mostly designed to be used for register machines.
126 The GCC Java engine that generates Java byte codes cheats: it does
127 not use the GCC backend; it has a special backend just for Java, so
128 you can not really generate Java bytecodes from the other languages
131 Q: If your C# compiler is written in C#, how do you plan on getting
132 this working on a non-Microsoft environment.
134 We will do this through an implementation of the CLI Virtual
135 Execution System for Unix (our JIT engine).
139 A: No, currently I am using Jay which is a port of Berkeley Yacc to
140 Java that I later ported to C#. This means that error recovery is
141 not as nice as I would like to, and for some reason error
142 productions are not being caught.
144 In the future I want to port one of the Bison/Java ports to C# for
147 You might also want to look at the <a href="faq.html#gcc">GCC</a>
148 section on the main FAQ