Compare commits

..
164 Commits
Author SHA1 Message Date
nobody b0784aa131 This commit was manufactured by cvs2svn to create tag 'MCS_0_4'.
svn path=/tags/MCS_0_4/mcs/; revision=171
2001-07-16 01:07:36 +00:00
Miguel de Icaza 405dc3ea6c Add System.XML
svn path=/trunk/mcs/; revision=170
2001-07-16 01:07:36 +00:00
Miguel de Icaza 39a57ed2e5 Add .cvsignore
svn path=/trunk/mono/; revision=169
2001-07-16 00:49:43 +00:00
Miguel de Icaza 57def253ae Build doc directory
svn path=/trunk/mono/; revision=168
2001-07-16 00:49:19 +00:00
Miguel de Icaza 3bc2a24a3a Flush
svn path=/trunk/mono/; revision=167
2001-07-16 00:46:46 +00:00
Miguel de Icaza 92f0a06788 Flush
svn path=/trunk/mono/; revision=166
2001-07-16 00:45:31 +00:00
Miguel de Icaza ba11592b2c John
svn path=/trunk/mono/; revision=165
2001-07-15 22:03:51 +00:00
Miguel de Icaza 0992611bf0 Add spaces
svn path=/trunk/mono/; revision=164
2001-07-15 21:57:26 +00:00
Joe Shaw 800c8c64cf Flush. Add comments about IList
svn path=/trunk/mcs/; revision=163
2001-07-15 20:45:16 +00:00
Joe Shaw b529037728 Added some info about System.Array
svn path=/trunk/mcs/; revision=162
2001-07-15 20:41:19 +00:00
Joe Shaw 7404b2e846 2001-07-15 Joe Shaw <[email protected]>
* configure.in: Don't create doc/Makefile as there's nothing there
	to make.

	* Makefile.am: Don't build the doc directory because there's no
	Makefile.am there.

svn path=/trunk/mono/; revision=161
2001-07-15 20:33:14 +00:00
Joe Shaw cfc2593d84 2001-07-15 Joe Shaw <[email protected]>
* autogen.sh: Call aclocal with the $ACLOCAL_FLAGS env var.

svn path=/trunk/mono/; revision=160
2001-07-15 20:30:07 +00:00
Miguel de Icaza a84f29dc6d Flush documentation changes, and update maintainers
svn path=/trunk/mono/; revision=159
2001-07-15 18:59:26 +00:00
Miguel de Icaza 2abd9a70e2 Flush documentation changes, and update maintainers
svn path=/trunk/mono/; revision=158
2001-07-15 18:57:59 +00:00
Paolo Molaro f462287294 Sun Jul 15 19:39:06 CEST 2001 Paolo Molaro <[email protected]>
* metadata.c, metadata.h: decode local vars in method header
	parse function. Change callers accordingly.

svn path=/trunk/mono/; revision=157
2001-07-15 17:41:25 +00:00
Paolo Molaro e0a57962b1 Sun Jul 15 17:50:23 CEST 2001 Paolo Molaro <[email protected]>
* Started changelog.
	* interp.c: use new mono_get_method () function to get the complete
	info on a method invocation: we support now method invocation with
	multiple (or zero) simple arguments and with or without a return value.
	Implement also a couple more opcodes.

svn path=/trunk/mono/; revision=156
2001-07-15 16:26:06 +00:00
Paolo Molaro ab9d0406da Fix typo and remove debug prints.
svn path=/trunk/mono/; revision=155
2001-07-15 16:25:17 +00:00
Paolo Molaro 8c1647dc82 Sun Jul 15 17:29:10 CEST 2001 Paolo Molaro <[email protected]>
* get.h,get.c: added some dis_stringify_object() functions:
	metadata decoding is now done in libmetadata. Still need to use
	them throughhout the code (and move other decode code to
	metadata). Fix also field decoding (band-aid until we load
	also referenced assemblies).
	* dis/main.c: start using the new routines.

svn path=/trunk/mono/; revision=154
2001-07-15 16:14:11 +00:00
Paolo Molaro c67de2d075 Sun Jul 15 17:40:47 CEST 2001 Paolo Molaro <[email protected]>
* metadata.h, cil-coff.h: protect against multiple inclusion.
	Added some new structures to hold information decoded from metadata:
	MonoType, MonoParam, MonoArray, MonoMethod, MonoMethodSignature
	and relevant decoding/free functions.
	* metadata.c: implement decoding functions. Add warning for out of bounds
	index in mono_metadata_locate(). Implement mono_get_method () to retreive
	all the info about a method signature and invocation. Remove check on
	uninitialized local var in parse_mh() and fix memory leak.

svn path=/trunk/mono/; revision=153
2001-07-15 16:13:54 +00:00
Sean MacIsaac a6ffb6c02a * String.cs: Spelling error of IComparable, object's
MemberwiseClone cannot be overridden.  Made indexer valid for now,
but not sure what to do about this in the long run.  Seems to be a
couple bugs in csc.exe having to do with multiple pointer defs in
the same statement, and returning subclasses of a class in the
return type of an interface function implementation.  Also moved
operators inside of class definition.

svn path=/trunk/mcs/; revision=152
2001-07-15 08:02:44 +00:00
Sean MacIsaac da54cf461f * IDictionary.cs: Clear was clear.
svn path=/trunk/mcs/; revision=151
2001-07-15 07:39:54 +00:00
Sean MacIsaac 9a5ade334f * makefile: added windows and unix targets.
svn path=/trunk/mcs/; revision=150
2001-07-15 05:46:41 +00:00
Sean MacIsaac 3dfc511a33 * StringCollection.cs: Added so that CodeDom.* would compile.
svn path=/trunk/mcs/; revision=149
2001-07-15 05:45:23 +00:00
Sean MacIsaac 1fe22719b1 * MemberAttributes.cs: Added so rest of classes would compile.
* FieldDirection.cs: Added so rest of classes would compile.

* CodeTypeMember.cs: Added so rest of classes would compile.

* CodeTypeDeclaration.cs: Added so rest of classes would compile.

* CodeObject.cs: Added so rest of classes would compile.

* CodeBinaryOperatorType.cs: Added so rest of classes would compile.

svn path=/trunk/mcs/; revision=148
2001-07-15 05:44:59 +00:00
Sean MacIsaac c0d11bde1d * CodeGenerator.cs: moved using statement out of namespace
declaration.

svn path=/trunk/mcs/; revision=147
2001-07-15 05:44:43 +00:00
Sean MacIsaac 6fb3de52cb makefile *.src easy compilation stuff.
svn path=/trunk/mcs/; revision=146
2001-07-15 04:57:07 +00:00
Sean MacIsaac 210c1115e9 Removing uneccessary files.
svn path=/trunk/mcs/; revision=145
2001-07-15 04:27:43 +00:00
Sean MacIsaac abb7a6759f Removing unnecessary files.
svn path=/trunk/mcs/; revision=144
2001-07-15 04:27:10 +00:00
Sean MacIsaac bf879a9795 Changes to the makefiles to allow cleaner builds.
svn path=/trunk/mcs/; revision=143
2001-07-15 04:21:27 +00:00
Jeffrey Stedfast 393b396ebf 2001-07-14 Jeffrey Stedfast <[email protected]>
* String.cs: A tom of compile fixes, although we still don't compile.

	* IConvertible.cs: The To*Int64() methods return *Int64's, not
	*Int32's. Also, it's ToDateTime() not ToDateType().

svn path=/trunk/mcs/; revision=142
2001-07-15 04:11:49 +00:00
Sean MacIsaac a6d6ebabe6 .cvsignore
svn path=/trunk/mcs/; revision=141
2001-07-15 03:37:52 +00:00
Miguel de Icaza 60df095c46 Flushety flush
svn path=/trunk/mcs/; revision=140
2001-07-15 01:02:13 +00:00
Sean MacIsaac 6702db9247 Removed cs-parser.cs, as this is generated by jay
svn path=/trunk/mcs/; revision=139
2001-07-14 23:34:24 +00:00
Sean MacIsaac d021bf6bad Added the jay directory, compiler should be okay now.
svn path=/trunk/mcs/; revision=138
2001-07-14 23:30:42 +00:00
Jeffrey Stedfast 96e6f83423 2001-07-14 Jeffrey Stedfast <[email protected]>
* String.cs: Apparently I needed to at least write stubs for the
	IConvertible interfaces. *sigh*

svn path=/trunk/mcs/; revision=137
2001-07-14 22:55:48 +00:00
Jeffrey Stedfast bf760518ef more logic fixes and some code simplification
svn path=/trunk/mcs/; revision=136
2001-07-14 21:07:13 +00:00
Jeffrey Stedfast fff7bcfca2 2001-07-14 Jeffrey Stedfast <[email protected]>
* String.cs: Many logic/other fixes and better usage of the
	features of c#
	(tolower): New convenience method to help condense code.
	(toupper): Another new helper method.
	(Compare): Use the new helper methods.
	(ToLower): use tolower().
	(ToUpper): use toupper().
	(LastIndexOfAny): Implemented.
	(BoyerMoore): New private helper method that implements a modified
	version of the Boyer-Moore search algorithm. Noothing uses it yet
	as I'm not 100% sure it even works properly with unicode strings
	not to mention it uses a huge lookup-table :-)
	(Split): Implemented.

svn path=/trunk/mcs/; revision=135
2001-07-14 19:22:43 +00:00
Miguel de Icaza 7e002902d5 further web page loving
svn path=/trunk/mono/; revision=134
2001-07-14 19:04:58 +00:00
Miguel de Icaza feef427cdf Update authors
svn path=/trunk/mcs/; revision=133
2001-07-14 18:58:53 +00:00
Miguel de Icaza 9b614b0cee Done!
svn path=/trunk/mono/; revision=131
2001-07-14 18:52:08 +00:00
Miguel de Icaza 1c98a14e94 Fix compilation issue, bump version to 0.3
svn path=/trunk/mono/; revision=130
2001-07-14 18:33:59 +00:00
Miguel de Icaza be0f108da0 Flushety
svn path=/trunk/mono/; revision=129
2001-07-14 18:27:50 +00:00
Jeffrey Stedfast 13b5cdf600 2001-07-13 Jeffrey Stedfast <[email protected]>
* TODO: Added things that need to be finished in System.String

	* String.cs: New source file implementing the System.String class

svn path=/trunk/mcs/; revision=128
2001-07-14 02:29:15 +00:00
Miguel de Icaza 16f05aed1d Fix to compile
svn path=/trunk/mcs/; revision=127
2001-07-13 23:19:19 +00:00
Miguel de Icaza bef83794c8 oops
svn path=/trunk/mcs/; revision=126
2001-07-13 23:10:45 +00:00
Miguel de Icaza 0d8874def6 2001-07-13 Simon Cozens <[email protected]>
* cs-parser.jay (rank_specifier): Remove a conflict by reordering
	the

	(unary_expression): Expand pre_increment_expression and
	post_decrement_expression to reduce a shift/reduce.

svn path=/trunk/mcs/; revision=125
2001-07-13 22:52:34 +00:00
Sean MacIsaac 7fc6d7d59d Fixed all sorts of compiler errors.
svn path=/trunk/mcs/; revision=124
2001-07-13 22:20:51 +00:00
Miguel de Icaza e904d2e669 Flush
svn path=/trunk/mono/; revision=123
2001-07-13 18:47:29 +00:00
Miguel de Icaza 134bd1a356 2001-07-13 Miguel de Icaza <[email protected]>
* All files: Renamespace things to System.

svn path=/trunk/mcs/; revision=122
2001-07-13 05:05:36 +00:00
Miguel de Icaza c99279c286 2001-07-13 Miguel de Icaza <[email protected]>
* All files: Renamespace things to System.

svn path=/trunk/mcs/; revision=121
2001-07-13 05:04:57 +00:00
Miguel de Icaza 4c4489afd7 Add StringBuilder
svn path=/trunk/mono/; revision=120
2001-07-13 04:53:58 +00:00
Miguel de Icaza a7347925bc Replace dude
svn path=/trunk/mono/; revision=119
2001-07-13 04:52:50 +00:00
Miguel de Icaza 753b849c64 Add .cvsignore
svn path=/trunk/mono/; revision=118
2001-07-13 04:51:48 +00:00
Miguel de Icaza 87a3e5cc91 2001-07-12 Miguel de Icaza <[email protected]>
* metadata.h: More macros.

	* tokentype.h: New file.

svn path=/trunk/mono/; revision=117
2001-07-13 04:51:38 +00:00
Miguel de Icaza dbd8f3fba3 2001-07-13 Miguel de Icaza <[email protected]>
* get.c (get_method): GOOD. Implemented this other bad boy.

2001-07-12  Miguel de Icaza  <[email protected]>

	* get.c (get_token_type): Implement TOKEN_TYPE_TYPE_SPEC.
	(get_typespec): Implement.
	(get_typedef_or_ref): Use get_typespec.

	* dis-cil.c (dissasemble_cil): Implement InlineField
	(dissasemble_cil): Implement InlineTok.

	* get.c (get_token, get_field): Implemented.  Worked around lame
	tables in the spec.

svn path=/trunk/mono/; revision=116
2001-07-13 04:51:06 +00:00
Miguel de Icaza 7d573efc35 Add Stylesheet
svn path=/trunk/mono/; revision=115
2001-07-13 01:04:23 +00:00
Miguel de Icaza b717b59aa6 Add author information
svn path=/trunk/mono/; revision=114
2001-07-13 01:03:02 +00:00
Miguel de Icaza a05bb67043 fixety fix
svn path=/trunk/mono/; revision=113
2001-07-13 00:54:37 +00:00
cheridy a78aa4d06e removed /mono subdir as home link, replaced with /
svn path=/trunk/mono/; revision=112
2001-07-13 00:49:57 +00:00
cheridy 65527b12de removed monkeybutton and ximian branding
svn path=/trunk/mono/; revision=111
2001-07-13 00:43:16 +00:00
Miguel de Icaza 6f3fae0c17 more updates
svn path=/trunk/mono/; revision=110
2001-07-13 00:30:42 +00:00
cheridy 8723f67783 added webmaster address and accompanying style/table formatting
svn path=/trunk/mono/; revision=109
2001-07-13 00:07:29 +00:00
Miguel de Icaza f19fbdbf57 Flushage
svn path=/trunk/mono/; revision=108
2001-07-13 00:07:25 +00:00
Miguel de Icaza 18af4a09c1 :Flush
svn path=/trunk/mono/; revision=107
2001-07-13 00:05:42 +00:00
Miguel de Icaza c9422522e9 More
svn path=/trunk/mono/; revision=106
2001-07-13 00:01:06 +00:00
Miguel de Icaza ce8a3a0f64 Finish passport document
svn path=/trunk/mono/; revision=105
2001-07-12 23:56:51 +00:00
Joe Shaw 90ef332cd6 2001-07-12 Joe Shaw <[email protected]>
* Array.cs: Fix backwards parameters to Array.SetValue() throughout.
	(BinarySearch): Fix backward logic surrounding whether to
	call value.CompareTo or comparer.Compare.
	(LastIndexOf): Stop being stupid. I am so not used to strongly
	bounded arrays...
	(Sort): Implement a quicksort.

svn path=/trunk/mcs/; revision=104
2001-07-12 23:50:17 +00:00
cheridy 4ca231c005 added mention of doc/README for those interested in editing website
svn path=/trunk/mono/; revision=103
2001-07-12 23:41:18 +00:00
cheridy 9cacf09b7e info about docs, howto edit website content/appearance (here instead of in /web because content lives up on this level)
svn path=/trunk/mono/; revision=102
2001-07-12 23:39:14 +00:00
Miguel de Icaza c844124d37 Flush
svn path=/trunk/mono/; revision=101
2001-07-12 21:42:01 +00:00
Miguel de Icaza 5f3cf20c99 More docs for the web site
svn path=/trunk/mono/; revision=100
2001-07-12 21:40:42 +00:00
Paolo Molaro 4d1415ac0b The interpreter.
svn path=/trunk/mono/; revision=99
2001-07-12 21:31:37 +00:00
Miguel de Icaza 5b9ac905de 2001-07-12 Marcin Szczepanski <[email protected]>
* StringBuilder.cs: Implemented.

	The only methods left unimplemented are the AppendFormat( ... )
	ones just because it's probably better to wait until some of the
	Format related classes are implemented.  I've put that as a TODO
	comment at the top and created the methods with a "nop" body.

svn path=/trunk/mcs/; revision=98
2001-07-12 19:15:38 +00:00
Joe Shaw e2a54347cd 2001-07-11 Joe Shaw <[email protected]>
* Array.cs: Change all instances of trying to access an array with
	the index operator to calls to GetValue and SetValue, and add
	InternalGetValue and InternalSetValue which are internal calls into
	the runtime. Ew.

svn path=/trunk/mcs/; revision=97
2001-07-11 21:50:45 +00:00
Miguel de Icaza 7923199f14 *** empty log message ***
svn path=/trunk/mcs/; revision=96
2001-07-11 20:42:43 +00:00
Paolo Molaro c9b0722ff5 Wed Jul 11 18:52:15 CEST 2001 Paolo Molaro <[email protected]>
* dis-cil.c: output real name of local var.
	* dump.c: output more info about fields (flags and type). Properly decode
	Property signatures. Decode also method table.
	* main.c: Fix local variable info. Hopefully fix field and property list.

svn path=/trunk/mono/; revision=95
2001-07-11 17:03:57 +00:00
Paolo Molaro bbc981c763 Wed Jul 11 18:50:12 CEST 2001 Paolo Molaro <[email protected]>
* cil-opcodes.xml: change duplicate unused entry.

