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