Toad, a .net compiler playground

New Post: System.Linq.Expressions?

BobStrogg — Fri, 27 Jun 2008 18:23:16 GMT

Hi - I stumbled on Toad looking for a way to generate IL from System.Linq.Expressions trees. Unusually I actually *want* the IL and not the compiled delegate. Any ideas if Toad could handle this? (or maybe a "Toad Lite" is in the works?).

Thanks.

Source code checked in

pelikhan — Sun, 10 Feb 2008 21:52:01 GMT

Source code checked in

pelikhan — Sun, 08 Jul 2007 19:07:02 GMT

added CSharp language

UPDATED WIKI: Home

pelikhan — Sun, 20 May 2007 17:06:30 GMT

Toad, a framework for building toy compilers and languages in .net.

made while commuting

Toad is a framework to play around building languages and compiler for .net. Toad provides an AST (expression and statement tree) which gets compiled to MSIL using Reflection.Emit. Toad also comes with a set of visitors to solve common task such as inferring variable types, computing closures, optimization string concats or refactoring to some extent.

Curious? Check out Hello World or a simple Xml serializer compiler
User Manual
Peli's blog

Disclaimer

Toad was written to get a better understanding of what it takes to build languages.... during my daily work commute

It is not meant to be complete and certaintly not used in production.
Toad does not understand the DLR (currently)

UPDATED WIKI: Home

pelikhan — Sun, 20 May 2007 17:06:08 GMT

Toad, a framework for building toy compilers and languages in .net.

Curious? Check out Hello World or a simple Xml serializer compiler
User Manual
Peli's blog

Disclaimer

Toad was written to get a better understanding of what it takes to build languages.... during my commute sessions

It is not meant to be complete and certaintly not used in production.
Toad does not understand the DLR (currently)

UPDATED WIKI: Home

pelikhan — Sun, 20 May 2007 17:05:51 GMT

Toad, a framework for building toy compilers and languages in .net.

Curious? Check out Hello World or a simple Xml serializer compiler
User Manual
Peli's blog

_Toad was written to get a better understanding of what it takes to build languages.... during my commute sessions.

It is not meant to be complete and certaintly not used in production.
Toad does not understand the DLR (currently)

UPDATED WIKI: Home

pelikhan — Sun, 20 May 2007 17:02:52 GMT

Toad, a framework for building toy compilers and languages in .net.

Curious? Check out Hello World or a simple Xml serializer compiler
User Manual
Peli's blog

_Toad was written to get a better understanding of what it takes to build languages.... during my commute sessions.

It is not meant to be complete and certaintly not used in production.
Toad does not understand the DLR currently_

UPDATED WIKI: Simple Xml Serializer Compiler

pelikhan — Sun, 20 May 2007 17:00:38 GMT

Simplex Xml Serializer Compiler

In this exercise, we will build a mini compiler that takes a Type annotated with some System.Xml.Serialization attributes and generates a lightweight serializer on the fly.

What we want to do...

For the sake of simplicity we will support properties tagged with XmlAttributeAttribute and XmlElementAttribute, in which cases the property can be an array as well. Let's this with an example:

public class Foo
{
    [XmlAttribute]
    public string Name {get;set;}
 
    [XmlElement]
    public Bar MyBar {get;set;}
}
 
    public class Bar
    {
        [XmlElement]
        public Foo[] Foes {get;set;}
    }

Given a little object tree, we'll expect the serializer to produce a nice xml output:

Foo foo = new Foo();
foo.Name = "Hello";
foo.MyBar = new Bar();
foo.MyBar.Foes = new Foo[]{ new Foo(), new Foo(), null };
foo.MyBar.Foes[0].Name = "foo1";
foo.MyBar.Foes[1].Name = "foo2";

gives

<Foo Name="Hello">
  <Bar>
    <Foes>
      <Foo Name="foo1" />
      <Foo Name="foo2" />
    </Foes>
  </Bar>
</Foo>

Designing the serializer

Given the type Foo, we expect the compiler to generate a method for each type Foo and Bar that works directly on a XmlWriter:

