Status Report on Google-Sponsered XAML Compiler for Mono

Hello,

   Iain McCoy  -  the student  sponsored by Google to code a XAML 
compiler for Mono - writes in the mail titled "xaml status report #3":

This week, a reasonable amount got done. I have some unit tests for the 
parser now (which are run on make run-test in the
class/PresentationFramework folder, as you'd expect). They've already 
found a few bugs. I also improved the debuggability of the whole thing 
somewhat by adding a bundle of calls to Debug.WriteLine that make it
much easier to see what's going on. I'm pretty sure they're harmless in 
library code, since they only have an effect if the code is compiled 
with -d:DEBUG.

When building objects at runtime, you can now set dependency properties. 
The object builder now also supports conversions from strings.

I've finally implemented support for creating complex objects as 
property values; this is the "more complex property scenarios" support 
I've been rambling about. It was about as tricky as I thought it would 
be, so I'm glad I let it percolate for a while. I also watched a lot of 
firefly.

Upshot of all this (except for firefly) is that I think xamlc is very 
close to feature-complete.

Having said that, there's lots left to do. The object builder still 
needs some feature work, and I suspect there's a bunch of bugs I don't 
know about as well as the handful I do. I'm also going to expand the 
unit tests for the parser and get started on unit tests for the code 
generator. That should keep me going for this week.

More long-term, I need to work out how microsoft's implementation 
reports errors and be more like them, as well as look closely at the 
styling system. I also need to carefully decide on the surface area of 
my Mono.Windows.Serialization, because at the moment it's way too big, 
and implement more of System.Windows.Serialization.

Testing this stuff is still hard. The biggest problem is concocting a 
small and easy to write library of classes to wire up with xaml that 
allow you to use most or all of the xaml features, which I think I've 
now done. Unfortunately, the nature of the language is such is that you 
can only test things that your objects allow for, which means that 
pathological cases require a pathological library.

Possibly the biggest problem is that I don't really understand 
Assembly.Load() and friends. They are my mortal enemy, and I wasted a 
few days on trying to get them to do what I thought was obviously 
sensible behaviour (my eventual decision, pending actual understanding 
of the issue, was to call LoadFrom() and if any exception came out of
that try Load() instead).

Hope everyone else had similarly good weeks.

-Iain

Source: http://article.gmane.org/gmane.comp.gnome.mono.summer-of-code/17  
  


-------------------------------------------------------
SF.Net email is sponsored by: Discover Easy Linux Migration Strategies
from IBM. Find simple to follow Roadmaps, straightforward articles,
informative Webcasts and more! Get everything you need to get up to
speed, fast. http://ads.osdn.com/?ad_id=7477&alloc_id=16492&op=click