Compare commits

..
1 Commits
Author SHA1 Message Date
nobody c275f7585f This commit was manufactured by cvs2svn to create tag 'MCS_0_8'.
svn path=/tags/MCS_0_8/mcs/; revision=2345
2002-02-11 22:51:46 +00:00
4907 changed files with 57217 additions and 596383 deletions

No files matched your search

-1
View File
@@ -1,3 +1,2 @@
Miguel de Icaza ([email protected])
Paolo Molaro ([email protected])
Dietmar Maurer ([email protected])
-485
View File
@@ -1,485 +0,0 @@
The Mono runtime is licensed under the terms of the GNU
Library General Public License, version 2.
GNU LIBRARY GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.
Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.
Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.
The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.
Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.
However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.
Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.
GNU LIBRARY GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
c) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
d) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!
-269
View File
@@ -1,272 +1,3 @@
Tue Aug 20 15:15:52 CEST 2002 Paolo Molaro <[email protected]>
* configure.in: patch by [email protected] (Daniel Resare)
to error out if bison is missing.
2002-08-17 Gonzalo Paniagua Javier <[email protected]>
* configure.in: don't link against libdl on windoze.
2002-08-12 Dick Porter <[email protected]>
* mono.pc.in: Add $includedir to Cflags
Fri Jul 19 18:38:38 CEST 2002 Paolo Molaro <[email protected]>
* configure.in, Makefile.am, mono.pc.in: add a mono.pc file for use
with pkg-config.
* */Makefile.am: makefile overhaul to create a shared libmono library.
* */*.h: do not include config.h in headers that should be installed.
2002-07-12 Dick Porter <[email protected]>
* acconfig.h:
* configure.in: Check the size of sockaddr_un.sun_path
2002-06-23 Miguel de Icaza <[email protected]>
* man/Makefile.am (man_MANS): Added new man page
* man/mono-config.5: New manual page describing the mono-config
file format.
2002-06-10 Jaroslaw Kowalski <[email protected]>
* configure.in: added checks for MSG_NOSIGNAL
2002-05-30 Daniel Morgan <[email protected]>
* doc/ado-net: update the ado-net web page on go-mono.com
input parameters support, beginnings of Mono.Data.MySQL
and System.Data.OleDb, updated the sample source code,
and output from a PostgresTest
2002-05-21 Martin Baulig <[email protected]>
* mono.1: Documented the "--debug-args" debugging arguments.
2002-05-21 Martin Baulig <[email protected]>
* mono.1: Updated to reflect my latest changes and beautified this a bit.
(FIXME: There are still command line argument which aren't documented here.)
2002-05-19 Daniel Morgan <[email protected]>
* doc/ado-net: updated page to include C# code snippets using
System.Data. Update status: handle reading NULL values, DataSet/DataAdapter
works, executing/reading multiple results, and stored procedures.
And other tweaks about the providers.
2002-05-19 Martin Baulig <[email protected]>
* mono/Makefile.am (SUBDIRS): Added `os', it's referenced by
interpreter/Makefile.am.
Wed May 15 12:22:09 CEST 2002 Paolo Molaro <[email protected]>
* configure.in: search for pthread functions also in libc_r (patch
from Garrett Rooney <[email protected]>).
2002-05-11 Daniel Morgan <[email protected]>
* doc/ado-net: added instructions for installing PostgreSQL on Linux
and for using nant to re-compile just the System.Data.dll assembly
on Windows.
2002-05-10 Rodrigo Moya <[email protected]>
* doc/ado-net: added instructions for compiling System.Data.dll
(a subset of) on Linux.
2002-05-10 Daniel Morgan <[email protected]>
* doc/ado-net: added links
2002-05-09 Dick Porter <[email protected]>
* configure.in: Set CPPFLAGS not CFLAGS (bug 23767)
2002-05-05 Daniel Morgan <[email protected]>
* doc/ado-net: correct formatting
* doc/index: added credit i forgot to add
2002-05-05 Daniel Morgan <[email protected]>
* doc/ado-net: i did not format it correctly earlier, i
tried added various tags where appropriate.
* doc/index: added news item for May 5, 2002 - ado.net able
to retrieve data now
2002-05-05 Daniel Morgan <[email protected]>
* doc/ado-net: updated the current status which
I kept forgetting to do.
2002-05-05 Daniel Morgan <[email protected]>
* doc/ado-net: updated to includes an example for
running ipc-daemon as a Windows service. Thanks
to gonzalo.
2002-05-05 Daniel Morgan <[email protected]>
* doc/ado-net: updated to include installation of
PostgreSQL DBMS under cygwin. It is a TODO for Linux though.
Also included notes on running the System.Data/Test/PostgresTest.cs
that should work on a lot of Mono installations that have
PostgreSQL installed. If not please let me, rodrigo, or gonzalo
know.
2002-05-01 Rodrigo Moya <[email protected]>
* doc/ado-net: updated a little bit.
2002-04-30 Jeffrey Stedfast <[email protected]>
* configure.in: Added checks for timezone stuff.
2002-04-30 Dick Porter <[email protected]>
* acconfig.h:
* configure.in: Added option to disable using shared memory for
handles
2002-04-28 Gonzalo Paniagua Javier <[email protected]>
* configure.in: fix for conditional "THREADS_PTHREAD" was never
defined problem under cygwin with latest version of automake and
autoconf. Patch from Jeroen Janssen <[email protected]>.
2002-04-23 Gonzalo Paniagua Javier <[email protected]>
* configure.in: removed -Wshadow from CFLAGS.
2002-04-12 Rodrigo Moya <[email protected]>
* status/maintainers.xml: added danmorg and myself for System.Data.*
classes.
* status/class.xml: added System.Data.* classes.
2002-04-08 Dick Porter <[email protected]>
* configure.in: Set -mno-cygwin here rather than in the build script
2002-04-05 Dietmar Maurer <[email protected]>
* mono/tests/remoting2.cs: new test for async invoke of proxy calls
2002-03-29 Martin Baulig <[email protected]>
* doc/jit-debug, docs/jit-debug-sample, docs/jit-debug-sample2:
New files, added documentation for the debugging code.
* doc/web/commands: Added the debugging pages.
* docs/jit-debug: Removed, this is now on the web site.
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.
+1 -9
View File
@@ -1,9 +1 @@
AUTOMAKE_OPTIONS = foreign
SUBDIRS = mono doc docs runtime scripts man data
EXTRA_DIST= mono.pc.in mono.spec.in
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA= mono.pc
DISTCLEANFILES= mono.pc
SUBDIRS = mono doc runtime scripts man
-713
View File
@@ -1,716 +1,3 @@
* Sergey Chaban added thread-safe support to
System.Collections.SortedList.
* Fixes to the compiler by Andrew Birkett.
* Tim Coleman contributed the OleDb provider for System.Data and started
work on System.Web.Services.
* Radek fixed a lot of problems on the PPC side. [*]
* Miguel and Martin committed the new type lookup system.
* Dietmar rewrote the marshalling code. [*]
* Peter Williams and Martin contributed the new Makefiles, with help
from Alp Toker as well.
* Contributors to this release:
* Non-Ximian developers: Nick Drochak, Martin Baulig, Tim
Coleman, Mike Kestner, Alp Toker, Jonathan Pryor, Jaime
Anguiano, Piers Haken, Rafael Teixeira, Mark Crichton,
Sergey Chabon, Ajay Kumar Dwivedi, Andrew Birkett, Dennis
Hayes (SWF), Adam Treat, Johannes Roith and Lawrence Pit.
* Ximian developers: Duncan, Ravi, Dick, Dietmar, Paolo,
Gonzalo, Rachel, Radek, Rodrigo, Jeff, Peter Williams and
Miguel.
Special thanks to Duncan for helping me put this release together.
Hello!
A new version of Mono (0.12), is out.
Mono is an open source implementation of the Microsoft.NET
Framework, and ships with a C# compiler, a runtime engine
(with a JIT on x86 cpus) and a set of class libraries.
Mono is know to work on a number of platforms:
x86/Linux, x86/Windows, x86/FreeBSD; sparc/solaris;
linuxppc/linux; strongarm/linux.
There have been many changes since the last release of Mono in
late April, thanks to Duncan for assembling the list of new
features, any omissions are my fault.
Changes since 0.11:
It is hard to keep track of the changes, as there are 1632
patches that were posted to the mailing list. One third of
the total number of patches since we opened mono-patches
list. I am sure I missed some stuff and probably missed some
contributors. I apologize in advance.
Runtime:
Paolo: New Reflection.Emit generation code generates
code that can be executed in Windows. Now binaries
generated by Mono/MCS will run on Windows.
Paolo got Activator.CreateInstance to work.
Sergey's CPU-optimization for CPBLK.
Many many bug fixes to the runtime from Dick, Dan
Lewis, Dietmar, Gonzalo, Martin, Paolo, Radek and Sergey,
Compiler:
Many bug fixes: The compiler can now compile Gtk#,
Vorbis#, System.Data assembly and System.Xml assembly
which previously did not work (Dietmar, Miguel, Paolo,
Piers, Ravi, Miguel). Thanks to all the bug
reporters.
Class Libraries:
Mike started work on System.Xml.XPath
Christian, Dennis, Daniel and friends got more stubs
for System.Windows.Forms in.
Ajay revamped System.Xml.Schema. And Jason and Duncan
updated System.Xml
Daniel also checked in a working CodeDOM
implementation and a C# provider.
Many bug fixes by everyone. Thanks to Daniel, Duncan,
Jonathan, Lawrence, Martin Mike, Nick and Piers. I am
missing a lot of contributors that should be listed.
ASP.NET support
A lot of work from Gonzalo allows some small and
modest ASP.NET applications to run (you still need the
unreleased XSP code though).
System.Data:
Integrated the MySQL provider from Brad Merryl.
Lots of work by Dan, Rodrigo, Tim.
Microsoft.VisualBasic runtime support
Rafael and Chris have been working on the VisualBasic
runtime support DLLs
Hello everyone!
Mono 0.11 is out!
This new version has new features:
* Massive:
* Ultrich Kunitz implemented the whole calendar set of
classes. Yes, thats right. The whole thing, with a
complete test suite. Thanks Ultrich!
* JIT/runtime features:
* Martin's debugging framework is included (see web
site for details on how to use it). (Martin)
* Transparent Proxy has been implemented for the
runtime (lets you run/debug/hack on remoting for Mono) (Dietmar)
* Inline and constant folding/propagation support
in the JIT engine (Dietmar)
* Profiling support for the JIT engine (--profile).
* Cool runtime hacks, that made our compiler twice as fast:
* New string rewrite: faster, speedier, leaner, cooler!
Paolo had been talking about a new string rewrite,
and super hacker Patrik Torstensson started the
implementation, Dietmar then switched the object
layout and the Mono team helped iron out a few of
the details.
* New array reprensetation: Dan Lewis contributed a new
faster and smaller array implementation.
* Improved Reflection.Emit: Paolo improved our
reflection emit code.
* ADO.NET
* Daniel Morgan, Rodrigo Moya have some pieces of the
Sql classes ready to run. he first signs of life
this week (we can connect, insert rows; do transactions:
commit/rollback; SQL errors and exceptions work).
* Http Runtime
* The HTTP runtime (to be used by our ASP.NET implementation)
was contributed by Patrik Torstensson. Patrik not only
contributed a massive ammount of classes, but he immediately
went on to implement ThreadPools and then helped out with the
new String rewrite.
* XML improvements:
* Kral Ferch and Duncan Mak contributed more
improvements to the XML implementation.
* Work on Xml Serialization from John Donagher.
* Documentation:
* MonoDoc ships for the first time!
(John Barnette, Adam Treat and John Sohn)
* New documentation stubs ready to be filled, and translated
included (thanks to our doc team!)
* General fixes:
* Piers Haken fixed many of our attributes and many
little problems that were exposed by his CorCompare tool
* Many Mono C# compiler bug fixes.
* Other improvements:
* NUnit works on Linux! (Patrik Torstensson)
* More NUnit tests (Nick Drochak)
* Windows.Forms progress: Dennis Hayes and Christian
Meyer have been contributing stubs for the
Windows.Forms work.
* Full Parse implementations and bug fixing by Gonzalo
* Dan Lewis contributed some missing classes for the
Regexp implementation.
* Jonathan's trace classes
* This Month's Mono is brought to you by:
Adam Treat, Chris Podugriel, Christian Meyer, Daniel Lewis,
Daniel Morgan, Dennis Hayes, Dick Porter, Dietmar Maurer,
Duncan Mak, Guarav Vaish, Gonzalo Paniagua, Jaime Anguiano,
Jason Diamond, Joe Shaw, John Barnette, John Donagher, John
Sohn, Jonathan Pryor, Kral Ferch, Martin Baulig, Miguel de
Icaza, Mike Kestner, Nick Drochak, Paolo Molaro, Patrik
Tostensson, Piers Haken, Ravi Pratap, Rodrigo Moya, Sergey
Chanben, Ultrich Kunitz, Wictor Wilen.
I know that I missed some features, there is a lot of work
that happens in a month. I apologize in advance for any
features I omited by accident.
Special thanks go to Duncan for helping out with all those
little details in the project. And also Nick who has been
keeping us in good shape by maintaining and helping new
contributors provide more test suites.
* Reporting bugs
If you find a bug in Mono, please file a bug here:
http://bugzilla.ximian.com
That way we wont loose your bug report, and will be able to
follow up properly with it. Also try to provide simple test
cases whenever possible and try as hard as possible to
identify the root of a problem (compiler, runtime, class
libraries).
* Forum
The [email protected] mailing list is open for
those of you who want to discuss the future of Mono.
Hello everyone!
Mono "Self Hosting" 0.10 is out! (Alex insisted I used the
<blink> tag for "Self Hosting", but was dissapointed when he
realized most mailers dont support this).
Too many things have happened since the the 0.9 release,
almost an entire month. The big news is that we are shipping
a the self-hosting Mono C# compiler. This has been tested on
Linux/x86 only.
Also, we delayed the release for one reason or other, but it
turns out that as a extra bonus, Paolo fixed the last
outstanding bug in the JIT engine, so the compiler now runs in
the JIT engine instead of the interpreter.
The mono-0.10 release includes the libraries required to run
the compiler as well as assorted .NET programs [1].
* What is new
There is so much stuff in this release that is hard to keep
track of it.
Jason, Kral and Duncan have done an amazing job with
System.Xml, up to the point that it is even being used by
gtk-sharp's code generator (and it all comes with great test
suites to verify that it works!). Ajay's XmlSchema code is
also shipped.
Martin worked on our debugging infrastructure (the JIT can
load dwarf files, and our class libraries now generate dwarf
debugging info; we are in the process of adding this to the
compiler, the patch did not make it to this release though).
For the first time the System.Web assembly has built without
all the excludes, so you can get your hands on Gaurav and
Lee's massive code base.
Lots of new tests to the runtime, class libraries and compiler
are included. As always, big thanks go to Nick for continued
guidance to new developers, and writing new tests.
Dan removed the System.PAL dependency, we now have moved to an
internalcall setup for all the System.IO calls, and dropped
the MonoWrapper shared library.
Porting wise: Sergey's StrongARM port is included now; Jeff's
SPARC port and Radek's PowerPC port have been updated to
reflect the new changes in the engine.
Runtime wise: Dietmar also got us asyncronous delegates
implemented. Dick continues his work on our foundation
classes, and has resumed his work on the IO layer.
Paolo is the hero behind self hosting on Linux. Send your
congrats (and wine) to him.
And without the help from Mike, Duco, David, Piers, Nick,
Sergey, Mark, Jonathan, John, Adam and Dennis this release
would have not been possible.
This release is mostly ECMA compatible. I did not expect this
to happen so soon. I am very grateful to everyone who has
made this happen
* The goods
The runtime sources and binaries to the compiler/libraries:
http://www.go-mono.com/archive/mono-0.10.tar.gz
The class and compiler sources:
http://www.go-mono.com/archive/mcs-0.10.tar.gz
* Requirements:
You still need glib-2, and pkg-config. If you plan on
compiling large applications, getting the Boehm GC is a plus
(we will integrate this in a future version, for now it is an
external requirement).
Boehm GC is available in packaged format for Debian and Red
Hat systems.
* To compile on Linux
Do your regular chores with mono-0.10.tar.gz, you know the
drill. In the end, after you reach the `make install' phase,
now you can do some cool stuff.
If you want to compile the compiler (just to try it out),
untar the sources to the compiler (mcs-0.10.tar.gz) and do
manually:
cd mcs-0.10
(cd jay; make)
(cd mcs; make monomcs)
Now you will end up with a nice mcs4.exe in the mcs/mcs
directory, that is the compiler. If you want to use that,
replace the mcs.exe we distribute with the mcs4.exe you got.
* Gadgets
Man pages for mcs, mono and mint are included for your
enjoyment.
Particularly of interest is `mint --profile' which is awesome
to profile your application, the output is very useful.
Also, if you want to impress your friends, you might want to
run the JIT with the `-d' flag, that shows you how the JITer
compiles the code (and shows the basic blocks and the forst of
trees as it goes).
* Next steps
More classes are missing. These are required so we can run
nant and nunit natively. Once we achieve that, we will be
able to ship a complete environment that compiles on Linux.
Currently our makefiles still use csc, as we still need
nunit/nant to work.
[1] Of course, .NET programs that try to use classes we have not yet
implemented, will be left wondering `why did this happen to me?'.
Hello!
I have just uploaded Mono 0.9 to the web server, you can get
the goodies here:
http://www.go-mono.com/archive/mono-0.9.tar.gz
http://www.go-mono.com/archive/mcs-0.9.tar.gz
mono-0.9.tar.gz contains the source code to the runtime (JIT
and interpreter) as well as a pre-compiled version of the
compiler (mcs.exe) and the class libraries.
To compile the compiler and the class libraries, you still
need Windows with the .NET SDK, as our runtime can not host
the compiler completely yet.
* Improved Build System
You can check http://www.go-mono.com/download.html for the
new and fresh compilation instructions. Same requirements as
the last version (pkg-config, glib 1.3.xx need to be
installed).
* What is new:
Compiler can compile about 75% of our regression test suite
on Linux. Most of this work is on the class libraries and
Paolo has been the magician behind the work here.
JIT can run the compiler now (Dietmar)
Mint works on Windows now (Dick).
Application Domains have been implemented (Dietmar)
* Two modes of operation are available, depending on
your needs: share code, or maximize speed (does not
share code). This is described by the the
LoaderOptimization enumeration in .NET.
Corlib no longer has references to mscorlib (Daniel Lewis)
Ports:
PowerPC has been updated (Radek Doulik)
New SPARC port (Jeffrey Stedfast)
Documentation system:
Adam Treat has been working on finishing the Doctools
to maintain the Mono class library documentation. We
still need a GUI editor though.
Tracking progress:
Nick's new tools to track progress are included in
this release.
Many new more regression tests for the class library
(David Brandt, Mark Crichton, Nick Drochak, Bob Doan,
Duco Fijma).
Lots of new code:
Gaurav Vaish (the hacking god behind System.Web),
Chris Podugriel (System.Data) and Mark Crichton (Crypto)
Runtime:
Socket layer is finished (Dick Porter)
Compiler has full support for unsafe code now (Miguel)
Still a few things missing: constant folding is not
finished everywhere and access permissions are not
enforced yet.
Many many many bug fixes everywhere from everyone on the team:
Paolo Molaro, Daniel Lewis, Daniel Stodden, Dietmar
Maurer, Jeff Stedfast, Nick Drochak, Duco Fijma, Ravi Pratap,
Dick Porter, Duncan Mak, Jeff Stedfast and Miguel de Icaza.
I am sorry if I left a major component out of the
announcement, this were some intense 11 days of work.
* What is obviously missing
Currently our System.Reflection.Emit is lacking array and
pointer support, which is why many programs still do not
compile, but this should be taken care of next week.
* How can you help
There are many ways to help the project, check the details
documentation in:
http://www.go-mono.com/contributing.html
You might also want to stop by our IRC channel on
irc.gnome.org, channel #mono if you are interested in
contributing.
Have a happy weekend!
Miguel.
Hey guys!
Mono 0.7 has been released.
It has been a long time since the last release of Mono (almost
three weeks). We have made an incredible ammount of work in the past
three weeks.
* Highlights of this release:
* The monoburg: BURS-instruction selector implemented (for our
portable JIT engine).
* JIT engine works for very simple programs (Fibonacci works
for instance). It is about 30% faster running than the
equivalent code compiled with Kaffe.
The interesting part is that this was accomplished with the
a minimum register allocator, and very simple monoburg
rules, so there is a *lot* of room to improve here.
* The Interpreter has madured a lot. Value Types are fully
supported now; We dropped the FFI dependency, as we now
have our own code generator.
* The runtime has been expanded and extended as to support
real file I/O (including console I/O). So Hello World works
in there.
* The compiler can generate code for most statements now; It
also performs semantic analysis on most expressions.
Creation of new objects is supported, access to parameters,
fields and local variables works. Method invocation works.
Implicit type conversions, assignments and much more.
Operator overloading is implemented, but broken on this
release, hopefully this will be fixed soon.
Delegates and Attributes are now declared and passed around,
but no code generation for those exist yet.
* More classes (look for details). Sergey and Paolo have been
working on various classes in System.Reflection.Emit to get
the compiler self-hosting.
* NUnit is now part of the distribution, so it should be
trivial to write test cases (and if you want to help out,
this is one way to do it, we really need more tests cases).
I am going to try to switch to Nick's JB for C# this week or next
week. But the excitement of having the compiler deal with real C#
programs is too much to be contained, and I can not keep my hands of
the code generation in the compiler.
* Availability:
http://www.go-mono.com/archive/mono-0.7.tar.gz
http://www.go-mono.com/archive/mcs-0.7.tar.gz
* Details
Class Library Changes:
Many enumerations have been revamped to have the same value
definitions as those in .NET as those cause problems. They were also
missing the [Flags] attributes, so we got that right too.
* System
SerializableAttribute impl (Miguel)
String updates (Jeff)
System.Char (Ravi)
* System.Configuration
ConfigurationSettings impl (Christopher Podurgiel)
SingleTagSectionHandler impl (Christopher Podurgiel)
DictionarySectionHandler impl (Christopher Podurgiel)
* System.Collections.Specialized
NameObjectCollectionBase impl (Nick Drochak)
* System.Diagnostics
StackFrame stubs (alexk)
StackTrace stubs (alexk)
* System.IO
File stubs (Jim Richardson)
IOException impl (Paolo)
StreamWriter impl (Dietmar)
StreamReader stubs (Dietmar)
* System.Net
ConnectionModes (Miguel)
ProxyUseType (Miguel)
WebStatus (Miguel)
* System.Reflection
Assembly (stubs) (Paolo)
MethodBase (Paolo)
MethodInfo (Paolo)
* System.Reflection.Emit
EventToken (Sergey)
FieldToken (Sergey)
FlowControl (Sergey)
ILGenerator (stubbed) (Paolo)
Label (Paolo)
MethodToken (Sergey)
OpCode.cs (Sergey)
OpCodeType (Sergey)
OpCodes.cs (Sergey)
OperandType (Sergey)
PEFileKinds (Paolo)
PackingSize (Sergey)
ParameterToken (Sergey)
PropertyToken (Sergey)
SignatureToken (Sergey)
StackBehaviour (Sergey)
StringToken (Sergey)
TypeToken (Sergey)
* System.Threading
Most classes stubbed out by Dick Porter (Dick)
* System.Web
HttpWorkerRequest stubs (Bob Smith)
* System.Web.Hosting (Bob Smith)
AppDomainFactory stubs (Bob Smith)
ApplicationHost stubs (Bob Smith)
IAppDomainFactory stubs (Bob Smith)
IISAPIRuntime stubs (Bob Smith)
ISAPIRuntime stubs (Bob Smith)
SimpleWorkerRequest stubs (Bob Smith)
* System.Web.UI
LiteralControl implemented (Bob Smith)
HtmlContainerControl bugfixes (Bob Smith)
BuildMethod
BuildTemplateMethod
HtmlTextWriterAttribute
HtmlTextWriterStyle
HtmlTextWriterTag
IAttributeAccessor
IDataBindingsAccessor
INamingContainer
IParserAccessor
IPostBackDataHandler
IPostBackEventHandler
IStateManager
ITagNameToTypeMapper
ITemplate
IValidator
ImageClickEventHandler
OutputCacheLocation
PersistanceMode
StateItem
* System.Web.UI.HtmlControls
HtmlAnchor impl (Leen Teolen)
HtmlTextArea impl (Leen Teolen)
* System.Web.UI.WebControls
WebControl.cs (Gaurav Vaish)
* System.XML
Lots of enumerations (Miguel)
(will add later)
* Add loads of enumerations throughout (Sergey)
(will add later)
Compiler Changes:
* Assignment (Miguel)
* expression semantic analysis (Miguel)
* constructor creation, chaining (Miguel)
* Unified error reporting (Ravi)
* initial attribute support (Ravi)
* calling convention support (Miguel)
* loop construct code generation (Miguel)
* conditional statement code generation (Miguel)
* indexer declarations (Ravi)
* event declarations (Ravi)
* try/catch parsing fixed (Ravi)
* initial delegate support (Ravi)
* operator overload (Ravi)
Tools Changes:
* Add NUnit windows binaries to distribution (Nick Drochak, Miguel)
Runtime Changes:
* First JIT implementation (Dietmar, Paolo)
* value type size calculation (Dietmar)
* full value type support (Paolo)
* frequently used types cache (Paolo)
* FileStream support (Paolo)
* Console input/output support (Dietmar)
* print arguments and exception name in stack trace (Paolo)
* beginnings of virtual call support (Paolo)
* reimplement pinvoke support (Dietmar)
* remove libffi dependency (Dietmar)
* IBURG code generator implementation (Dietmar)
* new opcodes implemented: starg.s, ldobj, isinst, (Paolo, Miguel)
ldarg, starg, ldloc, ldloca, stloc, initobj,
cpblk, sizeof, conv.i, conv.i1, conv.i2, conv.i4,
conv.i8, conv.u1, conv.u2, conv.u4, conv.r4,
conv.r8, ldelema, ceq, cgt, clt.
* This list
Parts of this list of features were compiled by Alex by following
the CVS mailing list. My deepest thanks to Alex for helping me out
with this. I want to apologize for the missing features that I did
not document here, Mono is moving too fast to keep track of all the
changes.
2002-Feb-11 Miguel de Icaza <[email protected]>
New release, functional x86-JIT, x86 interpreter, ppc interpreter
+19 -33
View File
@@ -8,40 +8,17 @@ Installation:
http://www.go-mono.com/download.html
* Using Mono
Once you have installed the software, you can run a few programs:
* runtime engine
mono program.exe
or
mint program.exe
* C# compiler
mcs program.cs
* CIL Disassembler
monodis program.exe
See the man pages for mono(1), mint(1), monodis(1) and mcs(2)
for further details.
* A directory roadmap:
A directory roadmap:
doc/
Contains documentation and the web site contents.
mono/
The core of the Mono Runtime.
The core of the executable.
metadata/
The object system and metadata reader.
jit/
The Just in Time Compiler.
The library to deal with executables and libraries for
.NET
dis/
CIL executable Disassembler
@@ -49,10 +26,6 @@ Installation:
cli/
Common code for the JIT and the interpreter.
io-layer/
The I/O layer and system abstraction for
emulating the .NET IO model.
cil/
Common Intermediate Representation, XML
definition of the CIL bytecodes.
@@ -60,7 +33,20 @@ Installation:
interp/
Interpreter for CLI executables.
arch/
Architecture specific portions.
* 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
+1 -15
View File
@@ -1,20 +1,6 @@
#undef HAVE_INET_PTON
#undef HAVE_INET_ATON
#undef HAVE_MSG_NOSIGNAL
#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 PLATFORM_WIN32_NATIVE
#undef HAVE_NEW_ICONV
#undef NAME_DEV_RANDOM
#undef HAVE_CRYPT_RNG
#undef HAVE_BOEHM_GC
#undef DISABLE_SHARED_HANDLES
#undef HAVE_TIMEZONE
#undef HAVE_TM_GMTOFF
#undef MONO_SIZEOF_SUNPATH
-34
View File
@@ -3,46 +3,12 @@
/* Define if you have the ANSI C header files. */
#undef STDC_HEADERS
#undef HAVE_INET_PTON
#undef HAVE_INET_ATON
#undef HAVE_SOL_IP
#undef HAVE_SOL_TCP
#undef HAVE_IP_PKTINFO
#undef HAVE_STRUCT_IP_MREQN
#undef HAVE_PTHREAD
#undef HAVE_PTHREAD_MUTEX_TIMEDLOCK
#undef USE_MONO_MUTEX
#undef HAVE_LARGE_FILE_SUPPORT
#undef PLATFORM_WIN32
#undef HAVE_NEW_ICONV
#undef NAME_DEV_RANDOM
#undef HAVE_CRYPT_RNG
#undef HAVE_BOEHM_GC
/* The number of bytes in a void *. */
#undef SIZEOF_VOID_P
/* Define if you have the inet_aton function. */
#undef HAVE_INET_ATON
/* Define if you have the inet_pton function. */
#undef HAVE_INET_PTON
/* Define if you have the <dlfcn.h> header file. */
#undef HAVE_DLFCN_H
/* Define if you have the <netdb.h> header file. */
#undef HAVE_NETDB_H
/* Define if you have the <sys/filio.h> header file. */
#undef HAVE_SYS_FILIO_H
/* Define if you have the <sys/sockio.h> header file. */
#undef HAVE_SYS_SOCKIO_H
/* Define if you have the <utime.h> header file. */
#undef HAVE_UTIME_H
/* Name of package */
#undef PACKAGE
+43 -313
View File
@@ -1,39 +1,15 @@
AC_INIT(README)
AC_CANONICAL_SYSTEM
AM_CONFIG_HEADER(config.h)
AM_INIT_AUTOMAKE(mono, 0.14)
AM_INIT_AUTOMAKE(mono, 0.8)
AM_MAINTAINER_MODE
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)
CC="gcc -mno-cygwin"
libdl=
;;
*)
platform_win32=no
libdl="-ldl"
;;
esac
AC_MSG_RESULT($platform_win32)
AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
AC_CHECK_TOOL(CC, gcc, gcc)
AC_PROG_CC
AM_PROG_CC_STDC
AC_PROG_INSTALL
AC_CHECK_PROG(BISON, bison,yes,no)
if test "x$BISON" = "xno";
then
AC_MSG_ERROR([You need to install bison])
fi
dnl may require a specific autoconf version
dnl AC_PROG_CC_FOR_BUILD
dnl CC_FOR_BUILD not automatically detected
@@ -52,18 +28,10 @@ AC_HEADER_STDC
AC_LIBTOOL_WIN32_DLL
AM_PROG_LIBTOOL
AC_CHECK_HEADERS(sys/filio.h sys/sockio.h netdb.h utime.h)
AC_CHECK_HEADERS(iconv.h)
AC_CHECK_HEADERS(giconv.h)
# 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 -Wstrict-prototypes -Wmissing-prototypes -Wnested-externs -Wpointer-arith -Wno-cast-qual -Wcast-align -Wwrite-strings'
CFLAGS='-g -Wall -Wunused -Wmissing-prototypes -Wmissing-declarations'
AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
if test "x$PKG_CONFIG" = "xno"; then
@@ -105,37 +73,38 @@ AC_SUBST(GLIB_LIBS)
AC_SUBST(GMODULE_CFLAGS)
AC_SUBST(GMODULE_LIBS)
AC_CHECK_LIB(gc, GC_malloc, found_boehm="yes",,$libdl)
gc=auto
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 $libdl"
;;
xnone)
AC_MSG_WARN("Compiling mono without GC.")
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)
;;
*)
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 $libdl"
gc="boehm"
fi
dnl AC_MSG_WARN("Compiling mono without GC.")
platform_win32=no
;;
esac
AC_MSG_RESULT($platform_win32)
AM_CONDITIONAL(PLATFORM_WIN32, test x$platform_win32 = xyes)
if test x$platform_win32 = xyes; then
AC_MSG_CHECKING([if building for native Win32])
case "$host" in
*-*-mingw*)
platform_win32_native=yes
AC_DEFINE(PLATFORM_WIN32_NATIVE)
;;
*)
platform_win32_native=no
;;
esac
AC_MSG_RESULT($platform_win32_native)
AM_CONDITIONAL(PLATFORM_WIN32_NATIVE,
test x$platform_win32_native = xyes)
fi
if test x$platform_win32 = xno; then
dnl ******************************************************************
@@ -145,7 +114,7 @@ if test x$platform_win32 = xno; then
# Check that off_t can represent 2**63 - 1 correctly, working around
# potential compiler bugs. Defines LARGE_FILE_SUPPORT, adds $1 to
# CPPFLAGS and sets $large_offt to yes if the test succeeds
# CFLAGS and sets $large_offt to yes if the test succeeds
large_offt=no
AC_DEFUN(LARGE_FILES, [
large_CPPFLAGS=$CPPFLAGS
@@ -167,7 +136,7 @@ if test x$platform_win32 = xno; then
], [
AC_MSG_RESULT(ok)
AC_DEFINE(HAVE_LARGE_FILE_SUPPORT)
large_CPPFLAGS="$large_CPPFLAGS $1"
CFLAGS="$CFLAGS $1"
large_offt=yes
], [
AC_MSG_RESULT(no)
@@ -184,121 +153,12 @@ if test x$platform_win32 = xno; then
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 MSG_NOSIGNAL ***
dnl *******************************
AC_MSG_CHECKING(for MSG_NOSIGNAL)
AC_TRY_COMPILE([#include <sys/socket.h>], [
int f = MSG_NOSIGNAL;
], [
# Yes, we have it...
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_MSG_NOSIGNAL)
], [
# We'll have to use signals
AC_MSG_RESULT(no)
])
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 size of sockaddr_un.sun_path ***
dnl ***********************************************
# AC_CHECK_SIZEOF can't cope with struct members :-(
AC_MSG_CHECKING(size of sockaddr_un.sun_path)
AC_CACHE_VAL(cv_mono_sizeof_sunpath,
[AC_TRY_RUN([
#include <stdio.h>
#include <sys/un.h>
int main(void) {
struct sockaddr_un sock_un;
FILE *f=fopen("conftestval", "w");
if(!f) exit(1);
fprintf(f, "%d\n", sizeof(sock_un.sun_path));
exit(0);
}
], cv_mono_sizeof_sunpath=`cat conftestval`,
cv_mono_sizeof_sunpath=0,
cv_mono_sizeof_sunpath=0)])dnl
AC_MSG_RESULT($cv_mono_sizeof_sunpath)
AC_DEFINE_UNQUOTED(MONO_SIZEOF_SUNPATH, $cv_mono_sizeof_sunpath)
dnl *****************************
dnl *** Checks for libpthread ***
dnl *****************************
AC_SEARCH_LIBS(pthread_create, pthread c_r, [
AC_SEARCH_LIBS(pthread_create, pthread, [
AM_CONDITIONAL(THREADS_PTHREAD, true)
AC_DEFINE(HAVE_PTHREAD)
@@ -314,7 +174,7 @@ if test x$platform_win32 = xno; then
pthread_mutex_timedlock(&mut, NULL);
], [
# Works!
AC_MSG_RESULT(yes)
AC_MSG_RESULT(ok)
AC_DEFINE(HAVE_PTHREAD_MUTEX_TIMEDLOCK)
], [
AC_MSG_RESULT(no)
@@ -327,7 +187,7 @@ if test x$platform_win32 = xno; then
pthread_mutex_t mut=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_timedlock(&mut, NULL);
], [
AC_MSG_RESULT(yes)
AC_MSG_RESULT(ok)
pthread_CFLAGS="-D_GNU_SOURCE"
AC_DEFINE(HAVE_PTHREAD_MUTEX_TIMEDLOCK)
], [
@@ -337,7 +197,7 @@ if test x$platform_win32 = xno; then
])
])
CPPFLAGS=$orig_CPPFLAGS
CPPFLAGS="$CPPFLAGS $pthread_CFLAGS"
CFLAGS="$CFLAGS $pthread_CFLAGS"
# Need PTHREAD_MUTEX_RECURSIVE
pthread_CFLAGS=""
@@ -368,120 +228,16 @@ if test x$platform_win32 = xno; then
], [
AC_MSG_RESULT(no)
dnl Add other variants here
AC_MSG_WARN(Using mono_mutex_t for recursive mutexes)
AC_DEFINE(USE_MONO_MUTEX)
AC_MSG_ERROR([PTHREAD_MUTEX_RECURSIVE not found])
])
])
CPPFLAGS=$orig_CPPFLAGS
CPPFLAGS="$CPPFLAGS $pthread_CFLAGS"
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")
dnl ********************************
dnl *** Checks for timezone stuff **
dnl ********************************
AC_CACHE_CHECK(for timezone variable, ac_cv_var_timezone,
AC_TRY_COMPILE([
#include <time.h>
], [
timezone = 1;
], ac_cv_var_timezone=yes, ac_cv_var_timezone=no))
if test $ac_cv_var_timezone = yes; then
AC_DEFINE(HAVE_TIMEZONE)
else
AC_CACHE_CHECK(for tm_gmtoff in struct tm, ac_cv_struct_tm_gmtoff,
AC_TRY_COMPILE([
#include <time.h>
], [
struct tm tm;
tm.tm_gmtoff = 1;
], ac_cv_struct_tm_gmtoff=yes, ac_cv_struct_tm_gmtoff=no))
if test $ac_cv_struct_tm_gmtoff = yes; then
AC_DEFINE(HAVE_TM_GMTOFF)
else
AC_ERROR(unable to find a way to determine timezone)
fi
fi
else
AM_CONDITIONAL(THREADS_PTHREAD, false)
# 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)
@@ -503,29 +259,21 @@ else
fi
fi
AC_MSG_CHECKING([if inter-process shared handles are requested])
AC_ARG_ENABLE(shared-handles, [ --disable-shared-handles disable inter-process shared handles], try_shared_handles=$enableval, try_shared_handles=yes)
AC_MSG_RESULT($try_shared_handles)
if test "x$try_shared_handles" != "xyes"; then
AC_DEFINE(DISABLE_SHARED_HANDLES)
AC_SUBST(DISABLE_SHARED_HANDLES)
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";;
sparc*-*-*) 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-* | armv4l-*-linux-*) TARGET=ARM; arch_target=arm; ACCESS_UNALIGNED="no";;
#arm-*-linux-*) TARGET=ARM; ACCESS_UNALIGNED="no";;
esac
if test ${TARGET} = unknown; then
CPPFLAGS="$CPPFLAGS -DNO_PORT"
CFLAGS="$CFLAGS -DNO_PORT"
AC_MSG_WARN("mono has not been ported to $host: some things may not work.")
fi
@@ -544,43 +292,25 @@ AM_CONDITIONAL(ARM, test x$TARGET = xARM)
AC_SUBST(arch_target)
AC_SUBST(CFLAGS)
AC_SUBST(CPPFLAGS)
AC_OUTPUT([
Makefile
mono.pc
mono/Makefile
mono/utils/Makefile
mono/metadata/Makefile
mono/dis/Makefile
mono/cil/Makefile
mono/arch/Makefile
mono/os/Makefile
mono/os/win32/Makefile
mono/os/unix/Makefile
mono/arch/x86/Makefile
mono/arch/ppc/Makefile
mono/arch/sparc/Makefile
mono/arch/arm/Makefile
mono/interpreter/Makefile
mono/tests/Makefile
mono/benchmark/Makefile
mono/wrapper/Makefile
mono/monoburg/Makefile
mono/monograph/Makefile
mono/jit/Makefile
mono/io-layer/Makefile
mono/handles/Makefile
runtime/Makefile
scripts/Makefile
man/Makefile
doc/Makefile
docs/Makefile
data/Makefile
mono.spec
])
echo "
GC: $gc
"
-9
View File
@@ -1,9 +0,0 @@
monodir = $(sysconfdir)/mono
EXTRA_DIST = config.in
mono_DATA = config
config: config.in Makefile
sed -e 's^\@LIBC\@^libc.so.6^g' < $(srcdir)/config.in > config.tmp \
&& mv config.tmp config
-4
View File
@@ -1,4 +0,0 @@
<configuration>
<dllmap dll="cygwin1.dll" target="@LIBC@" />
<dllmap dll="libc" target="@LIBC@" />
</configuration>
-1
View File
@@ -1,4 +1,3 @@
Makefile.in
Makefile
all-docs
pending-classes.in
+7 -12
View File
@@ -1,9 +1,9 @@
WEB_FILES= \
ado-net c-sharp class-library contact contributing documentation download \
c-sharp class-library contact contributing documentation download \
faq gcc-frontend ideas index passport rationale resources \
roadmap runtime status team testing thanks tools porting anoncvs monodoc-xml winforms
roadmap runtime status team testing thanks tools porting anoncvs
OTHERS= pending resources-pending todo mono-build.sh mono-build-w32.sh
OTHERS= pending resources-pending todo
EXTRA_DIST = $(WEB_FILES) README $(OTHERS)
@@ -15,18 +15,13 @@ all-docs: $(WEB_FILES)
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
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: class-status
(cd web; make && make push)
push-notes:
scp release-notes/mono* www@www:/web/cvsmodules/mono/archive
dummy:
-801
View File
@@ -1,801 +0,0 @@
* ADO.NET
The coordinator for the ADO.NET implementation is <a
href="mailto:[email protected]">Rodrigo Moya</a>, with
the collaboration of <a href="mailto:[email protected]">Daniel
Morgan</a> and <a href="mailto:[email protected]">Tim Coleman</a>.
* Action plan
The current plan to implement ADO.NET is as follows:
<b>Step 1:</b> Initial <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfsystemdatasqlclient.asp?frame=true">System.Data.SqlClient</a> Provider:
<ul>
* Initial implementation of System.Data.SqlClient is based on
the <a href="http://www.postgresql.org/idocs/">PostgreSQL C API</a> which is a
client API to the PostgreSQL DBMS. PostgreSQL was chosen so we could quickly
create and test the System.Data classes.
* Once the <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfsystemdatasqlclient.asp?frame=true">System.Data.SqlClient</a>
code is functional and is usable by other people, we willl move it to
Mono.Data.PostgreSQL, and will convert the existing
System.Data.SqlClient to be just a wrapper around
Mono.Data.PostgreSQL.
</ul>
<b>Step 2:</b> <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfSystemDataOleDb.asp?frame=true">System.Data.OleDb</a> Provider:
<ul>
* <p>On Unix systems: System.Data.OleDb uses the
<a href="http://www.gnome-db.org/">LibGDA</a>
engine.
<p>LibGDA is a data access engine like ADO/OLE-DB, but for Unix. The
GDA in libGDA stands for GNU/GNOME Data Access, but it does not require GNOME.
It only requires glib2 and libxml2. LibGDA is used by
libgnomedb, GNOME-DB, and gaSQL.
<p>There is work under way to get libgda working under
Windows using Cygwin by the GNOME-DB developers.
<p>LibGDA has providers for MySQL, PostgreSQL, XML, ODBC,
Oracle, Interbase, Sybase/SQL server (via FreeTDS), IBM DB2,
SQLite and MDB Tools
(MS Access support).
* On Windows systems: System.Data.OleDb will use libgda as well,
if we can get it working, or OLE-DB as
its engine.
</ul>
<b>Step 3:</b> <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfsystemdatasqlclient.asp?frame=true">System.Data.SqlClient</a> Provider:
<ul>
* <p>System.Data.SqlClient will then become a managed
provider for Microsoft SQL Server, both on Windows and
Linux, to be compatible with applications written
for the Microsoft .NET Development Framework.
<p>Once Step 1 has been completed and the PostgreSQL
provider support has been moved to its own place at
Mono.Data.PostgreSQL, we will use
<a href="http://www.freetds.org/">FreeTDS</a> as the basis
for providing access to Microsoft SQL Server databases.
<P>FreeTDS is a C API for Unix and Windows that implements
the TDS (Tabular Data Stream) protocol used in accessing
Microsoft SQL Server and Sybase databases. A .NET Data Provider could be
created for Sybase databases as well, but this would be put in Mono.Data.Sybase.
</ul>
<b>Step 4:</b> <a href="http://msdn.microsoft.com/downloads/sample.asp?url=/MSDN-FILES/027/001/668/msdncompositedoc.xml&frame=true">System.Data.Odbc</a> Provider:
<ul>
* We will create a .NET Managaed Provider for ODBC
in System.Data.Odbc for those using ODBC.
On Unix and Windows, <a href="http://www.unixodbc.org/">unixODBC</a> mabye used.
iODBC is an alternative to using unixODBC.
<p>unixODBC works on Unix and Windows. Well, I have not actually
used it on Cygwin, but it does build and install without problems.
<p>unixODBC has providers for:
Oracle, Microsoft SQL Server and Sybase via FreeTDS,
MySQL, PostgreSQL, Informix, IBM DB2 (Universal Database),
Interbase, miniSQL (mSQL), AdabasD, Empress, YARD SQL, and others.
</ul>
<b>Step 5:</b> Other System.Data providers:
<ul>
* <p>The idea in Microsoft .NET System.Data is to have
a managed provider for each supported DBMS. System.Data.SqlClient
for Microsoft SQL Server.
System.Data.OracleClient for Oracle 8i and 9i.
<p>We will need to have Mono.Data.MySQL, Mono.Data.PostgreSQL,
Mono.Data.DB2, and Mono.Data.miniSQL. Others,
of course, are welcomed.
<p>System.Data has been designed so
non-database providers can be created too.
</ul>
* Current Status
<p>We are working on Steps 1, 2, and 5. We have only just begun on
steps 2 and 5 though. We still have tons and tons of stuff to do.
If you have any ideas, let us know.
<p>For Step 1, the PostgreSQL is starting to come together - it
still needs a lot of work.
<p>For Step 2, Rodrigo Moya has been working on System.Data.OleDb which uses libgda
which is an OLE-DB/ADO data access for Unix. The C-Sharp bindings to libgda
currently work - meaning they can compile, run, and you can connect to a
PostgreSQL database via libgda via the C-Sharp bindings to libgda. Basic
functionality (execution of commands, data retrieval, transactions, etc) are
now working. Current focus is on filling up the missing pieces (Data adapters
mainly).
<p>For Step 3, we need someone to start the FreeTDS .NET Data Provider so
we can have data access to Microsoft SQL Server and Sybase databases, or either
add the support in libgda.
<p>For Step 4, we need someone to start the unixODBC .NET Data Provider, or add
the support in libgda.
<p>For Step 5, we have just begun creating a Mono.Data .NET Provider - a MySQL
.NET Provider that uses the MySQL C Client Library. This provider is
found in Mono.Data.MySql. We can currently connect and do a SQL INSERT and insert
a row into a MySQL database. However, it currently only works on Cygwin because
the MySQL client library libmySQL.dll is different
from the library on Linux libmysqlclient.dll. Another problem, mysql thread functions
do not load for some reason. Also, the provider only runs if you use "mint" (the Mono
runtime interpreter). It does not work on "mono" (the Mono Just-In-Time compiler).
The C# Bindings to MySQL are thanks to Brad Meril.
<p>We are able to do simple CREATE TABLE, DROP TABLE, UPDATE, INSERT, and
DELETE SQL commands using the ExecuteNonQuery method in SqlCommand.
<p>We can execute multiple queries and do a NextResult() in SqlDataReader()
to get the next result set.
<p>We are also able to do simple aggregate functions,
ie, count(), sum(), min(), and max()
in a simple SELECT SQL query using the ExecuteScalar() now.
<p>We are also able to retrieve data with a simple SELECT SQL query
using ExecuteReader() which returns a SqlDataReader. We are able to
use GetSchemaTable() to get the meta data about the table columns.
We are able to Read() to get each row from the result set.
<p>Here is a sample of code that is based on PostgresTest.cs and
TestSqlDataReader.cs tests:
<pre>
static void SelectData (IDbConnection cnc) {
IDbCommand selectCommand = cnc.CreateCommand();
IDataReader reader;
selectCommand.CommandType = CommandType.Text;
selectCommand.CommandText =
"select * from pg_user;" +
"select * from pg_tables;" +
"select * from pg_database";
reader = selectCommand.ExecuteReader ();
do {
// get the DataTable that holds
// the schema
DataTable dt = rdr.GetSchemaTable();
if(rdr.RecordsAffected != -1) {
// Results for
// SQL INSERT, UPDATE, DELETE Commands
// have RecordsAffected >= 0
Console.WriteLine("Result is from a SQL Command (INSERT,UPDATE,DELETE). Records Affected: " + rdr.RecordsAffected);
}
else if (dt == null)
Console.WriteLine("Result is from a SQL Command not (INSERT,UPDATE,DELETE). Records Affected: " + rdr.RecordsAffected);
else {
// Results for
// SQL not INSERT, UPDATE, nor DELETE
// have RecordsAffected = -1
Console.WriteLine("Result is from a SQL SELECT Query. Records Affected: " + rdr.RecordsAffected);
// Results for a SQL Command (CREATE TABLE, SET, etc)
// will have a null reference returned from GetSchemaTable()
//
// Results for a SQL SELECT Query
// will have a DataTable returned from GetSchemaTable()
results++;
Console.WriteLine("Result Set " + results + "...");
// number of columns in the table
Console.WriteLine(" Total Columns: " +
dt.Columns.Count);
// display the schema
foreach (DataRow schemaRow in dt.Rows) {
foreach (DataColumn schemaCol in dt.Columns)
Console.WriteLine(schemaCol.ColumnName +
" = " +
schemaRow[schemaCol]);
Console.WriteLine();
}
int nRows = 0;
string output, metadataValue, dataValue;
// Read and display the rows
Console.WriteLine("Gonna do a Read() now...");
while(rdr.Read()) {
Console.WriteLine(" Row " + nRows + ": ");
for(c = 0; c < rdr.FieldCount; c++) {
// column meta data
DataRow dr = dt.Rows[c];
metadataValue =
" Col " +
c + ": " +
dr["ColumnName"];
// column data
if(rdr.IsDBNull(c) == true)
dataValue = " is NULL";
else
dataValue =
": " +
rdr.GetValue(c);
// display column meta data and data
output = metadataValue + dataValue;
Console.WriteLine(output);
}
nRows++;
}
Console.WriteLine(" Total Rows: " +
nRows);
}
} while(rdr.NextResult());
Console.WriteLine("Total Result sets: " + results);
rdr.Close();
}
</pre>
<p>We are able to get
String data (char, character, text, varchar), Int16 (smallint),
Int32 (integer), Int64 (bigint), DateTime (time, date, timestamp),
Boolean (boolean), Single (float), and Double (double).
More data types will come later. Note, the types that do work still
need thorough testing.
<p>Rows that are returned which contain columns that are NULL are handled now.
The SqlDataReader method IsDBNull() needs to be called to determine
if a field IS NULL before trying to read data from that field.
<p>Calling PostgreSQL stored procedures works. It does not work perfectly. It may not
even work to specification - yet. If you want to test it yourself, look at
TestSqlDataReader.cs or PostgresTest.cs in
mcs/class/System.Data/Test.
<p>Below, I have some sample code you can
use to call a PostgreSQL stored procedure named "version". This stored
procedure returns a string containing the PostgreSQL server version. Notice
the CommandType is StoredProcedure and the method ExecuteScalar() is called.
<p>ExecuteScalar() is a lightweight method in class SqlCommand that only returns
one row and one column as one object - even if there is more than row or column.
<pre>
static string GetDatabaseServerVersion (SqlConnection cnc)
{
SqlCommand cmd = cnc.CreateCommand ();
string data;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "version";
data = (string) cmd.ExecuteScalar ();
return data;
}
</pre>
<p>We have the beginnings of Parameters support PostgreSQL. Only
Input Parameters are currently supported. Output, Input/Output,
and Return parameters still need to be done.
<p>A lot of functionality in System.Data is missing, but the
infrastructure is starting to come together.
<p>A lot of Exceptions need to be thrown for various exceptions. However,
SqlException, SqlErrorCollection, and SqlError have been partially
implemented.
<p>Tim Coleman and Rodrigo Moya got the beginnings of the
SqlDataAdapter/DataSet/DataTable/DataRow to work. Currently,
the SqlDataAdapter can Fill() relational data into a DataTable in a DataSet.
See the test mcs/class/System.Data/Test/TestSqlDataAdapter.cs to see it in action.
Below, I show a snippets from the test:
<pre>
string connectionString;
string sqlQuery;
SqlDataAdapter adapter;
DataSet dataSet = null;
connectionString =
"host=localhost;" +
"dbname=test;" +
"user=postgres";
sqlQuery = "select * from pg_tables";
adapter = new SqlDataAdapter (sqlQuery,
connectionString);
dataSet = new DataSet ();
adapter.Fill (dataSet);
if (dataSet != null) {
foreach (DataRow row in dataSet.Tables["Table"].Rows)
Console.WriteLine("tablename: " + row["tablename"]);
}
</pre>
<p>We do need help on the DataSet/DataAdaptor/DataTable/DataRelation/XML
functionality so we can integrate with
the ASP.NET controls and Windows.Forms controls by allowing the controls to bind
to a data source. Gonzalo, Gaurav, Leen, Patrik, Duncan, and others are
working very hard on the ASP.NET support. If you want to help,
contact <a href="mailto:[email protected]">Gonzalo Paniagua Javier</a>
<P>Need to add XML support in System.Data. This involves working on
the classes: DataSet and XmlDataDocument and the ExecuteXmlReader() in SqlCommand.
<p>The System.Data.dll gets built with the rest of the class library.
To compile the System.Data.dll assembly separately, you need:
<b>On Unix</b>
<ul>
* update your mono sources. Be sure you have latest mcs.exe
and .dll's, since there have been many fixes needed for
compilation on Linux.
* compile System.Data.dll:
<pre>
cd mcs/class/System.Data<br>
mcs --target library -o System.Data.dll @list
</pre>
</ul>
<b>On Windows</b>
<ul>
* update your mono sources. Be sure you have latest mcs.exe
and .dll's. You can use the same method as Linux,
or you can use NAnt.
* To use NAnt:
<pre>
cd mcs/class/System.Data
../../nant/NAnt.exe
</pre>
This will automatically copy the System.Data.dll to Test.
If you need to do a clean for the System.Data.dll assembly,<br><br>
<pre>
cd mcs/class/System.Data
../../nant/NAnt.exe clean
</pre>
</ul>
* Testing
<p>In order to test System.Data.SqlClient, you will need to have
access to a remote PostgreSQL DBMS, or you will have to install
one locally. PostgreSQL is the DBMS used for the initial
implementation of System.Data.SqlClient.
<p>Why? Because it is free software, has a client
library that is easy to use, PostgreSQL is easy to install on
Unix and Windows (using the Cygwin install program), not difficult to setup after
installation, and it runs under: Linux,
Windows (via cygwin and ipc-daemon), Unix, and
others. This allowed us to create the
System.Data functionality in Mono much quicker.
<p>If you plan on using a remote PostgreSQL DBMS Server,
than you will need to have the PostgreSQL client software on your
local computer that includes libpq.so (pq.dll on Windows).
<p>The System.Data tests use this connection string to connect
to the PostgreSQL database named "test" at host "localhost" as
user "postgres".
<pre>
"host=localhost;dbname=test;user=postgres"
</pre>
<p>Installation instructions for PostgreSQL DBMS:
<b>On Unix</b>
<ul>
* Read the PostgreSQL Installation Instructions
at \usr\doc\postgresql-x.x.x\html\installation.html
* Depending on your Unix system,
PostgreSQL maybe already installed, a database user 'postgres' created,
a linux user 'postgres' created and initdb ran. Or maybe not.
<pre>
su
adduser postgres
mkdir /usr/local/pgsql/data
chown postgres /usr/local/pgsql/data
su - postgres
initdb -D /usr/local/pgsql/data
postmaster -i -D /usr/local/pgsql/data
createdb test
psql test
</pre>
* Make sure you have a database user named postgres. It is best to install
the PostgreSQL DBMS under linux user postgres. When you run the postmaster,
run it under the user postgres as well. If this was not done, then you
will need to create a user named postgres for the System.Data tests.
* If you already installed PostgeSQL and you do not have a database
user named postgres, then you can create user postgres using psql:
<pre>
psql test
create user postgres with password 'fun2db';
</pre>
* The postmaster must be run with -i option.
* In the /usr/local/pgsql/data/pg_hba.conf file, you need
to have the AUTH_TYPE set to md5. You can read more on this at
/usr/doc/postgresql-7.2.1/html/client-authentication.html
or wherever your
PostgreSQL html docs are located. See the 2nd line below,
host 127.0.0.1 has an AUTH_TYPE md5 in pg_hba.conf.
<pre>
# TYPE DATABASE IP_ADDRESS MASK AUTH_TYPE
local all trust
host all 127.0.0.1 255.255.255.255 md5
</pre>
* If you can not find your PostgreSQL documentation locally or you
did not install it, then you
can get it <a href="http://www.postgresql.org/idocs/">here</a>.
</ul>
<b>On Windows</b>
<ul>
* Use the <a href="http://www.cygwin.com/">Cygwin</a> installer to
install the PostgreSQL DBMS. It is
found in the database category.
* <p>Read the file postgres-x.x.README at /usr/doc/Cygwin and read
the requirements to install PostgreSQL. Those requirements
are included with cygwin except cygipc. A default installtion
of cygwin does not install everything you will need, so on the
safe side, just include everything when installing cygwin.
* <p>The -x.x in postgres-x.x is the version of your PostgreSQL DBMS.
* <p>Once Cygwin has installed the PostgreSQL DBMS on your computer,
read the file FAQ_MSWIN which is available
in /usr/doc/postgres-x.x
* <p>Important notes from this file are:
<ul>
<p><b>2.</b> - Install the latest <a href="http://www.neuro.gatech.edu/users/cwilson/cygutils/OBSOLETE/V1.1/cygipc/index.html">CygIPC</a> package.
<p>The cygipc package contains the ipc-daemon you will need
to run before you can
run the PostgreSQL DBMS Server daemon (postmaster) or run
initdb which initializes the PostgreSQL database.
<p><b>3.</b> The Cygwin bin directory has to be placed in
the path before the Windows program directories,
for example, C:\cygwin\bin
<p><b>My own note.</b> In the Windows control panel, I set
the environment variables PATH to my cygwin /usr/local/bin,
/usr/bin, and /bin. I also set my LD_LIBRARY_PATH to
/usr/local/lib and /usr/lib. For example:
<p>
<pre>
PATH=c:\cygwin\usr\local\bin;c:\cygwin\usr\bin;c:\cygwin\bin;
LD_LIBRARY_PATH=c:\cygwin\usr\local\lib;c:\cygwin\usr\lib;
</pre>
<p><b>4.</b> Start the ipc-daemon that came with the cygipc
package. There
are two ways to do this: run it from the command line as:
<p>
<pre>
ipc-daemon &
</pre>
<p>or you can set it up as a Windows service. See the
file cygrunsrv.README at /usr/doc/Cygwin on how to do this
for ipc-daemon and postmaster. Note the
troubleshooting section at the end of
the cygrunsrv.README file.
<p>To install ipc-daemon as a service,
you just have to run
<p>
<pre>
ipc-daemon --install-as-service' (--remove-as-service)
</pre>
<p>and then run
<pre>
net start ipc-daemon
</pre>
</ul>
<p>Read the installation.html file
at /usr/doc/postgresql-x.x/html/installation.html
<p>You will see in this file that you will need to
run the following commands:
<p>
<pre>
mkdir /usr/local/pgsql/data
initdb -D /usr/local/pgsql/data
postmaster -D /usr/local/pgsql/data
createdb test
psql test
</pre>
<p>When you need to connect to the database,
you will need ipc-daemon and postmaster running. Start ipc-daemon
before any of the command above. If you restart your computer, you
need to start ipc-daemon and postmaster either manually or as a
service.
<p>psql is a command-line PostgreSQL client tool to
enter and run SQL commands and queries.
<p>If there is no database user named postgres, create a user named
postgres with the following SQL command in the client tool psql:
<p>
<pre>
psql test
create user postgres with password 'fun2db';
</pre>
<p>The only reason I say this is so you can easily use the System.Data tests
without having to change the database, userid, etc.
</ul>
<p>In the path mcs/class/System.Data/Test
there is a PostgreSQL test program named
PostgreTest.cs. Thanks goes to Gonzalo for creating the original
PostgreSQL test.
<p>To use it to test System.Data, you
modify the file to your PostgreSQL database
connection requirements:
<p>
<ul>
<li><b>dbname</b> database, ie., test</li>
<li><b>host</b> hostname of the PostgreSQL DBMS Server to connect to, ie., localhost</li>
<li><b>user</b> username, ie., someuser</li>
<li><b>password</b> password, ie., mypass1234</li>
</ul>
<p>The connection string is in OLE-DB connection string format. Internally,
SqlConnection converts this to the PostgreSQL connection string format.
<p>
<pre>
OLE-DB: "host=localhost;dbname=test;user=joe;password=smoe"
PostgreSQL: "host=localhost dbname=test user=joe password=smoe"
</pre>
<p>
Note that OLE-DB includes the semicolons while PostgreSQL's connection
string does not.
<p>
To compile the PostgresTest.cs program, do:
<p>
<pre>
mcs PostgresTest.cs -r System.Data.dll
</pre>
<p>
To run using mint, do:
<p>
<pre>
mint PostgresTest.exe
</pre>
<p>
To run using mono, do:
<pre>
mono PostgresTest.exe
</pre>
<p>Below, I show how the output from PostgresTest. I have omitted a lot
of the meta data for the columns except two columns. The classes
used were from System.Data.SqlClient and were used to connect to a
PostgreSQL database and retrieve data.
<p>
<pre>
danmorg@DANPC ~/mono/mcs/class/System.Data/Test
$ mcs PostgresTest.cs -r System.Data.dll
danmorg@DANPC ~/mono/mcs/class/System.Data/Test
$ mono PostgresTest.exe
Postgres provider specific tests...
Drop table:
Error (don't worry about this one)SqlError:PGRES_FATAL_ERROR ERROR: table "mono
_postgres_test" does not exist
<Stack Trace>
Create table with all supported types:
OK
Insert values for all known types:
OK
Update values:
OK
Insert values for all known types:
OK
Aggregate: count(*)
Agg Result: 2
Aggregate: min(text_value)
Agg Result: This is a text
Aggregate: max(int4_value)
Agg Result: 1048000
Aggregate: sum(int4_value)
Agg Result: 1048003
Select values from the database:
Result is from a SELECT SQL Query. Records Affected: -1
Result Set 1...
Total Columns: 28
ColumnName = boolean_value
ColumnOrdinal = 1
ColumnSize = 1
NumericPrecision = 0
NumericScale = 0
IsUnique = False
IsKey =
BaseCatalogName =
BaseColumnName = boolean_value
BaseSchemaName =
BaseTableName =
DataType = System.Boolean
AllowDBNull = False
ProviderType = 16
IsAliased = False
IsExpression = False
IsIdentity = False
IsAutoIncrement = False
IsRowVersion = False
IsHidden = False
IsLong = False
IsReadOnly = False
...
ColumnName = null_timestamp_value
ColumnOrdinal = 28
ColumnSize = 8
NumericPrecision = 0
NumericScale = 0
IsUnique = False
IsKey =
BaseCatalogName =
BaseColumnName = null_timestamp_value
BaseSchemaName =
BaseTableName =
DataType = System.DateTime
AllowDBNull = False
ProviderType = 1184
IsAliased = False
IsExpression = False
IsIdentity = False
IsAutoIncrement = False
IsRowVersion = False
IsHidden = False
IsLong = False
IsReadOnly = False
Gonna do a Read() now...
Row 0:
Col 0: boolean_value: False
Col 1: int2_value: 5
Col 2: int4_value: 3
Col 3: bigint_value: 9
Col 4: float_value: 3.141590
Col 5: double_value: 3.14159
Col 6: numeric_value: 123456789012.345
Col 7: char_value: Mono.Data!
Col 8: varchar_value: It was not me!
Col 9: text_value: We got data!
Col 10: point_value: (1,0)
Col 11: time_value: 01/01/1 21:13:14
Col 12: date_value: 02/29/2000 00:00:00
Col 13: timestamp_value: 02/29/2004 14:00:11
Col 14: null_boolean_value is NULL
Col 15: null_int2_value is NULL
Col 16: null_int4_value is NULL
Col 17: null_bigint_value is NULL
Col 18: null_float_value is NULL
Col 19: null_double_value is NULL
Col 20: null_numeric_value is NULL
Col 21: null_char_value is NULL
Col 22: null_varchar_value is NULL
Col 23: null_text_value is NULL
Col 24: null_point_value is NULL
Col 25: null_time_value is NULL
Col 26: null_date_value is NULL
Col 27: null_timestamp_value is NULL
Row 1:
Col 0: boolean_value: True
Col 1: int2_value: -22
Col 2: int4_value: 1048000
Col 3: bigint_value: 123456789012345
Col 4: float_value: 3.141590
Col 5: double_value: 3.14159
Col 6: numeric_value: 123456789012.345
Col 7: char_value: This is a char
Col 8: varchar_value: This is a varchar
Col 9: text_value: This is a text
Col 10: point_value: (1,0)
Col 11: time_value: 01/01/1 21:13:14
Col 12: date_value: 02/29/2000 00:00:00
Col 13: timestamp_value: 02/29/2004 14:00:11
Col 14: null_boolean_value is NULL
Col 15: null_int2_value is NULL
Col 16: null_int4_value is NULL
Col 17: null_bigint_value is NULL
Col 18: null_float_value is NULL
Col 19: null_double_value is NULL
Col 20: null_numeric_value is NULL
Col 21: null_char_value is NULL
Col 22: null_varchar_value is NULL
Col 23: null_text_value is NULL
Col 24: null_point_value is NULL
Col 25: null_time_value is NULL
Col 26: null_date_value is NULL
Col 27: null_timestamp_value is NULL
Total Rows Retrieved: 2
Total Result sets: 1
Call ExecuteReader with a SQL Command. (Not INSERT,UPDATE,DELETE
).
Result is from a SQL Command not (INSERT,UPDATE,DELETE). Records Affected: -1
Total Result sets: 0
Call ExecuteReader with a SQL Command. (Is INSERT,UPDATE,DELETE)
.
Result is from a SQL Command (INSERT,UPDATE,DELETE). Records Affected: 1
Total Result sets: 0
Calling stored procedure version()
Result: PostgreSQL 7.2.1 on i686-pc-cygwin, compiled by GCC 2.95.3-5
Database Server Version: PostgreSQL 7.2.1 on i686-pc-cygwin, compiled by GCC 2.9
5.3-5
Clean up...
Drop table...
OK
RESULT: 0
</pre>
+7 -23
View File
@@ -1,22 +1,21 @@
* 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.
Anonymous access to the Mono is available currently from the
HispaLinux CVS server (later I will provide a nice
anoncvs.go-mono.com alias).
Sources are currently being updated every hour.
The server is currently located in Spain. If you want to
become an AnonCVS mirror, go <a href="#mirror">here</a>
** Checking out the sources
To check out the sources for the first time from the
repository, use this command:
<pre>
export CVSROOT=:pserver:anonymous@anoncvs.go-mono.com:/mono
cvs login
export CVSROOT=:pserver:anonymous@reypastor.hispalinux.es:/mono
cvs -z3 co mcs mono gtk-sharp
</pre>
@@ -53,18 +52,3 @@
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>
-130
View File
@@ -1,130 +0,0 @@
* ASP.NET
ASP.NET support is divided in two pieces:
<ul>
* Web Forms (Web Applications infrastructure).
* Web Services (the SOAP-based rpc system).
</ul>
There is work underway for both systems. The Web Forms
support is more advanced at this point, and various ".aspx"
programs can be run using the Mono runtime and the XSP page
parser.
Tim started work on the Web Services. Although we have a
SoapFormatter as part of the remoting infrastructure already
(contributed by Jesus), most people will be using the ASP.NET
Web Services support. Work for the supporting class libraries
just started recently.
* Web Forms: The pieces
There are a couple of components to the puzzle:
<ul>
* .aspx page parser (converts .aspx to C# code).
* System.Web.HttpRuntime support.
* Web controls (System.Web.UI.HtmlControls and
System.Web.UI.WebControls).
* Underlying infrastructure for the controls (System.Web.UI).
* HttpRuntime.ProcessRequest is the core of the ASP.NET
implementation.
</ul>
Gonzalo has been working on an ASP.NET parser that takes .aspx
files and generated the code required to run them (the code lives in
module `xsp' along with a little web server for testing).
Most of the runtime support was written by Patrik Torstensson
(now at Intel). This was interesting, because in order to implement
some of its features, Patrik had to go into the runtime/JIT engine and
he spent a few weeks doing work there.
The classes for running ASP.NET are being actively written.
Gaurav, Leen and Patrik worked in the core of the classes
required to run ASP.NET web application as well as a small
embeddable web server.
Duncan got our System.Web assembly to compile.
** HttpRuntime
Patrik has authored most of the HttpRuntime support (both on
the System.Web and on the foundation).
He is now working on finishing HttpRuntime and a few needed
classes.
** XSP
Currently XSP provides the .aspx compiler to C#.
There is also a small web server for testing in module xsp
along with a bunch of .aspx pages to test the server.
The C# code generator is being moved to System.Web.Compilation.
Gonzalo is in charge of the compiler.
** Controls
A lot of work has been put in the various classes that
implement the controls (UI.HtmlControls and UI.WebControls),
but they have been coded mostly in the dark, and without being
able to test them in real life: Gaurav and Leen worked very
hard on this namespace.
We can now render all HtmlControls and almost all WebControls.
DataGrid and DataList controls are being finisehd by Gaurav.
Xml control needs some work on System.Xml related to XSL.
** Extending ASP.NET
Currently you have to reference in your ASP.NET the control
and all of its properties, which works fine if you have a GUI
designer, but is harder for people used to develop using text
editors.
Since we have a parser, we could extend this parser to allow
people to still use ASP.NET controls, using a simpler syntax.
For example people doing blogs and editing their templates
over the web probably do not want to use direct ASP.NET but a
wrapper around it.
** Roadmap
1. The Parser.
2. Get the parser to generate output compatible with ASP.NET.
3. Run the sample output with the real Microsoft runtime
but using our generated page.
4. Run the sample with our classes with the .NET runtime.
5. Run the samples with our classes with the our runtime (without
using HttpRuntime).
6. Finish HttpRuntime.
<b>We are here</b>.
7. Running our sample code with our classes with our runtime.
** How to Help
Testing and fixing HtmlControls, WebControls and validators is an
easy way to help.
In the CVS module XSP you can find the aspx to C# page parser,
a little web server used for testing and a directory containing
sample aspx pages.
You have some documentation under doc directory and in the README
file of each directory. They explain how to test our System.Web.
Testing is really easy!
-37
View File
@@ -1,37 +0,0 @@
* C# Books
A Programmer's Introduction to C# - Second Edition: Eric Gunnerson
* Remoting
<a href="http://www.dotnetremoting.cc/book/AdvancedDotNetRemoting.asp">
Advanced .NET Remoting: Ingo Rammer</a>
* Compiler Implementation
Compilers - Principles, Techniques, and Tools: Alfred V. Aho, Ravi Sethi,
Jeffrey D. Ullman
Advanced Compiler Design Implementation: Steven S. Muchnick
Modern Compiler Implementation in C: Andrew W. Appel
A Retargetable C Compiler - Design and Implementation: C. Fraser, David
Hanson
* Reference Manuals
<a
href="http://developer.intel.com/design/pentium/manuals/24319101.pdf">Intel
Architecture Software Developer's Manual, Volume 2 - Instruction Set Reference Manual</a>
<a
href="http://www.caldera.com/developers/devspecs/abi386-4.pdf">System V ABI
- i386 Architecture Processor Supplement</a>
<a
href="http://www.caldera.com/developers/devspecs/mipsabi.pdf">System V ABI -
MIPS Processor supplement</a>
<a href="http://www.sparc.org/standards/V8.pdf">The SPARC Architecture
Manual Version 8</a>
+34 -13
View File
@@ -2,13 +2,14 @@
MCS is currently able to compile itself and many more C#
programs (there is a test suite included that you can use).
It is routinely used to compile Mono, roughly half a million
lines of C# code.
We are in feature completion mode right now. There are still
a couple of areas that are not covered by the Mono compiler, but
they are very very few at this point (security attributes),
you can also browse the MCS <a href="http://bugzilla.ximian.com/buglist.cgi?product=Mono%2FMCS&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&email1=&emailtype1=substring&emailassigned_to1=1&email2=&emailtype2=substring&emailreporter2=1&changedin=&chfieldfrom=&chfieldto=Now&chfieldvalue=&short_desc=&short_desc_type=substring&long_desc=&long_desc_type=substring&bug_file_loc=&bug_file_loc_type=substring&keywords=&keywords_type=anywords&op_sys_details=&op_sys_details_type=substring&version_details=&version_details_type=substring&cmdtype=doit&newqueryname=&order=Reuse+same+sort+as+last+time&form_name=query">bugs</a> from Bugzilla.
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
@@ -22,9 +23,10 @@
** Running MCS
MCS is written in C# and uses heavily the .NET APIs. MCS runs
on Linux with the Mono runtime and on Windows with both the
.NET runtime and the Mono runtime.
MCS is written in C# and uses heavily the .NET APIs. At this point
MCS only runs on Windows with the .NET Framework SDK installed. Work
is progressing rapidly in our JIT engine and our class libraries to
allow MCS to be ran in non-Windows systems.
** Reporting Bugs in MCS
@@ -99,14 +101,33 @@
able to use this generic CIL optimizer in their projects
reducing their time to develop a production compiler.
** History
<a name="tasks">
** Current pending tasks
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.
Simple tasks:
The Mono Runtime and the Mono execution engine were able to make
our compiler self hosting on March 12, 2002.
<ul>
* Redo the way we deal with built-in operators.
</ul>
Larger tasks:
<ul>
* 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>
* 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.
</ul>
** Questions and Answers
+407
View File
@@ -0,0 +1,407 @@
* 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
These classes are only classes pending from the CORLIB assembly
other assemblies are not yet listed. We are going to be working
on an improved status display for pending classes.
Please bear with us in the meantime.
This is a list of pending classes, and links to their documentation on MSDN.Microsoft.com<p><p>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfMicrosoftWin32Registry␍ClassTopic.asp">Microsoft.Win32.Registry␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfMicrosoftWin32RegistryHive␍ClassTopic.asp">Microsoft.Win32.RegistryHive␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfMicrosoftWin32RegistryKey␍ClassTopic.asp">Microsoft.Win32.RegistryKey␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystem__ComObject␍ClassTopic.asp">System.__ComObject␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemActivator␍ClassTopic.asp">System.Activator␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemArgIterator␍ClassTopic.asp">System.ArgIterator␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemAssemblyLoadEventHandler␍ClassTopic.asp">System.AssemblyLoadEventHandler␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemAsyncCallback␍ClassTopic.asp">System.AsyncCallback␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemCrossAppDomainDelegate␍ClassTopic.asp">System.CrossAppDomainDelegate␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemDBNull␍ClassTopic.asp">System.DBNull␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemDiagnosticsSymbolStoreSymDocumentType␍ClassTopic.asp">System.Diagnostics.SymbolStore.SymDocumentType␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemDiagnosticsSymbolStoreSymLanguageType␍ClassTopic.asp">System.Diagnostics.SymbolStore.SymLanguageType␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemDiagnosticsSymbolStoreSymLanguageVendor␍ClassTopic.asp">System.Diagnostics.SymbolStore.SymLanguageVendor␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemEventHandler␍ClassTopic.asp">System.EventHandler␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationCompareInfo␍ClassTopic.asp">System.Globalization.CompareInfo␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationHebrewCalendar␍ClassTopic.asp">System.Globalization.HebrewCalendar␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationHijriCalendar␍ClassTopic.asp">System.Globalization.HijriCalendar␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationJapaneseCalendar␍ClassTopic.asp">System.Globalization.JapaneseCalendar␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationKoreanCalendar␍ClassTopic.asp">System.Globalization.KoreanCalendar␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationRegionInfo␍ClassTopic.asp">System.Globalization.RegionInfo␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationSortKey␍ClassTopic.asp">System.Globalization.SortKey␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationStringInfo␍ClassTopic.asp">System.Globalization.StringInfo␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationTaiwanCalendar␍ClassTopic.asp">System.Globalization.TaiwanCalendar␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationTextElementEnumerator␍ClassTopic.asp">System.Globalization.TextElementEnumerator␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationTextInfo␍ClassTopic.asp">System.Globalization.TextInfo␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationThaiBuddhistCalendar␍ClassTopic.asp">System.Globalization.ThaiBuddhistCalendar␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemIOEndOfStreamException␍ClassTopic.asp">System.IO.EndOfStreamException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemIOIsolatedStorageIsolatedStorage␍ClassTopic.asp">System.IO.IsolatedStorage.IsolatedStorage␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemIOIsolatedStorageIsolatedStorageException␍ClassTopic.asp">System.IO.IsolatedStorage.IsolatedStorageException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemIOIsolatedStorageIsolatedStorageFile␍ClassTopic.asp">System.IO.IsolatedStorage.IsolatedStorageFile␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemIOPathTooLongException␍ClassTopic.asp">System.IO.PathTooLongException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemReflectionEmitMethodRental␍ClassTopic.asp">System.Reflection.Emit.MethodRental␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemReflectionMemberFilter␍ClassTopic.asp">System.Reflection.MemberFilter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemReflectionMissing␍ClassTopic.asp">System.Reflection.Missing␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemReflectionModuleResolveEventHandler␍ClassTopic.asp">System.Reflection.ModuleResolveEventHandler␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemReflectionPointer␍ClassTopic.asp">System.Reflection.Pointer␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemReflectionStrongNameKeyPair␍ClassTopic.asp">System.Reflection.StrongNameKeyPair␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemReflectionTargetException␍ClassTopic.asp">System.Reflection.TargetException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemReflectionTypeFilter␍ClassTopic.asp">System.Reflection.TypeFilter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemResolveEventHandler␍ClassTopic.asp">System.ResolveEventHandler␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesAccessedThroughPropertyAttribute␍ClassTopic.asp">System.Runtime.CompilerServices.AccessedThroughPropertyAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesCallConvCdecl␍ClassTopic.asp">System.Runtime.CompilerServices.CallConvCdecl␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesCallConvFastcall␍ClassTopic.asp">System.Runtime.CompilerServices.CallConvFastcall␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesCallConvStdcall␍ClassTopic.asp">System.Runtime.CompilerServices.CallConvStdcall␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesCallConvThiscall␍ClassTopic.asp">System.Runtime.CompilerServices.CallConvThiscall␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesCompilationRelaxationsAttribute␍ClassTopic.asp">System.Runtime.CompilerServices.CompilationRelaxationsAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesCompilerGlobalScopeAttribute␍ClassTopic.asp">System.Runtime.CompilerServices.CompilerGlobalScopeAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesCustomConstantAttribute␍ClassTopic.asp">System.Runtime.CompilerServices.CustomConstantAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesDateTimeConstantAttribute␍ClassTopic.asp">System.Runtime.CompilerServices.DateTimeConstantAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesDecimalConstantAttribute␍ClassTopic.asp">System.Runtime.CompilerServices.DecimalConstantAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesDiscardableAttribute␍ClassTopic.asp">System.Runtime.CompilerServices.DiscardableAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesIDispatchConstantAttribute␍ClassTopic.asp">System.Runtime.CompilerServices.IDispatchConstantAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesIsVolatile␍ClassTopic.asp">System.Runtime.CompilerServices.IsVolatile␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesIUnknownConstantAttribute␍ClassTopic.asp">System.Runtime.CompilerServices.IUnknownConstantAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeCompilerServicesRequiredAttributeAttribute␍ClassTopic.asp">System.Runtime.CompilerServices.RequiredAttributeAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesArrayWithOffset␍ClassTopic.asp">System.Runtime.InteropServices.ArrayWithOffset␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesAssemblyRegistrationFlags␍ClassTopic.asp">System.Runtime.InteropServices.AssemblyRegistrationFlags␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesAutomationProxyAttribute␍ClassTopic.asp">System.Runtime.InteropServices.AutomationProxyAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesBIND_OPTS␍ClassTopic.asp">System.Runtime.InteropServices.BIND_OPTS␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesBINDPTR␍ClassTopic.asp">System.Runtime.InteropServices.BINDPTR␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesCALLCONV␍ClassTopic.asp">System.Runtime.InteropServices.CALLCONV␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesClassInterfaceAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ClassInterfaceAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesClassInterfaceType␍ClassTopic.asp">System.Runtime.InteropServices.ClassInterfaceType␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesCoClassAttribute␍ClassTopic.asp">System.Runtime.InteropServices.CoClassAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesComAliasNameAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ComAliasNameAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesComConversionLossAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ComConversionLossAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesComEventInterfaceAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ComEventInterfaceAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesCOMException␍ClassTopic.asp">System.Runtime.InteropServices.COMException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesComImportAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ComImportAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesComInterfaceType␍ClassTopic.asp">System.Runtime.InteropServices.ComInterfaceType␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesComMemberType␍ClassTopic.asp">System.Runtime.InteropServices.ComMemberType␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesComRegisterFunctionAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ComRegisterFunctionAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesComSourceInterfacesAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ComSourceInterfacesAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesComUnregisterFunctionAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ComUnregisterFunctionAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesComVisibleAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ComVisibleAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesCONNECTDATA␍ClassTopic.asp">System.Runtime.InteropServices.CONNECTDATA␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesCurrencyWrapper␍ClassTopic.asp">System.Runtime.InteropServices.CurrencyWrapper␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesDESCKIND␍ClassTopic.asp">System.Runtime.InteropServices.DESCKIND␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesDispatchWrapper␍ClassTopic.asp">System.Runtime.InteropServices.DispatchWrapper␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesDispIdAttribute␍ClassTopic.asp">System.Runtime.InteropServices.DispIdAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesDISPPARAMS␍ClassTopic.asp">System.Runtime.InteropServices.DISPPARAMS␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesELEMDESC␍ClassTopic.asp">System.Runtime.InteropServices.ELEMDESC␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesErrorWrapper␍ClassTopic.asp">System.Runtime.InteropServices.ErrorWrapper␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesEXCEPINFO␍ClassTopic.asp">System.Runtime.InteropServices.EXCEPINFO␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesExpandoIExpando␍ClassTopic.asp">System.Runtime.InteropServices.Expando.IExpando␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesExporterEventKind␍ClassTopic.asp">System.Runtime.InteropServices.ExporterEventKind␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesExtensibleClassFactory␍ClassTopic.asp">System.Runtime.InteropServices.ExtensibleClassFactory␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesFILETIME␍ClassTopic.asp">System.Runtime.InteropServices.FILETIME␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesFUNCDESC␍ClassTopic.asp">System.Runtime.InteropServices.FUNCDESC␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesFUNCFLAGS␍ClassTopic.asp">System.Runtime.InteropServices.FUNCFLAGS␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesFUNCKIND␍ClassTopic.asp">System.Runtime.InteropServices.FUNCKIND␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesGCHandle␍ClassTopic.asp">System.Runtime.InteropServices.GCHandle␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesGuidAttribute␍ClassTopic.asp">System.Runtime.InteropServices.GuidAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesHandleRef␍ClassTopic.asp">System.Runtime.InteropServices.HandleRef␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesICustomAdapter␍ClassTopic.asp">System.Runtime.InteropServices.ICustomAdapter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesICustomFactory␍ClassTopic.asp">System.Runtime.InteropServices.ICustomFactory␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesICustomMarshaler␍ClassTopic.asp">System.Runtime.InteropServices.ICustomMarshaler␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesIDispatchImplAttribute␍ClassTopic.asp">System.Runtime.InteropServices.IDispatchImplAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesIDispatchImplType␍ClassTopic.asp">System.Runtime.InteropServices.IDispatchImplType␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesIDLDESC␍ClassTopic.asp">System.Runtime.InteropServices.IDLDESC␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesIDLFLAG␍ClassTopic.asp">System.Runtime.InteropServices.IDLFLAG␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesIMPLTYPEFLAGS␍ClassTopic.asp">System.Runtime.InteropServices.IMPLTYPEFLAGS␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesImportedFromTypeLibAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ImportedFromTypeLibAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesImporterEventKind␍ClassTopic.asp">System.Runtime.InteropServices.ImporterEventKind␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesInterfaceTypeAttribute␍ClassTopic.asp">System.Runtime.InteropServices.InterfaceTypeAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesInvalidComObjectException␍ClassTopic.asp">System.Runtime.InteropServices.InvalidComObjectException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesInvalidOleVariantTypeException␍ClassTopic.asp">System.Runtime.InteropServices.InvalidOleVariantTypeException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesINVOKEKIND␍ClassTopic.asp">System.Runtime.InteropServices.INVOKEKIND␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesIRegistrationServices␍ClassTopic.asp">System.Runtime.InteropServices.IRegistrationServices␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesITypeLibConverter␍ClassTopic.asp">System.Runtime.InteropServices.ITypeLibConverter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesITypeLibExporterNameProvider␍ClassTopic.asp">System.Runtime.InteropServices.ITypeLibExporterNameProvider␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesITypeLibExporterNotifySink␍ClassTopic.asp">System.Runtime.InteropServices.ITypeLibExporterNotifySink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesITypeLibImporterNotifySink␍ClassTopic.asp">System.Runtime.InteropServices.ITypeLibImporterNotifySink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesLCIDConversionAttribute␍ClassTopic.asp">System.Runtime.InteropServices.LCIDConversionAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesLIBFLAGS␍ClassTopic.asp">System.Runtime.InteropServices.LIBFLAGS␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesMarshalDirectiveException␍ClassTopic.asp">System.Runtime.InteropServices.MarshalDirectiveException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesObjectCreationDelegate␍ClassTopic.asp">System.Runtime.InteropServices.ObjectCreationDelegate␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesPARAMDESC␍ClassTopic.asp">System.Runtime.InteropServices.PARAMDESC␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesPARAMFLAG␍ClassTopic.asp">System.Runtime.InteropServices.PARAMFLAG␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesPreserveSigAttribute␍ClassTopic.asp">System.Runtime.InteropServices.PreserveSigAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesPrimaryInteropAssemblyAttribute␍ClassTopic.asp">System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesProgIdAttribute␍ClassTopic.asp">System.Runtime.InteropServices.ProgIdAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesRegistrationServices␍ClassTopic.asp">System.Runtime.InteropServices.RegistrationServices␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesRuntimeEnvironment␍ClassTopic.asp">System.Runtime.InteropServices.RuntimeEnvironment␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesSafeArrayRankMismatchException␍ClassTopic.asp">System.Runtime.InteropServices.SafeArrayRankMismatchException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesSafeArrayTypeMismatchException␍ClassTopic.asp">System.Runtime.InteropServices.SafeArrayTypeMismatchException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesSEHException␍ClassTopic.asp">System.Runtime.InteropServices.SEHException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesSTATSTG␍ClassTopic.asp">System.Runtime.InteropServices.STATSTG␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesSYSKIND␍ClassTopic.asp">System.Runtime.InteropServices.SYSKIND␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTYPEATTR␍ClassTopic.asp">System.Runtime.InteropServices.TYPEATTR␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTYPEDESC␍ClassTopic.asp">System.Runtime.InteropServices.TYPEDESC␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTYPEFLAGS␍ClassTopic.asp">System.Runtime.InteropServices.TYPEFLAGS␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTYPEKIND␍ClassTopic.asp">System.Runtime.InteropServices.TYPEKIND␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTYPELIBATTR␍ClassTopic.asp">System.Runtime.InteropServices.TYPELIBATTR␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTypeLibConverter␍ClassTopic.asp">System.Runtime.InteropServices.TypeLibConverter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTypeLibExporterFlags␍ClassTopic.asp">System.Runtime.InteropServices.TypeLibExporterFlags␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTypeLibFuncAttribute␍ClassTopic.asp">System.Runtime.InteropServices.TypeLibFuncAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTypeLibFuncFlags␍ClassTopic.asp">System.Runtime.InteropServices.TypeLibFuncFlags␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTypeLibImporterFlags␍ClassTopic.asp">System.Runtime.InteropServices.TypeLibImporterFlags␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTypeLibTypeAttribute␍ClassTopic.asp">System.Runtime.InteropServices.TypeLibTypeAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTypeLibTypeFlags␍ClassTopic.asp">System.Runtime.InteropServices.TypeLibTypeFlags␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTypeLibVarAttribute␍ClassTopic.asp">System.Runtime.InteropServices.TypeLibVarAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesTypeLibVarFlags␍ClassTopic.asp">System.Runtime.InteropServices.TypeLibVarFlags␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIBindCtx␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIBindCtx␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIConnectionPoint␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIConnectionPoint␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIConnectionPointContainer␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIConnectionPointContainer␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIEnumConnectionPoints␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIEnumConnectionPoints␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIEnumConnections␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIEnumConnections␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIEnumMoniker␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIEnumMoniker␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIEnumString␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIEnumString␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIEnumVARIANT␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIEnumVARIANT␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIMoniker␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIMoniker␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIPersistFile␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIPersistFile␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIRunningObjectTable␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIRunningObjectTable␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMIStream␍ClassTopic.asp">System.Runtime.InteropServices.UCOMIStream␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMITypeComp␍ClassTopic.asp">System.Runtime.InteropServices.UCOMITypeComp␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMITypeInfo␍ClassTopic.asp">System.Runtime.InteropServices.UCOMITypeInfo␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUCOMITypeLib␍ClassTopic.asp">System.Runtime.InteropServices.UCOMITypeLib␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesUnknownWrapper␍ClassTopic.asp">System.Runtime.InteropServices.UnknownWrapper␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesVARDESC␍ClassTopic.asp">System.Runtime.InteropServices.VARDESC␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeInteropServicesVARFLAGS␍ClassTopic.asp">System.Runtime.InteropServices.VARFLAGS␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingActivatedClientTypeEntry␍ClassTopic.asp">System.Runtime.Remoting.ActivatedClientTypeEntry␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingActivatedServiceTypeEntry␍ClassTopic.asp">System.Runtime.Remoting.ActivatedServiceTypeEntry␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingActivationUrlAttribute␍ClassTopic.asp">System.Runtime.Remoting.Activation.UrlAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsBaseChannelObjectWithProperties␍ClassTopic.asp">System.Runtime.Remoting.Channels.BaseChannelObjectWithProperties␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsBaseChannelSinkWithProperties␍ClassTopic.asp">System.Runtime.Remoting.Channels.BaseChannelSinkWithProperties␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsBaseChannelWithProperties␍ClassTopic.asp">System.Runtime.Remoting.Channels.BaseChannelWithProperties␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsChannelDataStore␍ClassTopic.asp">System.Runtime.Remoting.Channels.ChannelDataStore␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsChannelServices␍ClassTopic.asp">System.Runtime.Remoting.Channels.ChannelServices␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsClientChannelSinkStack␍ClassTopic.asp">System.Runtime.Remoting.Channels.ClientChannelSinkStack␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIChannel␍ClassTopic.asp">System.Runtime.Remoting.Channels.IChannel␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIChannelDataStore␍ClassTopic.asp">System.Runtime.Remoting.Channels.IChannelDataStore␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIChannelReceiver␍ClassTopic.asp">System.Runtime.Remoting.Channels.IChannelReceiver␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIChannelReceiverHook␍ClassTopic.asp">System.Runtime.Remoting.Channels.IChannelReceiverHook␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIChannelSender␍ClassTopic.asp">System.Runtime.Remoting.Channels.IChannelSender␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIChannelSinkBase␍ClassTopic.asp">System.Runtime.Remoting.Channels.IChannelSinkBase␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIClientChannelSink␍ClassTopic.asp">System.Runtime.Remoting.Channels.IClientChannelSink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIClientChannelSinkProvider␍ClassTopic.asp">System.Runtime.Remoting.Channels.IClientChannelSinkProvider␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIClientChannelSinkStack␍ClassTopic.asp">System.Runtime.Remoting.Channels.IClientChannelSinkStack␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIClientFormatterSink␍ClassTopic.asp">System.Runtime.Remoting.Channels.IClientFormatterSink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIClientFormatterSinkProvider␍ClassTopic.asp">System.Runtime.Remoting.Channels.IClientFormatterSinkProvider␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIClientResponseChannelSinkStack␍ClassTopic.asp">System.Runtime.Remoting.Channels.IClientResponseChannelSinkStack␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIServerChannelSink␍ClassTopic.asp">System.Runtime.Remoting.Channels.IServerChannelSink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIServerChannelSinkProvider␍ClassTopic.asp">System.Runtime.Remoting.Channels.IServerChannelSinkProvider␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIServerChannelSinkStack␍ClassTopic.asp">System.Runtime.Remoting.Channels.IServerChannelSinkStack␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIServerFormatterSinkProvider␍ClassTopic.asp">System.Runtime.Remoting.Channels.IServerFormatterSinkProvider␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsIServerResponseChannelSinkStack␍ClassTopic.asp">System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsITransportHeaders␍ClassTopic.asp">System.Runtime.Remoting.Channels.ITransportHeaders␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsServerChannelSinkStack␍ClassTopic.asp">System.Runtime.Remoting.Channels.ServerChannelSinkStack␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsServerProcessing␍ClassTopic.asp">System.Runtime.Remoting.Channels.ServerProcessing␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsSinkProviderData␍ClassTopic.asp">System.Runtime.Remoting.Channels.SinkProviderData␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingChannelsTransportHeaders␍ClassTopic.asp">System.Runtime.Remoting.Channels.TransportHeaders␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingContextsContextProperty␍ClassTopic.asp">System.Runtime.Remoting.Contexts.ContextProperty␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingContextsCrossContextDelegate␍ClassTopic.asp">System.Runtime.Remoting.Contexts.CrossContextDelegate␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingContextsIContextPropertyActivator␍ClassTopic.asp">System.Runtime.Remoting.Contexts.IContextPropertyActivator␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingContextsIContributeClientContextSink␍ClassTopic.asp">System.Runtime.Remoting.Contexts.IContributeClientContextSink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingContextsIContributeDynamicSink␍ClassTopic.asp">System.Runtime.Remoting.Contexts.IContributeDynamicSink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingContextsIContributeEnvoySink␍ClassTopic.asp">System.Runtime.Remoting.Contexts.IContributeEnvoySink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingContextsIContributeObjectSink␍ClassTopic.asp">System.Runtime.Remoting.Contexts.IContributeObjectSink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingContextsIContributeServerContextSink␍ClassTopic.asp">System.Runtime.Remoting.Contexts.IContributeServerContextSink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingIChannelInfo␍ClassTopic.asp">System.Runtime.Remoting.IChannelInfo␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingIEnvoyInfo␍ClassTopic.asp">System.Runtime.Remoting.IEnvoyInfo␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingInternalRemotingServices␍ClassTopic.asp">System.Runtime.Remoting.InternalRemotingServices␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingIObjectHandle␍ClassTopic.asp">System.Runtime.Remoting.IObjectHandle␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingIRemotingTypeInfo␍ClassTopic.asp">System.Runtime.Remoting.IRemotingTypeInfo␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingLifetimeClientSponsor␍ClassTopic.asp">System.Runtime.Remoting.Lifetime.ClientSponsor␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingLifetimeILease␍ClassTopic.asp">System.Runtime.Remoting.Lifetime.ILease␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingLifetimeISponsor␍ClassTopic.asp">System.Runtime.Remoting.Lifetime.ISponsor␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingLifetimeLeaseState␍ClassTopic.asp">System.Runtime.Remoting.Lifetime.LeaseState␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingLifetimeLifetimeServices␍ClassTopic.asp">System.Runtime.Remoting.Lifetime.LifetimeServices␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingAsyncResult␍ClassTopic.asp">System.Runtime.Remoting.Messaging.AsyncResult␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingCallContext␍ClassTopic.asp">System.Runtime.Remoting.Messaging.CallContext␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingConstructionCall␍ClassTopic.asp">System.Runtime.Remoting.Messaging.ConstructionCall␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingConstructionResponse␍ClassTopic.asp">System.Runtime.Remoting.Messaging.ConstructionResponse␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingHeader␍ClassTopic.asp">System.Runtime.Remoting.Messaging.Header␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingHeaderHandler␍ClassTopic.asp">System.Runtime.Remoting.Messaging.HeaderHandler␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingILogicalThreadAffinative␍ClassTopic.asp">System.Runtime.Remoting.Messaging.ILogicalThreadAffinative␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingIMessageCtrl␍ClassTopic.asp">System.Runtime.Remoting.Messaging.IMessageCtrl␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingIMessageSink␍ClassTopic.asp">System.Runtime.Remoting.Messaging.IMessageSink␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingIMethodCallMessage␍ClassTopic.asp">System.Runtime.Remoting.Messaging.IMethodCallMessage␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingInternalMessageWrapper␍ClassTopic.asp">System.Runtime.Remoting.Messaging.InternalMessageWrapper␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingIRemotingFormatter␍ClassTopic.asp">System.Runtime.Remoting.Messaging.IRemotingFormatter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingLogicalCallContext␍ClassTopic.asp">System.Runtime.Remoting.Messaging.LogicalCallContext␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingMessageSurrogateFilter␍ClassTopic.asp">System.Runtime.Remoting.Messaging.MessageSurrogateFilter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingMethodCall␍ClassTopic.asp">System.Runtime.Remoting.Messaging.MethodCall␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingMethodCallMessageWrapper␍ClassTopic.asp">System.Runtime.Remoting.Messaging.MethodCallMessageWrapper␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingMethodResponse␍ClassTopic.asp">System.Runtime.Remoting.Messaging.MethodResponse␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingMethodReturnMessageWrapper␍ClassTopic.asp">System.Runtime.Remoting.Messaging.MethodReturnMessageWrapper␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingOneWayAttribute␍ClassTopic.asp">System.Runtime.Remoting.Messaging.OneWayAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingRemotingSurrogateSelector␍ClassTopic.asp">System.Runtime.Remoting.Messaging.RemotingSurrogateSelector␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMessagingReturnMessage␍ClassTopic.asp">System.Runtime.Remoting.Messaging.ReturnMessage␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataSoapAttribute␍ClassTopic.asp">System.Runtime.Remoting.Metadata.SoapAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataSoapFieldAttribute␍ClassTopic.asp">System.Runtime.Remoting.Metadata.SoapFieldAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataSoapMethodAttribute␍ClassTopic.asp">System.Runtime.Remoting.Metadata.SoapMethodAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataSoapOption␍ClassTopic.asp">System.Runtime.Remoting.Metadata.SoapOption␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataSoapParameterAttribute␍ClassTopic.asp">System.Runtime.Remoting.Metadata.SoapParameterAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataSoapTypeAttribute␍ClassTopic.asp">System.Runtime.Remoting.Metadata.SoapTypeAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001ISoapXsd␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.ISoapXsd␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapAnyUri␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapAnyUri␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapBase64Binary␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapBase64Binary␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapDate␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDate␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapDateTime␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDateTime␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapDay␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDay␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapDuration␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDuration␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapEntities␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapEntities␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapEntity␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapEntity␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapHexBinary␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapHexBinary␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapId␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapId␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapIdref␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapIdref␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapIdrefs␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapIdrefs␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapInteger␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapInteger␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapLanguage␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapLanguage␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapMonth␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapMonth␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapMonthDay␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapMonthDay␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapName␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapName␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapNcName␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNcName␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapNegativeInteger␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNegativeInteger␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapNmtoken␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNmtoken␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapNmtokens␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNmtokens␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapNonNegativeInteger␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNonNegativeInteger␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapNonPositiveInteger␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNonPositiveInteger␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapNormalizedString␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNormalizedString␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapNotation␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNotation␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapPositiveInteger␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapPositiveInteger␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapQName␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapQName␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapTime␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapTime␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapToken␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapToken␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapYear␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapYear␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataW3cXsd2001SoapYearMonth␍ClassTopic.asp">System.Runtime.Remoting.Metadata.W3cXsd2001.SoapYearMonth␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingMetadataXmlFieldOrderOption␍ClassTopic.asp">System.Runtime.Remoting.Metadata.XmlFieldOrderOption␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingProxiesProxyAttribute␍ClassTopic.asp">System.Runtime.Remoting.Proxies.ProxyAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingProxiesRealProxy␍ClassTopic.asp">System.Runtime.Remoting.Proxies.RealProxy␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingRemotingConfiguration␍ClassTopic.asp">System.Runtime.Remoting.RemotingConfiguration␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingRemotingException␍ClassTopic.asp">System.Runtime.Remoting.RemotingException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingRemotingServices␍ClassTopic.asp">System.Runtime.Remoting.RemotingServices␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingRemotingTimeoutException␍ClassTopic.asp">System.Runtime.Remoting.RemotingTimeoutException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingServerException␍ClassTopic.asp">System.Runtime.Remoting.ServerException␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingServicesEnterpriseServicesHelper␍ClassTopic.asp">System.Runtime.Remoting.Services.EnterpriseServicesHelper␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingServicesITrackingHandler␍ClassTopic.asp">System.Runtime.Remoting.Services.ITrackingHandler␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingServicesTrackingServices␍ClassTopic.asp">System.Runtime.Remoting.Services.TrackingServices␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingSoapServices␍ClassTopic.asp">System.Runtime.Remoting.SoapServices␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingTypeEntry␍ClassTopic.asp">System.Runtime.Remoting.TypeEntry␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingWellKnownClientTypeEntry␍ClassTopic.asp">System.Runtime.Remoting.WellKnownClientTypeEntry␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeRemotingWellKnownServiceTypeEntry␍ClassTopic.asp">System.Runtime.Remoting.WellKnownServiceTypeEntry␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationFormatter␍ClassTopic.asp">System.Runtime.Serialization.Formatter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationFormatterConverter␍ClassTopic.asp">System.Runtime.Serialization.FormatterConverter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationFormattersBinaryBinaryFormatter␍ClassTopic.asp">System.Runtime.Serialization.Formatters.Binary.BinaryFormatter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationFormattersInternalRM␍ClassTopic.asp">System.Runtime.Serialization.Formatters.InternalRM␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationFormattersInternalST␍ClassTopic.asp">System.Runtime.Serialization.Formatters.InternalST␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationFormattersServerFault␍ClassTopic.asp">System.Runtime.Serialization.Formatters.ServerFault␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationFormattersSoapFault␍ClassTopic.asp">System.Runtime.Serialization.Formatters.SoapFault␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationFormattersSoapMessage␍ClassTopic.asp">System.Runtime.Serialization.Formatters.SoapMessage␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationFormatterServices␍ClassTopic.asp">System.Runtime.Serialization.FormatterServices␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationObjectIDGenerator␍ClassTopic.asp">System.Runtime.Serialization.ObjectIDGenerator␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationObjectManager␍ClassTopic.asp">System.Runtime.Serialization.ObjectManager␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationSerializationBinder␍ClassTopic.asp">System.Runtime.Serialization.SerializationBinder␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationSerializationEntry␍ClassTopic.asp">System.Runtime.Serialization.SerializationEntry␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationSerializationInfoEnumerator␍ClassTopic.asp">System.Runtime.Serialization.SerializationInfoEnumerator␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeSerializationSurrogateSelector␍ClassTopic.asp">System.Runtime.Serialization.SurrogateSelector␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemRuntimeArgumentHandle␍ClassTopic.asp">System.RuntimeArgumentHandle␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityAllowPartiallyTrustedCallersAttribute␍ClassTopic.asp">System.Security.AllowPartiallyTrustedCallersAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyCryptoConfig␍ClassTopic.asp">System.Security.Cryptography.CryptoConfig␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyDSACryptoServiceProvider␍ClassTopic.asp">System.Security.Cryptography.DSACryptoServiceProvider␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyHMACSHA1␍ClassTopic.asp">System.Security.Cryptography.HMACSHA1␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyKeyedHashAlgorithm␍ClassTopic.asp">System.Security.Cryptography.KeyedHashAlgorithm␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyMACTripleDES␍ClassTopic.asp">System.Security.Cryptography.MACTripleDES␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyMaskGenerationMethod␍ClassTopic.asp">System.Security.Cryptography.MaskGenerationMethod␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyPasswordDeriveBytes␍ClassTopic.asp">System.Security.Cryptography.PasswordDeriveBytes␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyPKCS1MaskGenerationMethod␍ClassTopic.asp">System.Security.Cryptography.PKCS1MaskGenerationMethod␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRandomNumberGenerator␍ClassTopic.asp">System.Security.Cryptography.RandomNumberGenerator␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRC2␍ClassTopic.asp">System.Security.Cryptography.RC2␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRC2CryptoServiceProvider␍ClassTopic.asp">System.Security.Cryptography.RC2CryptoServiceProvider␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRijndael␍ClassTopic.asp">System.Security.Cryptography.Rijndael␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRijndaelManaged␍ClassTopic.asp">System.Security.Cryptography.RijndaelManaged␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRNGCryptoServiceProvider␍ClassTopic.asp">System.Security.Cryptography.RNGCryptoServiceProvider␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRSA␍ClassTopic.asp">System.Security.Cryptography.RSA␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRSACryptoServiceProvider␍ClassTopic.asp">System.Security.Cryptography.RSACryptoServiceProvider␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRSAOAEPKeyExchangeDeformatter␍ClassTopic.asp">System.Security.Cryptography.RSAOAEPKeyExchangeDeformatter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRSAOAEPKeyExchangeFormatter␍ClassTopic.asp">System.Security.Cryptography.RSAOAEPKeyExchangeFormatter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRSAParameters␍ClassTopic.asp">System.Security.Cryptography.RSAParameters␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRSAPKCS1KeyExchangeDeformatter␍ClassTopic.asp">System.Security.Cryptography.RSAPKCS1KeyExchangeDeformatter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRSAPKCS1KeyExchangeFormatter␍ClassTopic.asp">System.Security.Cryptography.RSAPKCS1KeyExchangeFormatter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRSAPKCS1SignatureDeformatter␍ClassTopic.asp">System.Security.Cryptography.RSAPKCS1SignatureDeformatter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyRSAPKCS1SignatureFormatter␍ClassTopic.asp">System.Security.Cryptography.RSAPKCS1SignatureFormatter␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographySHA1Managed␍ClassTopic.asp">System.Security.Cryptography.SHA1Managed␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographySHA384Managed␍ClassTopic.asp">System.Security.Cryptography.SHA384Managed␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographySHA512Managed␍ClassTopic.asp">System.Security.Cryptography.SHA512Managed␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyTripleDES␍ClassTopic.asp">System.Security.Cryptography.TripleDES␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyTripleDESCryptoServiceProvider␍ClassTopic.asp">System.Security.Cryptography.TripleDESCryptoServiceProvider␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityCryptographyX509CertificatesX509Certificate␍ClassTopic.asp">System.Security.Cryptography.X509Certificates.X509Certificate␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityNamedPermissionSet␍ClassTopic.asp">System.Security.NamedPermissionSet␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsEnvironmentPermission␍ClassTopic.asp">System.Security.Permissions.EnvironmentPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsFileDialogPermission␍ClassTopic.asp">System.Security.Permissions.FileDialogPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsFileDialogPermissionAccess␍ClassTopic.asp">System.Security.Permissions.FileDialogPermissionAccess␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsIsolatedStorageFilePermission␍ClassTopic.asp">System.Security.Permissions.IsolatedStorageFilePermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsIsolatedStoragePermissionAttribute␍ClassTopic.asp">System.Security.Permissions.IsolatedStoragePermissionAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsPrincipalPermission␍ClassTopic.asp">System.Security.Permissions.PrincipalPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsPrincipalPermissionAttribute␍ClassTopic.asp">System.Security.Permissions.PrincipalPermissionAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsPublisherIdentityPermission␍ClassTopic.asp">System.Security.Permissions.PublisherIdentityPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsPublisherIdentityPermissionAttribute␍ClassTopic.asp">System.Security.Permissions.PublisherIdentityPermissionAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsReflectionPermission␍ClassTopic.asp">System.Security.Permissions.ReflectionPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsRegistryPermission␍ClassTopic.asp">System.Security.Permissions.RegistryPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsSecurityPermission␍ClassTopic.asp">System.Security.Permissions.SecurityPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsSecurityPermissionAttribute␍ClassTopic.asp">System.Security.Permissions.SecurityPermissionAttribute␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsSiteIdentityPermission␍ClassTopic.asp">System.Security.Permissions.SiteIdentityPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsStrongNameIdentityPermission␍ClassTopic.asp">System.Security.Permissions.StrongNameIdentityPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsStrongNamePublicKeyBlob␍ClassTopic.asp">System.Security.Permissions.StrongNamePublicKeyBlob␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsUIPermission␍ClassTopic.asp">System.Security.Permissions.UIPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsUrlIdentityPermission␍ClassTopic.asp">System.Security.Permissions.UrlIdentityPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPermissionsZoneIdentityPermission␍ClassTopic.asp">System.Security.Permissions.ZoneIdentityPermission␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyAllMembershipCondition␍ClassTopic.asp">System.Security.Policy.AllMembershipCondition␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyApplicationDirectory␍ClassTopic.asp">System.Security.Policy.ApplicationDirectory␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyApplicationDirectoryMembershipCondition␍ClassTopic.asp">System.Security.Policy.ApplicationDirectoryMembershipCondition␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyFileCodeGroup␍ClassTopic.asp">System.Security.Policy.FileCodeGroup␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyFirstMatchCodeGroup␍ClassTopic.asp">System.Security.Policy.FirstMatchCodeGroup␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyHash␍ClassTopic.asp">System.Security.Policy.Hash␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyHashMembershipCondition␍ClassTopic.asp">System.Security.Policy.HashMembershipCondition␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyNetCodeGroup␍ClassTopic.asp">System.Security.Policy.NetCodeGroup␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyPermissionRequestEvidence␍ClassTopic.asp">System.Security.Policy.PermissionRequestEvidence␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyPolicyStatement␍ClassTopic.asp">System.Security.Policy.PolicyStatement␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyPublisher␍ClassTopic.asp">System.Security.Policy.Publisher␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyPublisherMembershipCondition␍ClassTopic.asp">System.Security.Policy.PublisherMembershipCondition␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicySite␍ClassTopic.asp">System.Security.Policy.Site␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicySiteMembershipCondition␍ClassTopic.asp">System.Security.Policy.SiteMembershipCondition␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyStrongName␍ClassTopic.asp">System.Security.Policy.StrongName␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyStrongNameMembershipCondition␍ClassTopic.asp">System.Security.Policy.StrongNameMembershipCondition␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyUnionCodeGroup␍ClassTopic.asp">System.Security.Policy.UnionCodeGroup␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyUrl␍ClassTopic.asp">System.Security.Policy.Url␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyUrlMembershipCondition␍ClassTopic.asp">System.Security.Policy.UrlMembershipCondition␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyZone␍ClassTopic.asp">System.Security.Policy.Zone␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPolicyZoneMembershipCondition␍ClassTopic.asp">System.Security.Policy.ZoneMembershipCondition␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPrincipalWindowsIdentity␍ClassTopic.asp">System.Security.Principal.WindowsIdentity␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPrincipalWindowsImpersonationContext␍ClassTopic.asp">System.Security.Principal.WindowsImpersonationContext␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSecurityPrincipalWindowsPrincipal␍ClassTopic.asp">System.Security.Principal.WindowsPrincipal␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemThreadingCompressedStack␍ClassTopic.asp">System.Threading.CompressedStack␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemThreadingIOCompletionCallback␍ClassTopic.asp">System.Threading.IOCompletionCallback␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemThreadingThreadStart␍ClassTopic.asp">System.Threading.ThreadStart␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemThreadingTimerCallback␍ClassTopic.asp">System.Threading.TimerCallback␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemThreadingWaitCallback␍ClassTopic.asp">System.Threading.WaitCallback␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemThreadingWaitOrTimerCallback␍ClassTopic.asp">System.Threading.WaitOrTimerCallback␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemTimeZone␍ClassTopic.asp">System.TimeZone␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemTypedReference␍ClassTopic.asp">System.TypedReference␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemUnhandledExceptionEventHandler␍ClassTopic.asp">System.UnhandledExceptionEventHandler␍</a><br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemWeakReference␍ClassTopic.asp">System.WeakReference␍</a><br>
+4 -8
View File
@@ -15,12 +15,8 @@
* 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.
These classes are only classes pending from the CORLIB assembly
other assemblies are not yet listed. We are going to be working
on an improved status display for pending classes.
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>.
Please bear with us in the meantime.
+5
View File
@@ -2,6 +2,11 @@
** 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,
+2 -106
View File
@@ -18,72 +18,15 @@
something that would help tremendously would be to help with
small duties in the project that need to be addressed.
You can see what needs to be done in the class libraries <a href="class-status.html">here</a>
* IRC Channel
Many developers get together on the <b>#mono</b> irc channel
on the <b>irc.gnome.org</b> server.
** To start contributing
As a programmer, you can contribute in three different scenarios to Mono:
<ul>
* If you only have Linux/Unix.
* If you only have Windows.
* If you have both Linux and Windows.
</ul>
You might also want to check our <a href="#setup">common
setups</a> section that describes some common setups that people
use while working on Mono.
*** Contributing to the class library, regression tests or the compiler
This only requires Windows currently.
To start developing classes or to contribute to the compiler,
you only need Windows and the .NET Framework 1.0 SDK. Please notice
that you do not need Visual Studio (although you can use it if
you want). The .NET Framework SDK requires some version of
Windows XP or Windows NT. If you are running Windows 98, 95
or Me, you could use instead the <a
href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/001/829/msdncompositedoc.xml">.NET Redist package</a>, but it
lacks the documentation browser and the ildasm program (C#, VB, JScript and IL
assembler are included).
you want).
You can get it <a href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml&frame=true">here</a>
If you are new to .NET, writing regression tests is a good way
of starting to contribute: it will help you get used to C# as
well as getting comfortable with the .NET APIs.
This helps because at this point you might be the best
qualified person to fix a problem found by the regression
test, or you might have a new class to implement in the .NET
world that only has a test suite.
To get started writing tests see the <a href="testing.html">Test Suite</a>
section. <a href="mono-contribution-howto.html">Here</a> there is a good All-In-One introduction to the art of writing tests.
*** Contributing to the runtime engine
This only requires Linux, currently some tasks are easier if you
have access to Windows as well.
Here are a few things you can do:
<ul>
* Port the runtime to other architectures.
* Port the runtime to other operating systems.
* Finish the IL code verifier in the runtime.
* Hack the JIT, improve the code generator, add new
pattern rules, improve the register allocator.
* Implement the debugging interfaaces
</ul>
** Bug reporting
If you find bugs in Mono, please make sure you enter a bug
@@ -93,8 +36,6 @@
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:
@@ -130,52 +71,7 @@
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
+1 -28
View File
@@ -32,31 +32,4 @@
** Class Library documentation
We are moving to a new setup for documenting the class libraries,
and you can read about it <a href="classlib-doc.html">here</a>.
A few words of warning and advice for class documentors:
A well-documented API can ease hours of frustration; as Mono
matures, robust and complete class library documentation will
become increasingly important. As you write API documentation,
whether it is embedded in source files or in external Monodoc XML,
please keep the following in mind:
Plagarism, even if it's unintentional, is a Bad Thing(TM).
Microsoft's .NET Framework Class Library documentation is an
excellent resource for understanding the behavior and properties of
a type, and a lot of hard work went in to creating this (copyrighted)
resource. Please don't copy from Microsoft's reference when
documenting a type.
To avoid this, I (<a href="mailto:[email protected]">[email protected]</a>)
suggest that you read the complete Microsoft documentation for a type,
ponder it for a while, and write the Mono documentation in your own
words. While it's certainly okay to refer to the Microsoft
documentation to clarify your understanding of behavior or properties,
please don't open the Microsoft docs and refer to them for each member
you document.
There's a lot of domain expertise among the class library contributors;
let's put the same personal stamp on the class library documentation
that we have on the class libraries themselves.
you can read about it <a href="classlib-doc.html">here</a>
+129 -252
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,308 +10,185 @@
test suite and the class library are in the `mcs' package, we
will move this later into `mono' itself.
<b>Note: (Beginners read!)</b> There are a couple of documents you
should read before going ahead. You can reach them in the
<a href="http://www.go-mono.org/mono-beginning.html">Resources/Beginning section</a>. And the <a href="http://www.go-mono.org/faq.html">FAQ</a>
and the <a href="http://geneura.ugr.es/~jaime/deploy/mono-common-problems.html">
Mono Common Problems</a>. Might be useful too. Take the Mono Beginners
HOWTO for your system and proceed as it's described there.
In order to make mcs and the class libraries you will need the
GNU make tools. These may be obtained for the Windows
environment from <a href="http://www.cygwin.com">cygwin.com</a>.
You will also need to get GLIB and <a
href="http://www.freedesktop.org/software/pkgconfig">pkgconfig</a>.
You can get Glib 1.3 from: <a
href="ftp://ftp.gtk.org/pub/gtk/v1.3/glib-1.3.12.tar.gz">ftp://ftp.gtk.org/pub/gtk/v1.3/glib-1.3.12.tar.gz</a>.
<a name="sources">
*** Sources
** Sources
Stay up to date on the Mono team's development using the
<a href="http://lists.ximian.com/mailman/listinfo/mono-cvs-list">
mono-cvs-list</a> mailing list. The CVS source code can also
be browsed <a href="http://cvs.hispalinux.es/cgi-bin/cvsweb/?cvsroot=Mono#dirlist">here</a>
<a name="jun-7">
<b>Mono 0.13</b>
New packaged versions of the Mono C# compiler and Mono runtime
are now available. The latest version is 0.13.
<ul>
* <a href="archive/mono-0.13">Mono 0.13 release notes</a>
* <a href="archive/mcs-0.13.tar.gz">mcs-0.13.tar.gz</a>
Mono C# compiler with class library source code.
* <a href="archive/mono-0.13.tar.gz">mono-0.13.tar.gz</a>
Mono runtime.
</ul>
* Snapshots
Already daily volunteer's made binaries:
<ul>
* <a href="http://www.atoker.com/mono">Debian Linux</a>
* <a href="http://noa.tm/mono/">Red Hat (and RPM based systems)</a>
* <a href="http://www.superin.formativ.net/mono/mono.htm">Windows</a> (works without cygwin!)
</ul>
<b>Note1:</b> Don't look for the Mono BaseLabs RPMs; they are not providing it
anymore.<br>
<b>Note2:</b> You will find that you can get binaries for the gtk-sharp
package too.
We provide both <a href="#packaged">packaged and tested</a>
tarballs (those are known to compile and pass `make
distcheck') as well as <a href="snapshots">daily snapshots</a> done
at 10pm Boston Time
<a name="snapshots">
For up to date sources, it is recommended that you use the Mono
source code from either the
<a href="http://www.go-mono.com/snapshots">nightly snapshots</a> or
the <a href="anoncvs.html">Anonymous CVS</a>. The nightly
snapshots are done every night at 10pm EST (Boston Time).
The anoncvs mirrors provided by Hispalinux are updated every six
hours.
*** Snapshots
The nightly snapshots are not guaranteed to build, but most of the
time they should. They should give you a window to see what we are
up to.
The daily snapshots are available <a
href="http://www.go-mono.com/snapshots">here</a>. These
snapshots are done every day at 10pm EST (Boston Time).
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:
They are not guaranteed to build, but most of the time they
should. They should give you a window to see what we are up to.
<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>
You might also want to track our development using the <a
href="http://lists.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list</a>
mailing list.
The script requires wget on either platform, and building the
software requires make, gcc, automake, autoconf, and libtool.
You should install these packages from your distribution or
with the cygwin installer. You should also take care of setting
the right environment variables as the PKG_CONFIG_FLAGS, etc.
<a name="packaged">
The script will download required packages from
www.go-mono.com and do a cvs checkout of mono in the current
directory. <b>IMPORTANT!:</b> The cvs server chosen defaults to
anonymous cvs;
set your CVSROOT environment variable before running the script to
select a particular cvs server.
At this point, you should look into using one of the <a
href="snapshots">nightly snapshots</a> or getting the
sources from <a href="anoncvs.html">Anonymous CVS</a>
as significant work has gone into Mono since our last stable
release in September.
** Mono Regression Test Suite
We will be making a packaged release sometime in January.
You can get binaries for the Mono Regression Test Suite <a
href="archive/mono-tests.tar.gz">here</a>
<a name="install">
** Building the software manually
** Installing the software
*** Building on Linux
To install and work on the compiler and the class libraries,
follow these instructions:
<ul>
* Install <a href="http://www.cygwin.com">CygWin</a> first.
You can build mono and mcs in Linux but to do that be
sure to obtain the corlib.dll and install it before
trying to compile.
In linux be sure you get <a href="http://www.gtk.org">glib2.0</a>
(>= 2.0.4, 2.0.6
recomended) and <a href="http://www.freedesktop.org/software/pkgconfig">pkg-config</a> 0.80.
Also the corresponding development packages for those as
well as the GNU Build Tools (make, autoconf...).
Then download the mono packages and compile them.
You must start compiling mcs and then mono.
Be sure you set all the environment variables before
compiling. You can use pkg-config --list-all to see
if you forgot to set some of them.
Normally you should enter:
export ACLOCAL_FLAGS="-I /usr/local/share/aclocal"
if your install prefix is /usr/local.
If you downloaded the Mono nightly snapshots, untar the
snapshot.
Change directories to "<strong>mcs</strong>".
Configure, compile and install:
<pre>
<strong>./configure
make
make install</strong></pre>
Do the same in the "<strong>mono</strong>" directory.
*** On Windows, to install and work on the compiler and the class libraries:
**** Install Cygwin and the GNU build tools, Microsoft's .NET Framework SDK and the precompiled GLIB 2.0 and pkg-config libraries.
<ul>
* Install <a href="http://www.cygwin.com">Cygwin</a>.
* Install <a href="http://msdn.microsoft.com/downloads">
Microsoft .NET Framework SDK</a>.
* Change to the <strong>/usr/local</strong> directory
of your Cygwin installation.<br>
Unzip the precompiled packages listed above.
* Untar the MCS distribution (see below for information).
* Go into the MCS directory and type `make windows'
</ul>
<ul>
* If you downloaded the Mono
<a href="http://www.go-mono.com/snapshots">nightly snapshot
</a>, untar the snapshot.
* Change directories to <strong>"mcs"</strong>.
To compile the mono runtime on windows:
* Compile:
<pre>
<strong>make windows</strong>
</pre>
<ul>
* Install <a href="http://www.cygwin.com">CygWin</a> first.
*** On Windows, to compile the mono runtime:
* Install in /usr/local in your Cygwin world the following
packages (compiled by <a href="mailto:[email protected]">Alex Graveley</a>):
<ul>
<li><a href="http://primates.ximian.com/~alex/glib-1.3.12-win32-native.zip">
http://primates.ximian.com/~alex/glib-1.3.12-win32-native.zip</a>
<ul>
* If you downloaded the Mono
<a href="http://www.go-mono.com/snapshots">nightly snapshot
</a>, untar the snapshot.
<li><a href="http://primates.ximian.com/~alex/pkg-config-0.8-cygwin.zip">
http://primates.ximian.com/~alex/pkg-config-0.8-cygwin.zip</a>
</ul>
* Change directories to <strong>"mono"</strong>.
* Configure, compile and install:
<pre><strong>
./configure --prefix=c:/mono
make
make install
</strong></pre>
These already contain libiconv linked statically.
</ul>
* Software resources, notes and old releases:
The required and additional software can be downloaded here:
* Microsoft's .NET Framework SDK from
<a href="http://msdn.microsoft.com/downloads">
msdn.microsoft.com/downloads</a>.
* Cygwin and the GNU Make tools from
<a href="http://www.cygwin.com">www.cygwin.com</a>.
Some people observed problems with autoconf 2.52. Installing
autoconf 2.13 helped in those cases.
* Precompiled GLIB 2.0 and pkg-config packages (and
their dependencies) by the <a href="http://www.gimp.org/~tml/gimp/win32//index.html">GIMP for Windows</a> project from
<a href="http://www.go-mono.com/archive/pkgconfig-0.80-tml-20020101.zip">http://www.go-mono.com/archive/pkgconfig-0.80-tml-20020101.zip</a>
<a href="http://www.go-mono.com/archive/glib-1.3.12-20020101.zip">http://www.go-mono.com/archive/glib-1.3.12-20020101.zip</a>
<a href="http://www.go-mono.com/archive/glib-dev-1.3.12-20020101.zip">http://www.go-mono.com/archive/glib-dev-1.3.12-20020101.zip</a>
<a href="http://www.go-mono.com/archive/libiconv-1.7.zip">http://www.go-mono.com/archive/libiconv-1.7.zip</a>
<a href="http://www.go-mono.com/archive/libiconv-dev-1.7.zip">http://www.go-mono.com/archive/libiconv-dev-1.7-20020101.zip</a>
<a href="http://www.go-mono.com/archive/libintl-0.10.40-20020101.zip">http://www.go-mono.com/archive/libintl-0.10.40-20020101.zip</a>
* Download the Mono source code from the
<a href="#feb-11">packaged versions</a> or
the <a href="http://www.go-mono.com/snapshots">
nightly snapshots</a> or the <a href="anoncvs.html">
Anonymous CVS</a>. The nightly snapshots are done every
night at 10pm EST (Boston Time). The nightly snapshots are
not guaranteed to build, but most of the time they should.
</ul>
*** Notes on compiling GLIB 2.0 and pkg-config from source:
If you want to compile things yourself you will need to compile and install:
<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.
* Install <a href="http://www.freedesktop.org/software/pkgconfig">pkgconfig</a>.
(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>pkgconfig-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
<pre>
tar xzvf pkgconfig-0.8.0.tar.gz
cd pkgconfig-0.8.0
./configure --prefix=/usr
make
make install</strong>
make install
</pre>
* Download, compile and install <a href="ftp://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.7.tar.gz">libiconv</a> from source.<br>
* Install <a href="ftp://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.7.tar.gz">libiconv</a>.
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>.
href="http://www.gimp.org/win32/libiconv-dev-20001007.zip">here</a>.
* Download, compile and install the
<a href="ftp://ftp.gtk.org/pub/gtk/v2.0/glib-2.0.6.tar.gz">
glib 2.0</a> from source.
* Install the newest glib (1.3 version). You can download it
from <a href="ftp://ftp.gtk.org/pub/gtk/v1.3/glib-1.3.12.tar.gz">here</a>.
* Unpack the mono distribution:
<pre>
tar xzvf mono-XXX.tar.gz
</pre>
* Configure, compile and install:
For official releases, use:
<pre>
./configure --prefix=//c/mono
make
make install
</pre>
For Snapshots, or CVS trees, use:
<pre>
./autogen.sh --prefix=//c/mono
make
make install
</pre>
* Some people observed problems with autoconf 2.52. Installing
autoconf 2.13 helped in those cases (don't forget to do a
`make maintainer-clean' after the update)
</ul>
To compile the mono runtime on Unix:
<ul>
* Install <a href="http://www.freedesktop.org/software/pkgconfig">pkgconfig</a>.
* Install newest glib (cvs head version). You can download it
from <a href="ftp://ftp.gtk.org/pub/gtk/v1.3/glib-1.3.12.tar.gz">here</a>. Maybe you need
to modify your ACLOCAL_FLAGS for pkgconfig, for example if
your install prefix is /usr/local:
<pre>
export ACLOCAL_FLAGS="-I /usr/local/share/aclocal"
</pre>
* Download the mono distribution
* Unpack the mono distribution:
<pre>
tar xzvf mono-XXX.tar.gz
</pre>
* Configure, compile and install:
For official releases:
<pre>
./configure
make
make install
</pre>
For snapshots and CVS trees:
<pre>
./autogen.sh
make
make install
</pre>
</ul>
<a name="oldreleases">
*** Old releases.
<ul>
<ul>
<a name="apr-24">
<b>Mono 0.11; April 24, 2002</b>
* <a href="archive/mono-0.11">Mono 0.11 release notes</a>
* <a href="archive/mcs-0.11.tar.gz">mcs-0.11.tar.gz</a>
Mono C# compiler
* <a href="archive/mono-0.11.tar.gz">mono-0.11.tar.gz</a>
Mono runtime
</ul>
<ul>
<a name="mar-27">
<b>Mono 0.10; March 27, 2002</b>
* <a href="archive/mono-0.10">Mono 0.10 release notes</a>
* <a href="archive/mcs-0.10.tar.gz">mcs-0.10.tar.gz</a>
Mono C# compiler
* <a href="archive/mono-0.10.tar.gz">mono-0.10.tar.gz</a>
Mono runtime
</ul>
<ul>
<a name="feb-22">
<b>Mono 0.9; February 22, 2002</b>
* <a href="archive/mono-0.9">Mono 0.9 release notes</a>
* <a href="archive/mcs-0.9.tar.gz">mcs-0.9.tar.gz</a>
Mono C# compiler
* <a href="archive/mono-0.9.tar.gz">mono-0.9.tar.gz</a>
Mono runtime
</ul>
<a name="feb-11">
<b>February 11, 2002</b>
* <a href="archive/mcs-0.8.tar.gz">mcs-0.8.tar.gz</a>
Mono C# compiler
* <a href="archive/mono-0.8.tar.gz">mono-0.8.tar.gz</a>
Mono runtime
</ul>
<a name="sep-18">
<b>September 18, 2001</b>
<ul>
+26 -547
View File
@@ -2,12 +2,9 @@
<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="#winforms">Mono and WinForms</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="#asp">Mono and ASP.NET</a><br>
<a href="#ado">Mono and ADO.NET</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>
@@ -16,13 +13,8 @@
<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 href="#problems">Mono Common Problems</a><br>
A <a
href="http://www.es.gnome.org/documentacion/articulos/MONO-PUF/MONO-PUF/">spanish
translation</a> is also available
<a name="basics"></a>
** Basics
@@ -30,9 +22,9 @@ translation</a> is also available
Q: What is Mono exactly?
A: The Mono Project is an open development initiative sponsored by
Ximian that is working to develop an open source, Unix
Ximian that is working to develop an open source, Linux-based
version of the Microsoft .NET development platform. Its objective
is to enable Unix developers to build and
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.
@@ -68,7 +60,7 @@ A: Mono contains a number of components useful for building new
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, Perl, Python, Scheme,
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
@@ -110,26 +102,19 @@ 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 mature enough to run some real applications
(the compiler for instance, and every day more and more applications
are natively developed with Mono).
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.
Q: When will you ship it?
A: Different parts of Mono will achieve usability at different stages,
once we are comfortable with the compiler, we will release "Mono Core",
which contains everything needed to develop applications with the base
class libraries. This should be available at some point during 2002.
Other higher level class libraries (ASP.NET, ADO.NET) will
be released when they become stable.
Q: What major components will you include in Mono?
A: Hopefully everything that Microsoft ships on their Framework
(ADO.NET, ASP.NET), and
we encourage third party developers to create reusable components that
work on both Mono and Windows.
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.
Q: How can I contribute?
@@ -146,10 +131,6 @@ A: We are interested in providing the best tools for programmers to
Project white paper</a>.
the project.
Q: Miguel said once that Mono was being implemented in COBOL. Is that true?.
A: No. It was a joke.
<a name="ximian"></a>
@@ -183,13 +164,6 @@ Q: Will Ximian offer Mono commercially?
A: When Mono is ready to be shipped Ximian will offer a commercial
support and services for Mono.
Q: Does Ximian provide consulting services around Mono?
A: Yes, Ximian does provide consulting services around Mono to
make it suitable to your needs. Porting the runtime engine,
customizing it, working on specific classes or tuning the code
for your particular needs.
Q: Will you wait until Mono is finished?
A: Mono will ship on various stages as they mature. Some people
@@ -244,22 +218,13 @@ Q: But will I be able to build GNOME applications?
A: Yes, we will enable people to write GNOME applications using Mono.
Q: Do you have C# bindings for GNOME?.
A: Yes, we currently bind libgnome, libgnomecanvas, and libgnomeui --
although I dare say I have no idea how functional the bindings are
outside of what I tested in the sample app. I imagine other libraries
under the GNOME framework will be added on an as-needed (and as-requested)
basis...although a truly good bonobo binding will have to wait on the CORBA
remoting support which has been started recently.
<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# API.
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?
@@ -273,75 +238,6 @@ 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.
Q: Where can I learn mora about Gtk#?
A: The following <a href="http://gtk-sharp.sourceforge.net>link</a> sends you to the page of the project.
Q: What can I do with Gtk#?.
A: Gtk# is becoming very usable and you can create applications and
applets like those you see in a GNOME desktop environment. It's
easy to install so it's worth a try.
Q: How can I compile my HelloWorld.cs which uses Gtk#?.
A: Try: mcs --unsafe -o HelloWorld.exe -r glib-sharp -r pango-sharp -r
atk-sharp -r gdk-sharp -r gtk-sharp -r gdk-imaging-sharp
HelloWorld.cs
Q: Is there any way how to connect DataAdapter to some GTK# controls?
A: There is a sample file called `DbClient' in gtk-sharp/samples that you
might to look at. It is a sample program in Gtk# that adds/updates/deletes
information on a Postgress database. When we have the new table/tree widgets,
I am sure someone would write an adapter for System.Data (in Gtk2 the
tree/list widgets are written using a view/model, so you only need to write
a model that maps to the database). You can have a look at
gtk-sharp/sample/DbClient, where there is a GTK# application that uses
System.Data. It does not use DataAdapter, but DataReader though.
<a name="winforms"></a>
** Mono and WinForms
Q: Can you tell me why aren't you implementing WinForms?.
A: (This is based in an original mail to mono-list written by Miguel de
Icaza. You should read it for completion, but the core part is here).
First, Windows.Forms is packed with quirks and is not that great of a
toolkit in the first place. Up to the point of the unconfirmed rumor
that Microsoft is working on a replacement for it.
Once the runtime is done, we will very likely start contributing to
the Gtk# project ourselves, and we will likely start doing feasibility
work on getting Mono used by Gnome developers: full gnome apps and
extending existing applications.
Those interested in hacking on Windows.Forms are welcome to do so,
but Ximian will not likely look at it in the near future; if there is
enough demand, or I can be convinced that Windows.Forms is useful for
something Ximian might re-evaluate our resource allocation for this
task.
By doing native ports, we could use the same API on all those systems.
Also, Gtk is mature enough, we know this because we have built an entire
desktop (and all sorts of very window system-specific hacks), and we
have built a bunch of productivity applications with it.
Q: What about VCL?.
Someone mentioned VCL. The only problem with the VCL is that it can
only be used for GPL applications (or I guess you could license it from
Borland for your app), and would have to be ported from Delphi to C#
(or someone would have to write a CIL compiler for it).
Q: What about doing something like the eclipse project (www.eclipse.org)?
A: The Eclipse toolkit is not a general purpose toolkit.  It will require a
lot of work before it is such a thing.  It is a toolkit used to
implement a development environment.
<a name="msft"></a>
** Mono and Microsoft
@@ -439,25 +335,6 @@ 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>.
Q: Will I be able to compile a Microsoft VB.NET application and execute
the resultant MSIL file under MONO on Linux without converting to C#
and recompiling?
A: Once we have a complete VisualBasic runtime, yes.
Q: Can mono run the WebMatrix ?
A: No. That requires winforms (we don't have).
Q: Does mono have something like Passport ? (ie PassportIdentity class,somewhere
in System.Web ?) . Will mono have a server side Passport/Similar framework
for XSP as well as client classes ?
A: Not yet, but the client side API for authentication is not the problem.
We will likely have a lot of other authentication APIs, like the Liberty
Aliance APIs. The problem is people on the web provider end that might use
this for authentication.
<a name="pnpproject"></a>
** Mono and Portable.NET
@@ -465,48 +342,8 @@ Q: What are the differences between Mono and Portable.NET?
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).
It is easier to describe what is unique about Mono:
<ul>
<li> A self-hosting C# compiler written in C#, which is clean, easy
to maintain.
<li> A multi-platform runtime engine: both a JIT engine and an
interpreter exist. The JIT engine runs currently on x86
systems, while the interpreter works on Sparc, StrongARM and
PowerPC systems.
<li> Supports Linux, Windows and Solaris at this point.
<li> The JIT engine is written using a portable instruction
selector which not only generates good code (we are told
that we are faster than Rotor, but it is hard to tell) but
is also the foundation to retarget the JIT engine to other
systems.
The system employed is described in various compiler
books and it is very similar to what is described in the
book that covers LCC, the Ansi C retargetable C compiler.
<li> The JIT engine supports inlining, constant folding and propagation,
<li> Full support for remoting in the runtime, but the class
libraries are still behind.
<li> The C# compiler, the JIT engine and the class libraries are
mature enough that the whole system is self-hosting, ie, that
it can be fully developed with itself at this point.
<li> We are not yet done, and there is a lot of work left to be
done
<li> We have a great community of developers, without which Mono
would not be possible.
<li> We will provide an ahead of time compilation mode in the
future.
</ul>
interfaces to the garbage collection system). The Portable.NET
Project is using C for development.
<a name="webservices"></a>
** Web Services
@@ -555,10 +392,6 @@ 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.
Q: Will Mono use ORBit?
A: No. Mono will be using a new implementation of CORBA that isn't still started.
<a name="devel"></a>
** Development Tools and Issues
@@ -597,172 +430,6 @@ 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.
Q: Isn't it a little bit confusing to have the name of "XSP" (the same
as in the Apache Project) for the ASP.NET support in Mono?.
A: In Mono, xsp is just the name of the C# code generator for ASP.NET
pages. In the Apache Project, it is a term for the "eXtensible Server
Pages" technology so as they are very different things, they don't
conflict.
Q: What about using something like Jabber instead of the System.Messaging
namespace?.
A: In short, MSMQ is not something like Jabber, but asynchronous messaging
through queues. Usefull queues do more than serialize messages, they are
also platform bridges.
Q: Are you supporting XMLDocument and relatives?.
A: Currently, we aren't implementing them yet. It would require updates to
most of the XmlNode derivatives so it's not a trivial task. We are
currently focusing on getting XPath support working.
Q: Is there any plan to develop an aspx server for Mono?.
A: The webserver turned out to be very simple compared to the rest of the
work. Gonzalo has got the page generator mostly done (a module called
xsp, who has nothing to do with the XSP term used in the Apache Project).
Patrik has done a lot of the work to get the ProcessRequest to work.
You can try to help in the final touches to the System.Web classes and
writing regression tests for the widgets we have.
Q: Is there any way I can develop the class libraries using linux yet?
A: Yes. Some class libraries can be developed on Linux. Search for
Paolo's post (he lists which classes can be compiled fine now).
Q: Is there any way I can install a known working copy of mono in /usr,
and an experimental copy somewhere else, and have both copies use
their own libraries? (I'm still not very good at library paths in
linux)
A: Yes. Just use two installation prefixes.
Q: How should I write tests or a tests suite?
A: If you do a test suite for C#, you might want to keep it
independent of the Mono C# compiler, so that other compiler
implementations can later use it.
Q: Is the current stage the implementation of mono_create_trampoline
function? Hence the sparc-codegen.h is reasonably complete? Is
mono/arch/x86/* the best reference material for this stuff?
A: sparc-codegen.h is basically complete. We may want to add some
convenience macros along the way, but it has all the stuff you need.
And yes, or, the ppc/ dir, since the ppc call convention is more similar
to the sparc one than the x86 one. The current issues with the sparc
code are. roughly:
1) it needs to handle overflowing the out registers (the additional
arguments need to be put on the stack)
2) it needs to flush the icache where the generated code is stored
3) it needs to implement mono_create_method_pointer to get delegates
working
4) it needs a couple of updates (mono_method_pointer_get is no longer
needed, for example)
Q: Would it be too terrible to have another corlib signed as mscorlib?
A: We rename corlib to mscorlib also when saving the PE files, in fact,
the runtime can execute program created by mono just fine.
Q: How do I build corlib under Linux?
A: You can build your own (see the web site on how to get the mcs
project from cvs), but in order to build them using mcs you need a
set of working class libraries. After building the runtime (using
mono-build.sh) get them from the nightly build and put them (and
mcs.exe) in your mono/install/lib directory. Then you should be able
to do: cd mcs, then: make -f makefile.gnu, then: cp mcs/mcs.exe
class/lib/*.dll ../install/lib Also, you should know that you can
either get your dose of DLLs from MonoCharge, or from
http://primates.ximian.com/~miguel/runtime. MonoCharge is updated
automatically, while the later is only updated when Miguel is around
Once you have the DLLs, you can use `make -f makefile.gnu' as described
before to self-host.
Q: Is there a relatively straightforward way to repeat the steps taken
by Paolo to get Mono completely self-hosted on linux?
A: To build the compiler and class libraries in Linux, run:
<ul><li>make -f makefile.gnu. To install them, run: </li>
<li>make -f makefile.gnu install</li>
<li>You can also specify a prefix:</li>
<li>make -f makefile.gnu install prefix=/opt</li>
</ul>
If you want to produce and distribute a monocharge tarball, run:
make -f makefile.gnu dist
Of course you have to run these in the top level mcs directory.
Q: Is it possible to build a C# file to some sort of intermediate format which
can linked into a final module, like the traditional .c -> .o -> .so path?
A: You could do: mcs /target:module file1.cs, mcs /target:module file2.cs,
mcs /target:exe file1.dll file2.dll /out:mybin.exe
Q: Is there any plans for implementing remoting in the near future?, When will
work in System.Runtime.Remoting.dll start?
A: The remoting infrastructure is in place. Some of the channels and
formatters are not.
Q: I'm wondering if there are any plans to start using nant to build the
class lib + test lib. i think that every project neeed/should use an
automated build process and nant + a couple of tools enables this. is
the problem that the compiler can't run nant yet?
A: Maybe well be doing some sort of automated build process + testing when
the summer finish.
<a name="asp">
** Mono and ASP.NET
Q: Is Mono supporting ASP.NET?
A: Yes. The development of the support for ASP.NET comes in various stages,
here is what Gonzalo has been working on: 1. The Parser. 2. Getting the
parser to generate output compatible with ASP.NET. 3. Running the sample
output with the real Microsoft runtime but using our generated page. 4.
Running the sample with our classes with the .NET runtime. 5. Running
our sample code with our classes with our runtime. This is the process
we are following. Currently Gonzalo has reached point 5.
Q: Do I need install cygwin to work on ASP.NET in mono or Linux is enough since
it is self host right now.
A: Linux is enough.
Q: Any plan to make ASP.NET in mono works with Apache in linux?.
A: Yes, we have plans to do so, but we need to wait for Patrik's patches to
HttpRuntime. Once that is there, writing a mod_mono should be trivial
(look at mono/samples/embed for a sample embedded application).
<a name="ado">
** Mono and ADO.NET
Q: What is the status of ADO.NET support?. Could I start migrating
applications from MS.NET to Mono?.
A: You could start right now using the ADO.NET support in mono, of course,
if you want to help filling the missing gaps while you develop your app
:-) Well, what I mean is that we're not that far to having full ADO.NET
support in Mono, and we've got a lot of working things, so if we could
get more help, we'd finish it really soon :-)
Q: In developing the data architecture for the application are there and
objects I should stay away from in order to insure the smoothest possible
transition (minimum code rewrite) to Mono's ADO.NET implementation? (For
example, strongly typed datasets versus untyped datasets, etc...)
A: we are implementing all the classes in Microsoft .NET's System.Data, so
you can be sure that things will work the same in Mono as with the MS's
implementation. We'll maybe provide extra classes to fix some things
we've found missing while developing ADO.NET in Mono, but if you keep
using the MS's System.Data classes, things will work out of the box with
no changes (or at least that's the plan :-)
<a name="java">
** Mono and Java
@@ -814,24 +481,6 @@ A: Yes, it is possible. Here are a few starting point:
be translated into the equivalent "meaning" in CLR-land.
</ul>
Q: Could mono become a hybrid cil/java platform?
A: No. It is quite far from the philosophy of the project. The idea of Mono
is, to have only _one_ VM, on which all can run. And if there existing a
binary-converter from Java-.class to IL and if there existing something
like J-Sharp on Mono, you can write programs in Java, which than can run
on Mono. You do not need two bindings (like your example: GTK-Sharp _and_
Java-Gnome). You need only _one_ of it (GTK-Sharp). Thats the idea of Mono.
An other point is, that there are no people, who use OpenSource-JVMs. They
all prefer Suns original. But for Unix there don't exist a .NET-Framework.
So it is possible, that in the future Mono is the standard .NET for unixes.
Q: Do you plan to implement a Javascript compiler?
A: Yes. Eto Demerzal has started a Rhino port to C#.
After this is completed, we will begin developing
the Javascript compiler.
<a name="extending"></a>
** Extending Mono
@@ -859,20 +508,7 @@ A: Embracing a good technology is good. Extending technologies in
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.
Q: Is there any way I can develop the class libraries using linux yet?
A: Yes. Some class libraries can be developed on Linux. Search for
Paolo's post (he lists which classes can be compiled fine now).
Q: Is there any way I can install a known working copy of mono in /usr,
and an experimental copy somewhere else, and have both copies use
their own libraries? (I'm still not very good at library paths in
linux)
A: Yes. Just use two installation prefixes.
Mono and .NET
<a name="portability"></a>
** Portability
@@ -883,7 +519,7 @@ A: Currently, we are doing our work on Linux-based systems and
Windows. We do not expect many Linux-isms in the code, so it
should be easy to port Mono to other UNIX variants.
Q: What about Mono on non Linux-based systems?
Q: What about Mono on non X-based systems?
A: Our main intention at Ximian is to be able to develop GNOME
applications with Mono, but if you are interested in providing a
@@ -891,27 +527,11 @@ A: Our main intention at Ximian is to be able to develop GNOME
MacOS X for example), we would gladly integrate them, as long
they are under an open source license.
Q: What operating systems/CPUs do you support
Q: Will Mono run on Windows?
A: Mono currently runs on Linux, Windows, Solaris and FreeBSD.
There is a JIT engine available for x86 processors that can
generate code and optimizations tailored for a particular CPU.
Interpreters exist for the SPARC, PowerPC and StrongARM cpus.
Q: Does Mono run on Windows?
A: Yes. The Compiler and the runtime both run on Windows.
Q: When will mono and mcs compile on Linux?.
A: That happend a long time ago. Know you can download and compile
them or even install them from already made binary packages for
Windows and for Linux (RPM/DEB).
Q: Will I require Cygwin to run mono?
A: No. While you'll need it to compile it, it runs without cygwin and does not even require cygwin1.dll
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?
@@ -920,28 +540,6 @@ A: It will depend only if you are using a particular assembly (for
in Mono for implementing a `Hello World Enterprise P2P Web
Service', you will not need any GNOME components.
Q: Is anyone working on porting Mono to IA-64?
A: Nobody is working on such port.
Q: If I were about to start a Mono port to IA-64,would the same lburg code
generator work for IA-64 also? or anything else need to be used for code
generation(as the processor architecture is totally different from IA32)
A: The lburg approach can be use for any processor architecture. But you might
think in another better approach.
Q: Do you plan to port Rhino to C#?.
A: Eto Demerzal has started a Rhino port to C#.
Q: Has anyone succeeded in building a Mac version of the C# environment.
If so can you explain how?
A: You could try to check with the Darwin people, or the Fink people.
Mono/C# is self hosting on Linux/PPC which is the hard part, so it
should be relatively simple to get it to work on macos
<a name="reuse"></a>
** Reusing Existing Code
@@ -957,53 +555,11 @@ A: At this time, we are investigating whether we can use elements of
defined API that splits the JIT from the GC system and the actual
byte code implementation.
We are using some pieces of ORP (Their code generation interface)
and we use it as a source of inspiration for optimizations. Paolo
and Dietmar consider ORP as being one of the best JIT engines out
there (and their research work and papers are very useful if you are
interested in JIT technology).
Q: What about using GNU Lightning?
A: We are not using GNU Lightning. Our JIT is using an instruction
selector based on tree-pattern matching, and a code generation
interface that is very tied to the current architecture.
Q: Will I be able to use Microsoft SQL Server 2000 or will I need to switch
to a specific Open Source Database. Will I need to recode?
A: There should not be any need to recode.
Q: What do I need to watch out for when programming in VB.NET so that I'm
sure to be able to run those apps on Linux?
A: Not making any PInvoke or DLL calls should and not using anything in
the Microsoft.* namespaces should suffice. Also do not use any
Methods/Classes marked as "This type/method supports the .NET Framework
infrastructure and is not intended to be used directly from your code."
even if you know what these classes/methods do.
Q: Will built-in reporting be supported for crystal reports? This is a
heavily used part of our system.
A: Probably not. Crystal Reports are propriety. Someone may try to emulate
the behaviour, but no-one has yet volunteered.
Q: Who about writing to the registry? As I understand it, Linux does not have
a counterpart to the registry. Should I avoid relying on that feature?
A: Try to avoid it. Although there would be a emulation for registry in
Mono too. GNOME does have a registry like mechanism for configuration. But
Even if gnome has a configuration system similar to the registry, the keys
will not be equal, so you will probably end up having to do some runtime
detection, and depending on this load an assembly that has your
platform-specific hacks.
Q: System.Data.SqlClient with FreeTDS, will you port parts of these to C# and
use them?
A: if their license is compatible with mono's, yes, we'd think about porting
them. If not, we'll continue with the plan of using FreeTDS.
A: We are also researching <a
href="http://www.gnu.org/software/lightning/lightning.html">GNU
Lightning</a>.
<a name="gcc"></a>
** Mono and GCC
@@ -1081,33 +637,7 @@ 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>
<a name="etc"></a>
** Miscellaneous Questions
Q: You say that the CLI allows multiple languages to execute on the
@@ -1131,54 +661,3 @@ Q: Will you support COM?
A: The runtime will support XPCOM on Unix systems and COM on Windows.
Most of the code for dynamic trampolines exists already.
Q: Will Ximian offer certifications on Mono or related technologies?.
A: It's possible. But there is no plan about this. So the short answer is no.
Q: Are there any Boehm's gc binaries?
A: Yes. You can find RPMs <a href="http://java.thn.htu.se/~toor/">here</a>, though
if your distribution provides the correct packages, you should use those.
The suggested version of the Boehm GC is 6.1.
Q: How can I report a bug?
A: The best thing is to track down the bug and provide a simple test to
reproduce the bug. You can then add the bug to
<a href="http://bugzilla.ximian.com/enter_bug.cgi">bugzilla</a> or
simply send it to [email protected]. Please provide info about
what version of mono you're using and any relevant details to be
able to repoduce the bug. Note that bugs reported on the mailing-list
may be easily forgotten, so it's better to file them in bugzilla.
Q: Does mcs support the same command line options as the MS C#
compiler?
A: The Mono C# compiler now supports the same command line
arguments as the Microsoft C# compiler does.
Q: How about getting searchable archives on lists.ximian.com?
A: You can perform a search on the mono-related mailing lists
<a href="http://www.go-mono.com/mailing-lists.html">here</a>.
Q: When using mono from cvs or from a snapshot, I get an error messaage
saying that Mono and the runtime are out of sync. How do I fix that?
A: If you use mono from cvs, you need to be prepared for changes in the
runtime internals. This means that you should keep a working setup
before blindling updating (a working setup may just be the last released
tarball or a recent binary snapshot).
Usually, compiling corlib with mcs before recompiling the C runtime does
the right thing (but occasionally you may need to do it the other
way around).
<a name="problems"></a>
** Mono Common Problems
If you are having problems compiling or running Mono software
or if you think that you found a bug, etc. Please visit the
<a href="http://geneura.ugr.es/~jaime/deploy/mono-common-problems.html">Mono Common Problems</a> document and try there.
-23
View File
@@ -1,23 +0,0 @@
* Mono Hackers Hall Of Fame
Without the help, the skills and the time of many passionate developers outside of
the Ximian Mono team, Mono would not be where it is today.
Many of them do it for fun, some do it because they really want a nice CLR they
can hack on, some do it because they need a working solution to some development
issues and mono is the ideal tool for the job.
Some of them may start contributing because they want a mention in the
<b>Mono Hackers Hall Of Fame</b>! Whatever the cause, join us in a big<br>
<h1 align="center">Thank you!</h1>
* Mono Hackers
** Nick Drochak
The first, deserved, entry in the <b>Mono Hackers Hall Of Fame</b> is for
Nick Drochak, who joined us in the first days of Mono and built the testing
infrastructure for the C# assemblies, fixed tons of bugs and even adventured
himself in the lands of the C runtime. His work is invaluable for keeping
Mono on the right track through the daily changes in the codebase.
+74 -1027
View File
File diff suppressed because it is too large. Load diff
-62
View File
@@ -1,62 +0,0 @@
* Java
It would be interesting to support the Java language as part
of the Mono project.
You have to think of Java as various pieces: Java the
language and Java the virtual machine.
It is possible to compile Java to .NET, as shown by the
Microsoft J# compiler. We could then allow the migration of
Java applications to the Mono runtime.
** Native compiler
Although a native compiler can be built, and probably should be
built using an existing compiler, a short term solution is to
build a translator from Java class files to the ECMA CIL images.
This has the advantage that we can use an existing and tested
Java compiler to generate the code, and then we can use an automated
code compiler that compiles Java VM bytecodes to CIL bytecodes.
** The translator.
It would be interesting to write a semantic translator that
converts java byte codes into CIL opcodes. This is possible
because the Java byte codes are a subset of the CIL ones.
A semantic tree needs to be constructed (very much in the
spirit of what is done in mono_analize_stack in
<tt>mono/mono/jit/jit.c</tt>. Once such a semantic tree is
constructed, we could generate the equivalent Java code.
This has a number of interesting side effects: people can
continue to use their existing Java compilers to compile their
code, and a simple tool that converts their .class files into
a .NET assembly can be used.
** Libraries
We could translate the GNU Classpath libraries with the above
tools to provide the Java runtime required to host into the
Mono runtime. Some special treatment would be required for
core data types like integers, arrays and strings, and of
course reuse where possible existing classes from .NET to make
them compatible.
** JILC - Java to IL Compiler
This is an attempt to make the java bytecode available for the
.NET environment.
The project attempts to generate the IL code / bytecode from the
compiled java class files. It has reached the stage of code-generation.
The issues that needs to be addressed is the mapping of java objects
to the IL objects, eg: java.lang.String to System.String.
Gaurav Vaish and Abhaya Agarwal are currently leading this project.
The project is currently hosted at <a href="http://sourceforge.net/projects/jilc">SourceForge.Net</a>.
The official home page of the project is
<a href="http://jilc.sourceforge.net">http://jilc.sourceforge.net</a>.
-184
View File
@@ -1,184 +0,0 @@
* How to debug your C# application with the JIT engine
To debug a C# application you need to run the JIT in your debugger.
Before you can do anything useful in a debugger, you need a symbol
file which tells your debugger about functions, types, line numbers
and such. Unfortunately, this symbol file needs to be recreated each
time the JIT compiles a new method since it doesn't know anything
about this method (especially not its memory address) before actually
compiling it.
You have two ways of creating a symbol file:
** Letting the JIT dynamically create the symbol file
This'll give you a symbol file which is suitable for debugging IL byte
code - you won't see your C# source code.
However, this method has the advantage that it works with every assembly,
no matter whether it has been compiled with Mono's C# compiler (MCS) or
with any other compiler. It's currently the only way to debug
<tt>corlib.dll</tt> or any other library which cannot be compiled with
our compiler yet.
All that you need is a dump of the IL bytecode for each assembly (including
all assemblies this assembly is referencing). This is done by using the
<tt>monodis</tt> utility:
<pre>
monodis /home/export/martin/MONO-LINUX/lib/corlib.dll > corlib.il<br>
monodis /home/export/martin/MONO-LINUX/lib/System.dll > System.il<br>
monodis /home/export/martin/MONO-LINUX/bin/mcs.exe > mcs.il
</pre>
This is normally done automatically, but you can also disable
it and create them by hand. See the <tt>mono</tt> manual page
for details.
Make sure that all the .il files have the same name as their corresponding
assembly and that they're all created in the current directory.
The JIT supports two different debugging file formats:
<ul>
* STABS: This is a very simple debugging format, but it may be the only one
which is supported on your system. It is limited to source files of no more
than 65.535 lines and it's type support is also very limited. You should only
use this if your debugger doesn't support DWARF 2.
To generate STABS output, use the <tt>--debug=stabs</tt> command line argument.
* DWARF 2: The DWARF 2 debugging format is a very powerful debugging format
which can handle source files of arbitrary size and has a highly sophisticated
type support. It's the recommended format unless you need to use STABS because
your debugger doesn't support DWARF 2.
To generate DWARF 2 output, use the <tt>--debug=dwarf</tt> command line argument.
</ul>
You need to regenerate the symbol file each time the JIT compiled a new
method and each time you restart the JIT. You cannot reuse your symbol file
if you start the JIT a second file, not even if you're running the same
application with the same input data a second time.
Regenerating the symbol file is done by calling the JIT's
<tt>mono_debug_make_symbols ()</tt> function from within your debugger and
then reloading the symbol files. This function creates a <tt>filename-dwarf.s</tt>
(or <tt>filename-stabs.s</tt>) assembler input file in the current directory and
an object file in <tt>/tmp/filename.o</tt> - you need to tell your debugger to
add this object file as symbol file.
If you're using the GNU debugger, this is done like this:
<pre>
call mono_debug_make_symbols ()
add-symbol-file /tmp/corlib.o
add-symbol-file /tmp/mcs.o
add-symbol-file /tmp/Mono.CSharp.Debugger.o
</pre>
You can also write a GDB macro like this:
<pre>
define reload
call mono_debug_make_symbols ()
add-symbol-file /tmp/corlib.o
add-symbol-file /tmp/mcs.o
add-symbol-file /tmp/Mono.CSharp.Debugger.o
end
</pre>
Then you can just say <tt>reload</tt> to have GDB recreate the symbol file.
There's also an <a href="jit-debug-sample.html">example debugging session</a> using
the GNU debugger.
** Using a symbol file which have been created by the Mono C# compiler
If you compiled your application with Mono's C# compiler (MCS), you can tell it to
create a symbol file which is then processed and rewritten by the JIT engine.
To do this, you must give MCS the <tt>-g</tt> option:
<pre>
$ mcs -g Foo.cs
</pre>
This creates a <tt>Foo-debug.s</tt> assembler input file.
To use this in the JIT, you must first copy it to the target machine (the machine
where you want to run the JIT to debug your application) and run it through the
assembler to produce an object file <tt>Foo-debug.o</tt>. This object file must be
in the current directory.
Then start the JIT in your debugger and give it the <tt>--debug=dwarf-plus</tt> command
line argument.
Each time you call <tt>mono_debug_make_symbols ()</tt> from withing your debugger,
the JIT will read this <tt>Foo-debug.o</tt>, fix some machine dependent things like
memory addresses etc. in it and write it back to disk.
If you're using the GNU debugger, you'll want to use a macro like this:
<pre>
define relocate
call mono_debug_make_symbols ()
add-symbol-file /tmp/corlib.o
add-symbol-file mcs-debug.o
add-symbol-file Mono.CSharp.Debugger-debug.o
end
</pre>
If there is no <tt>assembly-debug.o</tt> file, but an <tt>assembly.il</tt> one, the
JIT will fall back to normal DWARF 2 (in the example above, <tt>corlib.dll</tt> was
compiled with Microsoft's compiler and the JIT is thus using DWARF to debug it).
This debugging method only works if you compiled your assembly with MCS, but it'll
allow you to actually debug your C# source code :-)
Here's an <a href="jit-debug-sample2.html">example debugging session</a> using
the GNU debugger.
** Breakpoints and single stepping
The JIT has a <tt>--break</tt> command line argument to insert a breakpoint at the
beginning of this method. It takes a <tt>Namespace.Class:Method</tt> argument which
is the method. This argument can be given multiple times.
However, once your application is stopped in GDB you may want to insert a breakpoint
the next time the JIT compiles a method. There's a global variable
<tt>mono_debug_insert_breakpoint</tt> which you can modify in your debugger.
If this variable is set to a non-zero value, the JIT's <tt>arch_compile_method</tt>
will insert a breakpoint the next time it is called, ie. at the top of the next
method it compiles. If this value has a positive value, it acts as a counter and is
decremented after inserting the breakpoint - setting it to a negative value will let
the JIT insert the breakpoint each time it compiles a new method.
There's also global variable <tt>mono_debug_last_breakpoint_address</tt> which always
contains the address of the last inserted breakpoint. You may manually override this
address with a <tt>nop</tt> instruction to delete the breakpoint.
For instance, I have a GDB macro called <tt>enter</tt> which I use to enter a method
rather than stepping over it:
<pre>
define enter
set mono_debug_insert_breakpoint = 1
continue
set *mono_debug_last_breakpoint_address = 0x90
relocate
frame
</pre>
Btw. speaking of single stepping - you should use your debuggers <tt>next</tt> command,
not its <tt>step</tt> command for single stepping unless you compiled the JIT without
debugging support. The reason for this is that the JIT creates machine code which contains
calls to JIT methods such as <tt>mono_object_new_wrapper</tt> at places where you don't
expect them - so unless the JIT is compiled at least without line numbers, your debugger
will enter such methods if you use <tt>step</tt> rather than <tt>next</tt>.
-86
View File
@@ -1,86 +0,0 @@
* A debugging session using a dynamically generated symbol file.
Let's assume we have the following C# application which we want to debug:
<pre>
using System;
public class Foo
{
public struct MyStruct {
int a;
long b;
double c;
}
public static void Main ()
{
Int32 value = 5;
long test = 512;
MyStruct my_struct;
my_struct.a = 5;
my_struct.b = test;
my_struct.c = 23323.5235;
}
}
</pre>
First of all, we need to compile it and create the .il files:
<pre>
$ mcs ./Foo.cs
$ monodis /home/export/martin/MONO-LINUX/lib/corlib.dll > corlib.il
$ monodis Foo.exe > Foo.il
</pre>
Now we can start the JIT in the debugger:
<pre>
$ gdb ~/monocvs/mono/mono/jit/mono
(gdb) r --debug=dwarf --break Foo:Main ./Foo.exe
Starting program: /home/martin/monocvs/mono/mono/jit/mono --debug=dwarf --break Foo:Main ./Foo.exe
0x081e8911 in ?? ()
(gdb) call mono_debug_make_symbols ()
(gdb) add-symbol-file /tmp/Foo.o
Reading symbols from /tmp/Foo.o...done.
Current language: auto; currently c++
(gdb) frame
#0 Foo.Main () at Foo.il:26
26 // method line 2
(gdb) n
Foo.Main () at Foo.il:38
38 IL_0000: ldc.i4.5
(gdb) list
33 .maxstack 2
34 .locals (
35 int32 V_0,
36 int64 V_1,
37 valuetype MyStruct V_2)
38 IL_0000: ldc.i4.5
39 IL_0001: stloc.0
40 IL_0002: ldc.i4 512
41 IL_0007: conv.i8
42 IL_0008: stloc.1
43 IL_0009: ldloca.s 2
44 IL_000b: ldc.i4.5
45 IL_000c: stfld int32 .MyStruct::a
46 IL_0011: ldloca.s 2
47 IL_0013: ldloc.1
48 IL_0014: stfld int64 .MyStruct::b
49 IL_0019: ldloca.s 2
50 IL_001b: ldc.r8 23323.5
51 IL_0024: stfld float64 .MyStruct::c
52 IL_0029: ret
(gdb) until 52
Foo.Main () at Foo.il:53
53 }
(gdb) info locals
V_0 = 5
V_1 = 512
V_2 = {a = 5, b = 512, c = 23323.523499999999}
</pre>
As you see in this example, you need to know IL code to use this debugging method - but
it may be the only way to debug a library.
-70
View File
@@ -1,70 +0,0 @@
* A debugging session using a symbol file which has been created by MCS.
Let's assume we have the following C# application which we want to debug:
<pre>
using System;
public class Foo
{
public struct MyStruct {
int a;
long b;
double c;
}
public static void Main ()
{
Int32 value = 5;
long test = 512;
MyStruct my_struct;
my_struct.a = 5;
my_struct.b = test;
my_struct.c = 23323.5235;
}
}
</pre>
First of all, we need to compile it with MCS, assemble the generated .s file and
create the .il files for all referenced assemblies which were not compiled with MCS:
<pre>
$ mcs -g ./Foo.cs
$ as -o Foo-debug.o Foo-debug.s
$ monodis /home/export/martin/MONO-LINUX/lib/corlib.dll > corlib.il
</pre>
Now we can start the JIT in the debugger:
<pre>
$ gdb ~/monocvs/mono/mono/jit/mono
(gdb) r --debug=dwarf-plus --break Foo:Main ./Foo.exe
Starting program: /home/martin/monocvs/mono/mono/jit/mono --debug=dwarf-plus --break Foo:Main ./Foo.exe
Program received signal SIGTRAP, Trace/breakpoint trap.
0x081e8681 in ?? ()
(gdb) call mono_debug_make_symbols ()
(gdb) add-symbol-file Foo-debug.o
(gdb) add-symbol-file /tmp/corlib.o
` (gdb) frame
#0 Main () at ./Foo.cs:11
11 public static void Main ()
(gdb) n
Main () at ./Foo.cs:13
13 Int32 value = 5;
(gdb)
14 long test = 512;
(gdb)
17 my_struct.a = 5;
(gdb)
18 my_struct.b = test;
(gdb)
19 my_struct.c = 23323.5235;
(gdb)
20 }
(gdb) info locals
value = 5
test = 512
my_struct = { a = 5, b = 512, c = 23323.5235 }
</pre>
-117
View File
@@ -1,117 +0,0 @@
* Compilers for other languages
Here are some other free compilers for other languages that
target .NET and should work with Mono with no problem:
<ul>
* <a href="#ComponentPascal">Component Pascal</a>
* <a href="#MonoLogo">MonoLogo</a>
* <a href="#Oberon">Oberon</a>
* <a href="#Forth">Forth</a>
</ul>
Languages we would like to have supported, with links to resources:
<ul>
* <a href="#JavaScript">Java Script</a>
* <a href="java.html">Java</a>
* <a href="#c">C</a>
</ul>
Some experimental languages:
<ul>
* <a href="#Tachy">Tachy</a> (scheme-like)
</ul>
<a name="MonoLogo">
** MonoLogo
An implementation of Logo for Mono (and .NET)
The <A href="http://monologo.sf.net">Mono Logo</a> compiler is
hosted in the <a href="ccvs.html">Mono CVS</a> repository
and also available on the <a href="anoncvs.html">AnonCVS</a> mirrors.
<a name="Oberon">
** Oberon
This Oberon compiler is written in Oberon.NET (another self
hosting compiler).
The main site <a href="http://www.oberon.ethz.ch/oberon.net/">http://www.oberon.ethz.ch/oberon.net/</a>
Download:
<a href="http://www.oberon.ethz.ch/oberon.net/download/">http://www.oberon.ethz.ch/oberon.net/download/</a>
Examples:
<a href="http://www.oberon.ethz.ch/oberon.net/examples/">http://www.oberon.ethz.ch/oberon.net/examples/</a>
<a href="http://www.superin.formativ.net/mono/oberon/oberon.zip">http://www.superin.formativ.net/mono/oberon/oberon.zip</a>
<a name="ComponentPascal">
** Component Pascal
The Component Pascal compiler: <a
href="http://www2.fit.qut.edu.au/CompSci/PLAS/ComponentPascal">Home
Page</a>, you can <a
href="http://www2.fit.qut.edu.au/CompSci/PLAS/ComponentPascal/gpcp1.1.4-netRTM.zip">
download it</a>
<a name="Forth">
** Delta Forth
The Delta Forth.NET project: <a
href="www.dataman.ro/dforth">Home
Page</a> and <a href="http://www.dataman.ro/dforth/index.html">more
details here</a>.
<a name="Tachy">
** Tachy
A subset of Scheme language called <a
href="http://radio.weblogs.com/0101156/stories/2002/03/19/tachy.html">Tachy</a>
* Missing languages
Here is a list of a few languages that we would like to see
supported. We will try to maintain a set of links here with
technical information for those interested in porting,
implementing or adapting a compiler for any of these
languages:
<a name="JavaScript">
* Java Script
The Mozilla project has an implementation of JavaScript
written in Java called <a
href="http://www.mozilla.org/rhino/">Rhino</a>.
You could port this code from Java to C#.
Note that since JavaScript allows for evaluation at runtime,
the compiler has to be built as a class that can be invoked at
runtime.
<a name="c">
* C
Ideally GCC could be modified to generate CIL, but it is a
big task. That would give us various compilers in one pass.
Rumor is that the next version of the LCC compiler will
include an IL backend. We do not know how extensive the support
for integration with .NET will be, but it would be an interesting
excercise to add an extension to C to call into .NET code.
LCC is not an open source compiler, but it is free as long as you
do not profit from selling it.
<a name="Java">
* Java
We have a <a href="java.html">separate page</a> for Java.
-202
View File
@@ -1,202 +0,0 @@
* Mailing Lists
Most of the mailing lists are in english, but there is also
Mono Hispano that has lists in Spanish. <a
href="http://mono.es.gnome.org/mailman/listinfo/mono-hispano">Mono Hispano list</a>
There are a number of mailing lists for Mono in English:
<table>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-list">mono-list</a></b>
</td>
<td>
The general Mono discussion list.
</td>
</tr>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-announce-list">mono-announce-list</a></b>
</td>
<td>
Announcements of Mono developments.
</td>
</tr>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-gc-list">mono-gc-list</a></b>
</td>
<td>
Discussion on the GC system of Mono.
</td>
</tr>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-patches">mono-patches</a></b>
</td>
<td>
Track the CVS activity of Mono on this mailing list (patches are sent to recipients).
You can get <a href="http://www.go-mono.com/snapshots">daily snapshots</a> as well.
</td>
</tr>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list</a></b>
</td>
<td>
Track the CVS activity of Mono on this mailing list.
</td>
</tr>
<tr>
<td>
<b><a
href="http://lists.ximian.com/mailman/listinfo/mono-docs-list">mono-docs-list</a></b>
</td>
<td>
Discussion on the documentation of Mono.
</td>
</tr>
<tr>
<td>
<b><a href="http://lists.ximian.com/mailman/listinfo/mono-bugs">mono-bugs</a></b>
</td>
<td>
This mailing list is used to keep track of the bugs in Mono as reported
in <a href="http://bugzilla.ximian.com">Bugzilla.ximian.com</a>
</td>
</tr>
</table>
Other mailing lists of interest:
<ul>
* <b><a
href="http://discuss.develop.com/dotnet.html">Dotnet mailing
list at Develop.com:</a></b> The guys at Develop Mentor run
this general purpose mailing list.
</ul>
</ul>
* Google search of the archives
<!-- Google Search with mods -->
<center>
<table>
<tr>
<td><a href="http://www.google.com/search"><img src="mailing-lists_files/Logo_40wht.gif" border="0" alt="Google" align="middle"></a></td>
<td>
<table>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face="arial,sans-serif" size="-1"><input type="hidden" name="domains" value="www.go-mono.com;lists.ximian.com"><br><input type="radio" name="sitesearch" value="www.go-mono.com"> Search www.go-mono.com <input type="radio" name="sitesearch" value="lists.ximian.com"> Search lists.ximian.com </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-list">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>list</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-announce-list">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>announce-list</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-bugs">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>bugs</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-gc-list">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>gc-list</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-cvs-list">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>cvs-list</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
<tr><td>
<FORM method=GET action=http://www.google.com/custom>
<TABLE bgcolor=#FFFFFF cellspacing=0 border=0>
<tr valign=top>
<td>
<INPUT TYPE=text name=q size=31 maxlength=255 value="">
<INPUT TYPE=hidden name=q size=31 maxlength=255 value="mono-patches">
<INPUT type=submit name=sa VALUE="Search">
<input type="hidden" name="cof" value="GIMP:#00ff00;T:#ffffff;LW:401;BIMG:http://www.go-mono.com/images/bgsquares.gif;ALC:#ffffff;L:http://www.go-mono.com/images/mono.gif;GFNT:#cc7700;LC:#ee9900;LH:80;BGC:#444444;AH:center;VLC:#cccccc;S:http://www.go-mono.com;GALT:#eeee00;AWFID:45753ce73241ef7a;">
<font face=arial,sans-serif size=-1><input type=hidden name=domains value="lists.ximian.com"><br> <input type=hidden name=sitesearch value="lists.ximian.com"> Search mono-<b>patches</b> </font><br>
</td></tr></TABLE>
</FORM>
</tr></td>
</table>
</tr>
</table>
</center>
<!-- /Google Search with mods -->
-37
View File
@@ -1,37 +0,0 @@
* Mono for beginners
Hinne Hettema and Jaime Anguiano Olarra are providing us with
nice and complete set of documents (HOWTOs) about how to install,
configure, run and test the software developed by the Mono Project.
You can read them online, get PDF versions or get the XML sources.
HTML Format (read it online)
For <a href="mono-beginning/t1.html">RPM Linux based systems</a>
For <a href="http://geneura.ugr.es/~jaime/mono-beginning-windows/t1.html">Microsoft Windows</a>
PDF Format
For <a href="mono-beginning.pdf">RPM Linux based systems</a>
For <a href="http://geneura.ugr.es/~jaime/mono-beginning-windows/mono-beginning-windows.pdf">Microsoft Windows</a>
XML Source
For <a href="mono-beginning.xml">RPM Linux based systems</a>
For <a href="http://geneura.ugr.es/~jaime/mono-beginning-windows/mono-beginning-windows.xml">Microsoft Windows</a>
Currently Hinne is working on a Mono Tools HOWTO. Which will be
very useful for the hackers that would like to get in touch with
Mono and Jaime is working out a Mono Beginning HOWTO for Debian
users.
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
-147
View File
@@ -1,147 +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
if [ ! -z "${AUTO_STABLE}" -o -e /usr/autotool/stable ]; then
export AUTO_STABLE=${AUTO_STABLE:-/usr/autotool/stable}
export AUTO_DEVEL=${AUTO_STABLE}
fi
# Need to install pkgconfig and set ACLOCAL_FLAGS if there is not a
# pkgconfig installed already. Otherwise set PKG_CONFIG_PATH to the
# glib we're about to install in $here/install. This script could
# attempt to be clever and see if glib 2 is already installed, too.
# --print-ac-dir was added in 1.2h according to the ChangeLog. This
# should mean that any automake new enough for us has it.
# This sets ACLOCAL_FLAGS to point to the freshly installed pkgconfig
# if it doesnt already exist on the system (otherwise auto* breaks if
# it finds two copies of the m4 macros). The GIMP for Windows
# pkgconfig sets its prefix based on the location of its binary, so we
# dont need PKG_CONFIG_PATH (the internal pkgconfig config file
# $prefix is handled similarly).
function aclocal_scan () {
# Quietly ignore the rogue '-I' and other aclocal flags that
# aren't actually directories...
#
# cd into mono/ so that the aclocal wrapper can work out which version
# of aclocal to run
for i in `(cd mono && aclocal --print-ac-dir)` $ACLOCAL_FLAGS
do
if [ -f $i/$1 ]; then
return 0
fi
done
return 1
}
function install_package() {
zipfile=$1
markerfile=$2
name=$3
echo "Installing $name..."
if [ ! -f $here/$zipfile ]; then
wget http://www.go-mono.com/archive/$zipfile
fi
# Assume that the package is installed correctly if the marker
# file is there
if [ ! -f $here/install/$markerfile ]; then
(cd $here/install || exit -1; unzip -o $here/$zipfile || exit -1) || exit -1
fi
}
if ! aclocal_scan pkg.m4 ; then
ACLOCAL_FLAGS="-I $here/install/share/aclocal $ACLOCAL_FLAGS"
fi
export PATH
export ACLOCAL_FLAGS
# Grab pkg-config, glib etc
if [ ! -d $here/install ]; then
mkdir $here/install || exit -1
fi
# Fetch and install pkg-config, glib, iconv, intl
install_package pkgconfig-0.80-tml-20020101.zip bin/pkg-config.exe pkgconfig
install_package glib-1.3.12-20020101.zip lib/libglib-1.3-12.dll glib
install_package glib-dev-1.3.12-20020101.zip lib/glib-1.3.lib glib-dev
install_package libiconv-1.7.zip lib/iconv.dll iconv
install_package libiconv-dev-1.7.zip lib/iconv.lib iconv-dev
install_package libintl-0.10.40-20020101.zip lib/libintl-1.dll intl
install_package libgc-dev.zip lib/gc.dll gc-dev
# Needed to find the libiconv bits
CPPFLAGS="$CPPFLAGS -I$here/install/include"
LDFLAGS="$LDFLAGS -L$here/install/lib"
export CPPFLAGS
export LDFLAGS
# Make sure we build native w32, not cygwin
#CC="gcc -mno-cygwin"
#export CC
# --prefix is used to set the class library dir in mono, and it needs
# to be in windows-native form. It also needs to have '\' turned into
# '/' to avoid quoting issues during the build.
prefix=`cygpath -w $here/install | sed -e 's@\\\\@/@g'`
# Build and install mono
echo "Building and installing mono"
(cd $here/mono; ./autogen.sh --prefix=$prefix || exit -1; make || exit -1; make install || exit -1) || exit -1
echo ""
echo ""
echo "All done."
echo "Add $here/install/bin and $here/install/lib to \$PATH"
echo "Don't forget to copy the class libraries to $here/install/lib"
-183
View File
@@ -1,183 +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
configure_options=$4
echo "Installing $name..."
if [ ! -f $here/$tarfile ]; then
wget http://www.go-mono.org/archive/$tarfile
fi
# Assume that the package built correctly if the dir is there
if [ ! -d $here/$dirname ]; then
# Build and install package
tar xzf $here/$tarfile || exit -1
(cd $here/$dirname; ./configure --prefix=$here/install $configure_options || exit -1; make || exit -1; make install || exit -1)
success=$?
if [ $success -ne 0 ]; then
echo "***** $name build failure. Run rm -rf $here/$dirname to have this script attempt to build $name again next time"
exit -1
fi
fi
}
if aclocal_scan pkg.m4 ; then
install_pkgconfig=no
else
install_pkgconfig=yes
fi
if aclocal_scan glib-2.0.m4 ; then
install_glib=no
if [ $install_pkgconfig = "yes" ]; then
# We have to tell the newly-installed pkgconfig about the
# system-installed glib
PKG_CONFIG_PATH=`pkgconfig_scan glib-2.0`:$PKG_CONFIG_PATH
fi
else
install_glib=yes
PKG_CONFIG_PATH="$here/install/lib/pkgconfig:$PKG_CONFIG_PATH"
fi
if [ -f /usr/include/gc/gc.h ]; then
install_libgc=no
else
install_libgc=yes
fi
if [ $install_pkgconfig = "yes" -o $install_glib = "yes" ]; then
ACLOCAL_FLAGS="-I $here/install/share/aclocal $ACLOCAL_FLAGS"
fi
export PATH
export LD_LIBRARY_PATH
export ACLOCAL_FLAGS
export PKG_CONFIG_PATH
CPPFLAGS="$CPPFLAGS -I$here/install/include"
LDFLAGS="$LDFLAGS -L$here/install/lib"
export CPPFLAGS
export LDFLAGS
# Grab pkg-config-0.8, glib-1.3.12 if necessary
if [ $install_pkgconfig = "yes" ]; then
install_package pkgconfig-0.8.0.tar.gz pkgconfig-0.8.0 pkgconfig ""
else
echo "Not installing pkgconfig, you already seem to have it installed"
fi
if [ $install_glib = "yes" ]; then
install_package glib-1.3.13.tar.gz glib-1.3.13 glib ""
else
echo "Not installing glib, you already seem to have it installed"
fi
if [ $install_libgc = "yes" ]; then
LIBS="-ldl" install_package gc6.0.tar.gz gc6.0 libgc "--enable-threads=pthreads"
# make install didnt do the headers!
mkdir -p $here/install/include/gc
cp -r $here/gc6.0/include/* $here/install/include/gc
else
echo "Not installing libgc, you already seem to have it installed"
fi
# End of build dependencies, now get the latest mono checkout and build that
test -z "$CVSROOT" && CVSROOT=:pserver:[email protected]:/mono
export CVSROOT
echo "Updating mono"
# cvs checkout does the same as cvs update, except that it copes with
# new modules being added
# Older versions of cvs insist on a cvs login for :pserver: methods
# Make sure cvs is using ssh for :ext: methods
if [ ${CVSROOT:0:5} = ":ext:" ]; then
CVS_RSH=ssh
export CVS_RSH
elif [ ${CVSROOT:0:9} = ":pserver:" ]; then
# Chop off the trailing /mono because cvs 1.11 adds the port number
# into the .cvspass line
if ! grep ${CVSROOT%:/mono} ~/.cvspass > /dev/null 2>&1 ; then
echo "Logging into CVS server. Anonymous CVS password is probably empty"
cvs login
fi
fi
cvs checkout mono || exit -1
# Build and install mono
echo "Building and installing mono"
(cd $here/mono; ./autogen.sh --prefix=$here/install || exit -1; make || exit -1; make install || exit -1) || exit -1
echo ""
echo ""
echo "All done."
echo "Add $here/install/bin to \$PATH"
echo "Add $here/install/lib to \$LD_LIBRARY_PATH"
echo "Don't forget to copy the class libraries to $here/install/lib"
-551
View File
@@ -1,551 +0,0 @@
<Mono newbie coders start file>
<h1> A little help for mono newbie coders </h1>
For those who are new to Mono and are impatient to contribute
with code (uhh... you are brave!!) here is the document you
should read.
You will see all Mono hackers say the same (great minds have
similar way of thinking): First, DO WRITE TESTS!!!. In order
to do that:
<ul>
* Start with the NUnit Tests Guidelines. In the cvs
they are located at: mcs/class/doc/NUnitGuideli...
* But wait, this is a document for impatient
people. So EVERYTHING should be here. Well, it is.
</ul>
<h2> The NUnit Tests Guidelines document </h2>
Mono NUnit Test Guidelines and Best Practices
Authors: Nick Drochak <[email protected]>
Martin Baulig <[email protected]>
Last Update: 2002-03-02
Rev: 0.3
<b> Purpose </b>
This document captures all the good ideas people have had
about writing NUnit tests for the mono project. This document
will be useful for anyone who writes or maintains unit tests.
<b> Other resources </b>
- mcs/class/README has an explanation of the build process and
how it relates to the tests.
- http://nunit.sourceforge.net is the place to find out about
NUnit
<b> Getting Started </b>
If you are new to writing NUnit tests, there is a template
you may use to help get started. The file is:
mcs/class/doc/TemplateTest.cs
(2.- This is the point two!. This file is just after the end
of the guidelines. Copy/paste it in another buffer. And keep
reading.)
Save a copy of this file in the appropriate test subdirecty
(see below), and replace all the [text] markers with
appropriate code. Comments in the template are there to guide
you. You should also look at existing tests to see how other
people have written them.
mcs/class/corlib/Test/System.Collections/CollectionBaseTest.cs
is a small one that might help.
(3.- You reached the third point. And as expected, it's just
here to tell you that the content of CollectionBaseTest.cs is
after the TemplateTest.cs code at the end of these
guidelines.)
The directory that will contain your new file depends on the
assembly/namespace of the class for which you are creating the
tests. Under mcs/class there is a directory for each assembly.
In each assembly there is a Test directory, e.g.
mcs/class/corlib/Test. In the Test directory there are
sub-directories for each namespace in the assembly, e.g.
mcs/class/corlib/Test/Sytem. Put your new test file in the
appropriate sub-directory under Test for the class you are
testing.
Once your test class is complete, you need to add it to the
AllTests.cs file in the same directory as your new test. Add a
call to "suite.AddTest()" passing the name of your new test
class's suite property as the parameter. You will see examples
in the AllTests.cs file, so just copy and paste inside there.
Once all of that is done, you can do a 'make test' from the top
mcs directory. Your test class will be automagically included
in the build and the tests will be run along with all the
others.
<b> Tips </b>
<b> Provide an unique error message for Assert() </b>
Include an unique message for each Assert() so that when the
assert fails, it is trivial to locate the failing one.
Otherwise, it may be difficult to determine which part of the
test is failing. A good way to ensure unique messages is to use
something like #A01, #A02 etc.
Bad:
<pre>
AssertEquals("array match", compare[0], i1[0]);
AssertEquals("array match", compare[1], i1[1]);
AssertEquals("array match", compare[2], i1[2]);
AssertEquals("array match", compare[3], i1[3]);
</pre>
Good:
<pre>
AssertEquals("#A01", compare[0], i1[0]);
AssertEquals("#A02", compare[1], i1[1]);
AssertEquals("#A03", compare[2], i1[2]);
AssertEquals("#A04", compare[3], i1[3]);
</pre>
Once you used such a number in an Assert(), don't change it
later on - people might use it it identify the test in bug
reports or in mailing lists.
<b> Use AssertEquals() to compare things, not Assert(). </b>
Never compare two values with Assert() - if the test fails,
people have no idea what went wrong while AssertEquals()
reports the failed value.
Bad:
<pre>
Assert ("A01", myTicks[0] == t1.Ticks);
</pre>
Good:
<pre>
AssertEquals ("A01", myTicks[0], t1.Ticks);
</pre>
<b> Constructors </b>
When writing your testcase, please make sure to provide a
constructor which takes no arguments:
<pre>
public class DateTimeTest : TestCase
{
public DateTimeTest() : base ("[MonoTests.System.DateTimeTest]") {}
public DateTimeTest (string name): base(name) {}
public static ITest Suite
{
get {
TestSuite suite = new TestSuite ();
return suite;
}
}
}
</pre>
<b> Namespace </b>
Please keep the namespace within each test directory
consistent - all tests which are referenced in the same
AllTests.cs must be in the same namespace. Of course you can
use subnamespaces as you like - especially for subdirectories
of your testsuite.
For instance, if your AllTests.cs is in namespace "MonoTests"
and you have a subdirectory called "System", you can put all
the tests in that dir into namespace "MonoTests.System".
<b> Test your test with the microsoft runtime </b>
If possible, try to run your testsuite with the Microsoft
runtime on Windows and make sure all tests in it pass. This is
especially important if you're writing a totally new testcase
- without this check you can never be sure that your testcase
contains no bugs ....
Don't worry if you're writing your test on Linux, other people
can test it for you on Windows.
Sometimes you may discover that a test doesn't show the
expected result when run with the Microsoft runtime - either
because there is a bug in their runtime or something is
misleading or wrong in their documentation. In this case,
please put a detailed description of the problem to
mcs/class/doc/API-notes and do also report it to the list -
we'll forward this to the Microsoft people from time to time
to help them fix their documentation and runtime.
<pre>
-------------------- TemplateTest.cs begins ----------
// this is a template for making NUnit tests. Text enclosed
// in square brackets (and the brackets themselves) should be
// replaced by appropiate code.
// [File Name].cs - NUnit Test Cases for [explain here]
//
// [Author Name] ([Author email Address])
//
// (C) [Copyright holder]
//
// these are the standard namespaces you will need. You may
// need to add more depending on your tests.
using NUnit.Framework;
using System;
// all test namespaces start with "MonoTests." Append the
// Namespace that contains the class you are testing, e.g.
// MonoTests.System.Collections
namespace MonoTests.[Namespace]
{
// the class name should end with "Test" and start with the name
// of the class you are testing, e.g. CollectionBaseTest
public class [Class to be tested]Test : TestCase {
// there should be two constructors for your class. The first
// one (without parameters) should set the name to something
// unique.
// Of course the name of the method is the same as the name of
// the class
public [Constructor]() : base ("[Namespace.Class]") {}
public [Constructor](string name) : base(name) {}
// this method is run before each Test* method is called. You
// can put variable initialization, etc. here that is common to
// each test.
// Just leave the method empty if you don't need to use it.
protected override void SetUp() {}
// this method is run after each Test* method is called. You
// can put clean-up code, etc. here. Whatever needs to be done
// after each test. Just leave the method empty if you don't need
// to use it.
protected override void TearDown() {}
// this property is required. You need change the parameter for
// typeof() below to be your class.
public static ITest Suite {
get {
return new TestSuite(typeof([Classname here]));
}
}
// this is just one of probably many test methods in your test
// class. each test method must start with "Test". All methods
// in your class which start with "Test" will be automagically
// called by the NUnit framework.
public void Test[Something] {
// inside here you will exercise your class and then
// call Assert()
}
}
---------------------- TemplateTest.cs ends --------------
---------------------- CollectionBaseTest.cs begins ------
//
// System.Collections.CollectionBase
// Test suite for System.Collections.CollectionBase
//
// Author:
// Nick D. Drochak II
//
// (C) 2001 Nick D. Drochak II
//
using System;
using System.Collections;
using NUnit.Framework;
namespace MonoTests.System.Collections
{
public class CollectionBaseTest : TestCase
{
public CollectionBaseTest () : base
("System.Collection.CollectionBase testsuite")
{}
public CollectionBaseTest (String name) : base (name)
{}
// We need a concrete class to test the abstract base
// class
public class ConcreteCollection : CollectionBase
{
// These fields are used as markers to test
// the On* hooks.
public bool onClearFired;
public bool onClearCompleteFired;
public bool onInsertFired;
public int onInsertIndex;
public bool onInsertCompleteFired;
public int onInsertCompleteIndex;
public bool onRemoveFired;
public int onRemoveIndex;
public bool onRemoveCompleteFired;
public int onRemoveCompleteIndex;
public bool onSetFired;
public int onSetOldValue;
public int onSetNewValue;
public bool onSetCompleteFired;
public int onSetCompleteOldValue;
public int onSetCompleteNewValue;
// This constructor is used to test OnValid()
public ConcreteCollection()
{
IList listObj;
listObj = this;
listObj.Add(null);
}
// This constructor puts consecutive integers into the list
public ConcreteCollection(int i) {
IList listObj;
listObj = this;
int j;
for (j = 0; j< i; j++) {
listObj.Add(j);
}
}
// A helper method to look at a value in the
// list at a specific index
public int PeekAt(int index)
{
IList listObj;
listObj = this;
return (int) listObj[index];
}
// Mark the flag if this hook is fired
protected override void OnClear() {
this.onClearFired = true;
}
// Mark the flag if this hook is fired
protected override void OnClearComplete()
{
this.onClearCompleteFired = true;
}
// Mark the flag, and save the paramter if
// this hook is fired
protected override void OnInsert(int index,
object value)
{
this.onInsertFired = true;
this.onInsertIndex = index;
}
// Mark the flag, and save the paramter if
// this hook is fired
protected override void OnInsertComplete(int index,
object value)
{
this.onInsertCompleteFired = true;
this.onInsertCompleteIndex = index;
}
// Mark the flag, and save the paramter if this hook
// is fired
protected override void OnRemove(int index,
object value)
{
this.onRemoveFired = true;
this.onRemoveIndex = index;
}
// Mark the flag, and save the paramter if this hook
// is fired
protected override void OnRemoveComplete(int index,
object value)
{
this.onRemoveCompleteFired = true;
this.onRemoveCompleteIndex = index;
}
// Mark the flag, and save the paramters if this hook
// is fired
protected override void OnSet(int index, object oldValue,
object newValue)
{
this.onSetFired = true;
this.onSetOldValue = (int) oldValue;
this.onSetNewValue = (int) newValue;
}
// Mark the flag, and save the paramters if this hook
// is fired
protected override void OnSetComplete(int index,
object oldValue,
object newValue)
{
this.onSetCompleteFired = true;
this.onSetCompleteOldValue = (int) oldValue;
this.onSetCompleteNewValue = (int) newValue;
}
} // public class ConcreteCollection
public static ITest Suite {
get {
return new TestSuite
(typeof(CollectionBaseTest));
}
}
// Check the count property
public void TestCount() {
ConcreteCollection myCollection;
myCollection = new ConcreteCollection(4);
Assert(4 == myCollection.Count);
}
// Make sure GetEnumerator returns an object
public void TestGetEnumerator() {
ConcreteCollection myCollection;
myCollection = new ConcreteCollection(4);
Assert(null != myCollection.GetEnumerator());
}
// OnValid disallows nulls
public void TestOnValid() {
ConcreteCollection myCollection;
try {
myCollection = new ConcreteCollection();
}
catch (ArgumentNullException) {
}
}
// Test various Insert paths
public void TestInsert() {
ConcreteCollection myCollection;
int numberOfItems;
numberOfItems = 3;
// The constructor inserts
myCollection = new ConcreteCollection(numberOfItems);
Assert(myCollection.onInsertFired);
Assert(myCollection.onInsertCompleteFired);
// Using the IList interface, check inserts in the middle
IList listObj = myCollection;
listObj.Insert(1, 9);
Assert(myCollection.onInsertIndex == 1);
Assert(myCollection.onInsertCompleteIndex == 1);
Assert(myCollection.PeekAt(1) == 9);
}
// Test Clear and it's hooks
public void TestClear()
{
ConcreteCollection myCollection;
int numberOfItems;
numberOfItems = 1;
myCollection = new ConcreteCollection(numberOfItems);
myCollection.Clear();
Assert(myCollection.Count == 0);
Assert(myCollection.onClearFired);
Assert(myCollection.onClearCompleteFired);
}
// Test RemoveAt, other removes and the hooks
public void TestRemove()
{
ConcreteCollection myCollection;
int numberOfItems;
numberOfItems = 3;
// Set up a test collection
myCollection = new ConcreteCollection(numberOfItems);
// The list is 0-based. So if we remove the second one
myCollection.RemoveAt(1);
// We should see the original third one in it's place
Assert(myCollection.PeekAt(1) == 2);
Assert(myCollection.onRemoveFired);
Assert(myCollection.onRemoveIndex == 1);
Assert(myCollection.onRemoveCompleteFired);
Assert(myCollection.onRemoveCompleteIndex == 1);
IList listObj = myCollection;
listObj.Remove(0);
// Confirm parameters are being passed to the hooks
Assert(myCollection.onRemoveIndex == 0);
Assert(myCollection.onRemoveCompleteIndex == 0);
}
// Test the random access feature
public void TestSet()
{
ConcreteCollection myCollection;
int numberOfItems;
numberOfItems = 3;
myCollection = new ConcreteCollection(numberOfItems);
IList listObj = myCollection;
listObj[0] = 99;
Assert((int) listObj[0] == 99);
Assert(myCollection.onSetFired);
Assert(myCollection.onSetCompleteFired);
Assert(myCollection.onSetOldValue == 0);
Assert(myCollection.onSetCompleteOldValue == 0);
Assert(myCollection.onSetNewValue == 99);
Assert(myCollection.onSetCompleteNewValue == 99);
}
}
}
----------------------- CollectionBaseTest.cs ends --------
</pre>
<ul>
* If you use Emacs, you might want to use the .emacs
file and the package developed by Brad Merrill
mailto:[email protected]. It will allow you to
highlight and indent in C# style in your Emacs
editor. (XEmacs will still work but it'll also
complain).
* CSharpDevelop is a GPLed IDE developed by IC#Code.
Search for it at sourceforge if you are interested
in it.
* For those who Java: "A comparison of Microsoft's
C# programming language to Sun Microsystem's Java
Programming language" by Dare Obasanjo is a really good
(very complete) text to read.
* Suggest this point and more, now I can't think of
anything more.
</ul>
Enjoy!!.
(c) 2002, <a href="mailto:[email protected]">Jaime Anguiano Olarra</a>.
The parts included in this document are property of their
respective authors.
Note: The identation of the source code has been changed a bit
so it could fit better in the website. Anyway, as nothing more
changed, the files should work as expected.
-755
View File
@@ -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>
-96
View File
@@ -1,96 +0,0 @@
* JIT Compiler
<a
href="http://citeseer.nj.nec.com/vitek97efficient.html">
Efficient Type Inclusion Tests: Jahn Vitek, R. Nigel Horspool, Andres
Krall</a>
<a
href="http://citeseer.nj.nec.com/cytron91efficiently.html">
Efficiently Computing Static Single Assignment Form and the Control
Dependence Graph: Ron Cytron, Jeanne Ferrante</a>
<a
href="http://citeseer.nj.nec.com/193349.html">
Practical Improvements to the Construction and Destruction of Static Single Assignment Form: Preston Briggs,
Keith Cooper, Timothy Harvey, Taylor Simpson</a>
<a
href="http://citeseer.nj.nec.com/krall98efficient.html">
Efficient JavaVM Just-in-Time Compilation: Andreas Krall</a>
<a
href="http://citeseer.nj.nec.com/452617.html">Java for
Large-Scale Scientific Computations: Andreas Krall, Phillip Thomsich</a>
<a
href="http://citeseer.nj.nec.com/117522.html">
Engineering Simple, Efficient Code Generator Generator: Christopher
W. Fraser, David R. Hanson, Todd A. Proebsting</a>
<a
href="http://citeseer.nj.nec.com/proebsting92code.html">
Code Generation Techniques: Todd Alan Proebsting</a>
<a
href="http://citeseer.nj.nec.com/74629.html">Fast,
Effective Code Generation in a Just-In-Time Java Compiler: Ali-Reza
Adl-Tabatabai Guei-Yuan Lueh, Vishesh M. Parikh, James M. Stichnoth...</a>
<a
href="http://citeseer.nj.nec.com/bodik00abcd.html">
ABCD: Eliminating Array-Bounds Checks on Demand: Rastislav Bodik, Rajiv Gupta, Vivek Sarkar</a>
* Register Allocation
<a
href="http://citeseer.nj.nec.com/poletto99linear.html">
Linear Scan Register Allocation: Massimiliano Poletto, Vivek Sarkar</a>
<a
href="http://citeseer.nj.nec.com/traub98quality.html">
Quality and Speed in Linear-scan Register Allocation: Omri Traub, Glenn
Holloway, Michael D. Smith</a>
* Loop Transformations
<a
href="http://citeseer.nj.nec.com/bacon93compiler.html">
Compiler Transformations for High-Performance Computing: David Bacon</a>
* Interpreter
<a
href="http://citeseer.nj.nec.com/470069.html">
vmgen-A Generator of Efficient Virtual Machine Interpreters: M. Anton
Ertl, David Gregg, Andreas Krall, Bernd Paysan</a>
* Synchronization
<a
href="http://citeseer.nj.nec.com/krall98monitors.html">
Monitors and Exceptions - How to implement Java efficiently: Andreas Krall,
Mark Probst</a>
<a
href="http://citeseer.nj.nec.com/bacon98thin.html">
Thin Locks: Featherweight Synchronization for Java: David Bacon</a>
<a
href="http://citeseer.nj.nec.com/278639.html">
Featherweight Monitors with Bacon Bits: David Bacon</a>
* Garbage Collection
<a
href="http://citeseer.nj.nec.com/wilson92uniprocessor.html">
Uniprocessor Garbage Collection Techniques: Paul Wilson</a>
<a
href="http://citeseer.nj.nec.com/41666.html">
A Language-Independent Garbage Collector Toolkit: Richard Hudson, Eliot Moss, Amer Diwan, Christopher Weight</a>
<a
href="http://citeseer.nj.nec.com/seligmann95incremental.html">
Incremental Collection of Mature Objects: Richard Hudson, Eliot Moss</a>
+384 -246
View File
@@ -1,246 +1,384 @@
System.Object
System.Exception
System.ValueType
System.Delegate
System.MulticastDelegate
System.Enum
System.Activator
System.ArgIterator
System.__ComObject
System.TypedReference
System.Security.AllowPartiallyTrustedCallersAttribute
System.Runtime.Serialization.Formatter
System.Runtime.Serialization.FormatterConverter
System.Runtime.Serialization.FormatterServices
System.Runtime.Serialization.ObjectIDGenerator
System.Runtime.Serialization.ObjectManager
System.Reflection.ModuleResolveEventHandler
System.Reflection.Pointer
System.Globalization.CompareInfo
System.Globalization.HebrewCalendar
System.Globalization.HijriCalendar
System.Globalization.JapaneseCalendar
System.Globalization.KoreanCalendar
System.Globalization.SortKey
System.Globalization.StringInfo
System.Globalization.TaiwanCalendar
System.Globalization.TextElementEnumerator
System.Globalization.TextInfo
System.Globalization.ThaiBuddhistCalendar
System.IO.IsolatedStorage.IsolatedStorageFile
System.Reflection.Emit.MethodRental
System.Runtime.CompilerServices.AccessedThroughPropertyAttribute
System.Runtime.CompilerServices.CallConvCdecl
System.Runtime.CompilerServices.CallConvStdcall
System.Runtime.CompilerServices.CallConvThiscall
System.Runtime.CompilerServices.CallConvFastcall
System.Runtime.CompilerServices.CustomConstantAttribute
System.Runtime.CompilerServices.DateTimeConstantAttribute
System.Runtime.CompilerServices.DiscardableAttribute
System.Runtime.CompilerServices.DecimalConstantAttribute
System.Runtime.CompilerServices.CompilationRelaxationsAttribute
System.Runtime.CompilerServices.CompilerGlobalScopeAttribute
System.Runtime.CompilerServices.IDispatchConstantAttribute
System.Runtime.CompilerServices.IsVolatile
System.Runtime.CompilerServices.IUnknownConstantAttribute
System.Runtime.CompilerServices.RequiredAttributeAttribute
System.Runtime.InteropServices.ArrayWithOffset
System.Runtime.InteropServices.DispIdAttribute
System.Runtime.InteropServices.ClassInterfaceType
System.Runtime.InteropServices.ClassInterfaceAttribute
System.Runtime.InteropServices.ComVisibleAttribute
System.Runtime.InteropServices.LCIDConversionAttribute
System.Runtime.InteropServices.ComRegisterFunctionAttribute
System.Runtime.InteropServices.ComUnregisterFunctionAttribute
System.Runtime.InteropServices.ProgIdAttribute
System.Runtime.InteropServices.ImportedFromTypeLibAttribute
System.Runtime.InteropServices.IDispatchImplType
System.Runtime.InteropServices.IDispatchImplAttribute
System.Runtime.InteropServices.ComSourceInterfacesAttribute
System.Runtime.InteropServices.ComConversionLossAttribute
System.Runtime.InteropServices.TypeLibTypeFlags
System.Runtime.InteropServices.TypeLibFuncFlags
System.Runtime.InteropServices.TypeLibVarFlags
System.Runtime.InteropServices.TypeLibTypeAttribute
System.Runtime.InteropServices.TypeLibFuncAttribute
System.Runtime.InteropServices.TypeLibVarAttribute
System.Runtime.InteropServices.ComImportAttribute
System.Runtime.InteropServices.PreserveSigAttribute
System.Runtime.InteropServices.ComAliasNameAttribute
System.Runtime.InteropServices.AutomationProxyAttribute
System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute
System.Runtime.InteropServices.CoClassAttribute
System.Runtime.InteropServices.ComEventInterfaceAttribute
System.Runtime.InteropServices.COMException
System.Runtime.InteropServices.ComMemberType
System.Runtime.InteropServices.CurrencyWrapper
System.Runtime.InteropServices.DispatchWrapper
System.Runtime.InteropServices.ErrorWrapper
System.Runtime.InteropServices.ExtensibleClassFactory
System.Runtime.InteropServices.HandleRef
System.Runtime.InteropServices.InvalidComObjectException
System.Runtime.InteropServices.InvalidOleVariantTypeException
System.Runtime.InteropServices.TypeLibImporterFlags
System.Runtime.InteropServices.ExporterEventKind
System.Runtime.InteropServices.ITypeLibExporterNotifySink
System.Runtime.InteropServices.ITypeLibConverter
System.Runtime.InteropServices.MarshalDirectiveException
System.Runtime.InteropServices.ObjectCreationDelegate
System.Runtime.InteropServices.RuntimeEnvironment
System.Runtime.InteropServices.RegistrationServices
System.Runtime.InteropServices.SafeArrayRankMismatchException
System.Runtime.InteropServices.SafeArrayTypeMismatchException
System.Runtime.InteropServices.SEHException
System.Runtime.InteropServices.TypeLibConverter
System.Runtime.InteropServices.BIND_OPTS
System.Runtime.InteropServices.UCOMIBindCtx
System.Runtime.InteropServices.UCOMIConnectionPointContainer
System.Runtime.InteropServices.UCOMIConnectionPoint
System.Runtime.InteropServices.UCOMIEnumMoniker
System.Runtime.InteropServices.CONNECTDATA
System.Runtime.InteropServices.UCOMIEnumConnections
System.Runtime.InteropServices.UCOMIEnumConnectionPoints
System.Runtime.InteropServices.UCOMIEnumString
System.Runtime.InteropServices.UCOMIEnumVARIANT
System.Runtime.InteropServices.FILETIME
System.Runtime.InteropServices.UCOMIMoniker
System.Runtime.InteropServices.UCOMIPersistFile
System.Runtime.InteropServices.UCOMIRunningObjectTable
System.Runtime.InteropServices.STATSTG
System.Runtime.InteropServices.UCOMIStream
System.Runtime.InteropServices.DESCKIND
System.Runtime.InteropServices.BINDPTR
System.Runtime.InteropServices.UCOMITypeComp
System.Runtime.InteropServices.TYPEKIND
System.Runtime.InteropServices.TYPEFLAGS
System.Runtime.InteropServices.IMPLTYPEFLAGS
System.Runtime.InteropServices.TYPEATTR
System.Runtime.InteropServices.FUNCDESC
System.Runtime.InteropServices.IDLFLAG
System.Runtime.InteropServices.IDLDESC
System.Runtime.InteropServices.PARAMFLAG
System.Runtime.InteropServices.PARAMDESC
System.Runtime.InteropServices.TYPEDESC
System.Runtime.InteropServices.ELEMDESC
System.Runtime.InteropServices.VARDESC
System.Runtime.InteropServices.DISPPARAMS
System.Runtime.InteropServices.EXCEPINFO
System.Runtime.InteropServices.FUNCKIND
System.Runtime.InteropServices.INVOKEKIND
System.Runtime.InteropServices.CALLCONV
System.Runtime.InteropServices.FUNCFLAGS
System.Runtime.InteropServices.VARFLAGS
System.Runtime.InteropServices.UCOMITypeInfo
System.Runtime.InteropServices.SYSKIND
System.Runtime.InteropServices.LIBFLAGS
System.Runtime.InteropServices.TYPELIBATTR
System.Runtime.InteropServices.UCOMITypeLib
System.Runtime.InteropServices.UnknownWrapper
System.Runtime.Remoting.IObjectHandle
System.Runtime.Remoting.IRemotingTypeInfo
System.Runtime.Remoting.IChannelInfo
System.Runtime.Remoting.IEnvoyInfo
System.Runtime.Remoting.RemotingConfiguration
System.Runtime.Remoting.TypeEntry
System.Runtime.Remoting.ActivatedClientTypeEntry
System.Runtime.Remoting.ActivatedServiceTypeEntry
System.Runtime.Remoting.WellKnownClientTypeEntry
System.Runtime.Remoting.WellKnownServiceTypeEntry
System.Runtime.Remoting.RemotingException
System.Runtime.Remoting.ServerException
System.Runtime.Remoting.RemotingTimeoutException
System.Runtime.Remoting.RemotingServices
System.Runtime.Remoting.InternalRemotingServices
System.Runtime.Remoting.SoapServices
System.Runtime.Remoting.Activation.UrlAttribute
System.Runtime.Remoting.Messaging.IMessageSink
System.Runtime.Remoting.Messaging.AsyncResult
System.Runtime.Remoting.Messaging.CallContext
System.Runtime.Remoting.Messaging.ILogicalThreadAffinative
System.Runtime.Remoting.Messaging.InternalMessageWrapper
System.Runtime.Remoting.Messaging.IMethodCallMessage
System.Runtime.Remoting.Messaging.MethodCallMessageWrapper
System.Runtime.Remoting.Messaging.HeaderHandler
System.Runtime.Remoting.Messaging.IMessageCtrl
System.Runtime.Remoting.Messaging.IRemotingFormatter
System.Runtime.Remoting.Messaging.ReturnMessage
System.Runtime.Remoting.Messaging.MethodCall
System.Runtime.Remoting.Messaging.ConstructionCall
System.Runtime.Remoting.Messaging.MethodResponse
System.Runtime.Remoting.Messaging.ConstructionResponse
System.Runtime.Remoting.Messaging.MethodReturnMessageWrapper
System.Runtime.Remoting.Messaging.OneWayAttribute
System.Runtime.Remoting.Messaging.MessageSurrogateFilter
System.Runtime.Remoting.Messaging.RemotingSurrogateSelector
System.Runtime.Remoting.Contexts.CrossContextDelegate
System.Runtime.Remoting.Contexts.ContextProperty
System.Runtime.Remoting.Contexts.IContextPropertyActivator
System.Runtime.Remoting.Contexts.IContributeClientContextSink
System.Runtime.Remoting.Contexts.IContributeDynamicSink
System.Runtime.Remoting.Contexts.IContributeEnvoySink
System.Runtime.Remoting.Contexts.IContributeObjectSink
System.Runtime.Remoting.Contexts.IContributeServerContextSink
System.Runtime.Serialization.Formatters.InternalRM
System.Runtime.Serialization.Formatters.InternalST
System.Runtime.Serialization.Formatters.SoapMessage
System.Runtime.Serialization.Formatters.SoapFault
System.Runtime.Serialization.Formatters.ServerFault
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
System.Security.Cryptography.CryptoConfig
System.Security.Cryptography.KeyedHashAlgorithm
System.Security.Cryptography.HMACSHA1
System.Security.Cryptography.MACTripleDES
System.Security.Cryptography.MaskGenerationMethod
System.Security.Cryptography.PasswordDeriveBytes
System.Security.Cryptography.PKCS1MaskGenerationMethod
System.Security.Cryptography.RC2
System.Security.Cryptography.RC2CryptoServiceProvider
System.Security.Cryptography.RSACryptoServiceProvider
System.Security.Cryptography.RSAOAEPKeyExchangeDeformatter
System.Security.Cryptography.RSAOAEPKeyExchangeFormatter
System.Security.Cryptography.RSAPKCS1KeyExchangeDeformatter
System.Security.Cryptography.RSAPKCS1KeyExchangeFormatter
System.Security.Cryptography.RSAPKCS1SignatureDeformatter
System.Security.Cryptography.RSAPKCS1SignatureFormatter
System.Security.Cryptography.SHA1Managed
System.Security.Cryptography.TripleDES
System.Security.Cryptography.TripleDESCryptoServiceProvider
System.Security.Permissions.EnvironmentPermission
System.Security.Permissions.FileDialogPermission
System.Security.Permissions.IsolatedStorageFilePermission
System.Security.Permissions.PrincipalPermissionAttribute
System.Security.Permissions.SecurityPermissionAttribute
System.Security.Permissions.PublisherIdentityPermissionAttribute
System.Security.Permissions.PublisherIdentityPermission
System.Security.Permissions.ReflectionPermission
System.Security.Permissions.RegistryPermission
System.Security.Permissions.PrincipalPermission
System.Security.Permissions.SiteIdentityPermission
System.Security.Permissions.StrongNameIdentityPermission
System.Security.Permissions.StrongNamePublicKeyBlob
System.Security.Permissions.UIPermission
System.Security.Permissions.UrlIdentityPermission
System.Security.Permissions.ZoneIdentityPermission
System.Security.Policy.ApplicationDirectory
System.Security.Policy.ApplicationDirectoryMembershipCondition
System.Security.Policy.FirstMatchCodeGroup
System.Security.Policy.Hash
System.Security.Policy.HashMembershipCondition
System.Security.Policy.NetCodeGroup
System.Security.Policy.PermissionRequestEvidence
System.Security.Policy.Publisher
System.Security.Policy.PublisherMembershipCondition
System.Security.Policy.Site
System.Security.Policy.SiteMembershipCondition
System.Security.Policy.StrongName
System.Security.Policy.StrongNameMembershipCondition
System.Security.Policy.UnionCodeGroup
System.Security.Policy.Url
System.Security.Policy.UrlMembershipCondition
System.Security.Policy.Zone
System.Security.Policy.ZoneMembershipCondition
System.Security.Principal.WindowsIdentity
System.Security.Principal.WindowsImpersonationContext
System.Security.Principal.WindowsPrincipal
System.Threading.CompressedStack
Microsoft.Win32.Registry
Microsoft.Win32.RegistryHive
Microsoft.Win32.RegistryKey
System.__ComObject
System.Activator
System.ArgIterator
System.AssemblyLoadEventHandler
System.AsyncCallback
System.CrossAppDomainDelegate
System.DBNull
System.Diagnostics.SymbolStore.SymDocumentType
System.Diagnostics.SymbolStore.SymLanguageType
System.Diagnostics.SymbolStore.SymLanguageVendor
System.EventHandler
System.Globalization.CompareInfo
System.Globalization.HebrewCalendar
System.Globalization.HijriCalendar
System.Globalization.JapaneseCalendar
System.Globalization.KoreanCalendar
System.Globalization.RegionInfo
System.Globalization.SortKey
System.Globalization.StringInfo
System.Globalization.TaiwanCalendar
System.Globalization.TextElementEnumerator
System.Globalization.TextInfo
System.Globalization.ThaiBuddhistCalendar
System.IO.EndOfStreamException
System.IO.IsolatedStorage.IsolatedStorage
System.IO.IsolatedStorage.IsolatedStorageException
System.IO.IsolatedStorage.IsolatedStorageFile
System.IO.PathTooLongException
System.Reflection.Emit.MethodRental
System.Reflection.MemberFilter
System.Reflection.Missing
System.Reflection.ModuleResolveEventHandler
System.Reflection.Pointer
System.Reflection.StrongNameKeyPair
System.Reflection.TargetException
System.Reflection.TypeFilter
System.ResolveEventHandler
System.Runtime.CompilerServices.AccessedThroughPropertyAttribute
System.Runtime.CompilerServices.CallConvCdecl
System.Runtime.CompilerServices.CallConvFastcall
System.Runtime.CompilerServices.CallConvStdcall
System.Runtime.CompilerServices.CallConvThiscall
System.Runtime.CompilerServices.CompilationRelaxationsAttribute
System.Runtime.CompilerServices.CompilerGlobalScopeAttribute
System.Runtime.CompilerServices.CustomConstantAttribute
System.Runtime.CompilerServices.DateTimeConstantAttribute
System.Runtime.CompilerServices.DecimalConstantAttribute
System.Runtime.CompilerServices.DiscardableAttribute
System.Runtime.CompilerServices.IDispatchConstantAttribute
System.Runtime.CompilerServices.IsVolatile
System.Runtime.CompilerServices.IUnknownConstantAttribute
System.Runtime.CompilerServices.RequiredAttributeAttribute
System.Runtime.InteropServices.ArrayWithOffset
System.Runtime.InteropServices.AssemblyRegistrationFlags
System.Runtime.InteropServices.AutomationProxyAttribute
System.Runtime.InteropServices.BIND_OPTS
System.Runtime.InteropServices.BINDPTR
System.Runtime.InteropServices.CALLCONV
System.Runtime.InteropServices.ClassInterfaceAttribute
System.Runtime.InteropServices.ClassInterfaceType
System.Runtime.InteropServices.CoClassAttribute
System.Runtime.InteropServices.ComAliasNameAttribute
System.Runtime.InteropServices.ComConversionLossAttribute
System.Runtime.InteropServices.ComEventInterfaceAttribute
System.Runtime.InteropServices.COMException
System.Runtime.InteropServices.ComImportAttribute
System.Runtime.InteropServices.ComInterfaceType
System.Runtime.InteropServices.ComMemberType
System.Runtime.InteropServices.ComRegisterFunctionAttribute
System.Runtime.InteropServices.ComSourceInterfacesAttribute
System.Runtime.InteropServices.ComUnregisterFunctionAttribute
System.Runtime.InteropServices.ComVisibleAttribute
System.Runtime.InteropServices.CONNECTDATA
System.Runtime.InteropServices.CurrencyWrapper
System.Runtime.InteropServices.DESCKIND
System.Runtime.InteropServices.DispatchWrapper
System.Runtime.InteropServices.DispIdAttribute
System.Runtime.InteropServices.DISPPARAMS
System.Runtime.InteropServices.ELEMDESC
System.Runtime.InteropServices.ErrorWrapper
System.Runtime.InteropServices.EXCEPINFO
System.Runtime.InteropServices.Expando.IExpando
System.Runtime.InteropServices.ExporterEventKind
System.Runtime.InteropServices.ExtensibleClassFactory
System.Runtime.InteropServices.FILETIME
System.Runtime.InteropServices.FUNCDESC
System.Runtime.InteropServices.FUNCFLAGS
System.Runtime.InteropServices.FUNCKIND
System.Runtime.InteropServices.GCHandle
System.Runtime.InteropServices.GuidAttribute
System.Runtime.InteropServices.HandleRef
System.Runtime.InteropServices.ICustomAdapter
System.Runtime.InteropServices.ICustomFactory
System.Runtime.InteropServices.ICustomMarshaler
System.Runtime.InteropServices.IDispatchImplAttribute
System.Runtime.InteropServices.IDispatchImplType
System.Runtime.InteropServices.IDLDESC
System.Runtime.InteropServices.IDLFLAG
System.Runtime.InteropServices.IMPLTYPEFLAGS
System.Runtime.InteropServices.ImportedFromTypeLibAttribute
System.Runtime.InteropServices.ImporterEventKind
System.Runtime.InteropServices.InterfaceTypeAttribute
System.Runtime.InteropServices.InvalidComObjectException
System.Runtime.InteropServices.InvalidOleVariantTypeException
System.Runtime.InteropServices.INVOKEKIND
System.Runtime.InteropServices.IRegistrationServices
System.Runtime.InteropServices.ITypeLibConverter
System.Runtime.InteropServices.ITypeLibExporterNameProvider
System.Runtime.InteropServices.ITypeLibExporterNotifySink
System.Runtime.InteropServices.ITypeLibImporterNotifySink
System.Runtime.InteropServices.LCIDConversionAttribute
System.Runtime.InteropServices.LIBFLAGS
System.Runtime.InteropServices.MarshalDirectiveException
System.Runtime.InteropServices.ObjectCreationDelegate
System.Runtime.InteropServices.PARAMDESC
System.Runtime.InteropServices.PARAMFLAG
System.Runtime.InteropServices.PreserveSigAttribute
System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute
System.Runtime.InteropServices.ProgIdAttribute
System.Runtime.InteropServices.RegistrationServices
System.Runtime.InteropServices.RuntimeEnvironment
System.Runtime.InteropServices.SafeArrayRankMismatchException
System.Runtime.InteropServices.SafeArrayTypeMismatchException
System.Runtime.InteropServices.SEHException
System.Runtime.InteropServices.STATSTG
System.Runtime.InteropServices.SYSKIND
System.Runtime.InteropServices.TYPEATTR
System.Runtime.InteropServices.TYPEDESC
System.Runtime.InteropServices.TYPEFLAGS
System.Runtime.InteropServices.TYPEKIND
System.Runtime.InteropServices.TYPELIBATTR
System.Runtime.InteropServices.TypeLibConverter
System.Runtime.InteropServices.TypeLibExporterFlags
System.Runtime.InteropServices.TypeLibFuncAttribute
System.Runtime.InteropServices.TypeLibFuncFlags
System.Runtime.InteropServices.TypeLibImporterFlags
System.Runtime.InteropServices.TypeLibTypeAttribute
System.Runtime.InteropServices.TypeLibTypeFlags
System.Runtime.InteropServices.TypeLibVarAttribute
System.Runtime.InteropServices.TypeLibVarFlags
System.Runtime.InteropServices.UCOMIBindCtx
System.Runtime.InteropServices.UCOMIConnectionPoint
System.Runtime.InteropServices.UCOMIConnectionPointContainer
System.Runtime.InteropServices.UCOMIEnumConnectionPoints
System.Runtime.InteropServices.UCOMIEnumConnections
System.Runtime.InteropServices.UCOMIEnumMoniker
System.Runtime.InteropServices.UCOMIEnumString
System.Runtime.InteropServices.UCOMIEnumVARIANT
System.Runtime.InteropServices.UCOMIMoniker
System.Runtime.InteropServices.UCOMIPersistFile
System.Runtime.InteropServices.UCOMIRunningObjectTable
System.Runtime.InteropServices.UCOMIStream
System.Runtime.InteropServices.UCOMITypeComp
System.Runtime.InteropServices.UCOMITypeInfo
System.Runtime.InteropServices.UCOMITypeLib
System.Runtime.InteropServices.UnknownWrapper
System.Runtime.InteropServices.VARDESC
System.Runtime.InteropServices.VARFLAGS
System.Runtime.Remoting.ActivatedClientTypeEntry
System.Runtime.Remoting.ActivatedServiceTypeEntry
System.Runtime.Remoting.Activation.UrlAttribute
System.Runtime.Remoting.Channels.BaseChannelObjectWithProperties
System.Runtime.Remoting.Channels.BaseChannelSinkWithProperties
System.Runtime.Remoting.Channels.BaseChannelWithProperties
System.Runtime.Remoting.Channels.ChannelDataStore
System.Runtime.Remoting.Channels.ChannelServices
System.Runtime.Remoting.Channels.ClientChannelSinkStack
System.Runtime.Remoting.Channels.IChannel
System.Runtime.Remoting.Channels.IChannelDataStore
System.Runtime.Remoting.Channels.IChannelReceiver
System.Runtime.Remoting.Channels.IChannelReceiverHook
System.Runtime.Remoting.Channels.IChannelSender
System.Runtime.Remoting.Channels.IChannelSinkBase
System.Runtime.Remoting.Channels.IClientChannelSink
System.Runtime.Remoting.Channels.IClientChannelSinkProvider
System.Runtime.Remoting.Channels.IClientChannelSinkStack
System.Runtime.Remoting.Channels.IClientFormatterSink
System.Runtime.Remoting.Channels.IClientFormatterSinkProvider
System.Runtime.Remoting.Channels.IClientResponseChannelSinkStack
System.Runtime.Remoting.Channels.IServerChannelSink
System.Runtime.Remoting.Channels.IServerChannelSinkProvider
System.Runtime.Remoting.Channels.IServerChannelSinkStack
System.Runtime.Remoting.Channels.IServerFormatterSinkProvider
System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack
System.Runtime.Remoting.Channels.ITransportHeaders
System.Runtime.Remoting.Channels.ServerChannelSinkStack
System.Runtime.Remoting.Channels.ServerProcessing
System.Runtime.Remoting.Channels.SinkProviderData
System.Runtime.Remoting.Channels.TransportHeaders
System.Runtime.Remoting.Contexts.ContextProperty
System.Runtime.Remoting.Contexts.CrossContextDelegate
System.Runtime.Remoting.Contexts.IContextPropertyActivator
System.Runtime.Remoting.Contexts.IContributeClientContextSink
System.Runtime.Remoting.Contexts.IContributeDynamicSink
System.Runtime.Remoting.Contexts.IContributeEnvoySink
System.Runtime.Remoting.Contexts.IContributeObjectSink
System.Runtime.Remoting.Contexts.IContributeServerContextSink
System.Runtime.Remoting.IChannelInfo
System.Runtime.Remoting.IEnvoyInfo
System.Runtime.Remoting.InternalRemotingServices
System.Runtime.Remoting.IObjectHandle
System.Runtime.Remoting.IRemotingTypeInfo
System.Runtime.Remoting.Lifetime.ClientSponsor
System.Runtime.Remoting.Lifetime.ILease
System.Runtime.Remoting.Lifetime.ISponsor
System.Runtime.Remoting.Lifetime.LeaseState
System.Runtime.Remoting.Lifetime.LifetimeServices
System.Runtime.Remoting.Messaging.AsyncResult
System.Runtime.Remoting.Messaging.CallContext
System.Runtime.Remoting.Messaging.ConstructionCall
System.Runtime.Remoting.Messaging.ConstructionResponse
System.Runtime.Remoting.Messaging.Header
System.Runtime.Remoting.Messaging.HeaderHandler
System.Runtime.Remoting.Messaging.ILogicalThreadAffinative
System.Runtime.Remoting.Messaging.IMessageCtrl
System.Runtime.Remoting.Messaging.IMessageSink
System.Runtime.Remoting.Messaging.IMethodCallMessage
System.Runtime.Remoting.Messaging.InternalMessageWrapper
System.Runtime.Remoting.Messaging.IRemotingFormatter
System.Runtime.Remoting.Messaging.LogicalCallContext
System.Runtime.Remoting.Messaging.MessageSurrogateFilter
System.Runtime.Remoting.Messaging.MethodCall
System.Runtime.Remoting.Messaging.MethodCallMessageWrapper
System.Runtime.Remoting.Messaging.MethodResponse
System.Runtime.Remoting.Messaging.MethodReturnMessageWrapper
System.Runtime.Remoting.Messaging.OneWayAttribute
System.Runtime.Remoting.Messaging.RemotingSurrogateSelector
System.Runtime.Remoting.Messaging.ReturnMessage
System.Runtime.Remoting.Metadata.SoapAttribute
System.Runtime.Remoting.Metadata.SoapFieldAttribute
System.Runtime.Remoting.Metadata.SoapMethodAttribute
System.Runtime.Remoting.Metadata.SoapOption
System.Runtime.Remoting.Metadata.SoapParameterAttribute
System.Runtime.Remoting.Metadata.SoapTypeAttribute
System.Runtime.Remoting.Metadata.W3cXsd2001.ISoapXsd
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapAnyUri
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapBase64Binary
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDate
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDateTime
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDay
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDuration
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapEntities
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapEntity
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapHexBinary
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapId
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapIdref
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapIdrefs
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapInteger
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapLanguage
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapMonth
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapMonthDay
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapName
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNcName
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNegativeInteger
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNmtoken
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNmtokens
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNonNegativeInteger
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNonPositiveInteger
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNormalizedString
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNotation
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapPositiveInteger
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapQName
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapTime
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapToken
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapYear
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapYearMonth
System.Runtime.Remoting.Metadata.XmlFieldOrderOption
System.Runtime.Remoting.Proxies.ProxyAttribute
System.Runtime.Remoting.Proxies.RealProxy
System.Runtime.Remoting.RemotingConfiguration
System.Runtime.Remoting.RemotingException
System.Runtime.Remoting.RemotingServices
System.Runtime.Remoting.RemotingTimeoutException
System.Runtime.Remoting.ServerException
System.Runtime.Remoting.Services.EnterpriseServicesHelper
System.Runtime.Remoting.Services.ITrackingHandler
System.Runtime.Remoting.Services.TrackingServices
System.Runtime.Remoting.SoapServices
System.Runtime.Remoting.TypeEntry
System.Runtime.Remoting.WellKnownClientTypeEntry
System.Runtime.Remoting.WellKnownServiceTypeEntry
System.Runtime.Serialization.Formatter
System.Runtime.Serialization.FormatterConverter
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
System.Runtime.Serialization.Formatters.InternalRM
System.Runtime.Serialization.Formatters.InternalST
System.Runtime.Serialization.Formatters.ServerFault
System.Runtime.Serialization.Formatters.SoapFault
System.Runtime.Serialization.Formatters.SoapMessage
System.Runtime.Serialization.FormatterServices
System.Runtime.Serialization.ObjectIDGenerator
System.Runtime.Serialization.ObjectManager
System.Runtime.Serialization.SerializationBinder
System.Runtime.Serialization.SerializationEntry
System.Runtime.Serialization.SerializationInfoEnumerator
System.Runtime.Serialization.SurrogateSelector
System.RuntimeArgumentHandle
System.Security.AllowPartiallyTrustedCallersAttribute
System.Security.Cryptography.CryptoConfig
System.Security.Cryptography.DSACryptoServiceProvider
System.Security.Cryptography.HMACSHA1
System.Security.Cryptography.KeyedHashAlgorithm
System.Security.Cryptography.MACTripleDES
System.Security.Cryptography.MaskGenerationMethod
System.Security.Cryptography.PasswordDeriveBytes
System.Security.Cryptography.PKCS1MaskGenerationMethod
System.Security.Cryptography.RandomNumberGenerator
System.Security.Cryptography.RC2
System.Security.Cryptography.RC2CryptoServiceProvider
System.Security.Cryptography.Rijndael
System.Security.Cryptography.RijndaelManaged
System.Security.Cryptography.RNGCryptoServiceProvider
System.Security.Cryptography.RSA
System.Security.Cryptography.RSACryptoServiceProvider
System.Security.Cryptography.RSAOAEPKeyExchangeDeformatter
System.Security.Cryptography.RSAOAEPKeyExchangeFormatter
System.Security.Cryptography.RSAParameters
System.Security.Cryptography.RSAPKCS1KeyExchangeDeformatter
System.Security.Cryptography.RSAPKCS1KeyExchangeFormatter
System.Security.Cryptography.RSAPKCS1SignatureDeformatter
System.Security.Cryptography.RSAPKCS1SignatureFormatter
System.Security.Cryptography.SHA1Managed
System.Security.Cryptography.SHA384Managed
System.Security.Cryptography.SHA512Managed
System.Security.Cryptography.TripleDES
System.Security.Cryptography.TripleDESCryptoServiceProvider
System.Security.Cryptography.X509Certificates.X509Certificate
System.Security.NamedPermissionSet
System.Security.Permissions.EnvironmentPermission
System.Security.Permissions.FileDialogPermission
System.Security.Permissions.FileDialogPermissionAccess
System.Security.Permissions.IsolatedStorageFilePermission
System.Security.Permissions.IsolatedStoragePermissionAttribute
System.Security.Permissions.PrincipalPermission
System.Security.Permissions.PrincipalPermissionAttribute
System.Security.Permissions.PublisherIdentityPermission
System.Security.Permissions.PublisherIdentityPermissionAttribute
System.Security.Permissions.ReflectionPermission
System.Security.Permissions.RegistryPermission
System.Security.Permissions.SecurityPermission
System.Security.Permissions.SecurityPermissionAttribute
System.Security.Permissions.SiteIdentityPermission
System.Security.Permissions.StrongNameIdentityPermission
System.Security.Permissions.StrongNamePublicKeyBlob
System.Security.Permissions.UIPermission
System.Security.Permissions.UrlIdentityPermission
System.Security.Permissions.ZoneIdentityPermission
System.Security.Policy.AllMembershipCondition
System.Security.Policy.ApplicationDirectory
System.Security.Policy.ApplicationDirectoryMembershipCondition
System.Security.Policy.FileCodeGroup
System.Security.Policy.FirstMatchCodeGroup
System.Security.Policy.Hash
System.Security.Policy.HashMembershipCondition
System.Security.Policy.NetCodeGroup
System.Security.Policy.PermissionRequestEvidence
System.Security.Policy.PolicyStatement
System.Security.Policy.Publisher
System.Security.Policy.PublisherMembershipCondition
System.Security.Policy.Site
System.Security.Policy.SiteMembershipCondition
System.Security.Policy.StrongName
System.Security.Policy.StrongNameMembershipCondition
System.Security.Policy.UnionCodeGroup
System.Security.Policy.Url
System.Security.Policy.UrlMembershipCondition
System.Security.Policy.Zone
System.Security.Policy.ZoneMembershipCondition
System.Security.Principal.WindowsIdentity
System.Security.Principal.WindowsImpersonationContext
System.Security.Principal.WindowsPrincipal
System.Threading.CompressedStack
System.Threading.IOCompletionCallback
System.Threading.ThreadStart
System.Threading.TimerCallback
System.Threading.WaitCallback
System.Threading.WaitOrTimerCallback
System.TimeZone
System.TypedReference
System.UnhandledExceptionEventHandler
System.WeakReference
-15
View File
@@ -1,15 +0,0 @@
* Plans
Here we are tracking some plans to particular pieces of
technology that are part of Mono.
This is just a repository of information that is handy for
contributors.
Currently you can read our plans for <a
href="ado-net.html">ADO.NET</a>, <a
href="asp-net">ASP.NET</a>, <a href="java.html">Java</a> and
<a href="winforms.html">WinForms</a>.
-33
View File
@@ -1,33 +0,0 @@
* Mono PowerPC Port
** Status
It passes and compiles the same amount of mono tests as on the x86 architecture.
mcs is self hosting on Linux/PPC.
*** Interpreter
Up to date.
*** Jitter
Start the port
** Documentation
*** PowerPC architecture:
<A HREF="http://e-www.motorola.com/brdata/PDFDB/docs/MPCFPE32B.pdf">PowerPC Programming environments manual</A><BR>
<A HREF="http://e-www.motorola.com/brdata/PDFDB/docs/MPC7410UM.pdf">G4 (7410) User's manual</A>
There's a very nice introduction to PowerPC assembly language
at <a
href="http://www-106.ibm.com/developerworks/library/l-ppc/">http://www-106.ibm.com/developerworks/library/l-ppc/</a>.
*** Calling conventions:
<a href="http://www.esofta.com/softspecs.html">The PowerPC SystemV ABI specification</a>
-24
View File
@@ -1,24 +0,0 @@
* Open Projects
The .NET framework is a good first in terms of a new
development foundation, but it falls short of providing
higher-level components or building blocks for people to
reuse.
A few ideas of projects and classes that would be useful to
develop applications follows:
** EOG component
** XmlStorageSystem component
* Gtk# related projects
Gnome Canvas Bindings.
Bezier Canvas Item Binding.
* Graphical bindings
Binding for the Libart library
+36 -43
View File
@@ -9,7 +9,7 @@
** Microsoft .NET
The <a href="http://msdn.microsoft.com/net">Microsoft.NET site.</a>
The <a href="http://msdn.microsoft.com/net">Microsoft.NET site.
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>
@@ -86,6 +86,38 @@
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://lists.ximian.com/mailman/listinfo/mono-list">mono-list:</a></b>
The general Mono discussion list.
* <b><a
href="http://lists.ximian.com/mailman/listinfo/mono-announce-list">mono-announce-list:</a></b>
Announcements of Mono developments.
* <b><a
href="http://lists.ximian.com/mailman/listinfo/mono-gc-list">mono-gc-list:</a></b>
Discussion on the GC system of Mono.
* <b><a
href="http://lists.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list:</a></b>
Track the CVS activity of Mono on this mailing list. You can get <a href="http://www.go-mono.com/snapshots">daily snapshots</a> as well.
* <b><a
href="http://lists.ximian.com/mailman/listinfo/mono-docs-list">mono-docs-list:</a></b>
Discussion on the documentation of Mono.
* <b><a
href="http://lists.ximian.com/mailman/listinfo/mono-patches">mono-patches:</a></b>
Track the development of Mono in realtime: receive patches to the Mono repository
by email.
* <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>
@@ -104,19 +136,10 @@
There are a number of related projects to Mono:
<ul>
* <a
href="http://qtcsharp.sourceforge.net">Qt#:</a>
C# bindings for the Qt toolkit.
* <a
href="http://www.icsharpcode.net/OpenSource/SD/default.asp">Sharp
Develop:</a> an IDE for the C# language written in C#.
* <a
href="http://www.improve-technologies.com/alpha/esharp/">Eclipse
Plugin for C#</a>
* <a
href="http://janet-js.sourceforge.net/">Janet:</a>
an implemention of ECMAScript (the standarized
@@ -142,13 +165,11 @@
href="http://www.southern-storm.com.au/portable_net.html">Portable.NET:</a>
Another implementation of the CLI and C# compiler.
* A Free (GFDL) tutorial on C# in Spanish with examples, slides, and extras (under development). Get it <a href="http://geneura.ugr.es/~jaime/csharp/">here</a>.
</ul>
** GNOME Documentation
Documentation on GNOME, and the GNOME APIs is available from
Documnetation on GNOME, and the GNOME APIs is available from
the <a href="http://developer.gnome.org">developer</a> site at
GNOME:
@@ -162,34 +183,6 @@
* <A
href="http://developer.gnome.org/arch/">Architecture Overview</a>
</ul>
** Assembly Language Manuals online
<ul>
* <a href="http://www.agner.org/assem/#optimize">
Pentium optimization tutorial</a> by Agner Fog
* <a href="http://webster.cs.ucr.edu/">
Art of Assembly</a> (x86 only)
* Documentation for various CPUs
(<a href="http://www.mit.edu/afs/sipb/contrib/doc/specs/ic/cpu/">
x86, IA64, MIPS, ARM, Alpha</a>)
* <a href="http://www.heyrick.co.uk/assembler/">
ARM Assembler</a> tutorial
* PowerPC
<a href="http://www-3.ibm.com/chips/techlib/techlib.nsf/techdocs/852569B20050FF7785256996007558C6">
Compiler Writer's Guide</a>
* <a href="http://www.lightsoft.co.uk/Fantasm/Beginners/begin1.html">
Beginners Guide to PowerPC Assembler</a>
</ul>
** Win32
<ul>
* Win32 <a href="http://www.jorgon.freeserve.co.uk/ExceptFrame.htm">
Structured Exception Handling (SEH)</a> internals (x86 specific)
</ul>
+10 -56
View File
@@ -16,8 +16,14 @@
easy-to-port runtime engine.
</ul>
Currently we are using the Bohem conservative garbage
collector, but we working on incorporating the ORP GC engine.
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.
** Executing MSIL/CIL images
@@ -54,38 +60,18 @@
layout the code to support non-IA32 architectures. Our work
will be focused on getting a IA32 version running first.
The JIT engine works on Linux and Win32, although you
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).
** JIT Engine (<b>updated, July 8th, 2002</b>)
** JIT Engine (<b>updated, Dec 18th, 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.
The JIT engine implements a number of optimizations:
<ul>
* Opcode cost estimates (our architecture allows
us to generate different code paths depending
on the target CPU dynamically).
* Inlining.
* Constant folding.
Although compilers typically do
constant folding, the combination of inlining with
constant folding gives some very good results.
* Linear scan register allocation. In the past,
register allocation was our achilles heel, but now
we have left this problem behind.
</ul>
There are a couple of books that deal with this technique: "A
Retargetable C Compiler" and "Advanced Compiler Design and
Implementation" are good references. You can also get a
@@ -102,22 +88,8 @@
</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.
@@ -179,21 +151,3 @@
Initially we used libffi, but it was fairly slow, so we have
reused parts of the JIT work to create efficient PInvoke trampolines.
** Remoting
Mono has support for remoting and proxy objects, just like
.NET does. The runtime provides these facilities.
** Porting
If you are interested in porting the Mono runtime to other
platforms, you might find the pre-compiled <a
href="archive/mono-tests.tar.gz">Mono regression test
suite</a> useful to debug your implementation.
* COM and XPCOM
We plan on adding support for XPCOM on Unix and COM on Microsoft
Windows later in our development process.
+1 -1
View File
@@ -11,7 +11,7 @@
* The Mono JIT engine (<b>mono</b>. The JIT engine is
the real
virtual machine that we support. It is
currently functional, and we are improving its speed,
functionaly currently, and we are improving its speed,
and making it feature complete.
* A CIL bytecode interpreter (<b>mint</b>). This
+1 -1
View File
@@ -35,7 +35,7 @@
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>.
post it to <a href="resources.html#mailing">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
+1 -25
View File
@@ -4,43 +4,19 @@
1,Runtime,runtime.html,runtime.src
1,Classes,class-library.html,class-library.src
1,Gtk#,http://gtk-sharp.sourceforge.net
1,Class Status,class-status.html,class-status.src,cm/cormissing.css,cm/cormissing.js
2,corlib,class-status-corlib.html,class-status-corlib.src,cm/cormissing.css,cm/cormissing.js
2,System,class-status-System.html,class-status-System.src,cm/cormissing.css,cm/cormissing.js
2,System.Xml,class-status-System.Xml.html,class-status-System.Xml.src,cm/cormissing.css,cm/cormissing.js
2,System.Data,class-status-System.Data.html,class-status-System.Data.src,cm/cormissing.css,cm/cormissing.js
2,System.Drawing,class-status-System.Drawing.html,class-status-System.Drawing.src,cm/cormissing.css,cm/cormissing.js
2,System.Web,class-status-System.Web.html,class-status-System.Web.src,cm/cormissing.css,cm/cormissing.js
2,System.Web.Services,class-status-System.Web.Services.html,class-status-System.Web.Services.src,cm/cormissing.css,cm/cormissing.js
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,Hackers,hackers.html,hackers.src
1,Documentation,documentation.html,documentation.src
1,Class Docs,classlib-doc.html,classlib-doc.src
1,Doc format,monodoc-xml.html,monodoc-xml.src
1,Test Suite,testing.html,testing.src
1,Tools,tools.html,tools.src
1,Porting,porting.html,porting.src
2,PowerPC,ppc.html,ppc.src
1,HOWTO,mono-contribution-howto.html,mono-contribution-howto.src
0,Plans,plans.html,plans.src
1,ADO.NET,ado-net.html,ado-net.src
1,ASP.NET,asp-net.html,asp-net.src
1,Java,java.html,java.src
1,Windows.Forms,winforms.html,winforms.src
0,Resources,resources.html,resources.src
1,Beginning,mono-beginning.html,mono-beginning.src
1,Mailing Lists,mailing-lists.html,mailing-lists.src
1,Ideas,ideas.html,ideas.src
1,Passport,passport.html,passport.src
1,Books,books.html,books.src
1,Papers,papers.html,papers.src
1,Languages,languages.html,languages.src
1,Debugging,jit-debug.html,jit-debug.src
2,Example 1,jit-debug-sample.html,jit-debug-sample.src
2,Example 2,jit-debug-sample2.html,jit-debug-sample2.src
0,Contact,contact.html,contact.src
-1
View File
@@ -1 +0,0 @@
*.html
Binary file not shown.

Before

Width:  |  Height:  |  Size: 150 B

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

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.
-7
View File
@@ -9,17 +9,10 @@ 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 (/^\@item (.*)$/){
$name = $link = $1;
$link =~ s/ //g;
print "<a name=\"$link\">\n";
print "<h2>$name</h2>\n";
} elsif (/^Q: (.*)$/){
print "<p><a name=\"q$q\"></a><b>Question $q:</b> $1\n";
$q++;
Binary file not shown.

Before

Width:  |  Height:  |  Size: 429 B

+38 -121
View File
@@ -1,130 +1,47 @@
CSCRIPT = $(SYSTEMROOT)/system32/cscript.exe
CSC=csc
# Until we are ready:
# ../class-library \
CORCOMPARE=../../../mcs/tools/corcompare
SOURCES= \
../anoncvs \
../contributing \
../class-status \
../class-library \
../classlib-doc \
../contact \
../c-sharp \
../ccvs \
../documentation \
../download \
../faq \
../gcc-frontend \
../index \
../ideas \
../passport \
../rationale \
../resources \
../roadmap \
../runtime \
../status \
../testing \
../porting \
../tools
OBJECTS= \
deploy/ado-net.html \
deploy/anoncvs.html \
deploy/asp-net.html \
deploy/books.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.Drawing.html \
deploy/class-status-System.Data.html \
deploy/class-status-System.Web.html \
deploy/class-status-System.Web.Services.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/hackers.html \
deploy/index.html \
deploy/ideas.html \
deploy/java.html \
deploy/jit-debug.html \
deploy/jit-debug-sample.html \
deploy/jit-debug-sample2.html \
deploy/languages.html \
deploy/mailing-lists.html \
deploy/mono-beginning.html \
deploy/mono-contribution-howto.html \
deploy/monodoc-xml.html \
deploy/papers.html \
deploy/passport.html \
deploy/plans.html \
deploy/porting.html \
deploy/ppc.html \
deploy/rationale.html \
deploy/resources.html \
deploy/roadmap.html \
deploy/runtime.html \
deploy/status.html \
deploy/testing.html \
deploy/tools.html \
deploy/winforms.html
all:
-mkdir site
for i in $(SOURCES); do \
perl htmlify $$i > `basename $$i`.src; \
done;
# deploy/class-status-System.html \
NON_HTML_SOURCES= \
../mono-build.sh \
../mono-build-w32.sh
all: $(OBJECTS) deploy/index.rss
perl process.pl commands template.html.in deploy
tutorial: mono-beginning.html.stamp mono-beginning.pdf
cp -a mono-beginning mono-beginning.xml mono-beginning.pdf deploy
mono-beginning.html.stamp: mono-beginning.xml
db2html mono-beginning.xml
touch mono-beginning.html.stamp
mono-beginning.pdf: mono-beginning.xml
db2pdf mono-beginning.xml
mono-beginning.xml: ../mono-beginning.xml
cp ../mono-beginning.xml .
deploy/index.rss: mono-rss.exe ../index
./mono-rss.exe ../index deploy/index.rss
mono-rss.exe: mono-rss.cs rss.cs
$(CSC) mono-rss.cs rss.cs
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 -P 2200 *.html [email protected]:/web/cvsmodules/mono
echo scp *.html [email protected]:/home/groups/m/mo/mononet/htdocs
push2:
scp -r deploy/* primates:public_html/xxx
$(OBJECTS): $(patsubst deploy/%.html,src/%.src, $(OBJECTS))
#.PRECIOUS: $(patsubst deploy/%.html,src/%.src, $(OBJECTS))
.PRECIOUS: src/%.src
src/%.src: ../% commands makefile template.html.in
perl htmlify $< > $@
.PRECIOUS: ../class-status-%
../class-status-%: src/%.html.in ../class-status.in
cat ../class-status.in $< > $@
.PRECIOUS: src/%.html.in
src/%.html.in: src/%.xml $(CORCOMPARE)/transform.js $(CORCOMPARE)/cormissing.xsl
$(CSCRIPT) /nologo $(CORCOMPARE)/transform.js $< $(CORCOMPARE)/cormissing.xsl > $@
.PRECIOUS: src/%.xml
src/%.xml: ../../../mcs/class/lib/%.dll $(CORCOMPARE)/CorCompare.exe
$(CORCOMPARE)/CorCompare.exe -x $@ $<
src/corlib.xml: ../../../mcs/class/lib/corlib_cmp.dll $(CORCOMPARE)/CorCompare.exe
$(CORCOMPARE)/CorCompare.exe -f corlib -ms mscorlib -x $@ $<
../class-status: ../class-status.in
cp -f $< $@
make-rss:
$(CSC) make-rss.cs -o
scp *.html primates:public_html/xxx
-103
View File
@@ -1,103 +0,0 @@
//
// Generates the Mono RSS feed
//
// Miguel de Icaza
//
using System;
using System.IO;
using System.Xml;
using RSS;
class X {
static RSS.RSS rss;
static Channel c;
static int item_count;
static void PopulateRSS (StreamReader input)
{
string s;
while ((s = input.ReadLine ()) != null){
if (s.StartsWith ("@item "))
break;
}
if (s == null || !s.StartsWith ("@item ")){
Console.WriteLine ("Could not find beginning of text to RSS");
return;
}
Item i = null;
string description = "";
do {
if (s.StartsWith ("@item ")){
if (item_count++ > 25)
break;
if (i != null){
i.Description = description;
description = "";
}
string title = s.Substring (6);
string link = "http://www.go-mono.com/index.html#";
foreach (char ch in title){
if (ch != ' ')
link += ch;
}
i = c.NewItem ();
i.Title = title;
i.Link = link;
} else {
description += "\n" + (s == "\n" ? "<p>" : s);
}
} while ((s = input.ReadLine ()) != null);
if (i != null){
i.Description = description;
}
}
static void MakeRSS (string input, string output)
{
rss = new RSS.RSS ();
c = rss.NewChannel ("Mono Project News", "http://www.go-mono.com");
c.Title = "Mono Project News";
c.Link = "http://www.go-mono.com";
c.Description =
"News from the Mono project: a portable implementation of the .NET Framework";
c.WebMaster = "[email protected]";
c.ManagingEditor = "[email protected]";
string t = File.GetLastWriteTime (input).ToString ("r");
c.PubDate = t;
c.LastBuildDate = t;
using (FileStream fs = new FileStream (input, FileMode.Open)){
using (StreamReader input_stream = new StreamReader (fs)){
PopulateRSS (input_stream);
}
}
rss.XmlDocument.Save (output);
}
static int Main (string [] args)
{
switch (args.Length){
case 0:
MakeRSS ("index", "index.rss");
break;
case 2:
MakeRSS (args [0], args [1]);
break;
default:
Console.WriteLine ("Usage is: mono-rss [input output.rss]");
return 1;
}
return 0;
}
}
+7 -21
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;
@@ -48,7 +50,7 @@ while (<COMMANDS>) {
open OUTPUT, ">" . $n || die "Can not create $n";
my $content = "";
open INPUT, "src/$command[3]" || die "Can not open $command[3]";
open INPUT, $command[3] || die "Can not open $command[3]";
while (<INPUT>) {
$content .= $_;
}
@@ -58,30 +60,14 @@ while (<COMMANDS>) {
my $temp;
my $tit;
my $title;
my $css;
my $script;
$tit = $command[1];
$css = $command[4];
$script = $command[5];
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;
}
}
-262
View File
@@ -1,262 +0,0 @@
//
// RSS.cs: Some utility classes to generate RSS feeds
//
// (C) 2002 Miguel de Icaza ([email protected])
//
//
using System;
using System.Xml;
using System.IO;
namespace RSS {
public class Item {
XmlDocument doc;
XmlNode item;
XmlText title, link, description;
public Item (XmlDocument doc, XmlNode item)
{
this.doc = doc;
this.item = item;
}
XmlText MakeTextElement (string name)
{
XmlNode node = doc.CreateElement (name);
XmlText text = doc.CreateTextNode ("");
item.AppendChild (node);
node.AppendChild (text);
return text;
}
public string Title {
get {
if (title == null)
return null;
return title.Value;
}
set {
if (title == null)
title = MakeTextElement ("title");
title.Value = value;
}
}
public string Link {
get {
if (link == null)
return null;
return link.Value;
}
set {
if (link == null)
link = MakeTextElement ("link");
link.Value = value;
}
}
public string Description {
get {
if (description == null)
return null;
return description.Value;
}
set {
if (description == null)
description = MakeTextElement ("description");
description.Value = value;
}
}
}
public class Channel {
XmlDocument doc;
XmlNode channel;
XmlText title, link, description, language, pubDate, lastBuildDate;
XmlText managingEditor, webMaster;
XmlText MakeTextElement (string name)
{
XmlNode node = doc.CreateElement (name);
XmlText text = doc.CreateTextNode ("");
channel.AppendChild (node);
node.AppendChild (text);
return text;
}
public Channel (XmlDocument doc, XmlNode node)
{
this.channel = node;
this.doc = doc;
title = MakeTextElement ("title");
link = MakeTextElement ("link");
description = MakeTextElement ("description");
}
public Item NewItem ()
{
XmlNode node = doc.CreateElement ("item");
Item item;
channel.AppendChild (node);
item = new Item (doc, node);
return item;
}
public string Title {
get {
return title.Value;
}
set {
title.Value = value;
}
}
public string Link {
get {
return link.Value;
}
set {
link.Value = value;
}
}
public string Description {
get {
return description.Value;
}
set {
description.Value = value;
}
}
#region Optional Values
public string ManagingEditor {
get {
if (managingEditor == null)
return null;
return managingEditor.Value;
}
set {
if (managingEditor == null)
managingEditor = MakeTextElement ("managingEditor");
managingEditor.Value = value;
}
}
public string WebMaster {
get {
if (webMaster == null)
return null;
return webMaster.Value;
}
set {
if (webMaster == null)
webMaster = MakeTextElement ("webMaster");
webMaster.Value = value;
}
}
public string PubDate {
get {
if (pubDate == null)
return null;
return pubDate.Value;
}
set {
if (pubDate == null)
pubDate = MakeTextElement ("pubDate");
pubDate.Value = value;
}
}
public string LastBuildDate {
get {
if (lastBuildDate == null)
return null;
return lastBuildDate.Value;
}
set {
if (lastBuildDate == null)
lastBuildDate = MakeTextElement ("lastBuildDate");
lastBuildDate.Value = value;
}
}
public string Language {
get {
if (language == null)
return null;
return language.Value;
}
set {
if (language == null)
language = MakeTextElement ("language");
language.Value = value;
}
}
#endregion
}
class RSS {
XmlDocument doc;
XmlNode rss;
const string rss_base =
"<?xml version=\"1.0\"?> <rss version=\"0.92\"></rss>";
public RSS ()
{
doc = new XmlDocument ();
doc.LoadXml (rss_base);
rss = doc.DocumentElement;
}
public Channel NewChannel (string title, string url)
{
XmlNode node = doc.CreateElement ("channel");
Channel c;
rss.AppendChild (node);
c = new Channel (doc, node);
return c;
}
public XmlDocument XmlDocument {
get {
return doc;
}
}
}
}
-1
View File
@@ -1 +0,0 @@
*.src
+31 -44
View File
@@ -1,4 +1,3 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>#TITLE#</title>
@@ -8,56 +7,46 @@
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">
<table cellpadding="0" cellspacing="0" border="0" width="100%">
<tr>
<td><img src="images/pixel.gif" alt=""></td><!-- left border -->
<td><img src="images/pixel.gif"></td><!-- left border -->
<td colspan="4">
<a href="http://www.go-mono.com"><img src="images/mono.gif"
alt="mono-logo" border="0"></a></td>
<td><img src="images/pixel.gif" alt=""></td><!-- right border -->
<a href="http://www.go-mono.com"><img src="images/mono.gif" border="0"></a></td>
<td><img src="images/pixel.gif"></td><!-- right border -->
</tr>
<tr>
<td><img src="images/pixel.gif" width="1" height="1" alt=""></td>
<td colspan="3" bgcolor="black"><img src="images/pixel.gif"
height="2" alt=""></td>
<td bgcolor="black"><img src="images/pixel.gif" width="1" alt=""></td>
<td><img src="images/pixel.gif" alt=""></td>
<td><img src="images/pixel.gif" width="1" height="1"></td>
<td colspan="3" bgcolor="black"><img src="images/pixel.gif" height="2"></td>
<td bgcolor="black"><img src="images/pixel.gif" width="1"></td>
<td><img src="images/pixel.gif"></td>
</tr>
<tr>
<td width="100"><img src="images/pixel.gif" alt=""></td>
<td width="100"><img src="images/pixel.gif"></td>
<td valign="top">
<table cellpadding="2" valign="top" cellspacing="0" border="0">
#MENU#
</table>
</td>
<td bgcolor="black" width="1"><img src="images/pixel.gif"
width="1" alt=""></td>
<td bgcolor="black" width="1"><img src="images/pixel.gif" width="1"></td>
<td bgcolor="white" align="left" width="80%" valign="top">
<table cellpadding="16">
<tr><td>
@@ -65,26 +54,24 @@
</td></tr>
</table>
</td>
<td bgcolor="black"><img src="images/pixel.gif" width="1" alt=""></td>
<td width="100"><img src="images/pixel.gif" alt=""></td>
<td bgcolor="black"><img src="images/pixel.gif" width="1"></td>
<td width="100"><img src="images/pixel.gif"></td>
</tr>
<tr>
<td colspan="2">
<img src="images/pixel.gif" alt=""></td>
<td colspan="2" bgcolor="black"><img src="images/pixel.gif"
height="1" alt=""></td>
<td bgcolor="black"><img src="images/pixel.gif" width="1" alt=""></td>
<td><img src="images/pixel.gif" alt=""></td>
<img src="images/pixel.gif"></td>
<td colspan="2" bgcolor="black"><img src="images/pixel.gif" height="1"></td>
<td bgcolor="black"><img src="images/pixel.gif" width="1"></td>
<td><img src="images/pixel.gif"></td>
</tr>
<tr>
<td colspan="2"></td>
<td colspan="2" align="center">
<a class="footnote" href="mailto:[email protected]">[email protected]</a>
</td>
<td colspan="2"></td>
<td colspan="2"></td>
<td colspan="2" align="center">
<a class="footnote" href="mailto: [email protected]">[email protected]</a>
</td>
<td colspan="2"></td>
</tr>
</tr>
</tr>
</table>
</body>
-90
View File
@@ -1,90 +0,0 @@
* System.Windows.Forms
System.Windows.Forms eventually will support multiple
toolkits. Ximian will be delivering a product that will allow
for System.Windows.Forms applications to integrate with GNOME
through Gtk and MacOS X using Cocoa.
There are no current plans to support embedded devices, but
Gtk/FrameBuffer is an option. If you have suggestions or
recommendations, please let us <a
href="mailto:[email protected]">let us know</a>
* Contributing
Currently Ximian developers are busy making our JIT engine
feature complete, and dealing with the low-level details of
the Mono runtime.
If you are interested in contributing, you can start stubbing
out classes and providing enumerations. That will help us
significantly when we start working on the actual bindings.
Christian Meyer is currently organizing this effort.
* System.Drawing
Using existing libraries to implement some of the functionality required
<ul>
* gdk-pixbuf is a generic image loader that loads an image
and leaves it into an RGB buffer. It hides all the details
about what image file format is being loaded.
* Libart is a general framework for rendering RGB/RGBA
buffers into RGB buffers and rendering postscript-like paths into
RGB/RGBA buffers.
</ul>
We want to use gdk-pixbuf as the image loader for the image
classes, and then we need operations to render that into the
windowing system (Gtk+, MacOS, etc). But notice how there is
very little dependnecies in Gdk-pixbuf on gtk, and libart has
none.
They are pretty independent from a windowing system
(gdk-pixbuf comes with some "helper" routines for rendering
data into a pixmap and to load pixmaps into RGB buffers).
A few things to keep in mind:
<ul>
* gdk-pixbuf can be used to load images for Gtk+,
MacOS X and Windows, it should be pretty portable,
although we might need in the future to back-port
some new features from Gtk head.
* Libart is probably only going to be used with X11,
as the MacOS X provides the same features in Quartz,
and Win32 *probably* has that in GDI+. If not, we
should use libart in Win32 as well (or for older
Windows systems).
</ul>
* Directory Layout
System.Drawing (assembly directory)
System.Drawing.Blah
Common code for "Blah"
Stubs for "Blah" to ease ports.
Gtk
System.Drawing.Blah.
Gtk ports of "System.Drawing.Blah"
MacOS
System.Drawing.Blah
MacOS ports of "System.Drawing.Blah"
Win32
System.Drawing.Blah
Win32 ports of "System.Drawing.Blah"
Then we use nant targets to include/exclude the right set of
files to create the assembly.
* Open questions:
I believe that the graphics contexts that are used to render
can accept either libart-like rendering operations and
X11-like rendering operations. This complicates matters, but
I am not sure. Someone needs to investigate this.
-2
View File
@@ -1,2 +0,0 @@
Makefile
Makefile.in
-3
View File
@@ -1,3 +0,0 @@
EXTRA_DIST = gc-issues jit-thoughts object-layout unmanaged-calls \
exceptions jit-trampolines stack-alignment embedded-api
-227
View File
@@ -1,227 +0,0 @@
Embedding the Mono runtime, preliminary version
Miguel de Icaza, Paolo Molaro.
This document describes how to embed the Mono runtime in your
application, and how to invoke CIL methods from C, and how to
invoke C code from CIL.
* Embedding the runtime.
Embedding the runtime consists of various steps:
* Compiling and linking the Mono runtime
* Initializing the Mono runtime
* Optionally expose C code to the C#/CIL universe.
These are discussed in detail next.
** Compiling and Linking
To embed the runtime, you have to link your code against the
Mono runtime libraries. To do this, you want to pass the
flags returned by pkg-config to your compiler:
pkg-config --cflags --libs mono
Like this:
gcc sample.c `pkg-config --cflags --libs mono`
You can separate the compilation flags from the linking flags, for
instance, you can use the following macros in your makefile:
CFLAGS=`pkg-config --cflags mono`
LDFLAGS=`pkg-config --libs mono`
** Initializing the Mono runtime
To initialize the runtime, call mono_jit_init, like this:
MonoDomain *domain;
domain = mono_jit_init ("domain-name");
That will return a MonoDomain where your code will be
executed. You can create multiple domains. Each domain is
isolated from the other domains and code in one domain will
not interfere with code in other domains. This is useful if
you want to host different applications in your program.
Then you can load an assembly containing code into the domain:
MonoAssembly *assembly;
assembly = mono_domain_assembly_open ("file.dll");
if (!assembly)
error ();
In the above example, the contents of `file.dll' will be
loaded into the domain. This only loads the code, but it will
not execute anything yet. You can replace `file.dll' with
another transport file, like `file.exe'
To start executing code, you must invoke a method in the
assembly, or if you have provided a static Main method (an
entry point), you can use the convenience function:
retval = mono_jit_exec (domain, assembly, argc - 1, argv + 1);
If you want to invoke a different method, look at the
`Invoking Methods in the CIL universe' section later on.
** Shutting down the runtime
To shutdown the Mono runtime, you have to clean up all the
domains that were created, use this function:
mono_jit_cleanup (domain);
* Exposing C code to the CIL universe
The Mono runtime provides two mechanisms to expose C code to
the CIL universe: internal calls and native C code. Internal
calls are tightly integrated with the runtime, and have the
least overhead, as they use the same data types that the
runtime uses.
The other option is to use the Platform Invoke (P/Invoke) to
call C code from the CIL universe, using the standard P/Invoke
mechanisms.
To register an internal call, use this call in the C code:
mono_add_internal_call ("Hello::Sample", sample);
Now, you need to declare this on the C# side:
using System;
using System.Runtime.CompilerServices;
class Hello {
[MethodImplAttribute(MethodImplOptions.InternalCall)]
extern static string Sample ();
}
Since this routine returns a string, here is the C definition:
static MonoString*
Sample ()
{
return mono_string_new (mono_domain_get (), "Hello!");
}
Notice that we have to return a `MonoString', and we use the
`mono_string_new' API call to obtain this from a string.
* Invoking Methods in the CIL universe
Calling a method in the CIL universe from C requires a number of steps:
* Obtaining the MonoMethod handle to the method.
* The method invocation.
** Obtaining a MonoMethod
To get a MonoMethod there are several ways.
You can get a MonoClass (the structure representing a type)
using:
MonoClass *
mono_class_from_name (MonoImage *image, const char* name_space, const char *name);
and then loop in the returned class method array until you get
the one you're looking for. There are examples of such
searches as static functions in several C files in
metadata/*.c: we need to expose one through the API and remove
the duplicates.
The other, simpler, way is to use the functions in
debug-helpers.h: there are examples of their use in monograph,
mint and the jit as well. You basically use a string
description of the method, like:
"System.Object:GetHashCode()"
and create a MonoMethodDesc out of it with:
MonoMethodDesc* mono_method_desc_new (const char *name, gboolean include_namespace);
You can then use:
MonoMethod* mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass);
MonoMethod* mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image);
to search for the method in a class or in an image. You would
tipically do this just once at the start of the program and
store the result for reuse somewhere.
** Invoking a Method
There are two functions to call a managed method:
MonoObject*
mono_runtime_invoke (MonoMethod *method, void *obj, void **params,
MonoObject **exc);
and
MonoObject*
mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
MonoObject **exc);
obj is the 'this' pointer, it should be NULL for static
methods, a MonoObject* for object instances and a pointer to
the value type for value types.
The params array contains the arguments to the method with the
same convention: MonoObject* pointers for object instances and
pointers to the value type otherwise. The _invoke_array
variant takes a C# object[] as the params argument (MonoArray
*params): in this case the value types are boxed inside the
respective reference representation.
From unmanaged code you'll usually use the
mono_runtime_invoke() variant.
Note that this function doesn't handle virtual methods for
you, it will exec the exact method you pass: we still need to
expose a function to lookup the derived class implementation
of a virtual method (there are examples of this in the code,
though).
You can pass NULL as the exc argument if you don't want to
catch exceptions, otherwise, *exc will be set to the exception
thrown, if any. if an exception is thrown, you can't use the
MonoObject* result from the function.
If the method returns a value type, it is boxed in an object
reference.
We have plans for providing an additional method that returns
an unmanaged->managed thunk like this:
void* mono_method_get_unmanaged_thunk (MonoMethod *method);
You'll be able to store the returned pointer in a function
pointer with the proper signature and call that directly from
C:
typedef gint32 (*GetHashCode) (MonoObject *obj);
GetHashCode func = mono_method_get_unmanaged_thunk (System_Object_GetHashCode_method);
gint32 hashvalue = func (myobject);
It may not be possible to manage exceptions in that case,
though. I need to think more about it.
* Samples
See the sample programs inmono/sample/embed for examples of
embedding the Mono runtime in your application.
+2 -18
View File
@@ -1,6 +1,3 @@
Author: Dietmar Maurer ([email protected])
(C) 2001 Ximian, Inc.
Exception implementation (jit):
===============================
@@ -11,15 +8,8 @@ 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->bp < mono_end_of_stack) {
/* unhandled exception */
abort ();
}
info = mono_jit_info_table_find (mono_jit_info_table, ctx->ip);
@@ -31,20 +21,14 @@ void handle_exception ((struct sigcontext *ctx, gpointer obj)
execute_all_finally_handler ();
// restore register, including IP and Frame pointer
ctx = restore_caller_saved_registers_from_ctx (ji, ctx);
restore_caller_saved_registers (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);
// not implemented
}
}
-31
View File
@@ -1,31 +0,0 @@
* GC issues you need to be careful about when hacking on the mono runtime.
mono currently uses the Boehm garbage collection library. This is a conservative
GC package: this means that the memory is searched for possible memory references
to chunks allocated with the GC. Not all the memory is searched, but only the memory
allocated with the GC itself (unless you use the 'atomic' variant of the allocation
routines), the stack and global variables. Also, if the last reference to an object
is stored in an area of themory that is not searched, the object may be freed resulting
in memory corruption ind segfaults.
In particular, memory allocated with system's malloc() is not searched, so you need to be
careful NOT to store object references in memory allocated with malloc() (unless you are sure
that the object reference will be live at the same time in some other area under the control
of the GC (on the stack or in a global variable, for example). Since g_malloc()
ultimately calls system malloc() the data structures in GLib are not safe to
use to store object references.
Occasionally, you'll need to store some object reference from C code: in this case,
you must make sure that the store location is searched by the GC. You can safely
use thread local storage areas, global variables, stack variables. If you need a more
complicated data structure, you can use a hash table: MonoGHashTable.
This hash table has the same interface as GHashTable from GLib, just stick the "mono_"
prefix in function calls and the "Mono" prefix in the hash table type name.
This hash table ensures that object references stored in it are tracked by the GC, as long
as the pointer to the hash is tracked itself.
Other data structures that are allocated with the GC and are safe to use to store pointers
to GC-allocated memory, are MonoDomain (keeps track of many domain specfic objects)
and MonoVTable (referenced by MonoDomain: keeps track of the static data of a type
since that can hold references to objects).
-59
View File
@@ -1,59 +0,0 @@
* How to map C# types for use in the C implementation of internal calls
C# type C type
char gunichar2
bool MonoBoolean
sbyte signed char
byte guchar
short gint16
ushort guint16
int gint32
uint guint32
long gint64
ulong guint64
IntPtr/UIntPtr gpointer
object MonoObject*
string MonoString*
For ref and out paramaters you'll use the corresponding pointer type.
Arrays of any type must be described with a MonoArray* and the elements
must be accessed with the mono_array_* macros.
Any other type that has a matching C structure representation, should use
a pointer to the struct instead of a generic MonoObject pointer.
Instance methods that are internal calls will receive as first argument
the instance object, so you must account for it in the C method signature:
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public extern override int GetHashCode ();
becaomes:
gint32 ves_icall_System_String_GetHashCode (MonoString *this);
* How to hook internal calls with the runtime
Once you require an internal call in corlib, you need to create a C
implementation for it and register it in a static table in metadata/icall.c.
Add an entry in the table like:
"System.String::GetHashCode", ves_icall_System_String_GetHashCode,
Note that you need to include the full namespace.name of the class.
If there are overloaded methods, you need also to specify the signature
of _all_ of them:
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public extern override void DoSomething ();
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public extern override void DoSomething (bool useful);
should be mapped with:
"Namespace.ClassName::DoSomething()", ves_icall_Namespace_ClassName_DoSomething,
"Namespace.ClassName::DoSomething(bool)", ves_icall_Namespace_ClassName_DoSomething_bool,
+47
View File
@@ -0,0 +1,47 @@
How to use the debug support in the jit.
----------------------------------------
You need to run mono inside gdb. The following command line swicthes
are available:
--stabs
--debug 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.
--debug 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 information
created with the --stabs option with the assembler:
as assemblyname-stabs.s -o assemblyname-stabs.o
Now, inside gdb, you can load the debug information with:
add-symbol-file assemblyname-stabs.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.
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).
-64
View File
@@ -1,64 +0,0 @@
Register Allocation
===================
The current JIT implementation uses a tree matcher to generate code. We use a
simple algorithm to allocate registers in trees, and limit the number of used
temporary register to 4 when evaluating trees. So we can use 2 registers for
global register allocation.
Register Allocation for Trees
=============================
We always evaluate trees from left to right. When there are no more registers
available we need to spill values to memory. Here is the simplified algorithm.
gboolean
tree_allocate_regs (tree, exclude_reg)
{
if (!tree_allocate_regs (tree->left, -1))
return FALSE;
if (!tree_allocate_regs (tree->right, -1)) {
tree->left->spilled == TRUE;
free_used_regs (tree->left);
if (!tree_allocate_regs (tree->right, tree->left->reg))
return FALSE;
}
free_used_regs (tree->left);
free_used_regs (tree->right);
/* try to allocate a register (reg != exclude_reg) */
if ((tree->reg = next_free_reg (exclude_reg)) != -1)
return TRUE;
return FALSE;
}
The emit routing actually spills the registers:
tree_emit (tree)
{
tree_emit (tree->left);
if (tree->left->spilled)
save_reg (tree->left->reg);
tree_emit (tree->right);
if (tree->left->spilled)
restore_reg (tree->left->reg);
emit_code (tree);
}
Global Register Allocation
==========================
TODO.
+62 -5
View File
@@ -11,6 +11,48 @@ We are designing a JIT compiler, so we have to consider two things:
The current approach is to keep the JITer as simple as possible, and thus as
fast as possible. The generated code quality will suffer from that.
Register allocation is first done inside the trees of the forest, and each
tree can use the full set of registers. We simply split a tree if we get out of
registers, for example the following tree:
add(R0)
/ \
/ \
a(R0) add(R1)
/ \
/ \
b(R1) add(R2)
/ \
/ \
c(R2) b(R3)
can be transformed to:
stloc(t1) add(R0)
| / \
| / \
add(R0) a(R0) add(R1)
/ \ / \
/ \ / \
c(R0) b(R1) b(R1) t1(R2)
Please notice that the split trees use less registers than the original
tree.
Triggering JIT compilation:
===========================
The current approach is to call functions indirectly. The address to call is
stored in the MonoMethod structure. For each method we create a trampoline
function. When called, this function does the JIT compilation and replaces the
trampoline with the compiled method address.
We should consider using the CACAO approach, they do not use a trampoline at
all.
Register Allocation:
====================
@@ -19,6 +61,15 @@ allocation. For example this is needed by call, which return the value always
in EAX on x86. The current implementation works without such system, due to
special forest generation.
X86 Register Allocation:
========================
We can use 8bit or 16bit registers on the x86. If we use that feature we have
more registers to allocate, which maybe prevents some register spills. We
currently ignore that ability and always allocate 32 bit registers, because I
think we would gain very little from that optimisation and it would complicate
the code.
Different Register Sets:
========================
@@ -35,10 +86,11 @@ call class methods for ALU operations like add or sub. Sure, this method will
be be a bit inefficient.
The more performant solution is to allocate two 32bit registers for each 64bit
value. We add a new non terminal to the monoburg grammar called "lreg". The
value. We add a new non terminal to the monoburg grammar called long_reg. The
register allocation routines takes care of this non terminal and allocates two
32 bit registers for them.
Forest generation:
==================
@@ -50,7 +102,7 @@ LDC.1 (5,1) [5,0]
STLOC.0 (5) [1,0]
STLOC.1 () [1,5]
A simple forest generation generates:
The current forest generation generates:
STLOC.0(LDC.1)
STLOC.1(LDLOC.0)
@@ -105,6 +157,14 @@ STLOC(ADD (LDLOC, LDLOC))
This is what lcc is doing, if I understood 12.8, page 342, 343?
Value Types:
============
The only CLI instructions which can handle value types are loads and stores,
either to local variable, to the stack or to array elements. Value types with a
size smaller than sizeof(int) are handled like any other basic type. For other
value types we load the base address and emit block copies to store them.
Possible Optimisations:
=======================
@@ -120,6 +180,3 @@ 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
-98
View File
@@ -1,98 +0,0 @@
=pod
=head1 Internal design document for the mono_handle_d
This document is designed to hold the design of the mono_handle_d and
not as an api reference.
=head2 Primary goal and purpose
The mono_handle_d is a process which takes care of the (de)allocation
of scratch shared memory and handles (of files, threads, mutexes,
sockets etc. see L<WapiHandleType>) and refcounts of the
filehandles. It is designed to be run by a user and to be fast, thus
minimal error checking on input is done and will most likely crash if
given a faulty package. No effort has been, or should be, made to have
the daemon talking to machine of different endianness/size of int.
=head2 How to start the daemon
To start the daemon you either run the mono_handle_d executable or try
to attach to the shared memory segment via L<_wapi_shm_attach> which
will start a daemon if one does not exist.
=head1 Internal details
The daemon works by opening a socket and listening to clients. These
clients send packages over the socket complying to L<struct
WapiHandleRequest>.
=head2 Possible requests
=over
=item WapiHandleRequest_New
Find a handle in the shared memory segment that is free and allocate
it to the specified type. To destroy use
L</WapiHandleRequest_Close>. A L<WapiHandleResponse> with
.type=WapiHandleResponseType_New will be sent back with .u.new.handle
set to the handle that was allocated. .u.new.type is the type that was
requested.
=item WapiHandleRequestType_Open
Increase the ref count of an already created handle. A
L<WapiHandleResponse> with .type=WapiHandleResponseType_Open will be sent
back with .u.new.handle set to the handle, .u.new.type is set to the
type of handle this is.
=item WapiHandleRequestType_Close
Decrease the ref count of an already created handle. A
L<WapiHandleResponse> with .type=WapiHandleResponseType_Close will be
sent back with .u.close.destroy set to TRUE if ref count for this
client reached 0.
=item WapiHandleRequestType_Scratch
Allocate a shared memory area of size .u.scratch.length in bytes. A
L<WapiHandleResponse> with .type=WapiHandleResponseType_Scratch will be
sent back with .u.scratch.idx set to the index into the shared
memory's scratch area where to memory begins. (works just like
malloc(3))
=item WapiHandleRequestType_Scratch
Deallocate a shared memory area, this must have been allocated before
deallocating. A L<WapiHandleResponse> with
.type=WapiHandleResponseType_ScratchFree will be sent back (works just
like free(3))
=back
=head1 Why a daemon
From an email:
Dennis: I just have one question about the daemon... Why does it
exist? Isn't it better performancewise to just protect the shared area
with a mutex when allocation a new handle/shared mem segment or
changing refcnt? It will however be a less resilient to clients that
crash (the deamon cleans up ref'd handles if socket closes)
Dick: It's precisely because with a mutex the shared memory segment
can be left in a locked state. Also, it's not so easy to clean up
shared memory without it (you can't just mark it deleted when creating
it, because you can't attach any more readers to the same segment
after that). I did some minimal performance testing, and I don't
think the daemon is particularly slow.
=head1 Authors
Documentaion: Dennis Haney
Implementation: Dick Porter
=cut
Loaded 100 of 4907 files, more files were not shown because too many files have changed in this diff. Show more