void WriteFoo(XmlWriter writer, Foo target)
{
    writer.WriteStartElement("Foo");
    writer.WriteAttributeString("Name", target.Name);
    if (target.Bar != null)
        WriteBar(writer, target.Bar);
    writer.WriteEndElement();
}
 
void WriteBar(XmlWriter writer, Bar bar)
{
    writer.WriteStartElement("Bar");
    if (bar.Foes!=null)
    {
        writer.WriteStartElements("Foes");
        foreach(Foo foo in bar.Foes)
        {  
            if (foo!=null)
                WriteFoo(writer, foo); 
        }
        writer.WriteEndElement();
    }
    writer.WriteEndElement();
}

Building the compiler

The compilation process is a 2-pass algorithm:

collect the list of types that might be serialized by walking the property types. For each type, define new {{WriteXXX} method,

* bake the body for each {{WriteXXX}} method

The full source of this sample is in the source distribution. Let's focus on interresting parts, i.e. generating the method bodies.

Write a property as argument:

fetch the property value,
if the property is not a string, convert the value to string using XmlConvert,
invoke XmlWriter.WriteAttributeString

PropertyInfo property = ...;
XmlAttributeAttribute xmlAttribute = Attribute.GetCustomAttribute(property, typeof(XmlAttributeAttribute)) 
    as XmlAttributeAttribute; // is this an attribute?
if (xmlAttribute!=null)
{
    // var value = target.Foo;
    Expression pvalue= Expr.Param(value).GetProperty(property);
    if (property.PropertyType != typeof(string))
    {
        // WriteAttributeString works with string
        // string value = XmlConvert.ToString(target.Foo);
        pvalue = Expr.InvokeMethod(
            typeof(XmlConvert), "ToString", BindingFlags.Public | BindingFlags.Static, pvalue);
     }
 
     // writer.WriteAttributeString("Foo", XmlConvert.ToString(target.Foo);
     body.Statements.Add(
         Expr.Param(writer).InvokeMethod(
             "WriteAttributeString", Expr.Prim(property.Name), pvalue)
         );
}

Write an element:

if the element is not null, call the corresponding WriteXXX method:

// types is a dictionary containing the WriteXXX methods
MethodFactoryBase method = this.types[property.PropertyType];
 
// WriteFoo(writer, value.Foo); 
MethodInvokeExpression invoke = new MethodInvokeExpression(
    null, // static method
    (MethodInfo)method.Method,
    method.Parameters.GetParameterTypes());
invoke.Arguments.Add(Expr.Param(writer));
invoke.Arguments.Add(Expr.Param(value).GetProperty(property));
 
// if (value.Foo != null) WriteFoo(writer, value.Foo);
body.Statements.Add(
    Stm.If(
        Expr.Inequality(Expr.Param(value).GetProperty(property), Expr.Null),
        Stm.Expr(invoke)
        ) // If
    ); // Add

Write an array of elements:

check that the array is not null,
create a foreach loop that invokes the corresponding WriteXXX method. Even better, Toad supports adding a condition on the foreach (i.e. foreach ... where) so we can filter out null elements in the array:

//  foreach(Foo foo in target.Foes where foo != null)
ForEachStatement fe = Stm.ForEach(
    property.PropertyType.GetElementType(),
    "item",
    Expr.Param(value).GetProperty(property));
// where x != null                               
fe.WhereExpression = Expr.Inequality(Expr.Var(fe.Variable), Expr.Null);
 
// WriteFoo(writer, foo);    
MethodFactoryBase method = this.types[property.PropertyType.GetElementType()];
MethodInvokeExpression invoke = new MethodInvokeExpression(...);
invoke.Arguments.Add(Expr.Param(writer));
invoke.Arguments.Add(Expr.Var(fe.Variable));
 
// foreach(...) { WriteFoo(writer, foo); }
fe.Body = Stm.Expr(invoke);
 
// if (value.Foes != null) { foreach... }
body.Statements.Add(
    Stm.If(
        Expr.Inequality(Expr.Param(value).GetProperty(property), Expr.Null),
        fe
        )
    );

That's it. Glue the pieces together and let Toad bake the IL for you :)

UPDATED WIKI: Simple Xml Serializer Compiler

pelikhan — Sun, 20 May 2007 16:59:55 GMT

Simplex Xml Serializer Compiler

In this exercise, we will build a mini compiler that takes a Type annotated with some System.Xml.Serialization attributes and generates a lightweight serializer on the fly.

What we want to do...

For the sake of simplicity we will support properties tagged with XmlAttributeAttribute and XmlElementAttribute, in which cases the property can be an array as well. Let's this with an example:

public class Foo
{
    [XmlAttribute]
    public string Name {get;set;}
 
    [XmlElement]
    public Bar MyBar {get;set;}
}
 
    public class Bar
    {
        [XmlElement]
        public Foo[] Foes {get;set;}
    }

Given a little object tree, we'll expect the serializer to produce a nice xml output:

Foo foo = new Foo();
foo.Name = "Hello";
foo.MyBar = new Bar();
foo.MyBar.Foes = new Foo[]{ new Foo(), new Foo(), null };
foo.MyBar.Foes[0].Name = "foo1";
foo.MyBar.Foes[1].Name = "foo2";

gives

<Foo Name="Hello">
  <Bar>
    <Foes>
      <Foo Name="foo1" />
      <Foo Name="foo2" />
    </Foes>
  </Bar>
</Foo>

Designing the serializer

Given the type Foo, we expect the compiler to generate a method for each type Foo and Bar that works directly on a XmlWriter:

void WriteFoo(XmlWriter writer, Foo target)
{
    writer.WriteStartElement("Foo");
    writer.WriteAttributeString("Name", target.Name);
    if (target.Bar != null)
        WriteBar(writer, target.Bar);
    writer.WriteEndElement();
}
 
void WriteBar(XmlWriter writer, Bar bar)
{
    writer.WriteStartElement("Bar");
    if (bar.Foes!=null)
    {
        writer.WriteStartElements("Foes");
        foreach(Foo foo in bar.Foes)
        {  
            if (foo!=null)
                WriteFoo(writer, foo); 
        }
        writer.WriteEndElement();
    }
    writer.WriteEndElement();
}

Building the compiler

The compilation process is a 2-pass algorithm:

collect the list of types that might be serialized by walking the property types. For each type, define new {{WriteXXX} method,

* bake the body for each {{WriteXXX}} method

The full source of this sample is in the source distribution. Let's focus on interresting parts, i.e. generating the method bodies.

Write a property as argument:

fetch the property value,
if the property is not a string, convert the value to string using XmlConvert,
invoke XmlWriter.WriteAttributeString

PropertyInfo property = ...;
XmlAttributeAttribute xmlAttribute = Attribute.GetCustomAttribute(property, typeof(XmlAttributeAttribute)) 
    as XmlAttributeAttribute; // is this an attribute?
if (xmlAttribute!=null)
{
    // var value = target.Foo;
    Expression pvalue= Expr.Param(value).GetProperty(property);
    if (property.PropertyType != typeof(string))
    {
        // WriteAttributeString works with string
        // string value = XmlConvert.ToString(target.Foo);
        pvalue = Expr.InvokeMethod(
            typeof(XmlConvert), "ToString", BindingFlags.Public | BindingFlags.Static, pvalue);
     }
 
     // writer.WriteAttributeString("Foo", XmlConvert.ToString(target.Foo);
     body.Statements.Add(
         Expr.Param(writer).InvokeMethod(
             "WriteAttributeString", Expr.Prim(property.Name), pvalue)
         );
}

Write an element:

if the element is not null, call the corresponding WriteXXX method:

// types is a dictionary containing the WriteXXX methods
MethodFactoryBase method = this.types[property.PropertyType];
 
// WriteFoo(writer, value.Foo); 
MethodInvokeExpression invoke = new MethodInvokeExpression(
    null, // static method
    (MethodInfo)method.Method,
    method.Parameters.GetParameterTypes());
invoke.Arguments.Add(Expr.Param(writer));
invoke.Arguments.Add(Expr.Param(value).GetProperty(property));
 
// if (value.Foo != null) WriteFoo(writer, value.Foo);
body.Statements.Add(
    Stm.If(
        Expr.Inequality(Expr.Param(value).GetProperty(property), Expr.Null),
        Stm.Expr(invoke)
        ) // If
    ); // Add

Write an array of elements:

check that the array is not null,
create a foreach loop that invokes the corresponding WriteXXX method. Even better, Toad supports adding a condition on the foreach (i.e. foreach ... where) so we can filter out null elements in the array:

//  foreach(Foo foo in target.Foes where foo != null)
ForEachStatement fe = Stm.ForEach(
    property.PropertyType.GetElementType(),
    "item",
    Expr.Param(value).GetProperty(property));
// where x != null                               
fe.WhereExpression = Expr.Inequality(Expr.Var(fe.Variable), Expr.Null);
 
// WriteFoo(writer, foo);    
MethodFactoryBase method = this.types[property.PropertyType.GetElementType()];
MethodInvokeExpression invoke = new MethodInvokeExpression(...);
invoke.Arguments.Add(Expr.Param(writer));
invoke.Arguments.Add(Expr.Var(fe.Variable));
 
// foreach(...) { WriteFoo(writer, foo); }
fe.Body = Stm.Expr(invoke);
 
// if (value.Foes != null) { foreach... }
body.Statements.Add(
    Stm.If(
        Expr.Inequality(Expr.Param(value).GetProperty(property), Expr.Null),
        fe
        )
    );

UPDATED WIKI: Simple Xml Serializer Compiler

pelikhan — Sun, 20 May 2007 16:52:58 GMT

Simplex Xml Serializer Compiler

In this exercise, we will build a mini compiler that takes a Type annotated with some System.Xml.Serialization attributes and generates a lightweight serializer on the fly.

What we want to do...

For the sake of simplicity we will support properties tagged with XmlAttributeAttribute and XmlElementAttribute, in which cases the property can be an array as well. Let's this with an example:

public class Foo
{
    [XmlAttribute]
    public string Name {get;set;}
 
    [XmlElement]
    public Bar MyBar {get;set;}
}
 
    public class Bar
    {
        [XmlElement]
        public Foo[] Foes {get;set;}
    }

Given a little object tree, we'll expect the serializer to produce a nice xml output:

Foo foo = new Foo();
foo.Name = "Hello";
foo.MyBar = new Bar();
foo.MyBar.Foes = new Foo[]{ new Foo(), new Foo(), null };
foo.MyBar.Foes[0].Name = "foo1";
foo.MyBar.Foes[1].Name = "foo2";

gives

<Foo Name="Hello">
  <Bar>
    <Foes>
      <Foo Name="foo1" />
      <Foo Name="foo2" />
    </Foes>
  </Bar>
</Foo>

Designing the serializer

Given the type Foo, we expect the compiler to generate a method for each type Foo and Bar that works directly on a XmlWriter:

void WriteFoo(XmlWriter writer, Foo target)
{
    writer.WriteStartElement("Foo");
    writer.WriteAttributeString("Name", target.Name);
    if (target.Bar != null)
        WriteBar(writer, target.Bar);
    writer.WriteEndElement();
}
 
void WriteBar(XmlWriter writer, Bar bar)
{
    writer.WriteStartElement("Bar");
    if (bar.Foes!=null)
    {
        writer.WriteStartElements("Foes");
        foreach(Foo foo in bar.Foes)
        {  
            if (foo!=null)
                WriteFoo(writer, foo); 
        }
        writer.WriteEndElement();
    }
    writer.WriteEndElement();
}

Building the compiler

The compilation process is a 2-pass algorithm:

collect the list of types that might be serialized by walking the property types. For each type, define new {{WriteXXX} method,

* bake the body for each {{WriteXXX}} method

The full source of this sample is in the source distribution. Let's focus on interresting parts, i.e. generating the method bodies.

Write a property as argument:

fetch the property value,
if the property is not a string, convert the value to string using XmlConvert,
invoke XmlWriter.WriteAttributeString

PropertyInfo property = ...;
XmlAttributeAttribute xmlAttribute = Attribute.GetCustomAttribute(property, typeof(XmlAttributeAttribute)) 
    as XmlAttributeAttribute; // is this an attribute?
if (xmlAttribute!=null)
{
    // var value = target.Foo;
    Expression pvalue= Expr.Param(value).GetProperty(property);
    if (property.PropertyType != typeof(string))
    {
        // WriteAttributeString works with string
        // string value = XmlConvert.ToString(target.Foo);
        pvalue = Expr.InvokeMethod(
            typeof(XmlConvert), "ToString", BindingFlags.Public | BindingFlags.Static, pvalue);
     }
 
     // writer.WriteAttributeString("Foo", XmlConvert.ToString(target.Foo);
     body.Statements.Add(
         Expr.Param(writer).InvokeMethod(
             "WriteAttributeString", Expr.Prim(property.Name), pvalue)
         );
}

Write an element:

if the element is not null, call the corresponding WriteXXX method:

// types is a dictionary containing the WriteXXX methods
MethodFactoryBase method = this.types[property.PropertyType];
 
// WriteFoo(writer, value.Foo); 
MethodInvokeExpression invoke = new MethodInvokeExpression(
    null, // static method
    (MethodInfo)method.Method,
    method.Parameters.GetParameterTypes());
invoke.Arguments.Add(Expr.Param(writer));
invoke.Arguments.Add(Expr.Param(value).GetProperty(property));
 
// if (value.Foo != null) WriteFoo(writer, value.Foo);
body.Statements.Add(
    Stm.If(
        Expr.Inequality(Expr.Param(value).GetProperty(property), Expr.Null),
        Stm.Expr(invoke)
        ) // If
    ); // Add

UPDATED WIKI: Simple Xml Serializer Compiler

pelikhan — Sun, 20 May 2007 16:48:16 GMT

Simplex Xml Serializer Compiler

In this exercise, we will build a mini compiler that takes a Type annotated with some System.Xml.Serialization attributes and generates a lightweight serializer on the fly.

What we want to do...

For the sake of simplicity we will support properties tagged with XmlAttributeAttribute and XmlElementAttribute, in which cases the property can be an array as well. Let's this with an example:

public class Foo
{
    [XmlAttribute]
    public string Name {get;set;}
 
    [XmlElement]
    public Bar MyBar {get;set;}
}
 
    public class Bar
    {
        [XmlElement]
        public Foo[] Foes {get;set;}
    }

Given a little object tree, we'll expect the serializer to produce a nice xml output:

Foo foo = new Foo();
foo.Name = "Hello";
foo.MyBar = new Bar();
foo.MyBar.Foes = new Foo[]{ new Foo(), new Foo(), null };
foo.MyBar.Foes[0].Name = "foo1";
foo.MyBar.Foes[1].Name = "foo2";

gives

<Foo Name="Hello">
  <Bar>
    <Foes>
      <Foo Name="foo1" />
      <Foo Name="foo2" />
    </Foes>
  </Bar>
</Foo>

Designing the serializer

Given the type Foo, we expect the compiler to generate a method for each type Foo and Bar that works directly on a XmlWriter:

void WriteFoo(XmlWriter writer, Foo target)
{
    writer.WriteStartElement("Foo");
    writer.WriteAttributeString("Name", target.Name);
    if (target.Bar != null)
        WriteBar(writer, target.Bar);
    writer.WriteEndElement();
}
 
void WriteBar(XmlWriter writer, Bar bar)
{
    writer.WriteStartElement("Bar");
    if (bar.Foes!=null)
    {
        writer.WriteStartElements("Foes");
        foreach(Foo foo in bar.Foes)
        {  
            if (foo!=null)
                WriteFoo(writer, foo); 
        }
        writer.WriteEndElement();
    }
    writer.WriteEndElement();
}

Building the compiler

The compilation process is a 2-pass algorithm:

collect the list of types that might be serialized by walking the property types. For each type, define new {{WriteXXX} method,

* bake the body for each {{WriteXXX}} method

The full source of this sample is in the source distribution. Let's focus on interresting parts, i.e. generating the method bodies.

Write a property as argument:

PropertyInfo property = ...;
XmlAttributeAttribute xmlAttribute = Attribute.GetCustomAttribute(property, typeof(XmlAttributeAttribute)) 
    as XmlAttributeAttribute; // is this an attribute?
 
if (xmlAttribute!=null)
{
    // var value = target.Foo;
    Expression pvalue= Expr.Param(value).GetProperty(property);
    if (property.PropertyType != typeof(string))
    {
        // WriteAttributeString works with string
        // string value = XmlConvert.ToString(target.Foo);
        pvalue = Expr.InvokeMethod(
            typeof(XmlConvert), "ToString", BindingFlags.Public | BindingFlags.Static, pvalue);
     }
 
     // writer.WriteAttributeString("Foo", XmlConvert.ToString(target.Foo);
     body.Statements.Add(
         Expr.Param(writer).InvokeMethod(
             "WriteAttributeString", Expr.Prim(property.Name), pvalue)
         );
}

UPDATED WIKI: Simple Xml Serializer Compiler

pelikhan — Sun, 20 May 2007 16:33:38 GMT

Simplex Xml Serializer Compiler

In this exercise, we will build a mini compiler that takes a Type annotated with some System.Xml.Serialization attributes and generates a lightweight serializer on the fly.

What we want to do...

For the sake of simplicity we will support properties tagged with XmlAttributeAttribute and XmlElementAttribute, in which cases the property can be an array as well. Let's this with an example:

public class Foo
{
    [XmlAttribute]
    public string Name {get;set;}
 
    [XmlElement]
    public Bar MyBar {get;set;}
}
 
    public class Bar
    {
        [XmlElement]
        public Foo[] Foes {get;set;}
    }

Given a little object tree, we'll expect the serializer to produce a nice xml output:

Foo foo = new Foo();
foo.Name = "Hello";
foo.MyBar = new Bar();
foo.MyBar.Foes = new Foo[]{ new Foo(), new Foo(), null };
foo.MyBar.Foes[0].Name = "foo1";
foo.MyBar.Foes[1].Name = "foo2";

gives

<Foo Name="Hello">
  <Bar>
    <Foes>
      <Foo Name="foo1" />
      <Foo Name="foo2" />
    </Foes>
  </Bar>
</Foo>

Designing the serializer

Given the type Foo, we expect the compiler to generate a method for each type Foo and Bar that works directly on a XmlWriter:

void WriteFoo(XmlWriter writer, Foo target)
{
    writer.WriteStartElement("Foo");
    writer.WriteAttributeString("Name", target.Name);
    if (target.Bar != null)
        WriteBar(writer, target.Bar);
    writer.WriteEndElement();
}
 
void WriteBar(XmlWriter writer, Bar bar)
{
    writer.WriteStartElement("Bar");
    if (bar.Foes!=null)
    {
        writer.WriteStartElements("Foes");
        foreach(Foo foo in bar.Foes)
        {  
            if (foo!=null)
                WriteFoo(writer, foo); 
        }
        writer.WriteEndElement();
    }
    writer.WriteEndElement();
}

Compiler frontend

    public delegate void XmlWriterDelegate<T>(XmlWriter writer, T value);

UPDATED WIKI: Simple Xml Serializer Compiler

pelikhan — Sun, 20 May 2007 16:32:42 GMT

Simplex Xml Serializer Compiler

In this exercise, we will build a mini compiler that takes a Type annotated with some System.Xml.Serialization attributes and generates a lightweight serializer on the fly.

'Language design'

For the sake of simplicity we will support properties tagged with XmlAttributeAttribute and XmlElementAttribute, in which cases the property can be an array as well. Let's this with an example:

public class Foo
{
    [XmlAttribute]
    public string Name {get;set;}
 
    [XmlElement]
    public Bar MyBar {get;set;}
}
 
    public class Bar
    {
        [XmlElement]
        public Foo[] Foes {get;set;}
    }

Given a little object tree, we'll expect the serializer to produce a nice xml output:

Foo foo = new Foo();
foo.Name = "Hello";
foo.MyBar = new Bar();
foo.MyBar.Foes = new Foo[]{ new Foo(), new Foo(), null };
foo.MyBar.Foes[0].Name = "foo1";
foo.MyBar.Foes[1].Name = "foo2";

gives

<Foo Name="Hello">
  <Bar>
    <Foes>
      <Foo Name="foo1" />
      <Foo Name="foo2" />
    </Foes>
  </Bar>
</Foo>

Given the type Foo, we expect the compiler to generate a method for each type Foo and Bar that works directly on a XmlWriter:

void WriteFoo(XmlWriter writer, Foo target)
{
    writer.WriteStartElement("Foo");
    writer.WriteAttributeString("Name", target.Name);
    if (target.Bar != null)
        WriteBar(writer, target.Bar);
    writer.WriteEndElement();
}
 
void WriteBar(XmlWriter writer, Bar bar)
{
    writer.WriteStartElement("Bar");
    if (bar.Foes!=null)
    {
        writer.WriteStartElements("Foes");
        foreach(Foo foo in bar.Foes)
        {  
            if (foo!=null)
                WriteFoo(writer, foo); 
        }
        writer.WriteEndElement();
    }
    writer.WriteEndElement();
}

Compiler frontend

    public delegate void XmlWriterDelegate<T>(XmlWriter writer, T value);

Source code checked in

pelikhan — Sun, 20 May 2007 14:52:37 GMT

comestic changes

UPDATED WIKI: Simple Xml Serializer Compiler

pelikhan — Sun, 20 May 2007 14:50:53 GMT

Simplex Xml Serializer Compiler

In this exercise, we will build a mini compiler that takes a Type annotated with some System.Xml.Serialization attributes and generates a lightweight serializer on the fly.

'Language design'

For the sake of simplicity we will support properties tagged with XmlAttributeAttribute and XmlElementAttribute, in which cases the property can be an array as well. Let's this with an example:

public class Foo
{
    [XmlAttribute]
    public string Name {get;set;}
 
    [XmlElement]
    public Bar MyBar {get;set;}
}
 
    public class Bar
    {
        [XmlElement]
        public Foo[] Foes {get;set;}
    }

Given the type Foo, we expect the compiler to generate a method for each type Foo and Bar that works directly on a XmlWriter:

void WriteFoo(XmlWriter writer, Foo target)
{
    writer.WriteStartElement("Foo");
    writer.WriteAttributeString("Name", target.Name);
    if (target.Bar != null)
        WriteBar(writer, target.Bar);
    writer.WriteEndElement();
}
 
void WriteBar(XmlWriter writer, Bar bar)
{
    writer.WriteStartElement("Bar");
    if (bar.Foes!=null)
    {
        writer.WriteStartElements("Foes");
        foreach(Foo foo in bar.Foes)
        {  
            if (foo!=null)
                WriteFoo(writer, foo); 
        }
        writer.WriteEndElement();
    }
    writer.WriteEndElement();
}

Compiler frontend

    public delegate void XmlWriterDelegate<T>(XmlWriter writer, T value);

UPDATED WIKI: Simple Xml Serializer Compiler

pelikhan — Sun, 20 May 2007 14:50:29 GMT

Simplex Xml Serializer Compiler

In this exercise, we will build a mini compiler that takes a Type annotated with some System.Xml.Serialization attributes and generates a lightweight serializer on the fly.

'Language design'

For the sake of simplicity we will support properties tagged with XmlAttributeAttribute and XmlElementAttribute, in which cases the property can be an array as well. Let's this with an example:

    public class Foo
    {
        [XmlAttribute]
        public string Name {get;set;}
 
        [XmlElement]
        public Bar MyBar {get;set;}
    }
 
    public class Bar
    {
        [XmlElement]
        public Foo[] Foes {get;set;}
    }

Given the type Foo, we expect the compiler to generate a method for each type Foo and Bar that works directly on a XmlWriter:

void WriteFoo(XmlWriter writer, Foo target)
{
    writer.WriteStartElement("Foo");
    writer.WriteAttributeString("Name", target.Name);
    if (target.Bar != null)
        WriteBar(writer, target.Bar);
    writer.WriteEndElement();
}
 
void WriteBar(XmlWriter writer, Bar bar)
{
    writer.WriteStartElement("Bar");
    if (bar.Foes!=null)
    {
        writer.WriteStartElements("Foes");
        foreach(Foo foo in bar.Foes)
        {  
            if (foo!=null)
                WriteFoo(writer, foo); 
        }
        writer.WriteEndElement();
    }
    writer.WriteEndElement();
}

Compiler frontend

    public delegate void XmlWriterDelegate<T>(XmlWriter writer, T value);

UPDATED WIKI: Simple Xml Serializer Compiler

pelikhan — Sun, 20 May 2007 14:49:46 GMT

Simplex Xml Serializer Compiler

In this exercise, we will build a mini compiler that takes a Type annotated with some System.Xml.Serialization attributes and generates a lightweight serializer on the fly.

'Language design'

For the sake of simplicity we will support properties tagged with XmlAttributeAttribute and XmlElementAttribute, in which cases the property can be an array as well. Let's this with an example:

    public class Foo
    {
        [XmlAttribute]
        public string Name {get;set;}
 
        [XmlElement]
        public Bar MyBar {get;set;}
    }
 
    public class Bar
    {
        [XmlElement]
        public Foo[] Foes {get;set;}
    }

Given the type Foo, we expect the compiler to generate a method for each type Foo and Bar that works directly on a XmlWriter:

void WriteFoo(XmlWriter writer, Foo target)
{
    writer.WriteStartElement("Foo");
    writer.WriteAttributeString("Name", target.Name);
    if (target.Bar != null)
        WriteBar(writer, target.Bar);
    writer.WriteEndElement();
}
 
void WriteBar(XmlWriter writer, Bar bar)
{
    writer.WriteStartElement("Bar");
    if (bar.Foes!=null)
    {
        writer.WriteStartElements("Foes");
        foreach(Foo foo in bar.Foes)
        {  WriteFoo(writer, foo); }
        writer.WriteEndElement();
    }
    writer.WriteEndElement();
}

Compiler frontend

    public delegate void XmlWriterDelegate<T>(XmlWriter writer, T value);

UPDATED WIKI: Home

pelikhan — Sun, 20 May 2007 14:31:43 GMT

Toad, a framework for building toy compilers and languages in .net.

Curious? Check out Hello World or a simple Xml serializer compiler
User Manual
Peli's blog

Toad was written to get a better understanding of what it takes to build languages.... during my commute sessions. It is not meant to be complete and certaintly not used in production

UPDATED WIKI: Home

pelikhan — Sun, 20 May 2007 14:29:49 GMT

Toad, a .net compiler playground

Curious? Check out Hello World or a simple Xml serializer compiler
User Manual
Peli's blog

Toad was written to get a better understanding of what it takes to build languages.... during my commute sessions. It is not meant to be complete and certaintly not used in production

UPDATED WIKI: Home

pelikhan — Sun, 20 May 2007 14:28:45 GMT

Toad, a .net compiler playground

made while commuting

Toad is a framework to play around building languages and compiler for .net. Toad provides an AST (expression and statement tree) which gets compiled to MSIL using Reflection.Emit. Toad also comes with a set of AST visitors to solve common task such as inferring variable types, computing closures, optimization string concats or refactoring to some extent.

Curious? Check out Hello World or a simple Xml serializer compiler
User Manual
Peli's blog

Toad was written to get a better understanding of what it takes to build languages.... during my commute sessions. It is not meant to be complete and certaintly not used in production