* tsukimi project

* What's this?

	This will be a couple of attempt to achieve support for processing[*1]
	under moonlight[*2].

	So far there are three assemblies as outcome from this project:

	- Processing.Core.dll : it implements processing standard library,
	  to make application runnable under Moonlight.
	- Processing.Importer.dll : it is to import processing application
	  (pde) and generate Moonlight application (xap package etc.).
	  The resulting application should run under Silverlight too, but
	  it is not tested very often.
	  Since it internally invokes mxap, it requires moon installation
	  (moonlight.xpi is not enough.)
	- tsukimi-tool.exe : console frontend to the importer.

	It is still in early stage and everything is subject to change.

	[*1] http://processing.org/
	[*2] http://mono-project.com/Moonlight

** Dependencies

	To build it or use the importer, you need moon (from trunk) built
	and installed. To run tsukimi-based app, you just need either
	moonlight 2.0 (preview) or silverlight 2.0 or later.

	Also it depends on "zip" command when it imports application data.

** Usage

	First, build the assemblies above by running "make".

	Then, go to processing application directory (I recommend to
	create a copy of the original application, as this will generate
	extra files on the directory) and run:

		mono tsukimi-tool.exe --xap .

	Then it will generate xap package, stub html and so on (it is
	actually what mxap does). You'll only need *.xap.

** Basic design

	- Processing parser that parses processing files (*.pde) to the AST.
	- "processing standard library" for common functions and classes.
	  It is based on System.Windows.dll
	- Code generator that writes code that uses the standard library.
	  Not sure we generate either of some source code or direct IL.
	  So far we generate C# sources directly. (We could generate python
	  or ruby sources and make it work with dynamic silverlight, but
	  it adds somewhat heavy dependency. I avoid it so far.)

*** TODOs

	- A lot of library features are missing.

** Source Files

	- processing_syntax.txt:
	  my analysis on processing syntax. It is based on 1.0 beta.

	- skeleton.cs :
	  taken from mcs, required for jay.

	- apilist.txt :
	  It is embedded into Processing.Importer.dll to identify
	  processing native members in users code. It can be generated
	  by "apigen.sh".

** Parser/Converter

*** Some Details

	- *.pde files are parsed to build AstRoot.
	- "ProcessingApplication" class is generated to hold global members.
	- For each top level contents in AstRoot:
	-- A class is converted to generate a managed class.
	-- A global function definition is converted to a method of 
	   ProcessingApplication class.
	-- A statement is converted to become a statement in the global Run().