web/c-sharp

   1 * MCS: The Ximian C# compiler
   2
   3         The Mono C# compiler is considered feature complete at this
   4         point and relatively mature.  MCS is able to compile itself
   5         and many more C# programs (there is a test suite included that
   6         you can use).  It is routinely used to compile Mono, roughly
   7         half a million lines of C# code.
   8
   9 ** Obtaining MCS
  10
  11         The Mono C# compiler is part of the `mcs' module in the Mono CVS
  12         you can get it from our <a href="anoncvs.html">Anonymous CVS</a> server,
  13         or you can get nightly <a href="download.html">download page</a>.
  14
  15 ** Running MCS
  16
  17         MCS is written in C# and uses heavily the .NET APIs.  MCS runs
  18         on Linux with the Mono runtime and on Windows with both the
  19         .NET runtime and the Mono runtime.
  20
  21 ** Reporting Bugs in MCS
  22
  23         When you report a bug, try to provide a small test case that would
  24         show the error so we can include this as part of the Mono C# regression
  25         test suite.
  26
  27         If the bug is an error or a warning that we do not flag, write
  28         a sample program called `csXXXX.cs' where XXXX is the code number
  29         that is used by the Microsoft C# compiler that illustrates the
  30         problem.  That way we can also do regression tests on the invalid
  31         input.
  32
  33 ** Phases of the compiler
  34
  35         The compiler has a number of phases:
  36
  37         <ul>
  38                 * Lexical analyzer: hand-coded lexical analyzer that
  39                   provides tokens to the parser.
  40
  41                 * The Parser: the parser is implemented using Jay (A
  42                   Berkeley Yacc port to Java, that I ported to C#).
  43                   The parser does minimal work and syntax checking,
  44                   and only constructs a parsed tree.
  45
  46                   Each language element gets its own class.  The code
  47                   convention is to use an uppercase name for the
  48                   language element.  So a C# class and its associated
  49                   information is kept in a "Class" class, a "struct"
  50                   in a "Struct" class and so on.  Statements derive
  51                   from the "Statement" class, and Expressions from the
  52                   Expr class.
  53
  54                 * Parent class resolution: before the actual code
  55                   generation, we need to resolve the parents and
  56                   interfaces for interface, classe and struct
  57                   definitions.
  58
  59                 * Semantic analysis: since C# can not resolve in a
  60                   top-down pass what identifiers actually mean, we
  61                   have to postpone this decision until the above steps
  62                   are finished.
  63
  64                 * Code generation: The code generation is done through
  65                   the System.Reflection.Emit API.
  66         </ul>
  67
  68 ** CIL Optimizations.
  69
  70         The compiler performs a number of simple optimizations on its input:
  71         constant folding (this is required by the C# language spec) and
  72         can perform dead code elimination.
  73
  74         Other more interesting optimizations like hoisting are not possible
  75         at this point since the compiler output at this point does not
  76         generate an intermediate representation that is suitable to
  77         perform basic block computation.
  78
  79         Adding an intermediate layer to enable the basic block
  80         computation to the compiler should be a simple task, but we
  81         are considering having a generic CIL optimizer.  Since all the
  82         information that is required to perform basic block-based
  83         optimizations is available at the CIL level, we might just skip
  84         this step altogether and have just a generic IL optimizer that
  85         would perform hoisting on arbitrary CIL programs, not only
  86         those produced by MCS.
  87
  88         If this tool is further expanded to perform constant folding
  89         (not needed for our C# compiler, as it is already in there)
  90         and dead code elimination, other compiler authors might be
  91         able to use this generic CIL optimizer in their projects
  92         reducing their time to develop a production compiler.
  93
  94 * Open bugs
  95
  96         See the <a href="bugs.html">bugs page</a> for more information.
  97
  98         A test suite is maintained to track the progress of
  99         the compiler and various programs are routinely compiled and
 100         ran.
 101
 102 * Slides
 103
 104         Slides for the Mono C# Compiler presentation at .NET ONE are
 105         available <a
 106         href="http://primates.ximian.com/~miguel/slides-europe-nov-2002/Mono_C_Sharp_Overview_1007.sxi">here</a>
 107         in StarOffice format.
 108
 109 ** History
 110
 111         MCS was able to parse itself on April 2001, MCS compiled itself
 112         for the first time on December 28 2001.  MCS became self hosting
 113         on January 3rd, 2002.
 114
 115         The Mono Runtime and the Mono execution engine were able to make
 116         our compiler self hosting on March 12, 2002.
 117
 118 ** Questions and Answers
 119
 120 Q: Does the Mono C# compiler support C# 2.0?
 121
 122 A: At this point the Mono C# compiler supports some of the features of
 123    C# 2.0, but the support has not been completed.   To enable 2.0 features
 124    you must use the -2 flag to the compiler.
 125
 126 Q: What features are available as of Feb 2004?
 127
 128 A: Iterators have been implemented as well as method group implicit
 129    conversion to delegates on the main compiler branch.
 130
 131    We have a branch of the compiler in the module `mcs/gmcs' which is
 132    where we are developing the Generics support for the compiler.  Plenty
 133    of tests work (see mcs/tests/gen-*.cs for a list of tests), but work
 134    remains to be done.
 135
 136 Q: Will the C# 2.0 features be part of the Mono 1.0 release?
 137
 138 A: Only a few, the generic compiler will not be part of the 1.0
 139    stable release, but a beta preview will be distributed.
 140
 141 Q: Why not write a C# front-end for GCC?
 142
 143 A: I wanted to learn about C#, and this was an exercise in this
 144    task.  The resulting compiler is highly object-oriented, which has
 145    lead to a very nice, easy to follow and simple implementation of
 146    the compiler.
 147
 148    I found that the design of this compiler is very similar to
 149    Guavac's implementation.
 150
 151    Targeting the CIL/MSIL byte codes would require to re-architecting
 152    GCC, as GCC is mostly designed to be used for register machines.
 153
 154    The GCC Java engine that generates Java byte codes cheats: it does
 155    not use the GCC backend; it has a special backend just for Java, so
 156    you can not really generate Java bytecodes from the other languages
 157    supported by GCC.
 158
 159 Q: If your C# compiler is written in C#, how do you plan on getting
 160    this working on a non-Microsoft environment.
 161
 162    We will do this through an implementation of the CLI Virtual
 163    Execution System for Unix (our JIT engine).
 164
 165    Our JIT engine is working for the purposes of using the compiler.
 166    The supporting class libraries are being worked on to fully support
 167    the compiler.
 168
 169 Q: Do you use Bison?
 170
 171 A: No, currently I am using Jay which is a port of Berkeley Yacc to
 172    Java that I later ported to C#.  This means that error recovery is
 173    not as nice as I would like to, and for some reason error
 174    productions are not being caught.
 175
 176    In the future I want to port one of the Bison/Java ports to C# for
 177    the parser.
 178
 179 Q: Should someone work on a GCC front-end to C#?
 180
 181 A: I would love if someone does, and we would love to help anyone that
 182    takes on that task, but we do not have the time or expertise to
 183    build a C# compiler with the GCC engine.  I find it a lot more fun
 184    personally to work on C# on a C# compiler, which has an intrinsic
 185    beauty.
 186
 187    We can provide help and assistance to anyone who would like to work
 188    on this task.
 189
 190 Q: Should someone make a GCC backend that will generate CIL images?
 191
 192 A: I would love to see a backend to GCC that generates CIL images.  It
 193    would provide a ton of free compilers that would generate CIL
 194    code.  This is something that people would want to look into
 195    anyways for Windows interoperation in the future.
 196
 197    Again, we would love to provide help and assistance to anyone
 198    interested in working in such a project.
 199
 200 Q: What about making a front-end to GCC that takes CIL images and
 201    generates native code?
 202
 203 A: I would love to see this, specially since GCC supports this same
 204    feature for Java Byte Codes.  You could use the metadata library
 205    from Mono to read the byte codes (ie, this would be your
 206    "front-end") and generate the trees that get passed to the
 207    optimizer.
 208
 209    Ideally our implementation of the CLI will be available as a shared
 210    library that could be linked with your application as its runtime
 211    support.
 212
 213    Again, we would love to provide help and assistance to anyone
 214    interested in working in such a project.
 215
 216 Q: But would this work around the GPL in the GCC compiler and allow
 217    people to work on non-free front-ends?
 218
 219 A: People can already do this by targeting the JVM byte codes (there
 220    are about 130 compilers for various languages that target the JVM).
 221
 222 Q: Why are you writing a JIT engine instead of a front-end to GCC?
 223
 224 A: The JIT engine and runtime engine will be able to execute CIL
 225    executables generated on Windows.
 226
 227 You might also want to look at the <a href="faq.html#gcc">GCC</a>
 228 section on the main FAQ