svn path=/trunk/mono/; revision=94
2001-07-11 16:51:26 +00:00
Miguel de Icaza 58b09f265b Code style
svn path=/trunk/mono/; revision=93
2001-07-11 15:21:28 +00:00
Miguel de Icaza 16e3d27af5 Flush more FAQ
svn path=/trunk/mono/; revision=92
2001-07-11 15:08:21 +00:00
Paolo Molaro 97ddf06aca Wed Jul 11 00:36:36 CEST 2001 Paolo Molaro <[email protected]>
* status/*: scripts and data to create statistics about the
	class library status.

svn path=/trunk/mono/; revision=91
2001-07-10 22:38:54 +00:00
Joe Shaw 7bba496b84 2001-07-10 Joe Shaw <[email protected]>
* Array.cs: Implemented everything but Sort().

svn path=/trunk/mcs/; revision=90
2001-07-10 22:00:22 +00:00
Jeffrey Stedfast b7b6bb8acb 2001-07-09 Jeffrey Stedfast <[email protected]>
* Object.cs (Object::Equals): Object variable name is `o'.

svn path=/trunk/mcs/; revision=89
2001-07-10 14:43:56 +00:00
Alex Graveley 755c5801c1 2001-07-09 Alex Graveley <[email protected]>
* doc/makefile (clean): Add clean target.
	* doc/web/makefile (clean): Ditto.

svn path=/trunk/mono/; revision=88
2001-07-10 03:18:39 +00:00
Alex Graveley baa7349309 This doesn't belong.
svn path=/trunk/mono/; revision=87
2001-07-10 03:06:29 +00:00
Alex Graveley a5285dcf24 2001-07-09 Alex Graveley <[email protected]>
* doc/makefile (all-docs): Fix typo.

svn path=/trunk/mono/; revision=86
2001-07-10 03:05:24 +00:00
Miguel de Icaza c894cb6c02 More FAQ
svn path=/trunk/mono/; revision=85
2001-07-10 00:56:54 +00:00
Miguel de Icaza 5b51743061 More FAQ
svn path=/trunk/mono/; revision=84
2001-07-10 00:54:07 +00:00
Miguel de Icaza 621c73c413 Flush
svn path=/trunk/mono/; revision=83
2001-07-10 00:12:31 +00:00
Miguel de Icaza bcb9869445 More docs
svn path=/trunk/mono/; revision=82
2001-07-09 23:43:18 +00:00
Miguel de Icaza 54efb994f5 More faqs
svn path=/trunk/mono/; revision=81
2001-07-09 22:56:59 +00:00
Miguel de Icaza dd9ff4ef68 Add more questions
svn path=/trunk/mono/; revision=80
2001-07-09 21:59:29 +00:00
Miguel de Icaza 2943ad1c68 More flush flush
svn path=/trunk/mono/; revision=79
2001-07-09 20:52:14 +00:00
Miguel de Icaza ee93e49101 MOre faqs
svn path=/trunk/mono/; revision=78
2001-07-09 20:31:37 +00:00
Miguel de Icaza ca7a32387b Flush
svn path=/trunk/mono/; revision=77
2001-07-09 18:41:53 +00:00
Tuomas Kuosmanen 120ca25443 Some fix0ring to make it not totally suck on netscape..
/tigert

svn path=/trunk/mono/; revision=76
2001-07-09 17:20:47 +00:00
Paolo Molaro b2de01dca8 Mon Jul 9 16:39:41 CEST 2001 Paolo Molaro <[email protected]>
* dump.c: write stuff to output, not stderr. Give more info for properties.
	* dump.c,dump.h,main.c: implement dump_table_event(), dump_table_file(),
	dump_table_moduleref().
	* get.c: first attempt to decode string constants, need to find if and where
	this is actually specified.

svn path=/trunk/mono/; revision=75
2001-07-09 14:44:56 +00:00
xkahn 82c52f966c Fixed a typo in a link. (Forgot "<a ".)
svn path=/trunk/mono/; revision=74
2001-07-09 05:23:55 +00:00
Miguel de Icaza 9dc433169c I give up
svn path=/trunk/mono/; revision=73
2001-07-09 04:53:54 +00:00
Miguel de Icaza 7ac4448936 Fix
svn path=/trunk/mono/; revision=72
2001-07-09 04:28:11 +00:00
Miguel de Icaza 502f70b1e8 More flush
svn path=/trunk/mono/; revision=71
2001-07-09 02:31:17 +00:00
Miguel de Icaza afb8ad5494 More flushing
svn path=/trunk/mono/; revision=70
2001-07-09 02:25:24 +00:00
Miguel de Icaza 76d2890a78 Flushety flush
svn path=/trunk/mono/; revision=69
2001-07-09 01:44:52 +00:00
Miguel de Icaza 3011d1514a Flush
svn path=/trunk/mono/; revision=68
2001-07-09 01:41:06 +00:00
Aaron Weber 25b5d7a7ff 2001-07-07 Aaron Weber <[email protected]>
* doc/thanks: style, grammar. (FIXME: "a to read"? clarify)
	* doc/testing style, grammar.
	* doc/status: same.
	* doc/runtime: same.
	* doc/resources: same.
	* doc/rationale: same.
	* doc/ideas: same.
	* doc/gcc-frontend: same. (FIXME: clarify)
	* doc/faq: same. (FIXME: merge w/cheridy's version)
	* doc/documentation: same.
	* doc/class-library: same.
	* doc/index: same.

svn path=/trunk/mono/; revision=67
2001-07-07 22:23:21 +00:00
Miguel de Icaza 4ba499dd31 Hackety hack
svn path=/trunk/mono/; revision=66
2001-07-07 22:19:09 +00:00
Paolo Molaro 5be19b0b75 Fri Jul 6 19:49:21 CEST 2001 Paolo Molaro <[email protected]>
* dump.c,dump.h: implement dump_table_property().
	* main.c: implement local variable info disassembling.
	Annotate entrypoint method. Remove memory leak in
	parse_method_signature ().

svn path=/trunk/mono/; revision=65
2001-07-07 10:29:16 +00:00
Miguel de Icaza 65d237b06c Further flushage
svn path=/trunk/mono/; revision=64
2001-07-06 23:30:37 +00:00
Joe Shaw 1377915cbe 2001-07-06 Joe Shaw <[email protected]>
* Int16.cs, Int32.cs, Int64.cs, UInt16.cs, UInt32.cs, UInt64.cs:
	Implement the IComparable and IFormattable interfaces. Fix a
	typo (publig -> public)

	* ApplicationException.cs, ArgumentException.cs,
	ArgumentNullException.cs, ArgumentOutOfRangeException.cs,
	ArtithmeticException.cs, ArrayTypeMismatchException.cs,
	DivideByZeroException.cs, DuplicateWaitObjectException.cs,
	ExecutionEngineException.cs, FormatException.cs,
	IndexOutOfRangeException.cs, InvalidCastException.cs,
	InvalidOperationException.cs, InvalidProgramException.cs,
	MulticateNotSupportedException.cs, NotFiniteNumberException.cs,
	NotSupportedException.cs, NullReferenceException.cs,
	OutOfMemoryException.cs, OverflowException.cs, RankException.cs,
	StackOverflowException.cs, SystemException.cs,
	TypeInitializationException.cs: Added all of the exceptions
	specified by the language spec. Mmmm... bloat.

svn path=/trunk/mcs/; revision=63
2001-07-06 22:58:09 +00:00
Joe Shaw 4268f0f50f 2001-07-06 Joe Shaw <[email protected]>
* UnicodeCategory.cs: Added.

svn path=/trunk/mcs/; revision=62
2001-07-06 22:57:41 +00:00
Miguel de Icaza b2d20162e4 Flushage
svn path=/trunk/mono/; revision=61
2001-07-06 22:50:26 +00:00
Miguel de Icaza d7c95a0a26 More flushage
svn path=/trunk/mono/; revision=60
2001-07-06 19:49:55 +00:00
Miguel de Icaza 25f95f44fc More files
svn path=/trunk/mcs/; revision=59
2001-07-06 15:48:55 +00:00
Paolo Molaro 71dd46fc12 Fri Jul 6 11:30:53 CEST 2001 Paolo Molaro <[email protected]>
* assembly.c: added a consistency check and initialize
	some structures with g_new0().
	* metadata.c: fixed a couple more bugs in table size computation
	and add other checks for out-of bound access to metadata.

svn path=/trunk/mono/; revision=58
2001-07-06 09:33:48 +00:00
Miguel de Icaza 473bcdddac More flushage
svn path=/trunk/mono/; revision=57
2001-07-06 01:55:46 +00:00
Miguel de Icaza 6e15e0374e Flushety flush
svn path=/trunk/mono/; revision=56
2001-07-06 01:48:56 +00:00
Miguel de Icaza 0d8c271277 Work on the web site
svn path=/trunk/mono/; revision=55
2001-07-06 01:11:07 +00:00
Miguel de Icaza 3d6ecf4066 Update FAQ
svn path=/trunk/mono/; revision=54
2001-07-06 00:22:40 +00:00
Vladimir Vukicevic 5a8951e8cf * ArrayList.cs: initial checkin and implementation
* ICollection.cs, IComprarer.cs, IDictionary.cs,
  IDictionaryEnumerator.cs, IEnumerable.cs, IHashCodeProvider.cs,
  IList.cs: initial checkin

svn path=/trunk/mcs/; revision=53
2001-07-05 21:46:48 +00:00
Paolo Molaro 920ab84779 Thu Jul 5 22:34:21 CEST 2001 Paolo Molaro <[email protected]>
* metatada.c: fix bugs computing table sizes. Spew a
	warning when index in string heap is out of bounds.

svn path=/trunk/mono/; revision=52
2001-07-05 20:36:13 +00:00
Miguel de Icaza 773162244e More work, Dump more tables, Documentation Update
svn path=/trunk/mono/; revision=51
2001-07-04 23:41:47 +00:00
Miguel de Icaza b9b369acf3 More documentation
svn path=/trunk/mono/; revision=50
2001-07-03 23:51:07 +00:00
Paolo Molaro 204210f834 Mon Jul 2 15:31:31 CEST 2001 Paolo Molaro <[email protected]>
* cil-opcodes.xml: use a more proper XML format (single root tag).
	* make-opcodes-def.pl: use XML::Parser, remove debugging print that
	broke compilation, corrected opcode byte len.

Tue,  3 Jul 2001 18:32:10 +0200 Paolo Molaro <[email protected]>

	* main.c: return on failure.

Tue Jul  3 18:33:32 CEST 2001 Paolo Molaro <[email protected]>

	* assembly.c: g_free(ii->cli_sections) (and avoid double free of
	cli_section_tables).

lupus - who'd like better a toplevel ChangeLog

svn path=/trunk/mono/; revision=49
2001-07-03 16:39:12 +00:00
Miguel de Icaza 5b7ac1ccdd Doc Doc
svn path=/trunk/mono/; revision=48
2001-07-02 05:04:06 +00:00
Miguel de Icaza 0bf65263f7 2001-07-02 Miguel de Icaza <[email protected]>
* dis-cil.c (get_encoded_user_string): Return a string from the
	#US heap. o

	* get.c (get_blob_encoded_size): Implement 23.1.4 decoding.

svn path=/trunk/mono/; revision=47
2001-07-02 05:03:40 +00:00
Miguel de Icaza 65225b88cc Some more docs
svn path=/trunk/mono/; revision=46
2001-07-02 04:19:26 +00:00
Miguel de Icaza 3c8a3d1b06 Implement code disassembler.
svn path=/trunk/mono/; revision=45
2001-07-02 04:19:12 +00:00
Miguel de Icaza e04016adac Add TODO + ChangeLog
svn path=/trunk/mono/; revision=44
2001-07-02 02:58:16 +00:00
Miguel de Icaza 3be6fe1b03 Add opcodes XML file
svn path=/trunk/mono/; revision=43
2001-07-02 02:56:44 +00:00
Miguel de Icaza b36357e896 Add methodheader.h, fix Makefile.am. Thanks to Alex
svn path=/trunk/mono/; revision=42
2001-06-29 14:06:16 +00:00
Miguel de Icaza eb6fb07489 Method header parsing
svn path=/trunk/mono/; revision=41
2001-06-28 05:04:00 +00:00
Miguel de Icaza f10919de96 2001-06-27 Miguel de Icaza <[email protected]>
* main.c: Split code.

svn path=/trunk/mono/; revision=40
2001-06-27 17:29:01 +00:00
Miguel de Icaza a6fd721478 Start work on methods, argument methods
svn path=/trunk/mono/; revision=39
2001-06-27 05:16:51 +00:00
Miguel de Icaza ee38e09230 PropertyAttributes, ParameterAttributes, MethodSemantics, MethodAttributes
svn path=/trunk/mono/; revision=38
2001-06-26 22:18:04 +00:00
nick 50046bca16 all stubbed out
svn path=/trunk/mcs/; revision=37
2001-06-26 21:09:02 +00:00
Miguel de Icaza 96202e2729 Some more classes
svn path=/trunk/mcs/; revision=36
2001-06-26 19:27:40 +00:00
Sean MacIsaac 6b52f46149 * UnicodeEncoding.cs: Members added so that a clean compile is
possible.

* ASCIIEncoding.cs: Members added so that a clean compile is
possible.

* UTF7Encoding.cs: Members added so that a clean compile is
possible.

* UTF8Encoding.cs: Members added so that a clean compile is
possible.

* Encoding.cs: All public members included.  Most members
unimplemented.

svn path=/trunk/mcs/; revision=35
2001-06-26 14:19:40 +00:00
Miguel de Icaza f2f2beb463 Fix mismatch between Beta2/ECMA specs. Beautiful progress made
svn path=/trunk/mono/; revision=34
2001-06-26 06:33:21 +00:00
Miguel de Icaza fb90b4929c Add util.c util.h
svn path=/trunk/mono/; revision=33
2001-06-25 19:10:22 +00:00
Miguel de Icaza 3094b32e9d Weekend work
svn path=/trunk/mono/; revision=32
2001-06-25 17:22:30 +00:00
Miguel de Icaza 3de382ae0c More
svn path=/trunk/mcs/; revision=31
2001-06-22 21:52:00 +00:00
Miguel de Icaza f9a34404ea Add Love
svn path=/trunk/mcs/; revision=30
2001-06-22 21:39:44 +00:00
Miguel de Icaza 5cf1344d16 Add Exception and Version
svn path=/trunk/mcs/; revision=29
2001-06-22 21:35:23 +00:00
Miguel de Icaza 995519a513 Further details
svn path=/trunk/mcs/; revision=28
2001-06-22 21:18:06 +00:00
Miguel de Icaza 64b3b484ac Document layout
svn path=/trunk/mcs/; revision=27
2001-06-22 21:07:15 +00:00
Miguel de Icaza 14ed085f94 Add some interfaces
svn path=/trunk/mcs/; revision=26
2001-06-22 20:53:16 +00:00
Miguel de Icaza fe9fb1dd93 Lots of more work on the disassembler and supporting runtime
svn path=/trunk/mono/; revision=25
2001-06-22 19:46:13 +00:00
Miguel de Icaza dc79f25c40 2001-06-21 Miguel de Icaza <[email protected]>
* mono/metadata/assembly.c (mono_assembly_ensure_section_idx,
	mono_assembly_ensure_section): Section loading code.
	(load_section_tables): Load the sections.

svn path=/trunk/mono/; revision=24
2001-06-22 01:07:08 +00:00
Miguel de Icaza 983d92c25f Tools and Documentation documents
svn path=/trunk/mono/; revision=23
2001-06-21 23:43:52 +00:00
Miguel de Icaza 4198d71a3f Mention tracing garbage collector
svn path=/trunk/mono/; revision=22
2001-06-21 23:32:19 +00:00
Miguel de Icaza 28074f5a04 2001-06-21 Miguel de Icaza <[email protected]>
* mono/metadata/metadata.c (mono_metadata_locate_token,
	mono_metadata_locate): Functions to locate the information
	definition given a token or a table and an index.
	(mono_metadata_compute_table_bases): New.
	(compute_size): New function to compute the sizes of the various
	tables.

	* mono/metadata/metadata.h: Finish listing the different index
	types.

	* mono/metadata/pedump.c: Improve to dump new information.

svn path=/trunk/mono/; revision=21
2001-06-21 06:45:27 +00:00
Miguel de Icaza 848b7aa0f5 Add CodeDom implementation
svn path=/trunk/mcs/; revision=20
2001-06-21 05:17:07 +00:00
Miguel de Icaza aceaacc0ab Further flushage
svn path=/trunk/mono/; revision=19
2001-06-21 03:42:57 +00:00
Miguel de Icaza 854d04f65c Flush
svn path=/trunk/mono/; revision=18
2001-06-21 00:23:12 +00:00
Miguel de Icaza df2b2b9f32 Add .cvsignores
svn path=/trunk/mono/; revision=17
2001-06-21 00:22:37 +00:00
Miguel de Icaza 0f10ad8249 Flush
svn path=/trunk/mono/; revision=16
2001-06-20 04:39:52 +00:00
Miguel de Icaza 6049b85acc Add docs
svn path=/trunk/mono/; revision=15
2001-06-19 23:08:44 +00:00
Miguel de Icaza 2df9c2fb52 2001-06-19 Miguel de Icaza <[email protected]>
* Adjustments for Beta2.

svn path=/trunk/mcs/; revision=14
2001-06-19 16:01:14 +00:00
Miguel de Icaza 184e5b1172 2001-06-19 Miguel de Icaza <[email protected]>
* mono/metadata/metadata.c: Entered all the tables matching
	Beta2.

	* mono/metadata/assembly.c (load_metadata_ptrs): Fix for Beta2

svn path=/trunk/mono/; revision=13
2001-06-19 15:59:53 +00:00
Miguel de Icaza 3ba10d5488 Add Autogen.sh
svn path=/trunk/mono/; revision=12
2001-06-19 06:00:06 +00:00
Miguel de Icaza 0fae05ddc8 Initial revision
svn path=/trunk/mono/; revision=9
2001-06-19 03:37:46 +00:00
Miguel de Icaza 0273a2dd78 System.Net beginning
svn path=/trunk/mcs/; revision=8
2001-06-16 04:28:28 +00:00
Miguel de Icaza 2680ce3385 2001-06-13 Miguel de Icaza <[email protected]>
* decl.cs: Added `Define' abstract method.
	(InTransit): new property, used to catch recursive definitions.

	* interface.cs: Implement `Define'.

	* modifiers.cs: Map Modifiers.constants to
	System.Reflection.TypeAttribute flags.

	* class.cs: Keep track of types and user-defined types.
	(BuilderInit): New method for creating an assembly
	(ResolveType): New function to launch the resolution process, only
	used by interfaces for now.

	* cs-parser.jay: Keep track of Classes, Structs and Interfaces
	that are inserted into the name space.

svn path=/trunk/mcs/; revision=7
2001-06-13 23:52:08 +00:00
Miguel de Icaza 8ed037b794 Add test case for cs0114
svn path=/trunk/mcs/; revision=6
2001-06-13 23:29:34 +00:00
Miguel de Icaza dc0764172a Added README and AUTHORS
svn path=/trunk/mcs/; revision=5
2001-06-08 18:48:20 +00:00
387 changed files with 34577 additions and 5615 deletions

No files matched your search

+11
View File
@@ -0,0 +1,11 @@
config.h
Makefile
config.cache
stamp-h.in
config.status
aclocal.m4
configure
stamp-h
libtool
Makefile.in
config.log
+1
View File
@@ -0,0 +1 @@
Miguel de Icaza ([email protected])
+36
View File
@@ -0,0 +1,36 @@
2001-07-15 Joe Shaw <[email protected]>
* configure.in: Don't create doc/Makefile as there's nothing there
to make.
* Makefile.am: Don't build the doc directory because there's no
Makefile.am there.
* autogen.sh: Call aclocal with the $ACLOCAL_FLAGS env var.
2001-07-15 Miguel de Icaza <[email protected]>
* doc/class-library (A): Updated FAQ with question on error 1595.
2001-07-14 Miguel de Icaza <[email protected]>
* doc/index:
Wed Jul 11 00:36:36 CEST 2001 Paolo Molaro <[email protected]>
* status/*: scripts and data to create statistics about the
class library status.
2001-07-09 Alex Graveley <[email protected]>
* doc/makefile (clean): Add clean target.
* doc/web/makefile (clean): Ditto.
2001-07-09 Alex Graveley <[email protected]>
* doc/makefile (all-docs): Fix typo.
2001-05-30 Miguel de Icaza <[email protected]>
* NEWS:
+1
View File
@@ -0,0 +1 @@
SUBDIRS = mono doc
+13
View File
@@ -0,0 +1,13 @@
2001-07-12 Miguel de Icaza <[email protected]>
New XSLT file from Sergey Chaban for CIL opcodes
Paolo got the beginning of an interpreter in.
Further work on the dissasembler.
Fix various parts of the metadata library
2001-05-30 Miguel de Icaza <[email protected]>
Project started
+8
View File
@@ -0,0 +1,8 @@
This is MonoNet.
Ximian's portable implementation of .NET
----------
To edit the go-mono website, see doc/README.
Executable
+6
View File
@@ -0,0 +1,6 @@
libtoolize --automake
automake -a
autoheader
aclocal $ACLOCAL_FLAGS
autoconf
./configure $*
+37
View File
@@ -0,0 +1,37 @@
AC_INIT(README)
AM_CONFIG_HEADER(config.h)
AM_INIT_AUTOMAKE(mono, 0.3)
AM_MAINTAINER_MODE
AC_PROG_CC
AM_PROG_CC_STDC
AC_PROG_INSTALL
# Set STDC_HEADERS
AC_HEADER_STDC
AM_PROG_LIBTOOL
dnl ***************************
dnl *** Checks for glib 1.2 ***
dnl ***************************
AM_PATH_GLIB(1.2.0,,
AC_MSG_ERROR([Cannot find GLIB: Is glib-config in path?]))
GLIB_CFLAGS=`glib-config --cflags glib`
GLIB_LIBS=`glib-config --libs glib`
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
CFLAGS='-g -Wall -Wunused -Wmissing-prototypes -Wmissing-declarations'
AC_SUBST(CFLAGS)
AC_OUTPUT([
Makefile
mono/Makefile
mono/metadata/Makefile
mono/dis/Makefile
mono/cil/Makefile
mono/interpreter/Makefile
mono/doc/Makefile
])
+3
View File
@@ -0,0 +1,3 @@
Makefile.in
Makefile
all-docs
+16
View File
@@ -0,0 +1,16 @@
WEB_FILES=
c-sharp class-library contact contributing documentation download \
faq gcc-frontend ideas index makefile passport rationale resources \
roadmap runtime status team testing thanks tools
OTHERS= pending resources-pending todo
EXTRA_DIST = $(WEB_FILES) README $(OTHERS)
all-docs: $(WEB_FILES)
cat rationale roadmap c-sharp tools class-library \
runtime documentation download faq contributing \
resources status > all-docs
webit:
(cd web; make && make push)
+17
View File
@@ -0,0 +1,17 @@
To edit the website appearance:
cd doc/web
edit template.html.in
make
To edit website content:
cd doc (this directory)
edit files carefully
cd web
make
To publish changes:
cd web
make push
+151
View File
@@ -0,0 +1,151 @@
* MCS: The Ximian C# compiler
MCS began as an experiment to learn the features of C# by
writing a large C# program. MCS is currently able to parse C#
programs and create an internal tree representation of the
program. MCS can parse itself.
Work is progressing quickly on various fronts in the C#
compiler. Recently I started using the System.Reflection API
to load system type definitions and avoid self-population of
types in the compiler and dropped my internal Type
representation in favor of using the CLI's System.Type.
** Phases of the compiler
The compiler has a number of phases:
<ul>
* Lexical analyzer: hand-coded lexical analyzer that
provides tokens to the parser.
* The Parser: the parser is implemented using Jay (A
Berkeley Yacc port to Java, that I ported to C#).
The parser does minimal work and syntax checking,
and only constructs a parsed tree.
Each language element gets its own class. The code
convention is to use an uppercase name for the
language element. So a C# class and its associated
information is kept in a "Class" class, a "struct"
in a "Struct" class and so on. Statements derive
from the "Statement" class, and Expressions from the
Expr class.
* Parent class resolution: before the actual code
generation, we need to resolve the parents and
interfaces for interface, classe and struct
definitions.
* Semantic analysis: since C# can not resolve in a
top-down pass what identifiers actually mean, we
have to postpone this decision until the above steps
are finished.
* Code generation: nothing done so far, but I do not
expect this to be hard, as I will just use
System.Reflection.Emit to generate the code.
</ul>
<a name="tasks">
** Current pending tasks
Simple tasks:
<ul>
* Array declarations are currently being ignored,
* PInvoke declarations are not supported.
* Pre-processing is not supported.
* Attribute declarations and passing currently ignored.
* Compiler does not pass around line/col information from tokenizer for error reporting.
* Jay does not work correctly with `error'
productions, making parser errors hard to point. It
would be best to port the Bison-To-Java compiler to
become Bison-to-C# compiler ([email protected]
might have more information)
</ul>
Critical tasks:
<ul>
* Resolve "base" classes and "base" interfaces for
classes, structs and interfaces.
Once this is done, we can actually do the semantic
analysis, because otherwise we do not know who our
parents are.
</ul>
Interesting tasks:
<ul>
* Finishing the JB port from Java to C#. If you are
interested in working on this, please contact Brian
Jepson (bjepson at oreilly d-o-t com).
More on JB at: <a href="http://www.cs.colorado.edu/~dennis/software/jb.html">
http://www.cs.colorado.edu/~dennis/software/jb.html</a>
JB will allow us to move from the Berkeley Yacc
based Jay to a Bison-based compiler (better error
reporting and recovery).
</ul>
** Questions and Answers
Q: Why not write a C# front-end for GCC?
A: I wanted to learn about C#, and this was an exercise in this
task. The resulting compiler is highly object-oriented, which has
lead to a very nice, easy to follow and simple implementation of
the compiler.
I found that the design of this compiler is very similar to
Guavac's implementation.
Targeting the CIL/MSIL byte codes would require to re-architecting
GCC, as GCC is mostly designed to be used for register machines.
The GCC Java engine that generates Java byte codes cheats: it does
not use the GCC backend; it has a special backend just for Java, so
you can not really generate Java bytecodes from the other languages
supported by GCC.
Q: If your C# compiler is written in C#, how do you plan on getting
this working on a non-Microsoft environment.
We will do this through an implementation of the CLI Virtual
Execution System for Unix (our JIT engine).
Q: Do you use Bison?
A: No, currently I am using Jay which is a port of Berkeley Yacc to
Java that I later ported to C#. This means that error recovery is
not as nice as I would like to, and for some reason error
productions are not being caught.
In the future I want to port one of the Bison/Java ports to C# for
the parser.
Q: How do I compile it?
A: Compiling MCS currently requires you to run my port of <a
href="http://primates.ximian.com/~miguel/code/jay.cs.tar.gz">Jay to
C#</a> on a Unix system to generate the parser, and then you need
to use Microsoft's .NET csc.exe compiler to compile the compiler.
You only need to compile the compiler compiler (C code), the
samples are Java samples that I did not port, and you do not need
them.
It might be simple to port Jay.cs to Windows, but I have not tried
this.
You might also want to look at the <a href="faq.html#gcc">GCC</a>
section on the main FAQ
+174
View File
@@ -0,0 +1,174 @@
* The Class Library
The Class Library should be compatible with Microsoft's .NET
implementation.
Please see the <a href="class-status.html">Class Status</a>
page for a status of who is working on which classes.
We will write as much code as possible in C#. We may need to
interface with code written in C to gain access to the
functionality of libraries like libart, Gtk+, and libc.
** Contributing
We welcome contributions to the the Class Library. To get
started, check the status page for information about which
APIs are being worked on, and how to get in touch with
individual maintainers.
If you want to work on a class, first check the <a
href="download.html">Classes Distribution</a> to see if it is
not implemented yet, if not, check the <a
href="class-status.html">Class Status</a> to see if someone is
already working on it, and maybe contact them.
If nobody is working on it, mail <a
href="mailto:[email protected]">[email protected]</a>
with the class you want to implement and CC <a
href="mailto:[email protected]">[email protected]</a>
** Layout
The Class Library resides in the `mcs' module in the directoy
`class'.
Each directory in the directory represents the assembly where
the code belongs to, and inside each directory we divide the
code based on the namespace they implement.
There are two cases when we should consider portability: when
we are dealing with a couple of classes only that differ from
system to system (Consider System.Net and System.IO for Win32
and Unix). In those cases we will just place the files for
example on <t>corlib/System/System.IO/Unix-Console.cs</t> and
<t>corlib/System/System.IO/Win32-Console.cs</t>.
For classes that might differ more (for example, the
implementation of Windows.Forms), we might have different
directories altogether: <t>System.Windows.Forms/Win32</t>,
<t>System.Windows.Forms/Gtk+</t> and
<t>System.Windows.Forms/Cocoa</t>.
** Using existing components from GNOME.
Our current plan is to implement the GUI tools on top of
Gtk+. The only obstacle here is that applications from Windows
might expect to be able to pull the HWND property from the
widgets and use PInvoke to call Windows functions.
** Class Library and Win32 dependencies.
There are a few spots where the Win32 foundation is exposed to
the class library (for example, the HDC and HWND properties in
the GDI+). Casual inspection suggests that these can be
safely mapped to Gdk's GC and GdkWindow pointers without
breaking anything.
The only drawback is that support for PInvoke of Win32 code
won't be available. An alternate solution would be to use
portions of Wine, or even to use Wine as our toolkit.
*** Initial GDI+ and WinForms implementation
The initial implementation will use Gtk+ as the underlying
toolkit. Since GTK+ has already been ported to many windowing
systems other than X (including frame buffer, Win32, and BeOS)
its use should cover most applications for most users.
*** Database access
We will implement ADO.NET functionality by reusing <a
href="http://www.gnome-db.org">GNOME-DB</a>. This is an ideal
choice, since GNOME-DB was implemented precisely to provide an
ADO-like system for GNOME.
*** Component Integration
We will provide a new namespace to use GNOME specific features
as well as a namespace to host Bonobo interfaces and classes
in Mono.
** Licensing
The class library will be licensed under the terms of the GNU
LGPL. Some people have pointed out that the plain LGPL is
troublesome for embedded use of the Mono class libraries. So
we are considering to use the GPL with a special exception
(like the <a
href="http://www.gnu.org/software/classpath/classpath.html">GNU
Classpath</a> project did.
The exception to the GPL would be:
<i>The library is distributed under the terms of the GNU General
Public License with the following exception:
If you link this library against your own program, then you do not
need to release the source code for that program. However, any
changes that you make to the library itself, or to any native
methods upon which the library relies, must be re-distributed in
accordance with the terms of the GPL.</i>
If you are going to contribute, please keep in mind that we
might require you to agree that Ximian might adjust the
license to enable the use of the class libraries on embedded
systems or to develop proprietary applications using Mono.
We suggest that you assign the copyright of your work to the
GNOME Foundation or the Free Software Foundation to simplify
defending the code in case it is used inappropiately.
** Class Library testing
We need to write regression tests that will verify
the correctness of the class library, compiler, and JIT
engine.
** Coding conventions
Please follow the conventions on the ECMA specification (On
the Annex Partition) for your coding your libraries.
Use 8 space tabs for writing your code (hopefully we can keep
this consistent). If you are modifying someone else's code, try
to keep the coding style similar.
For a rationale on 8 space tabs, read Linus Torvald's Coding
Style guidelines in the Linux kernel source for a rationale.
*** Missing implementation bits
If you implement a class and you are missing implementation bits,
please put in the code the word "TODO" and a description of what
is missing to be implemented.
*** Tagging buggy code
If there is a bug in your implementation tag the problem by using
the word "FIXME" in the code, together with a description of the
problem.
Do not use XXX or obscure descriptions, because otherwise people
will not be able to understand what you mean.
*** Tagging Lame specs
Sometimes the specification will be lame (consider Version.ToString (fieldCount)
where there is no way of knowing how many fields are available, making the API
not only stupid, but leading to unreliable code).
In those cases, use the keyword "LAMESPEC".
** FAQ
Frequently asked questions about the class library:
Q: I am writing a new class that overrides one of the system classes,
and I am getting a 1595 warning from the compiler. Should we use a
different namespace?
A: There is a quick solution to the problem, you can pass the command
line argument /nowarn:1595 and this will effectively let you use
your implementation of the code, while overriding the ones from the
system assemblies.
+27
View File
@@ -0,0 +1,27 @@
* Status of the various pieces of the class library
You can browse the status of the class library and see who has
registered to work on what parts of the system. These list
work-in-progress components currently.
<ul>
* Per <a href="class-status/per-assembly.html">Assembly</a>
* Per <a href="class-status/per-completion.html">Completion</a>
* Per <a href="class-status/per-maintainer.html">Maintainer</a>
* Per <a href="class-status/per-unimplemented.html">Unimplemented</a>
</ul>
A better mechanism will soon be in place, I just did this
really quickly, as we already got one duplicated implementation.
You can also download the XML <a
href="class-status/maintainers.xml">maintainers</a> file that
contains the actual maintainers list.
I am sure we can generate better reports, if you are
interested in contributing, let <a
href="mailto:[email protected]">me</a> know.
+16
View File
@@ -0,0 +1,16 @@
* Contacting the Mono team.
You can contact the Mono Team by sending e-mail to `<a
href="mailto:[email protected]">mailto:[email protected]</a>'.
You can contact the general forum of discussion by sending
e-mail to <a href="mailto:[email protected]">[email protected]</a>
You can contact me (Miguel de Icaza) by sending e-mail to <a
href="mailto:[email protected]">[email protected]</a>. My web
page is <a
href="http://primates.ximian.com/~miguel">http://primates.ximian.com/~miguel"</a>
You can also <a
href="http://www.ximian.com/about/contact.php3">reach Ximian.</a>
+53
View File
@@ -0,0 +1,53 @@
* Contributing to the Mono project
There are many ways in which you can help in the Mono project:
<ul>
* <b>Programmers:</b> You can work on a free
implementation of the <a
href="class-library.html">class libraries</a>, the
<a href="runtime.html">runtime engine</a>, <a
href="tools.html">the tools</a>, the <a
href="testing.html">testing framework</a>
* <b>Writers:</b> You can help us with writing <a
href="documentation.html">documentation</a>.
</ul>
Those are just broad things that need to be worked on, but
something that would help tremendously would be to help with
small duties in the project that need to be addressed.
** Small tasks
A few smaller tasks are here, dropped in no particular order:
<ul>
* <b>MCS compilation process:</b> Currently MCS does
not build with a single `make' command. This should
be fixed (this being part of the `Joel Test' that
software has to pass).
* <b>Mono/doc and web site:</b> They need to be
packaged up in the official `distribution'
* <b>Enthusiasts: </b>
</ul>
* Special note
If you have looked at Microsoft's implementation of .NET or
their shared source code, you may not be able to contribute
to Mono. Details will follow when we know more about this.
In general be careful when you are implementing free software
and you have access to proprietary code. We need to make sure
that we are not using someone else's copyrighted code
accidentally.
Please do not use the <b>ildasm</b> program to disassemble
proprietary code when you are planning to reimplement a class
for Mono. If you have done this, we might not be able to use
your code.
Please stick to published documentation for implementing any
classes.
+50
View File
@@ -0,0 +1,50 @@
* Documentation
Although most of the concepts from Microsoft.NET can
be applied to the completed Mono platform, we do need to
have a complete set of free documentation written specifically
for Mono.
The documentation license we have chosen is the GNU Free
Documentation License (FDL), the standard for most documents
in the free software world.
We need documentation on a number of topics:
<ul>
* The development tools (compilers, assembler tools,
language reference, design time features).
* Frequently Asked Question compilations.
* HOWTO documents.
* The Class Libraries
* Tutorials on Mono and the specifics of running it.
* A guide to Mono as compared to the Microsoft.NET
Framework SDK
</ul>
** Class Library documentation
When contributing to the Class Library effort, please use the
inline XML documentation tags to document your classes so we
can automatically generate the documentation from the class
libraries.
If you provide examples, please do not embed them into the
source code, as that will make the source code harder to read
and maintain. Instead, put examples for your code into a
subdirectory of the class libraries. Make your sample
code a full standalone application that people can compile.
Ideally the Mono documentation browser will let you edit, modify
and run the sample programs.
+44
View File
@@ -0,0 +1,44 @@
* Software Availability
The Virtual Execution System is available in package `mono'.
Currently this contains a metadata library and the
disassembler. Please reffer to our <a
href="runtime.html">Runtime</a> description for more details
on this part of the project.
The code for the C# compiler as well as the language error
test suite and the class library are in the `mcs' package, we
will move this later into `mono' itself.
The mcs compiler requires the `jay' parser generator, this is
available in module `jay'.
** Sources
Currently we will be providing CVS snapshots every day, until
we make the first tarball release.
<ul>
<a name="july-14">
<b>July 14th, 2001</b>
<ul>
* <a href="archive/jay.cs.tar.gz">archive/jay.cs.tar.gz</a>: Sources to Jay.
* <a href="archive/mcs-12-Jul-2001.tar.gz">mcs-12-Jul-2001.tar.gz</a>: CVS snapshot.
* <a href="archive/mono-0.3.tar.gz">mono-0.3.tar.gz</a>: Packaged Source Code.
</ul>
<a name="july-8">
<b>July 8th, 2001</b>
<ul>
* <a href="archive/jay.cs.tar.gz">archive/jay.cs.tar.gz</a>: Sources.
* <a href="archive/mcs-08-Jul-2001.tar.gz">mcs-08-Jul-2001.tar.gz</a>: CVS Snapshot
* <a href="archive/mono-08-Jul-2001.tar.gz">mono-08-Jul-2001.tar.gz</a>: CVS Snapshot
</ul>
</ul>
** CVS
We are trying to figure out where to put our CVS repository.
We are debating between the GNOME CVS or SourceForge. Watch
this spot.
+609
View File
@@ -0,0 +1,609 @@
** Basics
Q: Is Mono the same as Microsoft's .NET initiative?
A: It is not.
.NET is a company-wide initiative at Microsoft that
encompasses many different areas. The .NET development framework,
Passport, Biztalk, new server products, and anything that is
remotely connected to .NET gets the ".NET-stamping" treatment.
Some components of Microsoft's .NET initiative have been announced
and some others are in the works.
Mono is a project to implement several technologies developed by
Microsoft that have now been submitted to the ECMA Standards Body.
Q: What technologies are included in Mono?
A: Mono contains a number of components useful for building new
software:
<ul>
* A Common Language Infrastructure (CLI) virtual
machine that contains a class loader, Just-in-time
compiler, and a garbage collecting runtime.
* A class library that can work with any language
which works on the CLR.
* A compiler for the C# language. In the future we
might work on other compilers that target the Common
Language Runtime.
Windows has compilers that target the
virtual machine from
<a href="http://msdn.microsoft.com/net/thirdparty/default.asp#lang">a
number of languages:</a> Managed C++, Java Script,
Eiffel, Component Pascal, APL, Cobol, Oberon, Perl,
Python, Scheme, Smalltalk, Standard ML, Haskell,
Mercury and Oberon.
</ul>
The CLR and the Common Type System (CTS) enables applications and
libraries to be written in a number of languages. Classes and
methods created in one language can be used from a different
language.
This means for example that if you define a class to do algebraic
manipulation in C#, that class can be reused from any other
language that supports the CLI. You could create a class in C#,
subclass it in C++ and instantiate it in an Eiffel program.
A single object system, threading system, class libraries, and
garbage collection system can be shared across all these languages.
Q: Where can I find the specification for these technologies?
A: You can find the work-in-progress documentation from the T3G ECMA
group here:
<a href="http://www.dotnetexperts.com">http://www.dotnetexperts.com</a>
Q: Will you implement the .NET Framework SDK class libraries?
A: Yes, we will be implementing the APIs of the .NET Framework SDK
class libraries.
Q: What does Mono stand for?
A: Mono is the word for `Monkey' in Spanish. We like monkeys.
Q: When will you ship it?
A: We do not know when the code will be shipped. The more
contributions we get to the project, the sooner it will ship.
A rough estimate is that we might be able to run our C# compiler on
Linux by the end of the year. That means running the Windows
Executable generated by a Microsoft .NET compiler on the Linux
platform.
We expect that doing GUI applications will require more work on the
class libraries. That could take another six months.
Q: How can I contribute?
A: Check the <a href="contributing.html">contributing</a> section.
Q: You guys should innovate instead of copying.
A: In this particular case, we see a clear advantage in the platform
and we are interested in using the features of the CLI on open source systems.
We have decided that we should spend our limited resources towards
implementing an existing specification instead of designing and
implementing our own.
Designing and implementing our own would be possible, but it doesn't make
sense to do that just because the specification comes from a
proprietary vendor.
** Ximian
Q: Why is Ximian working on .NET?
A: We are interested in providing the best tools for programmers to
develop applications for Free Operating Systems.
For more information, read the project <a
href="rationale.html">rationale</a> page.
Q: Will Ximian be able to take on a project of this size?
A: Ximian will not be able to taken on the whole project on its own.
Mono will be a free software/open source community project, that is
the only way we can hope to implement something of this size. You
can <a href="contributing.html">contribute</a> to this effort.
Q: What pieces will Ximian be working on?
A: We will focus on building a development and execution
environment.
The idea is to get Mono to a state of that would allow
third parties to actually be able to use it real-world development.
Q: Why does Ximian even care?
A: We like the features that the CLI and its related technologies
bring to the table. An exciting addition to the developer toolkit.
The goal of Mono is to bring this technology to non-Windows
platforms (although we hope Mono will also run on Windows, for
debugging and comparative purposes).
** Licensing
Q: Will I be able to write proprietary applications that run with
Mono?
A: Yes. We will make sure that the licensing will allow developers to
create proprietary applications.
Q: What license is Mono on?
A: The C# Compiler is released under the terms of the GPL. The class
libraries will be under the LGPL or the GPL with a special
exception. The runtime libraries are under the LGPL.
Here is the exception for the class libraries:
The library is distributed under the terms of the GNU General
Public License with the following exception:
If you link this library against your own program, then you do not
need to release the source code for that program. However, any
changes that you make to the library itself, or to any native
methods upon which the library relies, must be re-distributed in
accordance with the terms of the GPL.
This is similar in spirit to <a
href="http://www.gnu.org/software/classpath/classpath.html">GNU
Classpath.</a>
Q: Will you accept code under the XXX License?
A: If the XXX License is compatible with the license we use in that
specific piece of code, then yes. If you want to use the BSD license, make
sure you use the BSD license without the advertisement clause (The
`Ousterhout License').
** Mono and .NET
Q: If applications use Mono, does that mean that I have to pay a service fee?
A: No. Mono is not related to Microsoft's initiative of
software-as-a-service.
Q: If you implement .NET, will I depend on Microsoft Passport to run my software?
A: No. The .NET Framework is a runtime infrastructure and collection
of class libraries. Passport may be required to access certain web
services written for that framework, but only if the programmer
chooses Passport as the authentication mechanism.
Q: Is .NET just a bunch of marketing slogans?
A: Although the `.NET initiative' is still quite nebulous, The .NET Framework
has been available for some time. Mono is not an implementation of the .NET
initiative, just the development framework.
Q: What is a 100% .NET application?
A: A `100% .NET application' is one that only uses the APIs defined
under the System namespace and does not use PInvoke. These
applications would in theory run unmodified on Windows, Linux,
HP-UX, Solaris, MacOS X and others.
Q: But Microsoft will release a port of the real thing under the
`Shared Source' license, why bother with anything else?
A: The Shared Source implementation will not be usable for commercial
purposes. We are working towards an implementation that will grant
a number of rights to recipients: use for any purpose,
redistribution, modification, and redistribution of modifications.
This is what we call <a
href="http://www.gnu.org/philosophy/free-sw.html">Free Software</a>
** Passport
Q: Is this a free implementation of Passport?
A: No. Passport is part of Microsoft's Hailstorm initiative. Mono
is just a runtime, a compiler and a set of class libraries.
Q: Will the System.Web.Security.PassportIdentity class, mean
that my software will depend on Passport?
A: No. That just means that applications might use that API to
contact a Passport site.
As long as your application does not use Passport, you will not
need Passport.
It might even be possible to implement that class with
a set of dummy functions, or use an alternate Passport implementation.
We do not know at this time whether the Passport protocol is
documented and whether we will be able to talk to
passport.com
Q: What is your opinion?
A: You can read my personal <a href="passport.html">opinion on
passport</a>.
** Mono and Windows
Q: Will Mono allow me to run Microsoft Office on Linux?
A: No, it will not. Microsoft Office is a Windows application. To
run Windows applications on Intel Unix systems refer to <a
href="http://www.winehq.com">the Wine Project</a>
** GNOME
Q: How is this related to GNOME?
A: In a number of ways:
* Mono will use existing
components that have been developed for GNOME when it makes
sense. For example on X systems, we will use Gtk+ and
Libart to implement Winforms and the Drawing2D API.
For database access, we will use LibGDA (not really
depending on GNOME, but related to).
* This project was born out of the need of providing improved
tools for the GNOME community.
* We would like to add support to our CLR implementation to
deal with GObjects (in GNOME 1.x, they are called
GtkObjects), and allow Mono developers to provide GObjects
or use and extend existing GObjects.
Q: Has the GNOME Foundation or the GNOME team adopted Mono?
A: Mono is too new to be adopted by those groups. We hope that the
tools that we will provide will be adopted by free software
programmers including the GNOME Foundation members and the GNOME
project generally.
Q: Should GNOME programmers switch over to Mono?
A: Mono will not be ready even within the next six months, and a
complete implementation is probably one year away.
We encourage GNOME developers to continue using the existing tools,
libraries and components. Improvements made to GNOME will have an
impact on Mono, as they will provide the "backend" for various
classes.
Q: Will Mono include compatibility with Bonobo components?
A: Yes, we will provide a set of classes for implementing and using
Bonobo components from within Mono.
** Mono and the Web
Q: Is Mono a way of running Java applets?
A: No.
** Web Services
Q: Is Mono just a new way of writing Web Services?
A: No.
Q: If this implements the SDK classes, will I be able to write and
execute .NET Web Services with this?
A: Yes, you will.
When the project is finished, you will be able to use the same
technologies that are available through the .NET Framework SDK on
Windows to write Web Services.
Q: What about Soup?
A: Soup is a library for GNOME applications to create SOAP server and
SOAP clients. You can browse the source code for soup using <a
href="http://cvs.gnome.org/bonsai">GNOME's Bonsai</a>
Q: Can I use CORBA?
A: Yes. The CLI contains enough information about a class that
exposing it to other RPC systems (like CORBA) is really simple, and
does not even require support from an object.
We will be implementing CORBA interoperation as an extension to the
Mono classes so that we can integrate with Bonobo, just like
Microsoft provides COM interoperation classes and support
mechanisms.
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.
** Development Tools
Q: Will it be possible to use the CLI features without using bytecodes
or the JIT?
A: Yes. The CLI engine will be made available as a shared library.
The garbage collection engine, the threading abstraction, the
object system, the dynamic type code system and the JIT will be
available for C developers to integreate with their applications if
they wish to do so.
Q: Will you have new development tools?
A: Hopefully Free Software enthusiasts will contribute tools to
improve the developer environment. These tools could be developed
initially using Microsoft implementation of the CLI and then
executed later with Mono.
** Mono and Java
Q: What about using Java? After all there are many languages that
target the Java VM.
A: You can get very good tools for doing Java development on free
systems right now. <a href="http://www.redhat.com">Red Hat</a> has
contributed a <a href="http://gcc.gnu.org">GCC</a> <a
href="http://gcc.gnu.org/java">frontend for Java</a> that can take
Java sources or Java byte codes and generate native executables; <a
href="http://www.transvirtual.com">Transvirtual</a> has implemented
<a href="http://www.kaffe.org">Kaffe</a> a JIT engine for Java;
Intel also has a Java VM called <a
href="http://www.intel.com/research/mrl/orp">ORP</a>.
The JVM is not designed to be a general purpose virtual machine.
The Common Intermediate Language (CIL), on the other hand, is
designed to be a target for a
wide variety of programming languages, and has a set of rules
designed to be optimal for JITers.
Q: What kind of rules make the Common Intermediate Language useful for
JITers?
A: The main rule is that the stack in the CLI is not a general purpose
stack. You are not allowed to use it for other purposes than
computing values and passing arguments to functions or return
values.
At any given call or return instruction, the types on the stack
have to be the same independently of the flow of execution of your
code.
Q: I heard that the CIL is ideal for JITing and not efficient for
interpreters, is this the case?
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.
** Extending Mono
Q: Would you allow other classes other than those in the
specification?
A: Yes. The Microsoft class collection is very big, but it is by no
means complete. It would be nice to have a port of `Camel' (the
Mail API used by Evolution inspired by Java Mail) for Mono
applications.
You might also want to look into implementing CORBA for Mono. Not
only because it would be useful, but because it sounds like a fun
thing to do, given the fact that the CLI is such a type rich
system.
For more information on extending Mono, see our <a
href="ideas.html">ideas</a> page.
** Mono and portability
Q: Will Mono only work on Linux?
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 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
port of the Winform classes to other platforms (frame buffer or
MacOS X for example), we would gladly integrate them, as long
they are under a Free Software License.
** Reusing existing Code
Q: What projects will you reuse or build upon?
A: We want to get Mono in the hands of programmers soon. We are
interested in reusing existing open source software.
Q: What about Intel's research JIT framework, ORP?
A: At this time, we are investigating whether we can use elements of
ORP for Mono. ORP is a research JIT engine that has a clear
defined API that splits the JIT from the GC system and the actual
byte code implementation. It is a research product.
Q: What about using GNU Lightning?
A: We are also researching <a
href="http://www.gnu.org/software/lightning/lightning.html">GNU
Lightning</a>.
** Ximian and Microsoft
Q: Didn't Miguel de Icaza say that `Unix Sucks'?
A: Yes, he did, as a catch phrase in his opening remark on the Ottawa
Linux Symposium. His talk focused on various ways to improve Unix.
There is a paper describing some ways to improve Unix at:
<a href="http://primates.ximian.com/~miguel/bongo-bong.html">
http://primates.ximian.com/~miguel/bongo-bong.html</a>
Q: Didn't Ximian's Miguel work for Microsoft?
A: Actually, Nat Friedman (Ximian's co-founder) did work as an
intern for Microsoft for one summer but Miguel did not.
Q: Did Nat and Miguel meet at Microsoft?
A: They met online on the Linux IRC network; They met in person for
the first time in 1997.
** Mono and Microsoft
Q: How can you expect Mono to compete with Microsoft, wont this
require an effort too large?
A: You are right. Mono will never become a reality without the help
of other contributors. Ximian is a small company that can not
finish Mono alone. We will be working with members of the
community to deliver the product.
Q: Is Microsoft and Corel involved in the Mono implementation?
A: No, they are not.
Q: Are you writing Mono from the ECMA specs?
A: yes, we are writing them from the ECMA specs and the published
materials in print about .NET
** Acronyms
Q: What is the difference between CLR (Common Language Runtime) and
CLI (Common Language Infrastructure)?
A: CLI is the specification of an execution system. The Microsoft
implementation of this specification is named CLR.
Unless we come up with our own acronym, we could just call ours
also CLR, just because it would do exactly the same thing the
Microsoft implementation does.
<a name="gcc">
** Mono and GCC
Q: Should someone work on a GCC front-end to C#?
A: I would love if someone does, and we would love to help anyone that
takes on that task, but we do not have the time or expertise to
build a C# compiler with the GCC engine. I find it a lot more fun
personally to work on C# on a C# compiler, which has an intrinsic
beauty.
Q: Should someone make a GCC backend that will generate CIL images?
A: I would love to see a backend to GCC that generates CIL images. It
would provide a ton of free compilers that would generate CIL
code. This is something that people would want to look into
anyways for Windows interoperation in the future.
Q: What about making a front-end to GCC that takes CIL images and
generates native code?
A: I would love to see this, specially since GCC supports this same
feature for Java Byte Codes. You could use the metadata library
from Mono to read the byte codes (ie, this would be your
"front-end") and generate the trees that get passed to the
optimizer.
Ideally our implementation of the CLI will be available as a shared
library that could be linked with your application as its runtime
support.
Q: But would this work around the GPL in the GCC compiler and allow
people to work on non-free front-ends?
A: People can already do this by targeting the JVM byte codes (there
are about 130 compilers for various languages that target the JVM).
Q: Why are you writing a JIT engine instead of a front-end to GCC?
A: The JIT engine and runtime engine will be able to execute CIL
executables generated on Windows.
** Mono and GNU
Q: Is Mono part of the GNU project?
A: Mono is a Ximian project, that is also part of the GNU project.
** Mono and Portability
Q: Will Mono work on other variants of Unix?
A: Yes. We do not expect to add any gratuitous incompatibilities.
Q: Will Mono run on Windows?
A: Hopefully yes. Currently some parts of Mono only run on Windows
(the C# compiler is a .NET executable) and other parts have only
been compiled on Linux, but work on Windows with Cygwin.
Q: Will Mono depend on GNOME?
A: It will depend only if you are using a particular assembly (for
example, for doing GUI applications). If you are just interested
in Mono for implementing a `Hello World Enterprise P2P Web
Service', you will not need any GNOME component.
** Performance
Q: How fast will be Mono?
A: We can not predict the future, but a conservative estimate is that
it would be at least `as fast as other JIT engines'.
Now, wishfully thinking I hope that we will ship various JITs with
Mono just like Microsoft has done. A fast JITer when maximum
performance is not needed, but fast load times are important; And
an optimizing JITer that would be slower at generating code but
produce more optimal output.
The CIL has some advantages over the Java byte code: it is really
an intermediate representation and there are a number of
restrictions on how you can emit CIL code that simplify creating
better JIT engines.
For example, on the CIL the stack is not really an abstraction
available for the code generator to use at will: it is just a way
of creating a postfix representation of the parsed tree. At any
given call point or return point, the contents of the stack are
expected to contain the same object types independently of how the
instructions was reached.
** Assorted questions
Q: You say that the CLI allows multiple languages to execute on the
same environment. Isn't this the purpose of CORBA?
A: CORBA can be used for this purpose, but think of CORBA mostly as a
inter-process (local machine or remote machine) communication
system.
Think of the CLI to be targeted to interoperation of languages in
the same process, and CORBA as being a nifty addition for
out-of-process.
Sure, we have used CORBA for in-proc components, but the lack of an
ABI for in-proc components does not translate into a good framework
for in-proc systems
+9
View File
@@ -0,0 +1,9 @@
* The GCC front-end
The GCC front-end will accept input in a binary file with
codes in the Common Intermediate Language (CIL), and generate
native code.
This will allow pre-compilation and full optimization to take
place before a program is executed.
+40
View File
@@ -0,0 +1,40 @@
* Ideas
Here are a few ideas of tools, classes and projects that you
could start. More are forthcoming.
<a name="classes">
** Classes
<ul>
* Implement a JXTA protocol implementation:
<a href="http://www.jxta.org">http://www.jxta.org</a>
* Implement a Mail API, similar to Camel or JavaMail (Camel has
significant architecture features that are required on a real
mailer).
You can check the current C
<a href="http://cvs.gnome.org/bonsai/rview.cgi?dir=evolution%2Fcamel">
Camel implementation</a>.
* Interfacing to Multimedia systems. You might want
to look into the Quicktime API. I know <a
href="mailto:[email protected]">Vladimir</a> has
researched the problem before
</ul>
<a name="projects">
** Projects
<ul>
* Implement an xmlStorageSystem for the CLI:
<a href="http://www.soapware.org/xmlStorageSystem">
http://www.soapware.org/xmlStorageSystem</a>
* Build a CORBA interoperability engine for the CLR.
You do not need to do all of the work, just talking
the protocol will get us a long way (<a
href="http://www.omg.org">The OMG site</a> has the CORBA specs).
</ul>
+39
View File
@@ -0,0 +1,39 @@
** Jul 14, 2001
A <a
href="http://mail.ximian.com/archives/public/mono-list/2001-July/000399.html">new
release</a> of the
runtime, compiler and classes has been made. Get it <a href="download.html#july-14">here</a>
** Jul 12, 2001
I keep getting questions about my opinion on Passport, even when
Mono has <b>nothing</b> to do with it. I finally <a
href="passport.html">wrote something.</a>
** Jul 9, 2001
Today <a href="http://www.ximian.com">Ximian</a> announced the
launch of the Mono
project, an effort to create a free software
(sometimes called open source) implementation of the .NET
Development Framework.
If you have questions about the
project, please read our list of <a
href="faq.html">Frequently Asked Questions</a>.
You might also want to <a href="download.html">Download the
source</a> for our work so far.
You might want to <a
href="resources.html#mailing">subscribe</a> to our mono-list
and mono-announce-list
You can contact the team at: <a
href="mailto:[email protected]">[email protected]</a>
** O'Reilly
Brian posted a story on <a
href="http://www.oreillynet.com/dotnet">O'Reilly Network .NET</a>
+231
View File
@@ -0,0 +1,231 @@
* Microsoft Hailstorm and Passport
Microsoft Passport is a centralized database hosted by
Microsoft that enhances the consumer experience with the Web
by providing a single logon system that they can use across a
number of participant web sites.
As you might know by now from our extensive <a
href="faq.html">FAQ</a>, the Mono project has nothing to do
with Microsoft Hailstorm or <a
href="http://www.passport.com">Microsoft Passport.</a>
Still a lot of people have asked us our opinion on them.
** Passport
Passport is important not because of it being breaktrough
technologically speaking, but because the company is in a
position to drive most people toward being suscribers of it.
At the time of this writing passport is required to use the
free mail service <a href="http://www.hotmail.com">Hotmail</a>
to get customized support for the <a
href="http://www.msn.com">MSN portal</a>, <a
href="http://msdn.microsoft.com">Microsoft Developers
Network</a> and according to the original announcement from
Microsoft <a href="http://www.americanexpress.com">American
Express</a> and <a href="http://www.ebay.com">EBay</a> will be
adopting it.
There is already a <a
href="http://www.passport.com/Directory/Default.asp?PPDir=C&lc=1033">Large
list</a> of participating sites.
There are many current users of it and Microsoft will be
driving more users towards Passport as it <a
href="http://news.cnet.com/news/0-1003-200-6343275.html">integrates
it</a> in their upcoming release of Windows.
Microsoft has also <a
href="http://www.passport.com/Business/JoinPassportNetwork.asp?lc=1033">developed
a toolkit</a> to enable current web merchants to integrate
their services with passport.
To the end user, there is a clear benefit: they only have to
log into a single network and not remember multiple passwords
across sites on the internet. Companies that adopt passport
will have a competition advantage over those that dont.
Microsoft lists a list of <a
href="http://www.passport.com/Business/Default.asp?lc=1033">benefits</a>
to companies.
** The problems of Passport
There are a number of concerns that different groups have over
Passport. Sometimes I have some, sometimes I do not. But
overall, consumers and businesses can have better solutions.
<ul>
* <b>Single Point of Failure:</b> As more services and
components depend on remote servers, functionality can
grind to a halt if there is a failure on the
centralized Passport system.
Such a failure was predicted, and we recently <a
href="http://news.cnet.com/news/0-1005-200-6473003.html">witnessed</a>
got a lot of people worried.
The outgage lasted for seven days. Think what this
could do to your business.
* <b>Trust:</b> Not everyone trusts Microsoft to keep
their information confidential. Concerns are not only
at the corporate level policy, but also the fact that
the source code for Microsoft products is not
available, means that trojans or worms could be built
into the products by malicious engineers. This is not
unheard of, as the <a
href="http://slashdot.org/articles/00/04/14/0619206.shtml">Microsoft
Internet Server</a> had a trojan horse built into that
allowed anyone that knew about this to control any
server running IIS.
* <b>Security:</b> With a centralized system like
Passport, imagine the repercussions of a malicious
hacker gaining access to the Passport database.
Personal information and credit card information about
almost everyone using a computer could be stored there.
Hackers have already <a
href="http://slashdot.org/articles/00/10/27/1147248.shtml">broken
into Microsoft</a> in the past. And the company was
unable to figure out for how long their systems had been hacked.
</ul>
Microsoft might or might not realize this. The idea behind
Passport is indeed a good one (I can start to get rid of my
file that keeps track of the 30 logins and passwords or so
that I use across the various services on the net myself).
** Alternatives to Microsoft Passport
An alternative to Microsoft Passport needs to take the above
problems into consideration. Any solution of the form `We
will just have a competing offering' will not work.
The system thus has to be:
<ul>
* <b>Distributed:</b> The entire authentication
system should not create an internet `blackout' in the
case of failure.
* <b>Allow for multiple registrars:</b> Users should
be able to choose a registrar (their banks, local
phone company, service provider, Swiss bank, or any
other entity they trust.
* <b>Mandate good security measures:</b> As a
principle, only Open Source software should be used
for servers in the registrar, and they should conform
to a standard set of tools and software that can be
examined by third parties.
</ul>
An implementation of this protocol could use the DNS or a
DNS-like setup to distribute the information of users with the
possibility of replicating and caching public information
about the user.
For instant messaging (another pieces of the Hailstorm bit),
you want to use a non-centralized system like Sun's <a
href="http://www.jxta.org">JXTA</a>. Some people mailed me to
mention Jabber as a messaging platform.
It could also just use the user e-mail address as the `key' to
choose the registrar (msn.com, hotmail.com -> passport.com;
aol.com -> aol.passport.com; you get the idea).
The <a
href="http://www.soapware.org/xmlStorageSystem">xmlStorage</a>
idea from <a href="http://www.scripting.com">Dave Winer</a>
could be used to store the information.
A toolkit for various popular web servers could be provided,
authenticated and should be open sourced (for those of you who
think that a binary program would give more security and would
prevent people from tampering: you are wrong. You can always
use a proxy system that "behaves" like the binary, and passes
information back and forth from the real program, and snoops
in-transit information).
Good cryptographers need to be involved in this problem to
figure out the details and the possible insecure pieces of a
proposal like this.
** Implementation: In short
To keep it short: <b>DNS, JXTA, xmlStorage.</b>
** Deploying it
The implementation of such a system should be a pretty
straightforward tasks once security cryptographers have
designed such a beast.
The major problems are:
<ul>
* <b>People might just not care:</b> In a poll to US
citizens a couple of decades ago, it was found that
most people did not care about the rights they were
given by the Bill of Rights, which lead to a number of
laws to be passed in the US that eliminated most of
the rights people had.
* <b>The industry will move way too slow:</b>
Microsoft's implementation is out in the open now: it
is being deployed, and soon it will be insinuated to
many, many users. The industry needs to get together
soon if they care about this issue.
By the time the industry reacts, it might be too
late.
</ul>
** Passport and Mono
The .NET class libraries includes a Passport class that
applications might use to authenticate with Passport. Since
we do not have information at this point on the exact protocol
of Passport, it is not even feasible to implement it.
If at some point the information is disclosed, it could be
implemented.
If a competing system to Passport existed, we could probably
hide all the authentication information to use a number of
different passport-like systems.
If a user does not want to use Passport at all, he could
always turn it off (or completely remove the class from the
library). After all, this is free software.
Currently, we are too far from the point where this is a real
issue.
** Disclaimer
This is just a group of personal thoughts of mine that I have
placed here because I get asked this question a lot lately.
The views of this page are not a statement from my employer
(Ximian, Inc).
This is not part of Mono. We are not trying to deal with this
problem.
Nat Friedman (Ximian's co-founder) has his own ideas on how a
competing system to Passport could be designed, but I will let
<a href="http://www.nat.org/gym">him</a> post his own story.
** Other Alternatives
Some people have pointed out <a
href="http://www.xns.org">XNS</a>
Send comments to me: Miguel de Icaza (<a
href="mailto:[email protected]">[email protected]</a>)
+14
View File
@@ -0,0 +1,14 @@
** Microsoft and GNU and Linux.
Q: Does this mean that Microsoft is better than Linux?
A: Many of us are working on <a
href="http://www.gnu.org/philosophy/free-sw.html">free software<a>
and want to have an <a href="http://www.opensource.org">open
source</a> environment that we can change, modify, improve, learn
from, and share with others. Some of us also think that this will
lead on the long run to better software: more efficient, faster,
more robust and more.
We are willing to take good ideas from any source they come from.
+173
View File
@@ -0,0 +1,173 @@
* The Mono Project
** Background.
The GNOME project goal was to bring missing technologies to
Unix and make it competitive in the current market place for
desktop applications. We also realized early on that language
independence was important, and that is why GNOME APIs were
coded using a standard that allowed the APIs to be easily
wrapped for other languages. Our APIs are available to most
programming languages on Unix (Perl, Python, Scheme, C++,
Objective-C, Ada).
Later on we decided to use better methods for encapsulating
our APIs, and we started to use CORBA to define interfaces to
components. We complemented it with policy and a set of
standard GNOME interfaces for easily creating reusable,
language independent components, controls and compound
documents. This technology is known as <a
href="http://www.ximian.com/tech/bonobo.php3">Bonobo</a>.
Interfaces to Bonobo exist for C, Perl, Python, and
Java.
CORBA is good when you define coarse interfaces, and most
Bonobo interfaces are coarse. The only problem is that
Bonobo/CORBA interfaces are not good for small interfaces.
For example, an XML parsing Bonobo/CORBA component would be
inefficient compared to a C API.
** Another explanation
I recently explained our motivations to Dave Winer, and he posted
it <a
href="http://scriptingnews.userland.com/stories/storyReader$1275">here</a>
** Microsoft's .NET
The Microsoft .NET initiative is confusing because it is a
company wide effort that ranges from development tools to end
user applications. .NET is a branding formative that
has been applied to:
<ul>
* The .NET development platform, a new platform for
writing software.
* Web services.
* Microsoft Server Applications.
* New tools that use the new development platform.
* Hailstorm, the Passport centralized single-signon
system that is being integrated into Windows XP.
</ul>
Mono is an implementation of the .NET development platform.
** The Common Language Infrastructure platform.
Microsoft has created a new development platform. The
highlights of this new development platform are:
<ul>
* A runtime environment that provides garbage
collection, threading and a virtual machine
specification (The Virtual Execution System, VES)
* A comprehensive class library.
* A new language, C#. Very similar to Java, C#
allows programmers to use all the features available
on the .NET runtime.
* A language specification that compilers can
follow if they want to generate classes and code
that can interoperate with other programming
languages (The Common Language Specification: CLS)
</ul>
The Common Language Infrastructure platform is similar to the
goals we had in GNOME of giving language independence to
programmers. It is more mature, documented, larger in scope,
and has a consistent design.
Any API that is written using a CLS provider language can be
used by any language that is a CLS consumer. Compilers
generate code in a format called Common Intermediate Language
(CIL) which is an intermediate representation of a compiled
program and is easy to compile to native code or compiled
using Just-in-Time (JIT) engines. The restrictions placed by
the runtime on the CIL byte codes ensures that it is possible
to do a good job at optimizing the code in a JIT compiler.
There is not really a lot of innovation in this platform: we
have seen all of these concepts before, and we are all
familiar with how these things work.
What makes the Common Language Infrastructure development
platform interesting is that it is a good mix of technologies
that have been nicely integrated.
The .NET development platform is essentially a new foundation
for program development that gives Microsoft a room to grow
for the coming years.
** ECMA standards.
Microsoft has submitted the
specifications of C#, the runtime, the metadata and the
other various bits of the .NET development platform to the
<a href="http://www.ecma.ch">ECMA</a> for standarization.
You can get a copy of the specifications submitted to ECMA
from: <a href="http://www.dotnetexperts.com/ecma">http://www.dotnetexperts.com/ecma</a>
** Mono: an Open Source Common Language Infrastructure implementation.
Ximian has begun work on Mono, a project that aims to bring
the Common Language Infrastructure platform to free systems.
When the GNU project was launched, they picked the best
operating system that was available out there, and they
began to clone it: Unix.
The .NET development platform is a very rich, powerful, and
well designed platform that would help improve the free
software development platform. Just like the GNU project
began to clone Unix sixteen years ago, we will be cloning the
.NET development platform because it is a great platform to
build on.
** What makes up Mono?
There are various pieces that will make up Mono:
<ul>
* A C# compiler.
* The Virtual Execution System: that will have the
Just-in-Time compiler, garbage collector, loader,
threading engine.
A byte code interpreter will be provided for quickly
porting Mono to new systems and debugging the JIT
purposes, but it is not intended to be the ideal
execution environment.
* An implemenation of the .NET class library.
* Visual development tools.
* A CIL GCC frontend.
</ul>
** Why use GNOME components?
GNOME is an umbrella project that consists of infrastructural
components (GUI toolkit, XML libraries, CORBA implementation,
printing architecture, imaging system), a desktop environment,
and productivity applications.
The GNOME infrastructural components can be used to quickly
implement various pieces of the class libraries without reinventing
the wheel, and since all those components are licensed under
the terms of the GNU LGPL it is a perfect fit.
Libart will be used to implement the Drawing.2D API; Gtk+ and
the GNOME libraries will be used to implement the WinForms
API and of course Glib and libxml will be used in various
places.
+109
View File
@@ -0,0 +1,109 @@
* Resources
There are a number of resources available for those of you who
want to contribute to the Mono project. Here are a few links.
If you want to send suggestions for links, address them to <a
mailto="[email protected]">[email protected]</a>.
** ECMA Documentation.
You can get the documentation for the ECMA specs from a number of sites:
<ul>
* <a href="http://msdn.microsoft.com/net/ecma">At MSDN</a>
* <a href="http://www.dotnetexperts.com">Dot Net Experts</a>
* <a href="http://developer.intel.com/software/idap/ecma">Intel</a>
* <a href="http://lightning.csse.monash.edu.au/.net/CLI">Monash University</a>
</ul>
These contain specifications for the assembler, the metadata,
byte codes supported by the CLI virtual machine, the C#
language and the core class libraries.
For details on the .NET class libraries, you can
visit the Microsoft's Developer Network:
<ul>
* <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/cpref_start.asp">.NET Framework Class Library</a>
</ul>
You can also get this information if you install the Beta2
release of the .NET Framework.
<a name="mailing">
** Mailing Lists
There are a number of mailing lists for Mono
<ul>
* <b><a
href="http://mail.ximian.com/mailman/listinfo/mono-list">mono-list:</a></b>
The general Mono discussion list.
* <b><a
href="http://mail.ximian.com/mailman/listinfo/mono-announce-list">mono-announce-list:</a></b>
Announcements of Mono developments.
* <b><a
href="http://mail.ximian.com/mailman/listinfo/mono-docs-list">mono-docs-list:</a></b>
Discussion on the documentation of Mono.
* <b><a
href="http://discuss.develop.com/dotnet.html">Dotnet mailing
list at Develop.com:</a></b> The guys at Develop Mentor run
this general purpose mailing list.
</ul>
** Discussion Groups.
<ul>
* <a href="http://www.oreillynet.com">O'Reilly
Network</a> has a <a
href="http://www.oreillynet.com/dotnet">section devoted to
.NET</a>
* <a
href="http://msdn.microsoft.com/newsgroups">MSDN</a> also
lists various newsgroups related to .NET</ul>
</ul>
** Other .NET related projects
There are a number of related projects to Mono:
<ul>
* <a
href="http://www.icsharpcode.net/OpenSource/SD/default.asp">Sharp
Develop:</a> an IDE for the C# language written in C#.
* <a
href="http://www.southern-storm.com.au/portable_net.html">Portable.NET:</a>
* <a href="http://nunit.sourceforge.net">NUnit:</a> A
testing framework for .NET classes.
* <a href="http://www.kaffe.org">Kaffe:</a> A popular
Free Software JIT engine for Java.
* <a href="http://www.intel.com/research/mrl/orp">ORP:</a> A research
JIT/VM/GC system from Intel.
</ul>
** GNOME Documentation
Documnetation on GNOME, and the GNOME APIs is available from
the <a href="http://developer.gnome.org">developer</a> site at
GNOME:
<ul>
* <a href="http://developer.gnome.org/doc/API/">GNOME
API documentation</a>
* <a href="http://developer.gnome.org/doc/books">GNOME
Online books</a>
* <A
href="http://developer.gnome.org/arch/">Architecture Overview</a>
</ul>
+30
View File
@@ -0,0 +1,30 @@
** MacOS Documentation
** Assembly Language Manuals online
Intel
MIPS
SPARC
** Microsoft
msdn.microsoft.com/net
Research.microsoft.com
** Related Technologies
<ul>
* The CLI allows people to create Web Services using the SOAP
protocol. SOAP is based on XML, XML schemas an the HTTP
protocol.
<ul>
* XML specification.
* XML Namespaces.
* XML Schemas.
* SOAP Specification.
</ul>
</ul>
** Compiler Information
GCC
GCC Sample front-end tutorial
+12
View File
@@ -0,0 +1,12 @@
* Roadmap
We are working on the following three projects at Ximian:
The C# Compiler (mcs/mcs)
A .NET compatible Class Library (mcs/class)
The JIT/interpreter (mono)
+133
View File
@@ -0,0 +1,133 @@
The MonoNet runtime
The MonoNet runtime will implement the JIT engine (and a byte
code interpreter for quickly porting to new systems), the
class loader, the garbage collector, threading system and
metadata access libraries.
Currently the runtime contains the beginning of an image
loader and metadata access entry points. Since Beta2 has been
now released, it is possible to resume work using the ECMA
specs and testing with Beta2-generated executables.
The runtime core will be implemented in C, in a library
"libMonoVES.so".
** Executing MSIL/CIL images
The code will load an executable and map the references to
external assemblies to our own version of the assemblies on
GNU/Linux.
Our roadmap looks like this, this has been updated as of
<b>Jul 15, 2001</b>:
<ul>
* Milestone 1: Fully read and parse all CIL byte-codes
and metadata tokens (ie, a disassembler).
* Milestone 2: Complete an interpreter for CIL byte
codes. This interpreter can be used temporarly to
run CIL byte code on a system where no JIT is
available.
* Milestone 3: Define an <i>lburg</i> instruction
selector for the JITer for Intel. Although slower
at JITing than a streaming JITer, it generates
better code. The same grammar can later be used for
the stream jitter.
* Milestone 4: Implement JITer.
* Milestone 5: Port of the JITer to non IA32 systems.
</ul>
A setup similar to the Kaffe JIT engine can be used to
layout the code to support non-IA32 architectures. Our work
will be focused on getting a IA32 version running first.
The JIT engine should work on Linux and Win32, although you
will need to install the CygWin32 development tools to get a
Unix-like compilation environment.
** JIT Engine (<b>updated, Jul 14th, 2001</b>)
We will be using a code-generator generator approach for our
JITer. Given the properties of CIL byte codes, we can take
full advantage of a real instruction selector for our code
generator.
There are a couple of books that deal with this technique: "A
Retargetable C Compiler" and "Advanced Compiler Design and
Implementation" are good references. You can also get a
technical description of <a
href="http://research.microsoft.com/copyright/accept.asp?path=http://www.research.microsoft.com/~drh/pubs/iburg.pdf&pub=ACM">lbrug</a>
Previously we had looked at a number of JIT engines and tools,
but they would not take full advantage of the CIL properties:
<ul>
* <a
href="http://www.intel.com/research/mrl/orp/">ORP</a>
* <a
href="http://www.gnu.org/software/lightning/">GNU
Lightning</a>
* href="http://www.eecs.harvard.edu/~nr/toolkit/">NJ Machine
Toolkit</a>.).
* VCODE.
</ul>
** Garbage Collection
We have decided to implement a generational tracing garbage
collector, which is very similar to the one being used by
.NET. For an introduction to the garbage collection system
used by Microsoft's CLR implementation, you can read this book
on <a
href="http://www.amazon.com/exec/obidos/ASIN/0471941484/o/qid=992556433/sr=2-1/ref=aps_sr_b_1_1/103-5866388-0492603">Garbage
Collection.</a>
Although using a conservative garbage collector like Bohem's
would work, all the type information is available at runtime,
so we can actually implement a better collector than a
conservative collector.
<ul>
* Garbage collection list and FAQ:<br>
<a href="http://www.iecc.com/gclist/">http://www.iecc.com/gclist/</a>
* The Microsoft .NET Garbage Collection Implementation:<br>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp</a>
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp</a>
</ul>
** Useful links
Paolo Molaro found a few interesting links:
<ul>
* On compilation of stack-based languages:<br>
<a href="http://www.complang.tuwien.ac.at/projects/rafts.html">
http://www.complang.tuwien.ac.at/projects/rafts.html</a>
* A paper on fast JIT compilation of a stack-based language:<br>
<a href="http://www.research.microsoft.com/~cwfraser/pldi99codegen.pdf">
http://www.research.microsoft.com/~cwfraser/pldi99codegen.pdf</a>
* Vmgen generates much of the code for efficient virtual machine (VM)
interpreters from simple descriptions of the VM instructions:<br>
<a href="http://www.complang.tuwien.ac.at/anton/vmgen/">
http://www.complang.tuwien.ac.at/anton/vmgen</a>
</ul>
** PInvoke
PInvoke will be supported, and will be used to wrap Unix API
calls, these in turn are required for reusing some of the
GNOME libraries that will reduce the work we have to do to
deliver a complete class library.
+44
View File
@@ -0,0 +1,44 @@
* Project Status
Pieces of Mono that have been implemented:
<ul>
* C# compiler: The C# parser can now generate parse
trees. Next up: semantic analysis, compiler lever optimizations
and code generation.
* Metadata library: Can currently parse and load
information from .NET modules (executables and DLL
files). It has a few bugs outstanding (table
dimension computation is incorrect).
Parsing of Exception tables is missing.
It lacks Token to (Table, Index) mapping, but this
should be trivial to write.
* Disassembler: Can disassemble .NET modules. Still
lacking exception handling as well as useful debugging
tools (hex dumping, token dumping).
* Class Libraries: Only a few classes have been
implemented.
</ul>
Tasks on the critical path:
<ul>
* Method and Field resolution.
* Bytecode interpreter: Not implemented yet.
* Simple JIT: Not implemented yet.
* Garbage collection engine.
</ul>
+2
View File
@@ -0,0 +1,2 @@
* The MonoNet Team
+21
View File
@@ -0,0 +1,21 @@
* Testing
All classes in Mono libraries should have comprehensive unit test
suites to go with them. Unit testing is a software engineering
methodology that makes it easier to build correct code. Every
method in every class should have a set of tests to verify
that they work correctly. Mono also needs a testing framework
to make it easy to write and run lots of tests.
Try <a href="http://nunit.sourceforge.net">NUnit</a>
Why do unit testing? It becomes simple to run automated tests
for the whole library. Unit tests are a safety net - you can
change part of the code and verify that you haven't broken
anything. Ideally, tests are written before the actual library
code itself. And every time a bug is discovered, a test should
be written to demonstrate the bug and its fix. Then, if
you ever reintroduce the bug, you will know immediately. For
more info, read <a
href="http://nunit.sourceforge.net/doc/testinfected/testing.html">
JUnit Test Infected: Programmers Love Writing Tests</a>.
+6
View File
@@ -0,0 +1,6 @@
* Thanks
We would like to thank Tim O'Reilly, Brian Jepson and Nathan
Torkington for their help.
Dave Winer for provided interesting comments and a to read.
+1
View File
@@ -0,0 +1 @@
Discuss with write new JIT
+25
View File
@@ -0,0 +1,25 @@
* Tools
We need a number of tools to make people productive using a
Mono-based solution. Some of these tools can be developed on
Windows before Mono is fully finished.
** Debugger
We will need a debugging API to debug CLI applications and
then a debugger component that can be used in an IDE
environment.
** Integrated Development Environment
There is already a project to create a C# development
environment (SharpDevelop). People could work with the
SharpDevelop hackers to produce a unified development environment.
** Help Browser
We need a good help browser that can be used to browse all the
Mono documentation.
+2
View File
@@ -0,0 +1,2 @@
*.src
*.html
+17
View File
@@ -0,0 +1,17 @@
0,Home,index.html,index.src
1,FAQ,faq.html,faq.src
0,Mono,rationale.html,rationale.src
1,Runtime,runtime.html,runtime.src
1,Classes,class-library.html,class-library.src
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,Contributing,contributing.html,contributing.src
1,Documentation,documentation.html,documentation.src
1,Test Suite,testing.html,testing.src
1,Tools,tools.html,tools.src
0,Download,download.html,download.src
0,Resources,resources.html,resources.src
1,Ideas,ideas.html,ideas.src
1,Passport,passport.html,passport.src
0,Contact,contact.html,contact.src
+24
View File
@@ -0,0 +1,24 @@
#!/usr/bin/perl
$q = 1;
while (<>){
chop;
if (/^\* (.*)$/){
print "<h1>$1</h1>\n";
} elsif (/^\*\* (.*)$/) {
print "<h2>$1</h2>\n";
} elsif (/^\*\*\* (.*)$/) {
print "<h3>$1</h3>\n";
} elsif (/^$/) {
print "<p>\n";
} elsif (/^\t\t\* (.*)$/) {
print "<li>$1\n";
} elsif (/^Q: (.*)$/){
print "<p><a name=\"q$q\"><b>Question $q:</b> $1\n";
$q++;
} elsif (/^A: (.*)$/){
print "$1\n";
} else {
print "$_\n";
}
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 4.8 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 4.5 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 3.3 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 4.4 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 49 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 157 B

+39
View File
@@ -0,0 +1,39 @@
SOURCES= \
../contributing \
../class-library \
../class-status \
../contact \
../c-sharp \
../documentation \
../download \
../faq \
../gcc-frontend \
../index \
../ideas \
../passport \
../rationale \
../resources \
../roadmap \
../runtime \
../status \
../testing \
../tools
all:
-mkdir site
for i in $(SOURCES); do \
perl htmlify $$i > `basename $$i`.src; \
done;
perl process.pl commands template.html.in .
clean:
for i in $(SOURCES); do \
rm -f `basename $$i`.src `basename $$i`.html; \
done;
push:
scp *.html [email protected]:/web/cvsmodules/mono
push2:
scp *.html primates:public_html/xxx
+73
View File
@@ -0,0 +1,73 @@
#!/usr/bin/perl
#
# Author:
# Sean MacIsaac
#
use strict;
my $full_expand = 1;
my @template;
my $n;
if ($#ARGV != 2) {
print "process.pl command_file template_file directory_prefix\n";
exit ();
}
my $menu = "";
open COMMANDS, $ARGV[0] || die "Can not open $ARGV[0]";
while (<COMMANDS>) {
chop;
my @command = split /,/;
if ($command[0] != -1) {
$menu .= "\t\t";
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;
open TEMPLATE, $ARGV[1] || die "Can not open $ARGV[1]";
while (<TEMPLATE>) {
push @template, $_;
}
close TEMPLATE;
open COMMANDS, $ARGV[0] || die "Can not open $ARGV[0]";
while (<COMMANDS>) {
chop;
my @command = split /,/;
$n = $ARGV[2] . "/" . $command[2];
open OUTPUT, ">" . $n || die "Can not create $n";
my $content = "";
open INPUT, $command[3] || die "Can not open $command[3]";
while (<INPUT>) {
$content .= $_;
}
close INPUT;
my $line;
my $temp;
my $tit;
my $title;
$tit = $command[1];
foreach $line (@template) {
$temp = $line;
$title = "$tit / Mono";
$temp =~ s/#TITLE#/$title/;
$temp =~ s/#CONTENT#/$content/;
$temp =~ s/#MENU#/$menu/;
print OUTPUT $temp;
}
close OUTPUT;
}
+78
View File
@@ -0,0 +1,78 @@
<html>
<head>
<title>#TITLE#</title>
<style type="text/css">
<!--
body { font-family: "trebuchet ms", lucida, verdana, helvetica;
background-image: url("images/bgsquares.gif");
background-attachment: fixed; }
body, td, table { font-family: "trebuchet ms", lucida, verdana, helvetica;
font-size: 12px; }
.navi { font-size: 14px; background: #444444; }
.subnavi { font-size: 12px; }
.footnote { font-size: 10px; color: #aaaaaa; }
a.navi { color: #ffffff; text-decoration: none; font-weight: bold; }
a.navi:visited { color: #cccccc; }
a.navi: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>
</head>
<body bgcolor="#555555" text="#000000">
<table cellpadding="0" cellspacing="0" border="0" width="100%">
<tr>
<td><img src="images/pixel.gif"></td><!-- left border -->
<td colspan="4">
<a href="/"><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"></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"></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"></td>
<td bgcolor="white">
<table cellpadding="16">
<tr><td>
#CONTENT#
</td></tr>
</table>
</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"></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>
<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>
</table>
</body>
</html>
Executable
+9
View File
@@ -0,0 +1,9 @@
C# Compiler:
Miguel de Icaza ([email protected])
Class Libraries:
Jeff Stedfast ([email protected])
Joe Shaw ([email protected])
Miguel de Icaza ([email protected])
Sean MacIsaac ([email protected])
Vladimir Vukicevic ([email protected])
Executable
+2
View File
@@ -0,0 +1,2 @@
This is the Ximian MCS C# compiler written in C#
+34
View File
@@ -0,0 +1,34 @@
The class libraries are grouped together in the assemblies they belong.
Each directory here represents an assembly, and inside each directory we
divide the code based on the namespace they implement.
* Missing implementation bits
If you implement a class and you are missing implementation bits,
please put in the code the word "TODO" and a description of what
is missing to be implemented.
* Tagging buggy code
If there is a bug in your implementation tag the problem by using
the word "FIXME" in the code, together with a description of the
problem.
Do not use XXX or obscure descriptions, because otherwise people
will not be able to understand what you mean.
* Tagging Lame specs
Sometimes the specification will be lame (consider Version.ToString (fieldCount)
where there is no way of knowing how many fields are available, making the API
not only stupid, but leading to unreliable code).
In those cases, use the keyword "LAMESPEC".
* Coding consideration
Use 8 space tabs for writing your code (hopefully we can keep
this consistent). If you are modifying someone else's code, try
to keep the coding style similar.
+4
View File
@@ -0,0 +1,4 @@
all: windows
windows:
$(csc) /target:library /out:System.Data.dll /nowarn:1595 /recurse:*.cs
+4
View File
@@ -0,0 +1,4 @@
all: windows
windows:
$(csc) /target:library /out:System.Drawing.dll /nowarn:1595 /recurse:*.cs
+4
View File
@@ -0,0 +1,4 @@
all: windows
windows:
$(csc) /target:library /out:System.Management.dll /nowarn:1595 /recurse:*.cs
+40
View File
@@ -0,0 +1,40 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// Driver.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
using System;
using System.Xml;
public class Driver
{
public static void Main(string[] args)
{
XmlReader xmlReader = null;
if (args.Length < 1)
{
xmlReader = new XmlTextReader(Console.In);
}
else
{
xmlReader = new XmlTextReader(args[0]);
}
while (xmlReader.Read())
{
Console.WriteLine("NodeType = {0}", xmlReader.NodeType);
Console.WriteLine(" Name = {0}", xmlReader.Name);
Console.WriteLine(" IsEmptyElement = {0}", xmlReader.IsEmptyElement);
Console.WriteLine(" HasAttributes = {0}", xmlReader.HasAttributes);
Console.WriteLine(" AttributeCount = {0}", xmlReader.AttributeCount);
Console.WriteLine(" HasValue = {0}", xmlReader.HasValue);
Console.WriteLine(" Value = {0}", xmlReader.Value);
}
}
}
@@ -0,0 +1,21 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Xml.ReadState.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
namespace System.Xml
{
public enum ReadState
{
Closed,
EndOfFile,
Error,
Initial,
Interactive
}
}
+817
View File
@@ -0,0 +1,817 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Xml.Test.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
using System;
using System.Diagnostics;
using System.IO;
using NUnit.Framework;
namespace System.Xml
{
public class Test : TestCase
{
public Test(string name) : base(name) { }
private void AssertStartDocument(XmlReader xmlReader)
{
Assert(xmlReader.ReadState == ReadState.Initial);
Assert(xmlReader.NodeType == XmlNodeType.None);
Assert(!xmlReader.EOF);
}
private void AssertNode(
XmlReader xmlReader,
XmlNodeType nodeType,
bool isEmptyElement,
string name,
string value,
int attributeCount)
{
Assert(xmlReader.Read());
Assert(xmlReader.ReadState == ReadState.Interactive);
Assert(!xmlReader.EOF);
Assert(xmlReader.NodeType == nodeType);
Assert(xmlReader.IsEmptyElement == isEmptyElement);
Assert(xmlReader.Name == name);
Assert(xmlReader.HasValue == (value != String.Empty));
Assert(xmlReader.Value == value);
Assert(xmlReader.HasAttributes == (attributeCount > 0));
Assert(xmlReader.AttributeCount == attributeCount);
}
private void AssertAttribute(
XmlReader xmlReader,
string name,
string value)
{
Assert(xmlReader[name] == value);
Assert(xmlReader.GetAttribute(name) == value);
}
private void AssertEndDocument(XmlReader xmlReader)
{
Assert(!xmlReader.Read());
Assert(xmlReader.NodeType == XmlNodeType.None);
Assert(xmlReader.ReadState == ReadState.EndOfFile);
Assert(xmlReader.EOF);
xmlReader.Close();
Assert(xmlReader.ReadState == ReadState.Closed);
}
public void TestEmptyElement()
{
string xml = "<foo/>";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
true, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertEndDocument(xmlReader);
}
public void TestEmptyElementWithWhitespace()
{
string xml = "<foo />";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
true, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertEndDocument(xmlReader);
}
public void TestEmptyElementWithStartAndEndTag()
{
string xml = "<foo></foo>";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
false, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.EndElement, // nodeType
false, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertEndDocument(xmlReader);
}
public void TestEmptyElementWithStartAndEndTagWithWhitespace()
{
string xml = "<foo ></foo >";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
false, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.EndElement, // nodeType
false, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertEndDocument(xmlReader);
}
public void TestNestedEmptyTag()
{
string xml = "<foo><bar/></foo>";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
false, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
true, // isEmptyElement
"bar", // name
String.Empty, // value
0 // attributeCount
);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.EndElement, // nodeType
false, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertEndDocument(xmlReader);
}
public void TestNestedText()
{
string xml = "<foo>bar</foo>";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
false, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Text, // nodeType
false, // isEmptyElement
String.Empty, // name
"bar", // value
0 // attributeCount
);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.EndElement, // nodeType
false, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertEndDocument(xmlReader);
}
public void TestEmptyElementWithAttribute()
{
string xml = @"<foo bar=""baz""/>";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
true, // isEmptyElement
"foo", // name
String.Empty, // value
1 // attributeCount
);
AssertAttribute(
xmlReader, // xmlReader
"bar", // name
"baz" // value
);
AssertEndDocument(xmlReader);
}
public void TestStartAndEndTagWithAttribute()
{
string xml = @"<foo bar='baz'></foo>";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
false, // isEmptyElement
"foo", // name
String.Empty, // value
1 // attributeCount
);
AssertAttribute(
xmlReader, // xmlReader
"bar", // name
"baz" // value
);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.EndElement, // nodeType
false, // isEmptyElement
"foo", // name
String.Empty, // value
0 // attributeCount
);
AssertEndDocument(xmlReader);
}
public void TestEmptyElementWithTwoAttributes()
{
string xml = @"<foo bar=""baz"" quux='quuux'/>";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
true, // isEmptyElement
"foo", // name
String.Empty, // value
2 // attributeCount
);
AssertAttribute(
xmlReader, // xmlReader
"bar", // name
"baz" // value
);
AssertAttribute(
xmlReader, // xmlReader
"quux", // name
"quuux" // value
);
AssertEndDocument(xmlReader);
}
public void TestProcessingInstructionBeforeDocumentElement()
{
string xml = "<?foo bar?><baz/>";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.ProcessingInstruction, // nodeType
false, // isEmptyElement
"foo", // name
"bar", // value
0 // attributeCount
);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
true, // isEmptyElement
"baz", // name
String.Empty, // value
0 // attributeCount
);
AssertEndDocument(xmlReader);
}
public void TestCommentBeforeDocumentElement()
{
string xml = "<!--foo--><bar/>";
XmlReader xmlReader =
new XmlTextReader(new StringReader(xml));
AssertStartDocument(xmlReader);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Comment, // nodeType
false, // isEmptyElement
String.Empty, // name
"foo", // value
0 // attributeCount
);
AssertNode(
xmlReader, // xmlReader
XmlNodeType.Element, // nodeType
true, // isEmptyElement
"bar", // name
String.Empty, // value
0 // attributeCount
);
AssertEndDocument(xmlReader);
}
// The following is #if'ed out because it's specific to the Mono
// implementation and won't compile when testing Microsoft's code.
// Feel free to turn it on if you want to test Mono's name tables.
#if false
public void TestIsFirstNameChar()
{
for (int ch = 0; ch <= 0xFFFF; ++ch)
{
Assert(
XmlChar.IsFirstNameChar(ch) ==
IsFirstNameChar(ch));
}
}
public void TestIsNameChar()
{
for (int ch = 0; ch <= 0xFFFF; ++ch)
{
Assert(
XmlChar.IsNameChar(ch) ==
IsNameChar(ch));
}
}
private static bool IsFirstNameChar(int ch)
{
return
IsLetter(ch) ||
(ch == '_') ||
(ch == ':');
}
private static bool IsNameChar(int ch)
{
return
IsLetter(ch) ||
IsDigit(ch) ||
(ch == '.') ||
(ch == '-') ||
(ch == '_') ||
(ch == ':') ||
IsCombiningChar(ch) ||
IsExtender(ch);
}
private static bool IsLetter(int ch)
{
return
IsBaseChar(ch) ||
IsIdeographic(ch);
}
private static bool IsBaseChar(int ch)
{
return
(ch >= 0x0041 && ch <= 0x005A) ||
(ch >= 0x0061 && ch <= 0x007A) ||
(ch >= 0x00C0 && ch <= 0x00D6) ||
(ch >= 0x00D8 && ch <= 0x00F6) ||
(ch >= 0x00F8 && ch <= 0x00FF) ||
(ch >= 0x0100 && ch <= 0x0131) ||
(ch >= 0x0134 && ch <= 0x013E) ||
(ch >= 0x0141 && ch <= 0x0148) ||
(ch >= 0x014A && ch <= 0x017E) ||
(ch >= 0x0180 && ch <= 0x01C3) ||
(ch >= 0x01CD && ch <= 0x01F0) ||
(ch >= 0x01F4 && ch <= 0x01F5) ||
(ch >= 0x01FA && ch <= 0x0217) ||
(ch >= 0x0250 && ch <= 0x02A8) ||
(ch >= 0x02BB && ch <= 0x02C1) ||
(ch == 0x0386) ||
(ch >= 0x0388 && ch <= 0x038A) ||
(ch == 0x038C) ||
(ch >= 0x038E && ch <= 0x03A1) ||
(ch >= 0x03A3 && ch <= 0x03CE) ||
(ch >= 0x03D0 && ch <= 0x03D6) ||
(ch == 0x03DA) ||
(ch == 0x03DC) ||
(ch == 0x03DE) ||
(ch == 0x03E0) ||
(ch >= 0x03E2 && ch <= 0x03F3) ||
(ch >= 0x0401 && ch <= 0x040C) ||
(ch >= 0x040E && ch <= 0x044F) ||
(ch >= 0x0451 && ch <= 0x045C) ||
(ch >= 0x045E && ch <= 0x0481) ||
(ch >= 0x0490 && ch <= 0x04C4) ||
(ch >= 0x04C7 && ch <= 0x04C8) ||
(ch >= 0x04CB && ch <= 0x04CC) ||
(ch >= 0x04D0 && ch <= 0x04EB) ||
(ch >= 0x04EE && ch <= 0x04F5) ||
(ch >= 0x04F8 && ch <= 0x04F9) ||
(ch >= 0x0531 && ch <= 0x0556) ||
(ch == 0x0559) ||
(ch >= 0x0561 && ch <= 0x0586) ||
(ch >= 0x05D0 && ch <= 0x05EA) ||
(ch >= 0x05F0 && ch <= 0x05F2) ||
(ch >= 0x0621 && ch <= 0x063A) ||
(ch >= 0x0641 && ch <= 0x064A) ||
(ch >= 0x0671 && ch <= 0x06B7) ||
(ch >= 0x06BA && ch <= 0x06BE) ||
(ch >= 0x06C0 && ch <= 0x06CE) ||
(ch >= 0x06D0 && ch <= 0x06D3) ||
(ch == 0x06D5) ||
(ch >= 0x06E5 && ch <= 0x06E6) ||
(ch >= 0x0905 && ch <= 0x0939) ||
(ch == 0x093D) ||
(ch >= 0x0958 && ch <= 0x0961) ||
(ch >= 0x0985 && ch <= 0x098C) ||
(ch >= 0x098F && ch <= 0x0990) ||
(ch >= 0x0993 && ch <= 0x09A8) ||
(ch >= 0x09AA && ch <= 0x09B0) ||
(ch == 0x09B2) ||
(ch >= 0x09B6 && ch <= 0x09B9) ||
(ch >= 0x09DC && ch <= 0x09DD) ||
(ch >= 0x09DF && ch <= 0x09E1) ||
(ch >= 0x09F0 && ch <= 0x09F1) ||
(ch >= 0x0A05 && ch <= 0x0A0A) ||
(ch >= 0x0A0F && ch <= 0x0A10) ||
(ch >= 0x0A13 && ch <= 0x0A28) ||
(ch >= 0x0A2A && ch <= 0x0A30) ||
(ch >= 0x0A32 && ch <= 0x0A33) ||
(ch >= 0x0A35 && ch <= 0x0A36) ||
(ch >= 0x0A38 && ch <= 0x0A39) ||
(ch >= 0x0A59 && ch <= 0x0A5C) ||
(ch == 0x0A5E) ||
(ch >= 0x0A72 && ch <= 0x0A74) ||
(ch >= 0x0A85 && ch <= 0x0A8B) ||
(ch == 0x0A8D) ||
(ch >= 0x0A8F && ch <= 0x0A91) ||
(ch >= 0x0A93 && ch <= 0x0AA8) ||
(ch >= 0x0AAA && ch <= 0x0AB0) ||
(ch >= 0x0AB2 && ch <= 0x0AB3) ||
(ch >= 0x0AB5 && ch <= 0x0AB9) ||
(ch == 0x0ABD) ||
(ch == 0x0AE0) ||
(ch >= 0x0B05 && ch <= 0x0B0C) ||
(ch >= 0x0B0F && ch <= 0x0B10) ||
(ch >= 0x0B13 && ch <= 0x0B28) ||
(ch >= 0x0B2A && ch <= 0x0B30) ||
(ch >= 0x0B32 && ch <= 0x0B33) ||
(ch >= 0x0B36 && ch <= 0x0B39) ||
(ch == 0x0B3D) ||
(ch >= 0x0B5C && ch <= 0x0B5D) ||
(ch >= 0x0B5F && ch <= 0x0B61) ||
(ch >= 0x0B85 && ch <= 0x0B8A) ||
(ch >= 0x0B8E && ch <= 0x0B90) ||
(ch >= 0x0B92 && ch <= 0x0B95) ||
(ch >= 0x0B99 && ch <= 0x0B9A) ||
(ch == 0x0B9C) ||
(ch >= 0x0B9E && ch <= 0x0B9F) ||
(ch >= 0x0BA3 && ch <= 0x0BA4) ||
(ch >= 0x0BA8 && ch <= 0x0BAA) ||
(ch >= 0x0BAE && ch <= 0x0BB5) ||
(ch >= 0x0BB7 && ch <= 0x0BB9) ||
(ch >= 0x0C05 && ch <= 0x0C0C) ||
(ch >= 0x0C0E && ch <= 0x0C10) ||
(ch >= 0x0C12 && ch <= 0x0C28) ||
(ch >= 0x0C2A && ch <= 0x0C33) ||
(ch >= 0x0C35 && ch <= 0x0C39) ||
(ch >= 0x0C60 && ch <= 0x0C61) ||
(ch >= 0x0C85 && ch <= 0x0C8C) ||
(ch >= 0x0C8E && ch <= 0x0C90) ||
(ch >= 0x0C92 && ch <= 0x0CA8) ||
(ch >= 0x0CAA && ch <= 0x0CB3) ||
(ch >= 0x0CB5 && ch <= 0x0CB9) ||
(ch == 0x0CDE) ||
(ch >= 0x0CE0 && ch <= 0x0CE1) ||
(ch >= 0x0D05 && ch <= 0x0D0C) ||
(ch >= 0x0D0E && ch <= 0x0D10) ||
(ch >= 0x0D12 && ch <= 0x0D28) ||
(ch >= 0x0D2A && ch <= 0x0D39) ||
(ch >= 0x0D60 && ch <= 0x0D61) ||
(ch >= 0x0E01 && ch <= 0x0E2E) ||
(ch == 0x0E30) ||
(ch >= 0x0E32 && ch <= 0x0E33) ||
(ch >= 0x0E40 && ch <= 0x0E45) ||
(ch >= 0x0E81 && ch <= 0x0E82) ||
(ch == 0x0E84) ||
(ch >= 0x0E87 && ch <= 0x0E88) ||
(ch == 0x0E8A) ||
(ch == 0x0E8D) ||
(ch >= 0x0E94 && ch <= 0x0E97) ||
(ch >= 0x0E99 && ch <= 0x0E9F) ||
(ch >= 0x0EA1 && ch <= 0x0EA3) ||
(ch == 0x0EA5) ||
(ch == 0x0EA7) ||
(ch >= 0x0EAA && ch <= 0x0EAB) ||
(ch >= 0x0EAD && ch <= 0x0EAE) ||
(ch == 0x0EB0) ||
(ch >= 0x0EB2 && ch <= 0x0EB3) ||
(ch == 0x0EBD) ||
(ch >= 0x0EC0 && ch <= 0x0EC4) ||
(ch >= 0x0F40 && ch <= 0x0F47) ||
(ch >= 0x0F49 && ch <= 0x0F69) ||
(ch >= 0x10A0 && ch <= 0x10C5) ||
(ch >= 0x10D0 && ch <= 0x10F6) ||
(ch == 0x1100) ||
(ch >= 0x1102 && ch <= 0x1103) ||
(ch >= 0x1105 && ch <= 0x1107) ||
(ch == 0x1109) ||
(ch >= 0x110B && ch <= 0x110C) ||
(ch >= 0x110E && ch <= 0x1112) ||
(ch == 0x113C) ||
(ch == 0x113E) ||
(ch == 0x1140) ||
(ch == 0x114C) ||
(ch == 0x114E) ||
(ch == 0x1150) ||
(ch >= 0x1154 && ch <= 0x1155) ||
(ch == 0x1159) ||
(ch >= 0x115F && ch <= 0x1161) ||
(ch == 0x1163) ||
(ch == 0x1165) ||
(ch == 0x1167) ||
(ch == 0x1169) ||
(ch >= 0x116D && ch <= 0x116E) ||
(ch >= 0x1172 && ch <= 0x1173) ||
(ch == 0x1175) ||
(ch == 0x119E) ||
(ch == 0x11A8) ||
(ch == 0x11AB) ||
(ch >= 0x11AE && ch <= 0x11AF) ||
(ch >= 0x11B7 && ch <= 0x11B8) ||
(ch == 0x11BA) ||
(ch >= 0x11BC && ch <= 0x11C2) ||
(ch == 0x11EB) ||
(ch == 0x11F0) ||
(ch == 0x11F9) ||
(ch >= 0x1E00 && ch <= 0x1E9B) ||
(ch >= 0x1EA0 && ch <= 0x1EF9) ||
(ch >= 0x1F00 && ch <= 0x1F15) ||
(ch >= 0x1F18 && ch <= 0x1F1D) ||
(ch >= 0x1F20 && ch <= 0x1F45) ||
(ch >= 0x1F48 && ch <= 0x1F4D) ||
(ch >= 0x1F50 && ch <= 0x1F57) ||
(ch == 0x1F59) ||
(ch == 0x1F5B) ||
(ch == 0x1F5D) ||
(ch >= 0x1F5F && ch <= 0x1F7D) ||
(ch >= 0x1F80 && ch <= 0x1FB4) ||
(ch >= 0x1FB6 && ch <= 0x1FBC) ||
(ch == 0x1FBE) ||
(ch >= 0x1FC2 && ch <= 0x1FC4) ||
(ch >= 0x1FC6 && ch <= 0x1FCC) ||
(ch >= 0x1FD0 && ch <= 0x1FD3) ||
(ch >= 0x1FD6 && ch <= 0x1FDB) ||
(ch >= 0x1FE0 && ch <= 0x1FEC) ||
(ch >= 0x1FF2 && ch <= 0x1FF4) ||
(ch >= 0x1FF6 && ch <= 0x1FFC) ||
(ch == 0x2126) ||
(ch >= 0x212A && ch <= 0x212B) ||
(ch == 0x212E) ||
(ch >= 0x2180 && ch <= 0x2182) ||
(ch >= 0x3041 && ch <= 0x3094) ||
(ch >= 0x30A1 && ch <= 0x30FA) ||
(ch >= 0x3105 && ch <= 0x312C) ||
(ch >= 0xAC00 && ch <= 0xD7A3);
}
private static bool IsIdeographic(int ch)
{
return
(ch >= 0x4E00 && ch <= 0x9FA5) ||
(ch == 0x3007) ||
(ch >= 0x3021 && ch <= 0x3029);
}
private static bool IsDigit(int ch)
{
return
(ch >= 0x0030 && ch <= 0x0039) ||
(ch >= 0x0660 && ch <= 0x0669) ||
(ch >= 0x06F0 && ch <= 0x06F9) ||
(ch >= 0x0966 && ch <= 0x096F) ||
(ch >= 0x09E6 && ch <= 0x09EF) ||
(ch >= 0x0A66 && ch <= 0x0A6F) ||
(ch >= 0x0AE6 && ch <= 0x0AEF) ||
(ch >= 0x0B66 && ch <= 0x0B6F) ||
(ch >= 0x0BE7 && ch <= 0x0BEF) ||
(ch >= 0x0C66 && ch <= 0x0C6F) ||
(ch >= 0x0CE6 && ch <= 0x0CEF) ||
(ch >= 0x0D66 && ch <= 0x0D6F) ||
(ch >= 0x0E50 && ch <= 0x0E59) ||
(ch >= 0x0ED0 && ch <= 0x0ED9) ||
(ch >= 0x0F20 && ch <= 0x0F29);
}
private static bool IsCombiningChar(int ch)
{
return
(ch >= 0x0300 && ch <= 0x0345) ||
(ch >= 0x0360 && ch <= 0x0361) ||
(ch >= 0x0483 && ch <= 0x0486) ||
(ch >= 0x0591 && ch <= 0x05A1) ||
(ch >= 0x05A3 && ch <= 0x05B9) ||
(ch >= 0x05BB && ch <= 0x05BD) ||
(ch == 0x05BF) ||
(ch >= 0x05C1 && ch <= 0x05C2) ||
(ch == 0x05C4) ||
(ch >= 0x064B && ch <= 0x0652) ||
(ch == 0x0670) ||
(ch >= 0x06D6 && ch <= 0x06DC) ||
(ch >= 0x06DD && ch <= 0x06DF) ||
(ch >= 0x06E0 && ch <= 0x06E4) ||
(ch >= 0x06E7 && ch <= 0x06E8) ||
(ch >= 0x06EA && ch <= 0x06ED) ||
(ch >= 0x0901 && ch <= 0x0903) ||
(ch == 0x093C) ||
(ch >= 0x093E && ch <= 0x094C) ||
(ch == 0x094D) ||
(ch >= 0x0951 && ch <= 0x0954) ||
(ch >= 0x0962 && ch <= 0x0963) ||
(ch >= 0x0981 && ch <= 0x0983) ||
(ch == 0x09BC) ||
(ch == 0x09BE) ||
(ch == 0x09BF) ||
(ch >= 0x09C0 && ch <= 0x09C4) ||
(ch >= 0x09C7 && ch <= 0x09C8) ||
(ch >= 0x09CB && ch <= 0x09CD) ||
(ch == 0x09D7) ||
(ch >= 0x09E2 && ch <= 0x09E3) ||
(ch == 0x0A02) ||
(ch == 0x0A3C) ||
(ch == 0x0A3E) ||
(ch == 0x0A3F) ||
(ch >= 0x0A40 && ch <= 0x0A42) ||
(ch >= 0x0A47 && ch <= 0x0A48) ||
(ch >= 0x0A4B && ch <= 0x0A4D) ||
(ch >= 0x0A70 && ch <= 0x0A71) ||
(ch >= 0x0A81 && ch <= 0x0A83) ||
(ch == 0x0ABC) ||
(ch >= 0x0ABE && ch <= 0x0AC5) ||
(ch >= 0x0AC7 && ch <= 0x0AC9) ||
(ch >= 0x0ACB && ch <= 0x0ACD) ||
(ch >= 0x0B01 && ch <= 0x0B03) ||
(ch == 0x0B3C) ||
(ch >= 0x0B3E && ch <= 0x0B43) ||
(ch >= 0x0B47 && ch <= 0x0B48) ||
(ch >= 0x0B4B && ch <= 0x0B4D) ||
(ch >= 0x0B56 && ch <= 0x0B57) ||
(ch >= 0x0B82 && ch <= 0x0B83) ||
(ch >= 0x0BBE && ch <= 0x0BC2) ||
(ch >= 0x0BC6 && ch <= 0x0BC8) ||
(ch >= 0x0BCA && ch <= 0x0BCD) ||
(ch == 0x0BD7) ||
(ch >= 0x0C01 && ch <= 0x0C03) ||
(ch >= 0x0C3E && ch <= 0x0C44) ||
(ch >= 0x0C46 && ch <= 0x0C48) ||
(ch >= 0x0C4A && ch <= 0x0C4D) ||
(ch >= 0x0C55 && ch <= 0x0C56) ||
(ch >= 0x0C82 && ch <= 0x0C83) ||
(ch >= 0x0CBE && ch <= 0x0CC4) ||
(ch >= 0x0CC6 && ch <= 0x0CC8) ||
(ch >= 0x0CCA && ch <= 0x0CCD) ||
(ch >= 0x0CD5 && ch <= 0x0CD6) ||
(ch >= 0x0D02 && ch <= 0x0D03) ||
(ch >= 0x0D3E && ch <= 0x0D43) ||
(ch >= 0x0D46 && ch <= 0x0D48) ||
(ch >= 0x0D4A && ch <= 0x0D4D) ||
(ch == 0x0D57) ||
(ch == 0x0E31) ||
(ch >= 0x0E34 && ch <= 0x0E3A) ||
(ch >= 0x0E47 && ch <= 0x0E4E) ||
(ch == 0x0EB1) ||
(ch >= 0x0EB4 && ch <= 0x0EB9) ||
(ch >= 0x0EBB && ch <= 0x0EBC) ||
(ch >= 0x0EC8 && ch <= 0x0ECD) ||
(ch >= 0x0F18 && ch <= 0x0F19) ||
(ch == 0x0F35) ||
(ch == 0x0F37) ||
(ch == 0x0F39) ||
(ch == 0x0F3E) ||
(ch == 0x0F3F) ||
(ch >= 0x0F71 && ch <= 0x0F84) ||
(ch >= 0x0F86 && ch <= 0x0F8B) ||
(ch >= 0x0F90 && ch <= 0x0F95) ||
(ch == 0x0F97) ||
(ch >= 0x0F99 && ch <= 0x0FAD) ||
(ch >= 0x0FB1 && ch <= 0x0FB7) ||
(ch == 0x0FB9) ||
(ch >= 0x20D0 && ch <= 0x20DC) ||
(ch == 0x20E1) ||
(ch >= 0x302A && ch <= 0x302F) ||
(ch == 0x3099) ||
(ch == 0x309A);
}
private static bool IsExtender(int ch)
{
return
(ch == 0x00B7) ||
(ch == 0x02D0) ||
(ch == 0x02D1) ||
(ch == 0x0387) ||
(ch == 0x0640) ||
(ch == 0x0E46) ||
(ch == 0x0EC6) ||
(ch == 0x3005) ||
(ch >= 0x3031 && ch <= 0x3035) ||
(ch >= 0x309D && ch <= 0x309E) ||
(ch >= 0x30FC && ch <= 0x30FE);
}
#endif
public void TestIsName()
{
Assert(XmlReader.IsName("foo"));
Assert(!XmlReader.IsName("1foo"));
Assert(!XmlReader.IsName(" foo"));
}
public void TestIsNameToken()
{
Assert(XmlReader.IsNameToken("foo"));
Assert(XmlReader.IsNameToken("1foo"));
Assert(!XmlReader.IsNameToken(" foo"));
}
}
}
+202
View File
@@ -0,0 +1,202 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Xml.XmlChar.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
using System;
namespace System.Xml
{
internal class XmlChar
{
internal static bool IsWhitespace(int ch)
{
return ch == 0x20 || ch == 0x9 || ch == 0xD || ch == 0xA;
}
internal static bool IsFirstNameChar(int ch)
{
bool result = false;
if (ch >= 0 && ch <= 0xFFFF)
{
result = (nameBitmap[(firstNamePages[ch >> 8] << 3) + ((ch & 0xFF) >> 5)] & (1 << (ch & 0x1F))) != 0;
}
return result;
}
internal static bool IsNameChar(int ch)
{
bool result = false;
if (ch >= 0 && ch <= 0xFFFF)
{
result = (nameBitmap[(namePages[ch >> 8] << 3) + ((ch & 0xFF) >> 5)] & (1 << (ch & 0x1F))) != 0;
}
return result;
}
private static byte[] firstNamePages =
{
0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00,
0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
private static byte[] namePages =
{
0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00,
0x00, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
0x26, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
private static uint[] nameBitmap =
{
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0x00000000, 0x04000000, 0x87FFFFFE, 0x07FFFFFE,
0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFE00F, 0xFC31FFFF,
0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
0xFFFF0003, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF,
0x00000000, 0x07FFFFFE, 0x000007FE, 0xFFFE0000,
0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003,
0xFFF99FE0, 0x03C5FDFF, 0xB0000000, 0x00030003,
0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001,
0xFFF99FE0, 0x23CDFDFF, 0xB0000000, 0x00000003,
0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003,
0xFFFDDFE0, 0x03EFFDFF, 0x40000000, 0x00000003,
0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xFFFFFFFE, 0x000D7FFF, 0x0000003F, 0x00000000,
0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF,
0x0007DAED, 0x50000000, 0x82315001, 0x002C62AB,
0x40000000, 0xF580C900, 0x00000007, 0x02010800,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0x0FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x03FFFFFF,
0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF,
0x00000000, 0x00004C40, 0x00000000, 0x00000000,
0x00000007, 0x00000000, 0x00000000, 0x00000000,
0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF,
0x001FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x07FFFFFF,
0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0xFFFFFFFF, 0x0000000F, 0x00000000, 0x00000000,
0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF,
0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003,
0xFFFFD7C0, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF,
0xFFFFFFFF, 0x7CFFFFFF, 0xFFEF7FFF, 0x03FF3DFF,
0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF,
0xFFF987E4, 0xD36DFDFF, 0x5E003987, 0x001FFFC0,
0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3,
0xD63DC7EC, 0xC3BFC718, 0x00803DC7, 0x0000FF80,
0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3,
0xFFFDDFEC, 0xC3FFFDFF, 0x00803DCF, 0x0000FFC3,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000,
0xFEF02596, 0x3BFF6CAE, 0x03FF3F5F, 0x00000000,
0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF,
0x661FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x77FFFFFF
};
}
}
@@ -0,0 +1,20 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Xml.XmlNameTable.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
namespace System.Xml
{
public abstract class XmlNameTable
{
public abstract string Add(string name);
public abstract string Add(char[] buffer, int offset, int length);
public abstract string Get(string name);
public abstract string Get(char[] buffer, int offset, int length);
}
}
@@ -0,0 +1,22 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Xml.XmlNamespaceManager.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
using System.Collections;
namespace System.Xml
{
public class XmlNamespaceManager : IEnumerable
{
public IEnumerator GetEnumerator()
{
return null;
}
}
}
@@ -0,0 +1,34 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Xml.XmlNodeType.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
namespace System.Xml
{
public enum XmlNodeType
{
Attribute,
CDATA,
Comment,
Document,
DocumentFragment,
DocumentType,
Element,
EndElement,
EndEntity,
Entity,
EntityReference,
None,
Notation,
ProcessingInstruction,
SignifigantWhitespace,
Text,
Whitespace,
XmlDeclaration
}
}
@@ -0,0 +1,127 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Xml.XmlParserContext.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
namespace System.Xml
{
public class XmlParserContext
{
// constructors
public XmlParserContext(
XmlNameTable nameTable,
XmlNamespaceManager namespaceManager,
string xmlLang,
XmlSpace xmlSpace) :
this(
nameTable,
namespaceManager,
null,
null,
null,
null,
null,
xmlLang,
xmlSpace
)
{
}
public XmlParserContext(
XmlNameTable nameTable,
XmlNamespaceManager namespaceManager,
string docTypeName,
string publicID,
string systemID,
string internalSubset,
string baseURI,
string xmlLang,
XmlSpace xmlSpace)
{
this.nameTable = nameTable;
this.namespaceManager = namespaceManager;
this.docTypeName = docTypeName;
this.publicID = publicID;
this.systemID = systemID;
this.internalSubset = internalSubset;
this.baseURI = baseURI;
this.xmlLang = xmlLang;
this.xmlSpace = xmlSpace;
}
// properties
public string BaseURI
{
get { return baseURI; }
set { baseURI = value; }
}
public string DocTypeName
{
get { return docTypeName; }
set { docTypeName = value; }
}
public string InternalSubset
{
get { return internalSubset; }
set { internalSubset = value; }
}
public XmlNamespaceManager NamespaceManager
{
get { return namespaceManager; }
set { namespaceManager = value; }
}
public XmlNameTable NameTable
{
get { return nameTable; }
set { nameTable = nameTable; }
}
public string PublicId
{
get { return publicID; }
set { publicID = value; }
}
public string SystemId
{
get { return systemID; }
set { systemID = value; }
}
public string XmlLang
{
get { return xmlLang; }
set { xmlLang = value; }
}
public XmlSpace XmlSpace
{
get { return xmlSpace; }
set { xmlSpace = value; }
}
// privates
private string baseURI;
private string docTypeName;
private string internalSubset;
private XmlNamespaceManager namespaceManager;
private XmlNameTable nameTable;
private string publicID;
private string systemID;
private string xmlLang;
private XmlSpace xmlSpace;
}
}
@@ -0,0 +1,238 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Xml.XmlReader.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
namespace System.Xml
{
public abstract class XmlReader
{
// properties
public abstract int AttributeCount { get; }
public abstract string BaseURI { get; }
public virtual bool CanResolveEntity
{
get
{
return false;
}
}
public abstract int Depth { get; }
public abstract bool EOF { get; }
public virtual bool HasAttributes
{
get
{
return AttributeCount > 0;
}
}
public abstract bool HasValue { get; }
public abstract bool IsDefault { get; }
public abstract bool IsEmptyElement { get; }
public abstract string this[int i] { get; }
public abstract string this[string name] { get; }
public abstract string this[
string localName,
string namespaceName]
{ get; }
public abstract string LocalName { get; }
public abstract string Name { get; }
public abstract string NamespaceURI { get; }
public abstract XmlNameTable NameTable { get; }
public abstract XmlNodeType NodeType { get; }
public abstract string Prefix { get; }
public abstract char QuoteChar { get; }
public abstract ReadState ReadState { get; }
public abstract string Value { get; }
public abstract string XmlLang { get; }
public abstract XmlSpace XmlSpace { get; }
// methods
public abstract void Close();
public abstract string GetAttribute(int i);
public abstract string GetAttribute(string name);
public abstract string GetAttribute(
string localName,
string namespaceName);
public static bool IsName(string s)
{
bool result = false;
if (s != null && s.Length > 0)
{
char[] chars = s.ToCharArray();
if (XmlChar.IsFirstNameChar(chars[0]))
{
int i = 1;
int n = chars.Length;
while (i < n && XmlChar.IsNameChar(chars[i]))
{
++i;
}
result = i == n;
}
}
return result;
}
public static bool IsNameToken(string s)
{
bool result = false;
if (s != null && s.Length > 0)
{
char[] chars = s.ToCharArray();
int i = 0;
int n = chars.Length;
while (i < n && XmlChar.IsNameChar(chars[i]))
{
++i;
}
result = i == n;
}
return result;
}
public virtual bool IsStartElement()
{
// TODO: implement me.
return false;
}
public virtual bool IsStartElement(string name)
{
// TODO: implement me.
return false;
}
public virtual bool IsStartElement(
string localName,
string namespaceName)
{
// TODO: implement me.
return false;
}
public abstract string LookupNamespace(string prefix);
public abstract void MoveToAttribute(int i);
public abstract bool MoveToAttribute(string name);
public abstract bool MoveToAttribute(
string localName,
string namespaceName);
public virtual XmlNodeType MoveToContent()
{
// TODO: implement me.
return XmlNodeType.None;
}
public abstract bool MoveToElement();
public abstract bool MoveToFirstAttribute();
public abstract bool MoveToNextAttribute();
public abstract bool Read();
public abstract bool ReadAttributeValue();
public virtual string ReadElementString()
{
// TODO: implement me.
return null;
}
public virtual string ReadElementString(string name)
{
// TODO: implement me.
return null;
}
public virtual string ReadElementString(
string localName,
string namespaceName)
{
// TODO: implement me.
return null;
}
public virtual void ReadEndElement()
{
// TODO: implement me.
}
public abstract string ReadInnerXml();
public abstract string ReadOuterXml();
public virtual void ReadStartElement()
{
// TODO: implement me.
}
public virtual void ReadStartElement(string name)
{
// TODO: implement me.
}
public virtual void ReadStartElement(
string localName,
string namespaceName)
{
// TODO: implement me.
}
public abstract string ReadString();
public abstract void ResolveEntity();
public virtual void Skip()
{
// TODO: implement me.
}
}
}
@@ -0,0 +1,19 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Xml.XmlSpace.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
namespace System.Xml
{
public enum XmlSpace
{
Default,
None,
Preserve
}
}
@@ -0,0 +1,797 @@
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Xml.XmlTextReader.cs
//
// Author:
// Jason Diamond ([email protected])
//
// (C) 2001 Jason Diamond http://injektilo.org/
//
// FIXME:
// This can only parse basic XML: elements, attributes, processing
// instructions, and comments are OK but there's no support for
// entity/character references or namespaces yet.
//
// It barfs on DOCTYPE declarations and CDATA sections.
//
// There's also no checking being done for either well-formedness
// or validity.
//
// ParserContext and NameTables aren't being used yet.
//
// The XmlTextReader-specific properties and methods have yet to
// be added or implemented.
//
// Some thought needs to be given to performance. There's too many
// strings and string builders being allocated.
//
// None of the MoveTo methods have been implemented yet.
//
// LineNumber and LinePosition aren't being tracked.
//
// xml:space, xml:lang, and xml:base aren't being tracked.
//
// Depth isn't being tracked.
using System;
using System.Collections;
using System.IO;
using System.Net;
using System.Text;
namespace System.Xml
{
public class XmlTextReader : XmlReader
{
// constructors
protected XmlTextReader()
{
Init();
}
public XmlTextReader(Stream input)
{
Init();
reader = new StreamReader(
input,
Encoding.UTF8,
true);
}
public XmlTextReader(string url)
{
Init();
WebClient client = new WebClient();
reader = new StreamReader(
client.OpenRead(url),
Encoding.UTF8,
true);
}
public XmlTextReader(TextReader input)
{
Init();
reader = input;
}
public XmlTextReader(Stream input, XmlNameTable nameTable)
{
// TODO: implement me.
throw new NotImplementedException();
}
public XmlTextReader(string baseURI, Stream input)
{
// TODO: implement me.
throw new NotImplementedException();
}
public XmlTextReader(string baseURI, TextReader input)
{
// TODO: implement me.
throw new NotImplementedException();
}
public XmlTextReader(string url, XmlNameTable nameTable)
{
// TODO: implement me.
throw new NotImplementedException();
}
public XmlTextReader(
TextReader input,
XmlNameTable nameTable)
{
// TODO: implement me.
throw new NotImplementedException();
}
public XmlTextReader(
Stream inputFragment,
XmlNodeType fragmentType,
XmlParserContext context)
{
// TODO: implement me.
throw new NotImplementedException();
}
public XmlTextReader(
string baseURI,
Stream input,
XmlNameTable nameTable)
{
// TODO: implement me.
throw new NotImplementedException();
}
public XmlTextReader(
string baseURI,
TextReader input,
XmlNameTable nameTable)
{
// TODO: implement me.
throw new NotImplementedException();
}
public XmlTextReader(
string fragment,
XmlNodeType fragmentType,
XmlParserContext context)
{
// TODO: implement me.
throw new NotImplementedException();
}
// properties
public override int AttributeCount
{
get
{
return attributes.Count;
}
}
public override string BaseURI
{
get
{
// TODO: implement me.
return null;
}
}
public override bool CanResolveEntity
{
get
{
// TODO: implement me.
return false;
}
}
public override int Depth
{
get
{
// TODO: implement me.
return 0;
}
}
public override bool EOF
{
get
{
return
readState == ReadState.EndOfFile ||
readState == ReadState.Closed;
}
}
public override bool HasValue
{
get
{
return value != String.Empty;
}
}
public override bool IsDefault
{
get
{
// TODO: implement me.
return false;
}
}
public override bool IsEmptyElement
{
get
{
return isEmptyElement;
}
}
public override string this[int i]
{
get
{
return GetAttribute(i);
}
}
public override string this[string name]
{
get
{
return GetAttribute(name);
}
}
public override string this[
string localName,
string namespaceName]
{
get
{
return GetAttribute(localName, namespaceName);
}
}
public override string LocalName
{
get
{
// TODO: implement me.
return null;
}
}
public override string Name
{
get
{
return name;
}
}
public override string NamespaceURI
{
get
{
// TODO: implement me.
return null;
}
}
public override XmlNameTable NameTable
{
get
{
// TODO: implement me.
return null;
}
}
public override XmlNodeType NodeType
{
get
{
return nodeType;
}
}
public override string Prefix
{
get
{
// TODO: implement me.
return null;
}
}
public override char QuoteChar
{
get
{
// TODO: implement me.
return '"';
}
}
public override ReadState ReadState
{
get
{
return readState;
}
}
public override string Value
{
get
{
return value;
}
}
public override string XmlLang
{
get
{
// TODO: implement me.
return null;
}
}
public override XmlSpace XmlSpace
{
get
{
// TODO: implement me.
return XmlSpace.Default;
}
}
// methods
public override void Close()
{
readState = ReadState.Closed;
}
public override string GetAttribute(int i)
{
// TODO: implement me.
return null;
}
public override string GetAttribute(string name)
{
return (string)attributes[name];
}
public override string GetAttribute(
string localName,
string namespaceName)
{
// TODO: implement me.
return null;
}
public override string LookupNamespace(string prefix)
{
// TODO: implement me.
return null;
}
public override void MoveToAttribute(int i)
{
// TODO: implement me.
}
public override bool MoveToAttribute(string name)
{
// TODO: implement me.
return false;
}
public override bool MoveToAttribute(
string localName,
string namespaceName)
{
// TODO: implement me.
return false;
}
public override bool MoveToElement()
{
// TODO: implement me.
return false;
}
public override bool MoveToFirstAttribute()
{
// TODO: implement me.
return false;
}
public override bool MoveToNextAttribute()
{
// TODO: implement me.
return false;
}
public override bool Read()
{
bool more = false;
readState = ReadState.Interactive;
more = ReadContent();
return more;
}
public override bool ReadAttributeValue()
{
// TODO: implement me.
return false;
}
public override string ReadInnerXml()
{
// TODO: implement me.
return null;
}
public override string ReadOuterXml()
{
// TODO: implement me.
return null;
}
public override string ReadString()
{
// TODO: implement me.
return null;
}
public override void ResolveEntity()
{
// TODO: implement me.
}
// privates
private TextReader reader;
private ReadState readState;
private XmlNodeType nodeType;
private string name;
private bool isEmptyElement;
private string value;
private Hashtable attributes;
private void Init()
{
readState = ReadState.Initial;
nodeType = XmlNodeType.None;
name = String.Empty;
isEmptyElement = false;
value = String.Empty;
attributes = new Hashtable();
}
// Use this method rather than setting the properties
// directly so that all the necessary properties can
// be changed in harmony with each other. Maybe the
// fields should be in a seperate class to help enforce
// this.
private void SetProperties(
XmlNodeType nodeType,
string name,
bool isEmptyElement,
string value,
bool clearAttributes)
{
this.nodeType = nodeType;
this.name = name;
this.isEmptyElement = isEmptyElement;
this.value = value;
if (clearAttributes)
{
ClearAttributes();
}
}
private void AddAttribute(string name, string value)
{
attributes.Add(name, value);
}
private void ClearAttributes()
{
attributes.Clear();
}
// This should really keep track of some state so
// that it's not possible to have more than one document
// element or text outside of the document element.
private bool ReadContent()
{
bool more = false;
switch (reader.Peek())
{
case '<':
reader.Read();
ReadTag();
more = true;
break;
case -1:
readState = ReadState.EndOfFile;
SetProperties(
XmlNodeType.None, // nodeType
String.Empty, // name
false, // isEmptyElement
String.Empty, // value
true // clearAttributes
);
more = false;
break;
default:
ReadText();
more = true;
break;
}
return more;
}
// The leading '<' has already been consumed.
private void ReadTag()
{
switch (reader.Peek())
{
case '/':
reader.Read();
ReadEndTag();
break;
case '?':
reader.Read();
ReadProcessingInstruction();
break;
case '!':
reader.Read();
ReadComment();
break;
default:
ReadStartTag();
break;
}
}
// The leading '<' has already been consumed.
private void ReadStartTag()
{
string name = ReadName();
SkipWhitespace();
bool isEmptyElement = false;
ClearAttributes();
if (XmlChar.IsFirstNameChar(reader.Peek()))
{
ReadAttributes();
}
if (reader.Peek() == '/')
{
reader.Read();
isEmptyElement = true;
}
Expect('>');
SetProperties(
XmlNodeType.Element, // nodeType
name, // name
isEmptyElement, // isEmptyElement
String.Empty, // value
false // clearAttributes
);
}
// The reader is positioned on the first character
// of the element's name.
private void ReadEndTag()
{
string name = ReadName();
SkipWhitespace();
Expect('>');
SetProperties(
XmlNodeType.EndElement, // nodeType
name, // name
false, // isEmptyElement
String.Empty, // value
true // clearAttributes
);
}
// The reader is positioned on the first character
// of the text.
private void ReadText()
{
StringBuilder text = new StringBuilder();
text.Append((char)reader.Read());
while (reader.Peek() != '<' && reader.Peek() != -1)
{
text.Append((char)reader.Read());
}
SetProperties(
XmlNodeType.Text, // nodeType
String.Empty, // name
false, // isEmptyElement
text.ToString(), // value
true // clearAttributes
);
}
// The reader is positioned on the first character of
// the attribute name.
private void ReadAttributes()
{
do
{
string name = ReadName();
SkipWhitespace();
Expect('=');
SkipWhitespace();
string value = ReadAttribute();
SkipWhitespace();
AddAttribute(name, value);
}
while (reader.Peek() != '/' && reader.Peek() != '>' && reader.Peek() != -1);
}
// The reader is positioned on the quote character.
private string ReadAttribute()
{
int quoteChar = reader.Read();
if (quoteChar != '\'' && quoteChar != '\"')
{
throw new Exception("an attribute value was not quoted");
}
StringBuilder valueBuilder = new StringBuilder();
while (reader.Peek() != quoteChar)
{
int ch = reader.Read();
switch (ch)
{
case '<':
throw new Exception("attribute values cannot contain '<'");
case -1:
throw new Exception("unexpected end of file in an attribute value");
}
valueBuilder.Append((char)ch);
}
reader.Read();
return valueBuilder.ToString();
}
// The reader is positioned on the first character
// of the target.
private void ReadProcessingInstruction()
{
string target = ReadName();
SkipWhitespace();
StringBuilder valueBuilder = new StringBuilder();
while (reader.Peek() != -1)
{
int ch = reader.Read();
if (ch == '?' && reader.Peek() == '>')
{
reader.Read();
break;
}
valueBuilder.Append((char)ch);
}
SetProperties(
XmlNodeType.ProcessingInstruction, // nodeType
target, // name
false, // isEmptyElement
valueBuilder.ToString(), // value
true // clearAttributes
);
}
// The reader is positioned on the first character after
// the leading '<!'.
private void ReadComment()
{
Expect('-');
Expect('-');
StringBuilder valueBuilder = new StringBuilder();
while (reader.Peek() != -1)
{
int ch = reader.Read();
if (ch == '-' && reader.Peek() == '-')
{
reader.Read();
if (reader.Peek() != '>')
{
throw new Exception("comments cannot contain '--'");
}
reader.Read();
break;
}
valueBuilder.Append((char)ch);
}
SetProperties(
XmlNodeType.Comment, // nodeType
String.Empty, // name
false, // isEmptyElement
valueBuilder.ToString(), // value
true // clearAttributes
);
}
// The reader is positioned on the first character
// of the name.
private string ReadName()
{
if (!XmlChar.IsFirstNameChar(reader.Peek()))
{
throw new Exception("a name did not start with a legal character");
}
StringBuilder nameBuilder = new StringBuilder();
nameBuilder.Append((char)reader.Read());
while (XmlChar.IsNameChar(reader.Peek()))
{
nameBuilder.Append((char)reader.Read());
}
return nameBuilder.ToString();
}
// Read the next character and compare it against the
// specified character.
private void Expect(int expected)
{
int ch = reader.Read();
if (ch != expected)
{
throw new Exception(String.Format(
"expected '{0}' ({1:X}) but found '{2}' ({3:X})",
(char)expected,
expected,
(char)ch,
ch));
}
}
// Does not consume the first non-whitespace character.
private void SkipWhitespace()
{
while (XmlChar.IsWhitespace(reader.Peek()))
{
reader.Read();
}
}
}
}
@@ -0,0 +1,8 @@
XmlChar.cs
XmlNameTable.cs
XmlNamespaceManager.cs
XmlNodeType.cs
XmlParserContext.cs
XmlReader.cs
XmlSpace.cs
XmlTextReader.cs
+14
View File
@@ -0,0 +1,14 @@
all:
@echo "You must use 'make windows' or 'make unix'."
@echo "'make unix' is broken for now."
windows: make-list
$(CSC) /target:library /out:System.XML.dll /nowarn:1595 @list
unix:
@echo "'make unix' is broken for now."
make-list:
cat $$i/common.src $$i/windows.src | sed "s/^/$$i\\\\/";
test: $(PLATFORM)
+2
View File
@@ -0,0 +1,2 @@
System.dll
list
+5
View File
@@ -0,0 +1,5 @@
2001-07-15 Sean MacIsaac <[email protected]>
* CodeGenerator.cs: moved using statement out of namespace
declaration.
+237
View File
@@ -0,0 +1,237 @@
//
// System.CodeDom.Compiler CodeGenerator class
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
using System.CodeDom;
using System.Reflection;
using System.IO;
namespace System.CodeDom.Compiler {
public abstract class CodeGenerator : ICodeGenerator {
protected TextWriter output;
protected virtual void ContinueOnNewLine (string st)
{
}
CodeGenerator ()
{
indent = 8;
}
//
// Code Generation methods
//
protected abstract void GenerateArrayCreateExpression (CodeArrayCreateExpression e);
protected abstract void GenerateAssignStatement (CodeAssignStatement s);
protected abstract void GenerateAttachEventStatement (CodeAttachEventStatement s);
protected abstract void GenerateBaseReferenceExpression (CodeBaseReferenceExpression e);
protected abstract void GenerateBinaryOperatorExpression (CodeBinaryOperatorExpression x);
protected abstract void GenerateCastExpression (CodeCastExpression x);
protected abstract void GenerateClasses (CodeNamespace x);
protected abstract void GenerateCommentStatement (CodeCommentStatement x);
protected abstract void GenerateConstructor (CodeConstructor x, CodeTypeDeclaration c);
protected abstract void GenerateDelegateCreateExpression (CodeDelegateCreateExpression x);
protected abstract void GenerateDelegateInvokeExpression (CodeDelegateInvokeExpression x);
protected abstract void GenerateEvent (CodeMemberEvent x, CodeTypeDeclaration c);
protected abstract void GenerateExpression (CodeExpression x);
protected abstract void GenerateField (CodeMemberField x);
protected abstract void GenerateFieldReferenceExpression (CodeFieldReferenceExpression x);
protected abstract void GenerateIndexerExpression (CodeIndexerExpression x);
protected abstract void GenerateLinePragmaStart (CodeLinePragma x);
protected abstract void GenerateLinePragmaEnd (CodeLinePragma x);
protected abstract void GenerateMethod (CodeMemberMethod m, CodeTypeDeclaration c);
protected abstract void GenerateMethodInvokeExpression (CodeMethodInvokeExpression x);
protected abstract void GenerateMethodReturnStatement (CodeMethodReturnStatement x);
protected abstract void GenerateNamespace (CodeNamespace x);
protected abstract void GenerateNamespaceStart (CodeNamespace x);
protected abstract void GenerateNamespaceEnd (CodeNamespace x);
protected abstract void GenerateNamespaceImport (CodeNamespaceImport i);
protected abstract void GenerateNamespaceImports (CodeNamespace i);
protected abstract void GenerateObjectCreateExpression (CodeObjectCreateExpression x);
protected abstract void GenerateParameterDeclarationExpression (CodeParameterDeclarationExpression x);
protected abstract void GeneratePrimitiveExpression (CodePrimitiveExpression x);
protected abstract void GenerateProperty (CodeMemberProperty e, CodeTypeDeclaration c);
protected abstract void GeneratePropertyReferenceExpression (CodePropertyReferenceExpression x);
protected abstract void GenerateStatement (CodeStatement x);
protected abstract void GenerateStatementCollection (CodeStatementCollection x);
protected abstract void GenerateThisReferenceExpression (CodeThisReferenceExpression x);
protected abstract void GenerateThrowExceptionStatement (CodeThrowExceptionStatement x);
protected abstract void GenerateTryCatchFinallyStatement (CodeTryCatchFinallyStatement x);
protected abstract void GenerateTypeOfExpression (CodeTypeOfExpression x);
protected abstract void GenerateTypeReferenceExpression (CodeTypeReferenceExpression x);
protected abstract void GenerateVariableDeclarationStatement (CodeVariableDeclarationStatement x);
//
// Other members
//
protected abstract string GetNullToken ();
public abstract bool IsValidIdentifier (string value);
public static bool IsValidLanguateIndependentIdentifier (string value)
{
/* FIXME: implement */
return true;
}
//
// Output functions
//
protected virtual void OutputAttributeArgument (CodeAttributeArgument arg)
{
}
protected virtual void OutputDirection (FieldDirection dir)
{
}
protected virtual void OutputExpressionList (CodeExpressionCollection c)
{
}
protected virtual void OutputExpressionLIst (CodeExpressionCollection c, bool useNewlines)
{
}
protected virtual void OutputFieldScopeModifier (MemberAttributes attrs)
{
}
protected virtual void OutputIdentifier (string ident)
{
}
protected virtual void OutputMemberAccessModifier (MemberAttributes attrs)
{
}
protected virtual void OutputMemberScopeModifier (MemberAttributes attrs)
{
}
protected virtual void OutputOperator (CodeBinaryOperatorType op)
{
}
protected virtual void OutputParameters (CodeParameterDeclarationExpressionCollection pars)
{
}
protected virtual void OutputType (string typeRef)
{
}
protected virtual void OutputTypeAttributes (TypeAttributes attrs)
{
}
protected virtual void OutputTypeNamePair (string typeRef, string name)
{
}
protected abstract string QuoteLiteralString (string value);
public virtual void ValidateIdentifier (string value)
{
}
//
// Properties
//
protected string currentClassName;
protected string CurrentClassName {
get {
return currentClassName;
}
}
protected CodeTypeMember codeClassMember;
protected CodeTypeMember CurrentMember {
get {
return codeClassMember;
}
}
protected string CurrentMemberName {
get {
return codeClassMember.Name;
}
}
int indent;
protected int Indent {
get {
return indent;
}
set {
indent = value;
}
}
//
// This concept seems broken, I should not really be using
// a flag, I should be "probing" what is being generated.
// at least the Start/End
// functions should not be abstract, or abstract could
// have an implementation piece?
//
public bool isCurrentClass;
protected bool IsCurrentClass {
get {
return isCurrentClass;
}
}
public bool isCurrentDelegate;
protected bool IsCurrentDelegate {
get {
return isCurrentDelegate;
}
}
public bool isCurrentEnum;
protected bool IsCurrentEnum {
get {
return isCurrentEnum;
}
}
public bool isCurrentInterface;
protected bool IsCurrentInterface {
get {
return isCurrentInterface;
}
}
public bool isCurrentStruct;
protected bool IsCurrentStruct {
get {
return isCurrentStruct;
}
}
protected TextWriter Output {
get {
return output;
}
set {
output = value;
}
}
public abstract void GenerateCodeFromExpression (TextWriter output, CodeExpression expression);
public abstract void GenerateCodeFromNamespace (TextWriter output, CodeExpression expression);
public abstract void GenerateCodeFromStatement (TextWriter output, CodeStatement expression);
}
}
+30
View File
@@ -0,0 +1,30 @@
//
// System.CodeDom.Compiler ICodeGenerator Interface
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom.Compiler {
using System.CodeDom;
using System.IO;
public interface ICodeGenerator {
// <summary>
// Generates code for @expression on @output
// </summary>
void GenerateCodeFromExpression (TextWriter output, CodeExpression expression);
void GenerateCodeFromNamespace (TextWriter output, CodeExpression expression);
void GenerateCodeFromStatement (TextWriter output, CodeStatement expression);
bool IsValidIdentifier (string value);
void ValidateIdentifier (string value);
}
}
+2
View File
@@ -0,0 +1,2 @@
ICodeGenerator.cs
CodeGenerator.cs
View File
Whitespace-only changes.
View File
Whitespace-only changes.
+19
View File
@@ -0,0 +1,19 @@
2001-07-15 Sean MacIsaac <[email protected]>
* MemberAttributes.cs: Added so rest of classes would compile.
* FieldDirection.cs: Added so rest of classes would compile.
* CodeTypeMember.cs: Added so rest of classes would compile.
* CodeTypeDeclaration.cs: Added so rest of classes would compile.
* CodeObject.cs: Added so rest of classes would compile.
* CodeBinaryOperatorType.cs: Added so rest of classes would compile.
2001-07-12 Sean MacIsaac <[email protected]>
* All files implementing IList: Added IsFixedSize property.
* All files: Changed CodeDOM to CodeDom.
+159
View File
@@ -0,0 +1,159 @@
//
// System.CodeDOM Code@CONTAINEE@Collection Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDOM {
using System.Collections;
public class Code@CONTAINEE@Collection : IList, ICollection, IEnumerable {
ArrayList @arrayname@;
//
// Constructors
//
public Code@CONTAINEE@Collection ()
{
@arrayname@ = new ArrayList ();
}
//
// Properties
//
public int Count {
get {
return @arrayname@.Count;
}
}
//
// Methods
//
public void Add (Code@CONTAINEE@ value)
{
@arrayname@.Add (value);
}
public void AddRange (Code@CONTAINEE@ [] values)
{
foreach (Code@CONTAINEE@ ca in values)
@arrayname@.Add (ca);
}
public void Clear ()
{
@arrayname@.Clear ();
}
private class Enumerator : IEnumerator {
private Code@CONTAINEE@Collection collection;
private int currentIndex = -1;
internal Enumerator (Code@CONTAINEE@Collection collection)
{
this.collection = collection;
}
public object Current {
get {
if (currentIndex == collection.Count)
throw new InvalidOperationException ();
return collection [currentIndex];
}
}
public bool MoveNext ()
{
if (currentIndex > collection.Count)
throw new InvalidOperationException ();
return ++currentIndex < collection.Count;
}
public void Reset ()
{
currentIndex = -1;
}
}
public IEnumerator GetEnumerator ()
{
return new Code@CONTAINEE@Collection.Enumerator (this);
}
//
// IList method implementations
//
public int Add (object value)
{
return @arrayname@.Add (value);
}
public bool Contains (Object value)
{
return @arrayname@.Contains (value);
}
public int IndexOf (Object value)
{
return @arrayname@.IndexOf (value);
}
public void Insert (int index, Object value)
{
@arrayname@ [index] = value;
}
public object this[int index] {
get {
return @arrayname@ [index];
}
set {
@arrayname@ [index] = value;
}
}
public void Remove (object value)
{
@arrayname@.Remove (value);
}
public void RemoveAt (int index)
{
@arrayname@.RemoveAt (index);
}
//
// ICollection method implementations
//
public void CopyTo (Array array, int index)
{
@arrayname@.CopyTo (array, index);
}
public object SyncRoot {
get {
return @arrayname@.SyncRoot;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public bool IsSynchronized {
get {
return @arrayname@.IsSynchronized;
}
}
}
}
@@ -0,0 +1,89 @@
//
// System.CodeDom CodeArrayCreateExpression Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeArrayCreateExpression : CodeExpression {
string createType;
CodeExpressionCollection initializers;
CodeExpression sizeExpression;
int size;
//
// Constructors
//
public CodeArrayCreateExpression ()
{
}
public CodeArrayCreateExpression (string createType, CodeExpression size)
{
this.createType = createType;
this.sizeExpression = size;
}
public CodeArrayCreateExpression (string createType, int size)
{
this.createType = createType;
this.size = size;
}
public CodeArrayCreateExpression (string createType, CodeExpression [] initializers)
{
this.createType = createType;
this.initializers = new CodeExpressionCollection ();
this.initializers.AddRange (initializers);
}
//
// Properties
//
public CodeExpression SizeExpression {
get {
return sizeExpression;
}
set {
sizeExpression = value;
}
}
public int Size {
get {
return size;
}
set {
size = value;
}
}
public CodeExpressionCollection Initializers {
get {
return initializers;
}
set {
initializers = value;
}
}
public string CreateType {
get {
return createType;
}
set {
createType = value;
}
}
}
}
+52
View File
@@ -0,0 +1,52 @@
//
// System.CodeDom CodeArrayCreateExpression Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeAssignStatement : CodeStatement {
CodeExpression left, right;
//
// Constructors
//
public CodeAssignStatement ()
{
}
public CodeAssignStatement (CodeExpression left, CodeExpression right)
{
this.left = left;
this.right = right;
}
//
// Properties
//
public CodeExpression Left {
get {
return left;
}
set {
left = value;
}
}
public CodeExpression Right {
get {
return right;
}
set {
right = value;
}
}
}
}
@@ -0,0 +1,62 @@
//
// System.CodeDom CodeAttachEventStatement Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeAttachEventStatement : CodeStatement {
CodeExpression targetObject;
string eventName;
CodeExpression newListener;
public CodeAttachEventStatement ()
{
}
public CodeAttachEventStatement (CodeExpression targetObject,
string eventName,
CodeExpression newListener)
{
this.targetObject = targetObject;
this.eventName = eventName;
this.newListener = newListener;
}
//
// Properties
//
public string EventName {
get {
return eventName;
}
set {
eventName = value;
}
}
public CodeExpression NewListener {
get {
return newListener;
}
set {
newListener = value;
}
}
public CodeExpression TargetObject {
get {
return targetObject;
}
set {
targetObject = value;
}
}
}
}
+60
View File
@@ -0,0 +1,60 @@
//
// System.CodeDom CodeAttributeArgument Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeAttributeArgument {
string name;
CodeExpression val;
//
// Constructors
//
public CodeAttributeArgument ()
{
}
public CodeAttributeArgument (CodeExpression value)
{
}
public CodeAttributeArgument (string name, CodeExpression val)
{
this.name = name;
this.val = val;
}
//
// Properties
//
public string Name {
get {
return name;
}
set {
name = value;
}
}
public CodeExpression Value {
get {
return val;
}
set {
val = value;
}
}
}
}
@@ -0,0 +1,166 @@
//
// System.CodeDom CodeAttributeArgumentCollection Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
using System.Collections;
public class CodeAttributeArgumentCollection : IList, ICollection, IEnumerable {
ArrayList attributeArgs;
//
// Constructors
//
public CodeAttributeArgumentCollection ()
{
attributeArgs = new ArrayList ();
}
//
// Properties
//
public int Count {
get {
return attributeArgs.Count;
}
}
public bool IsFixedSize {
get {
return true;
}
}
//
// Methods
//
public void Add (CodeAttributeArgument value)
{
attributeArgs.Add (value);
}
public void AddRange (CodeAttributeArgument [] values)
{
foreach (CodeAttributeArgument ca in values)
attributeArgs.Add (ca);
}
public void Clear ()
{
attributeArgs.Clear ();
}
private class Enumerator : IEnumerator {
private CodeAttributeArgumentCollection collection;
private int currentIndex = -1;
internal Enumerator (CodeAttributeArgumentCollection collection)
{
this.collection = collection;
}
public object Current {
get {
if (currentIndex == collection.Count)
throw new InvalidOperationException ();
return collection [currentIndex];
}
}
public bool MoveNext ()
{
if (currentIndex > collection.Count)
throw new InvalidOperationException ();
return ++currentIndex < collection.Count;
}
public void Reset ()
{
currentIndex = -1;
}
}
public IEnumerator GetEnumerator ()
{
return new CodeAttributeArgumentCollection.Enumerator (this);
}
//
// IList method implementations
//
public int Add (object value)
{
return attributeArgs.Add (value);
}
public bool Contains (Object value)
{
return attributeArgs.Contains (value);
}
public int IndexOf (Object value)
{
return attributeArgs.IndexOf (value);
}
public void Insert (int index, Object value)
{
attributeArgs [index] = value;
}
public object this[int index] {
get {
return attributeArgs [index];
}
set {
attributeArgs [index] = value;
}
}
public void Remove (object value)
{
attributeArgs.Remove (value);
}
public void RemoveAt (int index)
{
attributeArgs.RemoveAt (index);
}
//
// ICollection method implementations
//
public void CopyTo (Array array, int index)
{
attributeArgs.CopyTo (array, index);
}
public object SyncRoot {
get {
return attributeArgs.SyncRoot;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public bool IsSynchronized {
get {
return attributeArgs.IsSynchronized;
}
}
}
}
+42
View File
@@ -0,0 +1,42 @@
//
// System.CodeDom CodeAttributeBlock Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeAttributeBlock {
CodeAttributeDeclarationCollection attributes;
//
// Constructors
//
public CodeAttributeBlock ()
{
}
public CodeAttributeBlock (CodeAttributeDeclaration [] attributes)
{
this.attributes = new CodeAttributeDeclarationCollection ();
this.attributes.AddRange (attributes);
}
//
// Prpoperties
//
public CodeAttributeDeclarationCollection Attributes {
get {
return attributes;
}
set {
attributes = value;
}
}
}
}
@@ -0,0 +1,60 @@
//
// System.CodeDom CodeAttributeDeclaration Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeAttributeDeclaration {
string name;
CodeAttributeArgumentCollection arguments;
//
// Constructors
//
public CodeAttributeDeclaration ()
{
}
public CodeAttributeDeclaration (string name)
{
this.name = name;
}
public CodeAttributeDeclaration (string name, CodeAttributeArgument [] arguments)
{
this.name = name;
this.arguments = new CodeAttributeArgumentCollection ();
this.arguments.AddRange (arguments);
}
//
// Properties
//
public CodeAttributeArgumentCollection Arguments {
get {
return arguments;
}
set {
arguments = value;
}
}
public string Name {
get {
return name;
}
set {
name = value;
}
}
}
}
@@ -0,0 +1,165 @@
//
// System.CodeDom CodeAttributeDeclarationCollection Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
using System.Collections;
public class CodeAttributeDeclarationCollection : IList, ICollection, IEnumerable {
ArrayList attributeDecls;
//
// Constructors
//
public CodeAttributeDeclarationCollection ()
{
attributeDecls = new ArrayList ();
}
//
// Properties
//
public int Count {
get {
return attributeDecls.Count;
}
}
public bool IsFixedSize {
get {
return true;
}
}
//
// Methods
//
public void Add (CodeAttributeDeclaration value)
{
attributeDecls.Add (value);
}
public void AddRange (CodeAttributeDeclaration [] values)
{
foreach (CodeAttributeDeclaration ca in values)
attributeDecls.Add (ca);
}
public void Clear ()
{
attributeDecls.Clear ();
}
private class Enumerator : IEnumerator {
private CodeAttributeDeclarationCollection collection;
private int currentIndex = -1;
internal Enumerator (CodeAttributeDeclarationCollection collection)
{
this.collection = collection;
}
public object Current {
get {
if (currentIndex == collection.Count)
throw new InvalidOperationException ();
return collection [currentIndex];
}
}
public bool MoveNext ()
{
if (currentIndex > collection.Count)
throw new InvalidOperationException ();
return ++currentIndex < collection.Count;
}
public void Reset ()
{
currentIndex = -1;
}
}
public IEnumerator GetEnumerator ()
{
return new CodeAttributeDeclarationCollection.Enumerator (this);
}
//
// IList method implementations
//
public int Add (object value)
{
return attributeDecls.Add (value);
}
public bool Contains (Object value)
{
return attributeDecls.Contains (value);
}
public int IndexOf (Object value)
{
return attributeDecls.IndexOf (value);
}
public void Insert (int index, Object value)
{
attributeDecls [index] = value;
}
public object this[int index] {
get {
return attributeDecls [index];
}
set {
attributeDecls [index] = value;
}
}
public void Remove (object value)
{
attributeDecls.Remove (value);
}
public void RemoveAt (int index)
{
attributeDecls.RemoveAt (index);
}
//
// ICollection method implementations
//
public void CopyTo (Array array, int index)
{
attributeDecls.CopyTo (array, index);
}
public object SyncRoot {
get {
return attributeDecls.SyncRoot;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public bool IsSynchronized {
get {
return attributeDecls.IsSynchronized;
}
}
}
}
@@ -0,0 +1,15 @@
//
// System.CodeDom CodeBaseReferenceExpression Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeBaseReferenceExpression : CodeExpression {
public CodeBaseReferenceExpression () {}
}
}
@@ -0,0 +1,88 @@
//
// System.CodeDom CodeBinaryOperatorExpression Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeBinaryOperatorExpression : CodeExpression {
CodeExpression left, right;
CodeBinaryOperatorType oper;
public enum CodeBinaryOperatorType {
Add,
Substract,
Multiply,
Divide,
Modulus,
Assign,
IdentityInequality,
IdentityEquality,
ValueEquality,
BitwiseOr,
BitwiseAnd,
BooleanOr,
BooleanAnd,
LessThan,
LessThanOrEqual,
GreatherThan,
GreatherThanOrEqual,
}
//
// Constructors
//
public CodeBinaryOperatorExpression ()
{
}
public CodeBinaryOperatorExpression (CodeExpression left,
CodeBinaryOperatorType oper,
CodeExpression right)
{
this.left = left;
this.oper = oper;
this.right = right;
}
//
// Properties
//
public CodeExpression Left {
get {
return left;
}
set {
left = value;
}
}
public CodeExpression Right {
get {
return right;
}
set {
right = value;
}
}
public CodeBinaryOperatorType Operator {
get {
return oper;
}
set {
oper = value;
}
}
}
}
+30
View File
@@ -0,0 +1,30 @@
//
// System.CodeDom CodeBinaryOperatorType Enum implementation
//
// Author:
// Sean MacIsaac ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public enum CodeBinaryOperatorType {
Add,
Assign,
BitwiseAnd,
BitwiseOr,
BooleanAnd,
BooleanOr,
Divide,
GreaterThan,
GreaterThanOrEqual,
IdentityEquality,
IdentityInequality,
LessThan,
LessThanOrEqual,
Modulus,
Multiply,
Subtract,
ValueEquality
}
}
+52
View File
@@ -0,0 +1,52 @@
//
// System.CodeDom CodeCastExpression Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeCastExpression : CodeExpression {
string targetType;
CodeExpression expression;
//
// Constructors
//
public CodeCastExpression ()
{
}
public CodeCastExpression (string targetType, CodeExpression expression)
{
this.targetType = targetType;
this.expression = expression;
}
//
// Properties
//
public CodeExpression Expression {
get {
return expression;
}
set {
expression = value;
}
}
public string TargetType {
get {
return targetType;
}
set {
targetType = value;
}
}
}
}
+46
View File
@@ -0,0 +1,46 @@
//
// System.CodeDom CodeCatchClaus Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeCatchClause {
CodeParameterDeclarationExpression condition;
CodeStatementCollection statements;
public CodeCatchClause ()
{
this.statements = new CodeStatementCollection ();
}
public CodeCatchClause (CodeParameterDeclarationExpression condition,
CodeStatement [] statements)
{
this.condition = condition;
this.statements = new CodeStatementCollection ();
this.statements.AddRange (statements);
}
public CodeStatementCollection Statements {
get {
return statements;
}
}
public CodeParameterDeclarationExpression Condition {
get {
return condition;
}
set {
condition = value;
}
}
}
}
@@ -0,0 +1,165 @@
//
// System.CodeDom CodeCatchClauseCollection Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
using System.Collections;
public class CodeCatchClauseCollection : IList, ICollection, IEnumerable {
ArrayList catchClauses;
//
// Constructors
//
public CodeCatchClauseCollection ()
{
catchClauses = new ArrayList ();
}
//
// Properties
//
public int Count {
get {
return catchClauses.Count;
}
}
public bool IsFixedSize {
get {
return true;
}
}
//
// Methods
//
public void Add (CodeCatchClause value)
{
catchClauses.Add (value);
}
public void AddRange (CodeCatchClause [] values)
{
foreach (CodeCatchClause ca in values)
catchClauses.Add (ca);
}
public void Clear ()
{
catchClauses.Clear ();
}
private class Enumerator : IEnumerator {
private CodeCatchClauseCollection collection;
private int currentIndex = -1;
internal Enumerator (CodeCatchClauseCollection collection)
{
this.collection = collection;
}
public object Current {
get {
if (currentIndex == collection.Count)
throw new InvalidOperationException ();
return collection [currentIndex];
}
}
public bool MoveNext ()
{
if (currentIndex > collection.Count)
throw new InvalidOperationException ();
return ++currentIndex < collection.Count;
}
public void Reset ()
{
currentIndex = -1;
}
}
public IEnumerator GetEnumerator ()
{
return new CodeCatchClauseCollection.Enumerator (this);
}
//
// IList method implementations
//
public int Add (object value)
{
return catchClauses.Add (value);
}
public bool Contains (Object value)
{
return catchClauses.Contains (value);
}
public int IndexOf (Object value)
{
return catchClauses.IndexOf (value);
}
public void Insert (int index, Object value)
{
catchClauses [index] = value;
}
public object this[int index] {
get {
return catchClauses [index];
}
set {
catchClauses [index] = value;
}
}
public void Remove (object value)
{
catchClauses.Remove (value);
}
public void RemoveAt (int index)
{
catchClauses.RemoveAt (index);
}
//
// ICollection method implementations
//
public void CopyTo (Array array, int index)
{
catchClauses.CopyTo (array, index);
}
public object SyncRoot {
get {
return catchClauses.SyncRoot;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public bool IsSynchronized {
get {
return catchClauses.IsSynchronized;
}
}
}
}
+107
View File
@@ -0,0 +1,107 @@
//
// System.CodeDom CodeClass Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
using System.Collections.Specialized;
namespace System.CodeDom {
using System.Reflection;
using System.Collections;
public class CodeClass : CodeClassMember {
CodeClassMemberCollection members;
TypeAttributes attrs;
StringCollection baseTypes;
bool isClass, isEnum, isInterface, isStruct;
string name;
//
// Constructors
//
public CodeClass ()
{
}
public CodeClass (string name)
{
this.name = name;
}
//
// Properties
//
public TypeAttributes attributes {
get {
return attrs;
}
set {
attrs = value;
}
}
public StringCollection BaseTypes {
get {
return baseTypes;
}
set {
baseTypes = value;
}
}
public bool IsClass {
get {
return isClass;
}
set {
isClass = value;
}
}
public bool IsEnum {
get {
return isEnum;
}
set {
isEnum = value;
}
}
public bool IsInterface {
get {
return isInterface;
}
set {
isInterface = value;
}
}
public bool IsStruct {
get {
return isStruct;
}
set {
isStruct = value;
}
}
public CodeClassMemberCollection Members {
get {
return members;
}
set {
members = value;
}
}
}
}
+165
View File
@@ -0,0 +1,165 @@
//
// System.CodeDom CodeClassCollection Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
using System.Collections;
public class CodeClassCollection : IList, ICollection, IEnumerable {
ArrayList classes;
//
// Constructors
//
public CodeClassCollection ()
{
classes = new ArrayList ();
}
//
// Properties
//
public int Count {
get {
return classes.Count;
}
}
public bool IsFixedSize {
get {
return true;
}
}
//
// Methods
//
public void Add (CodeClass value)
{
classes.Add (value);
}
public void AddRange (CodeClass [] values)
{
foreach (CodeClass ca in values)
classes.Add (ca);
}
public void Clear ()
{
classes.Clear ();
}
private class Enumerator : IEnumerator {
private CodeClassCollection collection;
private int currentIndex = -1;
internal Enumerator (CodeClassCollection collection)
{
this.collection = collection;
}
public object Current {
get {
if (currentIndex == collection.Count)
throw new InvalidOperationException ();
return collection [currentIndex];
}
}
public bool MoveNext ()
{
if (currentIndex > collection.Count)
throw new InvalidOperationException ();
return ++currentIndex < collection.Count;
}
public void Reset ()
{
currentIndex = -1;
}
}
public IEnumerator GetEnumerator ()
{
return new CodeClassCollection.Enumerator (this);
}
//
// IList method implementations
//
public int Add (object value)
{
return classes.Add (value);
}
public bool Contains (Object value)
{
return classes.Contains (value);
}
public int IndexOf (Object value)
{
return classes.IndexOf (value);
}
public void Insert (int index, Object value)
{
classes [index] = value;
}
public object this[int index] {
get {
return classes [index];
}
set {
classes [index] = value;
}
}
public void Remove (object value)
{
classes.Remove (value);
}
public void RemoveAt (int index)
{
classes.RemoveAt (index);
}
//
// ICollection method implementations
//
public void CopyTo (Array array, int index)
{
classes.CopyTo (array, index);
}
public object SyncRoot {
get {
return classes.SyncRoot;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public bool IsSynchronized {
get {
return classes.IsSynchronized;
}
}
}
}
+17
View File
@@ -0,0 +1,17 @@
//
// System.CodeDom CodeClassConstructor Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeClassConstructor : CodeMemberMethod {
public CodeClassConstructor ()
{
}
}
}
+52
View File
@@ -0,0 +1,52 @@
//
// System.CodeDom CodeClassDelegate Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeClassDelegate : CodeClass {
CodeParameterDeclarationExpressionCollection parameters;
string returnType;
string name;
//
// Constructors
//
public CodeClassDelegate ()
{
}
public CodeClassDelegate (string name)
{
this.name = name;
}
//
// Properties
//
public CodeParameterDeclarationExpressionCollection Parameters {
get {
return parameters;
}
set {
parameters = value;
}
}
public string ReturnType {
get {
return returnType;
}
set {
returnType = value;
}
}
}
}
+80
View File
@@ -0,0 +1,80 @@
//
// System.CodeDom CodeClassMember Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeClassMember : CodeStatement {
MemberAttributes attributes;
CodeAttributeBlock customAttributes;
string name;
//
// Yeah, this is a strange way of defining this
//
public enum MemberAttributes {
Abstract = 0x0001,
Final = 0x0002,
Override = 0x0004,
Const = 0x0005,
Assembly = 0x1000,
AccessMask = 0xf000,
FamANDAssem = 0x2000,
Family = 0x3000,
FamORAssem = 0x4000,
New = 0x0010,
Private = 0x5000,
Public = 0x6000,
ScopeMask = 0x000f,
Static = 0x0003,
VTableMask = 0x00f0
}
//
// Constructors
//
public CodeClassMember ()
{
}
//
// Properties
//
public MemberAttributes Attributes {
get {
return attributes;
}
set {
attributes = value;
}
}
public CodeAttributeBlock CustomAttributes {
get {
return customAttributes;
}
set {
customAttributes = value;
}
}
public string Name {
get {
return name;
}
set {
name = value;
}
}
}
}
@@ -0,0 +1,165 @@
//
// System.CodeDom CodeClassMemberCollection Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
using System.Collections;
public class CodeClassMemberCollection : IList, ICollection, IEnumerable {
ArrayList classMembers;
//
// Constructors
//
public CodeClassMemberCollection ()
{
classMembers = new ArrayList ();
}
//
// Properties
//
public int Count {
get {
return classMembers.Count;
}
}
public bool IsFixedSize {
get {
return true;
}
}
//
// Methods
//
public void Add (CodeClassMember value)
{
classMembers.Add (value);
}
public void AddRange (CodeClassMember [] values)
{
foreach (CodeClassMember ca in values)
classMembers.Add (ca);
}
public void Clear ()
{
classMembers.Clear ();
}
private class Enumerator : IEnumerator {
private CodeClassMemberCollection collection;
private int currentIndex = -1;
internal Enumerator (CodeClassMemberCollection collection)
{
this.collection = collection;
}
public object Current {
get {
if (currentIndex == collection.Count)
throw new InvalidOperationException ();
return collection [currentIndex];
}
}
public bool MoveNext ()
{
if (currentIndex > collection.Count)
throw new InvalidOperationException ();
return ++currentIndex < collection.Count;
}
public void Reset ()
{
currentIndex = -1;
}
}
public IEnumerator GetEnumerator ()
{
return new CodeClassMemberCollection.Enumerator (this);
}
//
// IList method implementations
//
public int Add (object value)
{
return classMembers.Add (value);
}
public bool Contains (Object value)
{
return classMembers.Contains (value);
}
public int IndexOf (Object value)
{
return classMembers.IndexOf (value);
}
public void Insert (int index, Object value)
{
classMembers [index] = value;
}
public object this[int index] {
get {
return classMembers [index];
}
set {
classMembers [index] = value;
}
}
public void Remove (object value)
{
classMembers.Remove (value);
}
public void RemoveAt (int index)
{
classMembers.RemoveAt (index);
}
//
// ICollection method implementations
//
public void CopyTo (Array array, int index)
{
classMembers.CopyTo (array, index);
}
public object SyncRoot {
get {
return classMembers.SyncRoot;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public bool IsSynchronized {
get {
return classMembers.IsSynchronized;
}
}
}
}
+39
View File
@@ -0,0 +1,39 @@
//
// System.CodeDom CodeCommentStatement Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeCommentStatement : CodeStatement {
string text;
//
// Constructors
//
public CodeCommentStatement ()
{
}
public CodeCommentStatement (string text)
{
this.text = text;
}
string Text {
get {
return text;
}
set {
text = value;
}
}
}
}
+43
View File
@@ -0,0 +1,43 @@
//
// System.CodeDom CodeConstructor Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeConstructor : CodeMemberMethod {
CodeExpressionCollection baseConstructorArgs;
CodeExpressionCollection chainedConstructorArgs;
//
// Constructors
//
public CodeConstructor ()
{
}
public CodeExpressionCollection BaseConstructorArgs {
get {
return baseConstructorArgs;
}
set {
baseConstructorArgs = value;
}
}
public CodeExpressionCollection ChainedConstructorArgs {
get {
return chainedConstructorArgs;
}
set {
chainedConstructorArgs = value;
}
}
}
}
@@ -0,0 +1,66 @@
//
// System.CodeDom CodeDelegateCreateExpression Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeDelegateCreateExpression : CodeExpression {
string delegateType, methodName;
CodeExpression targetObject;
//
// Constructors
//
public CodeDelegateCreateExpression (string delegateType,
CodeExpression targetObject,
string methodName)
{
this.delegateType = delegateType;
this.targetObject = targetObject;
this.methodName = methodName;
}
public CodeDelegateCreateExpression ()
{
}
//
// Properties
//
string DelegateType {
get {
return delegateType;
}
set {
delegateType = value;
}
}
string MethodName {
get {
return methodName;
}
set {
methodName = value;
}
}
CodeExpression TargetObject {
get {
return targetObject;
}
set {
targetObject = value;
}
}
}
}
@@ -0,0 +1,59 @@
//
// System.CodeDom CodeDelegateInvokeExpression Class implementation
//
// Author:
// Miguel de Icaza ([email protected])
//
// (C) 2001 Ximian, Inc.
//
namespace System.CodeDom {
public class CodeDelegateInvokeExpression : CodeExpression {
CodeExpressionCollection parameters;
CodeExpression targetObject;
//
// Constructors
//
public CodeDelegateInvokeExpression ()
{
}
public CodeDelegateInvokeExpression (CodeExpression targetObject,
CodeExpression [] parameters)
{
this.targetObject = targetObject;
this.parameters = new CodeExpressionCollection ();
this.parameters.AddRange (parameters);
}
public CodeDelegateInvokeExpression (CodeExpression targetObject)
{
this.targetObject = targetObject;
}
//
// Properties
//
public CodeExpression TargetObject {
get {
return targetObject;
}
set {
targetObject = value;
}
}
public CodeExpressionCollection Parameters {
get {
return parameters;
}
set {
parameters = value;
}
}
}
}
Loaded 100 of 387 files, more files were not shown because too many files have changed in this diff. Show more