X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=web%2Fc-sharp;h=ffa0b574bef43950ccb928ef65edad10ff7409fe;hb=db8116754634a1a90ee723acaea36bfaddf1c84e;hp=0c5be542f02de1735e20cc45c16ea6c25a05b4ba;hpb=06d27b18914cda3c7a8e22a96617e46c3aa1a4ed;p=mono.git
diff --git a/web/c-sharp b/web/c-sharp
index 0c5be542f02..ffa0b574bef 100644
--- a/web/c-sharp
+++ b/web/c-sharp
@@ -1,19 +1,42 @@
* MCS: The Ximian C# compiler
- MCS began as an experiment to learn the features of C# by
- writing a large C# program. MCS is currently able to parse C#
- programs and create an internal tree representation of the
- program. MCS can parse itself.
+ The Mono C# compiler is considered feature C# 1.0 complete at
+ this point and mature. MCS is able to compile itself and many
+ more C# programs (there is a test suite included that you can
+ use). It is routinely used to compile Mono, roughly 1.7
+ million lines of C# code.
- MCS now does type checking at the class, interface and struct
- levels and can resolve the class hierarchy and as of last week
- can generate interface code.
+ The compiler is also fairly fast. On a IBM ThinkPad t40 it
+ compiles 18,000 lines of C# code per second.
- Work is progressing quickly on various fronts in the C#
- compiler. Recently I started using the System.Reflection API
- to load system type definitions and avoid self-population of
- types in the compiler and dropped my internal Type
- representation in favor of using the CLI's System.Type.
+ Work on C# 2.0 has started: some pieces of it are available on
+ the standard compiler with the -2 switch (iterators, method
+ conversions) and some others are available on the `gmcs'
+ branch on CVS (generics)
+
+** Obtaining MCS
+
+ The Mono C# compiler is part of the `mcs' module in the Mono CVS
+ you can get it from our Anonymous CVS server,
+ or you can get nightly download page.
+
+** Running MCS
+
+ MCS is written in C# and uses heavily the .NET APIs. MCS runs
+ on Linux with the Mono runtime and on Windows with both the
+ .NET runtime and the Mono runtime.
+
+** Reporting Bugs in MCS
+
+ 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.
** Phases of the compiler
@@ -46,61 +69,82 @@
have to postpone this decision until the above steps
are finished.
- * Code generation: The compiler recently started generating IL
- executables that contain interfaces. Work is
- progressing in other areas.
-
- The code generation is done through the System.Reflection.Emit API.
+ * Code generation: The code generation is done through
+ the System.Reflection.Emit API.
-
-** Current pending tasks
+** CIL Optimizations.
- Simple tasks:
+ 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.
-
- * Array declarations are currently being ignored,
+ 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.
- * PInvoke declarations are not supported.
+ 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.
- * Pre-processing is not supported.
+ 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.
- * Attribute declarations and passing currently ignored.
+* Open bugs
- * Compiler does not pass around line/col information from tokenizer for error reporting.
+ See the bugs page for more information.
- * Jay does not work correctly with `error'
- productions, making parser errors hard to point. It
- would be best to port the Bison-To-Java compiler to
- become Bison-to-C# compiler (bjepson@oreilly.com
- might have more information)
-
+ A test suite is maintained to track the progress of
+ the compiler and various programs are routinely compiled and
+ ran.
- Interesting and Fun hacks to the compiler:
+* Slides
-
- * Finishing the JB port from Java to C#. If you are
- interested in working on this, please contact Brian
- Jepson (bjepson at oreilly d-o-t com).
+ Slides for the Mono C# Compiler presentation at .NET ONE are
+ available here
+ in StarOffice format.
- More on JB at:
- http://www.cs.colorado.edu/~dennis/software/jb.html
+** History
- JB will allow us to move from the Berkeley Yacc
- based Jay to a Bison-based compiler (better error
- reporting and recovery).
+ 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.
- * Semantic Analysis: Return path coverage and
- initialization before use coverage are two great
- features of C# that help reduce the number of bugs
- in applications. It is one interesting hack.
+ The Mono Runtime and the Mono execution engine were able to make
+ our compiler self hosting on March 12, 2002.
- * Enum resolutions: it is another fun hack, as enums can be defined
- in terms of themselves (enum X { a = b + 1, b = 5 }).
+** Questions and Answers
-
+Q: Does the Mono C# compiler support C# 2.0?
-** Questions and Answers
+A: At this point the Mono C# compiler supports some of the features of
+ C# 2.0, but the support has not been completed. To enable 2.0 features
+ you must use the -2 flag to the compiler.
+
+Q: What features are available as of Feb 2004?
+
+A: Iterators have been implemented as well as method group implicit
+ conversion to delegates on the main compiler branch.
+
+ We have a branch of the compiler in the module `mcs/gmcs' which is
+ where we are developing the Generics support for the compiler. Plenty
+ of tests work (see mcs/tests/gen-*.cs for a list of tests), but work
+ remains to be done.
+
+Q: Will the C# 2.0 features be part of the Mono 1.0 release?
+
+A: Only a few, the generic compiler will not be part of the 1.0
+ stable release, but a beta preview will be distributed.
Q: Why not write a C# front-end for GCC?
@@ -126,6 +170,10 @@ Q: If your C# compiler is written in C#, how do you plan on getting
We will do this through an implementation of the CLI Virtual
Execution System for Unix (our JIT engine).
+ Our JIT engine is working for the purposes of using the compiler.
+ The supporting class libraries are being worked on to fully support
+ the compiler.
+
Q: Do you use Bison?
A: No, currently I am using Jay which is a port of Berkeley Yacc to