Compare commits

..
1 Commits
Author SHA1 Message Date
nobody b0784aa131 This commit was manufactured by cvs2svn to create tag 'MCS_0_4'.
svn path=/tags/MCS_0_4/mcs/; revision=171
2001-07-16 01:07:36 +00:00
2368 changed files with 13892 additions and 319667 deletions

No files matched your search

+8 -14
View File
@@ -1,17 +1,11 @@
aclocal.m4
config.cache
config.guess
config.h
config.h.in
config.log
config.status
config.sub
configure
libtool
ltmain.sh
ltconfig
Makefile
Makefile.in
mono-*.tar.gz
stamp-h
config.cache
stamp-h.in
config.status
aclocal.m4
configure
stamp-h
libtool
Makefile.in
config.log
-2
View File
@@ -1,3 +1 @@
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!
-330
View File
@@ -1,333 +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.
2001-09-05 Dick Porter <[email protected]>
* autogen.sh: Fixed the section that adds $ACLOCAL_FLAGS to the
aclocal invocation, so putting aclocal files in /usr/local works
2001-08-30 Dietmar Maurer <[email protected]>
* *: removed the libffi dependency, mono now compiles on cygwin
* mono/wrapper/build-dll: new file.
2001-08-28 Dietmar Maurer <[email protected]>
* mono/tests/console.cs: impl.
* mono/tests/box.cs: impl.
* mono/tests/stream-writer.cs: impl.
Mon Aug 27 20:24:26 CEST 2001 Paolo Molaro <[email protected]>
* mono/tests/*: New test cases, mostly for virtual method dispatch.
Use make testb for the slow benchmarking programs,
make test for the usual regression test checks.
2001-08-22 Rodrigo Moya <[email protected]>
* mono/cil/Makefile.am:
* mono/wrapper/Makefile.am: use correct variables for installation
directories
Tue Aug 21 18:54:06 CEST 2001 Paolo Molaro <[email protected]>
* mono/tests/exceptions*: enhanced and added more tests for
exceptions.
2001-08-20 Miguel de Icaza <[email protected]>
* mono/Makefile.am (SUBDIRS): Remove `test' from here to allow us
to pass make distcheck
* mono/wrapper/Makefile.am (EXTRA_DIST): Include genwrapper.pl
* configure.in, Makefile.am, runtime/Makefile.am (dist-hook,
install-data-hook): Added mechanism to distribute and install the
dll files.
2001-08-20 Dietmar Maurer <[email protected]>
* mono/tests/stream.cs: new tests for the Stream class
* configure.in: I really need LIBTOOL for libmonowrapper.so, so I
added it again.
2001-08-16 Alex Graveley <[email protected]>
* configure.in: Replace AM_PROG_LIBTOOL with AC_PROG_RANLIB. This
removes libtool dependency on all of Mono.
2001-08-10 Dietmar Maurer <[email protected]>
* mono/tests/array.cs: more array tests
2001-08-09 Dietmar Maurer <[email protected]>
* mono/tests/array.cs: more array tests
2001-08-06 Dietmar Maurer <[email protected]>
* mono/tests/pinvoke.cs: we can now print strings ;-)
* mono/tests/array.cs: new test for arrays
2001-08-02 Alex Graveley <[email protected]>
* libffi/*: Import libffi CVS version, with minor changes to make it
compile.
* mono/interpreter/Makefile.am: Link against
../../libffi/.libs/libffi.a.
* Makefile.am: Add libffi
* autogen.sh: Replace with adapted gnome autogen.sh
* configure.in: Add AC_CONFIG_SUBDIRS(libffi).
2001-08-02 Dietmar Maurer <[email protected]>
* mono/tests/pinvoke.cs: impl.
Wed Aug 1 22:34:52 CEST 2001 Paolo Molaro <[email protected]>
* configure.in, mono/tests: added some tests for the interpreter.
2001-07-15 Sean MacIsaac <[email protected]>
* doc/download: added instructions for cygwin
* doc/c-sharp: removed bit about compiling
* status/compare-assembly.cs: basedir should be there if
parameters are provided.
* status/makefile: made targets to dump info.
2001-07-15 Joe Shaw <[email protected]>
* configure.in: Don't create doc/Makefile as there's nothing there
+1 -3
View File
@@ -1,3 +1 @@
AUTOMAKE_OPTIONS = foreign
SUBDIRS = mono doc runtime scripts man
SUBDIRS = mono doc
-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
+4 -48
View File
@@ -1,52 +1,8 @@
This is MonoNet.
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/
Contains documentation and the web site contents.
mono/
The core of the executable.
metadata/
The library to deal with executables and libraries for
.NET
dis/
CIL executable Disassembler
cli/
Common code for the JIT and the interpreter.
cil/
Common Intermediate Representation, XML
definition of the CIL bytecodes.
interp/
Interpreter for CLI executables.
* Using Mono
Once you have installed the software, you can run a few programs:
monodis program.exe
That will dump the bytecodes for program.exe. Monodis support
a number of options that dumps various metadata tables
(chapter 23 of the Partition III).
You can try the interpreter like this:
mint program.exe
Ximian's portable implementation of .NET
----------
To edit the go-mono website, see doc/README.
-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
+6 -120
View File
@@ -1,120 +1,6 @@
#!/bin/sh
# Run this to generate all the initial makefiles, etc.
# Ripped off from GNOME macros version
DIE=0
srcdir=`dirname $0`
test -z "$srcdir" && srcdir=.
if [ -n "$MONO_PATH" ]; then
ACLOCAL_FLAGS="-I $MONO_PATH/share/aclocal $ACLOCAL_FLAGS"
PATH="$MONO_PATH/bin:$PATH"
export PATH
fi
(autoconf --version) < /dev/null > /dev/null 2>&1 || {
echo
echo "**Error**: You must have \`autoconf' installed to compile Mono."
echo "Download the appropriate package for your distribution,"
echo "or get the source tarball at ftp://ftp.gnu.org/pub/gnu/"
DIE=1
}
(grep "^AM_PROG_LIBTOOL" $srcdir/configure.in >/dev/null) && {
(libtool --version) < /dev/null > /dev/null 2>&1 || {
echo
echo "**Error**: You must have \`libtool' installed to compile Mono."
echo "Get ftp://ftp.gnu.org/pub/gnu/libtool-1.2d.tar.gz"
echo "(or a newer version if it is available)"
DIE=1
}
}
grep "^AM_GNU_GETTEXT" $srcdir/configure.in >/dev/null && {
grep "sed.*POTFILES" $srcdir/configure.in >/dev/null || \
(gettext --version) < /dev/null > /dev/null 2>&1 || {
echo
echo "**Error**: You must have \`gettext' installed to compile Mono."
echo "Get ftp://alpha.gnu.org/gnu/gettext-0.10.35.tar.gz"
echo "(or a newer version if it is available)"
DIE=1
}
}
(automake --version) < /dev/null > /dev/null 2>&1 || {
echo
echo "**Error**: You must have \`automake' installed to compile Mono."
echo "Get ftp://ftp.gnu.org/pub/gnu/automake-1.3.tar.gz"
echo "(or a newer version if it is available)"
DIE=1
NO_AUTOMAKE=yes
}
# if no automake, don't bother testing for aclocal
test -n "$NO_AUTOMAKE" || (aclocal --version) < /dev/null > /dev/null 2>&1 || {
echo
echo "**Error**: Missing \`aclocal'. The version of \`automake'"
echo "installed doesn't appear recent enough."
echo "Get ftp://ftp.gnu.org/pub/gnu/automake-1.3.tar.gz"
echo "(or a newer version if it is available)"
DIE=1
}
if test "$DIE" -eq 1; then
exit 1
fi
if test -z "$*"; then
echo "**Warning**: I am going to run \`configure' with no arguments."
echo "If you wish to pass any to it, please specify them on the"
echo \`$0\'" command line."
echo
fi
case $CC in
xlc )
am_opt=--include-deps;;
esac
if grep "^AM_PROG_LIBTOOL" configure.in >/dev/null; then
if test -z "$NO_LIBTOOLIZE" ; then
echo "Running libtoolize..."
libtoolize --force --copy
fi
fi
echo "Running aclocal $ACLOCAL_FLAGS ..."
aclocal $ACLOCAL_FLAGS || {
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"
echo "set ACLOCAL_FLAGS to include \"-I \$prefix/share/aclocal\""
echo "for the prefix where you installed the packages whose"
echo "macros were not found"
exit 1
}
if grep "^AM_CONFIG_HEADER" configure.in >/dev/null; then
echo "Running autoheader..."
autoheader || { echo "**Error**: autoheader failed."; exit 1; }
fi
echo "Running automake --gnu $am_opt ..."
automake --add-missing --gnu $am_opt ||
{ echo "**Error**: automake failed."; exit 1; }
echo "Running autoconf ..."
autoconf || { echo "**Error**: autoconf failed."; exit 1; }
conf_flags="--enable-maintainer-mode --enable-compile-warnings" #--enable-iso-c
if test x$NOCONFIGURE = x; then
echo Running $srcdir/configure $conf_flags "$@" ...
$srcdir/configure $conf_flags "$@" \
&& echo Now type \`make\' to compile $PKG_NAME || exit 1
else
echo Skipping configure process.
fi
libtoolize --automake
automake -a
autoheader
aclocal $ACLOCAL_FLAGS
autoconf
./configure $*
+10 -463
View File
@@ -1,490 +1,37 @@
AC_INIT(README)
AC_CANONICAL_SYSTEM
AM_CONFIG_HEADER(config.h)
AM_INIT_AUTOMAKE(mono, 0.10)
AM_INIT_AUTOMAKE(mono, 0.3)
AM_MAINTAINER_MODE
AC_CHECK_TOOL(CC, gcc, gcc)
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)
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?]))
# for mono/metadata/debug-symfile.c
AC_CHECK_HEADERS(elf.h)
# 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)
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
TARGET="unknown"
ACCESS_UNALIGNED="yes"
case "$host" in
#mips-sgi-irix5.* | mips-sgi-irix6.*) TARGET=MIPS; ACCESS_UNALIGNED="no";;
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";;
#m68k-*-linux*) TARGET=M68K;;
powerpc-*-linux* | powerpc-*-sysv*) TARGET=POWERPC; arch_target=ppc;;
arm-*-linux-*) TARGET=ARM; arch_target=arm; ACCESS_UNALIGNED="no";;
esac
if test ${TARGET} = unknown; then
CFLAGS="$CFLAGS -DNO_PORT"
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)
AM_CONDITIONAL(X86, test x$TARGET = xX86)
AM_CONDITIONAL(ALPHA, test x$TARGET = xALPHA)
AM_CONDITIONAL(M68K, test x$TARGET = xM68K)
AM_CONDITIONAL(POWERPC, test x$TARGET = xPOWERPC)
AM_CONDITIONAL(ARM, test x$TARGET = xARM)
AC_SUBST(arch_target)
CFLAGS='-g -Wall -Wunused -Wmissing-prototypes -Wmissing-declarations'
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
mono/doc/Makefile
])
echo "
GC: $gc
"
-1
View File
@@ -1,4 +1,3 @@
Makefile.in
Makefile
all-docs
pending-classes.in
+5 -21
View File
@@ -1,9 +1,9 @@
WEB_FILES= \
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
faq gcc-frontend ideas index makefile passport rationale resources \
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,5 @@ 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>
+57 -126
View File
@@ -1,43 +1,15 @@
* 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 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,62 +42,59 @@
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: nothing done so far, but I do not
expect this to be hard, as I will just use
System.Reflection.Emit to generate the code.
</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
would be best to port the Bison-To-Java compiler to
become Bison-to-C# compiler.
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>
become Bison-to-C# compiler ([email protected]
might have more information)
</ul>
* 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.
Critical tasks:
<ul>
* Resolve "base" classes and "base" interfaces for
classes, structs and interfaces.
Once this is done, we can actually do the semantic
analysis, because otherwise we do not know who our
parents are.
</ul>
Interesting tasks:
<ul>
* Finishing the JB port from Java to C#. If you are
interested in working on this, please contact Brian
Jepson (bjepson at oreilly d-o-t com).
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).
</ul>
** Questions and Answers
@@ -154,10 +123,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
@@ -168,53 +133,19 @@ A: No, currently I am using Jay which is a port of Berkeley Yacc to
In the future I want to port one of the Bison/Java ports to C# for
the parser.
Q: Should someone work on a GCC front-end to C#?
Q: How do I compile it?
A: I would love if someone does, and we would love to help anyone that
takes on that task, but we do not have the time or expertise to
build a C# compiler with the GCC engine. I find it a lot more fun
personally to work on C# on a C# compiler, which has an intrinsic
beauty.
A: Compiling MCS currently requires you to run my port of <a
href="http://primates.ximian.com/~miguel/code/jay.cs.tar.gz">Jay to
C#</a> on a Unix system to generate the parser, and then you need
to use Microsoft's .NET csc.exe compiler to compile the compiler.
We can provide help and assistance to anyone who would like to work
on this task.
You only need to compile the compiler compiler (C code), the
samples are Java samples that I did not port, and you do not need
them.
Q: Should someone make a GCC backend that will generate CIL images?
A: I would love to see a backend to GCC that generates CIL images. It
would provide a ton of free compilers that would generate CIL
code. This is something that people would want to look into
anyways for Windows interoperation in the future.
Again, we would love to provide help and assistance to anyone
interested in working in such a project.
Q: What about making a front-end to GCC that takes CIL images and
generates native code?
A: I would love to see this, specially since GCC supports this same
feature for Java Byte Codes. You could use the metadata library
from Mono to read the byte codes (ie, this would be your
"front-end") and generate the trees that get passed to the
optimizer.
Ideally our implementation of the CLI will be available as a shared
library that could be linked with your application as its runtime
support.
Again, we would love to provide help and assistance to anyone
interested in working in such a project.
Q: But would this work around the GPL in the GCC compiler and allow
people to work on non-free front-ends?
A: People can already do this by targeting the JVM byte codes (there
are about 130 compilers for various languages that target the JVM).
Q: Why are you writing a JIT engine instead of a front-end to GCC?
A: The JIT engine and runtime engine will be able to execute CIL
executables generated on Windows.
It might be simple to port Jay.cs to Windows, but I have not tried
this.
You might also want to look at the <a href="faq.html#gcc">GCC</a>
section on the main FAQ
-138
View File
@@ -1,138 +0,0 @@
* CVS Access
If you are an active Mono developer, you can get a CVS account
that hosts the Mono source code.
If you are not a developer, but want to track the development, please
see the <a href="anoncvs.html">AnonCVS</a> instructions.
Send an e-mail to miguel with your public SSH key for this
purpose. Please specify if the key was generated with SSH1 or SSH2.
If you are using SSH2, please generate your key using:
<pre>
ssh-keygen -t rsa
</pre>
And mail me the id_rsa.pub file.
If you are using SSH1, run:
<pre>
ssh-keygen
</pre>
And mail me your identity.pub file.
You will need CVS and SSH. Windows users can get both by
installing Cygwin (<a
href="http://www.cygwin.com">http://www.cygwin.com</a>)
Unix users will probably have those tools installed already.
** Checking out the sources
To check out the sources for the first time from the
repository, use this command:
<pre>
export CVS_RSH=ssh
export [email protected]:/cvs/public
cvs -z3 co mcs mono
</pre>
** Updating your sources
Every day people will be making changes, to get your latest
updated sources, use:
<pre>
cvs -z3 update -Pd mcs mono
</pre>
Note: The '-z3' enables compression for the whole cvs action.
The '-Pd' makes the update operation (P)rune directories that
have been deleted and get new (d)irectories added to the
repository.
** Making patches
Usually you will want to make a patch to contribute, and let
other people review it before commiting it. To obtain such a
"patch", you type:
<pre>
cd directory-you-want-to-diff
cvs -z3 diff -u > file.diff
mail [email protected] < file.diff
</pre>
** Keeping track of changes.
We provide two e-mail based mechanisms to keep track of
changes to the code base:
<ul>
* <a href="mailto:[email protected]">
[email protected]</a>: This mailing list receives
in patch form all the changes that are being made to the
CVS.
* <a href="mailto:[email protected]">
[email protected]</a>: This mailing list only
receives the CVS commit logs with a list of files
modified.
</ul>
We hope to offer LXR and Bonsai in the future as well.
** Commiting your work
Once you get approval to commit to the CVS, or if you are
commiting code that you are the maintainer of, you will want
to commit your code to CVS.
To do this, you have to "add" any new files that you created:
<pre>
cvs add new-file.cs
</pre>
And then commit your changes to the repository:
<pre>
cvs commit file-1.cs file-2.cs
</pre>
** The Mailing List
To keep track of the various development and changes to the
CVS tree, you can subscribe to the [email protected].
To subscribe, send an email message to
[email protected] and in the body of the
message put `subscribe'.
This will send you an email message every time a change is
made to the CVS repository, together with the information that
the author of the changes submitted.
** Recommendations
Please do not commit code that would break the compile to the
CVS, because that normally wastes everybody's time. Two things
are important in this step: trying to build your sources and making
sure that you add all the new files before you do a commit.
To build the sources, most of the type trying the `make' command
is enough. In some cases (the class libraries) we use nant, so
you need to run nant manually.
Use ChangeLog entries so we can keep textual descriptions of
your work, and use the contents of your ChangeLog file as the
CVS commit message (ie, paste the contents of this into the
editor buffer).
If you are making changes to someone else's code, please make
sure you get in touch with the maintainer of that code before
applying patches. You want to avoid commiting conflicting
work to someone else's code.
+28 -44
View File
@@ -26,22 +26,7 @@
If nobody is working on it, mail <a
href="mailto:[email protected]">[email protected]</a>
with the class you want to implement and CC <a
href="mailto:[email protected]">[email protected]</a>.
You can also track live the activities of the Mono CVS module
by subscribing to the <a
href="http://lists.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list</a>
** Missing features
Our class libraries miss some features, for example, most classes
do not implement the serialization bits at all, it would be a good
contribution to add this to each class.
This is a simple task, but it needs to be done in a compatible way
with the Microsoft.NET classes: using the same arguments to serialize
and reincarnate data.
href="mailto:[email protected]">[email protected]</a>
** Layout
@@ -106,11 +91,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
@@ -118,9 +125,6 @@
the correctness of the class library, compiler, and JIT
engine.
Please write your regression tests using <a
href="http://nunit.sourceforge.net">NUnit</a>
** Coding conventions
Please follow the conventions on the ECMA specification (On
@@ -156,26 +160,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:
+27
View File
@@ -0,0 +1,27 @@
* 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.
<ul>
* Per <a href="class-status/per-assembly.html">Assembly</a>
* Per <a href="class-status/per-completion.html">Completion</a>
* Per <a href="class-status/per-maintainer.html">Maintainer</a>
* Per <a href="class-status/per-unimplemented.html">Unimplemented</a>
</ul>
A better mechanism will soon be in place, I just did this
really quickly, as we already got one duplicated implementation.
You can also download the XML <a
href="class-status/maintainers.xml">maintainers</a> file that
contains the actual maintainers list.
I am sure we can generate better reports, if you are
interested in contributing, let <a
href="mailto:[email protected]">me</a> know.
-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]">mailto:[email protected]</a>'.
You can contact the general forum of discussion by sending
e-mail to <a href="mailto:[email protected]">[email protected]</a>
+8 -144
View File
@@ -10,7 +10,7 @@
href="tools.html">the tools</a>, the <a
href="testing.html">testing framework</a>
* <b>Writers:</b> You can help us bywriting <a
* <b>Writers:</b> You can help us with writing <a
href="documentation.html">documentation</a>.
</ul>
@@ -18,158 +18,22 @@
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
that you do not need Visual Studio (although you can use it if
you want). The .NET Framework SDK requires some version of
Windows XP or Windows NT. If you are running Windows 98, 95
or Me, you could use instead the <a
href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/001/829/msdncompositedoc.xml">.NET Redist package</a>, but it
lacks the documentation browser and the ildasm program (C#, VB, JScript and IL
assembler are included).
You can get it <a href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml&frame=true">here</a>
If you are new to .NET, writing regression tests is a good way
of starting to contribute: it will help you get used to C# as
well as getting comfortable with the .NET APIs.
This helps because at this point you might be the best
qualified person to fix a problem found by the regression
test, or you might have a new class to implement in the .NET
world that only has a test suite.
To get started writing tests see the <a href="testing.html">Test Suite</a>
section.
*** Contributing to the runtime engine
This only requires Linux, currently some tasks are easier if you
have access to Windows as well.
Here are a few things you can do:
<ul>
* Port the runtime to other architectures.
* Port the runtime to other operating systems.
* Finish the IL code verifier in the runtime.
* Hack the JIT, improve the code generator, add new
pattern rules, improve the register allocator.
* Implement the debugging interfaaces
</ul>
** Bug reporting
If you find bugs in Mono, please make sure you enter a bug
report so we can keep track of problems in Mono.
To enter bug reports go to <a href="http://bugzilla.ximian.com">
http://bugzilla.ximian.com</a> and enter bug reports against
your favorite component (Mono, Runtime, C# compiler).
You can review the list of current bugs by going <a href="http://bugzilla.ximian.com/buglist.cgi?product=Mono%2FClass+Libraries&product=Mono%2FMCS&product=Mono%2FRuntime&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&email1=&emailtype1=substring&emailassigned_to1=1&email2=&emailtype2=substring&emailreporter2=1&changedin=&chfieldfrom=&chfieldto=Now&chfieldvalue=&short_desc=&short_desc_type=substring&long_desc=&long_desc_type=substring&bug_file_loc=&bug_file_loc_type=substring&keywords=&keywords_type=anywords&op_sys_details=&op_sys_details_type=substring&version_details=&version_details_type=substring&cmdtype=doit&order=%27Importance%27&form_name=query">here</a>
** Small tasks
A few smaller tasks are here, dropped in no particular order:
<ul>
* <b>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).
* <b>Enthusiasts: </b>
</ul>
* Emacs support
Brad Merryl's C# mode for Emacs is available: <a
href="http://www.cybercom.net/~zbrad/DotNet/Emacs/">http://www.cybercom.net/~zbrad/DotNet/Emacs/</a>
* Books on C# and DotNet.
<ul>
* Dotnet Books (<a href="http://www.dotnetbooks.com">http://www.dotnetbooks.com</a>)
* Dotnet Resources (<a href="http://www.dotnetexperts.com/resources/">
http://www.dotnetexperts.com/resources</a>)
* O'Reilly C# Essentials (<a href="http://www.oreilly.com/catalog/csharpess/">
http://www.oreally.com/catalog/csharpess</a>)
* O'Really .NET Essentials (<a href="http://www.oreilly.com/catalog/dotnetfrmess/">
http://www.oreally.com/catalog/dotnetfrmess</a>)
</ul>
<a name="setup">
* Common Setups
People running both Linux and Windows while contributing to
Mono use a number of tricks to increase their productivity.
Scenarios:
<ul>
* <b>Linux host and Windows host</b>
The Windows file system is shared (right click on
your hard drive icon, and select sharing, allow this
to be shared).
The Windows machine has the required build tools
(cygwin, and the .NET framework). On the Windows
machine, you want to setup the ssh server (run the
ssh-host-config program to configure your ssh) and
run it (from a cygwin terminal, type: /usr/sbin/sshd).
From the Linux side, you want to mount the Windows
file system, using something like this:
<tt><pre>
mount -t smbfs -o uid=miguel,username="Miguel de Icaza" "//quack/c$" /mnt
</pre></tt>
In the above example, my Linux user name is
`miguel', and this will allow this user to have
read/write access to the share.
The host name is `quack', and the name of the share
is `c$' (that is the C: partition).
The file system is accessible on /mnt.
You can perform your cvs update and cvs commits from
the /mnt directory, and run Emacs or your favorite
Linux text editor on the Unix side in this way.
Then from another terminal, you can ssh into your
Windows box using ssh, like this: ssh "Miguel de Icaza@quack"
</ul>
* Special Note
* Special note
If you have looked at Microsoft's implementation of .NET or
their shared source code, you may not be able to contribute
-190
View File
@@ -1,190 +0,0 @@
* Developer FAQ
** New classes
Q: Should we write classes which are not part of the .NET or ECMA specs?
A: Yes. The ECMA and .NET specifications are far from complete, and
to produce a complete platform we will need a number of other
classes and components.
Any new classes that are not part of .NET or ECMA should be
designed to be reusable on anyone's CLI implementation. So that
Windows developers can also use any new classes that we come up
with.
We have a few existing <a href="ideas.html">Ideas on missing
classes</a>
** Language Compatibility
Q: What is the magic that allow multiple languages to co-exist?
A: From Fergus Henderson:
<i><blockquote>
There are different levels of interoperability.
The ECMA spec defines different categories of
CLS (Common Language Specification) conformance.
There are also some useful categories that don't
correspond to any of the levels defined in the ECMA spec.
In increasing degree of difficulty, your language implementation
can
<ul>
* (a) just generate IL
* (b) be a CLS "consumer", which means that it can read in
meta-data describing component interfaces,
and that it provides a way to declare variables of
CLS-complaint types and to call CLS-complaint methods.
* (c) be a CLS "extender", which means that it can in addition
derive from CLS-compliant classes
and implement CLS-compliant interfaces
* (d) be able to produce components with *any* CLS-compliant
component interface.
</ul>
Supporting some of these may require extending your language. However,
you can get quite a lot of interoperability by just putting appropriate
functionality in your compiler, without extending your language.
For some things, e.g. ASP.NET, your language implementation also needs to be
able to
<ul>
* (e) consume CodeDom trees. CodeDom trees are an abstract
representation of programs in a form similar to a C# parse
tree, with embedded code snippets (unparsed strings).
Given a CodeDom tree, with the snippets in your language,
your language implementation needs to generate a (i) .NET
assembly and possibly also (ii) a source file in your language.
* (f) produce CodeDom trees. For some applications,
your language implementation also needs to be able to
round-trip from CodeDom -> your language -> CodeDom.
</ul>
and for some things it needs to
<ul>
* (g) generate *verifiable* IL
</ul>
So when you hear all the hype about how language XYZ is a
".NET language", make sure you ask which of these different
things are supported.
[For the record, Mercury currently supports (a). We're working on
(b) and (g), and on parts of (c) and (e). We're never going to do (f), I very
strongly doubt we'll ever do (d), and for (c) we might only ever support
implementing interfaces, not deriving from classes.]
</blockquote></i>
** PInvoke
Q: What are the two major initiatives to implement PInvoke?
A: Fergus Henderson answers:
<i><blockquote>
Many of the .NET APIs will need to be implemented using code that calls C/Unix
APIs, such as stat(). The standard way of interfacing with native code from
.NET code is to use "PInvoke". However, there is a difficulty: many of
these APIs are defined in terms of types such as C's `long' or `size_t'
or the Posix `struct stat' whose representation varies depending on the
platform (architecture/OS/C compiler). There's no *portable* way of
accessing those from .NET managed code.
So, there are a couple of different approaches.
One possibility is to access such routines by writing a wrapper, e.g. in C,
that provides the same functionality without using types with a system-dependent
representation. The wrapper can then be directly accessed from portable
.NET code. The .NET code remains both source- and binary-portable;
the wrapper code is source-portable, but needs to be compiled
seperately for each target platform. The drawback of this approach is
that you have to write a lot of cumbersome wrapper code.
Another possibility is to extend the .NET VM with support for an
additional custom attribute, e.g. "[PosixType]". The VM would then
represent types tagged with this attribute in the same way that the
underlying system represents those types. With this approach, no
wrapper code would be needed. A drawback of this approach is that it
pushes quite a bit of complexity into the VM; the VM would have to know
the native representation of all types annotated with this attribute.
Another drawback is that code using this extension might not work on
different VMs.
There have also been some other suggestions, but those are the two that
I think are the best.
</blockquote></i>
Q: What is the problem implementing PInvoke?
A: Again, from Fergus Henderson:
<i><blockquote>
There's no problem implementing PInvoke as specified in the ECMA
specs and/or MS documentation. It's just that PInvoke by itself
doesn't solve all of the problems; in particular it doesn't solve
the problem of C types whose representation is different on different
systems.
</blockquote></i>
** CVS use
Q: Why do we keep ChangeLogs and make the CVS commit messages be the
same? One could be generated from the other
A: There are a number of reasons for keeping ChangeLog files as well as
CVS commit files:
<ul>
* Offline programming: when people are traveling, CVS logs are
not available.
* Slow CVS access: Many people work over modem lines (very
typical for contributors in Europe, Asia, Latin America)
using CVS is slow and might not be available to you (cvs
server down, no anoncvs server available).
* ChangeLogs travel in a released tarball package, so it is
possible to study the rationale of changes even after a
project is long "released", or you only have the sources for
the code.
* ChangeLog are not metadata for each file, they are live
files that you can browse in the package that is being
distributed.
</ul>
Making the CVS commit message be the same as the ChangeLog has other
benefits:
<ul>
* You can track down with `cvs log' what things were changed,
and match those to meaningful reports on the intentions of
the commit.
* When reading the commits-list, you can get a glimpse of the
changes without having to diff out or cvs update your tree.
* You can read off-line the changes that are being made
(asyncrouns operation).
</ul>
This mechanism works very well for GNOME and other projects.
Q: Should I use any of the special RCS keywords like $Id: devel-faq,v 1.1 2001/07/31 21:13:05 miguel Exp $, $Author: miguel $,
$Date: 2001/07/31 21:13:05 $, or $Revision: 1.1 $?
A: Please avoid using those in the source code in the CVS. They
are not really useful, and they cause a lot of conflicts when
people have separate CVS trees.
It was a nightmare with the Linux kernel when two people had their
private CVS trees and were submitting patches to the core.
+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.
+13 -301
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,313 +10,19 @@
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>.
The mcs compiler requires the `jay' parser generator, this is
available in module `jay'.
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.
** Sources
<a name="sources">
*** Sources
Stay up to date on the Mono team's development using the
<a href="http://lists.ximian.com/mailman/listinfo/mono-cvs-list">
mono-cvs-list</a> mailing list. The CVS source code can also
be browsed <a href="http://cvs.hispalinux.es/cgi-bin/cvsweb/mcs/mcs/cfold.cs?cvsroot=Mono">here</a>
<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.
Currently we will be providing CVS snapshots every day, until
we make the first tarball release.
<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).
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.
You can download the GNU make tools and the Cygwin environment from
<a href="http://www.cygwin.com">www.cygwin.com</a>.
You can download Microsoft's .NET Framework SDK from
<a href="http://msdn.microsoft.com/downloads">
msdn.microsoft.com/downloads</a>.
There are scripts to help build mono for both Unix and Windows. Get
<a href="mono-build.sh">mono-build.sh</a> for Unix, or <a
href="mono-build-w32.sh">mono-build-w32.sh</a> for Windows.
These scripts automate the installation of GLIB and pkgconfig
(building from source on Unix, and using binary packages
provided by the GIMP for Windows project on Windows.) To use
the script, follow these simple steps:
<ul>
* Save the script for your platform somewhere (e.g. /usr/local/bin)
* Make the script executable (i.e chmod 755 /usr/local/bin/mono-build.sh)
* Create a directory to hold the mono source, and the compiled binaries (e.g. mkdir ~/mono)
* Change to the new directory (i.e. cd ~/mono)
* run the script (i.e. /usr/local/bin/mono-build.sh)
</ul>
The script requires wget on either platform, and building the
software requires make, gcc, automake, autoconf, and libtool.
You should install these packages from your distribution or
with the cygwin installer.
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>
* <a href="archive/mono-0.6.tar.gz">mono-0.6.tar.gz</a>: Mono Runtime 0.6 release.
* <a href="archive/mono-compiler-classes-0.6.tar.gz">mono-compiler-classes-0.6.tar.gz</a>: Mono Compiler and Classes 0.6 release.
* <a href="archive/mono-0.6">Release Notes.</a>
</ul>
<a name="july-29">
<b>July 29, 2001</b>
<ul>
* <a href="archive/mono-0.5.tar.gz">mono-0.5.tar.gz</a>: Mono Runtime 0.5 release.
* <a href="archive/mono-0.5">Release Notes.</a>
</ul>
<a name="july-22">
<b>July 22, 2001</b>
<ul>
* <a href="archive/mcs-22-Jul-2001.tar.gz">mcs-22-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mcs-Jul-22-Jul-19-2001.tar.gz">Differences since 19</a>: CVS snapshot.
* <a href="archive/mcs-22">Release Notes.</a>
</ul>
<a name="july-19">
<b>July 19th, 2001</b>
<ul>
* <a href="archive/mcs-19-Jul-2001.tar.gz">mcs-19-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mcs-Jul-17-Jul-19-2001.tar.gz">Differences since 17</a>: CVS snapshot.
* <a href="archive/mcs-19">Release Notes.</a>
</ul>
<a name="july-17">
<b>July 17th, 2001</b>
<ul>
* <a href="archive/mcs-17-Jul-2001.tar.gz">mcs-17-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mcs-Jul-15-Jul-17-2001.tar.gz">Differences since 15</a>: CVS snapshot.
* <a href="archive/mcs-17">Release Notes.</a>
</ul>
<a name="july-15">
<b>July 15th, 2001</b>
<ul>
* <a href="archive/mcs-15-Jul-2001.tar.gz">mcs-15-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mono-0.4.tar.gz">mono-0.4.tar.gz</a>: Packaged Source Code.
* <a href="archive/mono-0.4">Release Notes.</a>
</ul>
<a name="july-14">
<b>July 14th, 2001</b>
<ul>
* <a href="archive/jay.cs.tar.gz">archive/jay.cs.tar.gz</a>: Sources to Jay.
* <a href="archive/mcs-12-Jul-2001.tar.gz">mcs-12-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mono-0.3.tar.gz">mono-0.3.tar.gz</a>: Packaged Source Code.
</ul>
@@ -325,8 +31,14 @@ make install</strong>
<b>July 8th, 2001</b>
<ul>
* <a href="archive/jay.cs.tar.gz">archive/jay.cs.tar.gz</a>: Sources.
* <a href="archive/mcs-08-Jul-2001.tar.gz">mcs-08-Jul-2001.tar.gz</a>: CVS Snapshot
* <a href="archive/mono-08-Jul-2001.tar.gz">mono-08-Jul-2001.tar.gz</a>: CVS Snapshot
</ul>
</ul>
** CVS
We are trying to figure out where to put our CVS repository.
We are debating between the GNOME CVS or SourceForge. Watch
this spot.
+335 -416
View File
@@ -1,43 +1,18 @@
<a href="#basics">Basics</a><br>
<a href="#ximian">The Ximian Role in the Mono project</a><br>
<a href="#gnome">Mono and GNOME</a><br>
<a href="#gui">Building GUI applications with Mono</a><br>
<a href="#msft">Mono and Microsoft</a><br>
<a href="#pnpproject">Mono and the Portable.NET Project</a><br>
<a href="#webservices">Web Services</a><br>
<a href="#devel">Development Tools and Issues</a><br>
<a href="#java">Mono and Java</a><br>
<a href="#extending">Extending Mono</a><br>
<a href="#portability">Portability</a><br>
<a href="#reuse">Reusing Existing Code</a><br>
<a href="#gcc">Mono and GCC</a><br>
<a href="#performance">Performance</a><br>
<a href="#licensing">Licensing</a><br>
<a href="#patents">Patents</a><br>
<a href="#etc">Miscellaneous Questions</a><br>
<a name="basics"></a>
** Basics
Q: What is Mono exactly?
Q: Is Mono the same as Microsoft's .NET initiative?
A: The Mono Project is an open development initiative sponsored by
Ximian that is working to develop an open source, Linux-based
version of the Microsoft .NET development platform. Its objective
is to enable Linux developers to build and
deploy cross-platform .NET Applications. The project will
implement various technologies developed by Microsoft that have now
been submitted to the ECMA for standardization.
A: It is not.
Q: What is the difference between Mono and the .NET Initiative?
.NET is a company-wide initiative at Microsoft that
encompasses many different areas. The .NET development framework,
Passport, Biztalk, new server products, and anything that is
remotely connected to .NET gets the ".NET-stamping" treatment.
Some components of Microsoft's .NET initiative have been announced
and some others are in the works.
A: The ".NET Initiative" is a somewhat nebulous company-wide effort by
Microsoft, one part of which is a cross-platform development
framework. Mono is an implementation of the development framework,
but not an implementation of anything else related to the .NET
Initiative, such as Passport, software-as-a-service, or
corporate rebranding.
Mono is a project to implement several technologies developed by
Microsoft that have now been submitted to the ECMA Standards Body.
Q: What technologies are included in Mono?
@@ -55,18 +30,20 @@ A: Mono contains a number of components useful for building new
* A compiler for the C# language. In the future we
might work on other compilers that target the Common
Language Runtime.
Windows has compilers that target the
virtual machine from
<a href="http://msdn.microsoft.com/net/thirdparty/default.asp#lang">a
number of languages:</a> Managed C++, Java Script,
Eiffel, Component Pascal, APL, Cobol, Oberon, Perl,
Python, Scheme, Smalltalk, Standard ML, Haskell,
Mercury and Oberon.
</ul>
Windows has compilers that target the virtual machine from <a
href="http://msdn.microsoft.com/net/thirdparty/default.asp#lang">a
number of languages:</a> Managed C++, Java Script, Eiffel,
Component Pascal, APL, Cobol, Oberon, Perl, Python, Scheme,
Smalltalk, Standard ML, Haskell, Mercury and Oberon.
The CLR and the Common Type System (CTS) enables applications and
libraries to be written in a collection of different languages that
target the byte code
libraries to be written in a number of languages. Classes and
methods created in one language can be used from a different
language.
This means for example that if you define a class to do algebraic
manipulation in C#, that class can be reused from any other
@@ -88,58 +65,45 @@ Q: Will you implement the .NET Framework SDK class libraries?
A: Yes, we will be implementing the APIs of the .NET Framework SDK
class libraries.
Q: Will you offer an ECMA-compliant set of class libraries?
Q: What does Mono stand for?
A: Eventually we will. Our current focus is on interoperating
with the Microsoft SDK, but we will also offer an ECMA compliant
set of libraries.
Q: What does the name "Mono" mean?
A: Mono is the word for `monkey' in Spanish. We like monkeys.
Q: Is Mono usable?
A: The JIT engine is usable on Intel x86 machines. An interpreter
can be used on other non-Intel x86 machines.
The class libraries are not yet mature enough to run real applications,
but if you are interested in trying out Mono, you can definetly start
testing things out as many programs run.
The C# compiler has made significant progress, it can even compile
itself now, but it can not yet be ran with our class libraries as
they are missing some features.
A: Mono is the word for `Monkey' in Spanish. We like monkeys.
Q: When will you ship it?
A: It is premature to target a shipdate for the code, but we
anticipate that it will be available some time in the middle of
2002.
A: We do not know when the code will be shipped. The more
contributions we get to the project, the sooner it will ship.
A rough estimate is that we might be able to run our C# compiler on
Linux by the end of the year. That means running the Windows
Executable generated by a Microsoft .NET compiler on the Linux
platform.
We expect that doing GUI applications will require more work on the
class libraries. That could take another six months.
Q: How can I contribute?
A: Check the <a href="contributing.html">contributing</a> section.
Q: Aren't you just copying someone else's work?
Q: You guys should innovate instead of copying.
A: We are interested in providing the best tools for programmers to
develop applications for Free Operating Systems. We also want to help
provide the interoperability that will allow those systems to fit in
with other standards.
A: In this particular case, we see a clear advantage in the platform
and we are interested in using the features of the CLI on open source systems.
For more background, read the <a href="http://www.go-mono.com/rationale.html">Mono
Project white paper</a>.
the project.
We have decided that we should spend our limited resources towards
implementing an existing specification instead of designing and
implementing our own.
Designing and implementing our own would be possible, but it doesn't make
sense to do that just because the specification comes from a
proprietary vendor.
<a name="ximian"></a>
** The Ximian Role in the Mono Project
** Ximian
Q: Why is Ximian working on .NET?
A: Ximian is interested in providing the best tools for programmers to
A: We are interested in providing the best tools for programmers to
develop applications for Free Operating Systems.
For more information, read the project <a
@@ -147,150 +111,83 @@ A: Ximian is interested in providing the best tools for programmers to
Q: Will Ximian be able to take on a project of this size?
A: Of course not. Ximian a supporter of the Mono project, but the only way
to implement something of this size is for the entire free software
community to get involved. Visit the <a href="contributing.html">contributing</a>
page if you'd like to help out.
A: Ximian will not be able to taken on the whole project on its own.
Mono will be a free software/open source community project, that is
the only way we can hope to implement something of this size. You
can <a href="contributing.html">contribute</a> to this effort.
Q: What pieces will Ximian be working on?
A: We will devote most of our resources to work on the pieces which are
on the critical path to release a development and execution
environment. Once the project is at a stage where it is useful in
the real world, it will achieve a critical mass of developers to
improve it further.
A: We will focus on building a development and execution
environment.
Q: Will Ximian offer Mono commercially?
The idea is to get Mono to a state of that would allow
third parties to actually be able to use it real-world development.
A: When Mono is ready to be shipped Ximian will offer a commercial
support and services for Mono.
Q: Why does Ximian even care?
Q: Will you wait until Mono is finished?
A: We like the features that the CLI and its related technologies
bring to the table. An exciting addition to the developer toolkit.
The goal of Mono is to bring this technology to non-Windows
platforms (although we hope Mono will also run on Windows, for
debugging and comparative purposes).
A: Mono will ship on various stages as they mature. Some people
require only a subset of the technologies, those will ship first.
More advanced features will take more time to develop. A support
timeline will be available in June 2002.
** Licensing
<a name="gnome"></a>
** Mono and GNOME
Q: Will I be able to write proprietary applications that run with
Mono?
Q: How is Mono related to GNOME?
A: Yes. We will make sure that the licensing will allow developers to
create proprietary applications.
Q: What license is Mono on?
A: In a number of ways. This project was born out of the need of
providing improved tools for the GNOME community, and will use
existing components that have been developed for GNOME when they
are available. For example, we plan to use Gtk+ and Libart to
implement Winforms and the Drawing2D API and are considering
GObject support.
A: The C# Compiler is released under the terms of the GPL. The class
libraries will be under the LGPL or the GPL with a special
exception. The runtime libraries are under the LGPL.
Q: Has the GNOME Foundation or the GNOME team adopted Mono?
Here is the exception for the class libraries:
A: Mono is too new to be adopted by those groups. We hope that the
tools that we will provide will be adopted by free software
programmers including the GNOME Foundation members and the GNOME
project generally.
The library is distributed under the terms of the GNU General
Public License with the following exception:
Q: Should GNOME programmers switch over to Mono now?
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.
A: It is still far to early for discussions of "switching over." No
pieces of Mono will be ready within the next six months, and a
complete implementation is roughly one year away.
This is similar in spirit to <a
href="http://www.gnu.org/software/classpath/classpath.html">GNU
Classpath.</a>
We encourage GNOME developers to continue using the existing tools,
libraries and components. Improvements made to GNOME will have an
impact on Mono, as they would be the "backend" for various classes.
Q: Will you accept code under the XXX License?
Q: Will Mono include compatibility with Bonobo components? What is the
relationship between Mono and Bonobo?
A: If the XXX License is compatible with the license we use in that
specific piece of code, then yes. If you want to use the BSD license, make
sure you use the BSD license without the advertisement clause (The
`Ousterhout License').
A: Yes, we will provide a set of classes for implementing and using
Bonobo components from within Mono. Mono should allow you to write
Bonobo components more easily, just like .NET on Windows allows you
to export .NET components to COM.
** Mono and .NET
Q: Does Mono depend on GNOME?
A: No, Mono does not depend on GNOME. We use a few packages produced by
the GNOME team like the `glib' library.
Q: But will I be able to build GNOME applications?
A: Yes, we will enable people to write GNOME applications using Mono.
<a name="gui"></a>
** GUI applications
Q: Will Mono enable GUI applications to be authored?
A: Yes, you will be able to build GUI applications. Indeed, that is our
main focus. We will provide both the Windows.Forms API and the Gtk# AP(I.
Q: What is the difference between Gtk# and System.Windows.Forms?
A: Gtk# is a set of bindings for the Gtk+ toolkit for C# (and other
CIL-enabled languages). System.Windows.Forms is an API defined
by Microsoft to build GUI applications.
Q: Will I be able to run my smart clients on systems powered by Mono?
A: As long as your applications are 100% .NET and do not make use
of P/Invoke to call Win32 functions, your smart client applications
will run on Mono platforms.
<a name="msft"></a>
** Mono and Microsoft
Q: Is Microsoft helping Ximian with this project?
A: No. Ximian CTO Miguel de Icaza had a friendly conversation with
Microsoft software architect David Stutz, but that's about the
extent of the contact. Microsoft is interested in other
implementations of .NET and are willing to help make the ECMA spec
more accurate for this purpose.
Ximian representatives have also spoken with Sam Ruby at the ECMA
TG3 committee to discuss the same issues.
Q: Is Microsoft or Corel paying Ximian to do this?
A: No.
Q: Do you fear that Microsoft will change the spec and render Mono
useless?
A: No. Microsoft proved with the CLI and the C# language that it was
possible to create a powerful foundation for many languages to
interoperate. We will always have that.
Even if changes happened in the platform which were undocumented,
the existing platform would a value on its own.
Q: Are you writing Mono from the ECMA specs?
A: Yes, we are writing them from the ECMA specs and the published
materials in print about .NET.
Q: If my applications use Mono, will I have to pay a service fee?
Q: If applications use Mono, does that mean that I have to pay a service fee?
A: No. Mono is not related to Microsoft's initiative of
software-as-a-service.
software-as-a-service.
Q: Is the Mono Project is related to the Microsoft Hailstorm effort? Is
Ximian endorsing Hailstorm?
Q: If you implement .NET, will I depend on Microsoft Passport to run my software?
A: No. The Mono Project is focused on providing a compatible set of
tools for the Microsoft .NET development platform. It does not
address, require, or otherwise endorse the MS Passport-based
Hailstorm single sign-on system that is part of Windows XP and
other services.
A: No. The .NET Framework is a runtime infrastructure and collection
of class libraries. Passport may be required to access certain web
services written for that framework, but only if the programmer
chooses Passport as the authentication mechanism.
Q: Will Mono or .NET applications depend on Microsoft Passport?
Q: Is .NET just a bunch of marketing slogans?
A: No. MS Passport is unrelated to running .NET compatible applications
produced with the Mono tools. The only thing you will need is a
just-in-time compiler (JIT).
A: Although the `.NET initiative' is still quite nebulous, The .NET Framework
has been available for some time. Mono is not an implementation of the .NET
initiative, just the development framework.
Q: What is a 100% .NET application?
@@ -299,83 +196,123 @@ A: A `100% .NET application' is one that only uses the APIs defined
applications would in theory run unmodified on Windows, Linux,
HP-UX, Solaris, MacOS X and others.
Q: If Microsoft will release a port of their .NET platform under the
`Shared Source' license, why should I bother with anything else?
Q: But Microsoft will release a port of the real thing under the
`Shared Source' license, why bother with anything else?
A: The Shared Source implementation will be expensive and its uses
will be tightly restricted, especially for commercial use. We are
working towards an implementation that will grant a number of
important rights to recipients: use for any purpose,
A: The Shared Source implementation will not be usable for commercial
purposes. We are working towards an implementation that will grant
a number of rights to recipients: use for any purpose,
redistribution, modification, and redistribution of modifications.
This is what we call <a
href="http://www.gnu.org/philosophy/free-sw.html">Free Software</a>
Q: Is Mono a free implementation of Passport?
** Passport
A: No. Mono is just a runtime, a compiler and a set of class
libraries.
Q: Is this a free implementation of Passport?
Q: Will the System.Web.Security.PassportIdentity class mean
A: No. Passport is part of Microsoft's Hailstorm initiative. Mono
is just a runtime, a compiler and a set of class libraries.
Q: Will the System.Web.Security.PassportIdentity class, mean
that my software will depend on Passport?
A: No. Applications may use that API to contact a Passport site, but
are not required to do so.
A: No. That just means that applications might use that API to
contact a Passport site.
As long as your application does not use Passport, you will not
need Passport.
Q: Will Mono running on Linux make Passport available for Linux?
It might even be possible to implement that class with
a set of dummy functions, or use an alternate Passport implementation.
A: No. However, the Passport toolkit for Linux-based web servers is
available from Microsoft.
We do not know at this time whether the Passport protocol is
documented and whether we will be able to talk to
passport.com
Q: What is your opinion?
A: You can read my personal <a href="passport.html">opinion on
passport</a>.
** Mono and Windows
Q: Will Mono allow me to run Microsoft Office on Linux?
A: No, it will not. Microsoft Office is a Windows application. To
learn more about running Windows applications on Intel Unix systems
refer to <a href="http://www.winehq.com">the Wine Project</a>.
run Windows applications on Intel Unix systems refer to <a
href="http://www.winehq.com">the Wine Project</a>
<a name="pnpproject"></a>
** Mono and Portable.NET
** GNOME
Q: What are the differences between Mono and Portable.NET?
Q: How is this related to GNOME?
A: Most of Mono is being written using C#, with only
a few parts written in C (The JIT engine, the runtime, the
interfaces to the garbage collection system). The Portable.NET
Project is using C for development.
A: In a number of ways:
* Mono will use existing
components that have been developed for GNOME when it makes
sense. For example on X systems, we will use Gtk+ and
Libart to implement Winforms and the Drawing2D API.
For database access, we will use LibGDA (not really
depending on GNOME, but related to).
* This project was born out of the need of providing improved
tools for the GNOME community.
* We would like to add support to our CLR implementation to
deal with GObjects (in GNOME 1.x, they are called
GtkObjects), and allow Mono developers to provide GObjects
or use and extend existing GObjects.
Q: Has the GNOME Foundation or the GNOME team adopted Mono?
A: Mono is too new to be adopted by those groups. We hope that the
tools that we will provide will be adopted by free software
programmers including the GNOME Foundation members and the GNOME
project generally.
Q: Should GNOME programmers switch over to Mono?
A: Mono will not be ready even within the next six months, and a
complete implementation is probably one year away.
We encourage GNOME developers to continue using the existing tools,
libraries and components. Improvements made to GNOME will have an
impact on Mono, as they will provide the "backend" for various
classes.
Q: Will Mono include compatibility with Bonobo components?
A: Yes, we will provide a set of classes for implementing and using
Bonobo components from within Mono.
** Mono and the Web
Q: Is Mono a way of running Java applets?
A: No.
<a name="webservices"></a>
** Web Services
Q: How is Mono related to Web Services?
Q: Is Mono just a new way of writing Web Services?
A: Mono is only related to Web Services in that it will implement the
same set of classes that have been authored in the .NET Framework
to simplify and streamline the process of building Web Services.
A: No.
But most importantly, Mono is an Open Source implementation of the
.NET Framework.
Q: Can I author Web Services with Mono?
A: You will be able to write Web Services on .NET that run on Mono and
viceversa.
Q: If Mono implements the SDK classes, will I be able to write and
execute .NET Web Services with it?
Q: If this implements the SDK classes, will I be able to write and
execute .NET Web Services with this?
A: Yes. When the project is finished, you will be able to use the
same technologies that are available through the .NET Framework SDK
on Windows to write Web Services.
A: Yes, you will.
Q: What about Soup? Can I use Soup without Mono?
When the project is finished, you will be able to use the same
technologies that are available through the .NET Framework SDK on
Windows to write Web Services.
A: Soup is a library for GNOME applications to create SOAP servers and
SOAP clients, and can be used without Mono. You can browse the
source code for soup using <a
href="http://cvs.gnome.org/bonsai">GNOME's Bonsai</a>.
Q: What about Soup?
A: Soup is a library for GNOME applications to create SOAP server and
SOAP clients. You can browse the source code for soup using <a
href="http://cvs.gnome.org/bonsai">GNOME's Bonsai</a>
Q: Can I use CORBA?
@@ -393,8 +330,7 @@ Q: Can I serialize my objects to other things other than XML?
A: Yes, although the serializing tools have not yet been planned, and
you would probably have to implement them yourself.
<a name="devel"></a>
** Development Tools and Issues
** Development Tools
Q: Will it be possible to use the CLI features without using bytecodes
or the JIT?
@@ -407,34 +343,14 @@ A: Yes. The CLI engine will be made available as a shared library.
Q: Will you have new development tools?
A: With any luck, Free Software enthusiasts will contribute tools to
A: Hopefully Free Software enthusiasts will contribute tools to
improve the developer environment. These tools could be developed
initially using the Microsoft implementation of the CLI and then
initially using Microsoft implementation of the CLI and then
executed later with Mono.
Q: What kind of rules make the Common Intermediate Language useful for
JITers?
A: The main rule is that the stack in the CLI is not a general purpose
stack. You are not allowed to use it for other purposes than
computing values and passing arguments to functions or return
values.
At any given call or return instruction, the types on the stack
have to be the same independently of the flow of execution of your
code.
Q: Is it true that the CIL is ideal for JITing and not efficient for
interpreters?
A: The CIL is better suited to be JITed than JVM byte codes, but you
can interpret them as trivially as you can interpret JVM byte
codes.
<a name="java">
** Mono and Java
Q: Why don't you use Java? After all, there are many languages that
Q: What about using Java? After all there are many languages that
target the Java VM.
A: You can get very good tools for doing Java development on free
@@ -453,36 +369,26 @@ A: You can get very good tools for doing Java development on free
wide variety of programming languages, and has a set of rules
designed to be optimal for JITers.
Q: Could Java target the CLI?
A: Yes, Java could target the CLI. We have details on a <a
href="ideas.html#guavac">project</a> that someone could take on to
make this happen.
Q: What kind of rules make the Common Intermediate Language useful for
JITers?
Microsoft has an implemenation of the Java language called J# that
can target the CIL execution engine.
A: The main rule is that the stack in the CLI is not a general purpose
stack. You are not allowed to use it for other purposes than
computing values and passing arguments to functions or return
values.
Q: Is it possible to write a JVM byte code to CIL convertor?
At any given call or return instruction, the types on the stack
have to be the same independently of the flow of execution of your
code.
A: Yes, it is possible. Here are a few starting point:
Q: I heard that the CIL is ideal for JITing and not efficient for
interpreters, is this the case?
<ul>
* A byte code representation is really a flattened forest of
trees. Look at the Mono JIT engine to see how we compute
the basic blocks (this is used to figure out the "trees").
A: The CIL is better suited to be JITed than JVM byte codes, but you
can interpret them as trivially as you can interpret JVM byte
codes.
The forest is just an array of trees.
Indeed, run the JIT engine with -d (mono -d prog.exe) and
you will see how these trees look like.
You will have to do something similar for Java.
* Each "forest of trees" has a meaning. This meaning can now
be translated into the equivalent "meaning" in CLR-land.
</ul>
<a name="extending"></a>
** Extending Mono
Q: Would you allow other classes other than those in the
@@ -501,18 +407,7 @@ A: Yes. The Microsoft class collection is very big, but it is by no
For more information on extending Mono, see our <a
href="ideas.html">ideas</a> page.
Q: Do you plan to Embrace and Extend .NET?
A: Embracing a good technology is good. Extending technologies in
incompatible ways is bad for the users, so we do not plan on
extending the technologies.
If you have innovative ideas, and want to create new classes, we
encourage you to make those classes operate correctly well in both
Mono and .NET
<a name="portability"></a>
** Portability
** Mono and portability
Q: Will Mono only work on Linux?
@@ -526,23 +421,9 @@ A: Our main intention at Ximian is to be able to develop GNOME
applications with Mono, but if you are interested in providing a
port of the Winform classes to other platforms (frame buffer or
MacOS X for example), we would gladly integrate them, as long
they are under an open source license.
they are under a Free Software License.
Q: Will Mono run on Windows?
A: We hope so. Currently some parts of Mono only run on Windows
(the C# compiler is a .NET executable) and other parts have only
been compiled on Linux, but work on Windows with Cygwin.
Q: Will Mono depend on GNOME?
A: It will depend only if you are using a particular assembly (for
example, for doing GUI applications). If you are just interested
in Mono for implementing a `Hello World Enterprise P2P Web
Service', you will not need any GNOME components.
<a name="reuse"></a>
** Reusing Existing Code
** Reusing existing Code
Q: What projects will you reuse or build upon?
@@ -552,9 +433,9 @@ A: We want to get Mono in the hands of programmers soon. We are
Q: What about Intel's research JIT framework, ORP?
A: At this time, we are investigating whether we can use elements of
ORP for Mono. ORP is a research JIT engine that has a clearly
ORP for Mono. ORP is a research JIT engine that has a clear
defined API that splits the JIT from the GC system and the actual
byte code implementation.
byte code implementation. It is a research product.
Q: What about using GNU Lightning?
@@ -562,16 +443,89 @@ A: We are also researching <a
href="http://www.gnu.org/software/lightning/lightning.html">GNU
Lightning</a>.
<a name="gcc"></a>
** Ximian and Microsoft
Q: Didn't Miguel de Icaza say that `Unix Sucks'?
A: Yes, he did, as a catch phrase in his opening remark on the Ottawa
Linux Symposium. His talk focused on various ways to improve Unix.
There is a paper describing some ways to improve Unix at:
<a href="http://primates.ximian.com/~miguel/bongo-bong.html">
http://primates.ximian.com/~miguel/bongo-bong.html</a>
Q: Didn't Ximian's Miguel work for Microsoft?
A: Actually, Nat Friedman (Ximian's co-founder) did work as an
intern for Microsoft for one summer but Miguel did not.
Q: Did Nat and Miguel meet at Microsoft?
A: They met online on the Linux IRC network; They met in person for
the first time in 1997.
** Mono and Microsoft
Q: How can you expect Mono to compete with Microsoft, wont this
require an effort too large?
A: You are right. Mono will never become a reality without the help
of other contributors. Ximian is a small company that can not
finish Mono alone. We will be working with members of the
community to deliver the product.
Q: Is Microsoft and Corel involved in the Mono implementation?
A: No, they are not.
Q: Are you writing Mono from the ECMA specs?
A: yes, we are writing them from the ECMA specs and the published
materials in print about .NET
** Acronyms
Q: What is the difference between CLR (Common Language Runtime) and
CLI (Common Language Infrastructure)?
A: CLI is the specification of an execution system. The Microsoft
implementation of this specification is named CLR.
Unless we come up with our own acronym, we could just call ours
also CLR, just because it would do exactly the same thing the
Microsoft implementation does.
<a name="gcc">
** Mono and GCC
Q: Are you working on a GCC front-end to C#? A GCC backend that will
generate CIL images? What about making a front-end to GCC that
takes CIL images and generates native code?
Q: Should someone work on a GCC front-end to C#?
A: We are currently seeking volunteers for those projects.
Visit the <a href="contributing.html">contributing</a> section if
you are interested.
A: I would love if someone does, and we would love to help anyone that
takes on that task, but we do not have the time or expertise to
build a C# compiler with the GCC engine. I find it a lot more fun
personally to work on C# on a C# compiler, which has an intrinsic
beauty.
Q: Should someone make a GCC backend that will generate CIL images?
A: I would love to see a backend to GCC that generates CIL images. It
would provide a ton of free compilers that would generate CIL
code. This is something that people would want to look into
anyways for Windows interoperation in the future.
Q: What about making a front-end to GCC that takes CIL images and
generates native code?
A: I would love to see this, specially since GCC supports this same
feature for Java Byte Codes. You could use the metadata library
from Mono to read the byte codes (ie, this would be your
"front-end") and generate the trees that get passed to the
optimizer.
Ideally our implementation of the CLI will be available as a shared
library that could be linked with your application as its runtime
support.
Q: But would this work around the GPL in the GCC compiler and allow
people to work on non-free front-ends?
@@ -581,110 +535,75 @@ A: People can already do this by targeting the JVM byte codes (there
Q: Why are you writing a JIT engine instead of a front-end to GCC?
A: We want the JIT engine and runtime engine because they will be able
to execute CIL executables generated on Windows, and so no recompilation
will be necessary.
A: The JIT engine and runtime engine will be able to execute CIL
executables generated on Windows.
** Mono and GNU
Q: Is Mono part of the GNU project?
A: Mono is a Ximian project, that is also part of the GNU project.
** Mono and Portability
Q: Will Mono work on other variants of Unix?
A: Yes. We do not expect to add any gratuitous incompatibilities.
Q: Will Mono run on Windows?
A: Hopefully yes. Currently some parts of Mono only run on Windows
(the C# compiler is a .NET executable) and other parts have only
been compiled on Linux, but work on Windows with Cygwin.
Q: Will Mono depend on GNOME?
A: It will depend only if you are using a particular assembly (for
example, for doing GUI applications). If you are just interested
in Mono for implementing a `Hello World Enterprise P2P Web
Service', you will not need any GNOME component.
<a name="performance"></a>
** Performance
Q: How fast will Mono be?
Q: How fast will be Mono?
A: We can not predict the future, but a conservative estimate is that
it would be at least `as fast as other JIT engines'.
We would like to ship various JIT engines with Mono, just like
Microsoft has done with their .NET development platform. We could
provide a faster, JIT for fast load times but lower performance,
and an and an optimizing JIT that would be slower at generating
code but produce more optimal output.
Now, wishfully thinking I hope that we will ship various JITs with
Mono just like Microsoft has done. A fast JITer when maximum
performance is not needed, but fast load times are important; And
an optimizing JITer that would be slower at generating code but
produce more optimal output.
The CIL has some advantages over the Java byte code: it is really
an intermediate representation and there are a number of
restrictions on how you can emit CIL code that simplify creating
better JIT engines.
For example, on the CIL, the stack is not really an abstraction
available for the code generator to use at will. Rather, it is a
way of creating a postfix representation of the parsed tree. At
any given call point or return point, the contents of the stack are
For example, on the CIL the stack is not really an abstraction
available for the code generator to use at will: it is just a way
of creating a postfix representation of the parsed tree. At any
given call point or return point, the contents of the stack are
expected to contain the same object types independently of how the
instruction was reached.
instructions was reached.
<a name="licensing"></a>
** Licensing
Q: Will I be able to write proprietary applications that run with
Mono?
A: Yes. The licensing scheme is planned to allow proprietary
developers to write applications with Mono.
Q: What license or licenses are you using for the Mono Project?
A: The C# Compiler is released under the terms of the <a
href="http://www.opensource.org/licenses/gpl-license.html">GNU GPL</a>. The runtime
libraries are under the <a
href="http://www.opensource.org/licenses/lgpl-license.html">GNU
Library GPL</a>. And the class libraries are released
under the terms of the <a
href="http://www.opensource.org/licenses/mit-license.html">MIT X11</a>
license.
Q: I would like to contribute code to Mono under a particular
license. What licenses will you accept?
A: We will have to evaluate the licenses for compatibility first,
but as a general rule, we will accept the code under the same
terms of the "container" module.
<a name="patents></a>
** Patents
Q: Could patents be used to completely disable Mono (either submarine
patents filed now, or changes made by Microsoft specifically to
create patent problems)?
A: No. First, its basic functional capabilities have pre-existed too
long to be held up by patents. The basic components of Mono are
technologically equivalent to Sun's Java technology, which has been
around for years. Mono will also implement multi-language and
multi-architecture support, but there are previous technologies
such as UCSD p-code and ANDF that also support multiple languages
using a common intermediate language. The libraries are similar
to other language's libraries, so again, they're too similar to
be patentable in large measure.
However, if Microsoft does patent some technology, then our plan is
to either (1) work around it, (2) chop out patented pieces, (3)
find prior art that would render the patent useless.
Not providing a patented capability would weaken the
interoperability, but it would still provide the free software /
open source software community with good development tools, which
is the primary reason for developing Mono.
<a name="etc"></a> **
Miscellaneous Questions
** Assorted questions
Q: You say that the CLI allows multiple languages to execute on the
same environment. Isn't this the purpose of CORBA?
A: The key difference between CORBA (and COM) and the CLI is that the
CLI allows "data-level interoperability" because every
language/component uses the same data layout and memory management.
A: CORBA can be used for this purpose, but think of CORBA mostly as a
inter-process (local machine or remote machine) communication
system.
This means you can operate directly upon the datatypes that someone
else provides, without having to go via their interfaces. It also
means you don't have to "marshall" (convert) parameters (data
layouts are the same, so you can just pass components directly) and
you don't have to worry about memory managment, because all
languages/components share the same garbage collector and address
space. This means much less copying and no need for reference
counting.
Think of the CLI to be targeted to interoperation of languages in
the same process, and CORBA as being a nifty addition for
out-of-process.
Q: Will you support COM?
Sure, we have used CORBA for in-proc components, but the lack of an
ABI for in-proc components does not translate into a good framework
for in-proc systems
A: The runtime will support XPCOM on Unix systems and COM on Windows.
Most of the code for dynamic trampolines exists already.
+1 -73
View File
@@ -1,39 +1,15 @@
* Ideas
There are many pending classes that need to be implemented. Those have
the highest impact in the Mono project: the sooner they are done,
the sooner we can start using this platform to create new and
exciting applications.
That being said, if you are not very excited about working on class
libraries, here is a list of other related projects or tools that might
be useful to the Mono project.
Here are a few ideas of tools, classes and projects that you
could start. More are forthcoming.
<a name="runtime">
** Runtime
We need a verifier that can be run on an executable (assembly)
and tells whether the metadata for the executable is correct
or not. It should report any anomalies.
For a list of anomalies in assemblies, check the various assertions
that are described on the ECMA documentation.
This will help test our generated executables and can be also
used as an external verifier.
<a name="classes">
** Classes
<ul>
TODO=jxta,The JXTA Peer to Peer foundation
* Implement a JXTA protocol implementation:
<a href="http://www.jxta.org">http://www.jxta.org</a>
TODO=camel,Mail API
* Implement a Mail API, similar to Camel or JavaMail (Camel has
significant architecture features that are required on a real
mailer).
@@ -42,71 +18,23 @@ TODO=camel,Mail API
<a href="http://cvs.gnome.org/bonsai/rview.cgi?dir=evolution%2Fcamel">
Camel implementation</a>.
Such an implementation could be used both with
Microsoft .NET and Mono.
TODO=multimedia
* Interfacing to Multimedia systems. You might want
to look into the Quicktime API. I know <a
href="mailto:[email protected]">Vladimir</a> has
researched the problem before
</ul>
<a name="projects">
** Projects
<ul>
TODO=xmlStorage,
* Implement an xmlStorageSystem for the CLI:
<a href="http://www.soapware.org/xmlStorageSystem">
http://www.soapware.org/xmlStorageSystem</a>
TODO=guavac,Java compiler for .NET
* You could take one of the existing Java compilers
(Guavac comes to mind as it is so nice) and modify
it to generate .NET code rather than JVM byte
codes.
This should be a pretty straightforward task.
Guavac has the advantage of being written in C++ and
it could be compiled with the Microsoft Managed C++
compiler and produce a .NET executable with it.
TODO=CORBA,CORBA implementation
* Build a CORBA interoperability engine for the CLR.
You do not need to do all of the work, just talking
the protocol will get us a long way (<a
href="http://www.omg.org">The OMG site</a> has the
CORBA specs).
Get in touch with David Taylor (dtaylo11 at bigpond
dot net dot au) as he has been working on this
project.
TODO=Bonobo,Bonobo for Mono
* Once CORBA is done, implement the Bonobo interfaces
to allow people to use Bonobo components in Mono and
Mono components with Bonobo. The best of both worlds!
TODO=moniker,Object Naming System with Monikers
* A naming space for Mono. An object naming space is
a very powerful tool. Bonobo implements a moniker
system that is more powerful than the original
moniker concept that was pioneered by COM/OLE in the
Microsoft world.
Our implementation builds on a concept, and we have
made it simpler, more powerful, more extensible and
a much better mechanism than the equivalent monikers
on Windows.
Implementing Mono monikers would benefit both
Windows users using .NET and Mono users on Unix and
Windows.
Here is <a
href="http://primates.ximian.com/~miguel/monikers.html">an
overview of the moniker system</a> in Bonobo.
href="http://www.omg.org">The OMG site</a> has the CORBA specs).
</ul>
+24 -893
View File
@@ -1,908 +1,39 @@
<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.
** Jul 14, 2001
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>.
A <a
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>
You can read our <a href="rationale.html">rationale</a> for
this project. If you have questions about the project, please
read our list of <a href="faq.html">Frequently Asked
Questions</a> or <a href="mailto:[email protected]">contact us.</a>
** Jul 12, 2001
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>
** Jul 9, 2001
Today <a href="http://www.ximian.com">Ximian</a> announced the
launch of the Mono
project, an effort to create a free software
(sometimes called open source) implementation of the .NET
Development Framework.
If you have questions about the
project, please read our list of <a
href="faq.html">Frequently Asked Questions</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.
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.
Hello World consits of 1821 CIL instructions,
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
href="download.html#july-17">here</a>
Do not forget to check out the updated <a href="faq.html">FAQ</a>.
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
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>
+13 -75
View File
@@ -1,26 +1,3 @@
* Updates
<b>Sep 20, 2001:</b> Microsoft has just announced some changes
to passport that are rather interesting. This document
reflects the Passport system without taking into account the
new changes.
Read about it <a href="http://www.microsoft.com/presspass/features/2001/sep01/09-20passport.asp">here</a>.
For an analysis of security problems with passport, check <a
href="http://avirubin.com/passport.html">http://avirubin.com/passport.html</a>.
The bottom line is that you should not put any sensitive
information on passport.
I have received many comments from people, and I have updated
the page accordingly. From removing incorrect statements, to
fixing typos, to include mentions to other software pieces.
I also corrected my statement about IIS and a trojan horse, I
should read a more educated press in the future. My apologies
to Microsoft and its employees on this particular topic. IIS
did not have a trojan horse built in.
* Microsoft Hailstorm and Passport
Microsoft Passport is a centralized database hosted by
@@ -37,7 +14,7 @@
** Passport
Passport is important not because of it being a breakthrough
Passport is important not because of it being breaktrough
technologically speaking, but because the company is in a
position to drive most people toward being suscribers of it.
@@ -98,7 +75,12 @@
at the corporate level policy, but also the fact that
the source code for Microsoft products is not
available, means that trojans or worms could be built
into the products by malicious engineers.
into the products by malicious engineers. This is not
unheard of, as the <a
href="http://slashdot.org/articles/00/04/14/0619206.shtml">Microsoft
Internet Server</a> had a trojan horse built into that
allowed anyone that knew about this to control any
server running IIS.
* <b>Security:</b> With a centralized system like
Passport, imagine the repercussions of a malicious
@@ -109,21 +91,7 @@
Hackers have already <a
href="http://slashdot.org/articles/00/10/27/1147248.shtml">broken
into Microsoft</a> in the past. And the company was
unable to figure out for how long their systems had
been hacked.
Security holes have been found in <a
href="http://slashdot.org/articles/00/04/14/0619206.shtml">IIS
in the past.</a> If all the world's data is stored on
a central location, when a single security hole is
detected, it would allow an intruder to install a
backdoor within seconds into the corporate network
without people ever noticing.
Microsoft itself has been recently hit by worms,
imagine if all your business depended on a single
provider for providing all or your authentication
needs
unable to figure out for how long their systems had been hacked.
</ul>
Microsoft might or might not realize this. The idea behind
@@ -144,15 +112,6 @@
system should not create an internet `blackout' in the
case of failure.
A distributed system using different software
platforms and different vendors would be more
resistent to an attack, as holes in a particular
implementation of the server software would not affect
every person at the same time.
A security hole attack might not even be relevant to
other software vendors software.
* <b>Allow for multiple registrars:</b> Users should
be able to choose a registrar (their banks, local
phone company, service provider, Swiss bank, or any
@@ -170,14 +129,10 @@
possibility of replicating and caching public information
about the user.
For instant messaging (another piece of the Hailstorm bit),
For instant messaging (another pieces of the Hailstorm bit),
you want to use a non-centralized system like Sun's <a
href="http://www.jxta.org">JXTA</a>. Some people mailed me to
mention Jabber as a messaging platform and other people
pointed out to the <a
href="http://java.sun.com/products/jms/">Java Message
Service</a>. The JMS does support a number of very
interesting features that are worth researching.
mention Jabber as a messaging platform.
It could also just use the user e-mail address as the `key' to
choose the registrar (msn.com, hotmail.com -> passport.com;
@@ -208,7 +163,7 @@
** Deploying it
The implementation of such a system should be a pretty
straightforward task once security cryptographers have
straightforward tasks once security cryptographers have
designed such a beast.
The major problems are:
@@ -233,7 +188,7 @@
** Passport and Mono
The .NET class libraries include a Passport class that
The .NET class libraries includes a Passport class that
applications might use to authenticate with Passport. Since
we do not have information at this point on the exact protocol
of Passport, it is not even feasible to implement it.
@@ -252,18 +207,6 @@
Currently, we are too far from the point where this is a real
issue.
** Passport and endangering Open Source.
A few people have said: `Mono will allow Passport to be
available for Linux and that is bad'. This is plain
misinformation.
Currently, you can obtain Passport for Linux from Microsoft
itself and deploy it today on your Web server. Mono does not
even enter the picture here. Go to passport.com and download
the toolkit and you will see with your own eyes that passport
is <B>already</b> available for Linux.
** Disclaimer
This is just a group of personal thoughts of mine that I have
@@ -276,12 +219,7 @@
Nat Friedman (Ximian's co-founder) has his own ideas on how a
competing system to Passport could be designed, but I will let
<a href="http://www.nat.org/">him</a> post his own story.
** Other Passport Comments
An interesting study on the security of passport is available at: <a
href="http://avirubin.com/passport.html">http://avirubin.com/passport.html</a>
<a href="http://www.nat.org/gym">him</a> post his own story.
** Other Alternatives
-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.
-46
View File
@@ -1,46 +0,0 @@
To: [email protected], [email protected]
Subject: July 12 snapshots.
FCC: ~/Mail/outbox.txt
X-Windows: Sometimes you fill a vacuum and it still sucks.
--text follows this line--
Hey!
July 12 snapshots of class libraries, the compiler and the mono
runtime are available.
New on this release:
* Runtime (module: mono)
The beginning of a simple interpreter that Paolo started
workign on (can run really simple .NET programs).
Disassembler copes with more elements of the binary format and
more tokens are decoded. Paolo is working now on moving some
of these to the metadata library.
More tables are dumped.
* Class libraries (module: mcs/class)
Many new more classes are in from Joe, Vladimir, Jeff, Sean
and yours truly.
Sean fixed the build process, and it is now possible to
compile with a single command the assemblies. We will be
revisiting this mechanism in the future to compile per-OS
assemblies (ie, Unix, Windows, MacOS, etc).
* Compiler (module mcs/mcs)
Not much done this week, just a few fixes here and there, and
more work to make it easy to compiler.
* Documentation (module: mono/doc)
All the changes to the web site are there for your browsing
pleasure. We still need to integrate the status system in
there.
Miguel.
-43
View File
@@ -1,43 +0,0 @@
To: [email protected]
Subject: Sunday snapshot available.
Gcc: mail.2001-07
--text follows this line--
Hey guys,
I promise I will not be doing these so often once we have the CVS
server up. In the meantime:
* MCS
Sean got the classes to compile in a single go. You
will need CygWin (www.cygwin.org) to compile though
(GNU make and stuff is required).
System.Xml.XmlReader contribution from Jason
(WOOHHOO!!). It also contains a nice test-suite for
his functions, and in his new code bit, his
implementation is faster than Microsoft's
We now ship `jay' as part of the distribution to allow
you to compile the compiler with the same `make'
command. Small fixes to the parser as well were
introduced.
* Mono 0.4
Paolo's interpreter supports call instructions and has
the test suite program that he posted about.
All documentation ships now in the mono-0.4.tar.gz
Notes:
As usual, MCS is targeted to be compiled on a Windows machine
(you will need Cygwin).
Mono is targeted to be compiled on a Unix machine or a Windows
machine running Cygwin.
Miguel.
+26 -73
View File
@@ -7,64 +7,9 @@
If you want to send suggestions for links, address them to <a
mailto="[email protected]">[email protected]</a>.
** Microsoft .NET
The <a href="http://msdn.microsoft.com/net">Microsoft.NET site.</a>
The Microsoft .NET Framework 1.0 can be downloaded <a href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml&frame=true">here</a>
New methods that are not documented in 1.0, are documented <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/html/framewrkaddend.asp">here</a>
** IRC
Various Mono contributors get together on channel #mono on
irc.gnome.org
** Mono related sites.
Sergey's web page on Mono resources:
<a href="http://mono.eurosoft.od.ua">http://mono.eurosoft.od.ua</a>
Got Dot Net:
<a href="http://www.gotdotnet.com">Got Dot Net</a>
MonoMail:
<a href="http://sourceforge.net/projects/monomail/">http://sourceforge.net/projects/monomail/</a>
Zip classes:
Mike's port to .NET: <a
href="http://www.icsharpcode.net/OpenSource/NZipLib/default.asp">NZipLib</a>
.NET Security:
A nice overview paper on the <a
href="http://www.foundstone.com/pdf/dotnet-security-framework.pdf">.NET
security architecture</a>.
** Presentations
Currently the <a href="Presentations/O-Reilly">O'Reilly</a>
presentation on Mono is available. Arturo Espinosa has given
a talk on Mono in Mexico and made <a
href="http://construct.ximian.com/~arturo/Presentations/Mono.OLS/html">spanish
slides</a>
** ECMA Documentation.
You can get the documentation for the ECMA specs from:
<ul>
* <a href="http://www.ecma.ch/ecma1/STAND/ecma-334.htm">C# Language Specification</a>
* <a href="http://www.ecma.ch/ecma1/STAND/ecma-335.htm">Common Language Infrastructure</a>
</ul>
Older copies of the standard are available here:
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 +31,28 @@
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-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>
@@ -108,31 +75,17 @@
href="http://www.icsharpcode.net/OpenSource/SD/default.asp">Sharp
Develop:</a> an IDE for the C# language written in C#.
* <a
href="http://janet-js.sourceforge.net/">Janet:</a>
an implemention of ECMAScript (the standarized
version of JavaScript) in C#
* <a
href="http://xmarks.sourceforge.net/doc.html">XMarks DOC.NET:</a> For
creating online documentation you can browse for your own classes.
href="http://www.southern-storm.com.au/portable_net.html">Portable.NET:</a>
* <a href="http://nunit.sourceforge.net">NUnit:</a> A
testing framework for .NET classes.
testing framework for .NET classes.
* <a href="http://www.kaffe.org">Kaffe:</a> A popular
Free Software JIT engine for Java.
* <a href="http://www.intel.com/research/mrl/orp">ORP:</a> A research
JIT/VM/GC system from Intel.
* C# bindings for OpenGL and SDL are available here: <a
href="http://csgl.sourceforge.net">http://csgl.sourceforge.net</a>
* <a
href="http://www.southern-storm.com.au/portable_net.html">Portable.NET:</a>
Another implementation of the CLI and C# compiler.
JIT/VM/GC system from Intel.
</ul>
** GNOME Documentation
+54 -88
View File
@@ -1,112 +1,95 @@
* The Mono runtime
The MonoNet 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 MonoNet 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:
Currently the runtime contains the beginning of an image
loader and metadata access entry points. Since Beta2 has been
now released, it is possible to resume work using the ECMA
specs and testing with Beta2-generated executables.
<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.
The runtime core will be implemented in C, in a library
"libMonoVES.so".
** 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
and metadata tokens (ie, a disassembler).
* Milestone 1: 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> 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>
* 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 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.
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>
Although using a conservative garbage collector like Bohem's
would work, all the type information is available at runtime,
@@ -117,33 +100,17 @@
* Garbage collection list and FAQ:<br>
<a href="http://www.iecc.com/gclist/">http://www.iecc.com/gclist/</a>
* "GC points in a Threaded Environment":<br>
<a href="http://research.sun.com/techrep/1998/abstract-70.html">
http://research.sun.com/techrep/1998/abstract-70.html</a>
* "A Generational Mostly-concurrent Garbage Collector":
<a href="http://research.sun.com/techrep/2000/abstract-88.html">
http://research.sun.com/techrep/2000/abstract-88.html</a>
* Details on The Microsoft .NET Garbage Collection Implementation:<br>
* The Microsoft .NET Garbage Collection Implementation:<br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp</a>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp</a>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI2.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI2.asp</a>
</ul>
** IO and threading
The ECMA runtime and the .NET runtime assume an IO model and a
threading model that is very similar to the Win32 API.
Dick Porter has been working on the Mono abstraction layer
that allows our runtime to execute code that depend on this
behaviour.
** Useful links
Paolo Molaro found a few interesting links:
<ul>
* On compilation of stack-based languages:<br>
<a href="http://www.complang.tuwien.ac.at/projects/rafts.html">
http://www.complang.tuwien.ac.at/projects/rafts.html</a>
@@ -160,8 +127,7 @@
** PInvoke
PInvoke is the mechanism we are using to wrap Unix API calls
as well as talking to system libraries.
Initially we used libffi, but it was fairly slow, so we have
reused parts of the JIT work to create efficient PInvoke trampolines.
PInvoke will be supported, and will be used to wrap Unix API
calls, these in turn are required for reusing some of the
GNOME libraries that will reduce the work we have to do to
deliver a complete class library.
+28 -24
View File
@@ -4,37 +4,41 @@
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). It has a few bugs outstanding (table
dimension computation is incorrect).
* 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).
Parsing of Exception tables is missing.
<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).
It lacks Token to (Table, Index) mapping, but this
should be trivial to write.
* 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>.
* Class Libraries: Only a few classes have been
implemented.
</ul>
Tasks on the critical path:
<ul>
* Method and Field resolution.
* Bytecode interpreter: Not implemented yet.
* Simple JIT: Not implemented yet.
* Garbage collection engine.
</ul>
+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.
+6 -48
View File
@@ -4,64 +4,22 @@
Mono-based solution. Some of these tools can be developed on
Windows before Mono is fully finished.
All of these tools should be written using C#.
For the tools that are typically command line tools: Try to
write these as components that could load their input from
streams or collections of streams, and implement the command
line tools as wrappers around those classes.
For example, we will be making the C# compiler a component
that could be reused by applications that might have a use for
the various bits of the compiler (either to embed the
compiler, or reuse the code generator part of it).
This is important so that these components (compiler,
assembler, linker, etc) can be integrated later into the
visual development environment (hopefully with the help of the
SharpDevelop hackers).
TODO=ilasm,IL Assembler
** IL Assembler.
This assembler should basically take as input a file
containing IL bytecodes as specified in the `Partition II' of
the ECMA spec, and produce a binary file.
TODO=al,Assembly Linker
** Assembly Linker.
This tool is used to construct assemblies, which are basically
deployment units for CLI executables.
TODO=debugger,Debugger
** Debugger
We will need a debugging API to debug CLI applications and
then a debugger component that can be used in an IDE
environment.
TODO=ide,Integrated Development Environment
** Integrated Development Environment
There is already a project to create a C# development
environment: <a
href="http://www.icsharpcode.net/OpenSource/SD/default.asp">SharpDevelop</a>.
People should work with the SharpDevelop hackers to produce a
unified development environment.
environment (SharpDevelop). People could work with the
SharpDevelop hackers to produce a unified development environment.
Please work with the SharpDevelop hackers to build a good IDE.
We will work on creating an embedable compiler component and
an embeddable debugger component that can be used withing
SharpDevelop
TODO=hbrowser,Help Browser
** Help Browser
We need a good help browser that can be used to browse
documentation. Ideally this help browser can accept as input
XML Docbook input and an assorted set of file formats
(Microsoft Help, Unix manual pages, Unix Info pages)
We need a good help browser that can be used to browse all the
Mono documentation.
Look at the GNOME DevHelp for a good set of ideas on how to
implement this.
+2 -16
View File
@@ -3,29 +3,15 @@
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,Download,download.html,download.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 -6
View File
@@ -9,20 +9,16 @@ 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\* (.*)$/) {
print "<li>$1\n";
} elsif (/^Q: (.*)$/){
print "<p><a name=\"q$q\"></a><b>Question $q:</b> $1\n";
print "<p><a name=\"q$q\"><b>Question $q:</b> $1\n";
$q++;
} elsif (/^A: (.*)$/){
print "$1\n";
} elsif (/^TODO=(.*),$/){
print "<a name=\"$1\">\n";
} else {
} else {
print "$_\n";
}
}
-76
View File
@@ -1,76 +0,0 @@
#!/usr/bin/perl
$q = 1;
# Modified by Edwin Lima ([email protected]; [email protected])
# Date: 08/21/01, The Netherlands
# $f: Variable used as a flag to create the list of questions on top of the question-answers set. This
# is the only way that I found to scan the questions which have a <CR><LF>, in such a way that I will not
# scan the answer together at same time.
# @aname: Buffer used to store the question-answers set to print them out just after the print of the
# questions.
# @href: Buffer used to store the anchors (only questions) to the questions-answers set on the bottom
# of the page.
# I opened explicitly the file for input (input.txt) but U can change this as it was originally.
#
#
#comment this line if you are not open the file explicitly
#open(IN, "input.txt") || die "cannot open file input.txt" ;
print("<A name=TOP>") ;
#Uncomment line bellow to make it work as it was originally.
while (<>){
#comment line bellow
#while (<IN>){
chop;
if (/^\* (.*)$/){
push(@aname,"<h1>$1</h1>\n");
# print $body;
} elsif (/^\*\* (.*)$/) {
push(@aname, "<h2>$1</h2>\n");
push(@href, "<h2>$1</h2>\n");
} elsif (/^\*\*\* (.*)$/) {
push(@aname, "<h3>$1</h3>\n");
} elsif (/^$/) {
push(@aname, "<p>\n");
# push(@href, "<p>\n"); NOT NEEDED
} elsif (/^\t\t\* (.*)$/) {
push(@aname, "<li>$1\n");
} elsif (/^Q: (.*)$/){
push(@aname, "<p><a name=\"q$q\"></a><b>Question $q:</b> $1\n");
push(@href,"<p><a href=\"#q$q\"><b>Question $q:</b></a> $1\n");
$f=1;
$q++;
} elsif (/^A: (.*)$/){
push(@aname,"<P>\n<A HREF=#TOP>Top</A>\n<P>");
push(@aname,"$1\n");
$f=0;
} elsif (/^TODO=(.*),$/){
push(@aname, "<a name=\"$1\">\n");
#push(@href, "<a name=\"$1\">\n");
} else {
push(@aname,"$_\n");
if ($f==1) {
push(@href,"$_\n");
}
}
}
foreach $line (@href) #"\n\n";
{
print $line;
}
foreach $line (@aname) #"\n\n";
{
print $line;
}
#comment this line if you are not open the file explicitly
# close(IN) || die "cannot close file" ;
Binary file not shown.

Before

Width:  |  Height:  |  Size: 3.0 KiB

After

Width:  |  Height:  |  Size: 3.3 KiB

+31 -82
View File
@@ -1,90 +1,39 @@
CSCRIPT = $(SYSTEMROOT)/system32/cscript.exe
SOURCES= \
../contributing \
../class-library \
../class-status \
../contact \
../c-sharp \
../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
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
+13 -20
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">
@@ -37,7 +30,7 @@
<tr>
<td><img src="images/pixel.gif"></td><!-- left border -->
<td colspan="4">
<a href="http://www.go-mono.com"><img src="images/mono.gif" border="0"></a></td>
<a href="/"><img src="images/mono.gif" border="0"></a></td>
<td><img src="images/pixel.gif"></td><!-- right border -->
</tr>
<tr>
@@ -54,13 +47,13 @@
</table>
</td>
<td bgcolor="black" width="1"><img src="images/pixel.gif" width="1"></td>
<td bgcolor="white" align="left" width="80%" valign="top">
<td bgcolor="white">
<table cellpadding="16">
<tr><td>
#CONTENT#
</td></tr>
</table>
</td>
</td>
<td bgcolor="black"><img src="images/pixel.gif" width="1"></td>
<td width="100"><img src="images/pixel.gif"></td>
</tr>
-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]
-125
View File
@@ -1,125 +0,0 @@
Just some thoughts for the JITer:
General issues:
===============
We are designing a JIT compiler, so we have to consider two things:
- the quality of the generated code
- the time needed to generate that code
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.
Register Allocation:
====================
With lcc you can assign a fixed register to a tree before register
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.
Different Register Sets:
========================
Most processors have more that one register set, at least one for floating
point values, and one for integers. Should we support architectures with more
that two sets? Does someone knows such an architecture?
64bit Integer Values:
=====================
I can imagine two different implementation. On possibility would be to treat
long (64bit) values simply like any other value type. This implies that we
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
register allocation routines takes care of this non terminal and allocates two
32 bit registers for them.
Forest generation:
==================
Consider the following code:
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.
DAG handling:
=============
Monoburg can't handle DAGs, instead we need real trees as input for
the code generator. So we have two problems:
1.) DUP instruction: This one is obvious - we need to store the value
into a temporary variable to solve the problem.
2.) function calls: Chapter 12.8, page 343 of "A retargetable C compiler"
explains that: "because listing a call node will give it a hidden reference
from the code list". I don't understand that (can someone explain that?), but
there is another reason to save return values to temporaries: Consider the
following code:
x = f(y) + g(z); // all functions return integers
We could generate such a tree for this expression: STLOC(ADD(CALL,CALL))
The problem is that both calls returns the value in the same register,
so it is non trivial to generate code for that tree. We must copy one
register into another one, which make register allocation more complex.
The easier solution is store the result of function calls to
temporaries. This leads to the following forest:
STLOC(CALL)
STLOC(CALL)
STLOC(ADD (LDLOC, LDLOC))
This is what lcc is doing, if I understood 12.8, page 342, 343?
Possible Optimisations:
=======================
Miguel said ORP does some optimisation on IL level, for example moving array
bounds checking out of loops:
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)
-4
View File
@@ -2,12 +2,8 @@ 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])
Sean MacIsaac ([email protected])
Vladimir Vukicevic ([email protected])
Garrett Rooney ([email protected])
Bob Smith ([email protected])
John Barnette ([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 -22
View File
@@ -1,23 +1,2 @@
This contains the Mono C# compiler as well as the Mono runtime
library.
Layout:
class/
Class libraries
errors/
Sample programs that should generate errors by the compiler.
jay/
Yacc-based parser generator.
mcs/
The Mono C# compiler
tests/
Sample tests
Thanks a lot to Sergey Chaban for his help during the development of
the C# compiler.
This is the Ximian MCS C# compiler written in C#
-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
{ }
}
Loaded 100 of 2368 files, more files were not shown because too many files have changed in this diff. Show more