Compare commits

..
1 Commits
Author SHA1 Message Date
nobody 5bafbfd341 This commit was manufactured by cvs2svn to create tag 'MONO_0_7'.
svn path=/tags/MONO_0_7/mono/; revision=871
2001-09-18 20:20:55 +00:00
2193 changed files with 32798 additions and 264107 deletions

No files matched your search

-1
View File
@@ -1,3 +1,2 @@
Miguel de Icaza ([email protected])
Paolo Molaro ([email protected])
Dietmar Maurer ([email protected])
-485
View File
@@ -1,485 +0,0 @@
The Mono runtime is licensed under the terms of the GNU
Library General Public License, version 2.
GNU LIBRARY GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.
Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.
Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.
The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.
Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.
However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.
Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.
GNU LIBRARY GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
c) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
d) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!
-220
View File
@@ -1,223 +1,3 @@
2002-03-24 Martin Baulig <[email protected]>
* man/mcs.1: Documented the new --debug option and added a section
about debugging support.
* man/mono.1: Documented the new --dwarf and --dwarf-plus options.
2002-03-21 Martin Baulig <[email protected]>
* configure.in: Added check for <elf.h>.
2002-03-18 Dick Porter <[email protected]>
* configure.in: Only look for libgc on the system. Default to not
using GC at all, because it doesn't work with the jit.
2002-03-17 Miguel de Icaza <[email protected]>
* configure.in: Add support for building the included boehm GC.
Thu Mar 7 17:19:44 CET 2002 Paolo Molaro <[email protected]>
* configure.in: detect Boehm GC libs and add --with-gc switch.
Boehm GC needs to be explicitly enabled since the JIT currently fails
in some cases with it.
2002-02-27 Dietmar Maurer <[email protected]>
* mono/tests/fib.cs: it is now possible to pass a repeat count as
command line argument, for example fib.exe 20 runs the test 20
times.
2002-02-25 Sergey Chaban <[email protected]>
* configure.in: added support for ARM target arch.
Uncommented and modified arm-*-linux* target,
added mono/arch/arm/Makefile to AC_OUTPUT list.
2002-02-21 Mark Crichton <[email protected]>
* status/class.xml: Added contact info for RNGCryptoServiceProvider
class and Rijndael classes.
* status/maintainers.xml: Added contact info to maintainers list.
2002-02-21 Mark Crichton <[email protected]>
* configure.in: Add checks for a system-provided entropy device
* acconfig.h: Added HAVE_CRYPT_RNG and NAME_DEV_RANDOM
2002-02-20 Dick Porter <[email protected]>
* acconfig.h:
* configure.in: Always build without cygwin support on windows
2002-02-19 Radek Doulik <[email protected]>
* mono/tests/pinvoke.cs: use more pinvoke test methods
2002-02-19 Radek Doulik <[email protected]>
* mono/tests/libtest.c (mono_test_many_short_arguments): new test
method
(mono_test_many_byte_arguments): ditto
2002-02-18 Radek Doulik <[email protected]>
* mono/tests/Makefile.am: added small test library for pinvoke
testing
* mono/tests/libtest.c (mono_test_many_int_arguments): new file,
new function to test pinvoke
* mono/tests/pinvoke.cs (Test): added pinvoked method with 10 int
arguments
* mono/tests/Makefile.am: display # of passing tests too
added simple shared library libtest with testing function for
pinvoke
2002-02-17 Radek Doulik <[email protected]>
* mono/tests/Makefile.am (test): display # of failed tests
2002-02-16 Jeffrey Stedfast <[email protected]>
* configure.in: Add checks for SOL_IP, SOL_TCP, and
IP_PKTINFO. Also check for struct ip_mreqn.
2002-02-14 Jeffrey Stedfast <[email protected]>
* configure.in: Add checks to see if we need to link to libsocket,
libnsl, and/or librt. Also check for inet_pton and inet_aton.
2002-02-13 Jeffrey Stedfast <[email protected]>
* acconfig.h: #undef USE_MONO_MUTEX
* configure.in: If the system pthread implementation is lacking,
default to using mono-mutex.
2002-02-05 Dietmar Maurer <[email protected]>
* mono/tests/enum2.cs: new file with more enum tests.
2002-02-01 Dietmar Maurer <[email protected]>
* mono/tests/jit-long.cs: added some SHL/SHR tests
Fri Feb 1 15:32:36 CET 2002 Paolo Molaro <[email protected]>
* configure.in: allow PKG_CONFIG_PATH for the build-platform
pkg-config invocation.
Fri Feb 1 15:13:25 CET 2002 Paolo Molaro <[email protected]>
* configure.in: add some support/fixes for cross-compilation.
2002-01-14 Dietmar Maurer <[email protected]>
* mono/tests/exception6.cs: new tests for ADD_OVF, MUL_OVF
added tests for SUB_OVF, SUB_OVF_UN
2001-12-21 Dietmar Maurer <[email protected]>
* mono/tests/Makefile.am (TESTSRC): disabled stream-writer test
2001-12-21 Aaron Weber <[email protected]>
* doc/faq (A): added a linebreak that was missing and was causing
a heading to appear badly.
2001-12-20 Aaron Weber <[email protected]>
* doc/faq: added <a name=""> nav links, and moved all MSFT-related
questions into a single section.
2001-12-17 Aaron Weber <[email protected]>
* doc/faq (Q): Question-by-question, line-by-line revision.
2001-12-17 Dietmar Maurer <[email protected]>
* mono/tests/time.cs: new test
2001-11-30 Radek Doulik <[email protected]>
* configure.in: remove ACCESS_UNALIGNED="no" from ppc
2001-11-29 Radek Doulik <[email protected]>
* configure.in (ACCESS_UNALIGNED): uncommented and modified
powerpc-*-linux*
generate mono/arch/ppc/Makefile
2001-11-26 Dietmar Maurer <[email protected]>
* mono/tests/exception3.cs: modified the test to show a bug in the
current exception handling implementation.
2001-11-13 Dick Porter <[email protected]>
* configure.in: Some more tests for pthread features
(specifically, glibc 2.1 doesnt define pthread_mutex_timedlock but
still needs _GNU_SOURCE for PTHREAD_MUTEX_RECURSIVE)
2001-11-09 Dick Porter <[email protected]>
* configure.in: Try and get large file support, but it's not fatal
if it's not there (the io-layer just ignores the high word in that
case.)
Check for windows builds, and only bother to look for pthreads and
large files if we're not building for cygwin or native win32. Not
having pthread support on Posix systems is now a fatal error.
* autogen.sh: Fix ACLOCAL_FLAGS - it wasn't being passed to
aclocal
2001-10-15 Dietmar Maurer <[email protected]>
* mono/tests/Makefile.am: removed JITTESTS, simply run all tests for
target testjit.
2001-10-11 Dietmar Maurer <[email protected]>
* docs/object-layout: more documentation
Mon Oct 8 20:27:50 CEST 2001 Paolo Molaro <[email protected]>
* configure.in: define NO_UNALIGNED_ACCESS for platforms that
can't read on unaligned boundaries
2001-10-04 Dick Porter <[email protected]>
* configure.in: Do some deeper checks on pthreads for some of the
more interesting functions
2001-09-24 Dietmar Maurer <[email protected]>
* mono/tests/Makefile.am (testjit): a new target to test the JITer
* mono/tests/jit-*: added some test for the JITer
2001-09-23 Dick Porter <[email protected]>
* configure.in: Arrange to compile dummy thread support routines
if pthread isnt available
2001-09-23 Dick Porter <[email protected]>
* configure.in: Check for pthread.h, so that we can check for the
HAVE_PTHREAD_H define in config.h
2001-09-21 Dick Porter <[email protected]>
* configure.in: Check for libpthread
2001-09-19 Dietmar Maurer <[email protected]>
* mono/tests/test-ops.cs: added more tests
Mon Sep 10 20:19:00 CEST 2001 Paolo Molaro <[email protected]>
* configure.in: check for sizeof(void*) and for the architecture.
+1 -3
View File
@@ -1,3 +1 @@
AUTOMAKE_OPTIONS = foreign
SUBDIRS = mono doc runtime scripts man
SUBDIRS = mono doc runtime
-10
View File
@@ -1,13 +1,3 @@
2002-Feb-11 Miguel de Icaza <[email protected]>
New release, functional x86-JIT, x86 interpreter, ppc interpreter
Class libraries ship.
Limited compiler ships.
Too many changes to list
2001-07-12 Miguel de Icaza <[email protected]>
New XSLT file from Sergey Chaban for CIL opcodes
+1 -11
View File
@@ -1,13 +1,5 @@
This is Mono.
Installation:
Read doc/download for installation instructions,
or read the HTML version:
http://www.go-mono.com/download.html
A directory roadmap:
doc/
@@ -45,8 +37,6 @@ A directory roadmap:
You can try the interpreter like this:
mint program.exe
mono-int program.exe
-15
View File
@@ -1,15 +0,0 @@
#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
+2 -2
View File
@@ -86,8 +86,8 @@ if grep "^AM_PROG_LIBTOOL" configure.in >/dev/null; then
fi
fi
echo "Running aclocal $ACLOCAL_FLAGS ..."
aclocal $ACLOCAL_FLAGS || {
echo "Running aclocal $aclocalinclude ..."
aclocal $aclocalinclude || {
echo
echo "**Error**: aclocal failed. This may mean that you have not"
echo "installed all of the packages you need, or you may need to"
-51
View File
@@ -1,51 +0,0 @@
/* 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
+23 -429
View File
@@ -1,440 +1,52 @@
AC_INIT(README)
AC_CANONICAL_SYSTEM
AM_CONFIG_HEADER(config.h)
AM_INIT_AUTOMAKE(mono, 0.10)
AM_INIT_AUTOMAKE(mono, 0.6)
AM_MAINTAINER_MODE
AC_CHECK_TOOL(CC, gcc, gcc)
AC_CANONICAL_HOST
AC_PROG_CC
AM_PROG_CC_STDC
AC_PROG_INSTALL
dnl may require a specific autoconf version
dnl AC_PROG_CC_FOR_BUILD
dnl CC_FOR_BUILD not automatically detected
CC_FOR_BUILD=$CC
BUILD_EXEEXT=
if test "x$cross_compiling" = "xyes"; then
CC_FOR_BUILD=cc
BUILD_EXEEXT=""
fi
AC_SUBST(CC_FOR_BUILD)
AC_SUBST(HOST_CC)
AC_SUBST(BUILD_EXEEXT)
# Set STDC_HEADERS
AC_HEADER_STDC
AC_LIBTOOL_WIN32_DLL
AM_PROG_LIBTOOL
AC_CHECK_HEADERS(sys/filio.h sys/sockio.h netdb.h utime.h)
AC_CHECK_SIZEOF(void *)
# for mono/metadata/debug-symfile.c
AC_CHECK_HEADERS(elf.h)
dnl ***************************
dnl *** Checks for glib 1.2 ***
dnl ***************************
AM_PATH_GLIB(1.2.0,,
AC_MSG_ERROR([Cannot find GLIB: Is glib-config in path?]))
# not 64 bit clean in cross-compile
AC_CHECK_SIZEOF(void *, 4)
CFLAGS='-g -Wall -Wunused -Wmissing-prototypes -Wmissing-declarations'
AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
if test "x$PKG_CONFIG" = "xno"; then
AC_MSG_ERROR([You need to install pkg-config])
fi
dnl for use on the build system
dnl pkg-config is stupid
BUILD_GLIB_CFLAGS=`$PKG_CONFIG --cflags glib-2.0`
BUILD_GLIB_LIBS=`$PKG_CONFIG --libs glib-2.0`
AC_SUBST(BUILD_GLIB_CFLAGS)
AC_SUBST(BUILD_GLIB_LIBS)
PKG_PATH=
AC_ARG_WITH(crosspkgdir, [ --with-crosspkgdir=/path/to/pkg-config/dir],
if test x$with_crosspkgdir = "x"; then
if test -s $PKG_CONFIG_PATH; then
PKG_PATH=$PKG_CONFIG_PATH
fi
else
PKG_PATH=$with_crosspkgdir
PKG_CONFIG_PATH=$PKG_PATH
export PKG_CONFIG_PATH
fi
)
## Versions of dependencies
GLIB_REQUIRED_VERSION=1.3.11
PKG_CHECK_MODULES(BASE_DEPENDENCIES, glib-2.0 >= $GLIB_REQUIRED_VERSION)
GLIB_CFLAGS=`$PKG_CONFIG --cflags glib-2.0`
GLIB_LIBS=`$PKG_CONFIG --libs glib-2.0`
GMODULE_CFLAGS=`$PKG_CONFIG --cflags gmodule-2.0`
GMODULE_LIBS=`$PKG_CONFIG --libs gmodule-2.0`
GLIB_CFLAGS=`glib-config --cflags glib`
GLIB_LIBS=`glib-config --libs glib`
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
GMODULE_CFLAGS=`glib-config --cflags gmodule`
GMODULE_LIBS=`glib-config --libs gmodule`
AC_SUBST(GMODULE_CFLAGS)
AC_SUBST(GMODULE_LIBS)
AC_CHECK_LIB(gc, GC_malloc, found_boehm="yes")
gc=none
AC_ARG_WITH(gc, [ --with-gc=boehm,none],[gc=$with_gc])
case "x$gc" in
xboehm|xyes)
if test "x$found_boehm" != "xyes"; then
AC_MSG_ERROR("GC requested but libgc not found!")
fi
AC_DEFINE(HAVE_BOEHM_GC)
AC_SUBST(HAVE_BOEHM_GC)
LIBS="$LIBS -lgc"
;;
*)
dnl When the JIT works with libgc, use this chunk.
dnl # If libgc was found, use it. Otherwise just warn.
if test "x$found_boehm" != "xyes"; then
AC_MSG_WARN("Compiling mono without GC.")
else
AC_DEFINE(HAVE_BOEHM_GC)
AC_SUBST(HAVE_BOEHM_GC)
LIBS="$LIBS -lgc"
gc="boehm"
fi
dnl AC_MSG_WARN("Compiling mono without GC.")
;;
esac
dnl ****************************************
dnl *** Check if we're building on win32 ***
dnl ****************************************
AC_MSG_CHECKING([if building for some Win32 platform])
case "$host" in
*-*-mingw*|*-*-cygwin*)
platform_win32=yes
AC_DEFINE(PLATFORM_WIN32)
;;
*)
platform_win32=no
;;
esac
AC_MSG_RESULT($platform_win32)
AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
if test x$platform_win32 = xno; then
dnl ******************************************************************
dnl *** Check for large file support ***
dnl *** (If we were using autoconf 2.50 we'd use AC_SYS_LARGEFILE) ***
dnl ******************************************************************
# Check that off_t can represent 2**63 - 1 correctly, working around
# potential compiler bugs. Defines LARGE_FILE_SUPPORT, adds $1 to
# CFLAGS and sets $large_offt to yes if the test succeeds
large_offt=no
AC_DEFUN(LARGE_FILES, [
large_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $1"
AC_TRY_RUN([
#include <sys/types.h>
#define BIG_OFF_T (((off_t)1<<62)-1+((off_t)1<<62))
int main(void) {
int big_off_t=((BIG_OFF_T%2147483629==721) &&
(BIG_OFF_T%2147483647==1));
if(big_off_t) {
exit(0);
} else {
exit(1);
}
}
], [
AC_MSG_RESULT(ok)
AC_DEFINE(HAVE_LARGE_FILE_SUPPORT)
CFLAGS="$CFLAGS $1"
large_offt=yes
], [
AC_MSG_RESULT(no)
], "")
CPPFLAGS=$large_CPPFLAGS
])
AC_MSG_CHECKING(if off_t is 64 bits wide)
LARGE_FILES("")
if test $large_offt = no; then
AC_MSG_CHECKING(if _FILE_OFFSET_BITS=64 gives 64 bit off_t)
LARGE_FILES("-D_FILE_OFFSET_BITS=64")
fi
if test $large_offt = no; then
AC_MSG_WARN([No 64 bit file size support available])
fi
dnl *****************************
dnl *** Checks for libsocket ***
dnl *****************************
AC_CHECK_LIB(socket, socket, LIBS="$LIBS -lsocket")
dnl *****************************
dnl *** Checks for SOL_IP ***
dnl *****************************
AC_MSG_CHECKING(for SOL_IP)
AC_TRY_COMPILE([#include <netdb.h>], [
int level = SOL_IP;
], [
# Yes, we have it...
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_SOL_IP)
], [
# We'll have to use getprotobyname
AC_MSG_RESULT(no)
])
dnl *****************************
dnl *** Checks for SOL_TCP ***
dnl *****************************
AC_MSG_CHECKING(for SOL_TCP)
AC_TRY_COMPILE([#include <netdb.h>], [
int level = SOL_TCP;
], [
# Yes, we have it...
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_SOL_TCP)
], [
# We'll have to use getprotobyname
AC_MSG_RESULT(no)
])
dnl *****************************
dnl *** Checks for IP_PKTINFO ***
dnl *****************************
AC_MSG_CHECKING(for IP_PKTINFO)
AC_TRY_COMPILE([#include <netdb.h>], [
int level = IP_PKTINFO;
], [
# Yes, we have it...
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_IP_PKTINFO)
], [
AC_MSG_RESULT(no)
])
dnl *********************************
dnl *** Check for struct ip_mreqn ***
dnl *********************************
AC_MSG_CHECKING(for struct ip_mreqn)
AC_TRY_COMPILE([#include <netinet/in.h>], [
struct ip_mreqn mreq;
mreq.imr_address.s_addr = 0;
], [
# Yes, we have it...
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_STRUCT_IP_MREQN)
], [
# We'll just have to use struct ip_mreq
AC_MSG_RESULT(no)
])
dnl *****************************
dnl *** Checks for libnsl ***
dnl *****************************
AC_CHECK_LIB(nsl, gethostbyaddr, LIBS="$LIBS -lnsl")
AC_CHECK_FUNCS(inet_pton inet_aton)
dnl *****************************
dnl *** Checks for libpthread ***
dnl *****************************
AC_SEARCH_LIBS(pthread_create, pthread, [
AM_CONDITIONAL(THREADS_PTHREAD, true)
AC_DEFINE(HAVE_PTHREAD)
# Need pthread_mutex_timedlock
pthread_CFLAGS=""
orig_CPPFLAGS=$CPPFLAGS
# This is a gcc-specific error, but we already set
# gcc-specific options in CFLAGS
CPPFLAGS="$CPPFLAGS -Werror-implicit-function-declaration"
AC_MSG_CHECKING(for pthread_mutex_timedlock)
AC_TRY_COMPILE([ #include <pthread.h>], [
pthread_mutex_t mut=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_timedlock(&mut, NULL);
], [
# Works!
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_PTHREAD_MUTEX_TIMEDLOCK)
], [
AC_MSG_RESULT(no)
# glibc requires -D_GNU_SOURCE before it will declare
# this function
AC_MSG_CHECKING(whether _GNU_SOURCE is needed for pthread_mutex_timedlock)
CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
AC_TRY_COMPILE([ #include <pthread.h>], [
pthread_mutex_t mut=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_timedlock(&mut, NULL);
], [
AC_MSG_RESULT(yes)
pthread_CFLAGS="-D_GNU_SOURCE"
AC_DEFINE(HAVE_PTHREAD_MUTEX_TIMEDLOCK)
], [
AC_MSG_RESULT(no)
dnl Add other variants here
AC_MSG_WARN(Working around pthread_mutex_timedlock)
])
])
CPPFLAGS=$orig_CPPFLAGS
CFLAGS="$CFLAGS $pthread_CFLAGS"
# Need PTHREAD_MUTEX_RECURSIVE
pthread_CFLAGS=""
orig_CPPFLAGS=$CPPFLAGS
# This is a gcc-specific error, but we already set
# gcc-specific options in CFLAGS
CPPFLAGS="$CPPFLAGS -Werror-implicit-function-declaration"
AC_MSG_CHECKING(for PTHREAD_MUTEX_RECURSIVE)
AC_TRY_COMPILE([ #include <pthread.h>], [
pthread_mutexattr_t attr;
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
], [
# Works!
AC_MSG_RESULT(ok)
], [
AC_MSG_RESULT(no)
# glibc requires -D_GNU_SOURCE before it will declare
# this macro
AC_MSG_CHECKING(whether _GNU_SOURCE is needed for PTHREAD_MUTEX_RECURSIVE)
CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
AC_TRY_COMPILE([ #include <pthread.h>], [
pthread_mutexattr_t attr;
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
], [
AC_MSG_RESULT(ok)
pthread_CFLAGS="-D_GNU_SOURCE"
], [
AC_MSG_RESULT(no)
dnl Add other variants here
AC_MSG_WARN(Using mono_mutex_t for recursive mutexes)
AC_DEFINE(USE_MONO_MUTEX)
])
])
CPPFLAGS=$orig_CPPFLAGS
CFLAGS="$CFLAGS $pthread_CFLAGS"
], [
AC_MSG_ERROR([libpthread is required on non-win32 hosts])
])
dnl ********************************
dnl *** Checks for semaphore lib ***
dnl ********************************
AC_CHECK_LIB(rt, sem_init, LIBS="$LIBS -lrt")
else
# This is a kludge, we really ought to test for libws2_32, but
# I can't make AC_CHECK_LIB link (the symbols seem to be mangled
# with @num suffixes)
LIBS="$LIBS -lws2_32"
CFLAGS="$CFLAGS -mno-cygwin"
fi
dnl ****************************
dnl *** Look for /dev/random ***
dnl ****************************
AC_MSG_CHECKING([if usage of random device is requested])
AC_ARG_ENABLE(dev-random,
[ --disable-dev-random disable the use of the random device],
try_dev_random=$enableval, try_dev_random=yes)
AC_MSG_RESULT($try_dev_random)
case "{$target}" in
*-openbsd*)
NAME_DEV_RANDOM="/dev/srandom"
;;
dnl Win32 does not have /dev/random, they have their own method...
*-*-mingw*|*-*-cygwin*)
ac_cv_have_dev_random = no
;;
dnl Everywhere else, it's /dev/random
*)
NAME_DEV_RANDOM="/dev/random"
;;
esac
AC_DEFINE_UNQUOTED(NAME_DEV_RANDOM, "$NAME_DEV_RANDOM")
dnl Now check if the device actually exists
if test "x$try_dev_random" = "xyes"; then
AC_CACHE_CHECK(for random device, ac_cv_have_dev_random,
[if test -r "$NAME_DEV_RANDOM" ; then
ac_cv_have_dev_random=yes; else ac_cv_have_dev_random=no; fi])
if test "x$ac_cv_have_dev_random" = "xyes"; then
AC_DEFINE(HAVE_CRYPT_RNG)
fi
else
AC_MSG_CHECKING(for random device)
ac_cv_have_dev_random=no
AC_MSG_RESULT(has been disabled)
fi
if test "x$platform_win32" = "xyes"; then
AC_DEFINE(HAVE_CRYPT_RNG)
fi
if test "x$ac_cv_have_dev_random" = "xno" \
&& test "x$platform_win32" = "xno"; then
AC_MSG_WARN([[
***
*** A system-provided entropy source was not found on this system.
*** Because of this, the System.Security.Cryptography random number generator
*** will throw a NotImplemented exception.
***
*** If you are seeing this message, and you know your system DOES have an
*** entropy collection in place, please contact <[email protected]> and
*** provide information about the system and how to access the random device.
***
*** For those systems who lack a random device, EGD support is forthcoming.
***]])
fi
if test "x$cross_compiling" = "xno"; then
# check for new iconv version
AC_MSG_CHECKING(for new iconv)
AC_CACHE_VAL(new_iconv,[
AC_TRY_RUN([#include <stdio.h>
#include <iconv.h>
int main()
{
exit (iconv_open ("UTF-16le", "UTF-8") == (iconv_t)-1);
}
],
new_iconv=yes,new_iconv=)])
if test -n "$new_iconv"; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_NEW_ICONV)
else
AC_MSG_RESULT(no)
fi
fi
CFLAGS='-g -Wall -Wunused -Wmissing-prototypes -Wmissing-declarations'
TARGET="unknown"
ACCESS_UNALIGNED="yes"
case "$host" in
#mips-sgi-irix5.* | mips-sgi-irix6.*) TARGET=MIPS; ACCESS_UNALIGNED="no";;
#mips-sgi-irix5.* | mips-sgi-irix6.*) TARGET=MIPS;;
i*86-*-*) TARGET=X86; arch_target=x86;;
sparc*-*-*) TARGET=SPARC; arch_target=sparc; ACCESS_UNALIGNED="no";;
#alpha*-*-linux* | alpha*-*-osf*) TARGET=ALPHA; ACCESS_UNALIGNED="no";;
#sparc-sun-4*) TARGET=SPARC;;
#sparc-sun-*) TARGET=SPARC;;
#sparc*-*-linux*) TARGET=SPARC;;
#alpha*-*-linux* | alpha*-*-osf*) TARGET=ALPHA;;
#m68k-*-linux*) TARGET=M68K;;
powerpc-*-linux* | powerpc-*-sysv*) TARGET=POWERPC; arch_target=ppc;;
arm-*-linux-*) TARGET=ARM; arch_target=arm; ACCESS_UNALIGNED="no";;
#powerpc-*-linux* | powerpc-*-sysv*) TARGET=POWERPC;;
#arm-*-linux-*) TARGET=ARM;;
esac
if test ${TARGET} = unknown; then
@@ -442,10 +54,6 @@ if test ${TARGET} = unknown; then
AC_MSG_WARN("mono has not been ported to $host: some things may not work.")
fi
if test ${ACCESS_UNALIGNED} = no; then
CPPFLAGS="$CPPFLAGS -DNO_UNALIGNED_ACCESS"
fi
AM_CONDITIONAL(MIPS_GCC, test ${TARGET}${ac_cv_prog_gcc} = MIPSyes)
AM_CONDITIONAL(MIPS_SGI, test ${TARGET}${ac_cv_prog_gcc} = MIPSno)
AM_CONDITIONAL(SPARC, test x$TARGET = xSPARC)
@@ -461,30 +69,16 @@ AC_SUBST(CFLAGS)
AC_OUTPUT([
Makefile
mono/Makefile
mono/utils/Makefile
mono/metadata/Makefile
mono/dis/Makefile
mono/cil/Makefile
mono/arch/Makefile
mono/arch/x86/Makefile
mono/arch/ppc/Makefile
mono/arch/sparc/Makefile
mono/arch/arm/Makefile
mono/interpreter/Makefile
mono/tests/Makefile
mono/wrapper/Makefile
mono/monoburg/Makefile
mono/monograph/Makefile
mono/jit/Makefile
mono/io-layer/Makefile
runtime/Makefile
scripts/Makefile
man/Makefile
doc/Makefile
])
echo "
GC: $gc
"
-1
View File
@@ -1,4 +1,3 @@
Makefile.in
Makefile
all-docs
pending-classes.in
+3 -16
View File
@@ -1,9 +1,9 @@
WEB_FILES= \
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
roadmap runtime status team testing thanks tools
OTHERS= pending resources-pending todo mono-build.sh mono-build-w32.sh
OTHERS= pending resources-pending todo
EXTRA_DIST = $(WEB_FILES) README $(OTHERS)
@@ -12,21 +12,8 @@ all-docs: $(WEB_FILES)
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
webit:
(cd web; make && make push)
push-notes:
scp release-notes/mono* www@www:/web/cvsmodules/mono/archive
dummy:
-70
View File
@@ -1,70 +0,0 @@
* 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>
-32
View File
@@ -1,32 +0,0 @@
* C# Books
A Programmer's Introduction to C# - Second Edition: Eric Gunnerson
* 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>
+44 -72
View File
@@ -1,43 +1,19 @@
* 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).
MCS began as an experiment to learn the features of C# by
writing a large C# program. MCS is currently able to parse C#
programs and create an internal tree representation of the
program. MCS can parse itself.
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.
MCS now does type checking at the class, interface and struct
levels and can resolve the class hierarchy and as of last week
can generate interface code.
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.
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 Windows (with the .NET
framework 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.
Work is progressing quickly on various fronts in the C#
compiler. Recently I started using the System.Reflection API
to load system type definitions and avoid self-population of
types in the compiler and dropped my internal Type
representation in favor of using the CLI's System.Type.
** Phases of the compiler
@@ -70,47 +46,28 @@
have to postpone this decision until the above steps
are finished.
* Code generation: The code generation is done through
the System.Reflection.Emit API.
* Code generation: The compiler recently started generating IL
executables that contain interfaces. Work is
progressing in other areas.
The code generation is done through the System.Reflection.Emit API.
</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.
<a name="tasks">
** Current pending tasks
Simple tasks:
<ul>
* Redo the way we deal with built-in operators.
</ul>
* Array declarations are currently being ignored,
Larger tasks:
<ul>
* PInvoke declarations are not supported.
* Pre-processing is not supported.
* Attribute declarations and passing currently ignored.
* Compiler does not pass around line/col information from tokenizer for error reporting.
* Jay does not work correctly with `error'
productions, making parser errors hard to point. It
@@ -120,12 +77,31 @@
Nick Drochak has started a project on SourceForge for this.
You can find the project at: <a href="http://sourceforge.net/projects/jb2csharp/">
http://sourceforge.net/projects/jb2csharp/</a>
</ul>
Interesting and Fun hacks to the compiler:
<ul>
* Finishing the JB port from Java to C#. If you are
interested in working on this, please contact the project admin on SourceForge:
<a href="http://sourceforge.net/projects/jb2csharp/">
http://sourceforge.net/projects/jb2csharp/</a>
More on JB at: <a href="http://www.cs.colorado.edu/~dennis/software/jb.html">
http://www.cs.colorado.edu/~dennis/software/jb.html</a>
JB will allow us to move from the Berkeley Yacc
based Jay to a Bison-based compiler (better error
reporting and recovery).
* Semantic Analysis: Return path coverage and
initialization before use coverage are two great
features of C# that help reduce the number of bugs
in applications. It is one interesting hack.
* Enum resolutions: it is another fun hack, as enums can be defined
in terms of themselves (<tt>enum X { a = b + 1, b = 5 }</tt>).
</ul>
** Questions and Answers
@@ -154,10 +130,6 @@ Q: If your C# compiler is written in C#, how do you plan on getting
We will do this through an implementation of the CLI Virtual
Execution System for Unix (our JIT engine).
Our JIT engine is working for the purposes of using the compiler.
The supporting class libraries are being worked on to fully support
the compiler.
Q: Do you use Bison?
A: No, currently I am using Jay which is a port of Berkeley Yacc to
+3 -29
View File
@@ -1,10 +1,7 @@
* 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.
that hosts the Mono source code.
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.
@@ -67,25 +64,6 @@
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
@@ -119,13 +97,9 @@
** 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.
CVS, because that normally wastes everybody's time.
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.
Make sure that you add all the files before you do a commit.
Use ChangeLog entries so we can keep textual descriptions of
your work, and use the contents of your ChangeLog file as the
+28 -35
View File
@@ -30,18 +30,9 @@
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>
href="http://mail.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
@@ -106,11 +97,33 @@
** 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.
The class library will be licensed under the terms of the GNU
LGPL. Some people have pointed out that the plain LGPL is
troublesome for embedded use of the Mono class libraries. So
we are considering to use the GPL with a special exception
(like the <a
href="http://www.gnu.org/software/classpath/classpath.html">GNU
Classpath</a> project did.
The exception to the GPL would be:
<i>The library is distributed under the terms of the GNU General
Public License with the following exception:
If you link this library against your own program, then you do not
need to release the source code for that program. However, any
changes that you make to the library itself, or to any native
methods upon which the library relies, must be re-distributed in
accordance with the terms of the GPL.</i>
If you are going to contribute, please keep in mind that we
might require you to agree that Ximian might adjust the
license to enable the use of the class libraries on embedded
systems or to develop proprietary applications using Mono.
We suggest that you assign the copyright of your work to the
GNOME Foundation or the Free Software Foundation to simplify
defending the code in case it is used inappropiately.
** Class Library testing
@@ -156,26 +169,6 @@
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:
+16
View File
@@ -0,0 +1,16 @@
* 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.
-26
View File
@@ -1,26 +0,0 @@
* 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>.
-105
View File
@@ -1,105 +0,0 @@
* Class Library Documentation
** Summary
<em>
[This documentation is in progress. Comments to
<a href="mailto:[email protected]">[email protected]</a>.]
</em>
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.
+3
View File
@@ -1,5 +1,8 @@
* Contacting the Mono team.
You can contact the Mono Team by sending e-mail to `<a
href="mailto:[email protected]">[email protected]</a>'.
You can contact the general forum of discussion by sending
e-mail to <a href="mailto:[email protected]">[email protected]</a>
+28 -112
View File
@@ -18,65 +18,18 @@
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>
** 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
you only need Windows and the .NET Beta 2 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 want).
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.
*** 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>
Alternatively you can use the <a
href="#compile-service">compilation service</a> that was setup by
Derek.
** Bug reporting
@@ -87,27 +40,36 @@
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>MCS compilation process:</b> Currently MCS does
not build with a single `make' command. This should
be fixed (this being part of the `Joel Test' that
software has to pass).
* <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
<a name="compile-service">
* C# Compilation Service
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>
If you are working on a class for the Mono project, but do not
have a C# compiler available or a Windows machine to run the
.NET SDK, you can use the compilation service that Derek
Holden setup in the following URL: <a
href="http://toilet.2y.net:8080/">http://toilet.2y.net:8080/</a>
The service will let you compile a source file and get back a
list of errors in the class file. You will not be able to run
the code, but at least you can get some code written that will
help us further down the line.
You can contact (and thank) Derek for this service by sending
him nice email at <a
href="mailto:[email protected]">[email protected]</a>
* Books on C# and DotNet.
@@ -117,59 +79,13 @@
* 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/">
* O'Really 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
* Special note
If you have looked at Microsoft's implementation of .NET or
their shared source code, you may not be able to contribute
+17 -2
View File
@@ -31,5 +31,20 @@
** Class Library documentation
We are moving to a new setup for documenting the class libraries,
you can read about it <a href="classlib-doc.html">here</a>
When contributing to the Class Library effort, please use the
inline XML documentation tags to document your classes so we
can automatically generate the documentation from the class
libraries.
If you provide examples, please do not embed them into the
source code, as that will make the source code harder to read
and maintain. Instead, put examples for your code into a
subdirectory of the class libraries. Make your sample
code a full standalone application that people can compile.
Ideally the Mono documentation browser will let you edit, modify
and run the sample programs.
+99 -244
View File
@@ -2,7 +2,7 @@
The Virtual Execution System is available in package `mono'.
Currently this contains a metadata library and the
disassembler. Please refer to our <a
disassembler. Please reffer to our <a
href="runtime.html">Runtime</a> description for more details
on this part of the project.
@@ -10,261 +10,39 @@
test suite and the class library are in the `mcs' package, we
will move this later into `mono' itself.
In order to make mcs and the class libraries you will need a computer
running Windows with the <strong>GNU make tools</strong> from the
<strong>Cygwin</strong> environment, <strong>Microsoft's .NET Framework
SDK</strong>, <strong>GLIB 1.3</strong> and
<strong>pkg-config</strong>.
In order to make mcs and the class libraries you will need the
GNU make tools. These may be obtained for the Windows
environment from <a href="http://www.cygwin.com">cygwin.com</a>.
When installing Cygwin, don't forget to include
<tt>mingw-runtime</tt>. If you omit this, you will encounter
configure problems regarding not being able to generate
executables.
You will also need to get GLIB, from: <a
href="ftp://ftp.gtk.org/pub/gtk/v1.2/glib-1.2.10.tar.gz">ftp://ftp.gtk.org/pub/gtk/v1.2/glib-1.2.10.tar.gz</a>
<a name="sources">
*** 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/mcs/mcs/cfold.cs?cvsroot=Mono">here</a>
We provide both <a href="#packaged">packaged and tested</a>
tarballs (those are known to compile and pass `make
distcheck') as well as <a href="snapshots">daily snapshots</a> done
at 10pm Boston Time
<a name="feb-22">
<b>Mono 0.9</b>
New packaged versions of the Mono C# compiler and Mono runtime
are now available. The latest version is 0.9.
<ul>
* <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="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).
*** Snapshots
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.
The daily snapshots are available <a
href="http://www.go-mono.com/snapshots">here</a>. These
snapshots are done every day at 10pm EST (Boston Time).
You can download the GNU make tools and the Cygwin environment from
<a href="http://www.cygwin.com">www.cygwin.com</a>.
They 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.
You can download Microsoft's .NET Framework SDK from
<a href="http://msdn.microsoft.com/downloads">
msdn.microsoft.com/downloads</a>.
You might also want to track our development using the <a
href="http://mail.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list</a>
mailing list.
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:
<a name="packaged">
*** Released and tested packages
<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.
The script will download required packages from
www.go-mono.com and do a cvs checkout of mono in the current
directory. The cvs server chosen defaults to anonymous cvs;
set your CVSROOT environment variable before running the script to
select a particular cvs server.
<a name="install">
** Building the software manually
*** Download the required software.
<ul>
* 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 1.3 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>
*** Install Cygwin and the GNU build tools, Microsoft's .NET Framework SDK and the precompiled GLIB 1.3 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>
*** On Windows, to install and work on the compiler and the class libraries:
<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>
</ul>
*** 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>
*** On Unix, to compile the mono runtime:
<ul>
* Install <a href="http://www.freedesktop.org/software/pkgconfig">pkg-config</a>.
* Install glib 1.3. You can download it
from <a href="ftp://ftp.gtk.org/pub/gtk/v1.3/glib-1.3.12.tar.gz">ftp.gtk.org</a>. Maybe you need
to modify your ACLOCAL_FLAGS for pkg-config, for example if
your install prefix is /usr/local:
<pre>
<strong>export ACLOCAL_FLAGS="-I /usr/local/share/aclocal"</strong>
</pre>
* If you downloaded the Mono
<a href="http://www.go-mono.com/snapshots">nightly snapshots
</a>, untar the snapshot.
* Change directories to <strong>"mono"</strong>.
* Configure, compile and install:
<pre><strong>
./configure
make
make install</strong>
</pre>
</ul>
*** Notes on compiling GLIB 1.3 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/v1.3/glib-1.3.12.tar.gz">
glib 1.3</a> from source.
</ul>
<a name="oldreleases">
*** Very old releases.
<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>
@@ -330,3 +108,80 @@ make install</strong>
</ul>
</ul>
<a name="install">
** Installing the software
To install and work on the compiler and the class libraries,
follow these instructions:
<ul>
* Install <a href="http://www.cygwin.com">CygWin</a> first.
* Untar the MCS distribution (see below for information).
* Go into the MCS directory and type `make windows'
</ul>
To compile the mono runtime on windows:
<ul>
* Install <a href="http://www.cygwin.com">CygWin</a> first.
* Once installed, in a terminal window or a cygwin
window (a shortcut should be on your desktop), untar the glib
distribution:
<pre>
tar xzvf glib-1.2.10.tar.gz
</pre>
* Configure, compile and install glib, like this:
<pre>
./configure --prefix=/usr
make
make install
</pre>
* Unpack the mono distribution:
<pre>
tar xzvf mono-XXX.tar.gz
</pre>
* Configure, compile and install:
<pre>
./configure --prefix=//c/mono
make
make install
</pre>
* 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)
</ul>
To compile the mono runtime on Unix:
<ul>
* Download the mono distribution
* Unpack the mono distribution:
<pre>
tar xzvf mono-XXX.tar.gz
</pre>
* Configure, compile and install:
<pre>
./configure
make
make install
</pre>
</ul>
+431 -399
View File
File diff suppressed because it is too large. Load diff
+16 -9
View File
@@ -1,14 +1,5 @@
* 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.
@@ -51,6 +42,22 @@ TODO=multimedia
href="mailto:[email protected]">Vladimir</a> has
researched the problem before
TODO=gtk,Gtk+ wrappers for Mono and .NET
* Wrap the Gtk+ API. This is simple and can be done
on Windows as Gtk+ 2.0 works on Windows.
This work can also be used on Windows and will
enable developers on Windows to use some of Gtk+'s
advanced features.
The idea is to wrap the Gtk+ API and allow us to
build GUI applications using Gtk+ and in the future
other Gtk+-based libraries from Mono (Gal, GtkHTML).
There is extensive knowledge on wrapping Gtk+ in
other languages (this has been done this for Perl,
Python, Java, Scheme, Haskel and other languages in
the past).
</ul>
<a name="projects">
+5 -759
View File
@@ -1,6 +1,3 @@
<table>
<tr>
<td>
<a href="http://www.ximian.com">Ximian</a> announced the
launch of the Mono project, an effort to create an Open Source
implementation of the .NET Development Framework.
@@ -8,7 +5,7 @@
Mono includes: <a href="c-sharp.html">a compiler</a> for the
C# language, a <a href="runtime.html">runtime</a> for the
Common Language Infrastructure and a set of <a
href="class-library.html">class libraries</a>.
href="class-library.html">class libraries</a>
You can read our <a href="rationale.html">rationale</a> for
this project. If you have questions about the project, please
@@ -16,768 +13,46 @@
Questions</a> or <a href="mailto:[email protected]">contact us.</a>
You might also want to <a href="download.html">Download the
source</a> for our work so far. Grab a <a
href="snapshots">snapshot</a> of our current work, or <a
href="http://cvs.hispalinux.es/cgi-bin/cvsweb/?hidenonreadable=1&f=u&logsort=date&sortby=file&hideattic=1&cvsroot=Mono">browse
the sources</a>
source</a> for our work so far. Or you can grab a <a
href="snapshots">snapshot</a> of our current work.
You might want to <a
href="mailing-lists.html">subscribe</a> to our mono-list
href="resources.html#mailing">subscribe</a> to our mono-list
and mono-announce-list
You can contact the team at: <a
href="mailto:[email protected]">[email protected]</a>
</td>
<td>
<table border=1 bgcolor>
<tr>
</tr>
<tr>
<td>
<b><a href="c-sharp.html">C# Compiler</a></b>
</td>
<td>
Self hosting on Linux and Windows.
</td>
</tr>
<tr>
<td>
<b>JIT</b>
</td>
<td>
Linux/x86 working.
</td>
</tr>
<tr>
<td>
<b>Interpreter</b>
</td>
<td>
Working:<br>
Linux/x86, Linux/PPC<br>
In progress: StrongARM, SPARC.
</td>
</tr>
<tr>
<td>
<b><a href="class-status.html">Classes</a></b>
</td>
<td>
Corlib is self hosting.
</td>
</tr>
</table>
</td>
</tr>
</table>
** Mar 26, 2002
Paolo finally fixed the last bug in the JITer that stopped
us from using it to run the Mono C# compiler. Goodies are on
CVS.
<a href="http://gtk-sharp.sourceforge.net">Gtk#</a> runs <a
href="http://gtk-sharp.sourceforge.net/gtk-hello-world.png">Hello
World</a>
** Mar 19, 2002
Martin has been working on our debugging infrastructure, both
on the JIT side of things (adding dward support) as well as on
the class libraries (so that MCS can start generating
debugging information).
Jason and Kral keep working on the System.Xml namespace,
allowing Mike to move more to self-hosting his Gtk# code.
The System.Web classes are now part of the build (and they are
also part of the class status now). Ajay contributed a large
chunk of code to the System.Xml.Schema namespace
Dan (of regex fame) has been working on internal calls
support: moving more code from the old monowrapper to become
internal calls.
Paolo and Dietmar are working steadily on our runtime
environment, fixing bugs, adding missing features and allowing
us to run the compiler on Linux.
Remember to post your bug reports.
The nice class status on the right is brought to you by
endless hacking hours from Piers and Nick. These status
report pages have been helping us track down various mistakes
in our classes (very useful, check it out for yourself)
** Mar 12, 2002
At midnight, in Italy, Paolo got the Mono C# compiler to self
host on Linux, the last bug has been squashed to self
hostingness. We have now a fully self hosting compiler in Linux.
A release will follow up shortly.
** Mar 9, 2002
Updated the <a href="class-status.html">class status</a>, now
it is possible to use the right-side menu to browse a specific
assembly.
** Mar 7, 2002
MCS compiles on Linux!
Today Paolo got the <a
href="http://lists.ximian.com/archives/public/mono-list/2002-March/003726.html">MCS
compiler compiling itself on Linux</a>
completely for the first time! The resulting image still contains
some errors, but the whole compiler process goes now.
We are very close to have a complete self hosting environment now.
Mono is temporarly using the Bohem GC garbage collector while
we deploy the more advanced ORP one.
** Mar 5, 2002
The CVS repository <a href="http://cvs.hispalinux.es/cgi-bin/cvsweb/?hidenonreadable=1&f=u&logsort=date&sortby=file&hideattic=1&cvsroot=Mono">can be browsed</a>
Jason has got an incredible amount of work on the Xml
classes during the weekend, and Gaurav is very close to have
the complete System.Web.UI.WebControls namespace implemented.
Martin and Duco have been killing bugs by using the recently
revamped regression test suite.
Piers has updated our <a href="class-status.html">class
status</a> page again, with even more information available.
The C# compiler has full constant folding implemented now and Ravi
killed bugs of bugs in the <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">Mono Bug List</a>
** Mar 1, 2002
RPMs of Mono 0.9 are available at <a href="http://mono.baselabs.org/#download">mono.baselabs.com</a>
** Feb 28, 2002
<a
href="http://lists.ximian.com/archives/public/mono-list/2002-February/003464.html">Christophe</a>
has setup his <a href="http://mono.baselabs.org">First Steps in Mono</a> web site, which
shows you a step-by-step process on getting Mono running on your system.
RPMs of Mono 0.9 are available at <a href="http://mono.baselabs.org/index.php/software/">mono.baselabs.org</a>
** Feb 27, 2002
New <a href="class-status.html">class status</a> engine that
provides detailed information about missing functionality in
our class libraries. Nick built the cormissing tool and Piers
did the XSLT and DHTML magic.
More compiler progress on Linux: our support runtime now
enables the compiler to compile `MIS' on Linux (MIS being
Dick's Mono sample HTTP server ;-)
** Feb 26, 2002
Paolo posted a list of <a
href="http://lists.ximian.com/archives/public/mono-list/2002-February/003266.html">ways
you can help</a> if you do not have Windows right now. Sergey followed up with
<a href="http://lists.ximian.com/archives/public/mono-list/2002-February/003268.html">his</a>
suggestions.
** Feb 25, 2002
StrongARM port from Sergey Chaban has been checked into CVS.
** Feb 24, 2002
SPARC: 44 out of 74 tests pass now (Jeff)
Power PC: delegates are working now (Radek)
** Feb 22, 2002
<b>Mono 0.9 has been released!</b>
A new version of the runtime, compiler and class libraries has
been packaged for your download pleasure. The <a
href="archive/mono-0.9">Release Notes</a>
You can get it <a
href="download.html#feb-22">Here</a> (quick links: <a
href="archive/mono-0.9.tar.gz">runtime</a> and <a
href="archive/mcs-0.9.tar.gz">compiler/classes</a>).
** Feb 21, 2002
Paolo got our compiler natively to compile 117 of our tests.
Self hosting is closer every day.
Unsafe support is finished in the C# compiler.
** Feb 20, 2002
Gaurav got DataGrid and DataGridItemCollection done.
C# compiler: Unsafe support is mostly complete (only stackalloc is missing).
New easy to run scripts for compiling Mono on Unix and Windows
is <a href="download.html">available</a>. We can now easily compile
Mono on Windows and Linux. If you had trouble before, use the
above scripts which will get the setup right for you.
There are now three machines that can provide AnonCVS, just
use anoncvs.go-mono.com as the hostname for your CVSROOT and
you will get one of the machines.
** Feb 19, 2002
Do you want to see what <a href="http://people.debian.org/~lupus/mono/">Mono Looks Like?</a>
** Feb 18, 2002
Application Domains now support the two LoaderOptimization
modes: share code or do not share code, and you can control
this with the --share-code command line option.
Paolo has now 100+ test cases run on Linux now with our class
libraries.
PowerPC and SPARC ports are moving along (Radek and Jeff)
** Feb 13, 2002
Excellent news since the 11th, here is a quick rundown:
AppDomains have been deployed (Dietmar). Socket work is done
(Dick). Corlib compiled with no refs to mscorlib (Dan). New
comprehensive tests for colib bits (David). Nick is driving the
regression test suite efforts and class library completeness.
New System.Data work (Chris). Bug fixes (Paolo, Duncan, Ravi, Miguel)
Miguel is off to the <a
href="http://www.fosdem.org">FOSDEM</a> conference in Brussels.
** Feb 11, 2002
<b>Mono 0.8 has been released!</b>
A new version of the runtime, compiler and class libraries has
been packaged for your download pleasure.
You can get it <a
href="download.html#feb-11">Here</a> (quick links: <a
href="archive/mono-0.8.tar.gz">runtime</a> and <a
href="archive/mcs-0.8.tar.gz">compiler/classes</a>)
** Feb 11, 2002
We would like to welcome all the new developers that have
joined the project in the last couple of days. The classes
are rapidly moving.
An explanation of the relationship between <a
href="http://mail.gnome.org/archives/gnome-hackers/2002-February/msg00031.html">GNOME
and Mono</a>.
Nick is still leading our test suite platform. I can not
stress how important it is to have a good regression test suite
for our platform, as buggy class libraries are what are
stopping the compiler from running completely on Linux.
We are of course psyched to see Mono run on
non-Linux systems. Work is moving on native code generation
for StrongARM, PowerPC, and SPARC as well as porting Mono to
other systems.
There are a couple of debates on the Mono list on implementing
a set of web server classes for <a
href="http://lists.ximian.com/archives/public/mono-list/2002-February/002911.html">enabling
ASP.NET</a> on Mono.
Paolo also <a
href="http://lists.ximian.com/archives/public/mono-list/2002-February/002944.html">
posted a list of pending tasks</a> to enable the compiler to run on Linux
** Feb 10, 2002
Mike Kestner has posted an <a
href="http://lists.ximian.com/archives/public/gtk-sharp-list/2002-February/000024.html">Update
on his Gtk#</a> activities.
** Feb 4, 2002
Adam has done <a
href="http://lists.ximian.com/archives/public/mono-list/2002-February/002808.html">Qt
bindings</a> for .NET. Adam is cool.
** Jan 29, 2002
Dan Lewis has contributed a major missing set of classes to
Mono: <a
href="http://lists.ximian.com/archives/public/mono-list/2002-January/002745.html">
System.Text.RegularExpressions</a>.
This is a fully .NET compatible implementation of the .NET regular expressions,
fully Unicode aware. This contribution is very appreciated, as implementing this
was not entirely trivial (supporting Unicode, plus a regex engine which is a super
set of the Perl regex engine).
** Jan 28, 2002
The Mono contributors have relicensed the Class Libraries under
the terms of the
<a href="http://www.opensource.org/licenses/mit-license.html">MIT X11</a> license.
This license is an Open Source license, and is used by other projects
(most notably, the XFree86 project).
The runtime (JIT, metadata library, interpreter) remains under
the LGPL and the C# compiler remains under the GPL.
Our <a
href="http://www.ximian.com/about_us/press_center/press_releases/mono_partners.html">Press
Release</a>
Press coverage: <a
href="http://news.com.com/2100-1001-823734.html">CNet</a>, <a
href="http://www.wired.com/news/technology/0,1282,50037-2,00.html">Wired</a>,
<a href="http://www.infoworld.com/articles/hn/xml/02/01/28/020128hnopennet.xml">InfoWorld</a>,
<a href="http://www.newsforge.com/article.pl?sid=02/01/27/2232231">NewsForge</a>.
** Jan 23, 2002
New mailing list: <a href="mailto:[email protected]">[email protected]</a>.
This mailing list will receive automatically the patches that are submitted
to the Mono CVS to any of its modules.
This allows anyone who wants to participate in the peer-review of the
code submitted to CVS to receive patches on e-mail. It should also
expose to everyone the changes that are being done by the team every day.
** Jan 21, 2002
Dick has got a simple web server running with Mono (`MIS: Mono
Internet Server') that is mostly used to test our IO layer, a
<a href="http://primates.ximian.com/~miguel/dick-mis-server.png">screenshot</a>
Paolo and Dietmar are busy making our runtime self sufficient on
non-Windows platforms.
C# compiler front: A lot of focus in the past weeks after
the C# became self hosting has been in making the compiler a useful
tool for development: improve error handling, provide better error
reports, fixing all known bugs, and finally profiling of the compiler
has begun.
** Jan 8, 2002
Our compiler has been self-supporting since January 3rd. In
the meantime, we have been busy working on making it run on
Linux. Today Paolo got more work done on Reflection.Emit and
the compiler compiled `console.cs' (a sample Mono program) on
Linux.
** Jan 4, 2002
Dietmar landed the Unicode support patch. Class libraries and
runtimes are now fully Unicode aware. The details are <a href=
"http://lists.ximian.com/archives/public/mono-list/2002-January/002409.html">
here</a>
Last minute breaking news: Paolo got our compiler in Linux to
compile fib.cs, patches are comming tomorrow once we have
ChangeLog entries.
** Jan 4, 2002
Mike Kestner posted an update on Gtk# <a
href="http://lists.ximian.com/archives/public/gtk-sharp-list/2002-January/000021.html"><i>New
year, new direction</i></a>.
Gtk# will be our foundation on which we will be implementing
System.Windows.Forms.
** Jan 3, 2002
Mono C# compiler becomes self-sufficient. We can now continue
development of the compiler with itself.
Work on the class libraries is still underway for having a full
self hosting system. We hope to achieve our goal of self-hosting
on Linux before the end of the month.
Join the fun by downloading either tonight's <a
href="snapshots">snapshot</a> or getting your sources from our
<a href="anoncvs.html">Anonymous CVS server</a>.
** Dec 28, 2001
After a lot of work, the C# compiler can compile itself.
There are still errors in the generated image, but they are
being fixed quickly.
We will soon have the first non-Microsoft C# implementation!
** Dec 18, 2001
JIT: More work on our IO abstraction layer (Dick).
JIT: exception handling for unmanaged code (Dietmar)
System.Reflection: Support for PropertyInfo and
PropertyBuilder as well as the various queries for MethodBase.
C#: Pre-processor; Rewrite of MemberLookup which fixed many of
the outstanding issues. More bug fixing allows it to compile
more programs.
** Dec 14, 2001
Dietmar has improved the register allocation and now Mono performs
two to three times as fast as it did yesterday. Amazing.
The compiler keeps moving along, explicit interface
implementation is there.
** Dec 11, 2001
The JIT engine can now run all the compiler regression tests as
well as assorted other programs, many more opcodes added
recently. Currently the JIT engine uses a very simplistic register
allocator (just enough to allow us to focus on feature completeness)
and that will be the next major task to improve performance and
reduce spills and reloads.
On the C# compiler front: language features are now pretty
much complete. The big missing tasks are unsafe code support,
visibility, explicit interface implementation plus static flow
analysis. There are many small bugs that need to be addressed.
You can get your copy of the <a href="snapshots">latest Mono</a>
More work is also required on fixing the foundation class
libraries, it is easy to find spots now since Nick got the
`make test' going.
** Dec 1, 2001
AnonCVS access to Mono is here (updated every hour). Thanks
to <a href="http://www.hispalinux.es">HispaLinux</a> and Jesus
Climent for helping to set this up.
** Nov 30, 2001
All tests from the mono runtime work with the JIT engine now
(Dietmar).
Recursive enumeration definition in the C# compiler are
working now (Ravi).
More work on the Web classes (Gaurav).
** Nov 28, 2001
JIT land: Paolo got GDB support into the JIT engine while
Dietmar added exceptions support to it.
The C# compiler supports all array initializations now, and the
switch statement as well as fixing many existing bugs. Many
new more tests.
Nick keeps working on improving our class library test suite.
Dick has almost completed the Mono IO layer.
** Nov 16, 2001
<blockquote>
Mike Kestner has posted an <a
href="http://lists.ximian.com/archives/public/gtk-sharp-list/2001-November/000015.html">update</a>
on Gtk# development.
</blockquote>
** Nov 14, 2001
<blockquote>
Paolo today got the Mono C# compiler running <a
href="http://lists.ximian.com/archives/public/mono-list/2001-November/001941.html">on
Linux</a>. It compiles a sample program and then the sample
program is executed.
Mutator unary operators (++ and --) in the compiler are fully
functional, they used to only work on variables, and now they
are complete.
To sum things up: The Mono C# compiler is written in C# and
uses the .NET classes to get its work done. To make this work
on Linux work has to happen in various fronts:
<ul>
* The C# compiler is being worked on and can compile
many programs now (our test suite at this point is
made up of 40 tests).
* The class libraries need to be mature enough to support
the compiler, particularly System.Reflection.Emit (which is
what Paolo has been working on lately).
The compiler currently requires 103 classes from the
.NET runtime (you can get the list by running: <b>monodis --typeref mcs.exe</b>
* The interpreter should be mature enough to run the actual
compiler byte codes and the corlib bytecodes.
</ul>
At the same time, Dietmar is working on the JIT engine which will
replace our interpreter in production.
</blockquote>
** Nov 12, 2001
<blockquote>
Dietmar got value types working on the JIT engine. Sean has
got assembly loading in the runtime (required for NUnit).
More progress on enumerations and attributes from Ravi.
Nick keeps working on improving our class libraries.
</blockquote>
** Nov 8, 2001
<blockquote>
Enumerations, array access and attributes for the C# compiler are into the CVS now.
Full array support is not complete, but moving along.
</blockquote>
** Nov 5, 2001
<blockquote>
Dietmar's new set of patches to the JIT have 20 out of 33
tests running now.
</blockquote>
** Nov 4, 2001
<blockquote>
Mike Kestner, main Gtk# contributor has posted a very interesting <a
href="http://lists.ximian.com/archives/public/gtk-sharp-list/2001-November/000013.html">
update</a> on his work on Gtk#.
Ravi commited the initial support for Attributes in the
compiler.
Many HTML Controls from Leen checked into CVS.
Paolo checked in his new System.Reflection and
System.Reflection.Emit implementations. He has been working
steadily on this huge task for a few weeks now. This is the
foundation for the Mono C# compiler, and hence a very
important piece of the puzzle.
</blockquote>
** Nov 3, 2001
<blockquote>
Many clean ups have been going into the class library by Nick Drochak.
Mega patch from Dietmar: he commited the flow analysis code
for the JITer.
A lot of work has been going into the WebControls by Gaurav (4
new controls plus improved and bug fixed base classes).
</blockquote>
** Nov 1, 2001
<blockquote>
Ravi commited the caller-side method selection of methods with
variable length arguments. Now he depends on Miguel finishing
the array handling support.
</blockquote>
** Oct 27, 2001
<blockquote>
Lots of classes for System.Web from Gaurav were commited this
morning.
Some large recent developments:
The Decimal implementation from Martin Weindel has been
partially integrated (we need to put the internalcalls in
place now and compile and link the decimal code).
Derek Holden commited recently the IntegerFormatter code into
the CVS, so we got a pretty comprehensive integer formatting
engine that we can finally use all over the place.
Compiler got support for lock as well as assorted bug fixes.
Ravi is still working on array support (and then we can
optimize foreach for the array case).
Dietmar is busy working on flow analysis on the JITer, the
previous mechanism of generating the forest was wrong. Paolo
has been a busy bee reworking the System.Reflection.Emit
support code, and we should have some pretty nice stuff next
week. Dick on the other hand is still working on the
WaitOne/WaitAll emulation code. WaitAll is like select on
steroids: it can wait for different kinds of objects: files,
mutexes, events and a couple of others.
Mike Kestner is busy working on Gtk# which is now using the
.defs files to quickly wrap the API.
</blockquote>
** Oct 18, 2001
<blockquote>
Reworking expressions to support cleanly indexers and
properties. <a href="http://www.nat.org/evolution.php3">11
days</a> until Evolution 1.0 ships.
Ximian users around the world <!--a
href="http://www.bez.it/IMAGES/nora.jpg"-->rejoice<!--/a--> with
recent C# compiler progress.
</blockquote>
** Oct 17, 2001
<blockquote>
Delegate support has been checked into the compiler
(definition and invocation); break/continue implemented.
</blockquote>
** Oct 15, 2001
<blockquote>
JIT engine supports many of the object constructs now (object
creation, vtable setup, interface table setup).
The C# compiler now has almost full property support (only
missing bit are pre-post increment/decrement operations),
delegates are now created (still missing delegate invocation).
try/catch/finally is also supported in the compiler now.
System.Decimal implementation is in, as well as many crypto
classes.
</blockquote>
** Oct 5, 2001
<blockquote>
Sergey has released his first version of the <b>ilasm</b>
assembler written in C#. You can get it from his web page:
<a
href="http://mono.eurosoft.od.ua">http://mono.eurosoft.od.ua</a>.
The plan is to integrate ildasm into the Mono CVS soon. This
component should in theory also be reusable for SharpDevelop
eventually.
</blockquote>
** Oct 4, 2001
<blockquote>
Our System.Reflection.Emit implementation created its first
executable today. This means that a very simple .NET program
that was compiled on Windows was able to generate a .NET program
while running on Linux using the Mono runtime.
The various piece of the puzzle are starting to get together:
the compiler can compile simple programs now and we are
basically focusing on completeness now.
</blockquote>
** Sep 28, 2001
<blockquote>
<a
href="http://www.icsharpcode.net/OpenSource/SD/default.asp">Sharp
Develop 0.80</a> was released today.
</blockquote>
** Sep 26, 2001
<blockquote>
More progress: more opcodes are working (Paolo); The compiler
runs up to a point in Mint (Paolo); operator overloading works
(both unary and binary) all over the place (Miguel); Completed decimal
type conversions (Miguel); New build system in place based on
Ant (Sean and Sergey); Refactored and documented the
internals of the JIT engine (Dietmar); StatementExpressions
handled correctly (Miguel).
</blockquote>
** Sep 21, 2001
<blockquote>
A couple of news-worthy items: Dick got the initial thread
support into mint; Paolo implemented many new opcodes; Dietmar
got long operations and mul/div working on the JITer; Ravi rewrote
the Method selector for expressions to be conformant; Miguel
got i++ working. All in tonight's snapshot
</blockquote>
** Sep 19, 2001
<blockquote>
Paolo has written a section on <a href="porting.html">Porting
Mono</a> to othre architectures.
</blockquote>
** Sep 18, 2001
<blockquote>
<A a href="download.html#sep-18">Mono 0.7</a> has been
released (runtime engine, class libraries
and C# compiler). Check the <a href="archive/mono-0.7">Mono
0.7 announcement</a> for details
</blockquote>
** Sep 17, 2001
<blockquote>
Mike Kestner's Gtk# (Gtk-sharp) was checked into the CVS
repository. Gtk# can run a simple hello world application.
The binding is nice, as it maps Gtk+ signals to delegates in
C#. You can see the Gtk# Hello World program <a href="src/HelloWorld.cs">here</a>
Gtk-sharp should be available on the next snapshot set.
</blockquote>
** Sep 10, 2001
<blockquote>
Dietmar checked in his CIL tree/forest regeneration and most
importantly, the x86 instruction selector burg grammar.
</blockquote>
** Sep 5, 2001
<blockquote>
The MCS compiler <b>can compile the sample Hello World</b>
application and generate a Windows/CIL executable that runs!
This executable runs with the Mono Interpreter of course (see
August 28)
</blockquote>
** Sep 4, 2001
<blockquote>
Dietmar checked into CVS the `monoburg' architecture
independent instruction selector for the JIT engine.
</blockquote>
** Aug 28, 2001
<blockquote>
<b>.NET Hello World is working under Mono!</b> The latest snapshots
will let you run it.
@@ -785,78 +60,60 @@
performs 66 subroutine calls and loads 12 classes from the corlib.dll
Good work Mono team!
</blockquote>
** Aug 23, 2001
<blockquote>
Lloyd Dupont has announced his OpenGL bindings for C#, they
are available here: <a
href="http://csgl.sourceforge.net">http://csgl.sourceforge.net</a>
</blockquote>
** Aug 22, 2001
<blockquote>
New version of the Mono Runtime, Compiler and Classes has been
<a
href="download.html#august-22">released.</a> Check the <a
href="archive/mono-0.6">0.6 announcement</a>.
</blockquote>
** Aug 20, 2001
<blockquote>
A new <a href="contributing.html#compile-service">Compilation
service</a> has been made available by Derek to allow people
without access to the <a
href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml&frame=true">.NET SDK</a>
</blockquote>
** Aug 3, 2001
<blockquote>
Daily snapshots of mcs and mono are now available, they will
run every night at 10pm Boston time.
</blockquote>
** Jul 29, 2001
<blockquote>
Mono Runtime 0.5 has been <a
href="download.html#july-29">released.</a> Check the <a
href="archive/mono-0.5">release notes</a>
</blockquote>
** Jul 25, 2001
<blockquote>
The slides for <A href="Presentations/O-Reilly">my
presentation</a> at <a href="http://www.oreilly.com">O'Reilly
Open Source Software Convention</a>
</blockquote>
** Jul 22, 2001
<blockquote>
Another release of the class libraries is out, check the <a
href="archive/mcs-22">MCS 22-July Release Notes</a>. You can
get the new class libraries from <a
href="download.html#july-22">here</a>
</blockquote>
** Jul 19, 2001
<blockquote>
Another release of the class libraries is out, check the <a
href="archive/mcs-19">MCS 19-July Release Notes</a>. You can
get the new class libraries from <a
href="download.html#july-19">here</a>
</blockquote>
** Jul 17, 2001
<blockquote>
Another release of the class libraries is out, check the <a
href="archive/mcs-17">MCS 17-July Release Notes</a>. You can
get the new class libraries from <a
@@ -867,42 +124,31 @@
Got Sean's new <a href="class-status/index.html">Class
Status</a> web pages up. These are a lot better than mine, and
we are now keeping better track of contributors.
</blockquote>
** Jul 15, 2001
<blockquote>
Another release of Mono is out, check the <a
href="archive/mono-0.4">Mono 0.4 Release Notes</a>. Get it <a
href="download.html#july-15">here</a>.
</blockquote>
** Jul 14, 2001
<blockquote>
A <a
href="http://lists.ximian.com/archives/public/mono-list/2001-July/000399.html">new
href="http://mail.ximian.com/archives/public/mono-list/2001-July/000399.html">new
release</a> of the
runtime, compiler and classes has been made. Get it <a href="download.html#july-14">here</a>
</blockquote>
** Jul 12, 2001
<blockquote>
I keep getting questions about my opinion on Passport, even when
Mono has <b>nothing</b> to do with it. I finally <a
href="passport.html">wrote something.</a>
</blockquote>
** Jul 9, 2001
<blockquote>
Project launched.
</blockquote>
** O'Reilly
<blockquote>
Brian posted a story on <a
href="http://www.oreillynet.com/dotnet">O'Reilly Network .NET</a>
</blockquote>
-90
View File
@@ -1,90 +0,0 @@
* Mailing Lists
There are a number of mailing lists for Mono
<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-patches">mono-patches</a></b>
</td>
<td>
Track the development of Mono in realtime: receive patches to the Mono repository
by email.
</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>
-142
View File
@@ -1,142 +0,0 @@
#!/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
# 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"
-182
View File
@@ -1,182 +0,0 @@
#!/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
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 || 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
install_package gc6.0.tar.gz gc6.0 libgc
# 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"
-755
View File
@@ -1,755 +0,0 @@
* 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>
-55
View File
@@ -1,55 +0,0 @@
* JIT Compiler
<a
href="http://cui.unige.ch/OSG/publications/OO-articles/TechnicalReports/98/efficient.pdf">
Efficient Type Inclusion Tests: Jahn Vitek, R. Nigel Horspool, Andres
Krall</a>
<a
href="http://citeseer.nj.nec.com/rd/2822939%2C410249%2C1%2C0.25%2CDownload/http%253A%252F%252Fciteseer.nj.nec.com/cache/papers/cs/20094/http%253AzSzzSzwww.math.tau.ac.ilzSz%257EguyzSzjava-optzSzssa.pdf/cytron91efficiently.pdf">
Efficiently Computing Static Single Assignment Form and the Control
Dependence Graph: Ron Cytron, Jeanne Ferrante</a>
<a
href="http://citeseer.nj.nec.com/rd/14269422%2C217684%2C1%2C0.25%2CDownload/http%253A%252F%252Fciteseer.nj.nec.com/cache/papers/cs/9476/http%253AzSzzSzwww.cs.ucsb.eduzSzconferenceszSzjava98zSzpaperszSzcacao.pdf/krall98monitors.pdf">
Monitors and Exceptions - How to implement Java efficiently: Andreas Krall,
Mark Probst</a>
<a
href="http://citeseer.nj.nec.com/rd/78588775%2C217642%2C1%2C0.25%2CDownload/http%253A%252F%252Fciteseer.nj.nec.com/cache/papers/cs/9476/http%253AzSzzSzwww.complang.tuwien.ac.atzSzandizSzpact_98.pdf/krall98efficient.pdf">
Efficient JavaVM Just-in-Time Compilation: Andreas Krall</a>
<a
href="http://www.complang.tuwien.ac.at/andi/scicom_01.ps">Java for
Large-Scale Scientific Computations: Andreas Krall, Phillip Thomsich</a>
<a
href="http://citeseer.nj.nec.com/rd/62076894%2C117522%2C1%2C0.25%2CDownload/http%253A%252F%252Fciteseer.nj.nec.com/cache/papers/cs/642/ftp%253AzSzzSzftp.cs.princeton.eduzSzpubzSzlcczSzcontribzSziburg.pdf/fraser92engineering.pdf">
Engineering Simple, Efficient Code Generator Generator: Christopher
W. Fraser, David R. Hanson, Todd A. Proebsting</a>
<a
href="http://citeseer.nj.nec.com/rd/8408515%2C54698%2C1%2C0.25%2CDownload/http%253A%252F%252Fciteseer.nj.nec.com/cache/papers/cs/815/http%253AzSzzSzcuiwww.unige.chzSzOSGzSzpeoplezSzjvitekzSzResourceszSzArchivezSzProebsting.pdf/proebsting92code.pdf">
Code Generation Techniques: Todd Alan Proebsting</a>
* Register Allocation
<a
href="http://citeseer.nj.nec.com/rd/28309937%2C283402%2C1%2C0.25%2CDownload/http%253A%252F%252Fciteseer.nj.nec.com/cache/papers/cs/12458/http%253AzSzzSzwww.pdos.lcs.mit.eduzSzpaperszSztoplas-linearscan.pdf/poletto99linear.pdf">
Linear Scan Register Allocation: Massimiliano Poletto, Vivek Sarkar</a>
<a
href="http://citeseer.nj.nec.com/rd/19916683%2C91122%2C1%2C0.25%2CDownload/http%253A%252F%252Fciteseer.nj.nec.com/cache/papers/cs/468/http%253AzSzzSzwww.eecs.harvard.eduzSzhubezSzpaperszSzpldi98-binpack.pdf/traub98quality.pdf">
Quality and Speed in Linear-scan Register Allocation: Omri Traub, Glenn
Holloway, Michael D. Smith</a>
* Interpreter
<a
href="http://citeseer.nj.nec.com/rd/62076894%2C470069%2C1%2C0.25%2CDownload/http%253A%252F%252Fciteseer.nj.nec.com/cache/papers/cs/24640/http%253AzSzzSzwww.complang.tuwien.ac.atzSzpaperszSzertlzPz01.pdf/ertl01vmgen.pdf">
vmgen-A Generator of Efficient Virtual Machine Interpreters: M. Anton
Ertl, David Gregg, Andreas Krall, Bernd Paysan</a>
+1 -8
View File
@@ -1,12 +1,5 @@
* 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
@@ -256,7 +249,7 @@
A few people have said: `Mono will allow Passport to be
available for Linux and that is bad'. This is plain
misinformation.
missinformation.
Currently, you can obtain Passport for Linux from Microsoft
itself and deploy it today on your Web server. Mono does not
-246
View File
@@ -1,246 +0,0 @@
System.Object
System.Exception
System.ValueType
System.Delegate
System.MulticastDelegate
System.Enum
System.Activator
System.ArgIterator
System.__ComObject
System.TypedReference
System.Security.AllowPartiallyTrustedCallersAttribute
System.Runtime.Serialization.Formatter
System.Runtime.Serialization.FormatterConverter
System.Runtime.Serialization.FormatterServices
System.Runtime.Serialization.ObjectIDGenerator
System.Runtime.Serialization.ObjectManager
System.Reflection.ModuleResolveEventHandler
System.Reflection.Pointer
System.Globalization.CompareInfo
System.Globalization.HebrewCalendar
System.Globalization.HijriCalendar
System.Globalization.JapaneseCalendar
System.Globalization.KoreanCalendar
System.Globalization.SortKey
System.Globalization.StringInfo
System.Globalization.TaiwanCalendar
System.Globalization.TextElementEnumerator
System.Globalization.TextInfo
System.Globalization.ThaiBuddhistCalendar
System.IO.IsolatedStorage.IsolatedStorageFile
System.Reflection.Emit.MethodRental
System.Runtime.CompilerServices.AccessedThroughPropertyAttribute
System.Runtime.CompilerServices.CallConvCdecl
System.Runtime.CompilerServices.CallConvStdcall
System.Runtime.CompilerServices.CallConvThiscall
System.Runtime.CompilerServices.CallConvFastcall
System.Runtime.CompilerServices.CustomConstantAttribute
System.Runtime.CompilerServices.DateTimeConstantAttribute
System.Runtime.CompilerServices.DiscardableAttribute
System.Runtime.CompilerServices.DecimalConstantAttribute
System.Runtime.CompilerServices.CompilationRelaxationsAttribute
System.Runtime.CompilerServices.CompilerGlobalScopeAttribute
System.Runtime.CompilerServices.IDispatchConstantAttribute
System.Runtime.CompilerServices.IsVolatile
System.Runtime.CompilerServices.IUnknownConstantAttribute
System.Runtime.CompilerServices.RequiredAttributeAttribute
System.Runtime.InteropServices.ArrayWithOffset
System.Runtime.InteropServices.DispIdAttribute
System.Runtime.InteropServices.ClassInterfaceType
System.Runtime.InteropServices.ClassInterfaceAttribute
System.Runtime.InteropServices.ComVisibleAttribute
System.Runtime.InteropServices.LCIDConversionAttribute
System.Runtime.InteropServices.ComRegisterFunctionAttribute
System.Runtime.InteropServices.ComUnregisterFunctionAttribute
System.Runtime.InteropServices.ProgIdAttribute
System.Runtime.InteropServices.ImportedFromTypeLibAttribute
System.Runtime.InteropServices.IDispatchImplType
System.Runtime.InteropServices.IDispatchImplAttribute
System.Runtime.InteropServices.ComSourceInterfacesAttribute
System.Runtime.InteropServices.ComConversionLossAttribute
System.Runtime.InteropServices.TypeLibTypeFlags
System.Runtime.InteropServices.TypeLibFuncFlags
System.Runtime.InteropServices.TypeLibVarFlags
System.Runtime.InteropServices.TypeLibTypeAttribute
System.Runtime.InteropServices.TypeLibFuncAttribute
System.Runtime.InteropServices.TypeLibVarAttribute
System.Runtime.InteropServices.ComImportAttribute
System.Runtime.InteropServices.PreserveSigAttribute
System.Runtime.InteropServices.ComAliasNameAttribute
System.Runtime.InteropServices.AutomationProxyAttribute
System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute
System.Runtime.InteropServices.CoClassAttribute
System.Runtime.InteropServices.ComEventInterfaceAttribute
System.Runtime.InteropServices.COMException
System.Runtime.InteropServices.ComMemberType
System.Runtime.InteropServices.CurrencyWrapper
System.Runtime.InteropServices.DispatchWrapper
System.Runtime.InteropServices.ErrorWrapper
System.Runtime.InteropServices.ExtensibleClassFactory
System.Runtime.InteropServices.HandleRef
System.Runtime.InteropServices.InvalidComObjectException
System.Runtime.InteropServices.InvalidOleVariantTypeException
System.Runtime.InteropServices.TypeLibImporterFlags
System.Runtime.InteropServices.ExporterEventKind
System.Runtime.InteropServices.ITypeLibExporterNotifySink
System.Runtime.InteropServices.ITypeLibConverter
System.Runtime.InteropServices.MarshalDirectiveException
System.Runtime.InteropServices.ObjectCreationDelegate
System.Runtime.InteropServices.RuntimeEnvironment
System.Runtime.InteropServices.RegistrationServices
System.Runtime.InteropServices.SafeArrayRankMismatchException
System.Runtime.InteropServices.SafeArrayTypeMismatchException
System.Runtime.InteropServices.SEHException
System.Runtime.InteropServices.TypeLibConverter
System.Runtime.InteropServices.BIND_OPTS
System.Runtime.InteropServices.UCOMIBindCtx
System.Runtime.InteropServices.UCOMIConnectionPointContainer
System.Runtime.InteropServices.UCOMIConnectionPoint
System.Runtime.InteropServices.UCOMIEnumMoniker
System.Runtime.InteropServices.CONNECTDATA
System.Runtime.InteropServices.UCOMIEnumConnections
System.Runtime.InteropServices.UCOMIEnumConnectionPoints
System.Runtime.InteropServices.UCOMIEnumString
System.Runtime.InteropServices.UCOMIEnumVARIANT
System.Runtime.InteropServices.FILETIME
System.Runtime.InteropServices.UCOMIMoniker
System.Runtime.InteropServices.UCOMIPersistFile
System.Runtime.InteropServices.UCOMIRunningObjectTable
System.Runtime.InteropServices.STATSTG
System.Runtime.InteropServices.UCOMIStream
System.Runtime.InteropServices.DESCKIND
System.Runtime.InteropServices.BINDPTR
System.Runtime.InteropServices.UCOMITypeComp
System.Runtime.InteropServices.TYPEKIND
System.Runtime.InteropServices.TYPEFLAGS
System.Runtime.InteropServices.IMPLTYPEFLAGS
System.Runtime.InteropServices.TYPEATTR
System.Runtime.InteropServices.FUNCDESC
System.Runtime.InteropServices.IDLFLAG
System.Runtime.InteropServices.IDLDESC
System.Runtime.InteropServices.PARAMFLAG
System.Runtime.InteropServices.PARAMDESC
System.Runtime.InteropServices.TYPEDESC
System.Runtime.InteropServices.ELEMDESC
System.Runtime.InteropServices.VARDESC
System.Runtime.InteropServices.DISPPARAMS
System.Runtime.InteropServices.EXCEPINFO
System.Runtime.InteropServices.FUNCKIND
System.Runtime.InteropServices.INVOKEKIND
System.Runtime.InteropServices.CALLCONV
System.Runtime.InteropServices.FUNCFLAGS
System.Runtime.InteropServices.VARFLAGS
System.Runtime.InteropServices.UCOMITypeInfo
System.Runtime.InteropServices.SYSKIND
System.Runtime.InteropServices.LIBFLAGS
System.Runtime.InteropServices.TYPELIBATTR
System.Runtime.InteropServices.UCOMITypeLib
System.Runtime.InteropServices.UnknownWrapper
System.Runtime.Remoting.IObjectHandle
System.Runtime.Remoting.IRemotingTypeInfo
System.Runtime.Remoting.IChannelInfo
System.Runtime.Remoting.IEnvoyInfo
System.Runtime.Remoting.RemotingConfiguration
System.Runtime.Remoting.TypeEntry
System.Runtime.Remoting.ActivatedClientTypeEntry
System.Runtime.Remoting.ActivatedServiceTypeEntry
System.Runtime.Remoting.WellKnownClientTypeEntry
System.Runtime.Remoting.WellKnownServiceTypeEntry
System.Runtime.Remoting.RemotingException
System.Runtime.Remoting.ServerException
System.Runtime.Remoting.RemotingTimeoutException
System.Runtime.Remoting.RemotingServices
System.Runtime.Remoting.InternalRemotingServices
System.Runtime.Remoting.SoapServices
System.Runtime.Remoting.Activation.UrlAttribute
System.Runtime.Remoting.Messaging.IMessageSink
System.Runtime.Remoting.Messaging.AsyncResult
System.Runtime.Remoting.Messaging.CallContext
System.Runtime.Remoting.Messaging.ILogicalThreadAffinative
System.Runtime.Remoting.Messaging.InternalMessageWrapper
System.Runtime.Remoting.Messaging.IMethodCallMessage
System.Runtime.Remoting.Messaging.MethodCallMessageWrapper
System.Runtime.Remoting.Messaging.HeaderHandler
System.Runtime.Remoting.Messaging.IMessageCtrl
System.Runtime.Remoting.Messaging.IRemotingFormatter
System.Runtime.Remoting.Messaging.ReturnMessage
System.Runtime.Remoting.Messaging.MethodCall
System.Runtime.Remoting.Messaging.ConstructionCall
System.Runtime.Remoting.Messaging.MethodResponse
System.Runtime.Remoting.Messaging.ConstructionResponse
System.Runtime.Remoting.Messaging.MethodReturnMessageWrapper
System.Runtime.Remoting.Messaging.OneWayAttribute
System.Runtime.Remoting.Messaging.MessageSurrogateFilter
System.Runtime.Remoting.Messaging.RemotingSurrogateSelector
System.Runtime.Remoting.Contexts.CrossContextDelegate
System.Runtime.Remoting.Contexts.ContextProperty
System.Runtime.Remoting.Contexts.IContextPropertyActivator
System.Runtime.Remoting.Contexts.IContributeClientContextSink
System.Runtime.Remoting.Contexts.IContributeDynamicSink
System.Runtime.Remoting.Contexts.IContributeEnvoySink
System.Runtime.Remoting.Contexts.IContributeObjectSink
System.Runtime.Remoting.Contexts.IContributeServerContextSink
System.Runtime.Serialization.Formatters.InternalRM
System.Runtime.Serialization.Formatters.InternalST
System.Runtime.Serialization.Formatters.SoapMessage
System.Runtime.Serialization.Formatters.SoapFault
System.Runtime.Serialization.Formatters.ServerFault
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
System.Security.Cryptography.CryptoConfig
System.Security.Cryptography.KeyedHashAlgorithm
System.Security.Cryptography.HMACSHA1
System.Security.Cryptography.MACTripleDES
System.Security.Cryptography.MaskGenerationMethod
System.Security.Cryptography.PasswordDeriveBytes
System.Security.Cryptography.PKCS1MaskGenerationMethod
System.Security.Cryptography.RC2
System.Security.Cryptography.RC2CryptoServiceProvider
System.Security.Cryptography.RSACryptoServiceProvider
System.Security.Cryptography.RSAOAEPKeyExchangeDeformatter
System.Security.Cryptography.RSAOAEPKeyExchangeFormatter
System.Security.Cryptography.RSAPKCS1KeyExchangeDeformatter
System.Security.Cryptography.RSAPKCS1KeyExchangeFormatter
System.Security.Cryptography.RSAPKCS1SignatureDeformatter
System.Security.Cryptography.RSAPKCS1SignatureFormatter
System.Security.Cryptography.SHA1Managed
System.Security.Cryptography.TripleDES
System.Security.Cryptography.TripleDESCryptoServiceProvider
System.Security.Permissions.EnvironmentPermission
System.Security.Permissions.FileDialogPermission
System.Security.Permissions.IsolatedStorageFilePermission
System.Security.Permissions.PrincipalPermissionAttribute
System.Security.Permissions.SecurityPermissionAttribute
System.Security.Permissions.PublisherIdentityPermissionAttribute
System.Security.Permissions.PublisherIdentityPermission
System.Security.Permissions.ReflectionPermission
System.Security.Permissions.RegistryPermission
System.Security.Permissions.PrincipalPermission
System.Security.Permissions.SiteIdentityPermission
System.Security.Permissions.StrongNameIdentityPermission
System.Security.Permissions.StrongNamePublicKeyBlob
System.Security.Permissions.UIPermission
System.Security.Permissions.UrlIdentityPermission
System.Security.Permissions.ZoneIdentityPermission
System.Security.Policy.ApplicationDirectory
System.Security.Policy.ApplicationDirectoryMembershipCondition
System.Security.Policy.FirstMatchCodeGroup
System.Security.Policy.Hash
System.Security.Policy.HashMembershipCondition
System.Security.Policy.NetCodeGroup
System.Security.Policy.PermissionRequestEvidence
System.Security.Policy.Publisher
System.Security.Policy.PublisherMembershipCondition
System.Security.Policy.Site
System.Security.Policy.SiteMembershipCondition
System.Security.Policy.StrongName
System.Security.Policy.StrongNameMembershipCondition
System.Security.Policy.UnionCodeGroup
System.Security.Policy.Url
System.Security.Policy.UrlMembershipCondition
System.Security.Policy.Zone
System.Security.Policy.ZoneMembershipCondition
System.Security.Principal.WindowsIdentity
System.Security.Principal.WindowsImpersonationContext
System.Security.Principal.WindowsPrincipal
System.Threading.CompressedStack
-63
View File
@@ -1,63 +0,0 @@
* 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).
+1 -1
View File
@@ -18,7 +18,7 @@
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>.
href="http://www.ximian.com/tech/bonobo.php3">Bonobo</a>.
Interfaces to Bonobo exist for C, Perl, Python, and
Java.
+32 -54
View File
@@ -7,19 +7,6 @@
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:
@@ -30,41 +17,9 @@
<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:
You can get the documentation for the ECMA specs from a number of sites:
<ul>
* <a href="http://msdn.microsoft.com/net/ecma">At MSDN</a>
* <a href="http://www.dotnetexperts.com">Dot Net Experts</a>
@@ -86,6 +41,34 @@
You can also get this information if you install the Beta2
release of the .NET Framework.
<a name="mailing">
** Mailing Lists
There are a number of mailing lists for Mono
<ul>
* <b><a
href="http://mail.ximian.com/mailman/listinfo/mono-list">mono-list:</a></b>
The general Mono discussion list.
* <b><a
href="http://mail.ximian.com/mailman/listinfo/mono-announce-list">mono-announce-list:</a></b>
Announcements of Mono developments.
* <b><a
href="http://mail.ximian.com/mailman/listinfo/mono-gc-list">mono-gc-list:</a></b>
Discussion on the GC system of Mono.
* <b><a
href="http://mail.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list:</a></b>
Track the CVS activity of Mono on this mailing list. You can get <a href="http://www.go-mono.com/snapshots">daily snapshots</a> as well.
* <b><a
href="http://mail.ximian.com/mailman/listinfo/mono-docs-list">mono-docs-list:</a></b>
Discussion on the documentation of Mono.
* <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>
** Discussion Groups.
<ul>
@@ -114,8 +97,8 @@
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.
href="http://www.southern-storm.com.au/portable_net.html">Portable.NET:</a>
Another implementation of the CLI and C# compiler.
* <a href="http://nunit.sourceforge.net">NUnit:</a> A
testing framework for .NET classes.
@@ -126,13 +109,8 @@
* <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
* C# bindings for OpenGL 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.
</ul>
** GNOME Documentation
+50 -73
View File
@@ -1,112 +1,96 @@
* 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.
The Mono runtime will implement the JIT engine (and a byte
code interpreter for quickly porting 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 both runtimes are missing garbage collection. We
are planning on using the ORP GC engine and deploy it by
middle January.
* COM and XPCOM
We plan on adding support for XPCOM on Unix and COM on Microsoft
Windows later in our development process.
Currently the runtime has an image loader and metadata access
entry points. The runtime comes with a simple interpreter
that can execute very simple programs.
** 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.
GNU/Linux.
Our roadmap looks like this, this has been updated as of
<b>Dec 18, 2001</b>:
<b>Jul 15, 2001</b>:
<ul>
* Milestone 1: <b>Done</b> Fully read and parse all CIL byte-codes
* 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
* Milestone 2: 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 3: Define an <i>lburg</i>-like instruction
selector for the JITer for Intel. Although slower
at JITing than a streaming JITer, it generates
better code. The same grammar can later be used for
the stream jitter.
* 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 4: Implement JITer.
* Milestone 5: Port of the JITer to non IA32 systems.
</ul>
A setup similar to the Kaffe JIT engine will be used to
A setup similar to the Kaffe JIT engine can 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 should work 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).
Unix-like compilation environment.
** JIT Engine (<b>updated, March 26th, 2002</b>)
** JIT Engine (<b>updated, Jul 14th, 2001</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.
We will be using a code-generator generator approach for our
JITer. Given the properties of CIL byte codes, we can take
full advantage of a real instruction selector for our code
generator.
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>.
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:
Previously we had looked at a number of JIT engines and tools,
but they would not take full advantage of the CIL properties:
<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://www.intel.com/research/mrl/orp/">ORP</a>
* <a
href="http://www.gnu.org/software/lightning/">GNU
Lightning</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>
* <a href="http://www.eecs.harvard.edu/~nr/toolkit/">NJ Machine
Toolkit</a>.).
* VCODE.
</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 have decided to implement a generational tracing garbage
collector, which is very similar to the one being used by
.NET. For an introduction to the garbage collection system
used by Microsoft's CLR implementation, you can read this book
on <a
href="http://www.amazon.com/exec/obidos/ASIN/0471941484/o/qid=992556433/sr=2-1/ref=aps_sr_b_1_1/103-5866388-0492603">Garbage
Collection.</a>
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.
Another consideration is to use the same interface that ORP
uses to its Garbage Collection system and reuse that GC system
instead of rolling our own, as the ORP system is pretty advanced
and is independent of the rest of ORP.
Although using a conservative garbage collector like Bohem's
would work, all the type information is available at runtime,
@@ -130,15 +114,6 @@
<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:
@@ -163,5 +138,7 @@
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.
We hvae implemented PInvoke through libffi, but we are likely
going to roll our own system as the runtime matures, specially
as the interpreter is approaching completion, and we move into
the JITer.
+22 -24
View File
@@ -4,37 +4,35 @@
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.
* C# compiler: The C# parser can now generate parse
trees. Next up: semantic analysis, compiler lever optimizations
and code generation.
* The Mono JIT engine (<b>mono</b>. The JIT engine is
the real
virtual machine that we support. It is
functionaly currently, and we are improving its speed,
and making it feature complete.
* Metadata library: Can currently parse and load
information from .NET modules (executables and DLL
files).
* 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).
Parsing of Exception tables is missing.
* 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>.
<a href="class-status.html">Class Status page</a>
</ul>
Tasks on the critical path:
<ul>
* Bytecode interpreter: (Paolo is working on this).
* Simple JIT: Not implemented yet (Miguel is
researching the code-generator generator)
* Garbage collection engine (Dick is working on this, his contact is <a
href="mailto:[email protected]">[email protected]</a>
</ul>
If you want to work on any task here, please mail <a
href="mailto:[email protected]">[email protected]</a>
+2 -27
View File
@@ -1,12 +1,4 @@
* 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
* Testing
All classes in Mono libraries should have comprehensive unit test
suites to go with them. Unit testing is a software engineering
@@ -25,22 +17,5 @@
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">
href="http://nunit.sourceforge.net/doc/testinfected/testing.html">
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.
+1 -14
View File
@@ -3,29 +3,16 @@
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.Web,class-status-System.Web.html,class-status-System.Web.src,cm/cormissing.css,cm/cormissing.js
2,Class Status,class-status.html,class-status.src
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,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
0,Resources,resources.html,resources.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
0,Contact,contact.html,contact.src
-1
View File
@@ -1 +0,0 @@
*.html
Binary file not shown.

Before

Width:  |  Height:  |  Size: 150 B

-180
View File
@@ -1,180 +0,0 @@
.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_,
.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;
}
-396
View File
@@ -1,396 +0,0 @@
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 rgElts = getChildrenByTagName (elt, 'DIV');
var cElts = rgElts.length;
if (cElts == 0)
{
var rgImages = getChildrenByTagName (elt, 'IMG');
var cImages = rgImages.length;
for (var iImage = 0; iImage < cImages; iImage++)
{
var image = rgImages [iImage];
var strImage = trimSrc (rgImages [iImage].src);
if (dictTypes [strImage])
{
fView = true;
break;
}
}
}
else
{
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.

Before

Width:  |  Height:  |  Size: 137 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 861 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 111 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 90 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 90 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 101 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 65 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 111 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 73 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 127 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 70 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 73 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 76 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 101 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 73 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 49 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 64 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 67 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 92 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.8 KiB

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

Before

Width:  |  Height:  |  Size: 3.0 KiB

Binary file not shown.
Binary file not shown.

Before

Width:  |  Height:  |  Size: 49 B

Binary file not shown.
-2
View File
@@ -9,8 +9,6 @@ while (<>){
print "<h2>$1</h2>\n";
} elsif (/^\*\*\* (.*)$/) {
print "<h3>$1</h3>\n";
} elsif (/^\*\*\*\* (.*)$/) {
print "<h4>$1</h4>\n";
} elsif (/^$/) {
print "<p>\n";
} elsif (/^\t\t\* (.*)$/) {
+33 -82
View File
@@ -1,90 +1,41 @@
CSCRIPT = $(SYSTEMROOT)/system32/cscript.exe
SOURCES= \
../contributing \
../class-library \
../class-status \
../contact \
../c-sharp \
../ccvs \
../documentation \
../download \
../faq \
../gcc-frontend \
../index \
../ideas \
../passport \
../rationale \
../resources \
../roadmap \
../runtime \
../status \
../testing \
../tools
CORCOMPARE=../../../mcs/tools/corcompare
all:
-mkdir site
for i in $(SOURCES); do \
perl htmlify $$i > `basename $$i`.src; \
done;
OBJECTS= \
deploy/anoncvs.html \
deploy/contributing.html \
deploy/class-status.html \
deploy/class-status-corlib.html \
deploy/class-status-System.html \
deploy/class-status-System.Xml.html \
deploy/class-status-System.Data.html \
deploy/class-status-System.Web.html \
deploy/class-library.html \
deploy/classlib-doc.html \
deploy/contact.html \
deploy/c-sharp.html \
deploy/ccvs.html \
deploy/documentation.html \
deploy/download.html \
deploy/faq.html \
deploy/gcc-frontend.html \
deploy/index.html \
deploy/ideas.html \
deploy/mailing-lists.html \
deploy/monodoc-xml.html \
deploy/passport.html \
deploy/rationale.html \
deploy/resources.html \
deploy/roadmap.html \
deploy/runtime.html \
deploy/status.html \
deploy/testing.html \
deploy/porting.html \
deploy/tools.html \
deploy/books.html \
deploy/papers.html
NON_HTML_SOURCES= \
../mono-build.sh \
../mono-build-w32.sh
all: $(OBJECTS)
perl process.pl commands template.html.in deploy
perl process.pl commands template.html.in .
clean:
rm -f $(OBJECTS) $(patsubst deploy/%.html,src/%.src, $(OBJECTS)) src/*.xml src/*.html.in ../class-status-* ../class-status
for i in $(SOURCES); do \
rm -f `basename $$i`.src `basename $$i`.html; \
done;
push:
cp -f $(NON_HTML_SOURCES) deploy
echo scp -P 2200 -r deploy/* [email protected]:/web/cvsmodules/mono
(cd deploy; rsync --verbose --recursive --checksum --update --rsh='ssh -p 2200' . [email protected]:/web/cvsmodules/mono )
scp *.html [email protected]:/web/cvsmodules/mono
scp *.html [email protected]:/home/groups/m/mo/mononet/htdocs
push2:
scp -r deploy/* primates:public_html/xxx
$(OBJECTS): $(patsubst deploy/%.html,src/%.src, $(OBJECTS))
#.PRECIOUS: $(patsubst deploy/%.html,src/%.src, $(OBJECTS))
.PRECIOUS: src/%.src
src/%.src: ../% commands makefile template.html.in
perl htmlify $< > $@
.PRECIOUS: ../class-status-%
../class-status-%: src/%.html.in ../class-status.in
cat ../class-status.in $< > $@
.PRECIOUS: src/%.html.in
src/%.html.in: src/%.xml $(CORCOMPARE)/transform.js $(CORCOMPARE)/cormissing.xsl
$(CSCRIPT) /nologo $(CORCOMPARE)/transform.js $< $(CORCOMPARE)/cormissing.xsl > $@
.PRECIOUS: src/%.xml
src/%.xml: ../../../mcs/class/lib/%.dll $(CORCOMPARE)/CorCompare.exe
$(CORCOMPARE)/CorCompare.exe -x $@ $<
src/corlib.xml: ../../../mcs/class/lib/corlib_cmp.dll $(CORCOMPARE)/CorCompare.exe
$(CORCOMPARE)/CorCompare.exe -f corlib -ms mscorlib -x $@ $<
../class-status: ../class-status.in
cp -f $< $@
scp *.html primates:public_html/xxx
+30 -46
View File
@@ -23,10 +23,12 @@ while (<COMMANDS>) {
my @command = split /,/;
if ($command[0] != -1) {
$menu .= "\t\t";
$menu .= "<tr><td valign=\"top\" class=\"navi" . $command[0];
$menu .= "\"><a class=\"navi" . $command[0];
$menu .= "\"";
$menu .= "HREF=\"$command[2]\">$command[1]</A></td></tr>\n\n";
if ($command[0] == 0){
$menu .= "<tr><td valign=\"top\" class=\"navi\"><a class=\"navi\"";
} else {
$menu .= "<tr><td valign=\"top\" class=\"subnavi\">&nbsp;&nbsp;&nbsp<a class=\"subnavi\"";
}
$menu .= "HREF=\"$command[2]\">$command[1]</A></td></tr>\n\n";
}
}
close COMMANDS;
@@ -42,48 +44,30 @@ while (<COMMANDS>) {
chop;
my @command = split /,/;
if ($command[2] =~ /^http:/){
} else {
$n = $ARGV[2] . "/" . $command[2];
open OUTPUT, ">" . $n || die "Can not create $n";
my $content = "";
open INPUT, "src/$command[3]" || die "Can not open $command[3]";
while (<INPUT>) {
$content .= $_;
}
close INPUT;
my $line;
my $temp;
my $tit;
my $title;
my $css;
my $script;
$tit = $command[1];
$css = $command[4];
$script = $command[5];
$n = $ARGV[2] . "/" . $command[2];
open OUTPUT, ">" . $n || die "Can not create $n";
my $content = "";
open INPUT, $command[3] || die "Can not open $command[3]";
while (<INPUT>) {
$content .= $_;
}
close INPUT;
my $line;
my $temp;
my $tit;
my $title;
$tit = $command[1];
foreach $line (@template) {
$temp = $line;
$title = "$tit / Mono";
$temp =~ s/#TITLE#/$title/;
$temp =~ s/#CONTENT#/$content/;
$temp =~ s/#MENU#/$menu/;
print OUTPUT $temp;
}
foreach $line (@template) {
$temp = $line;
$title = "$tit / Mono";
$temp =~ s/#TITLE#/$title/;
$temp =~ s/#CONTENT#/$content/;
$temp =~ s/#MENU#/$menu/;
if ($css) {
$temp =~ s/#CSS#/<LINK rel="stylesheet" type="text\/css" href="$css">/;
} else {
$temp =~ s/#CSS#//;
}
if ($script) {
$temp =~ s/#SCRIPT#/<SCRIPT src="$script"><\/SCRIPT>/;
} else {
$temp =~ s/#SCRIPT#//;
}
print OUTPUT $temp;
}
}
close OUTPUT;
}
-1
View File
@@ -1 +0,0 @@
*.src
+10 -17
View File
@@ -7,29 +7,22 @@
background-image: url("images/bgsquares.gif");
background-attachment: fixed; }
body, td, table { font-family: "trebuchet ms", lucida, verdana, helvetica;
font-size: 14px; }
font-size: 12px; }
.navi0 { font-size: 14px; font-weight: bold; background: #444444; }
.navi1 { font-size: 14px; font-weight: bold; left-margin: 10pt}
.navi2 { font-size: 10px; font-weight: bold; left-margin: 20pt}
.footnote { font-size: 12px; color: #aaaaaa; }
.navi { font-size: 14px; background: #444444; }
.subnavi { font-size: 12px; }
.footnote { font-size: 10px; color: #aaaaaa; }
a.navi0 { color: #ffffff; text-decoration: none}
a.navi0:visited { color: #cccccc; }
a.navi0:hover { color: #ee9900; text-decoration: underline; }
a.navi { color: #ffffff; text-decoration: none; font-weight: bold; }
a.navi:visited { color: #cccccc; }
a.navi:hover { color: #ee9900; text-decoration: underline; }
a.navi1 { color: #ffffff; text-decoration: none; margin-left: 7px;}
a.navi1:visited { color: #cccccc; }
a.navi1:hover { color: #ee9900; text-decoration: underline; }
a.navi2 { color: #ffffff; text-decoration: none; margin-left: 20px;}
a.navi2:visited { color: #cccccc; }
a.navi2:hover { color: #ee9900; text-decoration: underline; }
a.subnavi { color: #ffffff; text-decoration: none; font-weight: bold; }
a.subnavi:visited { color: #cccccc; }
a.subnavi:hover { color: #ee9900; text-decoration: underline; }
// -->
</style>
#CSS#
#SCRIPT#
</head>
<body bgcolor="#555555" text="#000000">
-70
View File
@@ -1,70 +0,0 @@
Author: Dietmar Maurer ([email protected])
(C) 2001 Ximian, Inc.
Exception implementation (jit):
===============================
Stack unwinding:
================
We record the code address (start_address, size) of all methods. That way it is
possible to map an instruction pointer (IP) to the method information needed
for unwinding the stack:
We also save a Last Managed Frame (LMF) structure at each call from managed to
unmanaged code. That way we can recover from exceptions inside unmanaged code.
void handle_exception ((struct sigcontext *ctx, gpointer obj)
{
if (ctx->ip < mono_end_of_stack) {
/* unhandled exception */
abort ();
}
info = mono_jit_info_table_find (mono_jit_info_table, ctx->ip);
if (info) { // we are inside managed code
if (ch = find_catch_handler ())
execute_catch_handler (ch, ctx, obj);
execute_all_finally_handler ();
// restore register, including IP and Frame pointer
ctx = restore_caller_saved_registers_from_ctx (ji, ctx);
// continue unwinding
handle_exception (ctx, obj);
} else {
lmf = get_last_managed_frame ();
// restore register, including IP and Frame pointer
ctx = restore_caller_saved_registers_from_lmf (ji, lmf);
// continue unwinding
handle_exception (ctx, obj);
}
}
Code generation:
================
leave: is simply translated into a branch to the target. If the leave
instruction is inside a finally block (but not inside another handler)
we call the finally handler before we branch to the target.
finally/endfinally: is translated into subroutine ending with a "return"
statement. The subroutine does not save EBP/ESP, because we need access to the
local variables of the enclosing method. We have to use a "call"
instruction to execute such finally handlers. This makes it possible to
execute them inside the stack unwinding code.
throw: we first save all regs into a sigcontext struct (we pass the
exception object in register ECX), and then call the stack unwinding
code.
catch handler: receives the exception object in ECX. They store that
object into a local variable, so that rethrow can access the object.
-73
View File
@@ -1,73 +0,0 @@
How to use the debug support in the jit.
----------------------------------------
You need to run mono inside gdb. The following command line swicthes
are available:
--stabs
--dwarf
--debug className:methodName
--stabs will create an assemblyname-stabs.s file for each assembly the
CLR program uses. Note that to properly display source code lines,
you need to disassemble the CLR executables with monodis before running
mono. Each IL assembly file needs to have the name <assemblyname>.il.
--dwarf will create an assemblyname-dwarf.s file for each assembly the
CLR program uses. Note that to properly display source code lines,
you need to disassemble the CLR executables with monodis before running
mono. Each IL assembly file needs to have the name <assemblyname>.il.
--debug className:methodName will insert a breakpoin at the beginning of
methodName's code, so that control is trasnfered to the debugger as soon
as it is entered. You may use this switch multiple times.
So, suppose you use the --debug switch, or hit a segfault inside a
jitted method. In a shell you need to compile the stab/dwarf information
created with the --stabs or --dwarf option with the assembler:
as assemblyname-stabs.s -o assemblyname-stabs.o
or
as assemblyname-dwarf.s -o assemblyname-dwarf.o
Now, inside gdb, you can load the debug information with:
add-symbol-file assemblyname-stabs.o 0
or
add-symbol-file assemblyname-dwarf.o 0
And at this point the debugger should be able to print a correct
backtrace, you should be able to inspect method parameters and local
variables, disassemble methods and step through the code.
Using the DWARF 2 debugging format (with the --dwarf) argument is the
recommended one since it supports source files with more than 65.536
lines (for instance corlib.il) and you'll also get much better type
support with it. [FIXME: I'm still working on this, but it's already
making good progress. Martin].
However, some systems or debuggers may not support the DWARF 2 format,
in this case just use stabs.
Note that apparently you can't unload a symbol file from gdb, so you
need to restart it if you restart the program to debug.
Name mangling.
-------------
Currently CLR methods are exposed as C functions, so, if they are not
static, their first argument will be called 'this'.
Method names are mangled in the following way: a long name is created
concatting namespace, class name and method name. '.' chars are changed
to underscaore '_'. To allow for overloading, the address of the
MonoMethod from wich the method was created is appended to the end of
the name (i's also handy since you can use the address in gdb to inspect
the MonoMethod).
[This will change with DWARF 2 since this format is capable of storing
the full type name as it's seen by the programming language and doesn't
need any mangling. Martin]
+74 -48
View File
@@ -11,6 +11,50 @@ We are designing a JIT compiler, so we have to consider two things:
The current approach is to keep the JITer as simple as possible, and thus as
fast as possible. The generated code quality will suffer from that.
We do not map local variables to registers at the moment, and this makes the
whole JIT much easier, for example we do not need to identify basic block
boundaries or the lifetime of local variables, or select the variables which
are worth to put into a register.
Register allocation is thus done only inside the trees of the forest, and each
tree can use the full set of registers. We simply split a tree if we get out of
registers, for example the following tree:
add(R0)
/ \
/ \
a(R0) add(R1)
/ \
/ \
b(R1) add(R2)
/ \
/ \
c(R2) b(R3)
can be transformed to:
stloc(t1) add(R0)
| / \
| / \
add(R0) a(R0) add(R1)
/ \ / \
/ \ / \
c(R0) b(R1) b(R1) t1(R2)
Please notice that the split trees use less registers than the original
tree.
Triggering JIT compilation:
===========================
The current approach is to call functions indirectly. The address to call is
stored in the MonoMethod structure. For each method we create a trampoline
function. When called, this function does the JIT compilation and replaces the
trampoline with the compiled method address.
Register Allocation:
====================
@@ -19,6 +63,16 @@ allocation. For example this is needed by call, which return the value always
in EAX on x86. The current implementation works without such system, due to
special forest generation.
X86 Register Allocation:
========================
We can use 8bit or 16bit registers on the x86. If we use that feature we have
more registers to allocate, which maybe prevents some register spills. We
currently ignore that ability and always allocate 32 bit registers, because I
think we would gain very little from that optimisation and it would complicate
the code.
Different Register Sets:
========================
@@ -35,44 +89,26 @@ call class methods for ALU operations like add or sub. Sure, this method will
be be a bit inefficient.
The more performant solution is to allocate two 32bit registers for each 64bit
value. We add a new non terminal to the monoburg grammar called "lreg". The
value. We add a new non terminal to the monoburg grammar called long_reg. The
register allocation routines takes care of this non terminal and allocates two
32 bit registers for them.
registers for them.
Forest generation:
==================
Consider the following code:
It seems that trees generated from the CIL language have some special
properties, i.e. the trees already represents basic blocks, so there can be no
branches to the inside of such a tree. All results of those trees are stored to
memory.
OPCODE: STACK LOCALS
LDLOC.0 (5) [5,0]
LDC.1 (5,1) [5,0]
STLOC.0 (5) [1,0]
STLOC.1 () [1,5]
The current forest generation generates:
STLOC.0(LDC.1)
STLOC.1(LDLOC.0)
Which is wrong, since it stores the wrong value (1 instead of 5). Instead we
must generate something like:
STLOC.TMP(LDLOC.0)
STLOC.0(LDC.1)
STLOC.1(LDLOC.TMP)
Where STLOC.TMP saves the value into a new temporary variable.
We also need a similar solution for basic block boundaries when the stack depth
is not zero. We can simply save those values to new temporary values. Consider
the following basic block with one instruction:
LDLOC.1
This should generate a tree like:
STLOC.TMP(LDLOC.1) Please notice that an intelligent register allocator can
still allocate registers for those new variables.
One idea was to drive the code generation directly from the CIL code, without
generating an intermediate forest of trees. I think this is not possible,
because you always have to gather some attributes and attach it to the
instruction (for example the register allocation info). So I thing generating a
tree is the right thing and that also works perfectly with monoburg. IMO we
would not get any benefit from trying to feed monoburg directly with CIL
instructions.
DAG handling:
=============
@@ -105,21 +141,11 @@ STLOC(ADD (LDLOC, LDLOC))
This is what lcc is doing, if I understood 12.8, page 342, 343?
Possible Optimisations:
=======================
Value Types:
============
Miguel said ORP does some optimisation on IL level, for example moving array
bounds checking out of loops:
The only CLI instructions which can handle value types are loads and stores,
either to local variable, to the stack or to array elements. Value types with a
size smaller than sizeof(int) are handled like any other basic type. For other
value types we load the base address and emit block copies to store them.
for (i = 0; i < N; i++) { check_range (a, i); a [i] = X; }
id transformed to:
if (in_range (a, 0, N)) { for (i = 0; i < N; i++) a[i] = X; }
else for (i = 0; i < N; i++) { check_range (a, i); a [i] = X; }
The "else" is only to keep original semantics (exception handling).
We need loop detection logic in order to implement this (dominator tree).
AFAIK CACAO also implements this.
-52
View File
@@ -1,52 +0,0 @@
Author: Dietmar Maurer ([email protected])
(C) 2001 Ximian, Inc.
Howto trigger JIT compilation
=============================
The JIT translates CIL code to native code on a per method basis. For example
if you have this simple program:
public class Test {
public static void Main () {
System.Console.WriteLine ("Hello");
}
}
the JIT first compiles the Main function. Unfortunately Main() contains another
reference to System.Console.WriteLine(), so the JIT also needs the address for
WriteLine() to generate a call instruction.
The simplest solution would be to JIT compile System.Console.WriteLine()
to generate that address. But that would mean that we JIT compile half of our
class library at once, since WriteLine() uses many other classes and function,
and we have to call the JIT for each of them. Even worse there is the
possibility of cyclic references, and we would end up in an endless loop.
Thus we need some kind of trampoline function for JIT compilation. Such a
trampoline first calls the JIT compiler to create native code, and then jumps
directly into that code. Whenever the JIT needs the address of a function (to
emit a call instruction) it uses the address of those trampoline functions.
One drawback of this approach is that it requires an additional indirection. We
always call the trampoline. Inside the trampoline we need to check if the
method is already compiled or not, and when not compiled we start JIT
compilation. After that we call the code. This process is quite time consuming
and shows very bad performance.
The solution is to add some logic to the trampoline function to detect from
where it is called. It is then possible for the JIT to patch the call
instruction in the caller, so that it directly calls the JIT compiled code
next time.
Implementation for x86
======================
emit-x86.c (arch_create_jit_trampoline): return the JIT trampoline function
emit-x86.c (x86_magic_trampoline): contains the code to detect the caller and
patch the call instruction.
emit-x86.c (arch_compile_method): JIT compile a method
-63
View File
@@ -1,63 +0,0 @@
Author: Dietmar Maurer ([email protected])
(C) 2001 Ximian, Inc.
Object and VTable layout
========================
The first pointer inside an Object points to a MonoVtable structure. Objects
also contains a MonoThreadsSync structure which is used by the mono Thread
implementation.
typedef struct {
MonoVTable *vtable;
MonoThreadsSync synchronisation;
/* object specific data goes here */
} MonoObject;
The MonoVtable contains the vtable, interface offsets and a pointer to static
class data. Each object/vtable belongs to exactly one AppDomain.
typedef struct {
MonoClass *klass;
MonoDomain *domain;
gpointer *interface_offsets;
/* a pointer to static data */
gpointer data;
/* the variable sized vtable is included at the end */
gpointer vtable [0];
} MonoVTable;
The MonoClass contains domain independent Class infos.
typedef struct {
/* various class infos */
MonoClass *parent;
const char *name;
const char *name_space;
...
} MonoClass;
Calling virtual functions:
==========================
Each MonoMethod (if virtual) has an associated slot, which is an index into the
VTable. So we can use the following code to compute the address of a virtual
function:
method_addr = object->vtable->vtable [method->slot];
Calling interface methods:
==========================
Each interface class is associated with an unique ID. The following code
computes the address of an interface function:
method_addr = *(object->vtable->interface_offsets [interface_id] + method->slot*4);
-33
View File
@@ -1,33 +0,0 @@
Size and alignment requirements of stack values
===============================================
P ... System.IntPtr
I1 ... System.Int8
I2 ... System.Int16
I4 ... System.Int32
I8 ... System.Int64
F ... System.Single
D ... System.Double
LD ... native long double
-----------------------------------------------------------
ARCH | P | I1 | I2 | I4 | I8 | F | D | LD |
-----------------------------------------------------------
X86 | 4/4 | 4/4 | 4/4 | 4/4 | 8/4 | 4/4 | 8/4 |12/4 |
-----------------------------------------------------------
X86/W32 | 4/4 | 4/4 | 4/4 | 4/4 | 8/4 | 4/4 | 8/4 |12/4 |
-----------------------------------------------------------
ARM | 4/4 | 4/4 | 4/4 | 4/4 | 8/4 | 4/4 | 8/4 | 8/4 |
-----------------------------------------------------------
M68K | 4/4 | 4/4 | 4/4 | 4/4 | 8/4 | 4/4 | 8/4 |12/4 |
-----------------------------------------------------------
ALPHA | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 |
-----------------------------------------------------------
SPARC | 4/4 | 4/4 | 4/4 | 4/4 | 8/8 | 4/4 | 8/8 |16/8 |
-----------------------------------------------------------
SPARC64 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 |16/16|
-----------------------------------------------------------
MIPS | 4/4 | 4/4 | 4/4 | 4/4 | ?/? | 4/4 | 8/8 | 8/8 |
-----------------------------------------------------------
| | | | | | | | |
-----------------------------------------------------------
-135
View File
@@ -1,135 +0,0 @@
Author: Dietmar Maurer ([email protected])
(C) 2001 Ximian, Inc.
More about PInvoke and Internal calls
=====================================
1.) What is PInvoke
PInvoke stands for Platform Invoke. It is possible to call functions contained
in native shared libraries, for example you can declare:
[DllImport("cygwin1.dll", EntryPoint="puts"]
public static extern int puts (string name);
If you then call "puts(...)" it invokes the native "puts" functions in
"cygwin1.dll". It is also possible to specify several marshalling attributes
for the arguments, for example you can specify that they puts() function expect
ts the string in Ansi encoding by setting the CharSet attribute field:
[DllImport("cygwin1.dll", EntryPoint="puts", CharSet=CharSet.Ansi)]
public static extern int puts (string name);
2.) What are internal calls
Some class library functions are implemented in C, because it is either not
possible to implement them in C# or because of performance gains. Internal
functions are contained in the mono executable itself. Here is an example form
our array implementation:
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public extern int GetRank ();
If you call this GetRank() function it invokes
ves_icall_System_Array_GetRank() inside the mono runtime.
If you write your own runtime environment you can add internal calls with
mono_add_internal_call().
2.) Runtime considerations
Invoking native (unmanaged) code has several implications:
- We need to handle exceptions inside unmanaged code. The JIT simply saves some
informations at each transition from managed to unmanaged code (in a linked
list), called Last Managed Frame (LMF). If an exception occurs the runtime
first looks if the exception was inside managed code. If not there must be a
LMF entry which contains all necessary information to unwind the stack.
Creation of those LMF structure clearly involves some overhead, so calling
into unmanaged code is not as cheap as it looks like at first glance. Maybe
we can introduce a special attribute to avoid the creation of LMF on internal
call methods that cant raise exceptions.
- PInvoke has the possibility to convert argument types. For example Strings
are marshalled as Char*. So each String argument is translated into a
char*. The encoding is specified in the CharSet of the DllImport attribute.
3.) When/how does the runtime call unmanaged PInvoke code
- LDFTN, CALLI, Delegate::Invoke, Delegate::BeginInvoke: We must generate
wrapper code when we load the function with LDFTN, so that all arguments are
marshalled in the right format. We also need to save/restore the LMF.
- MethodBase::Invoke (runtime invoke): We need to marshal all arguments in
they right format and save/restore the LMF
- CALL: We need to marshal all arguments in they right format and save/restore
the LMF
The easiest way to implement this is to always create a wrapper function for
PInvoke calls, which takes care of argument marshalling and LMF save/restore.
4.) When/how does the runtime call unmanaged internal calls
We don't need to convert any arguments, so we need only take care of the LMF
structure.
- LDFTN, CALLI, Delegate::Invoke, Delegate::BeginInvoke: We must generate
wrapper code when we load the function with LDFTN which saves/restores the
LMF.
- MethodBase::Invoke (runtime invoke): We need to save/restore the LMF.
- CALL: We need to save/restore the LMF.
- CALLVIRT (through the vtable): We must generate wrapper code to save/restore
the LMF.
Please notice that we can call internal function with CALLVIRT, i.e. we can
call those function through a VTable. But we cant know in advance if a vtable
slot contains an internal call or managed code. So again it is best to generate
a wrapper functions for internal calls in order to save/restore the LMF.
Unfortunately we need to push all arguments 2 times, because we have to save
the LMF, and the LMF is currently allocated on the stack. So the stack looks
like:
--------------------
| method arguments |
--------------------
| LMF |
--------------------
| copied arguments |
--------------------
AFAIK this is the way ORP works. Another way is to allocate the LMF not on the
stack, but then we have additional overhead to allocate/free LMF structures
(and another call to arch_get_lmf_addr).
Maybe it is possible to avoid this addiotional copy for internal calls by
including the LMF in the C function signature. Lets say we hav a puts()
function which is a internal call:
ves_icall_puts (MonoString *string);
If we simply modify that to include the LMF we can avoid to copy all arguments:
ves_icall_puts (MonoLMF lmf, MonoString *string);
But this depends somehow on the calling conventions, and I don't know if that
works on all plattforms?
5.) What is stored in the LMF
- all caller saved registers (since we can trust unmanaged code)
- the instruction pointer of the last managed instruction
- a MonoMethod pointer for the unmanaged function
- the address of the thread local lfm_addr pointer (to avoid another call to
arch_get_lmf_addr when restoring LMF)
The LMF is allocated on the stack, so we also know the stack position for
stack unwinding.
-2
View File
@@ -1,2 +0,0 @@
Makefile
Makefile.in
-4
View File
@@ -1,4 +0,0 @@
man_MANS = mcs.1 mono.1
EXTRA_DIST = $(man_MANS)
-155
View File
@@ -1,155 +0,0 @@
.TH mcs 1 "6 January 2001"
.SH NAME
mcs \- Mono Compiler Suite.
.SH SYNOPSIS
.B mcs
[option] [source-files]
.SH DESCRIPTION
mcs is the Mono C# compiler, an implementation of the ECMA-334
language specification. You can pass one or more options to drive the
compiler, and a set of source files. Extra options or arguments can
be provided in a response file. Response files are referenced by
prepending the @ symbol to the response file name.
.PP
C# source files must end with a ".cs" extension. Compilation of C#
source code requires all the files that make up a library, module or
executable to be provided on the command line. There is no support
for partial compilation. To achieve the benefits of partial
compilation, you should compile programs into their own assemblies,
and later reference them with the "-r" flag.
.PP
The Mono C# compiler generates images (.exe files) that contain CIL
byte code that can be executed by any system that implements a Common
Language Infrastructure virtual machine such as the Microsoft .NET
runtime engine on Windows or the Mono runtime engine on Unix systems.
Executables are not bound to a specific CPU or operating system.
.PP
.SH OPTIONS
.TP
.I \-\-about
Displays information about the Mono C# compiler
.TP
.I \-\-checked
Sets the default compilation mode to `checked'. This makes all
the math operations checked (the default is unchecked).
.TP
.I \-\-define SYMBOL
Defines a symbol named SYMBOL. This can be tested in the source code
by the pre-processor.
.TP
.I \-\-debug or \-g
Generate debugging information.
.TP
.I \-\-fatal
This is used for debugging the compiler. This makes the error emission
generate an exception that can be caught by a debugger.
.TP
.I \-\-stacktrace
Generates a stack trace at the time the error is reported, useful for
debugging the compiler.
.TP
.I \-L PATH
Directs the compiler to look for libraries in the specified path.
Multiple paths can be provided.
.TP
.I \-\-nostdlib
Use this flag if you want to compile the core library. This makes the
compiler load its internal types from the assembly being compiled.
.TP
.I \-\-noconfig
Disables the default compiler configuration to be loaded. The
compiler by default has references to the system assemblies.
.TP
.I \-\-nowarn XXX
Makes the compiler ignore warning XXX.
.TP
.I \-o FNAME
Names the output file to be generated.
.TP
.I \-\-optimize
Turns on optimizations in the compiler.
.TP
.I \-\-parse
Used for benchmarking. The compiler will only parse its input files.
.TP
.I \-\-probe X L
Probes for the code to generate an error named `X' in line `L'. This
is only used by the test suite.
.TP
.I \-\-recurse PATTERN
Does recursive compilation using the specified pattern. In Unix the
shell will perform globbing, so you migth want to use it like this:
.PP
.nf
bash$ mcs --recurse '*.cs'
.fi
.TP
.I \-\-resource FILE
Adds FILE as a resource of the resulting assembly.
.TP
.I \-\-target KIND
Used to specify the desired target. The possible values are: exe,
winexe, library and module.
.TP
.I \-\-timestamp
Another debugging flag. Used to display the times at various points
in the compilation process.
.TP
.I \-\-unsafe
Enables compilation of unsafe code.
.TP
.I \-\-werror
Treat warnings as errors.
.TP
.I \-\-wlevel LEVEL
Sets the warning level. 0 is the lowest warning level, and 4 is the
highest. The default is 2.
.TP
.I \-r ASSEMBLY
Reference the named assembly. Use this to use classes from the named
assembly in your program. The assembly will be loaded from either the
system directory where all the assemblies live, or from the path
explicitly given with the -L option.
.TP
.I \-v
Debugging. Turns on verbose yacc parsing.
.TP
.I \-\-
Use this to stop option parsing, and allow option-looking parameters
to be passed on the command line.
.PP
.SH DEBUGGING SUPPORT
When use the "--debug" or "-g" flag, MCS will create an assembler file
FILE-debug.s containing debugging information where FILE is the name of
the generated assembly. You need to run this file through the assembler
to get a object file FILE-debug.o. See mono's "--dwarf-plus" argument
for details on how to use this file.
.SH NOTES
During compilation the MCS compiler defines the __MonoCS__ symbol,
this can be used by pre-processor instructions to compile Mono C#
compiler specific code.
.SH AUTHORS
The Mono C# Compiler was written by Miguel de Icaza and Ravi Pratap at
Ximian.
.PP
.SH LICENSE
The Mono Compiler Suite is released under the terms of the GNU GPL.
Please read the accompanying `COPYING' file for details. Alternative
licenses are available from Ximian.
.PP
.SH SEE ALSO
mono(1), mint(1)
.PP
.SH BUGS
To report bugs in the compiler, you can use `bug-buddy', or you can
file bug reports in our bug tracking system:
http://bugzilla.ximian.com.
.SH MAILING LIST
The Mono Mailing List is available at: [email protected]
.SH MORE INFORMATION
The Mono C# compiler is developed by Ximian, Inc
(http://www.ximian.com) (http://www.ximian.com) and is based on the
ECMA C# language standard available here:
http://www.ecma.ch/ecma1/STAND/ecma-334.htm
-79
View File
@@ -1,79 +0,0 @@
.\"
.\" mint manual page.
.\" (C) Ximian, Inc.
.\" Author:
.\" Miguel de Icaza ([email protected])
.\"
.TH Mono "Mono 1.0"
.SH NAME
mono \- Mono ECMA-CLI Just in Time compiler.
.SH SYNOPSIS
.PP
.B mono
[\-\-help] [\-d] [\-\-debug-asm] [\-\-debug-forest] [\-\-trace-calls]
[\-\-stabs] [\-\-compile cname] [\-\-ncompile num] [\-\-debug]
program.exe [arguments...]
.SH DESCRIPTION
The \fImono\fP program is a Just in Time compiler for ECMA CLI byte
codes. It translates dynamically a CIL stream into native code.
.I program.exe
and optionally passes
the
.I arguments
to it.
.SH OPTIONS
The following options are supported:
.TP
.I "--help", "-h"
Displays usage instructions.
.I "--share-code"
This mode makes the LoaderOptimization for Application Domains default
to sharing code. This results in slower code, but enables code
sharing across application domains. The default is to maximize for
speed, but disallow JITed code sharing across domains. See
System.LoaderOptimization for more information
.SH DEBUGGING OPTIONS
The following options are used to debug, or perfomance test the JIT
compiler:
.TP
.I "--trace-calls"
Shows method names as they are invoked.
.TP
.I "--dump-asm"
Displays the generated code as methods are invoked.
.TP
.I "--dump-forest"
Displays the basic blocks and the forest of trees that is
created from a stream of CIL opcodes.
.TP
.I "--stabs"
Writes out stabs debug information
.TP
.I "--dwarf"
Writes out dwarf debug information
.TP
.I "--dwarf-plus"
Uses an extended debugging information file which has been generated
by MCS. This extended debugging information will allow you to debug
C# source code rather than IL code. To use it, just run the JIT in
your debugger and call "mono_debug_make_symbols" each time the program
stops.
.TP
.I "--debug method"
Debugs the method whose name is `method'
.TP
.I "--compile"
Compiles the method on the given class (namespace.name:methodname).
.TP
.I "--ncompile"
Compiles the method a number of times. If no argument is specified,
the method will be compiled a thousand times.
.SH FILES
Assemblies are lodaed from the installation lib directory. If you set
`prefix' to /usr, the assemblies will be located in /usr/lib.
.SH MAILING LISTS
Visit http://mail.ximian.com/mailman/mono-list for details.
.SH WEB SITE
Visit: http://www.go-mono.com for details
.SH SEE ALSO
.BR mint(1), monodis(1)
-1
View File
@@ -2,7 +2,6 @@ C# Compiler:
Miguel de Icaza ([email protected])
Class Libraries:
Gaurav Vaish <[email protected]>
Jeff Stedfast ([email protected])
Joe Shaw ([email protected])
Miguel de Icaza ([email protected])
-21
View File
@@ -1,21 +0,0 @@
2002-03-26 Dick Porter <[email protected]>
* makefile (linux): Abandon the build if any of the subdir makes fail
2002-03-07 Nick Drochak <[email protected]>
* makefile: Change order of build so corlib is built before nunit since
Nunit needs corlib now.
2002-02-14 Nick Drochak <[email protected]>
* makefile: Build mcs/doctools too when one does 'make'
2002-01-20 Nick Drochak <[email protected]>
* on the 'test' target, make sure NUnit is built first before building
and running tests
2002-01-20 Nick Drochak <[email protected]>
* add nunit directory to the list of dirs to build in
+1 -3
View File
@@ -18,6 +18,4 @@ Layout:
tests/
Sample tests
Thanks a lot to Sergey Chaban for his help during the development of
the C# compiler.
-1
View File
@@ -1 +0,0 @@
lib
@@ -1,163 +0,0 @@
//
// Mono.CSharp.Debugger/AssemblerWriterI386.cs
//
// Author:
// Martin Baulig ([email protected])
//
// IAssemblerWriter implementation for the Intel i386.
//
// (C) 2002 Ximian, Inc. http://www.ximian.com
//
using System;
using System.IO;
namespace Mono.CSharp.Debugger
{
public class AssemblerWriterI386 : IAssemblerWriter
{
public AssemblerWriterI386 (StreamWriter writer) {
this.writer = writer;
}
private StreamWriter writer;
private static int next_anon_label_idx = 0;
public void WriteLabel (string label)
{
writer.WriteLine (".L_" + label + ":");
}
public int GetNextLabelIndex ()
{
return ++next_anon_label_idx;
}
public int WriteLabel ()
{
int index = GetNextLabelIndex ();
WriteLabel (index);
return index;
}
public string GetLabelName (int index)
{
return index.ToString ();
}
public void WriteLabel (int index)
{
WriteLabel (GetLabelName (index));
}
public void WriteUInt8 (bool value)
{
writer.WriteLine ("\t.byte\t\t" + (value ? 1 : 0));
}
public void WriteUInt8 (int value)
{
writer.WriteLine ("\t.byte\t\t" + value);
}
public void WriteInt8 (int value)
{
writer.WriteLine ("\t.byte\t\t" + value);
}
public void WriteUInt16 (int value)
{
writer.WriteLine ("\t.2byte\t\t" + value);
}
public void WriteInt16 (int value)
{
writer.WriteLine ("\t.2byte\t\t" + value);
}
public void WriteUInt32 (int value)
{
writer.WriteLine ("\t.long\t\t" + value);
}
public void WriteInt32 (int value)
{
writer.WriteLine ("\t.long\t\t" + value);
}
public void WriteSLeb128 (int value)
{
writer.WriteLine ("\t.sleb128\t" + value);
}
public void WriteULeb128 (int value)
{
writer.WriteLine ("\t.uleb128\t" + value);
}
public void WriteAddress (int value)
{
writer.WriteLine ("\t.long\t\t" + value);
}
public void WriteString (string value)
{
writer.WriteLine ("\t.string\t\t\"" + value + "\"");
}
public void WriteSectionStart (String section)
{
writer.WriteLine ("\t.section\t." + section);
}
public void WriteSectionEnd ()
{
writer.WriteLine ("\t.previous\n");
}
public void WriteRelativeOffset (string start_label, string end_label)
{
writer.WriteLine ("\t.long\t\t.L_" + end_label + " - .L_" + start_label);
}
public void WriteShortRelativeOffset (string start_label, string end_label)
{
writer.WriteLine ("\t.byte\t\t.L_" + end_label + " - .L_" + start_label);
}
public void WriteAbsoluteOffset (string label)
{
writer.WriteLine ("\t.long\t\t.L_" + label);
}
public object StartSubsectionWithSize ()
{
int start_index = GetNextLabelIndex ();
int end_index = GetNextLabelIndex ();
WriteRelativeOffset (GetLabelName (start_index), GetLabelName (end_index));
WriteLabel (start_index);
return end_index;
}
public object StartSubsectionWithShortSize ()
{
int start_index = GetNextLabelIndex ();
int end_index = GetNextLabelIndex ();
WriteShortRelativeOffset (GetLabelName (start_index), GetLabelName (end_index));
WriteLabel (start_index);
return end_index;
}
public void EndSubsection (object end_index)
{
WriteLabel ((int) end_index);
}
}
}
-95
View File
@@ -1,95 +0,0 @@
2002-03-25 Martin Baulig <[email protected]>
* MonoDwarfFileWriter.cs (CreateType): Return a `DieType'.
(RegisterType): Add the type to the type hash before creating dependency types
so we don't get recursion loops.
(RegisterPointerType): New func to register a "pointer to type" type.
(DieTypeDef, DiePointerType, DieArrayType, DieStringType, DieClassType): New
types; added support for strings, arrays and basic support for classes.
2002-03-24 Martin Baulig <[email protected]>
* IMonoSymbolWriter.cs: Killed all methods in this interface, no longer needed.
* MonoSymbolWriter.cs (MonoSymbolWriter): The constructor now takes a string
argument which is the full pathname of the assembly - you must call Close()
after the assembly has been written to disk since the symbol writer needs to
load the finished assembly to get its metadata.
* MonoDwarfFileWriter.cs: Added support for enums and structs.
2002-03-24 Martin Baulig <[email protected]>
* MonoDwarfFileWriter.cs: Added support for method parameters.
2002-03-24 Martin Baulig <[email protected]>
* IMonoSymbolWriter.cs (IMonoSymbolWriter): Removed my custom OpenMethod(),
we're now using the ISymbolWriter's method.
(IVariable): Added `byte[] Signature' property.
* MonoSymbolWriter.cs (SetAssembly): New method. This must be called before
Close(); the assembly parameter is the already-written assembly, ie. it must
contain the full metadata.
(OpenMethod): Only take the token argument and set MethodInfo later in DoFixups.
(SetMethodSourceRange): You must call this function to tell the symbol writer
in which source file the method is defined.
(DefineLocal): Store the signature in the local.
(DoFixups): Use two new interncalls to set the SourceMethod's MethodInfo field
and the LocalVariable's Type field.
2002-03-23 Martin Baulig <[email protected]>
* IMonoSymbolWriter.cs (ISourceBlock): New interface.
(ILocalVariable): Renamed this interface to IVariable.
(IVariable): Added Line, Type, Token.
(ILocalVariable, IMethodParameter): New interfaces, derive from IVariable.
(ISourceMethod): Added Blocks. Renamed FirstLine and LastLine to Start and End,
changed their type to ISourceLine. Removed CodeSize.
(ISourceLine): Renamed Line to Row, added Column. Added OffsetType and Offset.
* MonoDwarfFileWriter.cs (MonoDwarfFileWriter.DieLexicalBlock): New class.
(MonoDwarfFileWriter.DieMethodVariable): New class.
* MonoSymbolWriter.cs (OpenScope, CloseScope): Implemented.
Reflected latest IMonoSymbolWriter interface changes.
2002-03-20 Martin Baulig <[email protected]>
* IAssemblerWriter.cs: New interface.
* AssemblerWriterI386.cs: New class.
* MonoDwarfFileWriter.cs: Use the IAssemblerWriter interface to make this class
platform and assembler independent.
2002-03-20 Martin Baulig <[email protected]>
* IMonoSymbolWriter.cs (ISourceMethod): Added FirstLine, LastLine, CodeSize and
Token properties.
* MonoDwarfFileWriter.cs: Implemented line number support.
2002-03-19 Martin Baulig <[email protected]>
* IMonoSymbolWriter.cs (ISourceFile, ISourceMethod, ISourceLine, ILocalVariable):
New interfaces.
* IMonoSymbolWriter.cs (OpenMethod): Take a System.Reflection.MethodInfo, not
a string.
2002-03-19 Martin Baulig <[email protected]>
This is an implementation of the System.Diagnostics.SymbolStore.SymbolWriter
interface. It's still work in progress and not yet used anywhere.
There is some preliminary documentation in the source files and some more
docu in the README and README.relocation-table files.
* IMonoSymbolWriter.cs: New file.
* MonoDwarfFileWriter.cs: New file.
* MonoSymbolDocumentWriter.cs: New file.
* MonoSymbolWriter.cs: New file.
* README, README.relocation-table: Documentation.
@@ -1,68 +0,0 @@
//
// Mono.CSharp.Debugger/IAssemblerWriter.cs
//
// Author:
// Martin Baulig ([email protected])
//
// This is a platform and assembler independent assembler output interface.
//
// (C) 2002 Ximian, Inc. http://www.ximian.com
//
using System;
using System.Collections;
using System.IO;
namespace Mono.CSharp.Debugger
{
public interface IAssemblerWriter
{
int GetNextLabelIndex ();
string GetLabelName (int index);
void WriteLabel (int index);
void WriteLabel (string label);
int WriteLabel ();
void WriteUInt8 (bool value);
void WriteUInt8 (int value);
void WriteInt8 (int value);
void WriteUInt16 (int value);
void WriteInt16 (int value);
void WriteUInt32 (int value);
void WriteInt32 (int value);
void WriteSLeb128 (int value);
void WriteULeb128 (int value);
void WriteAddress (int value);
void WriteString (string value);
void WriteSectionStart (String section);
void WriteSectionEnd ();
void WriteRelativeOffset (string start_label, string end_label);
void WriteShortRelativeOffset (string start_label, string end_label);
void WriteAbsoluteOffset (string label);
object StartSubsectionWithSize ();
object StartSubsectionWithShortSize ();
void EndSubsection (object end_index);
}
}
@@ -1,161 +0,0 @@
//
// System.Diagnostics.SymbolStore/IMonoSymbolWriter.cs
//
// Author:
// Martin Baulig ([email protected])
//
// This interface is derived from System.Diagnostics.SymbolStore.ISymbolWriter.
//
// (C) 2002 Ximian, Inc. http://www.ximian.com
//
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Diagnostics.SymbolStore;
using System.Collections;
using System.IO;
namespace Mono.CSharp.Debugger
{
public interface IMonoSymbolWriter : ISymbolWriter
{ }
public interface ISourceFile
{
string FileName {
get;
}
ISourceMethod[] Methods {
get;
}
void AddMethod (ISourceMethod method);
}
public interface ISourceMethod
{
ISourceLine[] Lines {
get;
}
void AddLine (ISourceLine line);
ISourceBlock[] Blocks {
get;
}
ILocalVariable[] Locals {
get;
}
void AddLocal (ILocalVariable local);
ISourceLine Start {
get;
}
ISourceLine End {
get;
}
int Token {
get;
}
MethodInfo MethodInfo {
get;
}
ISourceFile SourceFile {
get;
}
}
public interface ISourceBlock
{
ISourceMethod SourceMethod {
get;
}
ILocalVariable[] Locals {
get;
}
void AddLocal (ILocalVariable local);
ISourceLine Start {
get;
}
ISourceLine End {
get;
}
int ID {
get;
}
}
public enum SourceOffsetType
{
OFFSET_NONE,
OFFSET_IL,
OFFSET_LOCAL,
OFFSET_PARAMETER
}
public interface ISourceLine
{
SourceOffsetType OffsetType {
get;
}
int Offset {
get;
}
int Row {
get;
}
int Column {
get;
}
}
public interface IVariable
{
string Name {
get;
}
ISourceLine Line {
get;
}
byte[] Signature {
get;
}
Type Type {
get;
}
int Token {
get;
}
int Index {
get;
}
}
public interface ILocalVariable : IVariable
{ }
public interface IMethodParameter : IVariable
{ }
}
@@ -1,24 +0,0 @@
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- NAnt build file for Mono.CSharp.Debugger.dll -->
<project name="Mono.CSharp.Debugger" default="build">
<property name="debug" value="false"/>
<target name="build">
<csc target="library" output="../lib/Mono.CSharp.Debugger.dll" debug="${debug}">
<arg value="/nowarn:1595"/>
<arg value="/unsafe"/>
<sources>
<includes name="**/*.cs"/>
<excludes name="Test/**"/>
</sources>
<references>
<includes name="../lib/corlib.dll"/>
</references>
</csc>
</target>
<target name="clean">
<delete file="../lib/Mono.CSharp.Debugger.dll" failonerror="false"/>
</target>
</project>
File diff suppressed because it is too large. Load diff
@@ -1,60 +0,0 @@
//
// System.Diagnostics.SymbolStore/MonoSymbolDocumentWriter.cs
//
// Author:
// Martin Baulig ([email protected])
//
// This is the default implementation of the
// System.Diagnostics.SymbolStore.ISymbolDocumentWriter interface.
//
// (C) 2002 Ximian, Inc. http://www.ximian.com
//
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Diagnostics.SymbolStore;
using System.IO;
namespace Mono.CSharp.Debugger
{
public class MonoSymbolDocumentWriter : ISymbolDocumentWriter
{
protected string url;
//
// Constructor
//
public MonoSymbolDocumentWriter (string url)
{
this.url = url;
}
public string FileName {
get {
return url;
}
}
//
// Interface ISymbolDocumentWriter
//
//
// MonoSymbolWriter creates a DWARF 2 debugging file and DWARF operates
// on file names, but has no way to include a whole source file in the
// symbol file.
//
public void SetCheckSum (Guid algorithmId, byte[] checkSum)
{
throw new NotSupportedException ();
}
public void SetSource (byte[] source)
{
throw new NotSupportedException ();
}
}
}
@@ -1,692 +0,0 @@
//
// System.Diagnostics.SymbolStore/MonoSymbolWriter.cs
//
// Author:
// Martin Baulig ([email protected])
//
// This is the default implementation of the System.Diagnostics.SymbolStore.ISymbolWriter
// interface.
//
// (C) 2002 Ximian, Inc. http://www.ximian.com
//
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Diagnostics.SymbolStore;
using System.Collections;
using System.IO;
namespace Mono.CSharp.Debugger
{
public class MonoSymbolWriter : IMonoSymbolWriter
{
protected Assembly assembly;
protected string output_filename = null;
protected ArrayList locals = null;
protected ArrayList orphant_methods = null;
protected Hashtable methods = null;
protected Hashtable sources = null;
protected class SourceFile : ISourceFile
{
private ArrayList _methods = new ArrayList ();
private string _file_name;
public SourceFile (string filename)
{
this._file_name = filename;
}
public override string ToString ()
{
return _file_name;
}
// interface ISourceFile
public string FileName {
get {
return _file_name;
}
}
public ISourceMethod[] Methods {
get {
ISourceMethod[] retval = new ISourceMethod [_methods.Count];
_methods.CopyTo (retval);
return retval;
}
}
public void AddMethod (ISourceMethod method)
{
_methods.Add (method);
}
}
protected class SourceBlock : ISourceBlock
{
static private int next_index;
private readonly int _index;
public SourceBlock (ISourceMethod method, ISourceLine start, ISourceLine end)
{
this._method = method;
this._start = start;
this._end = end;
this._index = ++next_index;
}
internal SourceBlock (ISourceMethod method, int startOffset)
{
this._method = method;
this._start = new SourceLine (startOffset);
this._index = ++next_index;
}
public override string ToString ()
{
return "SourceBlock #" + ID + " (" + Start + " - " + End + ")";
}
private readonly ISourceMethod _method;
internal ISourceLine _start;
internal ISourceLine _end;
private ArrayList _locals = new ArrayList ();
public ISourceMethod SourceMethod {
get {
return _method;
}
}
public ISourceLine Start {
get {
return _start;
}
}
public ISourceLine End {
get {
return _end;
}
}
public int ID {
get {
return _index;
}
}
public ILocalVariable[] Locals {
get {
ILocalVariable[] retval = new ILocalVariable [_locals.Count];
_locals.CopyTo (retval);
return retval;
}
}
public void AddLocal (ILocalVariable local)
{
_locals.Add (local);
}
}
protected class SourceLine : ISourceLine
{
public SourceLine (int row, int column)
: this (0, row, column)
{
this._type = SourceOffsetType.OFFSET_NONE;
}
public SourceLine (int offset, int row, int column)
{
this._offset = offset;
this._row = row;
this._column = column;
this._type = SourceOffsetType.OFFSET_IL;
}
internal SourceLine (int offset)
: this (offset, 0, 0)
{ }
public override string ToString ()
{
return "SourceLine (" + _offset + "," + _row + ":" + _column + ")";
}
internal SourceOffsetType _type;
internal int _offset;
internal int _row;
internal int _column;
// interface ISourceLine
public SourceOffsetType OffsetType {
get {
return _type;
}
}
public int Offset {
get {
return _offset;
}
}
public int Row {
get {
return _row;
}
}
public int Column {
get {
return _column;
}
}
}
protected class LocalVariable : ILocalVariable
{
public LocalVariable (string name, byte[] signature, int token, int index)
: this (name, signature, token, index, null)
{ }
public LocalVariable (string name, byte[] signature, int token, int index,
ISourceLine line)
{
this._name = name;
this._signature = signature;
this._token = token;
this._index = index;
this._line = line;
}
private readonly string _name;
internal Type _type;
private readonly byte[] _signature;
private readonly int _token;
private readonly int _index;
private readonly ISourceLine _line;
public override string ToString ()
{
return "LocalVariable (" + _index + "," + _name + ")";
}
// interface ILocalVariable
public string Name {
get {
return _name;
}
}
public int Token {
get {
return _token;
}
}
public int Index {
get {
return _index;
}
}
public Type Type {
get {
return _type;
}
}
public byte[] Signature {
get {
return _signature;
}
}
public ISourceLine Line {
get {
return _line;
}
}
}
protected class SourceMethod : ISourceMethod
{
private ArrayList _lines = new ArrayList ();
private ArrayList _blocks = new ArrayList ();
private Hashtable _block_hash = new Hashtable ();
private Stack _block_stack = new Stack ();
internal MethodInfo _method_info;
internal ISourceFile _source_file;
private readonly int _token;
private SourceBlock _implicit_block;
public SourceMethod (int token, MethodInfo method_info, ISourceFile source_file)
: this (token)
{
this._method_info = method_info;
this._source_file = source_file;
}
internal SourceMethod (int token)
{
this._token = token;
this._implicit_block = new SourceBlock (this, 0);
}
public void SetSourceRange (ISourceFile sourceFile,
int startLine, int startColumn,
int endLine, int endColumn)
{
_source_file = sourceFile;
_implicit_block._start = new SourceLine (startLine, startColumn);
_implicit_block._end = new SourceLine (endLine, endColumn);
}
public void StartBlock (ISourceBlock block)
{
_block_stack.Push (block);
}
public void EndBlock (int endOffset) {
SourceBlock block = (SourceBlock) _block_stack.Pop ();
block._end = new SourceLine (endOffset);
_blocks.Add (block);
_block_hash.Add (block.ID, block);
}
public void SetBlockRange (int BlockID, int startOffset, int endOffset)
{
SourceBlock block = (SourceBlock) _block_hash [BlockID];
((SourceLine) block.Start)._offset = startOffset;
((SourceLine) block.End)._offset = endOffset;
}
public ISourceBlock CurrentBlock {
get {
if (_block_stack.Count > 0)
return (ISourceBlock) _block_stack.Peek ();
else
return _implicit_block;
}
}
// interface ISourceMethod
public ISourceLine[] Lines {
get {
ISourceLine[] retval = new ISourceLine [_lines.Count];
_lines.CopyTo (retval);
return retval;
}
}
public void AddLine (ISourceLine line)
{
_lines.Add (line);
}
public ISourceBlock[] Blocks {
get {
ISourceBlock[] retval = new ISourceBlock [_blocks.Count];
_blocks.CopyTo (retval);
return retval;
}
}
public ILocalVariable[] Locals {
get {
return _implicit_block.Locals;
}
}
public void AddLocal (ILocalVariable local)
{
_implicit_block.AddLocal (local);
}
public MethodInfo MethodInfo {
get {
return _method_info;
}
}
public ISourceFile SourceFile {
get {
return _source_file;
}
}
public int Token {
get {
return _token;
}
}
public ISourceLine Start {
get {
return _implicit_block.Start;
}
}
public ISourceLine End {
get {
return _implicit_block.End;
}
}
}
protected SourceMethod current_method = null;
private readonly string assembly_filename = null;
//
// Interface IMonoSymbolWriter
//
public MonoSymbolWriter (string filename)
{
this.assembly_filename = filename;
this.methods = new Hashtable ();
this.sources = new Hashtable ();
this.orphant_methods = new ArrayList ();
this.locals = new ArrayList ();
}
public void Close () {
if (assembly == null)
assembly = AppDomain.CurrentDomain.Load (assembly_filename);
DoFixups (assembly);
CreateDwarfFile (output_filename);
}
public void CloseNamespace () {
}
// Create and return a new IMonoSymbolDocumentWriter.
public ISymbolDocumentWriter DefineDocument (string url,
Guid language,
Guid languageVendor,
Guid documentType)
{
return new MonoSymbolDocumentWriter (url);
}
public void DefineField (
SymbolToken parent,
string name,
FieldAttributes attributes,
byte[] signature,
SymAddressKind addrKind,
int addr1,
int addr2,
int addr3)
{
}
public void DefineGlobalVariable (
string name,
FieldAttributes attributes,
byte[] signature,
SymAddressKind addrKind,
int addr1,
int addr2,
int addr3)
{
}
public void DefineLocalVariable (string name,
FieldAttributes attributes,
byte[] signature,
SymAddressKind addrKind,
int addr1,
int addr2,
int addr3,
int startOffset,
int endOffset)
{
if (current_method == null)
return;
int token = current_method.Token;
LocalVariable local_info = new LocalVariable (name, signature, token, addr1);
current_method.CurrentBlock.AddLocal (local_info);
locals.Add (local_info);
}
public void DefineParameter (string name,
ParameterAttributes attributes,
int sequence,
SymAddressKind addrKind,
int addr1,
int addr2,
int addr3)
{
throw new NotSupportedException ();
}
public void DefineSequencePoints (ISymbolDocumentWriter document,
int[] offsets,
int[] lines,
int[] columns,
int[] endLines,
int[] endColumns)
{
SourceLine source_line = new SourceLine (offsets [0], lines [0], columns [0]);
if (current_method != null)
current_method.AddLine (source_line);
}
public void Initialize (IntPtr emitter, string filename, bool fFullBuild)
{
this.output_filename = filename;
}
public void OpenMethod (SymbolToken symbol_token)
{
int token = symbol_token.GetToken ();
if (methods.ContainsKey (token))
methods.Remove (token);
current_method = new SourceMethod (token);
methods.Add (token, current_method);
}
public void SetMethodSourceRange (ISymbolDocumentWriter startDoc,
int startLine, int startColumn,
ISymbolDocumentWriter endDoc,
int endLine, int endColumn)
{
if (current_method == null)
return;
if ((startDoc == null) || (endDoc == null))
throw new NullReferenceException ();
if (!(startDoc is MonoSymbolDocumentWriter) || !(endDoc is MonoSymbolDocumentWriter))
throw new NotSupportedException ("both startDoc and endDoc must be of type "
+ "MonoSymbolDocumentWriter");
if (!startDoc.Equals (endDoc))
throw new NotSupportedException ("startDoc and endDoc must be the same");
string source_file = ((MonoSymbolDocumentWriter) startDoc).FileName;
SourceFile source_info;
if (sources.ContainsKey (source_file))
source_info = (SourceFile) sources [source_file];
else {
source_info = new SourceFile (source_file);
sources.Add (source_file, source_info);
}
current_method.SetSourceRange (source_info, startLine, startColumn,
endLine, endColumn);
source_info.AddMethod (current_method);
}
public void CloseMethod () {
current_method = null;
}
public void OpenNamespace (string name)
{
}
public int OpenScope (int startOffset)
{
if (current_method == null)
return 0;
ISourceBlock block = new SourceBlock (current_method, startOffset);
current_method.StartBlock (block);
return block.ID;
}
public void CloseScope (int endOffset) {
if (current_method == null)
return;
current_method.EndBlock (endOffset);
}
public void SetScopeRange (int scopeID, int startOffset, int endOffset)
{
if (current_method == null)
return;
current_method.SetBlockRange (scopeID, startOffset, endOffset);
}
public void SetSymAttribute (SymbolToken parent, string name, byte[] data)
{
}
public void SetUnderlyingWriter (IntPtr underlyingWriter)
{
throw new NotSupportedException ();
}
public void SetUserEntryPoint (SymbolToken entryMethod)
{
}
public void UsingNamespace (string fullName)
{
}
//
// MonoSymbolWriter implementation
//
protected void WriteLocal (DwarfFileWriter.Die parent_die, ILocalVariable local)
{
DwarfFileWriter.DieMethodVariable die;
die = new DwarfFileWriter.DieMethodVariable (parent_die, local);
}
protected void WriteBlock (DwarfFileWriter.Die parent_die, ISourceBlock block)
{
DwarfFileWriter.DieLexicalBlock die;
die = new DwarfFileWriter.DieLexicalBlock (parent_die, block);
foreach (ILocalVariable local in block.Locals)
WriteLocal (die, local);
}
protected void WriteMethod (DwarfFileWriter.DieCompileUnit parent_die, ISourceMethod method)
{
DwarfFileWriter.DieSubProgram die;
die = new DwarfFileWriter.DieSubProgram (parent_die, method);
foreach (ILocalVariable local in method.Locals)
WriteLocal (die, local);
foreach (ISourceBlock block in method.Blocks)
WriteBlock (die, block);
}
protected void WriteSource (DwarfFileWriter writer, ISourceFile source)
{
DwarfFileWriter.CompileUnit compile_unit = new DwarfFileWriter.CompileUnit (
writer, source.FileName);
DwarfFileWriter.DieCompileUnit die = new DwarfFileWriter.DieCompileUnit (compile_unit);
foreach (ISourceMethod method in source.Methods)
WriteMethod (die, method);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal extern static Type get_local_type_from_sig (Assembly module, byte[] sig);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal extern static MethodInfo get_method (Assembly module, int token);
protected void DoFixups (Assembly assembly)
{
foreach (SourceMethod method in methods.Values) {
method._method_info = get_method (assembly, method.Token);
if (method.SourceFile == null)
orphant_methods.Add (method);
}
foreach (LocalVariable local in locals) {
byte[] signature = local.Signature;
Type type = get_local_type_from_sig (assembly, signature);
((LocalVariable) local)._type = type;
}
}
protected void CreateDwarfFile (string filename)
{
DwarfFileWriter writer = new DwarfFileWriter (filename);
foreach (ISourceFile source in sources.Values)
WriteSource (writer, source);
if (orphant_methods.Count > 0) {
SourceFile source = new SourceFile ("<unknown>");
foreach (SourceMethod orphant in orphant_methods) {
orphant._source_file = source;
source.AddMethod (orphant);
}
WriteSource (writer, source);
}
writer.Close ();
}
}
}
-43
View File
@@ -1,43 +0,0 @@
This is an implementation of the System.Diagnostics.SymbolStore.ISymbolWriter
interface which writes a dwarf debugging information file.
Unfortunately there are several major problems with this interface and I'm
unsure how to solve them:
1.) The interface contains a constructor method `Initialize' which has an
'IntPtr' emitter argument which seems to be a pointer to the actual
symbol writer which resides in a proprietary, undocumented DLL (I spent
almost 3 hours browsing the ".NET Framework SDK Documentation" and
msdn.microsoft.com - without success.
A short test showed me that mscorlib doesn't like passing zero, this
won't give you the system's default implementation.
To solve this problem, I created a derived interface IMonoSymbolWriter
which contains an additional constructor which only takes the name of
the symbol file as argument.
void Initialize (string filename);
2.) You seem to get an instance of a class implementing this interface by
creating a new instance of System.Reflection.Emit.ModuleBuilder (with the
`bool createSymbolFile' argument) and then calling GetSymWriter() on
the returned object.
So far so good, but how does this method find out which symbol writer
to use ?
3.) According to the documentation, some of the methods of
System.Reflection.Emit.ILGenerator and System.Reflection.Emit.LocalBuilder
seem to use the symbol writer to emit symbol debugging information.
But again, how do these objects get the symbol writer ?
Currently, there are two ways to use this assembly:
a.) Fix the problems outlined above and dynamically load this assembly
(Mono.CSharp.Debugger.dll) when a new symbol writer is created.
b.) Reference this assembly in your application and manually create the
symbol writer using the constructor.
Loaded 100 of 2193 files, more files were not shown because too many files have changed in this diff. Show more