MCS was able to parse itself on April 2001, MCS compiled itself for the first time on December 28 2001. MCS became self hosting on January 3rd, 2002. The Mono Runtime and the Mono execution engine were able to make?their compiler self hosting on March 12, 2002.

The Mono C# compiler is part of "mcs" module in the Mono CVS that you can get it from go-mono website, which are Anonymous CVS?and download page.

MCS is written in C# and uses heavily the .NET APIs. MCS runs on Linux (with the Mono runtime) and Windows (with the .NET framework runtime)

When you report a bug, try to provide a small test case that would show the error so we can include this as part of the Mono C# regression test suite. If the bug is an error or a warning that we do not flag, write a sample program called `csXXXX.cs' where XXXX is the code number that is used by the Microsoft C# compiler that illustrates the problem. That way we can also do regression tests on the invalid input.

The compiler has a number of phases:

• Lexical analyzer: hand-coded lexical analyzer that provides tokens to the parser.

• The Parser: the parser is implemented using Jay (A Berkeley Yacc port to Java, that I ported to C#). The parser does minimal work and syntax checking, and only constructs a parsed tree.

  Each language element gets its own class. The code convention is to use an uppercase name for the language element. So a C# class and its associated information is kept in a "Class" class, a "struct" in a "Struct" class and so on. Statements derive from the "Statement" class, and Expressions from the Expr class.

• Parent class resolution: before the actual code generation, we need to resolve the parents and interfaces for interface, classe and struct definitions.

• Semantic analysis: since C# can not resolve in a top-down pass what identifiers actually mean, we have to postpone this decision until the above steps are finished.

• Code generation: The code generation is done through the System.Reflection.Emit API.

The compiler performs a number of simple optimizations on its input: constant folding (this is required by the C# language spec) and can perform dead code elimination.

Other more interesting optimizations like hoisting are not possible at this point since the compiler output at this point does not generate an intermediate representation that is suitable to perform basic block computation.

Adding an intermediate layer to enable the basic block computation to the compiler should be a simple task, but we are considering having a generic CIL optimizer. Since all the information that is required to perform basic block-based optimizations is available at the CIL level, we might just skip this step altogether and have just a generic IL optimizer that would perform hoisting on arbitrary CIL programs, not only those produced by MCS.

If this tool is further expanded to perform constant folding (not needed for our C# compiler, as it is already in there) and dead code elimination, other compiler authors might be able to use this generic CIL optimizer in their projects reducing their time to develop a production compiler.

http://www.go-mono.com/c-sharp.html