Compare commits

..
3 Commits
Author SHA1 Message Date
nobody 3baf6444e0 This commit was manufactured by cvs2svn to create tag 'MCS_0_15'.
svn path=/tags/MCS_0_15/mcs/; revision=6974
2002-08-23 19:45:54 +00:00
Martin Baulig 7f0542b133 Importing NUnit 1.11.
svn path=/branches/NUNIT/mcs/; revision=2713
2002-02-27 09:38:21 +00:00
nobody 9f187b5dd0 This commit was manufactured by cvs2svn to create branch 'NUNIT'.
svn path=/branches/NUNIT/mcs/; revision=2712
2002-02-27 09:38:18 +00:00
11599 changed files with 298903 additions and 1424722 deletions

No files matched your search

-6
View File
@@ -15,9 +15,3 @@ Makefile.in
mono-*.tar.gz
stamp-h
stamp-h.in
mono.pc
mono.spec
autom4te.cache
mint.pc
stamp-h1
config.h.in
-1438
View File
File diff suppressed because it is too large. Load diff
+4 -182
View File
@@ -1,187 +1,9 @@
AUTOMAKE_OPTIONS = foreign
ACLOCAL_AMFLAGS = -I .
SUBDIRS = @libgc_dir@ mono @ikvm_jni_dir@ docs runtime scripts man data samples support web
SUBDIRS = mono doc docs runtime scripts man data
# Keep in sync with SUBDIRS
## 'tools' is not normally built
DIST_SUBDIRS = libgc mono ikvm-jni docs runtime scripts man data samples support web tools
EXTRA_DIST= mono.pc.in mono.spec.in mint.pc.in
EXTRA_DIST= mono.pc.in mono.spec.in
pkgconfigdir = $(libdir)/pkgconfig
if JIT_SUPPORTED
pkgconfig_DATA= mono.pc mint.pc
else
pkgconfig_DATA= mint.pc
endif
DISTCLEANFILES= mono.pc mint.pc
#
# The following targets are used to compile and install
# mono and mcs without running into the out-of-sync
# problems by doing the compilation in the right order.
#
mcs_topdir=$(top_srcdir)/../mcs
.PHONY: bootstrap faststrap fasterstrap bootstrap-clean bootstrap-check get-monolite-latest monolite-bootstrap
.PHONY: tmpinst-dir tmpinst-mcs-basic-build tmpinst-mcs-short-build tmpinst-mcs-full-build tmpinst-monolite
.PHONY: mono-do-runtime-only mcs-do-basic-build mcs-do-short-build mcs-do-full-build mcs-do-clean-profiles mcs-do-run-test
if USE_JIT
mono_runtime = mono/mini/mono
else
mono_runtime = mono/interpreter/mint
endif
# Minimal set of directories to build, and files used to run the 'mcs' compiler
MCS_BASIC_DIRS = jay mcs class/corlib class/System
MCS_BASIC_FILES = \
$(mcs_topdir)/mcs/mcs.exe \
$(mcs_topdir)/class/lib/default/mscorlib.dll \
$(mcs_topdir)/class/lib/default/System.dll
# Set of directories and files the 'mcs' compiler can use
## We build class/System twice to resolve the cyclic dependency of class/System.XML
MCS_DIRS = $(MCS_BASIC_DIRS) class/System.XML class/System class/Mono.CSharp.Debugger
MCS_FILES = $(MCS_BASIC_FILES) \
$(mcs_topdir)/class/lib/default/System.Xml.dll \
$(mcs_topdir)/class/lib/default/Mono.CSharp.Debugger.dll
tmpinst = _tmpinst
bootstrap: tmpinst-mcs-basic-build mono-do-runtime-only
$(MAKE) tmpinst-mcs-short-build
$(MAKE) fasterstrap
faststrap: tmpinst-mcs-short-build
$(MAKE) mono-do-runtime-only
$(MAKE) fasterstrap
.PHONY: populate-runtime-subdir
## *** warning ***: tested only with GNU make
populate-runtime-subdir:
srcdir=`cd $(srcdir) && pwd`; tmpinst=`pwd`/$(tmpinst) ; \
PATH=$$tmpinst/bin:$$PATH ; export PATH ; \
cd $(mcs_topdir) \
&& $(MAKE) PROGRAM_INSTALL_DIR=$$srcdir/runtime LIBRARY_INSTALL_DIR=$$srcdir/runtime/net_1_1 prefix=$$tmpinst/prefix PROFILE=default install \
&& $(MAKE) PROGRAM_INSTALL_DIR=$$srcdir/runtime LIBRARY_INSTALL_DIR=$$srcdir/runtime/net_2_0 prefix=$$tmpinst/prefix PROFILE=net_2_0 install
test -z "`find $(tmpinst)/prefix -name '*.dll'`"
test -z "`find $(tmpinst)/prefix -name '*.exe'`"
set fnord `find $(tmpinst)/prefix -type f | wc -l` ; test "$$2" = 9
rm -rf $(tmpinst)/prefix
fasterstrap: tmpinst-mcs-full-build
$(MAKE) populate-runtime-subdir
$(MAKE)
bootstrap-clean: clean mcs-do-clean-profiles
bootstrap-check: check mcs-do-run-test
# building with monolite
get-monolite-latest:
wget -O $(srcdir)/../monolite-latest.tar.gz http://www.go-mono.com/daily/monolite-latest.tar.gz
monolite-bootstrap: tmpinst-monolite mono-do-runtime-only
rm -f $(MCS_FILES)
$(MAKE) tmpinst-mcs-short-build
$(MAKE) fasterstrap
# internal targets
tmpinst-mcs-basic-build: mcs-do-basic-build tmpinst-dir
mv -f $(MCS_BASIC_FILES) $(tmpinst)/lib
tmpinst-mcs-short-build: mcs-do-short-build tmpinst-dir
mv -f $(MCS_FILES) $(tmpinst)/lib
tmpinst-mcs-full-build: mcs-do-full-build tmpinst-dir
cp -f $(MCS_FILES) $(tmpinst)/lib
tmpinst-monolite: tmpinst-dir
-rm -f $(tmpinst)/lib/mcs.exe $(tmpinst)/lib/*.dll
-rm -fr $(tmpinst)/monolite-*
srcdir=`cd $(srcdir) && pwd` && cd $(tmpinst) && ( gzip -d -c $$srcdir/../monolite-latest.tar.gz | tar xf - )
mv -f $(tmpinst)/monolite-*/mcs.exe $(tmpinst)/monolite-*/*.dll $(tmpinst)/lib
rm -fr $(tmpinst)/monolite-*
# Build enough of 'mono' to run the stage1 mcs.exe
mono-do-runtime-only: $(CONFIG_HEADER)
for dir in $(libgc_dir) mono data; do \
(cd $$dir && $(MAKE)) || exit 1 ; \
done
mcs-do-basic-build:
rm -f $(MCS_FILES)
for dir in $(MCS_BASIC_DIRS); do \
(cd $(mcs_topdir)/$$dir && $(MAKE) PROFILE=default USE_BOOT_COMPILE=yes BOOTSTRAP_MCS="mcs -d:BOOTSTRAP_WITH_OLDLIB") || exit 1 ; \
done
mcs-do-short-build:
tmpinst=`cd $(tmpinst) && pwd` ; \
PATH=$$tmpinst/bin:$$PATH; export PATH ; \
for dir in $(MCS_DIRS); do \
(cd $(mcs_topdir)/$$dir && $(MAKE) PROFILE=default) || exit 1 ; \
done
mcs-do-full-build:
tmpinst=`cd $(tmpinst) && pwd` ; \
PATH=$$tmpinst/bin:$$PATH ; export PATH ; \
cd $(mcs_topdir) && $(MAKE) all-profiles
mcs-do-clean-profiles:
cd $(mcs_topdir) && $(MAKE) clean-profiles
mcs-do-run-test: tmpinst-dir
tmpinst=`cd $(tmpinst) && pwd` ; \
PATH=$$tmpinst/bin:$$PATH ; export PATH ; \
cd $(mcs_topdir) && $(MAKE) PROFILE=default run-test
tmpinst-dir:
mkdir -p $(tmpinst) $(tmpinst)/bin $(tmpinst)/lib $(tmpinst)/etc/mono
$(MAKE) $(tmpinst)/bin/mono $(tmpinst)/bin/mcs $(tmpinst)/etc/mono/machine.config
$(tmpinst)/bin/mono: $(srcdir)/Makefile.am
echo '#! /bin/sh' > $@
echo 'builddir="'`pwd`'"; tmpinst=$$builddir/$(tmpinst)' >> $@
echo 'if test -z "$$MONO_PATH" ; then MONO_PATH=$$tmpinst/lib; else MONO_PATH=$${MONO_PATH}:$$tmpinst/lib ; fi' >> $@
echo 'MONO_CFG_DIR=$$tmpinst/etc' >> $@
echo 'export MONO_PATH MONO_CFG_DIR' >> $@
echo 'exec "$$builddir/libtool" --mode=execute "$$builddir/$(mono_runtime)" --config "$$builddir/data/config" "$$@"' >> $@
chmod +x $@
$(tmpinst)/bin/mcs: $(srcdir)/Makefile.am
(t=`cd $(tmpinst) && pwd`; echo '#! /bin/sh'; echo 'exec "'"$$t/bin/mono"'" "'"$$t/lib/mcs.exe"'" "$$@"') > $@
chmod +x $@
$(tmpinst)/etc/mono/machine.config: $(srcdir)/data/machine.config
rm -f $@
srcdir=`cd $(srcdir) && pwd`; cd $(tmpinst)/etc/mono && $(LN_S) $$srcdir/data/machine.config machine.config
# Obsolete target -- don't use.
.PHONY: fullbuild
fullbuild: bootstrap
$(MAKE) install
echo "*** 'fullbuild' is an obsolete target. Use 'make bootstrap && make install'."
exit 1
win32getdeps:
wget http://www.go-mono.com/archive/pkgconfig-0.11-20020310.zip
wget http://www.go-mono.com/archive/glib-2.0.4-20020703.zip
wget http://www.go-mono.com/archive/glib-dev-2.0.4-20020703.zip
wget http://www.go-mono.com/archive/libiconv-1.7.zip
wget http://www.go-mono.com/archive/libiconv-dev-1.7.zip
wget http://www.go-mono.com/archive/libintl-0.10.40-20020101.zip
wget http://www.jroith.de/nsis4cygwin.zip
unzip -n -d / pkgconfig-0.11-20020310.zip
unzip -n -d / glib-2.0.4-20020703.zip
unzip -n -d / glib-dev-2.0.4-20020703.zip
unzip -n -d / libiconv-1.7.zip
unzip -n -d / libiconv-dev-1.7.zip
unzip -n -d / libintl-0.10.40-20020101.zip
unzip -n -d / nsis4cygwin.zip
win32setup:
makensis /DMILESTONE=$(VERSION) /DSOURCE_INSTALL_DIR=$(SOURCE_INSTALL_DIR) /DBUILDNUM=$(BUILDNUM) monowiz.win32.nsi
pkgconfig_DATA= mono.pc
DISTCLEANFILES= mono.pc
-855
View File
@@ -1,858 +1,3 @@
Hello everyone!
We are releasing a new version of Mono, Mono 0.22. A new release
is made today because of the few recent bug-fixes that were committed
to CVS.
Source code and binaries for this release can be found on the
web page,
http://www.go-mono.com/download.html
The URLs for the sources are:
* MCS package (the Class Libraries, C# and VB.NET compiler
and other assorted tools written in Managed code):
http://www.go-mono.com/archive/mcs-0.22.tar.gz
* Mono package (the Runtime engine and JIT compiler):
http://www.go-mono.com/archive/mono-0.22.tar.gz
RPM packages for this release can be downloaded from the web-page
as well as from the 'Mono' channel on Red Carpet. Debian packages will
appear on the download page later, as well as an installer for our
Windows users.
Since last Thursday, 320 commits have been made to our CVS
repository. These following hackers contributed to Mono since version
0.21:
Aleksey Demakov, Alexandre Pigolkine, Atsushi Enomoto, Elan
Feingeld, Dick Porter, Dietmar Maurer, Duncan Mak, Gonzalo
Paniagua, Ian MacLean, Jackson Harper, Jean-Marc Andre, Jerome
Laban, Lluis Sanchez, Martin Baulig, Miguel de Icaza, Nick
Drochak, Paolo Molaro, Pedro Martinez, Per Ameng, Peter Williams,
Rafael Teixeira, Reggie Burnett, Sebastien Pouliot, Tim Coleman
and Zoltan Varga.
Highlights:
* The "MemoryStream" bug.
This bug affected a lot of classes, and made them crashy,
database code, XML parsing and a few others were
crashing. Thanks to Gonzalo for fixing this bug.
* System.Data:
More bug fixes from Aleksey and Tim.
* Reflection:
Zoltan continues to provide fixes to our Reflection.Emit code
to host IKVM.
* Remoting:
Lluis added support for activation using activation
attributes.
* PEToolkit:
Jackson imported the PEAPI package from the Queensland
University of Technology in Australia. This will replace the
existing Mono.PEToolkit for our ILasm back-end.
* Windows Forms:
More fixes from Reggie and Alexandre.
* System.Web.Mail:
Per has been working on this namespace. He announces recently
that all major parts of System.Web.Mail has now been implemented.
* System.Web.Mobile:
Gaurav continues to make progress here.
* Misc:
Ian MacLean contributed a /compile flag to monoresgen and
assorted bug-fixes and improvements from the rest of the team.
My name is Duncan Mak, and I just made my first Mono release.
-----------------------------------------------------------------------------
Hello everyone!
The Mono Team introduces the best Mono release so far we have
done. Thanks to everyone who contributed fixes, code, ideas, and bug
reports.
Mono 0.20 has been released, it is available at the usual location:
http://www.go-mono.com/download.html
This is a truly heroic release of Mono. Major architectural
chunks that were missing, or were miss-implemented have been fixed in
this release, and we are very proud of it. Please see the list of
features, because there is no short way of introducing just how good
this release is. A big thanks goes to Piers for setting up a
Tinderbox that monitors problems with the Mono CVS repository.
We released packages for SuSE 8.0, Mandrake 8.2, and various
Red Hat releases. It is also available from Red Carpet on the Mono
channel.
Source code for Mono, MCS, the Mono Debugger, XSP is available as
well from that web page. The sources are:
MCS package (Class Libraries, C# and VB.NET compiler and managed tools):
http://www.go-mono.com/archive/mcs-0.20.tar.gz
Mono package (Runtime engine, JIT compiler):
http://www.go-mono.com/archive/mono-0.20.tar.gz
XSP package (XSP test web server for ASP.NET webforms):
http://www.go-mono.com/archive/xsp-0.3.tar.gz
This release is brought to you by: Alvaro del Castillo, Alan Tam,
Alp Toker, Alejandro Sánchez, Alexandre Pigolkin, Atsushi Enomoto,
Brian Ritchie, Christopher Bockner, Daniel Lopez, Daniel Morgan,
Dennis Hayes, Dick Porter, Dietmar Maurer, Duncan Mak, Gaurav Vaish,
Gonzalo Paniagua, Jackson Harper, Jaime Anguiano, Jeff Stedfast,
Johannes Roith, John Sohn, Jonathan Pryor, "Lee Mallabone, "Lluis
Sanchez, "Marco Ridoni, Mark Crichton, Martin Baulig, Martin Willemoes
Hansen, Miguel de Icaza, Mike Kestner, Nick Drochak, Paolo Molaro,
Patrik Torstensson, Pedro Martinez, Per Arneng, Peter Williams, Petr
Danecek, Piers Haken, Radek Doulik, Rafael Teixeira, Rodrigo Moya,
Sebastien Pouliot, Tim Coleman, Ville Palo, and Zoltan Varga.
They commited 1810 changes to CVS patches in the past 33 days.
* New in this release
* Zoltan and IKVM
Zoltan's patches to run Jeroen's IKVM (the Java VM that
translates JVM bytecodes into .NET bytecodes) are in.
* Remoting.
The remoting team's patches that were held off on the previous
release are here. Lluis and Patrik have done a fantastic job
in getting remoting to work. Many low-level runtime engine
changes, and plenty of work on the class-library stuff.
Lluis has posted a couple of sample applications to the
mailing list, you can try those out.
The new release includes a working BinaryFormatter and
BinaryFormatterSink. It means that together with TcpChannel
it is possible to make remote calls with any type of
parameters and return values, including value types,
MarshalByRefObject types (that are properly
marshalled/unmarshalled), delegates, enums, etc.
RemotingConfiguration is partially implemented. It cannot read
from config files, but manual configuration using the api is
fully working.
Implemented full support for client activated types and for
well known objects (both singleton and single call).
Lease manager fully working (it manages the lifetime of server
objects).
Implemented interception of the new operator, so it is
possible to create a remote object using "new", if the type is
properly registered in RemotingConfiguration.
In Lluis' words: `Basically, 0.20 will have almost all needed
for a distributed application with Remoting'
* New threading semantics, IO-layer
Dick Porter in a couple of weeks has heroically redone much of
the threading support to match the .NET behavior (details are
on the .NET threading book as posted on the Mono site).
He also did a lot of bug fixes in the IO/threading space. The
threading implementation now contains a new and faster Monitor
implementation, as well as a correct Pulse()/Wait()
implementation.
GC thread finalization has been re-enabled. This means that
finalizers will be ran on a separate thread, as done in the
Microsoft.NET Framework. This might expose some bugs on
existing finalizer code.
* Moved to NUnit2
Nick and Gonzalo helped us move to the new NUnit2 platform for
all of our tests. A big applause goes to them.
* Cross Appdomain invocations work now.
ASP.NET and NUnit2 both used cross appdomain invocations, we
have fixed a number of problems, and they are now functional.
The AppDomain fixes and the Remoting fixes have allowed us to
remove a number of hacks in the ASP.NET implementation that
were previously there.
Implemented CrossAppDomainChannel, for calls between domains.
* C# Compiler and Debugging.
When generating debugging information in the compiler (with
-debug, -g or -debug+) the compiler will embed the debugging
information into the resulting executable instead of
generating a separate file. Very nice.
Generating debugging information has also improved vastly
performance-wise, and now it is possible to always use
debugging builds for software development.
A number of bugs were fixed on the compiler as well and
by using the Mono profiler we have reduced the memory
consumption and accelerated the compiler.
Thanks to Jackson, Martin, Paolo and for helping here.
* VB.NET Compiler.
Plenty of new features are included in the compiler in our
path to conformance. See <FIXME:get-url-for-posting> for
details on the status of the compiler, and the pieces missing.
* ILasm and Mono.PEToolkit.
Work on the IL assembler has resumed, but it is not yet ready
for production use. The Mono IL Assembler uses the
Mono.PEToolkit library done by Sergey and Jackson to
manipulate CIL image files.
* Cryptographic work.
Sebastien has provided a cert2spc and secutil tools for
certificate management. This is the first release that ships
an assembly for System.Security
Also a new internal assembly used only on Windows allows Mono
users to use the unmanaged crypto providers.
* System.XML
Atsushi has continued to improve the work on our XML
implementation: fixing bugs and more closely matching the
Microsoft implementation.
* More PowerPC/Alpha support.
Taylor Christopher has contributed more code generation macros
for PPC and Laramie Leavitt for Alpha.
* System.XML.Xsl
Gonzalo continued the implementation of our XSLT transformation
API (custom .NET functions are still missing though). It no
longer uses temporary files to apply transformations. Thanks
to an idea from Zdravko Tashev. Xslt Web controls work as
part of this fix.
* ASP.NET
Gonzalo has cleaned up a lot the code base, and now our test
server supports a --root and --virtual command line options
for better control.
Also, now we generate a much nicer error page on errors. We
are looking for volunteers to improve the default look of this
page.
Authentication is now supported
* Mobile Controls.
Gaurav Vaish continues on his quest to complete the
implementation of the Mobile controls. These controls are
required to run a stock IBuySpy application.
* Class Libraries:
New Mono.Posix class library that contains classes for working
on a Posix systems. Things like Unix domain sockets are here.
* System.Windows.Forms
Alexandre Pigolkine continues to contribute more code to our
Windows.Forms implementation. Currently it only runs on
Windows (or in Linux without GC enabled, due to the
pthread/Wine threading library mismatch. This is being
actively addressed as part of the Wine work due to the
movement to the new thread implementation available in RH 8.1).
* Database providers
Christopher Bockner has updated his DB2 database provider (now
with prepared statement functionality) and Tim Coleman has
continued work on the Oracle database provider (welcome back
Tim!)
* Database code.
Dan Morgan continues to develop core components in System.Data
(and now we welcome Alan Tam to the System.Data core hackers)
The SQL# tool now supports MySQLNet, Npgsql, DB2Client, and
Oracle clients.
* Runtime
mono --profile now performs memory allocation profiling too.
* Runtime fixes.
We now support multi-module with external file reference
assemblies.
The above in English means that we can now run Eiffel.NET code
in Mono.
* Monograph:
More statistics supported now.
* System.Web.Mail
Per has contributed the code for this namespace.
* Bugs
Plenty of bugs were closed.
-------------------------------------------------------------------------
Hello everyone!
We have made a new release of Mono available. Despite the fact
that we just did Mono 0.18, this release is packed with new features.
* Availability.
Mono 0.19 is available in package format from:
http://www.go-mono.com/download.html
We released packages for SuSE 8.0, Mandrake 8.2, Debian and various
Red Hat releases. It is also available from Red Carpet on the Mono
channel.
Source code for Mono, MCS, the Mono Debugger, XSP is available as
well from that web page.
* New in this release
* Remoting news:
Lluis has implemented and documented the Binary formatter
Woohoo! He has done a lot of work as well to support
remoting.
Patrik has also been working heavily on fixing a
number of remoting related bugs and missing features.
Ajay also implemented 1-d array serialization in System.Xml
* New database provider: IBM DB2
Christopher Bockner has contributed a DB2 data
provider for System.Data. We have a very complete
range of data providers.
* System.Web.Mobile
Gaurav has started work on this assembly, this will
allow us to run the unmodified reference ASP.NET
applications that were designed to support Mobile
browsing.
* System.Data and System.XML:
More implementation work on XmlDataDocument from Ville
and plenty of fixes from Atsushi.
* MacOS patches:
Paolo integrated John Duncan's and Benjamin Reed
patches to make Mono run on MacOS X out of the box.
* IsolatedStorage
The initial implementation of it was done by Jonathan
Pryor and included in this release.
* Compilers:
More work on the Mono Visual Basic compiler (it is now
included in the packages).
Plenty of bug fixes from Jackson, Miguel to the C#
compiler.
Patches from Francesco and Daniel to the VB.NET
support runtime.
* Debugger support
Plenty of updates to run the new Mono Debugger from Martin.
* Main missing bits:
Some of everyone's favorite patches or code chunks have not yet
been integrated, hopefully Mono 0.20 will have them:
* Zoltan's patch to run IKVM is not yet on this release
* Some parts of Patrik's remoting code did not make it to the
release either.
* Reggie's MySQL native provider is also missing.
Enjoy!
Miguel.
-------------------------------------------------------------------------
Hello everyone!
We have made a new release of Mono available. Despite the fact
that we just did Mono 0.18, this release is packed with new features.
* Availability.
Mono 0.19 is available in package format from:
http://www.go-mono.com/download.html
We released packages for SuSE 8.0, Mandrake 8.2, Debian and various
Red Hat releases. It is also available from Red Carpet on the Mono
channel.
Source code for Mono, MCS, the Mono Debugger, XSP is available as
well from that web page.
* New in this release
* Remoting news:
Lluis has implemented and documented the Binary formatter
Woohoo! He has done a lot of work as well to support
remoting.
Patrik has also been working heavily on fixing a
number of remoting related bugs and missing features.
Ajay also implemented 1-d array serialization in System.Xml
* New database provider: IBM DB2
Christopher Bockner has contributed a DB2 data
provider for System.Data. We have a very complete
range of data providers.
* System.Web.Mobile
Gaurav has started work on this assembly, this will
allow us to run the unmodified reference ASP.NET
applications that were designed to support Mobile
browsing.
* System.Data and System.XML:
More implementation work on XmlDataDocument from Ville
and plenty of fixes from Atsushi.
* MacOS patches:
Paolo integrated John Duncan's and Benjamin Reed
patches to make Mono run on MacOS X out of the box.
* IsolatedStorage
The initial implementation of it was done by Jonathan
Pryor and included in this release.
* Compilers:
More work on the Mono Visual Basic compiler (it is now
included in the packages).
Plenty of bug fixes from Jackson, Miguel to the C#
compiler.
Patches from Francesco and Daniel to the VB.NET
support runtime.
* Debugger support
Plenty of updates to run the new Mono Debugger from Martin.
* Main missing bits:
Some of everyone's favorite patches or code chunks have not yet
been integrated, hopefully Mono 0.20 will have them:
* Zoltan's patch to run IKVM is not yet on this release
* Some parts of Patrik's remoting code did not make it to the
release either.
* Reggie's MySQL native provider is also missing.
Enjoy!
Miguel.
------------------------------------------------------------------------------
Happy new year!
The Mono team is proud to release Mono 0.18, with plenty of bug
fixes and improvements. If you are a happy 0.17 user, this
release is a happiness extension release. Many bugs in the
runtime, class libraries and C# compiler have been fixed.
Also, our special envoy in Japan has reported that there is
some naming confussion about the naming of Mono, as can be
seen in the following documentary material:
Atsushi Enomoto shows the source of confussion:
http://primates.ximian.com/~duncan/gallery/Duncan-in-Tokyo/DSCN0702
Nick and Duncan echo it:
http://primates.ximian.com/~duncan/gallery/Duncan-in-Tokyo/DSCN0703
* Availability
Mono 0.18 packages and source code is available for download from:
http://www.go-mono.com/download.html
Those using Red Carpet on Linux can install Mono 0.18 from
the Mono channel. The packages have already been pushed for
you.
At release time we have packages for Red Hat 8.0, 7.3,
7.2 and 7.1 and Mandrake 8.2.
* Contributors to this release
This release is brought to you by:
Alejandro Sanchez, Alp Toker, Atsushi Enomoto, Cesar Octavio
Lopez Netaren, Daniel Lopez (mod_mono), Daniel Morgan, Dennis
Hayes, Dick Porter, Dietmar Maurer, Duncan Mak, Eduardo
Garcia, Gaurav Vaish, Gonzalo Paniagua, Jackson Harper, Jaime
Anguiano, Jeroen Janssen, Johannes Roith, Jonathan Pryor, Juli
Mallett, Lluis Sanchez, Marco Ridoni, Martin Baulig, Miguel de
Icaza, Nick Drochak, Paolo Molaro, Patrik Torstensson, Piers
Haken, Rachel Hestilow, Rafael Teixeira, Ravi Pratap,
Sebastian Pouliot, Tim Coleman, Tim Hayes, Ville Palo, Zoltan
Varga.
* New in this release
VB.NET compiler:
Many improvements to the Mono VB.NET compiler.
ASP.NET:
Plenty of bug fixes in ASP.NET. Larger applications
can now be run with it. The authentication system has
been deployed, most changes are from Gonzalo.
We have a modified IBuySpy running (without Xslt)
If you want to run ASP.NET you can run it with either
our XSP proof-of-concept server, or with Daniel's
Apache module that can be fetched from CVS (module
name: mod_apache)
Type Reflector:
A Console, Gtk# and Windows.Forms tool to browse
compiled assemblies and examine the types on it, from
Jonathan Pryor.
Moving to NUnit 2.0
Nick continues the work on moving our test suite to NUnit 2.0
Mobile.Controls:
Gaurav has started work on the Mobile controls, which
are required to run some of the reference applications
in full-mode like IBuySpy.
Remoting:
The remoting infrastructure has got a big boost from
Lluis in this release.
System.Data/XML
Ville has been working on improving our System.Data
classes in the XML assembly.
Crypto:
Plenty of new crypto from Sebastien as well. A new
web page in our site can be used to track this.
http://www.go-mono.com/crypto.html
----------------------------------------------------------------------
Hello!
Version 0.17 of Mono has been released.
There are plenty of new features, bug fixes, new classes,
performance improvements, optimizations and much more
available in this release.
* Stats
2605 cvs commits to the Mono repository since October 1st, an
average of 37 commits per day including weekends.
212 commits to the Mono module.
1438 commits to the MCS module.
* Mono Improvements:
Work has begun to make the runtime run a finalizer thread and
invoke all the finalizers from this thread. This is the same
behavior as Java and the Microsoft runtime, but it is disabled
on this build.
Integrated the s390 work from Neale Ferguson.
Beginning of the work for pre-compiling code (Ahead of time
compilation) for Mono (based on the early work of Zoltan).
New option `--noboundscheck' for benchmark purposes, it
disables array bound checks.
Uses mmap instead of SysV shared memory for the Windows API
emulation layer.
Plenty of bug fixes, improvements and integration with the
upper layer class libraries.
New exception handling code uses the GCC native support for
stack-walking if available and gives big performance boost
(15% on mcs bootstrap).
A lot of the work in the new release of Mono is required for
the Mono Debugger (which will be released separately). The
Mono debugger is interesting, because it can debug both
managed and unmanaged applications, but it only supports the
JITer for debugging.
Dick, Dietmar, Gonzalo, Martin and Paolo were in charge of
most of these changes.
* Compiler improvements:
Many bug fixes as usual, better C# compliancy.
Performance improvements. The new release of the Mono C#
compiler is 37% faster than the previous version (self-compile
is down to 8 seconds). On my P4 1.8Ghz machine, the Mono C#
compiler compiles (342,000 lines per minute).
Thanks to go Ravi and Martin for helping out with the bug
fixing hunt.
* Cryptography and Security classes
Sebastien Pouliot and Andrew Birkett were extremely busy
during the past two months working on the cryptography
classes, many of the crypto providers are now working
Jackson on the other hand helped us with the security
classes, he said about those:
`Writing security classes is the most exciting thing I have
ever done, I can not wait to write more of them'.
* ASP.NET:
We have now moved the code from the XSP server (which was our
test bed for ASP.NET) into the right classes inside
System.Web, and now any web server that was built by using the
System.Web hosting interfaces can be used with Mono.
The sample XSP server still exists, but it is now just a
simple implementation of the WorkerRequest and ApplicationHost
classes and can be used to test drive ASP.NET. A big thanks
goes to Gonzalo who worked on this night and day (mostly
night).
Gaurav keeps helping us with the Web.Design classes, and
improving the existing web controls.
* ADO.NET:
New providers are available in this release. The relentless
System.Data team (Brian, Dan, Rodrigo, Tim and Ville) are
hacking non-stop on the databse code. Improving existing
providers, and new providers.
The new providers on this release:
* Oracle
* MS SQL
* ODBC
* Sybase
* Sqlite (for embedded use).
Many regression tests have been added as well (Ville has been
doing a great job here).
Brian also created a DB provider multiplexor (The ProviderFactory)
Stuart Caborn contributed Writing XML from a DataSet.
Luis Fernandez contributed constraint handling code.
Also there is new a Gtk# GUI tool from Dan that can be used to
try out various providers.
* System.XML:
Atsushi has taken the lead in fixing and plugging the missing
parts of the System.XML namespace, many fixes, many
improvements.
* CodeDom and the C# provider.
Jackson Harper has been helping us with the various interface
classes from the CodeDOM to the C# compiler, in this release
a new assembly joins us: Cscompmgd. It is a simple assembly,
and hence Microsoft decided not to waste an entire "System"
"dot" on it.
* Testing
Nick Drochak has integrated the new NUnit 2.0 system.
* Monograph:
Monograph now has a --stats option to get statistics on
assembly code.
CVS Contributors to this release:
Alejandro Sanchez, Alp Toker, Andrew Birkett, Atsushi Enomoto,
Brian Ritchie, Cesar Octavio Lopez Nataren, Chris Toshok,
Daniel Morgan, Daniel Stodden, Dennis Hayes, Dick Porter,
Diego Sevilla, Dietmar Maurer, Duncan Mak, Eduardo Garcia,
Ettore Perazzoli, Gaurav Vaish, Gonzalo Paniagua, Jackson
Harper, Jaime Anguiano, Johannes Roith, John Sohn, Jonathan
Pryor, Kristian Rietveld, Mads Pultz, Mark Crichton, Martin
Baulig, Martin Willemoes Hansen, Miguel de Icaza, Mike
Kestner, Nick Drochak, Nick Zigarovich, Paolo Molaro, Patrik
Torstensson, Phillip Pearson, Piers Haken, Rachel Hestilow,
Radek Doulik, Rafael Teixeira, Ravi Pratap, Rodrigo Moya,
Sebastien Pouliot, Tim Coleman, Tim Haynes, Ville Palo,
Vladimir Vukicevic, and Zoltan Varga.
(Am sorry, I could not track everyone from the ChangeLog
messages, I apologize in advance for the missing
contributors).
------------------------------------------------------------------------
Hello!
Version 0.16 of Mono has been released! This is mostly a bug
fix release, a lot of work has been going on to make existing
features more robust and less buggy. Also, contributions are
too varied, so it is hard to classify them in groups.
* Stats
795 commits to mono and mcs since August 23rd.
* News
The changes that got in this releases are mostly
bugfixes. Miguel, Martin and Ravi attacked lots of bugs in the
compiler, Dick fixed a bunch of bugs related to processes and
threads. Mark Crichton resumed his work on the SPARC port and
made lots of progress there. Juli Mallett has been working on
making sure Mono also builds on BSD systems. As usual, Dietmar
and Paolo supplied their continuous stream of fixes to the
runtime.
Dietmar has completed the work on the runtime side for
remoting support and we ship now with a sample channel, the
System.Runtime.Remoting.Sample. This can be used as a
reference implementation for anyone interested in implementing
other channels (like a CORBA channel).
Duncan got preliminary XSLT support done by using
libxslt.
Gonzalo (with some help from Patrik) has been working hard
making our ASP.NET implementation work on both Mono and MS by
migrating the existing xsp code to the class library. Gaurav
started working on the classes in System.Design.dll and Chris
Toshok checked in Mono.Directory.LDAP, which will be the
foundation to implement the System.DirectoryServices assembly.
Various fixes from Kral, Jason, Piers and Gonzalo were
committed to System.Xml; Martin Algiers reports that the
upcoming NAnt release will be fully compatible with Mono.
Miguel imported Sergey Chaban's Mono.PEToolkit and ilasm code
to CVS. Nick, as always, continues to refine our testing
framework by improving our tests. Andrew Birkett continues to
improve the implementation of our security/cryptographic
classes. Jonathan Pryor contributed type-reflector the our
list of tools.
* Other News From Behind de Curtain.
While the above is pretty impressive on its own, various other
non-released portions of Mono have been undergoing: Adam Treat
has been leading the effort to document our class libraries
and produce the tools required for it.
Martin Baulig has been working on the Mono Debugger which is
not being released yet. This debugger allows both native
Linux application as well as CIL applications to be debugged
at the same time (and in fact, you can use this to debug the
JIT engine). The debugger is written in C# with some C glue
In the meant A new JIT engine is under development, focused on
adding more of the high-end optimizations which will be
integrated on an ahead-of-time-compiler. Dietmar and Paolo
have been working on this.
* Contributors to this release
* Non-Ximian developers: Adam Treat, Andrew Birkett, Dennis
Hayes, Diego Sevilla, Franklin Wise, Gaurav Vaish ,Jason
Diamond, Johannes Roith, John Sohn, Jonathan Pryor, Juli
Mallett, Kral Ferch, Mike Crichton, Nick Drochak, Nick
Zigarovich, Piers Haken, Rafael Teixeira, Ricardo Fernandez
Pascual, Sergey Chaban, Tim Coleman.
* Ximian developers: Dietmar, Paolo, Dick, Duncan, Ravi,
Miguel, Martin, Chris, Joe, Gonzalo, Rodrigo.
---------------------------------------------------------------------------------
* Sergey Chaban added thread-safe support to
System.Collections.SortedList.
+7 -197
View File
@@ -1,184 +1,14 @@
This is Mono.
1. Installation
2. Using Mono
3. Directory Roadmap
Installation:
1. Compilation and Installation
===============================
Read doc/download for installation instructions,
or read the HTML version:
a. Build Requirements
---------------------
http://www.go-mono.com/download.html
To build Mono, you will need the following components:
* pkg-config
Available from: http://www.freedesktop.org/Software/pkgconfig
* glib 2.0
Available from: http://www.gtk.org/
Optional dependencies:
* ICU library
http://oss.software.ibm.com/icu/index.html
You will need this one to get complete support for the international
features of the .NET Framework.
* Cairo and libgdiplus
If you want to get support for System.Drawing, you will need to get
both Libgdiplus and Cairo.
b. Building the Software
------------------------
If you obtained this package as an officially released tarball,
this is very simple, use configure and make:
./configure --prefix=/usr/local
make
make install
Mono supports a JIT engine on x86, SPARC and PowerPC systems.
The various commands that ship with Mono default to the JIT engine
on x86 and SPARC, to turn it on for PPC systems, use the --with-jit=yes
command line option to configure.
MacOS X Users: you will need to download the latest Boehm GC
Alpha release for garbage collection to work properly.
If you obtained this as a snapshot, you will need an existing
Mono installation. To upgrade your installation, unpack both
mono and mcs:
tar xzf mcs-XXXX.tar.gz
tar xzf mono-XXXX.tar.gz
mv mono-XXX mono
mv mcs-XXX mcs
cd mono
./autogen.sh --prefix=/usr/local
make bootstrap
c. Building the software from CVS
---------------------------------
If you are building the software from CVS, make sure that you
have up-to-date mcs and mono sources:
cvs co mono mcs
Then, go into the mono directory, and configure:
cd mono
./autogen.sh --prefix=/usr/local
Depending on whether you have an existing Mono installation or
not, you can try the following:
i. If you have an existing Mono installation
-----------------------------------------
First verify that you have a working installation:
echo 'class X { static void Main () { System.Console.Write("OK");}}' > x.cs
Compile:
mcs x.cs
And run:
mono x.exe
If you get the output `OK' and no errors, and you have mono
version 0.31 or later, continue. Otherwise, you can try option
(ii) below.
You are ready to start your CVS upgrade. Compile with
make bootstrap
This will automatically go into the mcs/ tree and build the
binaries there, and copy them into the appropriate
sub-directories of mono/runtime/.
Now, go to step (iii) below.
ii. If you don't have a working Mono installation
---------------------------------------------
If you don't have a working Mono installation, an obvious choice
is to install the latest released packages of 'mono' for your
distribution and go back to step (i).
You can also try a slightly more risky approach that should work
almost all the time.
This works by first getting the latest version of the 'monolite'
distribution, which contains just enough to run the 'mcs'
compiler. You do this by
make get-monolite-latest
This should place a monolite-latest.tar.gz in the parent
directory of the 'mono' source tree. You can then run:
make monolite-bootstrap
This will automatically gunzip and untar the tarball, place the
files appropriately, and then complete the bootstrap.
iii. Testing and Installation
------------------------
You can run the mono and mcs testsuites with the command:
make -k bootstrap-check
Expect to find several testsuite failures, especially in the
mcs/ tree. As a sanity check, you can compare the failures you
got with
http://go-mono.com/tests/displayTestResults.php
You can now install it:
make install
Failure to follow these steps will result in a broken installation.
iv. Other useful "bootstrap"-like facilities
----------------------------------------
If you have a CVS snapshot that you keep updating periodically,
and/or do your development in, you may try using a couple of
specialty make targets that may be slightly faster than a
"make bootstrap".
You can try a two-stage bootstrap with:
make faststrap
This assumes that you have already run a "make bootstrap" on the
tree before.
If you want to avoid waiting even for that, you can try the
riskier one-stage build:
make fasterstrap
This should be attempted only if you're sure that the sources of
the mcs compiler itself and the sources of the libraries used by
it have not been changed.
2. Using Mono
=============
* Using Mono
Once you have installed the software, you can run a few programs:
@@ -199,17 +29,10 @@ This is Mono.
See the man pages for mono(1), mint(1), monodis(1) and mcs(2)
for further details.
3. Directory Roadmap
====================
* A directory roadmap:
doc/
Contains the web site contents.
docs/
Technical documents about the Mono runtime.
data/
Configuration files installed as part of the Mono runtime.
Contains documentation and the web site contents.
mono/
The core of the Mono Runtime.
@@ -240,17 +63,4 @@ This is Mono.
arch/
Architecture specific portions.
man/
Manual pages for the various Mono commands and programs.
scripts/
Scripts used to invoke Mono and the corresponding program.
runtime/
A directory holding a pre-compiled version of the Mono
runtime.
+2 -19
View File
@@ -3,35 +3,18 @@
#undef HAVE_MSG_NOSIGNAL
#undef HAVE_SOL_IP
#undef HAVE_SOL_TCP
#undef HAVE_SOL_IPV6
#undef HAVE_IP_PKTINFO
#undef HAVE_STRUCT_IP_MREQN
#undef HAVE_STRUCT_IP_MREQ
#undef HAVE_PTHREAD
#undef HAVE_PTHREAD_MUTEX_TIMEDLOCK
#undef USE_MONO_MUTEX
#undef HAVE_LARGE_FILE_SUPPORT
#undef PLATFORM_WIN32
#undef HAVE_NEW_ICONV
#undef NAME_DEV_RANDOM
#undef HAVE_CRYPT_RNG
#undef HAVE_BOEHM_GC
#undef USE_INCLUDED_LIBGC
#undef DISABLE_SHARED_HANDLES
#undef HAVE_TIMEZONE
#undef HAVE_TM_GMTOFF
#undef MONO_SIZEOF_SUNPATH
#undef MONO_ZERO_ARRAY_LENGTH
#undef PTHREAD_POINTER_ID
#undef HAVE_GC_H
#undef HAVE_GC_GCJ_MALLOC
#undef HAVE_GC_ENABLE
#undef WITH_BUNDLE
#undef HAVE_GETHOSTBYNAME2_R
#undef HAVE_ICU
#undef HAVE_KW_THREAD
#undef HAVE_SIGNBIT
#undef USE_MACH_SEMA
#undef HAVE_SOCKLEN_T
#undef HAVE_TRUNCL
#undef HAVE_AINTL
#undef HAVE_SCANDIR
#undef HAVE_WORKING_SIGALTSTACK
+4 -26
View File
@@ -8,17 +8,8 @@ srcdir=`dirname $0`
test -z "$srcdir" && srcdir=.
if [ -n "$MONO_PATH" ]; then
# from -> /mono/lib:/another/mono/lib
# to -> /mono /another/mono
for i in `echo ${MONO_PATH} | tr ":" " "`; do
i=`dirname ${i}`
if [ -n "{i}" -a -d "${i}/share/aclocal" ]; then
ACLOCAL_FLAGS="-I ${i}/share/aclocal $ACLOCAL_FLAGS"
fi
if [ -n "{i}" -a -d "${i}/bin" ]; then
PATH="${i}/bin:$PATH"
fi
done
ACLOCAL_FLAGS="-I $MONO_PATH/share/aclocal $ACLOCAL_FLAGS"
PATH="$MONO_PATH/bin:$PATH"
export PATH
fi
@@ -30,15 +21,8 @@ fi
DIE=1
}
if [ -z "$LIBTOOL" ]; then
LIBTOOL=`which glibtool 2>/dev/null`
if [ ! -x "$LIBTOOL" ]; then
LIBTOOL=`which libtool`
fi
fi
(grep "^AM_PROG_LIBTOOL" $srcdir/configure.in >/dev/null) && {
($LIBTOOL --version) < /dev/null > /dev/null 2>&1 || {
(libtool --version) < /dev/null > /dev/null 2>&1 || {
echo
echo "**Error**: You must have \`libtool' installed to compile Mono."
echo "Get ftp://ftp.gnu.org/pub/gnu/libtool-1.2d.tar.gz"
@@ -98,7 +82,7 @@ esac
if grep "^AM_PROG_LIBTOOL" configure.in >/dev/null; then
if test -z "$NO_LIBTOOLIZE" ; then
echo "Running libtoolize..."
${LIBTOOL}ize --force --copy
libtoolize --force --copy
fi
fi
@@ -124,12 +108,6 @@ automake --add-missing --gnu $am_opt ||
echo "Running autoconf ..."
autoconf || { echo "**Error**: autoconf failed."; exit 1; }
if test -d $srcdir/libgc; then
echo Running libgc/autogen.sh ...
(cd $srcdir/libgc ; NOCONFIGURE=1 ./autogen.sh "$@")
echo Done running libgc/autogen.sh ...
fi
conf_flags="--enable-maintainer-mode --enable-compile-warnings" #--enable-iso-c
+51
View File
@@ -0,0 +1,51 @@
/* config.h.in. Generated automatically from configure.in by autoheader 2.13. */
/* Define if you have the ANSI C header files. */
#undef STDC_HEADERS
#undef HAVE_INET_PTON
#undef HAVE_INET_ATON
#undef HAVE_SOL_IP
#undef HAVE_SOL_TCP
#undef HAVE_IP_PKTINFO
#undef HAVE_STRUCT_IP_MREQN
#undef HAVE_PTHREAD
#undef HAVE_PTHREAD_MUTEX_TIMEDLOCK
#undef USE_MONO_MUTEX
#undef HAVE_LARGE_FILE_SUPPORT
#undef PLATFORM_WIN32
#undef HAVE_NEW_ICONV
#undef NAME_DEV_RANDOM
#undef HAVE_CRYPT_RNG
#undef HAVE_BOEHM_GC
/* The number of bytes in a void *. */
#undef SIZEOF_VOID_P
/* Define if you have the inet_aton function. */
#undef HAVE_INET_ATON
/* Define if you have the inet_pton function. */
#undef HAVE_INET_PTON
/* Define if you have the <dlfcn.h> header file. */
#undef HAVE_DLFCN_H
/* Define if you have the <netdb.h> header file. */
#undef HAVE_NETDB_H
/* Define if you have the <sys/filio.h> header file. */
#undef HAVE_SYS_FILIO_H
/* Define if you have the <sys/sockio.h> header file. */
#undef HAVE_SYS_SOCKIO_H
/* Define if you have the <utime.h> header file. */
#undef HAVE_UTIME_H
/* Name of package */
#undef PACKAGE
/* Version number of package */
#undef VERSION
+163 -845
View File
File diff suppressed because it is too large. Load diff
-5
View File
@@ -1,5 +0,0 @@
Makefile.in
Makefile
config
.cvsignore
browscap.ini
File diff suppressed because it is too large. Load diff
+5 -13
View File
@@ -1,17 +1,9 @@
monodir = $(sysconfdir)/mono
EXTRA_DIST = config.in \
machine.config \
DefaultWsdlHelpGenerator.aspx \
browscap.ini.gz
EXTRA_DIST = config.in
mono_DATA = config \
machine.config \
DefaultWsdlHelpGenerator.aspx \
browscap.ini
CLEANFILES = browscap.ini
browscap.ini: browscap.ini.gz
gunzip -c $^ > $@
mono_DATA = config
config: config.in Makefile
sed -e 's^\@LIBC\@^libc.so.6^g' < $(srcdir)/config.in > config.tmp \
&& mv config.tmp config
Binary file not shown.
-5
View File
@@ -1,9 +1,4 @@
<configuration>
<dllmap dll="cygwin1.dll" target="@LIBC@" />
<dllmap dll="libc" target="@LIBC@" />
<dllmap dll="libxslt.dll" target="libxslt@libsuffix@" />
<dllmap dll="libmySQL.dll" target="libmysqlclient@libsuffix@" />
<dllmap dll="odbc32.dll" target="libodbc@libsuffix@" />
<dllmap dll="oci" target="clntsh" />
<dllmap dll="db2cli" target="libdb2_36@libsuffix@"/>
</configuration>
-210
View File
@@ -1,210 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<configSections>
<section name="appSettings" type="System.Configuration.NameValueFileSectionHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<section name="system.diagnostics" type="System.Diagnostics.DiagnosticsConfigurationHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<section name="system.runtime.remoting" type="System.Configuration.IgnoreSectionHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowLocation="false"/>
<sectionGroup name="system.web">
<section name="httpHandlers"
type="System.Web.Configuration.HttpHandlersSectionHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="httpModules"
type="System.Web.Configuration.HttpModulesConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="machineKey"
type="System.Web.Configuration.MachineKeyConfigHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="authentication"
type="System.Web.Configuration.AuthenticationConfigHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="authorization"
type="System.Web.Configuration.AuthorizationConfigHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="globalization"
type="System.Web.Configuration.GlobalizationConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="sessionState"
type="System.Web.SessionState.SessionStateSectionHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="trace"
type="System.Web.Configuration.TraceConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="webServices"
type="System.Web.Services.Configuration.WebServicesConfigurationSectionHandler, System.Web.Services, Version=1.0.5000.0 Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="webControls"
type="System.Web.Configuration.WebControlsSectionHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="compilation"
type="System.Web.Configuration.CompilationConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="httpRuntime"
type="System.Web.Configuration.HttpRuntimeConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="customErrors"
type="System.Web.Configuration.CustomErrorsConfigHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<section name="pages"
type="System.Web.Configuration.PagesConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral" />
<section name="clientTarget"
type="System.Web.Configuration.ClientTargetSectionHandler, System.Web, Version=1.0.5000.0, Culture=neutral" />
</sectionGroup>
<sectionGroup name="system.net">
<section name="settings"
type="System.Net.Configuration.NetConfigurationHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<section name="connectionManagement"
type="System.Net.Configuration.ConnectionManagementHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<section name="authenticationModules"
type="System.Net.Configuration.NetAuthenticationModuleHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<section name="defaultProxy"
type="System.Net.Configuration.DefaultProxyHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<section name="webRequestModules"
type="System.Net.Configuration.WebRequestModuleHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
</sectionGroup>
<section name="system.drawing" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
</configSections>
<system.net>
<connectionManagement>
<add address="*" maxconnection="2" />
</connectionManagement>
<authenticationModules>
<add type="System.Net.BasicClient, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<add type="System.Net.DigestClient, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<add type="System.Net.NtlmClient, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
</authenticationModules>
<defaultProxy>
<proxy />
<!-- bypassonlocal and proxyaddress are ok -->
<!-- usessystemdefault is not supported -->
</defaultProxy>
<webRequestModules>
<add prefix="http" type="System.Net.HttpRequestCreator, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<add prefix="https" type="System.Net.HttpRequestCreator, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<add prefix="file" type="System.Net.FileWebRequestCreator, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
</webRequestModules>
<settings>
<ipv6 enabled="false"/>
</settings>
</system.net>
<system.web>
<httpHandlers>
<add verb="*" path="Trace.axd" type="System.Web.Handlers.TraceHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add verb="*" path="*.aspx" type="System.Web.UI.PageHandlerFactory, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add verb="*" path="*.asmx" validate="false" type="System.Web.Services.Protocols.WebServiceHandlerFactory, System.Web.Services, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add verb="*" path="*.ashx" type="System.Web.UI.SimpleHandlerFactory, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add verb="GET" path="WebResource.axd" type="System.Web.Handlers.AssemblyResourceLoader, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add verb="*" path="*.asax" type="System.Web.HttpForbiddenHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add verb="*" path="*.ascx" type="System.Web.HttpForbiddenHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add verb="*" path="*.config" type="System.Web.HttpForbiddenHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add verb="*" path="*.cs" type="System.Web.HttpForbiddenHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add verb="*" path="*.rem" type="System.Runtime.Remoting.Channels.Http.HttpRemotingHandlerFactory, System.Runtime.Remoting, Culture=neutral, PublicKeyToken=b77a5c561934e089" validate="false" />
<add verb="*" path="*.soap" type="System.Runtime.Remoting.Channels.Http.HttpRemotingHandlerFactory, System.Runtime.Remoting, Culture=neutral, PublicKeyToken=b77a5c561934e089" validate="false" />
<add verb="GET,HEAD" path="*" type="System.Web.StaticFileHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add verb="*" path="*" type="System.Web.HttpMethodNotAllowedHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
</httpHandlers>
<httpModules>
<add name="FormsAuthentication" type="System.Web.Security.FormsAuthenticationModule, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add name="UrlAuthorization" type="System.Web.Security.UrlAuthorizationModule, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add name="Session" type="System.Web.SessionState.SessionStateModule, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add name="OutputCache" type="System.Web.Caching.OutputCacheModule, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
</httpModules>
<authentication mode="Forms">
<forms name=".MONOAUTH" loginUrl="login.aspx" protection="All" timeout="30" path="/">
<credentials passwordFormat="Clear">
<!--<user name="gonzalo" password="gonz"/>-->
</credentials>
</forms>
</authentication>
<machineKey validationKey="AutoGenerate" decryptionKey="AutoGenerate" validation="SHA1" />
<globalization requestEncoding="utf-8"
responseEncoding="utf-8"
fileEncoding="utf-8"/>
<!--
culture="en-US"
uiculture="en-US" />
-->
<sessionState mode="InProc" />
<webServices>
<protocols>
<add name="HttpSoap"/>
<add name="HttpPost"/>
<add name="HttpGet"/>
<add name="Documentation"/>
</protocols>
<wsdlHelpGenerator href="DefaultWsdlHelpGenerator.aspx" />
</webServices>
<webControls clientScriptsLocation="/web_scripts" />
<compilation debug="false" defaultLanguage="c#">
<compilers>
<compiler language="cs;c#;csharp" extension=".cs" warningLevel="1" compilerOptions=""
type="Microsoft.CSharp.CSharpCodeProvider, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<compiler language="vb;vbs;visualbasic;vbscript" extension=".vb"
warningLevel="1" compilerOptions=""
type="Microsoft.VisualBasic.VBCodeProvider, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
</compilers>
<assemblies>
<!--<add assembly="mscorlib" /> -->
<add assembly="System" />
<add assembly="System.Xml" />
<add assembly="System.Data" />
<add assembly="System.Web" />
<add assembly="System.Web.Services" />
<add assembly="System.Drawing" />
<add assembly="*" /> <!-- Add assemblies in bin directory -->
</assemblies>
</compilation>
<httpRuntime executionTimeout="90"
maxRequestLength="4096"
useFullyQualifiedRedirectUrl="false"
minFreeThreads="8"
minLocalRequestFreeThreads="4"
appRequestQueueLimit="100" />
<pages buffer="true"
enableSessionState="true"
autoEventWireup="true"
validateRequest="true" />
</system.web>
<system.runtime.remoting>
<application>
<channels>
<channel ref="http client" displayName="http client (delay loaded)" delayLoadAsClientChannel="true" />
<channel ref="tcp client" displayName="tcp client (delay loaded)" delayLoadAsClientChannel="true" />
</channels>
</application>
<channels>
<channel id="http" type="System.Runtime.Remoting.Channels.Http.HttpChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<channel id="http client" type="System.Runtime.Remoting.Channels.Http.HttpClientChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<channel id="http server" type="System.Runtime.Remoting.Channels.Http.HttpServerChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<channel id="tcp" type="System.Runtime.Remoting.Channels.Tcp.TcpChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<channel id="tcp client" type="System.Runtime.Remoting.Channels.Tcp.TcpClientChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<channel id="tcp server" type="System.Runtime.Remoting.Channels.Tcp.TcpServerChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
</channels>
<channelSinkProviders>
<clientProviders>
<formatter id="soap" type="System.Runtime.Remoting.Channels.SoapClientFormatterSinkProvider, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<formatter id="binary" type="System.Runtime.Remoting.Channels.BinaryClientFormatterSinkProvider, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
</clientProviders>
<serverProviders>
<formatter id="soap" type="System.Runtime.Remoting.Channels.SoapServerFormatterSinkProvider, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<formatter id="binary" type="System.Runtime.Remoting.Channels.BinaryServerFormatterSinkProvider, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<provider id="wsdl" type="System.Runtime.Remoting.MetadataServices.SdlChannelSinkProvider, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
</serverProviders>
</channelSinkProviders>
</system.runtime.remoting>
<appSettings>
<!--<add key="yourkey" value="your value" /> -->
<!--<remove key="a key defined higher in the hierarchy" /> -->
<!--<clear/> Removes all defined settings -->
</appSettings>
<system.diagnostics>
<trace autoflush="false" indentsize="4" />
</system.diagnostics>
<system.drawing>
</system.drawing>
<strongNames>
<pubTokenMapping>
<!-- ECMA key -->
<map Token="b77a5c561934e089" PublicKey="002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df" />
<!-- Microsoft (final) key -->
<map Token="b03f5f7f11d50a3a" PublicKey="002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df" />
<!-- Microsoft (Web Service Enhancement) key -->
<map Token="31bf3856ad364e35" PublicKey="002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df" />
<!-- IBM (DB2 Data Provider) key -->
<map Token="7c307b91aa13d208" PublicKey="002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df" />
</pubTokenMapping>
</strongNames>
</configuration>
+4
View File
@@ -0,0 +1,4 @@
Makefile.in
Makefile
all-docs
pending-classes.in
+32
View File
@@ -0,0 +1,32 @@
WEB_FILES= \
ado-net c-sharp class-library contact contributing documentation download \
faq gcc-frontend ideas index passport rationale resources \
roadmap runtime status team testing thanks tools porting anoncvs monodoc-xml winforms
OTHERS= pending resources-pending todo mono-build.sh mono-build-w32.sh
EXTRA_DIST = $(WEB_FILES) README $(OTHERS)
all-docs: $(WEB_FILES)
cat rationale roadmap c-sharp tools class-library \
runtime documentation download faq contributing \
resources status > all-docs
class-status: class-status.in pending-classes Makefile.am
cat class-status.in pending-classes > class-status
pending-classes:
#pending-classes: pending-classes.in Makefile.am
# echo "This is a list of pending classes, and links to their documentation on MSDN.Microsoft.com<p><p>" > pending-classes
# for i in `cat pending-classes.in`; do x=`echo $$i | sed s/\\\.//g`; link=`echo http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrf@@@ClassTopic.asp | sed "s/@@@/$$x/"`; echo " <a href=\"$$link\">$$i</a><br>" >> pending-classes; done
webit: dummy
(cd web; make && make push)
push-notes:
scp release-notes/mono* www@www:/web/cvsmodules/mono/archive
dummy:
+17
View File
@@ -0,0 +1,17 @@
To edit the website appearance:
cd doc/web
edit template.html.in
make
To edit website content:
cd doc (this directory)
edit files carefully
cd web
make
To publish changes:
cd web
make push
+801
View File
@@ -0,0 +1,801 @@
* ADO.NET
The coordinator for the ADO.NET implementation is <a
href="mailto:[email protected]">Rodrigo Moya</a>, with
the collaboration of <a href="mailto:[email protected]">Daniel
Morgan</a> and <a href="mailto:[email protected]">Tim Coleman</a>.
* Action plan
The current plan to implement ADO.NET is as follows:
<b>Step 1:</b> Initial <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfsystemdatasqlclient.asp?frame=true">System.Data.SqlClient</a> Provider:
<ul>
* Initial implementation of System.Data.SqlClient is based on
the <a href="http://www.postgresql.org/idocs/">PostgreSQL C API</a> which is a
client API to the PostgreSQL DBMS. PostgreSQL was chosen so we could quickly
create and test the System.Data classes.
* Once the <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfsystemdatasqlclient.asp?frame=true">System.Data.SqlClient</a>
code is functional and is usable by other people, we willl move it to
Mono.Data.PostgreSQL, and will convert the existing
System.Data.SqlClient to be just a wrapper around
Mono.Data.PostgreSQL.
</ul>
<b>Step 2:</b> <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfSystemDataOleDb.asp?frame=true">System.Data.OleDb</a> Provider:
<ul>
* <p>On Unix systems: System.Data.OleDb uses the
<a href="http://www.gnome-db.org/">LibGDA</a>
engine.
<p>LibGDA is a data access engine like ADO/OLE-DB, but for Unix. The
GDA in libGDA stands for GNU/GNOME Data Access, but it does not require GNOME.
It only requires glib2 and libxml2. LibGDA is used by
libgnomedb, GNOME-DB, and gaSQL.
<p>There is work under way to get libgda working under
Windows using Cygwin by the GNOME-DB developers.
<p>LibGDA has providers for MySQL, PostgreSQL, XML, ODBC,
Oracle, Interbase, Sybase/SQL server (via FreeTDS), IBM DB2,
SQLite and MDB Tools
(MS Access support).
* On Windows systems: System.Data.OleDb will use libgda as well,
if we can get it working, or OLE-DB as
its engine.
</ul>
<b>Step 3:</b> <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfsystemdatasqlclient.asp?frame=true">System.Data.SqlClient</a> Provider:
<ul>
* <p>System.Data.SqlClient will then become a managed
provider for Microsoft SQL Server, both on Windows and
Linux, to be compatible with applications written
for the Microsoft .NET Development Framework.
<p>Once Step 1 has been completed and the PostgreSQL
provider support has been moved to its own place at
Mono.Data.PostgreSQL, we will use
<a href="http://www.freetds.org/">FreeTDS</a> as the basis
for providing access to Microsoft SQL Server databases.
<P>FreeTDS is a C API for Unix and Windows that implements
the TDS (Tabular Data Stream) protocol used in accessing
Microsoft SQL Server and Sybase databases. A .NET Data Provider could be
created for Sybase databases as well, but this would be put in Mono.Data.Sybase.
</ul>
<b>Step 4:</b> <a href="http://msdn.microsoft.com/downloads/sample.asp?url=/MSDN-FILES/027/001/668/msdncompositedoc.xml&frame=true">System.Data.Odbc</a> Provider:
<ul>
* We will create a .NET Managaed Provider for ODBC
in System.Data.Odbc for those using ODBC.
On Unix and Windows, <a href="http://www.unixodbc.org/">unixODBC</a> mabye used.
iODBC is an alternative to using unixODBC.
<p>unixODBC works on Unix and Windows. Well, I have not actually
used it on Cygwin, but it does build and install without problems.
<p>unixODBC has providers for:
Oracle, Microsoft SQL Server and Sybase via FreeTDS,
MySQL, PostgreSQL, Informix, IBM DB2 (Universal Database),
Interbase, miniSQL (mSQL), AdabasD, Empress, YARD SQL, and others.
</ul>
<b>Step 5:</b> Other System.Data providers:
<ul>
* <p>The idea in Microsoft .NET System.Data is to have
a managed provider for each supported DBMS. System.Data.SqlClient
for Microsoft SQL Server.
System.Data.OracleClient for Oracle 8i and 9i.
<p>We will need to have Mono.Data.MySQL, Mono.Data.PostgreSQL,
Mono.Data.DB2, and Mono.Data.miniSQL. Others,
of course, are welcomed.
<p>System.Data has been designed so
non-database providers can be created too.
</ul>
* Current Status
<p>We are working on Steps 1, 2, and 5. We have only just begun on
steps 2 and 5 though. We still have tons and tons of stuff to do.
If you have any ideas, let us know.
<p>For Step 1, the PostgreSQL is starting to come together - it
still needs a lot of work.
<p>For Step 2, Rodrigo Moya has been working on System.Data.OleDb which uses libgda
which is an OLE-DB/ADO data access for Unix. The C-Sharp bindings to libgda
currently work - meaning they can compile, run, and you can connect to a
PostgreSQL database via libgda via the C-Sharp bindings to libgda. Basic
functionality (execution of commands, data retrieval, transactions, etc) are
now working. Current focus is on filling up the missing pieces (Data adapters
mainly).
<p>For Step 3, we need someone to start the FreeTDS .NET Data Provider so
we can have data access to Microsoft SQL Server and Sybase databases, or either
add the support in libgda.
<p>For Step 4, we need someone to start the unixODBC .NET Data Provider, or add
the support in libgda.
<p>For Step 5, we have just begun creating a Mono.Data .NET Provider - a MySQL
.NET Provider that uses the MySQL C Client Library. This provider is
found in Mono.Data.MySql. We can currently connect and do a SQL INSERT and insert
a row into a MySQL database. However, it currently only works on Cygwin because
the MySQL client library libmySQL.dll is different
from the library on Linux libmysqlclient.dll. Another problem, mysql thread functions
do not load for some reason. Also, the provider only runs if you use "mint" (the Mono
runtime interpreter). It does not work on "mono" (the Mono Just-In-Time compiler).
The C# Bindings to MySQL are thanks to Brad Meril.
<p>We are able to do simple CREATE TABLE, DROP TABLE, UPDATE, INSERT, and
DELETE SQL commands using the ExecuteNonQuery method in SqlCommand.
<p>We can execute multiple queries and do a NextResult() in SqlDataReader()
to get the next result set.
<p>We are also able to do simple aggregate functions,
ie, count(), sum(), min(), and max()
in a simple SELECT SQL query using the ExecuteScalar() now.
<p>We are also able to retrieve data with a simple SELECT SQL query
using ExecuteReader() which returns a SqlDataReader. We are able to
use GetSchemaTable() to get the meta data about the table columns.
We are able to Read() to get each row from the result set.
<p>Here is a sample of code that is based on PostgresTest.cs and
TestSqlDataReader.cs tests:
<pre>
static void SelectData (IDbConnection cnc) {
IDbCommand selectCommand = cnc.CreateCommand();
IDataReader reader;
selectCommand.CommandType = CommandType.Text;
selectCommand.CommandText =
"select * from pg_user;" +
"select * from pg_tables;" +
"select * from pg_database";
reader = selectCommand.ExecuteReader ();
do {
// get the DataTable that holds
// the schema
DataTable dt = rdr.GetSchemaTable();
if(rdr.RecordsAffected != -1) {
// Results for
// SQL INSERT, UPDATE, DELETE Commands
// have RecordsAffected >= 0
Console.WriteLine("Result is from a SQL Command (INSERT,UPDATE,DELETE). Records Affected: " + rdr.RecordsAffected);
}
else if (dt == null)
Console.WriteLine("Result is from a SQL Command not (INSERT,UPDATE,DELETE). Records Affected: " + rdr.RecordsAffected);
else {
// Results for
// SQL not INSERT, UPDATE, nor DELETE
// have RecordsAffected = -1
Console.WriteLine("Result is from a SQL SELECT Query. Records Affected: " + rdr.RecordsAffected);
// Results for a SQL Command (CREATE TABLE, SET, etc)
// will have a null reference returned from GetSchemaTable()
//
// Results for a SQL SELECT Query
// will have a DataTable returned from GetSchemaTable()
results++;
Console.WriteLine("Result Set " + results + "...");
// number of columns in the table
Console.WriteLine(" Total Columns: " +
dt.Columns.Count);
// display the schema
foreach (DataRow schemaRow in dt.Rows) {
foreach (DataColumn schemaCol in dt.Columns)
Console.WriteLine(schemaCol.ColumnName +
" = " +
schemaRow[schemaCol]);
Console.WriteLine();
}
int nRows = 0;
string output, metadataValue, dataValue;
// Read and display the rows
Console.WriteLine("Gonna do a Read() now...");
while(rdr.Read()) {
Console.WriteLine(" Row " + nRows + ": ");
for(c = 0; c < rdr.FieldCount; c++) {
// column meta data
DataRow dr = dt.Rows[c];
metadataValue =
" Col " +
c + ": " +
dr["ColumnName"];
// column data
if(rdr.IsDBNull(c) == true)
dataValue = " is NULL";
else
dataValue =
": " +
rdr.GetValue(c);
// display column meta data and data
output = metadataValue + dataValue;
Console.WriteLine(output);
}
nRows++;
}
Console.WriteLine(" Total Rows: " +
nRows);
}
} while(rdr.NextResult());
Console.WriteLine("Total Result sets: " + results);
rdr.Close();
}
</pre>
<p>We are able to get
String data (char, character, text, varchar), Int16 (smallint),
Int32 (integer), Int64 (bigint), DateTime (time, date, timestamp),
Boolean (boolean), Single (float), and Double (double).
More data types will come later. Note, the types that do work still
need thorough testing.
<p>Rows that are returned which contain columns that are NULL are handled now.
The SqlDataReader method IsDBNull() needs to be called to determine
if a field IS NULL before trying to read data from that field.
<p>Calling PostgreSQL stored procedures works. It does not work perfectly. It may not
even work to specification - yet. If you want to test it yourself, look at
TestSqlDataReader.cs or PostgresTest.cs in
mcs/class/System.Data/Test.
<p>Below, I have some sample code you can
use to call a PostgreSQL stored procedure named "version". This stored
procedure returns a string containing the PostgreSQL server version. Notice
the CommandType is StoredProcedure and the method ExecuteScalar() is called.
<p>ExecuteScalar() is a lightweight method in class SqlCommand that only returns
one row and one column as one object - even if there is more than row or column.
<pre>
static string GetDatabaseServerVersion (SqlConnection cnc)
{
SqlCommand cmd = cnc.CreateCommand ();
string data;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "version";
data = (string) cmd.ExecuteScalar ();
return data;
}
</pre>
<p>We have the beginnings of Parameters support PostgreSQL. Only
Input Parameters are currently supported. Output, Input/Output,
and Return parameters still need to be done.
<p>A lot of functionality in System.Data is missing, but the
infrastructure is starting to come together.
<p>A lot of Exceptions need to be thrown for various exceptions. However,
SqlException, SqlErrorCollection, and SqlError have been partially
implemented.
<p>Tim Coleman and Rodrigo Moya got the beginnings of the
SqlDataAdapter/DataSet/DataTable/DataRow to work. Currently,
the SqlDataAdapter can Fill() relational data into a DataTable in a DataSet.
See the test mcs/class/System.Data/Test/TestSqlDataAdapter.cs to see it in action.
Below, I show a snippets from the test:
<pre>
string connectionString;
string sqlQuery;
SqlDataAdapter adapter;
DataSet dataSet = null;
connectionString =
"host=localhost;" +
"dbname=test;" +
"user=postgres";
sqlQuery = "select * from pg_tables";
adapter = new SqlDataAdapter (sqlQuery,
connectionString);
dataSet = new DataSet ();
adapter.Fill (dataSet);
if (dataSet != null) {
foreach (DataRow row in dataSet.Tables["Table"].Rows)
Console.WriteLine("tablename: " + row["tablename"]);
}
</pre>
<p>We do need help on the DataSet/DataAdaptor/DataTable/DataRelation/XML
functionality so we can integrate with
the ASP.NET controls and Windows.Forms controls by allowing the controls to bind
to a data source. Gonzalo, Gaurav, Leen, Patrik, Duncan, and others are
working very hard on the ASP.NET support. If you want to help,
contact <a href="mailto:[email protected]">Gonzalo Paniagua Javier</a>
<P>Need to add XML support in System.Data. This involves working on
the classes: DataSet and XmlDataDocument and the ExecuteXmlReader() in SqlCommand.
<p>The System.Data.dll gets built with the rest of the class library.
To compile the System.Data.dll assembly separately, you need:
<b>On Unix</b>
<ul>
* update your mono sources. Be sure you have latest mcs.exe
and .dll's, since there have been many fixes needed for
compilation on Linux.
* compile System.Data.dll:
<pre>
cd mcs/class/System.Data<br>
mcs --target library -o System.Data.dll @list
</pre>
</ul>
<b>On Windows</b>
<ul>
* update your mono sources. Be sure you have latest mcs.exe
and .dll's. You can use the same method as Linux,
or you can use NAnt.
* To use NAnt:
<pre>
cd mcs/class/System.Data
../../nant/NAnt.exe
</pre>
This will automatically copy the System.Data.dll to Test.
If you need to do a clean for the System.Data.dll assembly,<br><br>
<pre>
cd mcs/class/System.Data
../../nant/NAnt.exe clean
</pre>
</ul>
* Testing
<p>In order to test System.Data.SqlClient, you will need to have
access to a remote PostgreSQL DBMS, or you will have to install
one locally. PostgreSQL is the DBMS used for the initial
implementation of System.Data.SqlClient.
<p>Why? Because it is free software, has a client
library that is easy to use, PostgreSQL is easy to install on
Unix and Windows (using the Cygwin install program), not difficult to setup after
installation, and it runs under: Linux,
Windows (via cygwin and ipc-daemon), Unix, and
others. This allowed us to create the
System.Data functionality in Mono much quicker.
<p>If you plan on using a remote PostgreSQL DBMS Server,
than you will need to have the PostgreSQL client software on your
local computer that includes libpq.so (pq.dll on Windows).
<p>The System.Data tests use this connection string to connect
to the PostgreSQL database named "test" at host "localhost" as
user "postgres".
<pre>
"host=localhost;dbname=test;user=postgres"
</pre>
<p>Installation instructions for PostgreSQL DBMS:
<b>On Unix</b>
<ul>
* Read the PostgreSQL Installation Instructions
at \usr\doc\postgresql-x.x.x\html\installation.html
* Depending on your Unix system,
PostgreSQL maybe already installed, a database user 'postgres' created,
a linux user 'postgres' created and initdb ran. Or maybe not.
<pre>
su
adduser postgres
mkdir /usr/local/pgsql/data
chown postgres /usr/local/pgsql/data
su - postgres
initdb -D /usr/local/pgsql/data
postmaster -i -D /usr/local/pgsql/data
createdb test
psql test
</pre>
* Make sure you have a database user named postgres. It is best to install
the PostgreSQL DBMS under linux user postgres. When you run the postmaster,
run it under the user postgres as well. If this was not done, then you
will need to create a user named postgres for the System.Data tests.
* If you already installed PostgeSQL and you do not have a database
user named postgres, then you can create user postgres using psql:
<pre>
psql test
create user postgres with password 'fun2db';
</pre>
* The postmaster must be run with -i option.
* In the /usr/local/pgsql/data/pg_hba.conf file, you need
to have the AUTH_TYPE set to md5. You can read more on this at
/usr/doc/postgresql-7.2.1/html/client-authentication.html
or wherever your
PostgreSQL html docs are located. See the 2nd line below,
host 127.0.0.1 has an AUTH_TYPE md5 in pg_hba.conf.
<pre>
# TYPE DATABASE IP_ADDRESS MASK AUTH_TYPE
local all trust
host all 127.0.0.1 255.255.255.255 md5
</pre>
* If you can not find your PostgreSQL documentation locally or you
did not install it, then you
can get it <a href="http://www.postgresql.org/idocs/">here</a>.
</ul>
<b>On Windows</b>
<ul>
* Use the <a href="http://www.cygwin.com/">Cygwin</a> installer to
install the PostgreSQL DBMS. It is
found in the database category.
* <p>Read the file postgres-x.x.README at /usr/doc/Cygwin and read
the requirements to install PostgreSQL. Those requirements
are included with cygwin except cygipc. A default installtion
of cygwin does not install everything you will need, so on the
safe side, just include everything when installing cygwin.
* <p>The -x.x in postgres-x.x is the version of your PostgreSQL DBMS.
* <p>Once Cygwin has installed the PostgreSQL DBMS on your computer,
read the file FAQ_MSWIN which is available
in /usr/doc/postgres-x.x
* <p>Important notes from this file are:
<ul>
<p><b>2.</b> - Install the latest <a href="http://www.neuro.gatech.edu/users/cwilson/cygutils/OBSOLETE/V1.1/cygipc/index.html">CygIPC</a> package.
<p>The cygipc package contains the ipc-daemon you will need
to run before you can
run the PostgreSQL DBMS Server daemon (postmaster) or run
initdb which initializes the PostgreSQL database.
<p><b>3.</b> The Cygwin bin directory has to be placed in
the path before the Windows program directories,
for example, C:\cygwin\bin
<p><b>My own note.</b> In the Windows control panel, I set
the environment variables PATH to my cygwin /usr/local/bin,
/usr/bin, and /bin. I also set my LD_LIBRARY_PATH to
/usr/local/lib and /usr/lib. For example:
<p>
<pre>
PATH=c:\cygwin\usr\local\bin;c:\cygwin\usr\bin;c:\cygwin\bin;
LD_LIBRARY_PATH=c:\cygwin\usr\local\lib;c:\cygwin\usr\lib;
</pre>
<p><b>4.</b> Start the ipc-daemon that came with the cygipc
package. There
are two ways to do this: run it from the command line as:
<p>
<pre>
ipc-daemon &
</pre>
<p>or you can set it up as a Windows service. See the
file cygrunsrv.README at /usr/doc/Cygwin on how to do this
for ipc-daemon and postmaster. Note the
troubleshooting section at the end of
the cygrunsrv.README file.
<p>To install ipc-daemon as a service,
you just have to run
<p>
<pre>
ipc-daemon --install-as-service' (--remove-as-service)
</pre>
<p>and then run
<pre>
net start ipc-daemon
</pre>
</ul>
<p>Read the installation.html file
at /usr/doc/postgresql-x.x/html/installation.html
<p>You will see in this file that you will need to
run the following commands:
<p>
<pre>
mkdir /usr/local/pgsql/data
initdb -D /usr/local/pgsql/data
postmaster -D /usr/local/pgsql/data
createdb test
psql test
</pre>
<p>When you need to connect to the database,
you will need ipc-daemon and postmaster running. Start ipc-daemon
before any of the command above. If you restart your computer, you
need to start ipc-daemon and postmaster either manually or as a
service.
<p>psql is a command-line PostgreSQL client tool to
enter and run SQL commands and queries.
<p>If there is no database user named postgres, create a user named
postgres with the following SQL command in the client tool psql:
<p>
<pre>
psql test
create user postgres with password 'fun2db';
</pre>
<p>The only reason I say this is so you can easily use the System.Data tests
without having to change the database, userid, etc.
</ul>
<p>In the path mcs/class/System.Data/Test
there is a PostgreSQL test program named
PostgreTest.cs. Thanks goes to Gonzalo for creating the original
PostgreSQL test.
<p>To use it to test System.Data, you
modify the file to your PostgreSQL database
connection requirements:
<p>
<ul>
<li><b>dbname</b> database, ie., test</li>
<li><b>host</b> hostname of the PostgreSQL DBMS Server to connect to, ie., localhost</li>
<li><b>user</b> username, ie., someuser</li>
<li><b>password</b> password, ie., mypass1234</li>
</ul>
<p>The connection string is in OLE-DB connection string format. Internally,
SqlConnection converts this to the PostgreSQL connection string format.
<p>
<pre>
OLE-DB: "host=localhost;dbname=test;user=joe;password=smoe"
PostgreSQL: "host=localhost dbname=test user=joe password=smoe"
</pre>
<p>
Note that OLE-DB includes the semicolons while PostgreSQL's connection
string does not.
<p>
To compile the PostgresTest.cs program, do:
<p>
<pre>
mcs PostgresTest.cs -r System.Data.dll
</pre>
<p>
To run using mint, do:
<p>
<pre>
mint PostgresTest.exe
</pre>
<p>
To run using mono, do:
<pre>
mono PostgresTest.exe
</pre>
<p>Below, I show how the output from PostgresTest. I have omitted a lot
of the meta data for the columns except two columns. The classes
used were from System.Data.SqlClient and were used to connect to a
PostgreSQL database and retrieve data.
<p>
<pre>
danmorg@DANPC ~/mono/mcs/class/System.Data/Test
$ mcs PostgresTest.cs -r System.Data.dll
danmorg@DANPC ~/mono/mcs/class/System.Data/Test
$ mono PostgresTest.exe
Postgres provider specific tests...
Drop table:
Error (don't worry about this one)SqlError:PGRES_FATAL_ERROR ERROR: table "mono
_postgres_test" does not exist
<Stack Trace>
Create table with all supported types:
OK
Insert values for all known types:
OK
Update values:
OK
Insert values for all known types:
OK
Aggregate: count(*)
Agg Result: 2
Aggregate: min(text_value)
Agg Result: This is a text
Aggregate: max(int4_value)
Agg Result: 1048000
Aggregate: sum(int4_value)
Agg Result: 1048003
Select values from the database:
Result is from a SELECT SQL Query. Records Affected: -1
Result Set 1...
Total Columns: 28
ColumnName = boolean_value
ColumnOrdinal = 1
ColumnSize = 1
NumericPrecision = 0
NumericScale = 0
IsUnique = False
IsKey =
BaseCatalogName =
BaseColumnName = boolean_value
BaseSchemaName =
BaseTableName =
DataType = System.Boolean
AllowDBNull = False
ProviderType = 16
IsAliased = False
IsExpression = False
IsIdentity = False
IsAutoIncrement = False
IsRowVersion = False
IsHidden = False
IsLong = False
IsReadOnly = False
...
ColumnName = null_timestamp_value
ColumnOrdinal = 28
ColumnSize = 8
NumericPrecision = 0
NumericScale = 0
IsUnique = False
IsKey =
BaseCatalogName =
BaseColumnName = null_timestamp_value
BaseSchemaName =
BaseTableName =
DataType = System.DateTime
AllowDBNull = False
ProviderType = 1184
IsAliased = False
IsExpression = False
IsIdentity = False
IsAutoIncrement = False
IsRowVersion = False
IsHidden = False
IsLong = False
IsReadOnly = False
Gonna do a Read() now...
Row 0:
Col 0: boolean_value: False
Col 1: int2_value: 5
Col 2: int4_value: 3
Col 3: bigint_value: 9
Col 4: float_value: 3.141590
Col 5: double_value: 3.14159
Col 6: numeric_value: 123456789012.345
Col 7: char_value: Mono.Data!
Col 8: varchar_value: It was not me!
Col 9: text_value: We got data!
Col 10: point_value: (1,0)
Col 11: time_value: 01/01/1 21:13:14
Col 12: date_value: 02/29/2000 00:00:00
Col 13: timestamp_value: 02/29/2004 14:00:11
Col 14: null_boolean_value is NULL
Col 15: null_int2_value is NULL
Col 16: null_int4_value is NULL
Col 17: null_bigint_value is NULL
Col 18: null_float_value is NULL
Col 19: null_double_value is NULL
Col 20: null_numeric_value is NULL
Col 21: null_char_value is NULL
Col 22: null_varchar_value is NULL
Col 23: null_text_value is NULL
Col 24: null_point_value is NULL
Col 25: null_time_value is NULL
Col 26: null_date_value is NULL
Col 27: null_timestamp_value is NULL
Row 1:
Col 0: boolean_value: True
Col 1: int2_value: -22
Col 2: int4_value: 1048000
Col 3: bigint_value: 123456789012345
Col 4: float_value: 3.141590
Col 5: double_value: 3.14159
Col 6: numeric_value: 123456789012.345
Col 7: char_value: This is a char
Col 8: varchar_value: This is a varchar
Col 9: text_value: This is a text
Col 10: point_value: (1,0)
Col 11: time_value: 01/01/1 21:13:14
Col 12: date_value: 02/29/2000 00:00:00
Col 13: timestamp_value: 02/29/2004 14:00:11
Col 14: null_boolean_value is NULL
Col 15: null_int2_value is NULL
Col 16: null_int4_value is NULL
Col 17: null_bigint_value is NULL
Col 18: null_float_value is NULL
Col 19: null_double_value is NULL
Col 20: null_numeric_value is NULL
Col 21: null_char_value is NULL
Col 22: null_varchar_value is NULL
Col 23: null_text_value is NULL
Col 24: null_point_value is NULL
Col 25: null_time_value is NULL
Col 26: null_date_value is NULL
Col 27: null_timestamp_value is NULL
Total Rows Retrieved: 2
Total Result sets: 1
Call ExecuteReader with a SQL Command. (Not INSERT,UPDATE,DELETE
).
Result is from a SQL Command not (INSERT,UPDATE,DELETE). Records Affected: -1
Total Result sets: 0
Call ExecuteReader with a SQL Command. (Is INSERT,UPDATE,DELETE)
.
Result is from a SQL Command (INSERT,UPDATE,DELETE). Records Affected: 1
Total Result sets: 0
Calling stored procedure version()
Result: PostgreSQL 7.2.1 on i686-pc-cygwin, compiled by GCC 2.95.3-5
Database Server Version: PostgreSQL 7.2.1 on i686-pc-cygwin, compiled by GCC 2.9
5.3-5
Clean up...
Drop table...
OK
RESULT: 0
</pre>
+70
View File
@@ -0,0 +1,70 @@
* Anonymous CVS access
Anonymous access to the Mono is available currently from three
servers (anoncvs-spain-1.go-mono.com,
anoncvs-spain-2.go-mono.com and anoncvs-us-1.go-mono.com).
You can also use `anoncvs.go-mono.com', and that will pick a
server automatically for you.
Sources are currently being updated every hour.
** Checking out the sources
To check out the sources for the first time from the
repository, use this command:
<pre>
export CVSROOT=:pserver:[email protected]:/mono
cvs login
cvs -z3 co mcs mono gtk-sharp
</pre>
That will get you the compiler and class libraries (mcs), the
interpreter and JITer (mono) and the Gtk# bindings.
The server is located in Spain.
** Updating the sources
To update your sources every day, you use this command:
<pre>
export CVSROOT=:pserver:[email protected]:/mono
cvs -z3 update -dP mcs mono gtk-sharp
</pre>
** Thanks
Thanks to <a href="http://www.hispalinux.es">HispaLinux</a>
for providing this Anon CVS server. The server is located in
Spain.
Special thanks to Jesus Climent, Rodrigo Moya, Juantomás
García and Ismael Olea for making this happen.
<a name="#mirror">
** Becoming an AnonCVS mirror
To become an AnonCVS mirror, you currently need about 20
megabytes of free disk space and bandwidth that you do not
mind sharing (you probably want enough to spare).
I need to be able to rsync to your machine from the main CVS
server. The preferred method to rsync is to setup ssh in your
machine.
The requirements are:
<ul>
* An account where we can ssh into.
* rsync.
* AnonCVS setup with the same paths as the rest of the
servers.
* Currently, about 40 megabytes of disk space, but this
will likely grow as the project evolves.
* A sysadmin contact e-mail address.
</ul>
Executable
+130
View File
@@ -0,0 +1,130 @@
* ASP.NET
ASP.NET support is divided in two pieces:
<ul>
* Web Forms (Web Applications infrastructure).
* Web Services (the SOAP-based rpc system).
</ul>
There is work underway for both systems. The Web Forms
support is more advanced at this point, and various ".aspx"
programs can be run using the Mono runtime and the XSP page
parser.
Tim started work on the Web Services. Although we have a
SoapFormatter as part of the remoting infrastructure already
(contributed by Jesus), most people will be using the ASP.NET
Web Services support. Work for the supporting class libraries
just started recently.
* Web Forms: The pieces
There are a couple of components to the puzzle:
<ul>
* .aspx page parser (converts .aspx to C# code).
* System.Web.HttpRuntime support.
* Web controls (System.Web.UI.HtmlControls and
System.Web.UI.WebControls).
* Underlying infrastructure for the controls (System.Web.UI).
* HttpRuntime.ProcessRequest is the core of the ASP.NET
implementation.
</ul>
Gonzalo has been working on an ASP.NET parser that takes .aspx
files and generated the code required to run them (the code lives in
module `xsp' along with a little web server for testing).
Most of the runtime support was written by Patrik Torstensson
(now at Intel). This was interesting, because in order to implement
some of its features, Patrik had to go into the runtime/JIT engine and
he spent a few weeks doing work there.
The classes for running ASP.NET are being actively written.
Gaurav, Leen and Patrik worked in the core of the classes
required to run ASP.NET web application as well as a small
embeddable web server.
Duncan got our System.Web assembly to compile.
** HttpRuntime
Patrik has authored most of the HttpRuntime support (both on
the System.Web and on the foundation).
He is now working on finishing HttpRuntime and a few needed
classes.
** XSP
Currently XSP provides the .aspx compiler to C#.
There is also a small web server for testing in module xsp
along with a bunch of .aspx pages to test the server.
The C# code generator is being moved to System.Web.Compilation.
Gonzalo is in charge of the compiler.
** Controls
A lot of work has been put in the various classes that
implement the controls (UI.HtmlControls and UI.WebControls),
but they have been coded mostly in the dark, and without being
able to test them in real life: Gaurav and Leen worked very
hard on this namespace.
We can now render all HtmlControls and almost all WebControls.
DataGrid and DataList controls are being finisehd by Gaurav.
Xml control needs some work on System.Xml related to XSL.
** Extending ASP.NET
Currently you have to reference in your ASP.NET the control
and all of its properties, which works fine if you have a GUI
designer, but is harder for people used to develop using text
editors.
Since we have a parser, we could extend this parser to allow
people to still use ASP.NET controls, using a simpler syntax.
For example people doing blogs and editing their templates
over the web probably do not want to use direct ASP.NET but a
wrapper around it.
** Roadmap
1. The Parser.
2. Get the parser to generate output compatible with ASP.NET.
3. Run the sample output with the real Microsoft runtime
but using our generated page.
4. Run the sample with our classes with the .NET runtime.
5. Run the samples with our classes with the our runtime (without
using HttpRuntime).
6. Finish HttpRuntime.
<b>We are here</b>.
7. Running our sample code with our classes with our runtime.
** How to Help
Testing and fixing HtmlControls, WebControls and validators is an
easy way to help.
In the CVS module XSP you can find the aspx to C# page parser,
a little web server used for testing and a directory containing
sample aspx pages.
You have some documentation under doc directory and in the README
file of each directory. They explain how to test our System.Web.
Testing is really easy!
+37
View File
@@ -0,0 +1,37 @@
* C# Books
A Programmer's Introduction to C# - Second Edition: Eric Gunnerson
* Remoting
<a href="http://www.dotnetremoting.cc/book/AdvancedDotNetRemoting.asp">
Advanced .NET Remoting: Ingo Rammer</a>
* Compiler Implementation
Compilers - Principles, Techniques, and Tools: Alfred V. Aho, Ravi Sethi,
Jeffrey D. Ullman
Advanced Compiler Design Implementation: Steven S. Muchnick
Modern Compiler Implementation in C: Andrew W. Appel
A Retargetable C Compiler - Design and Implementation: C. Fraser, David
Hanson
* Reference Manuals
<a
href="http://developer.intel.com/design/pentium/manuals/24319101.pdf">Intel
Architecture Software Developer's Manual, Volume 2 - Instruction Set Reference Manual</a>
<a
href="http://www.caldera.com/developers/devspecs/abi386-4.pdf">System V ABI
- i386 Architecture Processor Supplement</a>
<a
href="http://www.caldera.com/developers/devspecs/mipsabi.pdf">System V ABI -
MIPS Processor supplement</a>
<a href="http://www.sparc.org/standards/V8.pdf">The SPARC Architecture
Manual Version 8</a>
+200
View File
@@ -0,0 +1,200 @@
* MCS: The Ximian C# compiler
MCS is currently 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 half a million
lines of C# code.
We are in feature completion mode right now. There are still
a couple of areas that are not covered by the Mono compiler, but
they are very very few at this point (security attributes),
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.
A test suite is maintained to track the progress of
the compiler and various programs are routinely compiled and
ran.
** Obtaining MCS
The Mono C# compiler is part of the `mcs' module in the Mono CVS
you can get it from our <a href="anoncvs.html">Anonymous CVS</a> server,
or you can get nightly <a href="download.html">download page</a>.
** 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
The compiler has a number of phases:
<ul>
* 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.
</ul>
** CIL Optimizations.
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.
** History
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
our compiler self hosting on March 12, 2002.
** Questions and Answers
Q: Why not write a C# front-end for GCC?
A: I wanted to learn about C#, and this was an exercise in this
task. The resulting compiler is highly object-oriented, which has
lead to a very nice, easy to follow and simple implementation of
the compiler.
I found that the design of this compiler is very similar to
Guavac's implementation.
Targeting the CIL/MSIL byte codes would require to re-architecting
GCC, as GCC is mostly designed to be used for register machines.
The GCC Java engine that generates Java byte codes cheats: it does
not use the GCC backend; it has a special backend just for Java, so
you can not really generate Java bytecodes from the other languages
supported by GCC.
Q: If your C# compiler is written in C#, how do you plan on getting
this working on a non-Microsoft environment.
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
Java that I later ported to C#. This means that error recovery is
not as nice as I would like to, and for some reason error
productions are not being caught.
In the future I want to port one of the Bison/Java ports to C# for
the parser.
Q: Should someone work on a GCC front-end to C#?
A: I would love if someone does, and we would love to help anyone that
takes on that task, but we do not have the time or expertise to
build a C# compiler with the GCC engine. I find it a lot more fun
personally to work on C# on a C# compiler, which has an intrinsic
beauty.
We can provide help and assistance to anyone who would like to work
on this task.
Q: Should someone make a GCC backend that will generate CIL images?
A: I would love to see a backend to GCC that generates CIL images. It
would provide a ton of free compilers that would generate CIL
code. This is something that people would want to look into
anyways for Windows interoperation in the future.
Again, we would love to provide help and assistance to anyone
interested in working in such a project.
Q: What about making a front-end to GCC that takes CIL images and
generates native code?
A: I would love to see this, specially since GCC supports this same
feature for Java Byte Codes. You could use the metadata library
from Mono to read the byte codes (ie, this would be your
"front-end") and generate the trees that get passed to the
optimizer.
Ideally our implementation of the CLI will be available as a shared
library that could be linked with your application as its runtime
support.
Again, we would love to provide help and assistance to anyone
interested in working in such a project.
Q: But would this work around the GPL in the GCC compiler and allow
people to work on non-free front-ends?
A: People can already do this by targeting the JVM byte codes (there
are about 130 compilers for various languages that target the JVM).
Q: Why are you writing a JIT engine instead of a front-end to GCC?
A: The JIT engine and runtime engine will be able to execute CIL
executables generated on Windows.
You might also want to look at the <a href="faq.html#gcc">GCC</a>
section on the main FAQ
+138
View File
@@ -0,0 +1,138 @@
* CVS Access
If you are an active Mono developer, you can get a CVS account
that hosts the Mono source code.
If you are not a developer, but want to track the development, please
see the <a href="anoncvs.html">AnonCVS</a> instructions.
Send an e-mail to miguel with your public SSH key for this
purpose. Please specify if the key was generated with SSH1 or SSH2.
If you are using SSH2, please generate your key using:
<pre>
ssh-keygen -t rsa
</pre>
And mail me the id_rsa.pub file.
If you are using SSH1, run:
<pre>
ssh-keygen
</pre>
And mail me your identity.pub file.
You will need CVS and SSH. Windows users can get both by
installing Cygwin (<a
href="http://www.cygwin.com">http://www.cygwin.com</a>)
Unix users will probably have those tools installed already.
** Checking out the sources
To check out the sources for the first time from the
repository, use this command:
<pre>
export CVS_RSH=ssh
export [email protected]:/cvs/public
cvs -z3 co mcs mono
</pre>
** Updating your sources
Every day people will be making changes, to get your latest
updated sources, use:
<pre>
cvs -z3 update -Pd mcs mono
</pre>
Note: The '-z3' enables compression for the whole cvs action.
The '-Pd' makes the update operation (P)rune directories that
have been deleted and get new (d)irectories added to the
repository.
** Making patches
Usually you will want to make a patch to contribute, and let
other people review it before commiting it. To obtain such a
"patch", you type:
<pre>
cd directory-you-want-to-diff
cvs -z3 diff -u > file.diff
mail [email protected] < file.diff
</pre>
** Keeping track of changes.
We provide two e-mail based mechanisms to keep track of
changes to the code base:
<ul>
* <a href="mailto:[email protected]">
[email protected]</a>: This mailing list receives
in patch form all the changes that are being made to the
CVS.
* <a href="mailto:[email protected]">
[email protected]</a>: This mailing list only
receives the CVS commit logs with a list of files
modified.
</ul>
We hope to offer LXR and Bonsai in the future as well.
** Commiting your work
Once you get approval to commit to the CVS, or if you are
commiting code that you are the maintainer of, you will want
to commit your code to CVS.
To do this, you have to "add" any new files that you created:
<pre>
cvs add new-file.cs
</pre>
And then commit your changes to the repository:
<pre>
cvs commit file-1.cs file-2.cs
</pre>
** The Mailing List
To keep track of the various development and changes to the
CVS tree, you can subscribe to the [email protected].
To subscribe, send an email message to
[email protected] and in the body of the
message put `subscribe'.
This will send you an email message every time a change is
made to the CVS repository, together with the information that
the author of the changes submitted.
** Recommendations
Please do not commit code that would break the compile to the
CVS, because that normally wastes everybody's time. Two things
are important in this step: trying to build your sources and making
sure that you add all the new files before you do a commit.
To build the sources, most of the type trying the `make' command
is enough. In some cases (the class libraries) we use nant, so
you need to run nant manually.
Use ChangeLog entries so we can keep textual descriptions of
your work, and use the contents of your ChangeLog file as the
CVS commit message (ie, paste the contents of this into the
editor buffer).
If you are making changes to someone else's code, please make
sure you get in touch with the maintainer of that code before
applying patches. You want to avoid commiting conflicting
work to someone else's code.
+190
View File
@@ -0,0 +1,190 @@
* The Class Library
The Class Library should be compatible with Microsoft's .NET
implementation.
Please see the <a href="class-status.html">Class Status</a>
page for a status of who is working on which classes.
We will write as much code as possible in C#. We may need to
interface with code written in C to gain access to the
functionality of libraries like libart, Gtk+, and libc.
** Contributing
We welcome contributions to the the Class Library. To get
started, check the status page for information about which
APIs are being worked on, and how to get in touch with
individual maintainers.
If you want to work on a class, first check the <a
href="download.html">Classes Distribution</a> to see if it is
not implemented yet, if not, check the <a
href="class-status.html">Class Status</a> to see if someone is
already working on it, and maybe contact them.
If nobody is working on it, mail <a
href="mailto:[email protected]">[email protected]</a>
with the class you want to implement and CC <a
href="mailto:[email protected]">[email protected]</a>.
You can also track live the activities of the Mono CVS module
by subscribing to the <a
href="http://lists.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list</a>
** Missing features
Our class libraries miss some features, for example, most classes
do not implement the serialization bits at all, it would be a good
contribution to add this to each class.
This is a simple task, but it needs to be done in a compatible way
with the Microsoft.NET classes: using the same arguments to serialize
and reincarnate data.
** Layout
The Class Library resides in the `mcs' module in the directoy
`class'.
Each directory in the directory represents the assembly where
the code belongs to, and inside each directory we divide the
code based on the namespace they implement.
There are two cases when we should consider portability: when
we are dealing with a couple of classes only that differ from
system to system (Consider System.Net and System.IO for Win32
and Unix). In those cases we will just place the files for
example on <t>corlib/System/System.IO/Unix-Console.cs</t> and
<t>corlib/System/System.IO/Win32-Console.cs</t>.
For classes that might differ more (for example, the
implementation of Windows.Forms), we might have different
directories altogether: <t>System.Windows.Forms/Win32</t>,
<t>System.Windows.Forms/Gtk+</t> and
<t>System.Windows.Forms/Cocoa</t>.
** Using existing components from GNOME.
Our current plan is to implement the GUI tools on top of
Gtk+. The only obstacle here is that applications from Windows
might expect to be able to pull the HWND property from the
widgets and use PInvoke to call Windows functions.
** Class Library and Win32 dependencies.
There are a few spots where the Win32 foundation is exposed to
the class library (for example, the HDC and HWND properties in
the GDI+). Casual inspection suggests that these can be
safely mapped to Gdk's GC and GdkWindow pointers without
breaking anything.
The only drawback is that support for PInvoke of Win32 code
won't be available. An alternate solution would be to use
portions of Wine, or even to use Wine as our toolkit.
*** Initial GDI+ and WinForms implementation
The initial implementation will use Gtk+ as the underlying
toolkit. Since GTK+ has already been ported to many windowing
systems other than X (including frame buffer, Win32, and BeOS)
its use should cover most applications for most users.
*** Database access
We will implement ADO.NET functionality by reusing <a
href="http://www.gnome-db.org">GNOME-DB</a>. This is an ideal
choice, since GNOME-DB was implemented precisely to provide an
ADO-like system for GNOME.
*** Component Integration
We will provide a new namespace to use GNOME specific features
as well as a namespace to host Bonobo interfaces and classes
in Mono.
** Licensing
The class library is being licensed under the terms of the
<a
href="http://www.opensource.org/licenses/mit-license.html">MIT
license.</a> This is the same license used by the X11 window
system.
** Class Library testing
We need to write regression tests that will verify
the correctness of the class library, compiler, and JIT
engine.
Please write your regression tests using <a
href="http://nunit.sourceforge.net">NUnit</a>
** Coding conventions
Please follow the conventions on the ECMA specification (On
the Annex Partition) for your coding your libraries.
Use 8 space tabs for writing your code (hopefully we can keep
this consistent). If you are modifying someone else's code, try
to keep the coding style similar.
For a rationale on 8 space tabs, read Linus Torvald's Coding
Style guidelines in the Linux kernel source for a rationale.
*** Missing implementation bits
If you implement a class and you are missing implementation bits,
please put in the code the word "TODO" and a description of what
is missing to be implemented.
*** Tagging buggy code
If there is a bug in your implementation tag the problem by using
the word "FIXME" in the code, together with a description of the
problem.
Do not use XXX or obscure descriptions, because otherwise people
will not be able to understand what you mean.
*** Tagging Lame specs
Sometimes the specification will be lame (consider Version.ToString (fieldCount)
where there is no way of knowing how many fields are available, making the API
not only stupid, but leading to unreliable code).
In those cases, use the keyword "LAMESPEC".
** Namespaces
We are using a number of namespaces in the class libraries for
private classes when we need them, you are encouraged to use these:
<pre>
Mono
.Languages // General Compiler classes
.CSharp // Specific C# parsing/tokenizing classes
.MonoBASIC // Specific VB.NET/MonoBASIC parsing/tokenizing classes
.Python // Specific Python parsing/tokenizing classes
.Runtime
.LateBind // General latebinding-support for MonoBASIC/Python
.MonoBASIC // Specific runtime classes for MonoBASIC programs
.Python // Specific runtime classes for Python programs
.Web
.UI
.Utils // Gaurav utility classes
</pre>
** FAQ
Frequently asked questions about the class library:
Q: I am writing a new class that overrides one of the system classes,
and I am getting a 1595 warning from the compiler. Should we use a
different namespace?
A: There is a quick solution to the problem, you can pass the command
line argument /nowarn:1595 and this will effectively let you use
your implementation of the code, while overriding the ones from the
system assemblies.
+26
View File
@@ -0,0 +1,26 @@
* Status of the various pieces of the class library
You can browse the status of the class library and see who has
registered to work on what parts of the system. These list
work-in-progress components currently.
Browse the current <a href="class-status/index.html">status</a>.
You can also download the XML <a
href="class-status/maintainers.xml">maintainers</a> file that
contains the actual maintainers list.
You can also download the master <a
href="class-status/class.xml">Class Status XML</a> file.
* List of not-implemented classes
Pick from the list of assemblies in the menu on the left to
view the current status of that assembly.
The tree shows items that are either missing or that have TODO
attributes associated with them.
You can use the checkboxes to show only missing or only TODO items.
Clicking on a name will take you to the <a href="http://msdn.microsoft.com/">MSDN documentation</a> for that item.
CTRL-Clicking will take you to the <a href="http://cvs.hispalinux.es/cgi-bin/cvsweb/?cvsroot=Mono">mono CVS tree</a>.
+100
View File
@@ -0,0 +1,100 @@
* Class Library Documentation
** Summary
While using inline XML tags to document classes is certainly
convenient, properly verbose documentation quickly overwhelms
the code, making the source quite difficult to read. Furthermore,
multilingual documentation makes for significant additional text.
With these considerations in mind, Mono will use external XML files
for type documentation, rather than documenting the source inline.
Several tools will be created for managing, verifying, generating,
and updating class library documentation, including:
<ul>
<li><a href="#docstub">docstub</a></li>
<li><a href="#docverify">docverify</a></li>
<li><a href="#docconv">docconv</a></li>
<li><a href="#docgen">docgen</a></li>
<li><a href="#monodoc">monodoc</a></li>
</ul>
** XML Documentation Files and Formats
*** Monodoc XML
This XML is similar to the XML documentation described in the
C# standard, with added tags for internationalization and a
slightly different structure. Documentation and a DTD/Schema
for Monodoc XML is forthcoming.
Monodoc XML does not contain any definitive type information,
and is only useful in conjunction with the Type definition for
whatever is being documented.
This XML could be generated by hand, by monostub, or by monodoc.
*** Assembly XML
This XML is generated by combining runtime type information for
an Assembly with a collection of Monodoc XML files. The resultant
XML (in the best of cases) contains both complete type and
documentary information for each type in the assembly.
This XML contains enough information to be transformed into
user-accessible documentation. It is likely that scripts
will be created to generate reference docs as HTML and other
formats.
Documentation and a DTD/Schema for Assembly XML is forthcoming.
** Documentation Tools
*** <a name="docstub">docstub</a>
Given a type name and an assembly, generates stub Monodoc XML
documentation for the type. Optionally, docstub can attempt to
populate initial documentation from an XML file in the format
published along with the ECMA standard.
*** <a name="docverify">docverify</a>
Given a Monodoc XML file and an assembly, verifies that the
documentation matches the compiled type. Checks signatures,
parameters, et cetera.
*** <a name="docconv">docconv</a>
Converts from Monodoc XML to the standard C# compiler-emitted
XML format and vice versa.
*** <a name="docgen">docgen</a>
Given an assembly and a collection of Monodoc XML files, creates
an Assembly XML file containing all documentation and type information
available. This output is suitable for transforming into user
documentation.
*** <a name="monodoc">monodoc</a>
A GUI tool for documentation and translation, this encapsulates
the capabilities of docstub, docverify, docconv, and docgen in
a friendly user interface. In addition, monodoc provides features
to ease translation, such as side-by-side editing and coverage
statistics.
** Status and Roadmap
*** 2 January 2002
As I write the initial version of this document, very little has been
implemented. Currently, there is a:
<ul>
<li>Preliminary version of the Monodoc XML format</li>
<li>Preliminary version of the docstub utility</li>
</ul>
Here's hoping for frequent, productive updates.
** Get Involved
Help us define Mono's documentation structure! Subscribe to
<a href="http://lists.ximian.com/mailman/listinfo/mono-docs-list">mono-docs-list</a>
and wade right in.
+13
View File
@@ -0,0 +1,13 @@
* Contacting the Mono team.
You can contact the general forum of discussion by sending
e-mail to <a href="mailto:[email protected]">[email protected]</a>
You can contact me (Miguel de Icaza) by sending e-mail to <a
href="mailto:[email protected]">[email protected]</a>. My web
page is <a
href="http://primates.ximian.com/~miguel">http://primates.ximian.com/~miguel"</a>
You can also <a
href="http://www.ximian.com/about/contact.php3">reach Ximian.</a>
+195
View File
@@ -0,0 +1,195 @@
* Contributing to the Mono project
There are many ways in which you can help in the Mono project:
<ul>
* <b>Programmers:</b> You can work on a free
implementation of the <a
href="class-library.html">class libraries</a>, the
<a href="runtime.html">runtime engine</a>, <a
href="tools.html">the tools</a>, the <a
href="testing.html">testing framework</a>
* <b>Writers:</b> You can help us bywriting <a
href="documentation.html">documentation</a>.
</ul>
Those are just broad things that need to be worked on, but
something that would help tremendously would be to help with
small duties in the project that need to be addressed.
You can see what needs to be done in the class libraries <a href="class-status.html">here</a>
* IRC Channel
Many developers get together on the <b>#mono</b> irc channel
on the <b>irc.gnome.org</b> server.
** To start contributing
As a programmer, you can contribute in three different scenarios to Mono:
<ul>
* If you only have Linux/Unix.
* If you only have Windows.
* If you have both Linux and Windows.
</ul>
You might also want to check our <a href="#setup">common
setups</a> section that describes some common setups that people
use while working on Mono.
*** Contributing to the class library, regression tests or the compiler
This only requires Windows currently.
To start developing classes or to contribute to the compiler,
you only need Windows and the .NET Framework 1.0 SDK. Please notice
that you do not need Visual Studio (although you can use it if
you want). The .NET Framework SDK requires some version of
Windows XP or Windows NT. If you are running Windows 98, 95
or Me, you could use instead the <a
href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/001/829/msdncompositedoc.xml">.NET Redist package</a>, but it
lacks the documentation browser and the ildasm program (C#, VB, JScript and IL
assembler are included).
You can get it <a href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml&frame=true">here</a>
If you are new to .NET, writing regression tests is a good way
of starting to contribute: it will help you get used to C# as
well as getting comfortable with the .NET APIs.
This helps because at this point you might be the best
qualified person to fix a problem found by the regression
test, or you might have a new class to implement in the .NET
world that only has a test suite.
To get started writing tests see the <a href="testing.html">Test Suite</a>
section. <a href="mono-contribution-howto.html">Here</a> there is a good All-In-One introduction to the art of writing tests.
*** Contributing to the runtime engine
This only requires Linux, currently some tasks are easier if you
have access to Windows as well.
Here are a few things you can do:
<ul>
* Port the runtime to other architectures.
* Port the runtime to other operating systems.
* Finish the IL code verifier in the runtime.
* Hack the JIT, improve the code generator, add new
pattern rules, improve the register allocator.
* Implement the debugging interfaaces
</ul>
** Bug reporting
If you find bugs in Mono, please make sure you enter a bug
report so we can keep track of problems in Mono.
To enter bug reports go to <a href="http://bugzilla.ximian.com">
http://bugzilla.ximian.com</a> and enter bug reports against
your favorite component (Mono, Runtime, C# compiler).
You can review the list of current bugs by going <a href="http://bugzilla.ximian.com/buglist.cgi?product=Mono%2FClass+Libraries&product=Mono%2FMCS&product=Mono%2FRuntime&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&order=%27Importance%27&form_name=query">here</a>
** Small tasks
A few smaller tasks are here, dropped in no particular order:
<ul>
* <b>Mono/doc and web site:</b> They need to be
packaged up in the official `distribution'
* Adding serialization support to all the classes.
We have many classes, but we have not implemented in
many cases the serialization and re-incarnation support in
them (this is pretty straight forward code, and simple,
but there is a lot to be done here).
</ul>
* Emacs support
Brad Merryl's C# mode for Emacs is available: <a
href="http://www.cybercom.net/~zbrad/DotNet/Emacs/">http://www.cybercom.net/~zbrad/DotNet/Emacs/</a>
* Books on C# and DotNet.
<ul>
* Dotnet Books (<a href="http://www.dotnetbooks.com">http://www.dotnetbooks.com</a>)
* Dotnet Resources (<a href="http://www.dotnetexperts.com/resources/">
http://www.dotnetexperts.com/resources</a>)
* O'Reilly C# Essentials (<a href="http://www.oreilly.com/catalog/csharpess/">
http://www.oreally.com/catalog/csharpess</a>)
* O'Really .NET Essentials (<a href="http://www.oreilly.com/catalog/dotnetfrmess/">
http://www.oreally.com/catalog/dotnetfrmess</a>)
</ul>
<a name="setup">
* Common Setups
People running both Linux and Windows while contributing to
Mono use a number of tricks to increase their productivity.
Scenarios:
<ul>
* <b>Linux host and Windows host</b>
The Windows file system is shared (right click on
your hard drive icon, and select sharing, allow this
to be shared).
The Windows machine has the required build tools
(cygwin, and the .NET framework). On the Windows
machine, you want to setup the ssh server (run the
ssh-host-config program to configure your ssh) and
run it (from a cygwin terminal, type: /usr/sbin/sshd).
From the Linux side, you want to mount the Windows
file system, using something like this:
<tt><pre>
mount -t smbfs -o uid=miguel,username="Miguel de Icaza" "//quack/c$" /mnt
</pre></tt>
In the above example, my Linux user name is
`miguel', and this will allow this user to have
read/write access to the share.
The host name is `quack', and the name of the share
is `c$' (that is the C: partition).
The file system is accessible on /mnt.
You can perform your cvs update and cvs commits from
the /mnt directory, and run Emacs or your favorite
Linux text editor on the Unix side in this way.
Then from another terminal, you can ssh into your
Windows box using ssh, like this: ssh "Miguel de Icaza@quack"
</ul>
* Special Note
If you have looked at Microsoft's implementation of .NET or
their shared source code, you may not be able to contribute
to Mono. Details will follow when we know more about this.
In general be careful when you are implementing free software
and you have access to proprietary code. We need to make sure
that we are not using someone else's copyrighted code
accidentally.
Please do not use the <b>ildasm</b> program to disassemble
proprietary code when you are planning to reimplement a class
for Mono. If you have done this, we might not be able to use
your code.
Please stick to published documentation for implementing any
classes.
+190
View File
@@ -0,0 +1,190 @@
* Developer FAQ
** New classes
Q: Should we write classes which are not part of the .NET or ECMA specs?
A: Yes. The ECMA and .NET specifications are far from complete, and
to produce a complete platform we will need a number of other
classes and components.
Any new classes that are not part of .NET or ECMA should be
designed to be reusable on anyone's CLI implementation. So that
Windows developers can also use any new classes that we come up
with.
We have a few existing <a href="ideas.html">Ideas on missing
classes</a>
** Language Compatibility
Q: What is the magic that allow multiple languages to co-exist?
A: From Fergus Henderson:
<i><blockquote>
There are different levels of interoperability.
The ECMA spec defines different categories of
CLS (Common Language Specification) conformance.
There are also some useful categories that don't
correspond to any of the levels defined in the ECMA spec.
In increasing degree of difficulty, your language implementation
can
<ul>
* (a) just generate IL
* (b) be a CLS "consumer", which means that it can read in
meta-data describing component interfaces,
and that it provides a way to declare variables of
CLS-complaint types and to call CLS-complaint methods.
* (c) be a CLS "extender", which means that it can in addition
derive from CLS-compliant classes
and implement CLS-compliant interfaces
* (d) be able to produce components with *any* CLS-compliant
component interface.
</ul>
Supporting some of these may require extending your language. However,
you can get quite a lot of interoperability by just putting appropriate
functionality in your compiler, without extending your language.
For some things, e.g. ASP.NET, your language implementation also needs to be
able to
<ul>
* (e) consume CodeDom trees. CodeDom trees are an abstract
representation of programs in a form similar to a C# parse
tree, with embedded code snippets (unparsed strings).
Given a CodeDom tree, with the snippets in your language,
your language implementation needs to generate a (i) .NET
assembly and possibly also (ii) a source file in your language.
* (f) produce CodeDom trees. For some applications,
your language implementation also needs to be able to
round-trip from CodeDom -> your language -> CodeDom.
</ul>
and for some things it needs to
<ul>
* (g) generate *verifiable* IL
</ul>
So when you hear all the hype about how language XYZ is a
".NET language", make sure you ask which of these different
things are supported.
[For the record, Mercury currently supports (a). We're working on
(b) and (g), and on parts of (c) and (e). We're never going to do (f), I very
strongly doubt we'll ever do (d), and for (c) we might only ever support
implementing interfaces, not deriving from classes.]
</blockquote></i>
** PInvoke
Q: What are the two major initiatives to implement PInvoke?
A: Fergus Henderson answers:
<i><blockquote>
Many of the .NET APIs will need to be implemented using code that calls C/Unix
APIs, such as stat(). The standard way of interfacing with native code from
.NET code is to use "PInvoke". However, there is a difficulty: many of
these APIs are defined in terms of types such as C's `long' or `size_t'
or the Posix `struct stat' whose representation varies depending on the
platform (architecture/OS/C compiler). There's no *portable* way of
accessing those from .NET managed code.
So, there are a couple of different approaches.
One possibility is to access such routines by writing a wrapper, e.g. in C,
that provides the same functionality without using types with a system-dependent
representation. The wrapper can then be directly accessed from portable
.NET code. The .NET code remains both source- and binary-portable;
the wrapper code is source-portable, but needs to be compiled
seperately for each target platform. The drawback of this approach is
that you have to write a lot of cumbersome wrapper code.
Another possibility is to extend the .NET VM with support for an
additional custom attribute, e.g. "[PosixType]". The VM would then
represent types tagged with this attribute in the same way that the
underlying system represents those types. With this approach, no
wrapper code would be needed. A drawback of this approach is that it
pushes quite a bit of complexity into the VM; the VM would have to know
the native representation of all types annotated with this attribute.
Another drawback is that code using this extension might not work on
different VMs.
There have also been some other suggestions, but those are the two that
I think are the best.
</blockquote></i>
Q: What is the problem implementing PInvoke?
A: Again, from Fergus Henderson:
<i><blockquote>
There's no problem implementing PInvoke as specified in the ECMA
specs and/or MS documentation. It's just that PInvoke by itself
doesn't solve all of the problems; in particular it doesn't solve
the problem of C types whose representation is different on different
systems.
</blockquote></i>
** CVS use
Q: Why do we keep ChangeLogs and make the CVS commit messages be the
same? One could be generated from the other
A: There are a number of reasons for keeping ChangeLog files as well as
CVS commit files:
<ul>
* Offline programming: when people are traveling, CVS logs are
not available.
* Slow CVS access: Many people work over modem lines (very
typical for contributors in Europe, Asia, Latin America)
using CVS is slow and might not be available to you (cvs
server down, no anoncvs server available).
* ChangeLogs travel in a released tarball package, so it is
possible to study the rationale of changes even after a
project is long "released", or you only have the sources for
the code.
* ChangeLog are not metadata for each file, they are live
files that you can browse in the package that is being
distributed.
</ul>
Making the CVS commit message be the same as the ChangeLog has other
benefits:
<ul>
* You can track down with `cvs log' what things were changed,
and match those to meaningful reports on the intentions of
the commit.
* When reading the commits-list, you can get a glimpse of the
changes without having to diff out or cvs update your tree.
* You can read off-line the changes that are being made
(asyncrouns operation).
</ul>
This mechanism works very well for GNOME and other projects.
Q: Should I use any of the special RCS keywords like $Id: devel-faq,v 1.1 2001/07/31 21:13:05 miguel Exp $, $Author: miguel $,
$Date: 2001/07/31 21:13:05 $, or $Revision: 1.1 $?
A: Please avoid using those in the source code in the CVS. They
are not really useful, and they cause a lot of conflicts when
people have separate CVS trees.
It was a nightmare with the Linux kernel when two people had their
private CVS trees and were submitting patches to the core.
+62
View File
@@ -0,0 +1,62 @@
* Documentation
Although most of the concepts from Microsoft.NET can
be applied to the completed Mono platform, we do need to
have a complete set of free documentation written specifically
for Mono.
The documentation license we have chosen is the GNU Free
Documentation License (FDL), the standard for most documents
in the free software world.
We need documentation on a number of topics:
<ul>
* The development tools (compilers, assembler tools,
language reference, design time features).
* Frequently Asked Question compilations.
* HOWTO documents.
* The Class Libraries
* Tutorials on Mono and the specifics of running it.
* A guide to Mono as compared to the Microsoft.NET
Framework SDK
</ul>
** Class Library documentation
We are moving to a new setup for documenting the class libraries,
and you can read about it <a href="classlib-doc.html">here</a>.
A few words of warning and advice for class documentors:
A well-documented API can ease hours of frustration; as Mono
matures, robust and complete class library documentation will
become increasingly important. As you write API documentation,
whether it is embedded in source files or in external Monodoc XML,
please keep the following in mind:
Plagarism, even if it's unintentional, is a Bad Thing(TM).
Microsoft's .NET Framework Class Library documentation is an
excellent resource for understanding the behavior and properties of
a type, and a lot of hard work went in to creating this (copyrighted)
resource. Please don't copy from Microsoft's reference when
documenting a type.
To avoid this, I (<a href="mailto:[email protected]">[email protected]</a>)
suggest that you read the complete Microsoft documentation for a type,
ponder it for a while, and write the Mono documentation in your own
words. While it's certainly okay to refer to the Microsoft
documentation to clarify your understanding of behavior or properties,
please don't open the Microsoft docs and refer to them for each member
you document.
There's a lot of domain expertise among the class library contributors;
let's put the same personal stamp on the class library documentation
that we have on the class libraries themselves.
+387
View File
@@ -0,0 +1,387 @@
* Software Availability
The Virtual Execution System is available in package `mono'.
Currently this contains a metadata library and the
disassembler. Please refer to our <a
href="runtime.html">Runtime</a> description for more details
on this part of the project.
The code for the C# compiler as well as the language error
test suite and the class library are in the `mcs' package, we
will move this later into `mono' itself.
<b>Note: (Beginners read!)</b> There are a couple of documents you
should read before going ahead. You can reach them in the
<a href="http://www.go-mono.org/mono-beginning.html">Resources/Beginning section</a>. And the <a href="http://www.go-mono.org/faq.html">FAQ</a>
and the <a href="http://geneura.ugr.es/~jaime/deploy/mono-common-problems.html">
Mono Common Problems</a>. Might be useful too. Take the Mono Beginners
HOWTO for your system and proceed as it's described there.
<a name="sources">
*** Sources
Stay up to date on the Mono team's development using the
<a href="http://lists.ximian.com/mailman/listinfo/mono-cvs-list">
mono-cvs-list</a> mailing list. The CVS source code can also
be browsed <a href="http://cvs.hispalinux.es/cgi-bin/cvsweb/?cvsroot=Mono#dirlist">here</a>
<a name="jun-7">
<b>Mono 0.13</b>
New packaged versions of the Mono C# compiler and Mono runtime
are now available. The latest version is 0.13.
<ul>
* <a href="archive/mono-0.13">Mono 0.13 release notes</a>
* <a href="archive/mcs-0.13.tar.gz">mcs-0.13.tar.gz</a>
Mono C# compiler with class library source code.
* <a href="archive/mono-0.13.tar.gz">mono-0.13.tar.gz</a>
Mono runtime.
</ul>
* Snapshots
Already daily volunteer's made binaries:
<ul>
* <a href="http://www.atoker.com/mono">Debian Linux</a>
* <a href="http://noa.tm/mono/">Red Hat (and RPM based systems)</a>
* <a href="http://www.superin.formativ.net/mono/mono.htm">Windows</a> (works without cygwin!)
</ul>
<b>Note1:</b> Don't look for the Mono BaseLabs RPMs; they are not providing it
anymore.<br>
<b>Note2:</b> You will find that you can get binaries for the gtk-sharp
package too.
<a name="snapshots">
For up to date sources, it is recommended that you use the Mono
source code from either the
<a href="http://www.go-mono.com/snapshots">nightly snapshots</a> or
the <a href="anoncvs.html">Anonymous CVS</a>. The nightly
snapshots are done every night at 10pm EST (Boston Time).
The anoncvs mirrors provided by Hispalinux are updated every six
hours.
The nightly snapshots are not guaranteed to build, but most of the
time they should. They should give you a window to see what we are
up to.
There are scripts to help build mono for both Unix and Windows. Get
<a href="mono-build.sh">mono-build.sh</a> for Unix, or <a
href="mono-build-w32.sh">mono-build-w32.sh</a> for Windows.
These scripts automate the installation of GLIB and pkgconfig
(building from source on Unix, and using binary packages
provided by the GIMP for Windows project on Windows.) To use
the script, follow these simple steps:
<ul>
* Save the script for your platform somewhere (e.g. /usr/local/bin)
* Make the script executable (i.e chmod 755 /usr/local/bin/mono-build.sh)
* Create a directory to hold the mono source, and the compiled binaries (e.g. mkdir ~/mono)
* Change to the new directory (i.e. cd ~/mono)
* run the script (i.e. /usr/local/bin/mono-build.sh)
</ul>
The script requires wget on either platform, and building the
software requires make, gcc, automake, autoconf, and libtool.
You should install these packages from your distribution or
with the cygwin installer. You should also take care of setting
the right environment variables as the PKG_CONFIG_FLAGS, etc.
The script will download required packages from
www.go-mono.com and do a cvs checkout of mono in the current
directory. <b>IMPORTANT!:</b> The cvs server chosen defaults to
anonymous cvs;
set your CVSROOT environment variable before running the script to
select a particular cvs server.
** Mono Regression Test Suite
You can get binaries for the Mono Regression Test Suite <a
href="archive/mono-tests.tar.gz">here</a>
<a name="install">
** Building the software manually
*** Building on Linux
<ul>
You can build mono and mcs in Linux but to do that be
sure to obtain the corlib.dll and install it before
trying to compile.
In linux be sure you get <a href="http://www.gtk.org">glib2.0</a>
(>= 2.0.4, 2.0.6
recomended) and <a href="http://www.freedesktop.org/software/pkgconfig">pkg-config</a> 0.80.
Also the corresponding development packages for those as
well as the GNU Build Tools (make, autoconf...).
Then download the mono packages and compile them.
You must start compiling mcs and then mono.
Be sure you set all the environment variables before
compiling. You can use pkg-config --list-all to see
if you forgot to set some of them.
Normally you should enter:
export ACLOCAL_FLAGS="-I /usr/local/share/aclocal"
if your install prefix is /usr/local.
If you downloaded the Mono nightly snapshots, untar the
snapshot.
Change directories to "<strong>mcs</strong>".
Configure, compile and install:
<pre>
<strong>./configure
make
make install</strong></pre>
Do the same in the "<strong>mono</strong>" directory.
*** On Windows, to install and work on the compiler and the class libraries:
**** Install Cygwin and the GNU build tools, Microsoft's .NET Framework SDK and the precompiled GLIB 2.0 and pkg-config libraries.
<ul>
* Install <a href="http://www.cygwin.com">Cygwin</a>.
* Install <a href="http://msdn.microsoft.com/downloads">
Microsoft .NET Framework SDK</a>.
* Change to the <strong>/usr/local</strong> directory
of your Cygwin installation.<br>
Unzip the precompiled packages listed above.
</ul>
<ul>
* If you downloaded the Mono
<a href="http://www.go-mono.com/snapshots">nightly snapshot
</a>, untar the snapshot.
* Change directories to <strong>"mcs"</strong>.
* Compile:
<pre>
<strong>make windows</strong>
</pre>
*** On Windows, to compile the mono runtime:
<ul>
* If you downloaded the Mono
<a href="http://www.go-mono.com/snapshots">nightly snapshot
</a>, untar the snapshot.
* Change directories to <strong>"mono"</strong>.
* Configure, compile and install:
<pre><strong>
./configure --prefix=c:/mono
make
make install
</strong></pre>
</ul>
* Software resources, notes and old releases:
The required and additional software can be downloaded here:
* Microsoft's .NET Framework SDK from
<a href="http://msdn.microsoft.com/downloads">
msdn.microsoft.com/downloads</a>.
* Cygwin and the GNU Make tools from
<a href="http://www.cygwin.com">www.cygwin.com</a>.
Some people observed problems with autoconf 2.52. Installing
autoconf 2.13 helped in those cases.
* Precompiled GLIB 2.0 and pkg-config packages (and
their dependencies) by the <a href="http://www.gimp.org/~tml/gimp/win32//index.html">GIMP for Windows</a> project from
<a href="http://www.go-mono.com/archive/pkgconfig-0.80-tml-20020101.zip">http://www.go-mono.com/archive/pkgconfig-0.80-tml-20020101.zip</a>
<a href="http://www.go-mono.com/archive/glib-1.3.12-20020101.zip">http://www.go-mono.com/archive/glib-1.3.12-20020101.zip</a>
<a href="http://www.go-mono.com/archive/glib-dev-1.3.12-20020101.zip">http://www.go-mono.com/archive/glib-dev-1.3.12-20020101.zip</a>
<a href="http://www.go-mono.com/archive/libiconv-1.7.zip">http://www.go-mono.com/archive/libiconv-1.7.zip</a>
<a href="http://www.go-mono.com/archive/libiconv-dev-1.7.zip">http://www.go-mono.com/archive/libiconv-dev-1.7-20020101.zip</a>
<a href="http://www.go-mono.com/archive/libintl-0.10.40-20020101.zip">http://www.go-mono.com/archive/libintl-0.10.40-20020101.zip</a>
* Download the Mono source code from the
<a href="#feb-11">packaged versions</a> or
the <a href="http://www.go-mono.com/snapshots">
nightly snapshots</a> or the <a href="anoncvs.html">
Anonymous CVS</a>. The nightly snapshots are done every
night at 10pm EST (Boston Time). The nightly snapshots are
not guaranteed to build, but most of the time they should.
</ul>
*** Notes on compiling GLIB 2.0 and pkg-config from source:
<ul>
* Some people observed problems with autoconf 2.52. Installing
autoconf 2.13 helped in those cases (don't forget to do a
`make maintainer-clean' after the update).
* Download, compile and install <a href="http://www.freedesktop.org/software/pkgconfig">pkg-config</a> from source.
(I had to change line 674 of
<nobr><tt>pkg-config-0.8.0/glib-1.2.8/gstrfuncs.c</tt></nobr> from
<nobr><tt>extern char *strsignal (int sig);</tt></nobr> to
<nobr><tt>extern const char *strsignal (int sig);</tt></nobr>.
<pre><strong>
tar xzvf pkg-config-0.8.0.tar.gz
cd pkg-config-0.8.0
./configure --prefix=/usr
make
make install</strong>
</pre>
* Download, compile and install <a href="ftp://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.7.tar.gz">libiconv</a> from source.<br>
If you dont have MS Visual C/C++ 4.0 or 5.0 or 6.0 you can also try
the binary package available at <a
href="http://www.gimp.org/win32/libiconv-dev-20001007.zip">
http://www.gimp.org/win32/libiconv-dev-20001007.zip</a>.
* Download, compile and install the
<a href="ftp://ftp.gtk.org/pub/gtk/v2.0/glib-2.0.6.tar.gz">
glib 2.0</a> from source.
</ul>
<a name="oldreleases">
*** Old releases.
<ul>
<ul>
<a name="apr-24">
<b>Mono 0.11; April 24, 2002</b>
* <a href="archive/mono-0.11">Mono 0.11 release notes</a>
* <a href="archive/mcs-0.11.tar.gz">mcs-0.11.tar.gz</a>
Mono C# compiler
* <a href="archive/mono-0.11.tar.gz">mono-0.11.tar.gz</a>
Mono runtime
</ul>
<ul>
<a name="mar-27">
<b>Mono 0.10; March 27, 2002</b>
* <a href="archive/mono-0.10">Mono 0.10 release notes</a>
* <a href="archive/mcs-0.10.tar.gz">mcs-0.10.tar.gz</a>
Mono C# compiler
* <a href="archive/mono-0.10.tar.gz">mono-0.10.tar.gz</a>
Mono runtime
</ul>
<ul>
<a name="feb-22">
<b>Mono 0.9; February 22, 2002</b>
* <a href="archive/mono-0.9">Mono 0.9 release notes</a>
* <a href="archive/mcs-0.9.tar.gz">mcs-0.9.tar.gz</a>
Mono C# compiler
* <a href="archive/mono-0.9.tar.gz">mono-0.9.tar.gz</a>
Mono runtime
</ul>
<a name="feb-11">
<b>February 11, 2002</b>
* <a href="archive/mcs-0.8.tar.gz">mcs-0.8.tar.gz</a>
Mono C# compiler
* <a href="archive/mono-0.8.tar.gz">mono-0.8.tar.gz</a>
Mono runtime
</ul>
<a name="sep-18">
<b>September 18, 2001</b>
<ul>
* <a href="archive/mono-0.7.tar.gz">mono-0.7.tar.gz</a>: Mono Runtime 0.7 release.
* <a href="archive/mcs-0.7.tar.gz">mcs-0.7.tar.gz</a>: Mono Compiler and Classes 0.7 release.
* <a href="archive/mono-0.7">Release Notes.</a>
</ul>
<a name="august-22">
<b>August 22, 2001</b>
<ul>
* <a href="archive/mono-0.6.tar.gz">mono-0.6.tar.gz</a>: Mono Runtime 0.6 release.
* <a href="archive/mono-compiler-classes-0.6.tar.gz">mono-compiler-classes-0.6.tar.gz</a>: Mono Compiler and Classes 0.6 release.
* <a href="archive/mono-0.6">Release Notes.</a>
</ul>
<a name="july-29">
<b>July 29, 2001</b>
<ul>
* <a href="archive/mono-0.5.tar.gz">mono-0.5.tar.gz</a>: Mono Runtime 0.5 release.
* <a href="archive/mono-0.5">Release Notes.</a>
</ul>
<a name="july-22">
<b>July 22, 2001</b>
<ul>
* <a href="archive/mcs-22-Jul-2001.tar.gz">mcs-22-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mcs-Jul-22-Jul-19-2001.tar.gz">Differences since 19</a>: CVS snapshot.
* <a href="archive/mcs-22">Release Notes.</a>
</ul>
<a name="july-19">
<b>July 19th, 2001</b>
<ul>
* <a href="archive/mcs-19-Jul-2001.tar.gz">mcs-19-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mcs-Jul-17-Jul-19-2001.tar.gz">Differences since 17</a>: CVS snapshot.
* <a href="archive/mcs-19">Release Notes.</a>
</ul>
<a name="july-17">
<b>July 17th, 2001</b>
<ul>
* <a href="archive/mcs-17-Jul-2001.tar.gz">mcs-17-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mcs-Jul-15-Jul-17-2001.tar.gz">Differences since 15</a>: CVS snapshot.
* <a href="archive/mcs-17">Release Notes.</a>
</ul>
<a name="july-15">
<b>July 15th, 2001</b>
<ul>
* <a href="archive/mcs-15-Jul-2001.tar.gz">mcs-15-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mono-0.4.tar.gz">mono-0.4.tar.gz</a>: Packaged Source Code.
* <a href="archive/mono-0.4">Release Notes.</a>
</ul>
<a name="july-14">
<b>July 14th, 2001</b>
<ul>
* <a href="archive/mcs-12-Jul-2001.tar.gz">mcs-12-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mono-0.3.tar.gz">mono-0.3.tar.gz</a>: Packaged Source Code.
</ul>
<a name="july-8">
<b>July 8th, 2001</b>
<ul>
* <a href="archive/mcs-08-Jul-2001.tar.gz">mcs-08-Jul-2001.tar.gz</a>: CVS Snapshot
* <a href="archive/mono-08-Jul-2001.tar.gz">mono-08-Jul-2001.tar.gz</a>: CVS Snapshot
</ul>
</ul>
+1184
View File
File diff suppressed because it is too large. Load diff
+9
View File
@@ -0,0 +1,9 @@
* The GCC front-end
The GCC front-end will accept input in a binary file with
codes in the Common Intermediate Language (CIL), and generate
native code.
This will allow pre-compilation and full optimization to take
place before a program is executed.
+23
View File
@@ -0,0 +1,23 @@
* Mono Hackers Hall Of Fame
Without the help, the skills and the time of many passionate developers outside of
the Ximian Mono team, Mono would not be where it is today.
Many of them do it for fun, some do it because they really want a nice CLR they
can hack on, some do it because they need a working solution to some development
issues and mono is the ideal tool for the job.
Some of them may start contributing because they want a mention in the
<b>Mono Hackers Hall Of Fame</b>! Whatever the cause, join us in a big<br>
<h1 align="center">Thank you!</h1>
* Mono Hackers
** Nick Drochak
The first, deserved, entry in the <b>Mono Hackers Hall Of Fame</b> is for
Nick Drochak, who joined us in the first days of Mono and built the testing
infrastructure for the C# assemblies, fixed tons of bugs and even adventured
himself in the lands of the C runtime. His work is invaluable for keeping
Mono on the right track through the daily changes in the codebase.
+112
View File
@@ -0,0 +1,112 @@
* Ideas
There are many pending classes that need to be implemented. Those have
the highest impact in the Mono project: the sooner they are done,
the sooner we can start using this platform to create new and
exciting applications.
That being said, if you are not very excited about working on class
libraries, here is a list of other related projects or tools that might
be useful to the Mono project.
Here are a few ideas of tools, classes and projects that you
could start. More are forthcoming.
<a name="runtime">
** Runtime
We need a verifier that can be run on an executable (assembly)
and tells whether the metadata for the executable is correct
or not. It should report any anomalies.
For a list of anomalies in assemblies, check the various assertions
that are described on the ECMA documentation.
This will help test our generated executables and can be also
used as an external verifier.
<a name="classes">
** Classes
<ul>
TODO=jxta,The JXTA Peer to Peer foundation
* Implement a JXTA protocol implementation:
<a href="http://www.jxta.org">http://www.jxta.org</a>
TODO=camel,Mail API
* Implement a Mail API, similar to Camel or JavaMail (Camel has
significant architecture features that are required on a real
mailer).
You can check the current C
<a href="http://cvs.gnome.org/bonsai/rview.cgi?dir=evolution%2Fcamel">
Camel implementation</a>.
Such an implementation could be used both with
Microsoft .NET and Mono.
TODO=multimedia
* Interfacing to Multimedia systems. You might want
to look into the Quicktime API. I know <a
href="mailto:[email protected]">Vladimir</a> has
researched the problem before
</ul>
<a name="projects">
** Projects
<ul>
TODO=xmlStorage,
* Implement an xmlStorageSystem for the CLI:
<a href="http://www.soapware.org/xmlStorageSystem">
http://www.soapware.org/xmlStorageSystem</a>
TODO=guavac,Java compiler for .NET
* You could take one of the existing Java compilers
(Guavac comes to mind as it is so nice) and modify
it to generate .NET code rather than JVM byte
codes.
This should be a pretty straightforward task.
Guavac has the advantage of being written in C++ and
it could be compiled with the Microsoft Managed C++
compiler and produce a .NET executable with it.
TODO=CORBA,CORBA implementation
* Build a CORBA interoperability engine for the CLR.
You do not need to do all of the work, just talking
the protocol will get us a long way (<a
href="http://www.omg.org">The OMG site</a> has the
CORBA specs).
Get in touch with David Taylor (dtaylo11 at bigpond
dot net dot au) as he has been working on this
project.
TODO=Bonobo,Bonobo for Mono
* Once CORBA is done, implement the Bonobo interfaces
to allow people to use Bonobo components in Mono and
Mono components with Bonobo. The best of both worlds!
TODO=moniker,Object Naming System with Monikers
* A naming space for Mono. An object naming space is
a very powerful tool. Bonobo implements a moniker
system that is more powerful than the original
moniker concept that was pioneered by COM/OLE in the
Microsoft world.
Our implementation builds on a concept, and we have
made it simpler, more powerful, more extensible and
a much better mechanism than the equivalent monikers
on Windows.
Implementing Mono monikers would benefit both
Windows users using .NET and Mono users on Unix and
Windows.
Here is <a
href="http://primates.ximian.com/~miguel/monikers.html">an
overview of the moniker system</a> in Bonobo.
</ul>
+1657
View File
File diff suppressed because it is too large. Load diff
Executable
+62
View File
@@ -0,0 +1,62 @@
* Java
It would be interesting to support the Java language as part
of the Mono project.
You have to think of Java as various pieces: Java the
language and Java the virtual machine.
It is possible to compile Java to .NET, as shown by the
Microsoft J# compiler. We could then allow the migration of
Java applications to the Mono runtime.
** Native compiler
Although a native compiler can be built, and probably should be
built using an existing compiler, a short term solution is to
build a translator from Java class files to the ECMA CIL images.
This has the advantage that we can use an existing and tested
Java compiler to generate the code, and then we can use an automated
code compiler that compiles Java VM bytecodes to CIL bytecodes.
** The translator.
It would be interesting to write a semantic translator that
converts java byte codes into CIL opcodes. This is possible
because the Java byte codes are a subset of the CIL ones.
A semantic tree needs to be constructed (very much in the
spirit of what is done in mono_analize_stack in
<tt>mono/mono/jit/jit.c</tt>. Once such a semantic tree is
constructed, we could generate the equivalent Java code.
This has a number of interesting side effects: people can
continue to use their existing Java compilers to compile their
code, and a simple tool that converts their .class files into
a .NET assembly can be used.
** Libraries
We could translate the GNU Classpath libraries with the above
tools to provide the Java runtime required to host into the
Mono runtime. Some special treatment would be required for
core data types like integers, arrays and strings, and of
course reuse where possible existing classes from .NET to make
them compatible.
** JILC - Java to IL Compiler
This is an attempt to make the java bytecode available for the
.NET environment.
The project attempts to generate the IL code / bytecode from the
compiled java class files. It has reached the stage of code-generation.
The issues that needs to be addressed is the mapping of java objects
to the IL objects, eg: java.lang.String to System.String.
Gaurav Vaish and Abhaya Agarwal are currently leading this project.
The project is currently hosted at <a href="http://sourceforge.net/projects/jilc">SourceForge.Net</a>.
The official home page of the project is
<a href="http://jilc.sourceforge.net">http://jilc.sourceforge.net</a>.
+184
View File
@@ -0,0 +1,184 @@
* How to debug your C# application with the JIT engine
To debug a C# application you need to run the JIT in your debugger.
Before you can do anything useful in a debugger, you need a symbol
file which tells your debugger about functions, types, line numbers
and such. Unfortunately, this symbol file needs to be recreated each
time the JIT compiles a new method since it doesn't know anything
about this method (especially not its memory address) before actually
compiling it.
You have two ways of creating a symbol file:
** Letting the JIT dynamically create the symbol file
This'll give you a symbol file which is suitable for debugging IL byte
code - you won't see your C# source code.
However, this method has the advantage that it works with every assembly,
no matter whether it has been compiled with Mono's C# compiler (MCS) or
with any other compiler. It's currently the only way to debug
<tt>corlib.dll</tt> or any other library which cannot be compiled with
our compiler yet.
All that you need is a dump of the IL bytecode for each assembly (including
all assemblies this assembly is referencing). This is done by using the
<tt>monodis</tt> utility:
<pre>
monodis /home/export/martin/MONO-LINUX/lib/corlib.dll > corlib.il<br>
monodis /home/export/martin/MONO-LINUX/lib/System.dll > System.il<br>
monodis /home/export/martin/MONO-LINUX/bin/mcs.exe > mcs.il
</pre>
This is normally done automatically, but you can also disable
it and create them by hand. See the <tt>mono</tt> manual page
for details.
Make sure that all the .il files have the same name as their corresponding
assembly and that they're all created in the current directory.
The JIT supports two different debugging file formats:
<ul>
* STABS: This is a very simple debugging format, but it may be the only one
which is supported on your system. It is limited to source files of no more
than 65.535 lines and it's type support is also very limited. You should only
use this if your debugger doesn't support DWARF 2.
To generate STABS output, use the <tt>--debug=stabs</tt> command line argument.
* DWARF 2: The DWARF 2 debugging format is a very powerful debugging format
which can handle source files of arbitrary size and has a highly sophisticated
type support. It's the recommended format unless you need to use STABS because
your debugger doesn't support DWARF 2.
To generate DWARF 2 output, use the <tt>--debug=dwarf</tt> command line argument.
</ul>
You need to regenerate the symbol file each time the JIT compiled a new
method and each time you restart the JIT. You cannot reuse your symbol file
if you start the JIT a second file, not even if you're running the same
application with the same input data a second time.
Regenerating the symbol file is done by calling the JIT's
<tt>mono_debug_make_symbols ()</tt> function from within your debugger and
then reloading the symbol files. This function creates a <tt>filename-dwarf.s</tt>
(or <tt>filename-stabs.s</tt>) assembler input file in the current directory and
an object file in <tt>/tmp/filename.o</tt> - you need to tell your debugger to
add this object file as symbol file.
If you're using the GNU debugger, this is done like this:
<pre>
call mono_debug_make_symbols ()
add-symbol-file /tmp/corlib.o
add-symbol-file /tmp/mcs.o
add-symbol-file /tmp/Mono.CSharp.Debugger.o
</pre>
You can also write a GDB macro like this:
<pre>
define reload
call mono_debug_make_symbols ()
add-symbol-file /tmp/corlib.o
add-symbol-file /tmp/mcs.o
add-symbol-file /tmp/Mono.CSharp.Debugger.o
end
</pre>
Then you can just say <tt>reload</tt> to have GDB recreate the symbol file.
There's also an <a href="jit-debug-sample.html">example debugging session</a> using
the GNU debugger.
** Using a symbol file which have been created by the Mono C# compiler
If you compiled your application with Mono's C# compiler (MCS), you can tell it to
create a symbol file which is then processed and rewritten by the JIT engine.
To do this, you must give MCS the <tt>-g</tt> option:
<pre>
$ mcs -g Foo.cs
</pre>
This creates a <tt>Foo-debug.s</tt> assembler input file.
To use this in the JIT, you must first copy it to the target machine (the machine
where you want to run the JIT to debug your application) and run it through the
assembler to produce an object file <tt>Foo-debug.o</tt>. This object file must be
in the current directory.
Then start the JIT in your debugger and give it the <tt>--debug=dwarf-plus</tt> command
line argument.
Each time you call <tt>mono_debug_make_symbols ()</tt> from withing your debugger,
the JIT will read this <tt>Foo-debug.o</tt>, fix some machine dependent things like
memory addresses etc. in it and write it back to disk.
If you're using the GNU debugger, you'll want to use a macro like this:
<pre>
define relocate
call mono_debug_make_symbols ()
add-symbol-file /tmp/corlib.o
add-symbol-file mcs-debug.o
add-symbol-file Mono.CSharp.Debugger-debug.o
end
</pre>
If there is no <tt>assembly-debug.o</tt> file, but an <tt>assembly.il</tt> one, the
JIT will fall back to normal DWARF 2 (in the example above, <tt>corlib.dll</tt> was
compiled with Microsoft's compiler and the JIT is thus using DWARF to debug it).
This debugging method only works if you compiled your assembly with MCS, but it'll
allow you to actually debug your C# source code :-)
Here's an <a href="jit-debug-sample2.html">example debugging session</a> using
the GNU debugger.
** Breakpoints and single stepping
The JIT has a <tt>--break</tt> command line argument to insert a breakpoint at the
beginning of this method. It takes a <tt>Namespace.Class:Method</tt> argument which
is the method. This argument can be given multiple times.
However, once your application is stopped in GDB you may want to insert a breakpoint
the next time the JIT compiles a method. There's a global variable
<tt>mono_debug_insert_breakpoint</tt> which you can modify in your debugger.
If this variable is set to a non-zero value, the JIT's <tt>arch_compile_method</tt>
will insert a breakpoint the next time it is called, ie. at the top of the next
method it compiles. If this value has a positive value, it acts as a counter and is
decremented after inserting the breakpoint - setting it to a negative value will let
the JIT insert the breakpoint each time it compiles a new method.
There's also global variable <tt>mono_debug_last_breakpoint_address</tt> which always
contains the address of the last inserted breakpoint. You may manually override this
address with a <tt>nop</tt> instruction to delete the breakpoint.
For instance, I have a GDB macro called <tt>enter</tt> which I use to enter a method
rather than stepping over it:
<pre>
define enter
set mono_debug_insert_breakpoint = 1
continue
set *mono_debug_last_breakpoint_address = 0x90
relocate
frame
</pre>
Btw. speaking of single stepping - you should use your debuggers <tt>next</tt> command,
not its <tt>step</tt> command for single stepping unless you compiled the JIT without
debugging support. The reason for this is that the JIT creates machine code which contains
calls to JIT methods such as <tt>mono_object_new_wrapper</tt> at places where you don't
expect them - so unless the JIT is compiled at least without line numbers, your debugger
will enter such methods if you use <tt>step</tt> rather than <tt>next</tt>.
+86
View File
@@ -0,0 +1,86 @@
* A debugging session using a dynamically generated symbol file.
Let's assume we have the following C# application which we want to debug:
<pre>
using System;
public class Foo
{
public struct MyStruct {
int a;
long b;
double c;
}
public static void Main ()
{
Int32 value = 5;
long test = 512;
MyStruct my_struct;
my_struct.a = 5;
my_struct.b = test;
my_struct.c = 23323.5235;
}
}
</pre>
First of all, we need to compile it and create the .il files:
<pre>
$ mcs ./Foo.cs
$ monodis /home/export/martin/MONO-LINUX/lib/corlib.dll > corlib.il
$ monodis Foo.exe > Foo.il
</pre>
Now we can start the JIT in the debugger:
<pre>
$ gdb ~/monocvs/mono/mono/jit/mono
(gdb) r --debug=dwarf --break Foo:Main ./Foo.exe
Starting program: /home/martin/monocvs/mono/mono/jit/mono --debug=dwarf --break Foo:Main ./Foo.exe
0x081e8911 in ?? ()
(gdb) call mono_debug_make_symbols ()
(gdb) add-symbol-file /tmp/Foo.o
Reading symbols from /tmp/Foo.o...done.
Current language: auto; currently c++
(gdb) frame
#0 Foo.Main () at Foo.il:26
26 // method line 2
(gdb) n
Foo.Main () at Foo.il:38
38 IL_0000: ldc.i4.5
(gdb) list
33 .maxstack 2
34 .locals (
35 int32 V_0,
36 int64 V_1,
37 valuetype MyStruct V_2)
38 IL_0000: ldc.i4.5
39 IL_0001: stloc.0
40 IL_0002: ldc.i4 512
41 IL_0007: conv.i8
42 IL_0008: stloc.1
43 IL_0009: ldloca.s 2
44 IL_000b: ldc.i4.5
45 IL_000c: stfld int32 .MyStruct::a
46 IL_0011: ldloca.s 2
47 IL_0013: ldloc.1
48 IL_0014: stfld int64 .MyStruct::b
49 IL_0019: ldloca.s 2
50 IL_001b: ldc.r8 23323.5
51 IL_0024: stfld float64 .MyStruct::c
52 IL_0029: ret
(gdb) until 52
Foo.Main () at Foo.il:53
53 }
(gdb) info locals
V_0 = 5
V_1 = 512
V_2 = {a = 5, b = 512, c = 23323.523499999999}
</pre>
As you see in this example, you need to know IL code to use this debugging method - but
it may be the only way to debug a library.
+70
View File
@@ -0,0 +1,70 @@
* A debugging session using a symbol file which has been created by MCS.
Let's assume we have the following C# application which we want to debug:
<pre>
using System;
public class Foo
{
public struct MyStruct {
int a;
long b;
double c;
}
public static void Main ()
{
Int32 value = 5;
long test = 512;
MyStruct my_struct;
my_struct.a = 5;
my_struct.b = test;
my_struct.c = 23323.5235;
}
}
</pre>
First of all, we need to compile it with MCS, assemble the generated .s file and
create the .il files for all referenced assemblies which were not compiled with MCS:
<pre>
$ mcs -g ./Foo.cs
$ as -o Foo-debug.o Foo-debug.s
$ monodis /home/export/martin/MONO-LINUX/lib/corlib.dll > corlib.il
</pre>
Now we can start the JIT in the debugger:
<pre>
$ gdb ~/monocvs/mono/mono/jit/mono
(gdb) r --debug=dwarf-plus --break Foo:Main ./Foo.exe
Starting program: /home/martin/monocvs/mono/mono/jit/mono --debug=dwarf-plus --break Foo:Main ./Foo.exe
Program received signal SIGTRAP, Trace/breakpoint trap.
0x081e8681 in ?? ()
(gdb) call mono_debug_make_symbols ()
(gdb) add-symbol-file Foo-debug.o
(gdb) add-symbol-file /tmp/corlib.o
` (gdb) frame
#0 Main () at ./Foo.cs:11
11 public static void Main ()
(gdb) n
Main () at ./Foo.cs:13
13 Int32 value = 5;
(gdb)
14 long test = 512;
(gdb)
17 my_struct.a = 5;
(gdb)
18 my_struct.b = test;
(gdb)
19 my_struct.c = 23323.5235;
(gdb)
20 }
(gdb) info locals
value = 5
test = 512
my_struct = { a = 5, b = 512, c = 23323.5235 }
</pre>
Executable
+117
View File
@@ -0,0 +1,117 @@
* Compilers for other languages
Here are some other free compilers for other languages that
target .NET and should work with Mono with no problem:
<ul>
* <a href="#ComponentPascal">Component Pascal</a>
* <a href="#MonoLogo">MonoLogo</a>
* <a href="#Oberon">Oberon</a>
* <a href="#Forth">Forth</a>
</ul>
Languages we would like to have supported, with links to resources:
<ul>
* <a href="#JavaScript">Java Script</a>
* <a href="java.html">Java</a>
* <a href="#c">C</a>
</ul>
Some experimental languages:
<ul>
* <a href="#Tachy">Tachy</a> (scheme-like)
</ul>
<a name="MonoLogo">
** MonoLogo
An implementation of Logo for Mono (and .NET)
The <A href="http://monologo.sf.net">Mono Logo</a> compiler is
hosted in the <a href="ccvs.html">Mono CVS</a> repository
and also available on the <a href="anoncvs.html">AnonCVS</a> mirrors.
<a name="Oberon">
** Oberon
This Oberon compiler is written in Oberon.NET (another self
hosting compiler).
The main site <a href="http://www.oberon.ethz.ch/oberon.net/">http://www.oberon.ethz.ch/oberon.net/</a>
Download:
<a href="http://www.oberon.ethz.ch/oberon.net/download/">http://www.oberon.ethz.ch/oberon.net/download/</a>
Examples:
<a href="http://www.oberon.ethz.ch/oberon.net/examples/">http://www.oberon.ethz.ch/oberon.net/examples/</a>
<a href="http://www.superin.formativ.net/mono/oberon/oberon.zip">http://www.superin.formativ.net/mono/oberon/oberon.zip</a>
<a name="ComponentPascal">
** Component Pascal
The Component Pascal compiler: <a
href="http://www2.fit.qut.edu.au/CompSci/PLAS/ComponentPascal">Home
Page</a>, you can <a
href="http://www2.fit.qut.edu.au/CompSci/PLAS/ComponentPascal/gpcp1.1.4-netRTM.zip">
download it</a>
<a name="Forth">
** Delta Forth
The Delta Forth.NET project: <a
href="www.dataman.ro/dforth">Home
Page</a> and <a href="http://www.dataman.ro/dforth/index.html">more
details here</a>.
<a name="Tachy">
** Tachy
A subset of Scheme language called <a
href="http://radio.weblogs.com/0101156/stories/2002/03/19/tachy.html">Tachy</a>
* Missing languages
Here is a list of a few languages that we would like to see
supported. We will try to maintain a set of links here with
technical information for those interested in porting,
implementing or adapting a compiler for any of these
languages:
<a name="JavaScript">
* Java Script
The Mozilla project has an implementation of JavaScript
written in Java called <a
href="http://www.mozilla.org/rhino/">Rhino</a>.
You could port this code from Java to C#.
Note that since JavaScript allows for evaluation at runtime,
the compiler has to be built as a class that can be invoked at
runtime.
<a name="c">
* C
Ideally GCC could be modified to generate CIL, but it is a
big task. That would give us various compilers in one pass.
Rumor is that the next version of the LCC compiler will
include an IL backend. We do not know how extensive the support
for integration with .NET will be, but it would be an interesting
excercise to add an extension to C to call into .NET code.
LCC is not an open source compiler, but it is free as long as you
do not profit from selling it.
<a name="Java">
* Java
We have a <a href="java.html">separate page</a> for Java.
+202
View File
@@ -0,0 +1,202 @@
* Mailing Lists
Most of the mailing lists are in english, but there is also
Mono Hispano that has lists in Spanish. <a
href="http://mono.es.gnome.org/mailman/listinfo/mono-hispano">Mono Hispano list</a>
There are a number of mailing lists for Mono in English:
<table>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-list">mono-list</a></b>
</td>
<td>
The general Mono discussion list.
</td>
</tr>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-announce-list">mono-announce-list</a></b>
</td>
<td>
Announcements of Mono developments.
</td>
</tr>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-gc-list">mono-gc-list</a></b>
</td>
<td>
Discussion on the GC system of Mono.
</td>
</tr>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-patches">mono-patches</a></b>
</td>
<td>
Track the CVS activity of Mono on this mailing list (patches are sent to recipients).
You can get <a href="http://www.go-mono.com/snapshots">daily snapshots</a> as well.
</td>
</tr>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list</a></b>
</td>
<td>
Track the CVS activity of Mono on this mailing list.
</td>
</tr>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-docs-list">mono-docs-list</a></b>
</td>
<td>
Discussion on the documentation of Mono.
</td>
</tr>
<tr>
<td>
<b><a href="http://lists.ximian.com/mailman/listinfo/mono-bugs">mono-bugs</a></b>
</td>
<td>
This mailing list is used to keep track of the bugs in Mono as reported
in <a href="http://bugzilla.ximian.com">Bugzilla.ximian.com</a>
</td>
</tr>
</table>
Other mailing lists of interest:
<ul>
* <b><a
href="http://discuss.develop.com/dotnet.html">Dotnet mailing
list at Develop.com:</a></b> The guys at Develop Mentor run
this general purpose mailing list.
</ul>
</ul>
* Google search of the archives
<!-- Google Search with mods -->
<center>
<table>
<tr>
<td><a href="http://www.google.com/search"><img src="mailing-lists_files/Logo_40wht.gif" border="0" alt="Google" align="middle"></a></td>
<td>
<table>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face="arial,sans-serif" size="-1"><input type="hidden" name="domains" value="www.go-mono.com;lists.ximian.com"><br><input type="radio" name="sitesearch" value="www.go-mono.com"> Search www.go-mono.com <input type="radio" name="sitesearch" value="lists.ximian.com"> Search lists.ximian.com </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-list">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>list</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-announce-list">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>announce-list</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-bugs">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>bugs</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-gc-list">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>gc-list</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-cvs-list">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>cvs-list</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-patches">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>patches</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
</table>
</tr>
</table>
</center>
<!-- /Google Search with mods -->
+37
View File
@@ -0,0 +1,37 @@
* Mono for beginners
Hinne Hettema and Jaime Anguiano Olarra are providing us with
nice and complete set of documents (HOWTOs) about how to install,
configure, run and test the software developed by the Mono Project.
You can read them online, get PDF versions or get the XML sources.
HTML Format (read it online)
For <a href="mono-beginning/t1.html">RPM Linux based systems</a>
For <a href="http://geneura.ugr.es/~jaime/mono-beginning-windows/t1.html">Microsoft Windows</a>
PDF Format
For <a href="mono-beginning.pdf">RPM Linux based systems</a>
For <a href="http://geneura.ugr.es/~jaime/mono-beginning-windows/mono-beginning-windows.pdf">Microsoft Windows</a>
XML Source
For <a href="mono-beginning.xml">RPM Linux based systems</a>
For <a href="http://geneura.ugr.es/~jaime/mono-beginning-windows/mono-beginning-windows.xml">Microsoft Windows</a>
Currently Hinne is working on a Mono Tools HOWTO. Which will be
very useful for the hackers that would like to get in touch with
Mono and Jaime is working out a Mono Beginning HOWTO for Debian
users.
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+147
View File
@@ -0,0 +1,147 @@
#!/bin/bash
# Script to automate the building of mono and its dependencies on
# cygwin. Relies on wget being installed (could make it fall back to
# using lynx, links, w3, curl etc), assumes that gcc, make, tar,
# automake, etc are already installed too (may be worth testing for
# all that right at the top and bailing out if missing/too old/too new
# etc).
# See where we are. This will become the top level directory for the
# installation, unless we are given an alternative location
here=$1
test -z "$here" && here=`pwd`
echo "Building Mono and dependencies in $here, installing to $here/install"
PATH=$here/install/bin:$here/install/lib:$PATH
# Check mono out first, so we can run aclocal from inside the mono dir (it
# needs to see which version of the real aclocal to run)
test -z "$CVSROOT" && CVSROOT=:pserver:[email protected]:/mono
export CVSROOT
echo "Updating mono"
# cvs checkout does the same as cvs update, except that it copes with
# new modules being added
# Older versions of cvs insist on a cvs login for :pserver: methods
# Make sure cvs is using ssh for :ext: methods
if [ ${CVSROOT:0:5} = ":ext:" ]; then
CVS_RSH=ssh
export CVS_RSH
elif [ ${CVSROOT:0:9} = ":pserver:" ]; then
if ! grep $CVSROOT ~/.cvspass > /dev/null 2>&1 ; then
echo "Logging into CVS server. Anonymous CVS password is probably empty"
cvs login || exit -1
fi
fi
cvs checkout mono || exit -1
if [ ! -z "${AUTO_STABLE}" -o -e /usr/autotool/stable ]; then
export AUTO_STABLE=${AUTO_STABLE:-/usr/autotool/stable}
export AUTO_DEVEL=${AUTO_STABLE}
fi
# Need to install pkgconfig and set ACLOCAL_FLAGS if there is not a
# pkgconfig installed already. Otherwise set PKG_CONFIG_PATH to the
# glib we're about to install in $here/install. This script could
# attempt to be clever and see if glib 2 is already installed, too.
# --print-ac-dir was added in 1.2h according to the ChangeLog. This
# should mean that any automake new enough for us has it.
# This sets ACLOCAL_FLAGS to point to the freshly installed pkgconfig
# if it doesnt already exist on the system (otherwise auto* breaks if
# it finds two copies of the m4 macros). The GIMP for Windows
# pkgconfig sets its prefix based on the location of its binary, so we
# dont need PKG_CONFIG_PATH (the internal pkgconfig config file
# $prefix is handled similarly).
function aclocal_scan () {
# Quietly ignore the rogue '-I' and other aclocal flags that
# aren't actually directories...
#
# cd into mono/ so that the aclocal wrapper can work out which version
# of aclocal to run
for i in `(cd mono && aclocal --print-ac-dir)` $ACLOCAL_FLAGS
do
if [ -f $i/$1 ]; then
return 0
fi
done
return 1
}
function install_package() {
zipfile=$1
markerfile=$2
name=$3
echo "Installing $name..."
if [ ! -f $here/$zipfile ]; then
wget http://www.go-mono.com/archive/$zipfile
fi
# Assume that the package is installed correctly if the marker
# file is there
if [ ! -f $here/install/$markerfile ]; then
(cd $here/install || exit -1; unzip -o $here/$zipfile || exit -1) || exit -1
fi
}
if ! aclocal_scan pkg.m4 ; then
ACLOCAL_FLAGS="-I $here/install/share/aclocal $ACLOCAL_FLAGS"
fi
export PATH
export ACLOCAL_FLAGS
# Grab pkg-config, glib etc
if [ ! -d $here/install ]; then
mkdir $here/install || exit -1
fi
# Fetch and install pkg-config, glib, iconv, intl
install_package pkgconfig-0.80-tml-20020101.zip bin/pkg-config.exe pkgconfig
install_package glib-1.3.12-20020101.zip lib/libglib-1.3-12.dll glib
install_package glib-dev-1.3.12-20020101.zip lib/glib-1.3.lib glib-dev
install_package libiconv-1.7.zip lib/iconv.dll iconv
install_package libiconv-dev-1.7.zip lib/iconv.lib iconv-dev
install_package libintl-0.10.40-20020101.zip lib/libintl-1.dll intl
install_package libgc-dev.zip lib/gc.dll gc-dev
# Needed to find the libiconv bits
CPPFLAGS="$CPPFLAGS -I$here/install/include"
LDFLAGS="$LDFLAGS -L$here/install/lib"
export CPPFLAGS
export LDFLAGS
# Make sure we build native w32, not cygwin
#CC="gcc -mno-cygwin"
#export CC
# --prefix is used to set the class library dir in mono, and it needs
# to be in windows-native form. It also needs to have '\' turned into
# '/' to avoid quoting issues during the build.
prefix=`cygpath -w $here/install | sed -e 's@\\\\@/@g'`
# Build and install mono
echo "Building and installing mono"
(cd $here/mono; ./autogen.sh --prefix=$prefix || exit -1; make || exit -1; make install || exit -1) || exit -1
echo ""
echo ""
echo "All done."
echo "Add $here/install/bin and $here/install/lib to \$PATH"
echo "Don't forget to copy the class libraries to $here/install/lib"
+183
View File
@@ -0,0 +1,183 @@
#!/bin/bash
# Script to automate the building of mono and its dependencies.
# Relies on wget being installed (could make it fall back to using
# lynx, links, w3, curl etc), assumes that gcc, make, tar, automake,
# etc are already installed too (may be worth testing for all that
# right at the top and bailing out if missing/too old/too new etc).
# See where we are. This will become the top level directory for the
# installation, unless we are given an alternative location
here=$1
test -z "$here" && here=`pwd`
echo "Building Mono and dependencies in $here, installing to $here/install"
PATH=$here/install/bin:$PATH
LD_LIBRARY_PATH=$here/install/lib:$LD_LIBRARY_PATH
# Need to install pkgconfig and set ACLOCAL_FLAGS if there is not a
# pkgconfig installed already. Otherwise set PKG_CONFIG_PATH to the
# glib we're about to install in $here/install. This script could
# attempt to be clever and see if glib 2 is already installed, too.
# --print-ac-dir was added in 1.2h according to the ChangeLog. This
# should mean that any automake new enough for us has it.
function aclocal_scan () {
# Quietly ignore the rogue '-I' and other aclocal flags that
# aren't actually directories...
for i in `aclocal --print-ac-dir` $ACLOCAL_FLAGS
do
if [ -f $i/$1 ]; then
return 0
fi
done
return 1
}
function pkgconfig_scan () {
module=$1
echo "Finding pkgconfig files for $module..."
# Should we use locate? or just a list of well-known directories?
# locate has the problem of false positives in src dirs
for i in /usr/lib/pkgconfig /usr/local/lib/pkgconfig
do
echo "Looking in $i..."
if [ -f $i/${module}.pc ]; then
echo $i
return
fi
done
}
function install_package() {
tarfile=$1
dirname=$2
name=$3
configure_options=$4
echo "Installing $name..."
if [ ! -f $here/$tarfile ]; then
wget http://www.go-mono.org/archive/$tarfile
fi
# Assume that the package built correctly if the dir is there
if [ ! -d $here/$dirname ]; then
# Build and install package
tar xzf $here/$tarfile || exit -1
(cd $here/$dirname; ./configure --prefix=$here/install $configure_options || exit -1; make || exit -1; make install || exit -1)
success=$?
if [ $success -ne 0 ]; then
echo "***** $name build failure. Run rm -rf $here/$dirname to have this script attempt to build $name again next time"
exit -1
fi
fi
}
if aclocal_scan pkg.m4 ; then
install_pkgconfig=no
else
install_pkgconfig=yes
fi
if aclocal_scan glib-2.0.m4 ; then
install_glib=no
if [ $install_pkgconfig = "yes" ]; then
# We have to tell the newly-installed pkgconfig about the
# system-installed glib
PKG_CONFIG_PATH=`pkgconfig_scan glib-2.0`:$PKG_CONFIG_PATH
fi
else
install_glib=yes
PKG_CONFIG_PATH="$here/install/lib/pkgconfig:$PKG_CONFIG_PATH"
fi
if [ -f /usr/include/gc/gc.h ]; then
install_libgc=no
else
install_libgc=yes
fi
if [ $install_pkgconfig = "yes" -o $install_glib = "yes" ]; then
ACLOCAL_FLAGS="-I $here/install/share/aclocal $ACLOCAL_FLAGS"
fi
export PATH
export LD_LIBRARY_PATH
export ACLOCAL_FLAGS
export PKG_CONFIG_PATH
CPPFLAGS="$CPPFLAGS -I$here/install/include"
LDFLAGS="$LDFLAGS -L$here/install/lib"
export CPPFLAGS
export LDFLAGS
# Grab pkg-config-0.8, glib-1.3.12 if necessary
if [ $install_pkgconfig = "yes" ]; then
install_package pkgconfig-0.8.0.tar.gz pkgconfig-0.8.0 pkgconfig ""
else
echo "Not installing pkgconfig, you already seem to have it installed"
fi
if [ $install_glib = "yes" ]; then
install_package glib-1.3.13.tar.gz glib-1.3.13 glib ""
else
echo "Not installing glib, you already seem to have it installed"
fi
if [ $install_libgc = "yes" ]; then
LIBS="-ldl" install_package gc6.0.tar.gz gc6.0 libgc "--enable-threads=pthreads"
# make install didnt do the headers!
mkdir -p $here/install/include/gc
cp -r $here/gc6.0/include/* $here/install/include/gc
else
echo "Not installing libgc, you already seem to have it installed"
fi
# End of build dependencies, now get the latest mono checkout and build that
test -z "$CVSROOT" && CVSROOT=:pserver:[email protected]:/mono
export CVSROOT
echo "Updating mono"
# cvs checkout does the same as cvs update, except that it copes with
# new modules being added
# Older versions of cvs insist on a cvs login for :pserver: methods
# Make sure cvs is using ssh for :ext: methods
if [ ${CVSROOT:0:5} = ":ext:" ]; then
CVS_RSH=ssh
export CVS_RSH
elif [ ${CVSROOT:0:9} = ":pserver:" ]; then
# Chop off the trailing /mono because cvs 1.11 adds the port number
# into the .cvspass line
if ! grep ${CVSROOT%:/mono} ~/.cvspass > /dev/null 2>&1 ; then
echo "Logging into CVS server. Anonymous CVS password is probably empty"
cvs login
fi
fi
cvs checkout mono || exit -1
# Build and install mono
echo "Building and installing mono"
(cd $here/mono; ./autogen.sh --prefix=$here/install || exit -1; make || exit -1; make install || exit -1) || exit -1
echo ""
echo ""
echo "All done."
echo "Add $here/install/bin to \$PATH"
echo "Add $here/install/lib to \$LD_LIBRARY_PATH"
echo "Don't forget to copy the class libraries to $here/install/lib"
+551
View File
@@ -0,0 +1,551 @@
<Mono newbie coders start file>
<h1> A little help for mono newbie coders </h1>
For those who are new to Mono and are impatient to contribute
with code (uhh... you are brave!!) here is the document you
should read.
You will see all Mono hackers say the same (great minds have
similar way of thinking): First, DO WRITE TESTS!!!. In order
to do that:
<ul>
* Start with the NUnit Tests Guidelines. In the cvs
they are located at: mcs/class/doc/NUnitGuideli...
* But wait, this is a document for impatient
people. So EVERYTHING should be here. Well, it is.
</ul>
<h2> The NUnit Tests Guidelines document </h2>
Mono NUnit Test Guidelines and Best Practices
Authors: Nick Drochak <[email protected]>
Martin Baulig <[email protected]>
Last Update: 2002-03-02
Rev: 0.3
<b> Purpose </b>
This document captures all the good ideas people have had
about writing NUnit tests for the mono project. This document
will be useful for anyone who writes or maintains unit tests.
<b> Other resources </b>
- mcs/class/README has an explanation of the build process and
how it relates to the tests.
- http://nunit.sourceforge.net is the place to find out about
NUnit
<b> Getting Started </b>
If you are new to writing NUnit tests, there is a template
you may use to help get started. The file is:
mcs/class/doc/TemplateTest.cs
(2.- This is the point two!. This file is just after the end
of the guidelines. Copy/paste it in another buffer. And keep
reading.)
Save a copy of this file in the appropriate test subdirecty
(see below), and replace all the [text] markers with
appropriate code. Comments in the template are there to guide
you. You should also look at existing tests to see how other
people have written them.
mcs/class/corlib/Test/System.Collections/CollectionBaseTest.cs
is a small one that might help.
(3.- You reached the third point. And as expected, it's just
here to tell you that the content of CollectionBaseTest.cs is
after the TemplateTest.cs code at the end of these
guidelines.)
The directory that will contain your new file depends on the
assembly/namespace of the class for which you are creating the
tests. Under mcs/class there is a directory for each assembly.
In each assembly there is a Test directory, e.g.
mcs/class/corlib/Test. In the Test directory there are
sub-directories for each namespace in the assembly, e.g.
mcs/class/corlib/Test/Sytem. Put your new test file in the
appropriate sub-directory under Test for the class you are
testing.
Once your test class is complete, you need to add it to the
AllTests.cs file in the same directory as your new test. Add a
call to "suite.AddTest()" passing the name of your new test
class's suite property as the parameter. You will see examples
in the AllTests.cs file, so just copy and paste inside there.
Once all of that is done, you can do a 'make test' from the top
mcs directory. Your test class will be automagically included
in the build and the tests will be run along with all the
others.
<b> Tips </b>
<b> Provide an unique error message for Assert() </b>
Include an unique message for each Assert() so that when the
assert fails, it is trivial to locate the failing one.
Otherwise, it may be difficult to determine which part of the
test is failing. A good way to ensure unique messages is to use
something like #A01, #A02 etc.
Bad:
<pre>
AssertEquals("array match", compare[0], i1[0]);
AssertEquals("array match", compare[1], i1[1]);
AssertEquals("array match", compare[2], i1[2]);
AssertEquals("array match", compare[3], i1[3]);
</pre>
Good:
<pre>
AssertEquals("#A01", compare[0], i1[0]);
AssertEquals("#A02", compare[1], i1[1]);
AssertEquals("#A03", compare[2], i1[2]);
AssertEquals("#A04", compare[3], i1[3]);
</pre>
Once you used such a number in an Assert(), don't change it
later on - people might use it it identify the test in bug
reports or in mailing lists.
<b> Use AssertEquals() to compare things, not Assert(). </b>
Never compare two values with Assert() - if the test fails,
people have no idea what went wrong while AssertEquals()
reports the failed value.
Bad:
<pre>
Assert ("A01", myTicks[0] == t1.Ticks);
</pre>
Good:
<pre>
AssertEquals ("A01", myTicks[0], t1.Ticks);
</pre>
<b> Constructors </b>
When writing your testcase, please make sure to provide a
constructor which takes no arguments:
<pre>
public class DateTimeTest : TestCase
{
public DateTimeTest() : base ("[MonoTests.System.DateTimeTest]") {}
public DateTimeTest (string name): base(name) {}
public static ITest Suite
{
get {
TestSuite suite = new TestSuite ();
return suite;
}
}
}
</pre>
<b> Namespace </b>
Please keep the namespace within each test directory
consistent - all tests which are referenced in the same
AllTests.cs must be in the same namespace. Of course you can
use subnamespaces as you like - especially for subdirectories
of your testsuite.
For instance, if your AllTests.cs is in namespace "MonoTests"
and you have a subdirectory called "System", you can put all
the tests in that dir into namespace "MonoTests.System".
<b> Test your test with the microsoft runtime </b>
If possible, try to run your testsuite with the Microsoft
runtime on Windows and make sure all tests in it pass. This is
especially important if you're writing a totally new testcase
- without this check you can never be sure that your testcase
contains no bugs ....
Don't worry if you're writing your test on Linux, other people
can test it for you on Windows.
Sometimes you may discover that a test doesn't show the
expected result when run with the Microsoft runtime - either
because there is a bug in their runtime or something is
misleading or wrong in their documentation. In this case,
please put a detailed description of the problem to
mcs/class/doc/API-notes and do also report it to the list -
we'll forward this to the Microsoft people from time to time
to help them fix their documentation and runtime.
<pre>
-------------------- TemplateTest.cs begins ----------
// this is a template for making NUnit tests. Text enclosed
// in square brackets (and the brackets themselves) should be
// replaced by appropiate code.
// [File Name].cs - NUnit Test Cases for [explain here]
//
// [Author Name] ([Author email Address])
//
// (C) [Copyright holder]
//
// these are the standard namespaces you will need. You may
// need to add more depending on your tests.
using NUnit.Framework;
using System;
// all test namespaces start with "MonoTests." Append the
// Namespace that contains the class you are testing, e.g.
// MonoTests.System.Collections
namespace MonoTests.[Namespace]
{
// the class name should end with "Test" and start with the name
// of the class you are testing, e.g. CollectionBaseTest
public class [Class to be tested]Test : TestCase {
// there should be two constructors for your class. The first
// one (without parameters) should set the name to something
// unique.
// Of course the name of the method is the same as the name of
// the class
public [Constructor]() : base ("[Namespace.Class]") {}
public [Constructor](string name) : base(name) {}
// this method is run before each Test* method is called. You
// can put variable initialization, etc. here that is common to
// each test.
// Just leave the method empty if you don't need to use it.
protected override void SetUp() {}
// this method is run after each Test* method is called. You
// can put clean-up code, etc. here. Whatever needs to be done
// after each test. Just leave the method empty if you don't need
// to use it.
protected override void TearDown() {}
// this property is required. You need change the parameter for
// typeof() below to be your class.
public static ITest Suite {
get {
return new TestSuite(typeof([Classname here]));
}
}
// this is just one of probably many test methods in your test
// class. each test method must start with "Test". All methods
// in your class which start with "Test" will be automagically
// called by the NUnit framework.
public void Test[Something] {
// inside here you will exercise your class and then
// call Assert()
}
}
---------------------- TemplateTest.cs ends --------------
---------------------- CollectionBaseTest.cs begins ------
//
// System.Collections.CollectionBase
// Test suite for System.Collections.CollectionBase
//
// Author:
// Nick D. Drochak II
//
// (C) 2001 Nick D. Drochak II
//
using System;
using System.Collections;
using NUnit.Framework;
namespace MonoTests.System.Collections
{
public class CollectionBaseTest : TestCase
{
public CollectionBaseTest () : base
("System.Collection.CollectionBase testsuite")
{}
public CollectionBaseTest (String name) : base (name)
{}
// We need a concrete class to test the abstract base
// class
public class ConcreteCollection : CollectionBase
{
// These fields are used as markers to test
// the On* hooks.
public bool onClearFired;
public bool onClearCompleteFired;
public bool onInsertFired;
public int onInsertIndex;
public bool onInsertCompleteFired;
public int onInsertCompleteIndex;
public bool onRemoveFired;
public int onRemoveIndex;
public bool onRemoveCompleteFired;
public int onRemoveCompleteIndex;
public bool onSetFired;
public int onSetOldValue;
public int onSetNewValue;
public bool onSetCompleteFired;
public int onSetCompleteOldValue;
public int onSetCompleteNewValue;
// This constructor is used to test OnValid()
public ConcreteCollection()
{
IList listObj;
listObj = this;
listObj.Add(null);
}
// This constructor puts consecutive integers into the list
public ConcreteCollection(int i) {
IList listObj;
listObj = this;
int j;
for (j = 0; j< i; j++) {
listObj.Add(j);
}
}
// A helper method to look at a value in the
// list at a specific index
public int PeekAt(int index)
{
IList listObj;
listObj = this;
return (int) listObj[index];
}
// Mark the flag if this hook is fired
protected override void OnClear() {
this.onClearFired = true;
}
// Mark the flag if this hook is fired
protected override void OnClearComplete()
{
this.onClearCompleteFired = true;
}
// Mark the flag, and save the paramter if
// this hook is fired
protected override void OnInsert(int index,
object value)
{
this.onInsertFired = true;
this.onInsertIndex = index;
}
// Mark the flag, and save the paramter if
// this hook is fired
protected override void OnInsertComplete(int index,
object value)
{
this.onInsertCompleteFired = true;
this.onInsertCompleteIndex = index;
}
// Mark the flag, and save the paramter if this hook
// is fired
protected override void OnRemove(int index,
object value)
{
this.onRemoveFired = true;
this.onRemoveIndex = index;
}
// Mark the flag, and save the paramter if this hook
// is fired
protected override void OnRemoveComplete(int index,
object value)
{
this.onRemoveCompleteFired = true;
this.onRemoveCompleteIndex = index;
}
// Mark the flag, and save the paramters if this hook
// is fired
protected override void OnSet(int index, object oldValue,
object newValue)
{
this.onSetFired = true;
this.onSetOldValue = (int) oldValue;
this.onSetNewValue = (int) newValue;
}
// Mark the flag, and save the paramters if this hook
// is fired
protected override void OnSetComplete(int index,
object oldValue,
object newValue)
{
this.onSetCompleteFired = true;
this.onSetCompleteOldValue = (int) oldValue;
this.onSetCompleteNewValue = (int) newValue;
}
} // public class ConcreteCollection
public static ITest Suite {
get {
return new TestSuite
(typeof(CollectionBaseTest));
}
}
// Check the count property
public void TestCount() {
ConcreteCollection myCollection;
myCollection = new ConcreteCollection(4);
Assert(4 == myCollection.Count);
}
// Make sure GetEnumerator returns an object
public void TestGetEnumerator() {
ConcreteCollection myCollection;
myCollection = new ConcreteCollection(4);
Assert(null != myCollection.GetEnumerator());
}
// OnValid disallows nulls
public void TestOnValid() {
ConcreteCollection myCollection;
try {
myCollection = new ConcreteCollection();
}
catch (ArgumentNullException) {
}
}
// Test various Insert paths
public void TestInsert() {
ConcreteCollection myCollection;
int numberOfItems;
numberOfItems = 3;
// The constructor inserts
myCollection = new ConcreteCollection(numberOfItems);
Assert(myCollection.onInsertFired);
Assert(myCollection.onInsertCompleteFired);
// Using the IList interface, check inserts in the middle
IList listObj = myCollection;
listObj.Insert(1, 9);
Assert(myCollection.onInsertIndex == 1);
Assert(myCollection.onInsertCompleteIndex == 1);
Assert(myCollection.PeekAt(1) == 9);
}
// Test Clear and it's hooks
public void TestClear()
{
ConcreteCollection myCollection;
int numberOfItems;
numberOfItems = 1;
myCollection = new ConcreteCollection(numberOfItems);
myCollection.Clear();
Assert(myCollection.Count == 0);
Assert(myCollection.onClearFired);
Assert(myCollection.onClearCompleteFired);
}
// Test RemoveAt, other removes and the hooks
public void TestRemove()
{
ConcreteCollection myCollection;
int numberOfItems;
numberOfItems = 3;
// Set up a test collection
myCollection = new ConcreteCollection(numberOfItems);
// The list is 0-based. So if we remove the second one
myCollection.RemoveAt(1);
// We should see the original third one in it's place
Assert(myCollection.PeekAt(1) == 2);
Assert(myCollection.onRemoveFired);
Assert(myCollection.onRemoveIndex == 1);
Assert(myCollection.onRemoveCompleteFired);
Assert(myCollection.onRemoveCompleteIndex == 1);
IList listObj = myCollection;
listObj.Remove(0);
// Confirm parameters are being passed to the hooks
Assert(myCollection.onRemoveIndex == 0);
Assert(myCollection.onRemoveCompleteIndex == 0);
}
// Test the random access feature
public void TestSet()
{
ConcreteCollection myCollection;
int numberOfItems;
numberOfItems = 3;
myCollection = new ConcreteCollection(numberOfItems);
IList listObj = myCollection;
listObj[0] = 99;
Assert((int) listObj[0] == 99);
Assert(myCollection.onSetFired);
Assert(myCollection.onSetCompleteFired);
Assert(myCollection.onSetOldValue == 0);
Assert(myCollection.onSetCompleteOldValue == 0);
Assert(myCollection.onSetNewValue == 99);
Assert(myCollection.onSetCompleteNewValue == 99);
}
}
}
----------------------- CollectionBaseTest.cs ends --------
</pre>
<ul>
* If you use Emacs, you might want to use the .emacs
file and the package developed by Brad Merrill
mailto:[email protected]. It will allow you to
highlight and indent in C# style in your Emacs
editor. (XEmacs will still work but it'll also
complain).
* CSharpDevelop is a GPLed IDE developed by IC#Code.
Search for it at sourceforge if you are interested
in it.
* For those who Java: "A comparison of Microsoft's
C# programming language to Sun Microsystem's Java
Programming language" by Dare Obasanjo is a really good
(very complete) text to read.
* Suggest this point and more, now I can't think of
anything more.
</ul>
Enjoy!!.
(c) 2002, <a href="mailto:[email protected]">Jaime Anguiano Olarra</a>.
The parts included in this document are property of their
respective authors.
Note: The identation of the source code has been changed a bit
so it could fit better in the website. Anyway, as nothing more
changed, the files should work as expected.
+755
View File
@@ -0,0 +1,755 @@
* MonoDoc XML Tag Reference
** Introduction
<em>
[This documentation is in progress. Comments to
<a href="mailto:[email protected]">[email protected]</a> and/or
<a href="mailto:[email protected]">[email protected]</a>.]
</em>
MonoDoc XML, our format for multilingual API documentation stored outside of
source files, is very similar to the output of Microsoft's csc /doc. Minor
alterations have been made to ease human parsing and hand-editing, but
the majority of the tags are identical. In fact, many of the descriptions
and examples below are taken from the ECMA C# Language Specification with
little or no alteration.
This document provides a list of all available MonoDoc XML tags, with
syntax and examples. A complete example can be found in
<a href="#appendix-a">Appendix A</a>, and both a <a href="#">DTD</a> and
<a href="#">XSD schema</a> will be available very shortly.
** MonoDoc XML Tags
<dl>
<dt><code><a href="#c">&lt;c&gt;</a></code></dt>
<dd>Mark short sections of text as code.</dd>
<dt><code><code><a href="#code">&lt;code&gt;</a></code></dt></code>
<dd>Mark one or more lines as code or output.</dd>
<dt><code><a href="#doc">&lt;doc&gt;</a></dt></code>
<dd>Root element of documentation XML.</dd>
<dt><code><a href="#event">&lt;event&gt;</a></dt></code>
<dd>Describe an event.</dd>
<dt><code><a href="#example">&lt;example&gt;</a></dt></code>
<dd>An example.</dd>
<dt><code><a href="#exception">&lt;exception&gt;</a></dt></code>
<dd>Specify an exception a method can throw.</dd>
<dt><code><a href="#field">&lt;field&gt;</a></dt></code>
<dd>Describe a field.</dd>
<dt><code><a href="#list">&lt;list&gt;</a></dt></code>
<dd>Create a list or table.</dd>
<dt><code><a href="#method">&lt;method&gt;</a></dt></code>
<dd>Describe a method.</dd>
<dt><code><a href="#para">&lt;para&gt;</a></dt></code>
<dd>Allow text to be structured in paragraphs.</dd>
<dt><code><a href="#param">&lt;param&gt;</a></dt></code>
<dd>Specify a parameter for a method.</dd>
<dt><code><a href="#paramref">&lt;paramref&gt;</a></dt></code>
<dd>Mark a word as a parameter.</dd>
<dt><code><a href="#permission">&lt;permission&gt;</a></dt></code>
<dd>Define the access level of a member.</dd>
<dt><code><a href="#property">&lt;property&gt;</a></dt></code>
<dd>Describe a property.</dd>
<dt><code><a href="#remarks">&lt;remarks&gt;</a></dt></code>
<dd>Provide verbose information for a type or member.</dd>
<dt><code><a href="#returns">&lt;returns&gt;</a></dt></code>
<dd>Specify the return value of a method.</dd>
<dt><code><a href="#see">&lt;see&gt;</a></dt></code>
<dd>Specify a link.</dd>
<dt><code><a href="#seealso">&lt;seealso&gt;</a></dt></code>
<dd>Specify a 'see also' entry.</dd>
<dt><code><a href="#summary">&lt;summary&gt;</a></dt></code>
<dd>Provide a brief (usually one sentence) description of a member or type.</dd>
<dt><code><a href="#type">&lt;type&gt;</a></dt></code>
<dd>Describe a type.</dd>
</dl>
** Definitions and Examples
*** <a name="c">&lt;c&gt;</a>
This tag can be used to mark short, inline fragments of text that should
be considered source code or program output. User agents should render
this tag in a special -- likely monospace -- font. For larger sections,
use <a href="#code"><code>&lt;code&gt;</code></a>.
**** Syntax
<pre>
&lt;c&gt;code or output text&lt;/c&gt;
</pre>
**** Example
<pre>
&lt;remarks&gt;
Class &lt;c&gt;Point&lt;/c&gt; models a point in two-dimensional space.
&lt;/remarks&gt;
</pre>
*** <a name="code">&lt;code&gt;</a>
This tag can be used to mark one or more lines of text as source code or
program output. User agents should render this tag in a special (likely
monospace) font, and preserve both whitespace and newlines.
**** Syntax
<code>&lt;code&gt;source or program output&lt;/code&gt;</code>
**** Example
<pre>
&lt;summary&gt;
This method changes the point's location by the given
x- and y-offsets.
&lt;example lang="C#"&gt;
A C# example:
&lt;code&gt;
Point p = new Point(3, 5);
p.Translate(-1, 3);
// p == (2, 8);
&lt;/code&gt;
&lt;/example&gt;
&lt;/summary&gt;
</pre>
*** <a name="doc">&lt;doc&gt;</a>
This tag is the root element of the documentation file. It can contain
any number of &lt;type&gt; elements.
**** Syntax
<code>&lt;doc lang="language" assembly="assembly"&gt;typedocs&lt;/doc&gt;</code>
<blockquote>
<em>lang="language"</em><br />
The two-letter ISO code that specifies what language the contained
documentation is written in.
</blockquote>
**** Example
<pre>
&lt;doc lang="en"&gt;
&lt;type name="Graphics.Point"&gt;
&lt;!-- ... --&gt;
&lt;/type&gt;
&lt;/doc&gt;
</pre>
*** <a name="event">&lt;event&gt;</a>
This tag documents an event.
**** Syntax
<code>&lt;event name="eventname"&gt;documentation&lt;/event&gt;</code>
<blockquote>
<em>name="eventname"</em><br />
The name of the event being documented.
</blockquote>
**** Example
<pre>
&lt;event name="Click"&gt;
&lt;summary&gt;
Occurs when the control is clicked.
&lt;/summary&gt;
&lt;data&gt;
The event handler receives an argument of type EventArgs
containing data related to this event.
&lt;/data&gt;
&lt;remarks&gt;
&lt;para&gt;The ControlStyles.StandardClick style must be set
for this event to be raised.&lt;/para&gt;
&lt;para&gt;For more information about handling events, see
Consuming Events.&lt;/para&gt;
&lt;/remarks&gt;
&lt;/event&gt;
</pre>
*** <a name="example">&lt;example&gt;</a>
This tag marks a section of text as an example, and optionally specifies
what programming language <code><a href="#code">&lt;code&gt;</a></code> portions of the example are written in.
**** Syntax
<code><example lang="language">example text and code</example></code>
<blockquote>
<em>lang="language"</em><br />
(optional) The name of the programming language <code><a href="#code">&lt;code&gt;</a></code> blocks in this example
use. This information can be used by user agents to provide
intelligent access to examples in multiple languages.
</blockquote>
**** Example
See <code><a href="#code">&lt;code&gt;<a/></code> for an example.
*** <a name="exception">&lt;exception&gt;</a>
This tag provides a way to specify the exceptions a method can throw.
**** Syntax
<code>&lt;exception cref="exception-type"&gt;description&lt;/exception&gt;</code>
<blockquote>
<em>cref="exception-type"</em><br />
The name of an exception type.
</blockquote>
**** Example
<pre>
&lt;exception cref="System.IO.FileNotFoundException"&gt;
Thrown when the requested file is not found.
&lt;/exception&gt;
</pre>
*** <a name="field">&lt;field&gt;</a>
This tag is used to describe a field.
**** Syntax
<code>&lt;field name="fieldname"&gt;documentation&lt;/field&gt;</code>
<blockquote>
<em>name="fieldname"</em><br />
The name of the field being documented.
</blockquote>
**** Example
<pre>
&lt;field name="x"&gt;
&lt;summary&gt;
Instance variable &lt;c&gt;x&lt;/c&gt; represents the point's
x-coordinate.
&lt;/summary&gt;
&lt;/field&gt;
</pre>
*** <a name="list">&lt;list&gt;</a>
This tag is used to create a list or table of items. It may contain a
<code>&lt;listheader&gt;</code> block to define the heading row of either a table or
definition list. (When defining a table, only an entry for 'term' in the
heading need be supplied.)
Each item in the list is specified with an <code>&lt;item&gt;</code> block. When creating a
definition list, both <code>&lt;term&gt;</code> and <code>&ltdescription&gt;</code> must be specified.
However, for a table, bulleted list, or numbered list, only <code>&lt;description&gt;</code>
need be specified.
**** Syntax
<pre>
&lt;list type="bullet" | "number" | "table"&gt;
&lt;listheader&gt;
&lt;term&gt;term&lt;/term&gt;
&lt;description&gt;description&lt;/description&gt;
&lt;/listheader&gt;
&lt;item&gt;
&lt;term&gt;term&lt;/term&gt;
&lt;description&gt;description&lt;/description&gt;
&lt;/item&gt;
...
&lt;/list&gt;
</pre>
<blockquote>
<em>term</em><br />
The term to define, whose definition is in <code>&lt;description&gt;</code>.
<br /><br />
<em>description</em><br />
Either an item in a bullet or numbered list, or the definition of a <code>&lt;term&gt;</code>.
</blockquote>
**** Example
<pre>
&lt;list type="bullet"&gt;
&lt;item&gt;
&lt;description&gt;Item 1&lt;/description&gt;
&lt;/item&gt;
&lt;item&gt;
&lt;description&gt;Item 2&lt;/description&gt;
&lt;/item&gt;
&lt;/list&gt;
</pre>
*** <a name="method">&lt;method&gt;</a>
This tag is the overall containing tag for documenting a method.
**** Syntax
<code>&lt;method name="methodname"&gt;documentation&lt;/method&gt;</code>
**** Example
<pre>
&lt;method name="op_Equality(Graphics.Point,Graphics.Point)"&gt;
&lt;summary&gt;
This operator determines whether two points have
the same location.
&lt;/summary&gt;
&lt;param name="p1"&gt;
&lt;c&gt;p1&lt;/c&gt; is the first Point to be compared.
&lt;/param&gt;
&lt;param name="p2"&gt;
&lt;c&gt;p2&lt;/c&gt; is the second Point to be compared.
&lt;/param&gt;
&lt;returns&gt;
True if the points have the same location and they
have the exact same type; otherwise, false.
&lt;/returns&gt;
&lt;seealso cref="Equals(System.Object)" /&gt;
&lt;seealso cref="op_Inequality(Graphics.Point,Graphics.Point)" /&gt;
&lt;/method&gt;
</pre>
*** <a name="para">&lt;para&gt;</a>
This tag is for use inside other tags such as <code>&lt;remarks&gt;</code> or <code>&lt;returns&gt;</code>, and
allows text to be structured into paragraphs.
**** Syntax
<code>&lt;para&gt;text&lt;/para&gt;</code>
**** Example
<pre>
&lt;summary&gt;
&lt;para&gt;
This is the entry point of the &lt;c&gt;Point&lt;/c&gt; class testing
program.
&lt;/para&gt;
&lt;para&gt;
This program tests each method and operator, and
is intended to be run after any non-trivial maintenance has
been performed on the &lt;c&gt;Point&lt;/c&gt; class.
&lt;/para&gt;
&lt;/summary&gt;
</pre>
*** <a name="param">&lt;param&gt;</a>
This tag is used to describe a parameter for a method, constructor, or
indexer.
**** Syntax
<code>&lt;param name="name"&gt;description&lt;/param&gt;</code>
<blockquote>
<em>name</em><br />
The name of the parameter.
</blockquote>
**** Example
<pre>
&lt;summary&gt;
This is the entry point of the &lt;c&gt;Point&lt;/c&gt;
class.
&lt;/summary&gt;
&lt;param name="xor"&gt;&lt;c&gt;xor&lt;/c&gt; is the new x-coordinate.&lt;/param&gt;
&lt;param name "yor"&gt;&lt;c&gt;yor&lt;/c&gt; is the new y-coordinate.&lt;/param&gt;
</pre>
*** <a name="paramref">&lt;paramref&gt;</a>
This tag is used to indicate that a word is a parameter. User agents
could use this information for special formatting or hyperlink insertion.
**** Syntax
<code>&lt;paramref name="name" /&gt;</code>
<blockquote>
<em>name</em><br />
The name of the parameter.
</blockquote>
**** Example
<pre>
&lt;summary&gt;
This constructor initializes the new Point to
(&lt;paramref name="xor" /&gt;,&lt;paramref name="yor" /&gt;).
&lt;/summary&gt;
&lt;param name="xor"&gt;&lt;c&gt;xor&lt;/c&gt; is the new x-coordinate.&lt;/param&gt;
&lt;param name "yor"&gt;&lt;c&gt;yor&lt;/c&gt; is the new y-coordinate.&lt;/param&gt;
</pre>
*** <a name="permission">&lt;permission&gt;</a>
This tag allows the security accessibility of a member to be documented.
**** Syntax
<code>&lt;permission cref="member"&gt;description&lt;/permission&gt;</code>
<blockquote>
<em>cref="member"</em><br />
The name of a member.</br>
</blockquote>
**** Example
<pre>
&lt;permission cref="System.Security.PermissionSet"&gt;
Everyone can access this method.
&lt;/permission&gt;
</pre>
*** <a name="property">&ltproperty&gt;</a>
This tag is the overall containing tag for documenting a property.
**** Syntax
<code>&lt;property name="propertyname"&gt;documentation&lt;/property&gt;</code>
<blockquote>
<em>name="propertyname"</em><br />
The name of the property.
</blockquote>
**** Example
<pre>
&lt;property name="X"&gt;
&lt;summary&gt;
Gets or sets the point's x-coordinate.
&lt;value&gt;
The point's x-coordinate.
&lt;/value&gt;
&lt;/property&gt;
</pre>
*** <a name="remarks">&lt;remarks&gt;</a>
This tag contains extended discussion and information about a member or
a type. <em>[jbarn: This differs from both the ECMA docs and
portions of Microsoft's documentation, but seems consistent with both
common usage, and, more importantly, NDoc convention.]</em>
**** Syntax
<code>&lt;remarks&gt;description&lt;/remarks&gt;</code>
**** Example
<pre>
&lt;type name="Graphics.Point"&gt;
&lt;summary&gt;
Models a point in a two-dimensional plane.
&lt;/summary&gt;
&lt;remarks&gt;
Herein I might have an extended discussion of
the validity of Cartesian coordinate systems,
with examples pro and con, and perhaps
some code.
&lt;/remarks&gt;
&lt;!-- ... --&gt;
&lt;/type&gt;
</pre>
*** <a name="returns">&lt;returns&gt;</a>
This tag is used to describe the return value of a method.
**** Syntax
<code>&lt;returns&gt;description&lt;/returns&gt;</code>
**** Example
<pre>
&lt;method name="op_Inequality(Graphics.Point,Graphics.Point)"&gt;
&lt;summary&gt;
This operator determines whether two points have the
same location.
&lt;/summary&gt;
&lt;param name="p1"&gt;&lt;c&gt;p1&lt;/c&gt; is the first Point to be compared.&lt;/param&gt;
&lt;param name="p2"&gt;&lt;c&gt;p2&lt;/c&gt; is the second Point to be compared.&lt;/param&gt;
&lt;returns&gt;
True if the points do not have the same location and they
have the exact same type; otherwise, false.
&lt;/returns&gt;
&lt;/method&gt;
</pre>
*** <a name="see">&lt;see&gt;</a>
This tag allows a link to be specified within documentation text. (Use
<code>&lt;seealso&gt;</code> to indicate links that should appear in a 'See Also' section.)
**** Syntax
<code>&lt;see cref="destination" /&gt;</code>
<blockquote>
<em>cref="destination"</em><br />
A destination, such as a type or a member of a type.
</blockquote>
**** Example
<pre>
&lt;summary&gt;
This method changes the point's location to the given
coordinates. This is an asinine way to insert a link,
but &lt;see cref="Equals(Object)" /&gt; to understand
how points are compared.
&lt;/summary&gt;
</pre>
*** <a name="seealso">&lt;seealso&gt;</a>
This tag allows an entry to be generated for the 'See Also' section. (Use
<code>&lt;see&gt;</code> to specify a link from within text.)
**** Syntax
<code>&lt;seealso cref="destination" /&gt;</code>
<blockquote>
<em>cref="destination"</em><br />
A destination, such as a type or a member of a type.
</blockquote>
**** Example
<pre>
&lt;summary&gt;
This method determines whether two Points have the
same location.
&lt;/summary&gt;
&lt;seealso cref="op_Equality(Graphics.Point,Graphics.Point)" /&gt;
&lt;seealso cref="op_Inequality(Graphics.Point,Graphics.Point" /&gt;
</pre>
*** <a name="summary">&lt;summary&gt;</a>
This tag contains a short summary of a member or type,
often one sentence. <em>[jbarn: This differs from both the ECMA docs and
portions of Microsoft's documentation, but seems consistent with both
common usage, and, more importantly, NDoc convention.]</em>
**** Syntax
<code>&lt;summary&gt;description&lt;/summary&gt;</code>
**** Example
<pre>
&lt;summary&gt;
This is the entry point of the &lt;c&gt;Point&lt;/c&gt; class testing
program.
&lt;/summary&gt;
&lt;remarks&gt;
This program tests each method an operator, and is intended
to be run after any non-trivial maintenance is performed
on the &lt;c&gt;Point&lt;/c&gt; class.
&lt;/remarks&gt;
</pre>
*** <a name="type">&lt;type&gt;</a>
This tag is the overall containing tag for documenting a type.
**** Syntax
<code>&lttype name="typename" assembly="assemblyname"&gt;documentation&lt;/type&gt;</code>
<blockquote>
<em>name="typename"</em><br />
The name of the type being documented.
<br /><br />
<em>assembly="assemblyname"</em><br />
The assembly this type resides in. This attribute is not required for nested types.
</blockquote>
**** Example
<pre>
&lt;type name="Graphics.Point" assembly="Point"&gt;
&lt;summary&gt;
Models a point in two-dimensional space.
&lt;/summary&gt;
&lt;!-- members --&gt;
&lt;field name="x"&gt;
&lt;summary&gt;
Represents the point's x-coordinate.
&lt;/summary&gt;
&lt;/field&gt;
&lt;/type&gt;
</pre>
** <a name="appendix-a">Appendix A: Complete Example</a>
<em>[jbarn: Please, please, don't take the human-readable portions of
this example to be good guidelines for writing your own documentation.
this XML is intended only to show structure.]</em>
<pre>
&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;doc lang="en"&gt;
&lt;type name="Graphics.Point" assembly="Point"&gt;
&lt;summary&gt;
Models a point in a two-dimensional plane.
&lt;/summary&gt;
&lt;remarks&gt;
No useful remarks.
&lt;/remarks&gt;
&lt;!-- fields --&gt;
&lt;field name="x"&gt;
&lt;summary&gt;
Instance variable &lt;c&gt;x&lt;/c&gt; represents the point's x-coordinate.
&lt;/summary&gt;
&lt;/field&gt;
&lt;field name="y"&gt;
&lt;summary&gt;
Instance variable &lt;c&gt;y&lt;/c&gt; represents the point's y-coordinate.
&lt;/summary&gt;
&lt;/field&gt;
&lt;!-- methods --&gt;
&lt;method name="#ctor"&gt;
&lt;summary&gt;
Initializes the new point to &lt;c&gt;(0,0)&lt;/c&gt;.
&lt;/summary&gt;
&lt;/method&gt;
&lt;method name="#ctor(System.Int32,System.Int32)"&gt;
&lt;summary&gt;
Initializes the new Point to (&lt;paramref name="xor" /&gt;,&lt;paramref name="yor" /&gt;).
&lt;/summary&gt;
&lt;param name="xor"&gt;&lt;c&gt;xor&lt;/c&gt; is the new x-coordinate.&lt;/param&gt;
&lt;param name="yor"&gt;&lt;c&gt;yor&lt;/c&gt; is the new y-coordinate.&lt;/param&gt;
&lt;/method&gt;
&lt;method name="Move(System.Int32,System.Int32)"&gt;
&lt;summary&gt;
This method changes the point's location to the given coordinates.
&lt;/summary&gt;
&lt;param name="xor"&gt;&lt;c&gt;xor&lt;/c&gt; is the new x-coordinate.&lt;/param&gt;
&lt;param name="yor"&gt;&lt;c&gt;yor&lt;/c&gt; is the new y-coordinate.&lt;/param&gt;
&lt;seealso cref="Translate(System.Int32,System.Int32)" /&gt;
&lt;/method&gt;
&lt;method name="Translate(System.Int32,System.Int32)"&gt;
&lt;summary&gt;This method changes the point's location by the given x- and y-offsets.&lt;/summary&gt;
&lt;remarks&gt;
&lt;example lang="C#"&gt;
A C# example:
&lt;code&gt;
Point p = new Point(3, 5);
p.Translate(-1, 3);
&lt;/code&gt;
This code results in &lt;c&gt;p&lt;/c&gt; having the value (2,8).
&lt;/example&gt;
&lt;/remarks&gt;
&lt;param name="xor"&gt;&lt;c&gt;xor&lt;/c&gt; is the relative x-offset.&lt;/param&gt;
&lt;param name="yor"&gt;&lt;c&gt;yor&lt;/c&gt; is the relative y-offset.&lt;/param&gt;
&lt;seealso cref="Move(System.Int32,System.Int32)" /&gt;
&lt;/method&gt;
&lt;method name="Equals(System.Object)"&gt;
&lt;summary&gt;This method determines whether two points have the same location.&lt;/summary&gt;
&lt;param name="o"&gt;&lt;c&gt;o&lt;/c&gt; is the object to be compared to the current object.&lt;/param&gt;
&lt;returns&gt;True if the Points have the same location and they have the exact same
type; otherwise, false.&lt;/returns&gt;
&lt;seealso cref="op_Equality(Graphics.Point,Graphics.Point)" /&gt;
&lt;seealso cref="op_Inequality(Graphics.Point,Graphics.Point" /&gt;
&lt;/method&gt;
&lt;method name="ToString"&gt;
&lt;summary&gt;Report a point's location as a string.&lt;/summary&gt;
&lt;returns&gt;A string representing a point's location, in the form (x,y), without any
leading, trailing, or embedded whitespace.&lt;/returns&gt;
&lt;/method&gt;
&lt;method name="op_Equality(Graphics.Point,Graphics.Point)"&gt;
&lt;summary&gt;This operator determines whether two points have the same location.&lt;/summary&gt;
&lt;param name="p1"&gt;&lt;c&gt;p1&lt;/c&gt; is the first Point to be compared.&lt;/param&gt;
&lt;param name="p2"&gt;&lt;c&gt;p2&lt;/c&gt; is the second Point to be compared.&lt;/param&gt;
&lt;returns&gt;True if the points have the same location and they have the exact same
type; otherwise, false.&lt;/returns&gt;
&lt;seealso cref="Equals(System.Object)" /&gt;
&lt;seealso cref="op_Inequality(Graphics.Point,Graphics.Point)" /&gt;
&lt;/method&gt;
&lt;method name="op_Inequality(Graphics.Point,Graphics.Point)"&gt;
&lt;summary&gt;This operator determines whether two points have the same location.&lt;/summary&gt;
&lt;param name="p1"&gt;&lt;c&gt;p1&lt;/c&gt; is the first Point to be compared.&lt;/param&gt;
&lt;param name="p2"&gt;&lt;c&gt;p2&lt;/c&gt; is the second Point to be compared.&lt;/param&gt;
&lt;returns&gt;True if the points do not have the same location and they have the exact same
type; otherwise, false.&lt;/returns&gt;
&lt;seealso cref="Equals(System.Object)" /&gt;
&lt;seealso cref="op_Equality(Graphics.Point,Graphics.Point)" /&gt;
&lt;/method&gt;
&lt;method name="Main"&gt;
&lt;summary&gt;
This is the entry point of the Point class testing program.
&lt;/summary&gt;
&lt;remarks&gt;
&lt;para&gt;This program tests each method and operator, and is intended to be run after
any non-trivial maintenance has been performed on the Point class.&lt;/para&gt;
&lt;/remarks&gt;
&lt;/method&gt;
&lt;!-- properties --&gt;
&lt;property name="X"&gt;
&lt;value&gt;Property &lt;c&gt;X&lt;/c&gt; represents the point's x-coordinate.&lt;/value&gt;
&lt;/property&gt;
&lt;property name="Y"&gt;
&lt;value&gt;Property &lt;c&gt;y&lt;/c&gt; represents the point's y-coordinate.&lt;/value&gt;
&lt;/property&gt;
&lt;/type&gt;
&lt;/doc&gt;
</pre>
+96
View File
@@ -0,0 +1,96 @@
* JIT Compiler
<a
href="http://citeseer.nj.nec.com/vitek97efficient.html">
Efficient Type Inclusion Tests: Jahn Vitek, R. Nigel Horspool, Andres
Krall</a>
<a
href="http://citeseer.nj.nec.com/cytron91efficiently.html">
Efficiently Computing Static Single Assignment Form and the Control
Dependence Graph: Ron Cytron, Jeanne Ferrante</a>
<a
href="http://citeseer.nj.nec.com/193349.html">
Practical Improvements to the Construction and Destruction of Static Single Assignment Form: Preston Briggs,
Keith Cooper, Timothy Harvey, Taylor Simpson</a>
<a
href="http://citeseer.nj.nec.com/krall98efficient.html">
Efficient JavaVM Just-in-Time Compilation: Andreas Krall</a>
<a
href="http://citeseer.nj.nec.com/452617.html">Java for
Large-Scale Scientific Computations: Andreas Krall, Phillip Thomsich</a>
<a
href="http://citeseer.nj.nec.com/117522.html">
Engineering Simple, Efficient Code Generator Generator: Christopher
W. Fraser, David R. Hanson, Todd A. Proebsting</a>
<a
href="http://citeseer.nj.nec.com/proebsting92code.html">
Code Generation Techniques: Todd Alan Proebsting</a>
<a
href="http://citeseer.nj.nec.com/74629.html">Fast,
Effective Code Generation in a Just-In-Time Java Compiler: Ali-Reza
Adl-Tabatabai Guei-Yuan Lueh, Vishesh M. Parikh, James M. Stichnoth...</a>
<a
href="http://citeseer.nj.nec.com/bodik00abcd.html">
ABCD: Eliminating Array-Bounds Checks on Demand: Rastislav Bodik, Rajiv Gupta, Vivek Sarkar</a>
* Register Allocation
<a
href="http://citeseer.nj.nec.com/poletto99linear.html">
Linear Scan Register Allocation: Massimiliano Poletto, Vivek Sarkar</a>
<a
href="http://citeseer.nj.nec.com/traub98quality.html">
Quality and Speed in Linear-scan Register Allocation: Omri Traub, Glenn
Holloway, Michael D. Smith</a>
* Loop Transformations
<a
href="http://citeseer.nj.nec.com/bacon93compiler.html">
Compiler Transformations for High-Performance Computing: David Bacon</a>
* Interpreter
<a
href="http://citeseer.nj.nec.com/470069.html">
vmgen-A Generator of Efficient Virtual Machine Interpreters: M. Anton
Ertl, David Gregg, Andreas Krall, Bernd Paysan</a>
* Synchronization
<a
href="http://citeseer.nj.nec.com/krall98monitors.html">
Monitors and Exceptions - How to implement Java efficiently: Andreas Krall,
Mark Probst</a>
<a
href="http://citeseer.nj.nec.com/bacon98thin.html">
Thin Locks: Featherweight Synchronization for Java: David Bacon</a>
<a
href="http://citeseer.nj.nec.com/278639.html">
Featherweight Monitors with Bacon Bits: David Bacon</a>
* Garbage Collection
<a
href="http://citeseer.nj.nec.com/wilson92uniprocessor.html">
Uniprocessor Garbage Collection Techniques: Paul Wilson</a>
<a
href="http://citeseer.nj.nec.com/41666.html">
A Language-Independent Garbage Collector Toolkit: Richard Hudson, Eliot Moss, Amer Diwan, Christopher Weight</a>
<a
href="http://citeseer.nj.nec.com/seligmann95incremental.html">
Incremental Collection of Mature Objects: Richard Hudson, Eliot Moss</a>
+293
View File
@@ -0,0 +1,293 @@
* Updates
<b>Sep 20, 2001:</b> Microsoft has just announced some changes
to passport that are rather interesting. This document
reflects the Passport system without taking into account the
new changes.
Read about it <a href="http://www.microsoft.com/presspass/features/2001/sep01/09-20passport.asp">here</a>.
For an analysis of security problems with passport, check <a
href="http://avirubin.com/passport.html">http://avirubin.com/passport.html</a>.
The bottom line is that you should not put any sensitive
information on passport.
I have received many comments from people, and I have updated
the page accordingly. From removing incorrect statements, to
fixing typos, to include mentions to other software pieces.
I also corrected my statement about IIS and a trojan horse, I
should read a more educated press in the future. My apologies
to Microsoft and its employees on this particular topic. IIS
did not have a trojan horse built in.
* Microsoft Hailstorm and Passport
Microsoft Passport is a centralized database hosted by
Microsoft that enhances the consumer experience with the Web
by providing a single logon system that they can use across a
number of participant web sites.
As you might know by now from our extensive <a
href="faq.html">FAQ</a>, the Mono project has nothing to do
with Microsoft Hailstorm or <a
href="http://www.passport.com">Microsoft Passport.</a>
Still a lot of people have asked us our opinion on them.
** Passport
Passport is important not because of it being a breakthrough
technologically speaking, but because the company is in a
position to drive most people toward being suscribers of it.
At the time of this writing passport is required to use the
free mail service <a href="http://www.hotmail.com">Hotmail</a>
to get customized support for the <a
href="http://www.msn.com">MSN portal</a>, <a
href="http://msdn.microsoft.com">Microsoft Developers
Network</a> and according to the original announcement from
Microsoft <a href="http://www.americanexpress.com">American
Express</a> and <a href="http://www.ebay.com">EBay</a> will be
adopting it.
There is already a <a
href="http://www.passport.com/Directory/Default.asp?PPDir=C&lc=1033">Large
list</a> of participating sites.
There are many current users of it and Microsoft will be
driving more users towards Passport as it <a
href="http://news.cnet.com/news/0-1003-200-6343275.html">integrates
it</a> in their upcoming release of Windows.
Microsoft has also <a
href="http://www.passport.com/Business/JoinPassportNetwork.asp?lc=1033">developed
a toolkit</a> to enable current web merchants to integrate
their services with passport.
To the end user, there is a clear benefit: they only have to
log into a single network and not remember multiple passwords
across sites on the internet. Companies that adopt passport
will have a competition advantage over those that dont.
Microsoft lists a list of <a
href="http://www.passport.com/Business/Default.asp?lc=1033">benefits</a>
to companies.
** The problems of Passport
There are a number of concerns that different groups have over
Passport. Sometimes I have some, sometimes I do not. But
overall, consumers and businesses can have better solutions.
<ul>
* <b>Single Point of Failure:</b> As more services and
components depend on remote servers, functionality can
grind to a halt if there is a failure on the
centralized Passport system.
Such a failure was predicted, and we recently <a
href="http://news.cnet.com/news/0-1005-200-6473003.html">witnessed</a>
got a lot of people worried.
The outgage lasted for seven days. Think what this
could do to your business.
* <b>Trust:</b> Not everyone trusts Microsoft to keep
their information confidential. Concerns are not only
at the corporate level policy, but also the fact that
the source code for Microsoft products is not
available, means that trojans or worms could be built
into the products by malicious engineers.
* <b>Security:</b> With a centralized system like
Passport, imagine the repercussions of a malicious
hacker gaining access to the Passport database.
Personal information and credit card information about
almost everyone using a computer could be stored there.
Hackers have already <a
href="http://slashdot.org/articles/00/10/27/1147248.shtml">broken
into Microsoft</a> in the past. And the company was
unable to figure out for how long their systems had
been hacked.
Security holes have been found in <a
href="http://slashdot.org/articles/00/04/14/0619206.shtml">IIS
in the past.</a> If all the world's data is stored on
a central location, when a single security hole is
detected, it would allow an intruder to install a
backdoor within seconds into the corporate network
without people ever noticing.
Microsoft itself has been recently hit by worms,
imagine if all your business depended on a single
provider for providing all or your authentication
needs
</ul>
Microsoft might or might not realize this. The idea behind
Passport is indeed a good one (I can start to get rid of my
file that keeps track of the 30 logins and passwords or so
that I use across the various services on the net myself).
** Alternatives to Microsoft Passport
An alternative to Microsoft Passport needs to take the above
problems into consideration. Any solution of the form `We
will just have a competing offering' will not work.
The system thus has to be:
<ul>
* <b>Distributed:</b> The entire authentication
system should not create an internet `blackout' in the
case of failure.
A distributed system using different software
platforms and different vendors would be more
resistent to an attack, as holes in a particular
implementation of the server software would not affect
every person at the same time.
A security hole attack might not even be relevant to
other software vendors software.
* <b>Allow for multiple registrars:</b> Users should
be able to choose a registrar (their banks, local
phone company, service provider, Swiss bank, or any
other entity they trust.
* <b>Mandate good security measures:</b> As a
principle, only Open Source software should be used
for servers in the registrar, and they should conform
to a standard set of tools and software that can be
examined by third parties.
</ul>
An implementation of this protocol could use the DNS or a
DNS-like setup to distribute the information of users with the
possibility of replicating and caching public information
about the user.
For instant messaging (another piece of the Hailstorm bit),
you want to use a non-centralized system like Sun's <a
href="http://www.jxta.org">JXTA</a>. Some people mailed me to
mention Jabber as a messaging platform and other people
pointed out to the <a
href="http://java.sun.com/products/jms/">Java Message
Service</a>. The JMS does support a number of very
interesting features that are worth researching.
It could also just use the user e-mail address as the `key' to
choose the registrar (msn.com, hotmail.com -> passport.com;
aol.com -> aol.passport.com; you get the idea).
The <a
href="http://www.soapware.org/xmlStorageSystem">xmlStorage</a>
idea from <a href="http://www.scripting.com">Dave Winer</a>
could be used to store the information.
A toolkit for various popular web servers could be provided,
authenticated and should be open sourced (for those of you who
think that a binary program would give more security and would
prevent people from tampering: you are wrong. You can always
use a proxy system that "behaves" like the binary, and passes
information back and forth from the real program, and snoops
in-transit information).
Good cryptographers need to be involved in this problem to
figure out the details and the possible insecure pieces of a
proposal like this.
** Implementation: In short
To keep it short: <b>DNS, JXTA, xmlStorage.</b>
** Deploying it
The implementation of such a system should be a pretty
straightforward task once security cryptographers have
designed such a beast.
The major problems are:
<ul>
* <b>People might just not care:</b> In a poll to US
citizens a couple of decades ago, it was found that
most people did not care about the rights they were
given by the Bill of Rights, which lead to a number of
laws to be passed in the US that eliminated most of
the rights people had.
* <b>The industry will move way too slow:</b>
Microsoft's implementation is out in the open now: it
is being deployed, and soon it will be insinuated to
many, many users. The industry needs to get together
soon if they care about this issue.
By the time the industry reacts, it might be too
late.
</ul>
** Passport and Mono
The .NET class libraries include a Passport class that
applications might use to authenticate with Passport. Since
we do not have information at this point on the exact protocol
of Passport, it is not even feasible to implement it.
If at some point the information is disclosed, it could be
implemented.
If a competing system to Passport existed, we could probably
hide all the authentication information to use a number of
different passport-like systems.
If a user does not want to use Passport at all, he could
always turn it off (or completely remove the class from the
library). After all, this is free software.
Currently, we are too far from the point where this is a real
issue.
** Passport and endangering Open Source.
A few people have said: `Mono will allow Passport to be
available for Linux and that is bad'. This is plain
misinformation.
Currently, you can obtain Passport for Linux from Microsoft
itself and deploy it today on your Web server. Mono does not
even enter the picture here. Go to passport.com and download
the toolkit and you will see with your own eyes that passport
is <B>already</b> available for Linux.
** Disclaimer
This is just a group of personal thoughts of mine that I have
placed here because I get asked this question a lot lately.
The views of this page are not a statement from my employer
(Ximian, Inc).
This is not part of Mono. We are not trying to deal with this
problem.
Nat Friedman (Ximian's co-founder) has his own ideas on how a
competing system to Passport could be designed, but I will let
<a href="http://www.nat.org/">him</a> post his own story.
** Other Passport Comments
An interesting study on the security of passport is available at: <a
href="http://avirubin.com/passport.html">http://avirubin.com/passport.html</a>
** Other Alternatives
Some people have pointed out <a
href="http://www.xns.org">XNS</a>
Send comments to me: Miguel de Icaza (<a
href="mailto:[email protected]">[email protected]</a>)
+14
View File
@@ -0,0 +1,14 @@
** Microsoft and GNU and Linux.
Q: Does this mean that Microsoft is better than Linux?
A: Many of us are working on <a
href="http://www.gnu.org/philosophy/free-sw.html">free software<a>
and want to have an <a href="http://www.opensource.org">open
source</a> environment that we can change, modify, improve, learn
from, and share with others. Some of us also think that this will
lead on the long run to better software: more efficient, faster,
more robust and more.
We are willing to take good ideas from any source they come from.
Executable
+15
View File
@@ -0,0 +1,15 @@
* Plans
Here we are tracking some plans to particular pieces of
technology that are part of Mono.
This is just a repository of information that is handy for
contributors.
Currently you can read our plans for <a
href="ado-net.html">ADO.NET</a>, <a
href="asp-net">ASP.NET</a>, <a href="java.html">Java</a> and
<a href="winforms.html">WinForms</a>.
+63
View File
@@ -0,0 +1,63 @@
* How to port Mono to your preferred architecture
** Endian, 64 bits and unaligned access issues
The first thing to do is to check that the metadata handling
library works on your target processor. You may use the disassembler
on simple programs and check that you get sensible results
(assuming it compiles at all on your system:-).
The main issue is to write macros that read unaligned
little endian shorts/ints/longs/float/doubles: look into
mono/metadata/endian.h. There may be other spots in the code that are
unsafe at reading/writing to some datatypes that require special
alignment, but there should be few such issues and they need to be fixed.
Once this stuff is sorted out, you should be able to run the interpreter
on simple programs that don't require delegates, P/Invoke functions etc..
** Generating assembly bytecodes for the target processor
Next, you need to provide the support code for generating assembly bytecode
for your target platform (in mono/arch/{ppc,sparc,alpha,*}).
The code should be more or less like the code in x86-codegen.h:
macros that produce fast in-line code. You don't need to provide
code to create every possible code, at first, just the code to
create trampolines and execute them is fine (you'll need to research
how the call convention works on your platform): that would be, for
example, the prolog and epilog code in a function, code to pass function
parameters and deal with the return value and so on.
libffi in gcc or the xptcall sources in mozilla may be helpful to
understand how the calling convention works, if you can't find a specification.
You'd need a processor manual to know how to create the assembly binary data.
This requires a lot of reading if you're not familiar with the assembly for your
target platform. Manuals for many processors are available as PDF files on the
web site of the respective vendors. Note that some processors require you to
flush the I-cache before executing the code: have a look at how the same thing is
done in GNU lightning.
** Getting the interpreter to work
Once you can generate binary code, you can start working on a
mono_create_trampoline() function for your platform: this function will receive
a MonoMethod that describes the arguments and the return type of a C function
and will create the code to call such function. When this function is complete
you'll be able to run more sample programs, that use System.IO, P/Invoke
functions etc.
To support delegates you'll need to write a mono_create_method_pointer()
function that creates a native function: this can be used to call the
method using the runtime's calling convention (it's basically the reverse
of mono_create_trampoline()).
** The final step: porting the JIT
At this point you'd need to have a more complete code generation header file
and you can start writing the machine description file for the monoburg
system. This code (jit/tesjit.c) will require some machine specific tweaks,
but hopefully all you have to do is create the grammar that emit assembly
code from the IR tree. Work is at the early stages also for x86 on this stuff
as we are still testing various solutions: you'd want to read about burg-like
code-generator generators (the LCC book is a good starting point).
+33
View File
@@ -0,0 +1,33 @@
* Mono PowerPC Port
** Status
It passes and compiles the same amount of mono tests as on the x86 architecture.
mcs is self hosting on Linux/PPC.
*** Interpreter
Up to date.
*** Jitter
Start the port
** Documentation
*** PowerPC architecture:
<A HREF="http://e-www.motorola.com/brdata/PDFDB/docs/MPCFPE32B.pdf">PowerPC Programming environments manual</A><BR>
<A HREF="http://e-www.motorola.com/brdata/PDFDB/docs/MPC7410UM.pdf">G4 (7410) User's manual</A>
There's a very nice introduction to PowerPC assembly language
at <a
href="http://www-106.ibm.com/developerworks/library/l-ppc/">http://www-106.ibm.com/developerworks/library/l-ppc/</a>.
*** Calling conventions:
<a href="http://www.esofta.com/softspecs.html">The PowerPC SystemV ABI specification</a>
Executable
+24
View File
@@ -0,0 +1,24 @@
* Open Projects
The .NET framework is a good first in terms of a new
development foundation, but it falls short of providing
higher-level components or building blocks for people to
reuse.
A few ideas of projects and classes that would be useful to
develop applications follows:
** EOG component
** XmlStorageSystem component
* Gtk# related projects
Gnome Canvas Bindings.
Bezier Canvas Item Binding.
* Graphical bindings
Binding for the Libart library
+173
View File
@@ -0,0 +1,173 @@
* The Mono Project
** Background.
The GNOME project goal was to bring missing technologies to
Unix and make it competitive in the current market place for
desktop applications. We also realized early on that language
independence was important, and that is why GNOME APIs were
coded using a standard that allowed the APIs to be easily
wrapped for other languages. Our APIs are available to most
programming languages on Unix (Perl, Python, Scheme, C++,
Objective-C, Ada).
Later on we decided to use better methods for encapsulating
our APIs, and we started to use CORBA to define interfaces to
components. We complemented it with policy and a set of
standard GNOME interfaces for easily creating reusable,
language independent components, controls and compound
documents. This technology is known as <a
href="http://developer.ximian.com/tech/bonobo.html">Bonobo</a>.
Interfaces to Bonobo exist for C, Perl, Python, and
Java.
CORBA is good when you define coarse interfaces, and most
Bonobo interfaces are coarse. The only problem is that
Bonobo/CORBA interfaces are not good for small interfaces.
For example, an XML parsing Bonobo/CORBA component would be
inefficient compared to a C API.
** Another explanation
I recently explained our motivations to Dave Winer, and he posted
it <a
href="http://scriptingnews.userland.com/stories/storyReader$1275">here</a>
** Microsoft's .NET
The Microsoft .NET initiative is confusing because it is a
company wide effort that ranges from development tools to end
user applications. .NET is a branding formative that
has been applied to:
<ul>
* The .NET development platform, a new platform for
writing software.
* Web services.
* Microsoft Server Applications.
* New tools that use the new development platform.
* Hailstorm, the Passport centralized single-signon
system that is being integrated into Windows XP.
</ul>
Mono is an implementation of the .NET development platform.
** The Common Language Infrastructure platform.
Microsoft has created a new development platform. The
highlights of this new development platform are:
<ul>
* A runtime environment that provides garbage
collection, threading and a virtual machine
specification (The Virtual Execution System, VES)
* A comprehensive class library.
* A new language, C#. Very similar to Java, C#
allows programmers to use all the features available
on the .NET runtime.
* A language specification that compilers can
follow if they want to generate classes and code
that can interoperate with other programming
languages (The Common Language Specification: CLS)
</ul>
The Common Language Infrastructure platform is similar to the
goals we had in GNOME of giving language independence to
programmers. It is more mature, documented, larger in scope,
and has a consistent design.
Any API that is written using a CLS provider language can be
used by any language that is a CLS consumer. Compilers
generate code in a format called Common Intermediate Language
(CIL) which is an intermediate representation of a compiled
program and is easy to compile to native code or compiled
using Just-in-Time (JIT) engines. The restrictions placed by
the runtime on the CIL byte codes ensures that it is possible
to do a good job at optimizing the code in a JIT compiler.
There is not really a lot of innovation in this platform: we
have seen all of these concepts before, and we are all
familiar with how these things work.
What makes the Common Language Infrastructure development
platform interesting is that it is a good mix of technologies
that have been nicely integrated.
The .NET development platform is essentially a new foundation
for program development that gives Microsoft a room to grow
for the coming years.
** ECMA standards.
Microsoft has submitted the
specifications of C#, the runtime, the metadata and the
other various bits of the .NET development platform to the
<a href="http://www.ecma.ch">ECMA</a> for standarization.
You can get a copy of the specifications submitted to ECMA
from: <a href="http://www.dotnetexperts.com/ecma">http://www.dotnetexperts.com/ecma</a>
** Mono: an Open Source Common Language Infrastructure implementation.
Ximian has begun work on Mono, a project that aims to bring
the Common Language Infrastructure platform to free systems.
When the GNU project was launched, they picked the best
operating system that was available out there, and they
began to clone it: Unix.
The .NET development platform is a very rich, powerful, and
well designed platform that would help improve the free
software development platform. Just like the GNU project
began to clone Unix sixteen years ago, we will be cloning the
.NET development platform because it is a great platform to
build on.
** What makes up Mono?
There are various pieces that will make up Mono:
<ul>
* A C# compiler.
* The Virtual Execution System: that will have the
Just-in-Time compiler, garbage collector, loader,
threading engine.
A byte code interpreter will be provided for quickly
porting Mono to new systems and debugging the JIT
purposes, but it is not intended to be the ideal
execution environment.
* An implemenation of the .NET class library.
* Visual development tools.
* A CIL GCC frontend.
</ul>
** Why use GNOME components?
GNOME is an umbrella project that consists of infrastructural
components (GUI toolkit, XML libraries, CORBA implementation,
printing architecture, imaging system), a desktop environment,
and productivity applications.
The GNOME infrastructural components can be used to quickly
implement various pieces of the class libraries without reinventing
the wheel, and since all those components are licensed under
the terms of the GNU LGPL it is a perfect fit.
Libart will be used to implement the Drawing.2D API; Gtk+ and
the GNOME libraries will be used to implement the WinForms
API and of course Glib and libxml will be used in various
places.
+46
View File
@@ -0,0 +1,46 @@
To: [email protected], [email protected]
Subject: July 12 snapshots.
FCC: ~/Mail/outbox.txt
X-Windows: Sometimes you fill a vacuum and it still sucks.
--text follows this line--
Hey!
July 12 snapshots of class libraries, the compiler and the mono
runtime are available.
New on this release:
* Runtime (module: mono)
The beginning of a simple interpreter that Paolo started
workign on (can run really simple .NET programs).
Disassembler copes with more elements of the binary format and
more tokens are decoded. Paolo is working now on moving some
of these to the metadata library.
More tables are dumped.
* Class libraries (module: mcs/class)
Many new more classes are in from Joe, Vladimir, Jeff, Sean
and yours truly.
Sean fixed the build process, and it is now possible to
compile with a single command the assemblies. We will be
revisiting this mechanism in the future to compile per-OS
assemblies (ie, Unix, Windows, MacOS, etc).
* Compiler (module mcs/mcs)
Not much done this week, just a few fixes here and there, and
more work to make it easy to compiler.
* Documentation (module: mono/doc)
All the changes to the web site are there for your browsing
pleasure. We still need to integrate the status system in
there.
Miguel.
+43
View File
@@ -0,0 +1,43 @@
To: [email protected]
Subject: Sunday snapshot available.
Gcc: mail.2001-07
--text follows this line--
Hey guys,
I promise I will not be doing these so often once we have the CVS
server up. In the meantime:
* MCS
Sean got the classes to compile in a single go. You
will need CygWin (www.cygwin.org) to compile though
(GNU make and stuff is required).
System.Xml.XmlReader contribution from Jason
(WOOHHOO!!). It also contains a nice test-suite for
his functions, and in his new code bit, his
implementation is faster than Microsoft's
We now ship `jay' as part of the distribution to allow
you to compile the compiler with the same `make'
command. Small fixes to the parser as well were
introduced.
* Mono 0.4
Paolo's interpreter supports call instructions and has
the test suite program that he posted about.
All documentation ships now in the mono-0.4.tar.gz
Notes:
As usual, MCS is targeted to be compiled on a Windows machine
(you will need Cygwin).
Mono is targeted to be compiled on a Unix machine or a Windows
machine running Cygwin.
Miguel.
+195
View File
@@ -0,0 +1,195 @@
* Resources
There are a number of resources available for those of you who
want to contribute to the Mono project. Here are a few links.
If you want to send suggestions for links, address them to <a
mailto="[email protected]">[email protected]</a>.
** Microsoft .NET
The <a href="http://msdn.microsoft.com/net">Microsoft.NET site.</a>
The Microsoft .NET Framework 1.0 can be downloaded <a href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml&frame=true">here</a>
New methods that are not documented in 1.0, are documented <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/html/framewrkaddend.asp">here</a>
** IRC
Various Mono contributors get together on channel #mono on
irc.gnome.org
** Mono related sites.
Sergey's web page on Mono resources:
<a href="http://mono.eurosoft.od.ua">http://mono.eurosoft.od.ua</a>
Got Dot Net:
<a href="http://www.gotdotnet.com">Got Dot Net</a>
MonoMail:
<a href="http://sourceforge.net/projects/monomail/">http://sourceforge.net/projects/monomail/</a>
Zip classes:
Mike's port to .NET: <a
href="http://www.icsharpcode.net/OpenSource/NZipLib/default.asp">NZipLib</a>
.NET Security:
A nice overview paper on the <a
href="http://www.foundstone.com/pdf/dotnet-security-framework.pdf">.NET
security architecture</a>.
** Presentations
Currently the <a href="Presentations/O-Reilly">O'Reilly</a>
presentation on Mono is available. Arturo Espinosa has given
a talk on Mono in Mexico and made <a
href="http://construct.ximian.com/~arturo/Presentations/Mono.OLS/html">spanish
slides</a>
** ECMA Documentation.
You can get the documentation for the ECMA specs from:
<ul>
* <a href="http://www.ecma.ch/ecma1/STAND/ecma-334.htm">C# Language Specification</a>
* <a href="http://www.ecma.ch/ecma1/STAND/ecma-335.htm">Common Language Infrastructure</a>
</ul>
Older copies of the standard are available here:
<ul>
* <a href="http://msdn.microsoft.com/net/ecma">At MSDN</a>
* <a href="http://www.dotnetexperts.com">Dot Net Experts</a>
* <a href="http://developer.intel.com/software/idap/ecma">Intel</a>
* <a href="http://lightning.csse.monash.edu.au/.net/CLI">Monash University</a>
</ul>
These contain specifications for the assembler, the metadata,
byte codes supported by the CLI virtual machine, the C#
language and the core class libraries.
For details on the .NET class libraries, you can
visit the Microsoft's Developer Network:
<ul>
* <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/cpref_start.asp">.NET Framework Class Library</a>
</ul>
You can also get this information if you install the Beta2
release of the .NET Framework.
** Discussion Groups.
<ul>
* <a href="http://www.oreillynet.com">O'Reilly
Network</a> has a <a
href="http://www.oreillynet.com/dotnet">section devoted to
.NET</a>
* <a
href="http://msdn.microsoft.com/newsgroups">MSDN</a> also
lists various newsgroups related to .NET</ul>
</ul>
** Other .NET related projects
There are a number of related projects to Mono:
<ul>
* <a
href="http://qtcsharp.sourceforge.net">Qt#:</a>
C# bindings for the Qt toolkit.
* <a
href="http://www.icsharpcode.net/OpenSource/SD/default.asp">Sharp
Develop:</a> an IDE for the C# language written in C#.
* <a
href="http://www.improve-technologies.com/alpha/esharp/">Eclipse
Plugin for C#</a>
* <a
href="http://janet-js.sourceforge.net/">Janet:</a>
an implemention of ECMAScript (the standarized
version of JavaScript) in C#
* <a
href="http://xmarks.sourceforge.net/doc.html">XMarks DOC.NET:</a> For
creating online documentation you can browse for your own classes.
* <a href="http://nunit.sourceforge.net">NUnit:</a> A
testing framework for .NET classes.
* <a href="http://www.kaffe.org">Kaffe:</a> A popular
Free Software JIT engine for Java.
* <a href="http://www.intel.com/research/mrl/orp">ORP:</a> A research
JIT/VM/GC system from Intel.
* C# bindings for OpenGL and SDL are available here: <a
href="http://csgl.sourceforge.net">http://csgl.sourceforge.net</a>
* <a
href="http://www.southern-storm.com.au/portable_net.html">Portable.NET:</a>
Another implementation of the CLI and C# compiler.
* A Free (GFDL) tutorial on C# in Spanish with examples, slides, and extras (under development). Get it <a href="http://geneura.ugr.es/~jaime/csharp/">here</a>.
</ul>
** GNOME Documentation
Documentation on GNOME, and the GNOME APIs is available from
the <a href="http://developer.gnome.org">developer</a> site at
GNOME:
<ul>
* <a href="http://developer.gnome.org/doc/API/">GNOME
API documentation</a>
* <a href="http://developer.gnome.org/doc/books">GNOME
Online books</a>
* <A
href="http://developer.gnome.org/arch/">Architecture Overview</a>
</ul>
** Assembly Language Manuals online
<ul>
* <a href="http://www.agner.org/assem/#optimize">
Pentium optimization tutorial</a> by Agner Fog
* <a href="http://webster.cs.ucr.edu/">
Art of Assembly</a> (x86 only)
* Documentation for various CPUs
(<a href="http://www.mit.edu/afs/sipb/contrib/doc/specs/ic/cpu/">
x86, IA64, MIPS, ARM, Alpha</a>)
* <a href="http://www.heyrick.co.uk/assembler/">
ARM Assembler</a> tutorial
* PowerPC
<a href="http://www-3.ibm.com/chips/techlib/techlib.nsf/techdocs/852569B20050FF7785256996007558C6">
Compiler Writer's Guide</a>
* <a href="http://www.lightsoft.co.uk/Fantasm/Beginners/begin1.html">
Beginners Guide to PowerPC Assembler</a>
</ul>
** Win32
<ul>
* Win32 <a href="http://www.jorgon.freeserve.co.uk/ExceptFrame.htm">
Structured Exception Handling (SEH)</a> internals (x86 specific)
</ul>
+30
View File
@@ -0,0 +1,30 @@
** MacOS Documentation
** Assembly Language Manuals online
Intel
MIPS
SPARC
** Microsoft
msdn.microsoft.com/net
Research.microsoft.com
** Related Technologies
<ul>
* The CLI allows people to create Web Services using the SOAP
protocol. SOAP is based on XML, XML schemas an the HTTP
protocol.
<ul>
* XML specification.
* XML Namespaces.
* XML Schemas.
* SOAP Specification.
</ul>
</ul>
** Compiler Information
GCC
GCC Sample front-end tutorial
+12
View File
@@ -0,0 +1,12 @@
* Roadmap
We are working on the following three projects at Ximian:
The C# Compiler (mcs/mcs)
A .NET compatible Class Library (mcs/class)
The JIT/interpreter (mono)
+199
View File
@@ -0,0 +1,199 @@
* The Mono runtime
The Mono runtime implements a JIT engine for the CIL virtual
machine (as well as a byte code interpreter, this is to
quickly port it to new systems), the class loader, the garbage
collector, threading system and metadata access libraries.
We currently have two runtimes:
<ul>
* <b>mono:</b> The Just In Time compiler implemented
using a BURS instruction selector. We only support
x86 machines in the JIT engine at this point.
* <b>mint:</b> The Mono interpreter. This is an
easy-to-port runtime engine.
</ul>
Currently we are using the Bohem conservative garbage
collector, but we working on incorporating the ORP GC engine.
** Executing MSIL/CIL images
The code will load an executable and map the references to
external assemblies to our own version of the assemblies on
Linux.
Our roadmap looks like this, this has been updated as of
<b>Dec 18, 2001</b>:
<ul>
* Milestone 1: <b>Done</b> Fully read and parse all CIL byte-codes
and metadata tokens (ie, a disassembler).
* Milestone 2: <b>Done</b> Complete an interpreter for CIL byte
codes. This interpreter can be used temporarly to
run CIL byte code on a system where no JIT is
available.
* Milestone 3: <b>Done</b>Define an <i>lburg</i>-like
instruction selector for the JITer for Intel.
* Milestone 4: <b>Done</b> Implement JITer. This is where our
current efforts are focused on, the JITer currently runs
all of the code we have tested on it. The major limitation
is that our class libraries are not complete, and hence not
every application can be ran.
* Milestone 5: Port of the JITer to non IA32 systems.
</ul>
A setup similar to the Kaffe JIT engine will be used to
layout the code to support non-IA32 architectures. Our work
will be focused on getting a IA32 version running first.
The JIT engine works on Linux and Win32, although you
will need to install the CygWin32 development tools to get a
Unix-like compilation environment (mostly we use GNU make in
a few of the makefiles).
** JIT Engine (<b>updated, July 8th, 2002</b>)
The JIT engine uses a code-generator generator approach for
compilation. Given the properties of CIL byte codes, we can
take full advantage of a real instruction selector for our
code generator.
The JIT engine implements a number of optimizations:
<ul>
* Opcode cost estimates (our architecture allows
us to generate different code paths depending
on the target CPU dynamically).
* Inlining.
* Constant folding.
Although compilers typically do
constant folding, the combination of inlining with
constant folding gives some very good results.
* Linear scan register allocation. In the past,
register allocation was our achilles heel, but now
we have left this problem behind.
</ul>
There are a couple of books that deal with this technique: "A
Retargetable C Compiler" and "Advanced Compiler Design and
Implementation" are good references. You can also get a
technical description of <a
href="http://research.microsoft.com/copyright/accept.asp?path=http://www.research.microsoft.com/~drh/pubs/iburg.pdf&pub=ACM">lbrug</a>.
A few papers that describe the instruction selector:
<ul>
* <a href="http://research.microsoft.com/copyright/accept.asp?path=http://www.research.microsoft.com/~drh/pubs/interface.pdf&pub=wiley">A code generation interface for ANSI C</a>
* <a href="http://research.microsoft.com/copyright/accept.asp?path=http://www.research.microsoft.com/~drh/pubs/iburg.pdf&pub=ACM">Engineering efficient code generators using tree matching and dynamic programming.</a>
</ul>
** Future plans
We are evaluating the future directions for the JIT engine:
both from our needs (optimizations like inlining, better register allocation,
instruction scheduling, and porting to other CPUs).
We have not yet decided how we will evolve the JIT engine. We
might just upgrade our current architecture, and provide optimizations as
an extra layer.
** Garbage Collection
Currently we are using the Boehm conservative GC. Although our plans
are to move to the Intel ORP GC engine, our plans on a next generation
dual-JIT engine have to be taken into account.
We will be using the Intel ORP GC engine as it provides a precise
garbage collector engine, similar to what is available on the
.NET environment.
Although using a conservative garbage collector like Bohem's
would work, all the type information is available at runtime,
so we can actually implement a better collector than a
conservative collector.
<ul>
* Garbage collection list and FAQ:<br>
<a href="http://www.iecc.com/gclist/">http://www.iecc.com/gclist/</a>
* "GC points in a Threaded Environment":<br>
<a href="http://research.sun.com/techrep/1998/abstract-70.html">
http://research.sun.com/techrep/1998/abstract-70.html</a>
* "A Generational Mostly-concurrent Garbage Collector":
<a href="http://research.sun.com/techrep/2000/abstract-88.html">
http://research.sun.com/techrep/2000/abstract-88.html</a>
* Details on The Microsoft .NET Garbage Collection Implementation:<br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp</a>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI2.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI2.asp</a>
</ul>
** IO and threading
The ECMA runtime and the .NET runtime assume an IO model and a
threading model that is very similar to the Win32 API.
Dick Porter has been working on the Mono abstraction layer
that allows our runtime to execute code that depend on this
behaviour.
** Useful links
Paolo Molaro found a few interesting links:
<ul>
* On compilation of stack-based languages:<br>
<a href="http://www.complang.tuwien.ac.at/projects/rafts.html">
http://www.complang.tuwien.ac.at/projects/rafts.html</a>
* A paper on fast JIT compilation of a stack-based language:<br>
<a href="http://www.research.microsoft.com/~cwfraser/pldi99codegen.pdf">
http://www.research.microsoft.com/~cwfraser/pldi99codegen.pdf</a>
* Vmgen generates much of the code for efficient virtual machine (VM)
interpreters from simple descriptions of the VM instructions:<br>
<a href="http://www.complang.tuwien.ac.at/anton/vmgen/">
http://www.complang.tuwien.ac.at/anton/vmgen</a>
</ul>
** PInvoke
PInvoke is the mechanism we are using to wrap Unix API calls
as well as talking to system libraries.
Initially we used libffi, but it was fairly slow, so we have
reused parts of the JIT work to create efficient PInvoke trampolines.
** Remoting
Mono has support for remoting and proxy objects, just like
.NET does. The runtime provides these facilities.
** Porting
If you are interested in porting the Mono runtime to other
platforms, you might find the pre-compiled <a
href="archive/mono-tests.tar.gz">Mono regression test
suite</a> useful to debug your implementation.
* COM and XPCOM
We plan on adding support for XPCOM on Unix and COM on Microsoft
Windows later in our development process.
+40
View File
@@ -0,0 +1,40 @@
* Project Status
Pieces of Mono that have been implemented:
<ul>
* C# compiler: The C# compiler is mostly complete, a
few features are still missing (for a list, check the
<a href="c-sharp.html">C# compiler</a> web page.
* The Mono JIT engine (<b>mono</b>. The JIT engine is
the real
virtual machine that we support. It is
currently functional, and we are improving its speed,
and making it feature complete.
* A CIL bytecode interpreter (<b>mint</b>). This
currently can be used to run most .NET programs
(modulo the fact that our class libraries are not
complete enough).
<b>mint</b> can currently run the Mono C# compiler and
the compiler generates valid code.
We use <b>mint</b> as a reference implementation of
the runtime environment and to quickly support
non-Intel platforms.
* Metadata library: Can currently parse
and load information from .NET modules (executables
and DLL files).
* Disassembler: Can disassemble .NET modules. Still
lacking exception handling as well as useful debugging
tools (hex dumping, token dumping).
* Class Libraries: You can check the current status in the
<a href="class-status.html">Class Status page</a>.
</ul>
+2
View File
@@ -0,0 +1,2 @@
* The MonoNet Team
+46
View File
@@ -0,0 +1,46 @@
* Testing
Testing is an important part of the Mono project: every one of its
three major components has a test suite tailored for its needs. This
is very helpful, because in the course of developing the software it
is very common to introduce bugs in existing code. A test suite
helps us fix the bugs as soon as they are introduced.
** Class Library Tests
All classes in Mono libraries should have comprehensive unit test
suites to go with them. Unit testing is a software engineering
methodology that makes it easier to build correct code. Every
method in every class should have a set of tests to verify
that they work correctly. Mono also needs a testing framework
to make it easy to write and run lots of tests.
Try <a href="http://nunit.sourceforge.net">NUnit</a>
Why do unit testing? It becomes simple to run automated tests
for the whole library. Unit tests are a safety net - you can
change part of the code and verify that you haven't broken
anything. Ideally, tests are written before the actual library
code itself. And every time a bug is discovered, a test should
be written to demonstrate the bug and its fix. Then, if
you ever reintroduce the bug, you will know immediately. For
more info, read <a
href="http://junit.sourceforge.net/doc/testinfected/testing.htm">
JUnit Test Infected: Programmers Love Writing Tests</a>.
** Getting Started
We welcome all contributions to the Class Libary Test Suite.
There is information to help you get started in CVS at
mcs/class/doc/NUnitGuidelines. Once you have written your test, please
post it to <a href="mailing-lists.html">mono-list</a>.
Someone will make sure to add the file or apply the patch as
appropriate. If you plan to be an on-going contributor and
would like to get cvs account, email <a href="mailto:[email protected]">miguel</a>.
Normally, after you send a couple of well-written new files
and/or patches to the list, you will be given cvs access.
+6
View File
@@ -0,0 +1,6 @@
* Thanks
We would like to thank Tim O'Reilly, Brian Jepson and Nathan
Torkington for their help.
Dave Winer for provided interesting comments and a to read.
+1
View File
@@ -0,0 +1 @@
Discuss with write new JIT
+67
View File
@@ -0,0 +1,67 @@
* Tools
We need a number of tools to make people productive using a
Mono-based solution. Some of these tools can be developed on
Windows before Mono is fully finished.
All of these tools should be written using C#.
For the tools that are typically command line tools: Try to
write these as components that could load their input from
streams or collections of streams, and implement the command
line tools as wrappers around those classes.
For example, we will be making the C# compiler a component
that could be reused by applications that might have a use for
the various bits of the compiler (either to embed the
compiler, or reuse the code generator part of it).
This is important so that these components (compiler,
assembler, linker, etc) can be integrated later into the
visual development environment (hopefully with the help of the
SharpDevelop hackers).
TODO=ilasm,IL Assembler
** IL Assembler.
This assembler should basically take as input a file
containing IL bytecodes as specified in the `Partition II' of
the ECMA spec, and produce a binary file.
TODO=al,Assembly Linker
** Assembly Linker.
This tool is used to construct assemblies, which are basically
deployment units for CLI executables.
TODO=debugger,Debugger
** Debugger
We will need a debugging API to debug CLI applications and
then a debugger component that can be used in an IDE
environment.
TODO=ide,Integrated Development Environment
** Integrated Development Environment
There is already a project to create a C# development
environment: <a
href="http://www.icsharpcode.net/OpenSource/SD/default.asp">SharpDevelop</a>.
People should work with the SharpDevelop hackers to produce a
unified development environment.
Please work with the SharpDevelop hackers to build a good IDE.
We will work on creating an embedable compiler component and
an embeddable debugger component that can be used withing
SharpDevelop
TODO=hbrowser,Help Browser
** Help Browser
We need a good help browser that can be used to browse
documentation. Ideally this help browser can accept as input
XML Docbook input and an assorted set of file formats
(Microsoft Help, Unix manual pages, Unix Info pages)
Look at the GNOME DevHelp for a good set of ideas on how to
implement this.
+2
View File
@@ -0,0 +1,2 @@
*.src
*.html
+46
View File
@@ -0,0 +1,46 @@
0,Home,index.html,index.src
1,FAQ,faq.html,faq.src
0,Mono,rationale.html,rationale.src
1,Runtime,runtime.html,runtime.src
1,Classes,class-library.html,class-library.src
1,Gtk#,http://gtk-sharp.sourceforge.net
1,Class Status,class-status.html,class-status.src,cm/cormissing.css,cm/cormissing.js
2,corlib,class-status-corlib.html,class-status-corlib.src,cm/cormissing.css,cm/cormissing.js
2,System,class-status-System.html,class-status-System.src,cm/cormissing.css,cm/cormissing.js
2,System.Xml,class-status-System.Xml.html,class-status-System.Xml.src,cm/cormissing.css,cm/cormissing.js
2,System.Data,class-status-System.Data.html,class-status-System.Data.src,cm/cormissing.css,cm/cormissing.js
2,System.Drawing,class-status-System.Drawing.html,class-status-System.Drawing.src,cm/cormissing.css,cm/cormissing.js
2,System.Web,class-status-System.Web.html,class-status-System.Web.src,cm/cormissing.css,cm/cormissing.js
2,System.Web.Services,class-status-System.Web.Services.html,class-status-System.Web.Services.src,cm/cormissing.css,cm/cormissing.js
1,C# Compiler,c-sharp.html,c-sharp.src
1,Status,status.html,status.src
0,Download,download.html,download.src
1,CVS access,ccvs.html,ccvs.src
1,AnonCVS access,anoncvs.html,anoncvs.src
0,Contributing,contributing.html,contributing.src
1,Hackers,hackers.html,hackers.src
1,Documentation,documentation.html,documentation.src
1,Class Docs,classlib-doc.html,classlib-doc.src
1,Doc format,monodoc-xml.html,monodoc-xml.src
1,Test Suite,testing.html,testing.src
1,Tools,tools.html,tools.src
1,Porting,porting.html,porting.src
2,PowerPC,ppc.html,ppc.src
1,HOWTO,mono-contribution-howto.html,mono-contribution-howto.src
0,Plans,plans.html,plans.src
1,ADO.NET,ado-net.html,ado-net.src
1,ASP.NET,asp-net.html,asp-net.src
1,Java,java.html,java.src
1,Windows.Forms,winforms.html,winforms.src
0,Resources,resources.html,resources.src
1,Beginning,mono-beginning.html,mono-beginning.src
1,Mailing Lists,mailing-lists.html,mailing-lists.src
1,Ideas,ideas.html,ideas.src
1,Passport,passport.html,passport.src
1,Books,books.html,books.src
1,Papers,papers.html,papers.src
1,Languages,languages.html,languages.src
1,Debugging,jit-debug.html,jit-debug.src
2,Example 1,jit-debug-sample.html,jit-debug-sample.src
2,Example 2,jit-debug-sample2.html,jit-debug-sample2.src
0,Contact,contact.html,contact.src
+1
View File
@@ -0,0 +1 @@
*.html
Binary file not shown.

After

Width:  |  Height:  |  Size: 150 B

+182
View File
@@ -0,0 +1,182 @@
.y IMG
{
border: 0px;
padding: 0px;
margin: 0px;
margin-right: 4px;
vertical-align: middle;
}
.y, .y_,
.n, .n_,
.c, .c_,
.c, .c_,
.d, .d_,
.en, .en_,
.i, .i_,
.s, .s_,
.e, .e_,
.f, .f_,
.m, .m_,
.o, .o_,
.p, .p_,
.r, .r_,
.x, .x_
{
FONT: 10px 'Verdana';
margin-left: 20px;
}
.y_ .n,
.y_ .n_,
.n_ .c,
.n_ .c_,
.n_ .s,
.n_ .s_,
.n_ .d,
.n_ .d_,
.n_ .en,
.n_ .en_,
.n_ .i,
.n_ .i_,
.c_ .c,
.c_ .c_,
.c_ .e,
.c_ .e_,
.c_ .f,
.c_ .f_,
.c_ .m,
.c_ .m_,
.c_ .o,
.c_ .o_,
.c_ .p,
.c_ .p_,
.c_ .r,
.c_ .r_,
.c_ .x,
.c_ .x_,
.c_ .i,
.c_ .i_,
.d_ .c,
.d_ .c_,
.d_ .e,
.d_ .e_,
.d_ .f,
.d_ .f_,
.d_ .m,
.d_ .m_,
.d_ .o,
.d_ .o_,
.d_ .p,
.d_ .p_,
.d_ .r,
.d_ .r_,
.d_ .x,
.d_ .x_,
.en_ .c,
.en_ .c_,
.en_ .e,
.en_ .e_,
.en_ .f,
.en_ .f_,
.en_ .m,
.en_ .m_,
.en_ .o,
.en_ .o_,
.en_ .p,
.en_ .p_,
.en_ .r,
.en_ .r_,
.en_ .x,
.en_ .x_,
.i_ .c,
.i_ .c_,
.i_ .e,
.i_ .e_,
.i_ .f,
.i_ .f_,
.i_ .m,
.i_ .m_,
.i_ .o,
.i_ .o_,
.i_ .p,
.i_ .p_,
.i_ .r,
.i_ .r_,
.i_ .x,
.i_ .x_,
.i_ .i,
.i_ .i_,
.s_ .c,
.s_ .c_,
.s_ .e,
.s_ .e_,
.s_ .f,
.s_ .f_,
.s_ .m,
.s_ .m_,
.s_ .o,
.s_ .o_,
.s_ .p,
.s_ .p_,
.s_ .r,
.s_ .r_,
.s_ .x,
.s_ .x_,
.s_ .i,
.s_ .i_,
.e_ .r,
.e_ .r_,
.e_ .o,
.e_ .o_,
.f_ .r,
.f_ .r_,
.f_ .o,
.f_ .o_,
.m_ .r,
.m_ .r_,
.m_ .o,
.m_ .o_,
.o_ .r,
.o_ .r_,
.o_ .o,
.o_ .o_,
.p_ .r,
.p_ .r_,
.p_ .o,
.p_ .o_,
.r_ .r,
.r_ .r_,
.r_ .o,
.r_ .o_,
.x_ .r,
.x_ .r_,
.x_ .o,
.x_ .o_
{
display: none;
}
.t
{
cursor: pointer;
margin-right: 8px;
}
.filter
{
cursor: pointer;
vertical-align: middle;
}
.st
{
margin-left: 20px;
}
.l
{
cursor: pointer;
}
+392
View File
@@ -0,0 +1,392 @@
function toggle (elt)
{
if (elt == null)
return;
var eltLink = elt.firstChild;
if (eltLink != null && eltLink.className == 't') // toggle
{
var ich = elt.className.indexOf ('_');
if (ich < 0)
{
eltLink.src = 'cm/tp.gif';
elt.className += '_';
}
else
{
eltLink.src = 'cm/tm.gif';
elt.className = elt.className.slice (0, ich);
}
}
}
function setView (elt, fView)
{
var eltLink = elt.firstChild;
if (eltLink != null && eltLink.className == 't') // toggle
{
var ich = elt.className.indexOf ('_');
if (ich < 0 && !fView)
{
eltLink.src = 'cm/tp.gif';
elt.className += '_';
}
else if (ich >= 0 && fView)
{
eltLink.src = 'cm/tm.gif';
elt.className = elt.className.slice (0, ich);
}
}
}
function trimSrc (strSrc)
{
return strSrc.slice (strSrc.lastIndexOf ('/') + 1, strSrc.lastIndexOf ('.'));
}
function getChildrenByTagName (elt, strTag)
{
strTag = strTag.toLowerCase ();
var rgChildren = new Array ();
var eltChild = elt.firstChild;
while (eltChild)
{
if (eltChild.tagName && eltChild.tagName.toLowerCase () == strTag)
rgChildren.push (eltChild);
eltChild = eltChild.nextSibling;
}
return rgChildren;
}
function viewAll (elt, dictTypes)
{
var fView = false;
var rgImages = getChildrenByTagName (elt, 'IMG');
var cImages = rgImages.length;
for (var iImage = 0; iImage < cImages; iImage++)
{
var strImage = trimSrc (rgImages [iImage].src);
if (dictTypes [strImage])
{
fView = true;
break;
}
}
var rgElts = getChildrenByTagName (elt, 'DIV');
var cElts = rgElts.length;
if (cElts != 0)
{
var iElt;
for (iElt = 0; iElt < cElts; iElt ++)
fView |= viewAll (rgElts [iElt], dictTypes);
}
elt.style.display = fView ? '' : 'none';
return fView;
}
function getView (elt)
{
var eltLink = elt.firstChild;
if (eltLink != null && eltLink.className == 't') // toggle
{
var ich = elt.className.indexOf ('_');
if (ich < 0)
return true;
}
return false;
}
function getParentDiv (elt)
{
if (elt)
{
do
{
elt = elt.parentNode;
}
while (elt && elt.tagName != 'DIV');
}
return elt;
}
function getName (elt)
{
var rgSpans = getChildrenByTagName (elt, 'SPAN');
for (var iSpan = 0; iSpan < rgSpans.length; iSpan ++)
{
var span = rgSpans [iSpan];
if (span.className == 'l') // label
{
if (span.innerText)
return span.innerText;
else
return span.firstChild.nodeValue;
}
}
return null;
}
function clickHandler (evt)
{
var elt;
if (document.layers)
elt = evt.taget;
else if (window.event && window.event.srcElement)
{
elt = window.event.srcElement;
evt = window.event;
}
else if (evt && evt.stopPropagation)
elt = evt.target;
if (!elt.className && elt.parentNode)
elt = elt.parentNode;
if (elt.className == 'l') // label
{
var strClass;
var strField;
var strNamespace;
var strAssembly;
elt = getParentDiv (elt);
var strEltClass = elt.className;
if (strEltClass.charAt (strEltClass.length - 1) == '_')
strEltClass = strEltClass.slice (0, strEltClass.length - 1);
if (strEltClass == 'x') // constructor
{
strField = 'ctor';
elt = getParentDiv (elt);
}
else
if (strEltClass == 'm' || // method
strEltClass == 'p' || // property
strEltClass == 'e' || // event
strEltClass == 'f') // field
{
strField = getName (elt).toLowerCase ();
var match = strField.match ( /[\.A-Z0-9_]*/i );
if (match)
strField = match [0];
elt = getParentDiv (elt);
}
var strEltClass = elt.className;
if (strEltClass.charAt (strEltClass.length - 1) == '_')
strEltClass = strEltClass.slice (0, strEltClass.length - 1);
if (strEltClass == 'c' || // class
strEltClass == 's' || // struct
strEltClass == 'i' || // struct
strEltClass == 'd' || // delegate
strEltClass == 'en') // enum
{
strClass = getName (elt);
if (strEltClass == 'en')
strField = null;
elt = getParentDiv (elt);
}
var strEltClass = elt.className;
if (strEltClass.charAt (strEltClass.length - 1) == '_')
strEltClass = strEltClass.slice (0, strEltClass.length - 1);
if (strEltClass == 'n')
{
strNamespace = getName (elt);
elt = getParentDiv (elt);
}
var strEltClass = elt.className;
if (strEltClass.charAt (strEltClass.length - 1) == '_')
strEltClass = strEltClass.slice (0, strEltClass.length - 1);
if (strEltClass == 'y')
{
strAssembly = getName (elt);
}
if (evt.ctrlKey)
{
var strRoot = 'http://cvs.hispalinux.es/cgi-bin/cvsweb/mcs/class/';
var strExtra = '?cvsroot=Mono';
if (strAssembly)
{
strRoot = strRoot + strAssembly + '/';
if (strNamespace)
{
strRoot = strRoot + strNamespace + '/';
if (strClass)
{
strRoot += strClass + '.cs';
strExtra += '&rev=1';
}
}
window.open (strRoot + strExtra, 'CVS');
}
}
else if (strNamespace)
{
var re = /\./g ;
strNamespace = strNamespace.toLowerCase ().replace (re, '');
if (strClass)
strNamespace += strClass.toLowerCase () + 'class';
if (strField)
strNamespace += strField;
if (strClass || strField)
strNamespace += 'topic';
window.open ('http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrf' + strNamespace + '.asp', 'MSDN');
}
}
else
{
if (elt.parentNode && elt.parentNode.className == 't') // toggle
elt = elt.parentNode;
else if (elt.className != 't') // toggle
return;
while (elt != null && elt.tagName != 'DIV')
elt = elt.parentNode;
if (evt.shiftKey)
{
var rgElts = getChildrenByTagName (elt, 'DIV');
var cElts = rgElts.length;
if (cElts != 0)
{
var fView = false;
var iElt;
for (iElt = 0; iElt < cElts; iElt ++)
{
if (getView (rgElts [iElt]))
{
fView = true;
break;
}
}
for (iElt = 0; iElt < cElts; iElt ++)
{
setView (rgElts [iElt], !fView);
}
}
}
else if (evt.ctrlKey)
{
setView (elt, true);
var eltParent = getParentDiv (elt);
while (eltParent)
{
var rgSiblings = getChildrenByTagName (eltParent, 'DIV');
var cSiblings = rgSiblings.length;
for (var iSibling = 0; iSibling < cSiblings; iSibling++)
{
var eltSibling = rgSiblings [iSibling];
if (eltSibling != elt)
{
setView (eltSibling, false);
}
}
elt = eltParent;
eltParent = getParentDiv (elt);
}
}
else
toggle (elt);
}
return false;
}
function filterTree ()
{
var eltMissing = document.getElementById ('missing');
var eltTodo = document.getElementById ('todo');
var eltExtra = document.getElementById ('extra');
var eltErrors = document.getElementById ('errors');
var dictTypes = new Object ();
if (eltMissing.checked)
dictTypes ['sm'] = true;
if (eltTodo.checked)
dictTypes ['st'] = true;
if (eltErrors.checked)
dictTypes ['se'] = true;
if (eltExtra.checked)
dictTypes ['sx'] = true;
// dictTypes ['sc'] = true;
viewAll (document.getElementById ('ROOT'), dictTypes);
}
function selectMissing ()
{
toggleFilter ('missing');
}
function selectTodo ()
{
toggleFilter ('todo');
}
function selectExtra ()
{
toggleFilter ('extra');
}
function selectErrors ()
{
toggleFilter ('errors');
}
function toggleFilter (strFilter)
{
var eltTodo = document.getElementById ('todo');
var eltMissing = document.getElementById ('missing');
var eltExtra = document.getElementById ('extra');
var eltErrors = document.getElementById ('errors');
var eltToggle = document.getElementById (strFilter);
if (window && window.event && window.event.shiftKey)
{
eltMissing.checked = eltTodo.checked = eltExtra.checked = eltErrors.checked = false;
eltToggle.checked = true;
}
else
if (!eltTodo.checked && !eltMissing.checked && !eltExtra.checked && !eltErrors.checked)
{
eltMissing.checked = eltTodo.checked = eltExtra.checked = eltErrors.checked = true;
eltToggle.checked = false;
}
filterTree ();
}
function onLoad ()
{
var eltMissing = document.getElementById ('missing');
var eltTodo = document.getElementById ('todo');
var eltExtra = document.getElementById ('extra');
var eltErrors = document.getElementById ('errors');
eltMissing.checked = eltTodo.checked = eltExtra.checked = eltErrors.checked = true;
}
if (document.layers)
{
document.captureEvents (Event.MOUSEUP);
document.onmouseup = clickHandler;
}
else if (document.attachEvent)
{
document.attachEvent('onclick', clickHandler);
}
else if (document.addEventListener)
{
document.addEventListener('click', clickHandler, false);
}
else
document.onclick = clickHandler;
Binary file not shown.

After

Width:  |  Height:  |  Size: 137 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 861 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 111 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 90 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 90 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 101 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 65 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 111 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 73 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 127 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 70 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 73 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 76 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 101 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 73 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 49 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 64 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 67 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 92 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 4.8 KiB

Binary file not shown.
Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 3.0 KiB

Binary file not shown.
Loaded 100 of 11599 files, more files were not shown because too many files have changed in this diff. Show more