Microsoft Visual Studio Solution File, Format Version 9.00

# Visual Studio 2005

Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "aml", "aml\aml.csproj", "{003790E7-06F5-4529-9149-6AB749345E8C}"

EndProject

Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "test", "test\test.csproj", "{9191BA44-53E9-4F67-AD60-6ECEA8708A3C}"

EndProject

Global

	GlobalSection(SolutionConfigurationPlatforms) = preSolution

		Debug|Any CPU = Debug|Any CPU

		Release|Any CPU = Release|Any CPU

	EndGlobalSection

	GlobalSection(ProjectConfigurationPlatforms) = postSolution

		{003790E7-06F5-4529-9149-6AB749345E8C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

		{003790E7-06F5-4529-9149-6AB749345E8C}.Debug|Any CPU.Build.0 = Debug|Any CPU

		{003790E7-06F5-4529-9149-6AB749345E8C}.Release|Any CPU.ActiveCfg = Release|Any CPU

		{003790E7-06F5-4529-9149-6AB749345E8C}.Release|Any CPU.Build.0 = Release|Any CPU

		{9191BA44-53E9-4F67-AD60-6ECEA8708A3C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

		{9191BA44-53E9-4F67-AD60-6ECEA8708A3C}.Debug|Any CPU.Build.0 = Debug|Any CPU

		{9191BA44-53E9-4F67-AD60-6ECEA8708A3C}.Release|Any CPU.ActiveCfg = Release|Any CPU

		{9191BA44-53E9-4F67-AD60-6ECEA8708A3C}.Release|Any CPU.Build.0 = Release|Any CPU

	EndGlobalSection

	GlobalSection(MonoDevelopProperties) = preSolution

		version = 0.1

		outputpath = build\bin

		StartupItem = aml\aml.csproj

		name = aml

	EndGlobalSection

EndGlobal

<?xml version="1.0" encoding="utf-8"?>

<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

    <ProductVersion>8.0.50727</ProductVersion>

    <SchemaVersion>2.0</SchemaVersion>

    <ProjectGuid>{003790E7-06F5-4529-9149-6AB749345E8C}</ProjectGuid>

    <OutputType>Library</OutputType>

    <AssemblyName>aml</AssemblyName>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

    <DebugSymbols>true</DebugSymbols>

    <DebugType>full</DebugType>

    <Optimize>true</Optimize>

    <OutputPath>bin\Debug</OutputPath>

    <DefineConstants>DEBUG</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

    <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>

    <ConsolePause>false</ConsolePause>

    <Execution>

      <Execution clr-version="Net_2_0" />

    </Execution>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

    <DebugType>none</DebugType>

    <Optimize>true</Optimize>

    <OutputPath>bin\Release</OutputPath>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

    <ConsolePause>false</ConsolePause>

    <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>

    <Execution>

      <Execution clr-version="Net_2_0" />

    </Execution>

  </PropertyGroup>

  <ItemGroup>

    <Compile Include="node.cs" />

    <Compile Include="scanner.cs" />

    <Compile Include="parser.cs" />

    <Compile Include="path\path.cs" />

    <Compile Include="path\scanner.cs" />

    <Compile Include="path\parser.cs" />

  </ItemGroup>

  <ItemGroup>

    <Reference Include="System" />

  </ItemGroup>

  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />

  <ItemGroup>

    <Folder Include="path\" />

  </ItemGroup>

</Project>

/*

 * 

 * aml.node

 * ~~~~~~~~

 * 

 * :copyright: 2009 by Bjoern Schulz <bjoern.schulz.92@gmail.com>

 * :license: MIT, see LICENSE for more details 

 * 

 */

using System;

using System.Collections;

using System.Text.RegularExpressions;

namespace aml.node {

	public interface INode: IEnumerable {

		object this[string name] {

			get;

			set;

		}

		void SetAttribute(string name, object value);

		object GetAttribute(string name);

		void DeleteAttribute(string name);

		IList Children {

			get;

		}

		Hashtable Attributes {

			get;

		}

		int Length {

			get;

		}

		INode Parent {

			get;

		}

		INode FirstChild {

			get;

		}

		INode LastChild {

			get;

		}

		string Name {

			set;

			get;

		}

		IEnumerable Each();

		void Append(Node node);

		void Insert(int index, Node node);

		void Remove(Node node);

	}

	public class Node: INode {

		private string _name;

		private Node _parent = null;

		private Node _first_child = null;

		private Node _last_child = null;

		private Hashtable _attributes = new Hashtable();

		private ArrayList _children = new ArrayList();

		public Node(string name) {

			this._name = name;

		}

		public Node(string name, Hashtable attributes) {

			this._name = name;

			foreach (DictionaryEntry entry in attributes) {

				this._attributes[entry.Key] = entry.Value;

			}

		}

		public Node(string name, IList children) {

			this._name = name;

			foreach (Node node in children) {

				this.Append(node);

			}

		}

		public Node(string name, Hashtable attributes, IList children) {

			this._name = name;

			foreach (DictionaryEntry entry in attributes) {

				this._attributes[entry.Key] = entry.Value;

			}

			foreach (Node node in children) {

				this.Append(node);

			}

		}

		public override string ToString() {

			string src = "(" + this._name + "{atts}{childs})";

			string attributes = "";

			foreach(DictionaryEntry entry in this._attributes) {

				attributes += " (" + entry.Key + " \"" + entry.Value + "\")";

			}

			src = src.Replace("{atts}", attributes);

			string childs = "";

			foreach(Node node in this._children) {

				childs += " " + node.ToString();

			}

			src = src.Replace("{childs}", childs);

			return src;

		}

		public IEnumerable Each() {

			foreach (Node node in this) {

				yield return node;

			}

		}

		public void SetAttribute(string name, object value) {

			this._attributes[name] = value;

		}

		public object GetAttribute(string name) {

			return this._attributes[name];

		}

		public void DeleteAttribute(string name) {

			this._attributes.Remove(name);

		}

		public void Append(Node node) {

			this.Insert(this._children.Count, node);

		}

		public void Insert(int index, Node node) {

			node._parent = node;

			this._children.Insert(index, node);

			this._first_child = (Node) this._children[0];

			this._last_child = (Node) this._children[this.Length - 1];

		}

		public void Remove(Node node) {

			this._children.Remove(node);

			if (this._children.Count > 0) {

				this._first_child = (Node) this._children[0];

				this._last_child = (Node) this._children[this.Length - 1];

			}

		}

		public int Length {

			get {

				return this._children.Count;

			}

		}

		public INode Parent {

			get {

				return this._parent;

			}

		}

		public INode FirstChild {

			get {

				return this._first_child;

			}

		}

		public INode LastChild {

			get {

				return this._last_child;

			}

		}

		public string Name {

			get {

				return this._name;

			} set {

				Regex re = new Regex("^\\w+$");

				if (re.IsMatch(value) && value.Length > 0) {

					this._name = value;

				}

			}

		}

		public object this[string name] {

			get {

				return this._attributes[name];

			} set {

				this._attributes[name] = value;

			}

		}

		public Hashtable Attributes {

			get {

				return this._attributes;

			}

		}

		public IList Children {

			get {

				return this._children;

			}

		}

		IEnumerator IEnumerable.GetEnumerator() {

			return new NodeEnum(this._children);

        }

	}

	public class NodeEnum: IEnumerator {

		private ArrayList _children;

		private int position = -1;

		public NodeEnum(ArrayList children) {

			this._children = children;

		}

		public bool MoveNext() {

			this.position++;

			return (this.position < this._children.Count);

		}

		public void Reset() {

			this.position--;

		}

		public object Current {

			get {

				try {

					return this._children[position];

				} catch (IndexOutOfRangeException) {

					throw new InvalidOperationException();

				}

			}

		}

	}	

}

using System;

using System.Collections;

using System.Text.RegularExpressions;

using aml.node;

using aml.scanner;

namespace aml.parser {

	public class Parser {

		private IEnumerator scanner;

		private string t;

		private object v;

		public Parser(IEnumerable scanner) {

			this.scanner = scanner.GetEnumerator();

			this.advance();

		}

		public Parser(string src) {

			this.scanner = Scanner.scanner(src).GetEnumerator();

			this.advance();

		}

		private void advance() {

			if(this.scanner.MoveNext()) {

				ArrayList current = (ArrayList) this.scanner.Current;

				this.t = (string) current[0];

				this.v = current[1];

			} else {

				this.t = null;

				this.v = null;

			}

		}

		private object expect(string t) {

			if(this.t != t) {

				throw(new Exception("SyntaxError: " + t + " excepted"));

			}

			object v = this.v;

			advance();

			return v;

		}

		private Node node(string name) {

			Node node = new Node(name);

			while(t == "(") {

				advance();

				name = (string) expect("name");

				if(t == "value") {

					node[name] = expect("value");

					expect(")");

				} else if(t == "(") {

					node.Append(this.node(name));

				} else if(t == ")") {

					node.Append(new Node(name));

					advance();

				}

			}

			expect(")");

			return node;

		}

		public Node parse() {

			expect("(");

			string name = (string) expect("name");

			return this.node(name);

		}

	}

}

using System;

using System.Collections;

using System.Text.RegularExpressions;

namespace aml.scanner {

	class Scanner {

		public static IEnumerable scanner(string src) {

			Regex re = new Regex("([-+]?\\d+)|(\\w+)|\"([^\"]*)\"|'([^']*)'|([()])|#.*?\n|\\s+");

			foreach (Match match in re.Matches(src)) {

				int i = 0;

				foreach(Group group in match.Groups) {

					if (group.Success && i > 0) {

						ArrayList token = new ArrayList(2);

						if (i == 1) {

							token.Add("value");

							token.Add(Convert.ToInt32(group.Value));

							yield return token;

						} else if (i == 2) {

							token.Add("name");

							token.Add(group.Value);

							yield return token;

						} else if (i == 3 || i == 4) {

							token.Add("value");

							token.Add(group.Value);

							yield return token;

						} else if (i == 5) {

							token.Add(group.Value);

							token.Add(group.Value);

							yield return token;

						}

					}

					i++;

				}

			}

		}

	}

}

using System;

using System.Collections;

using System.Text.RegularExpressions;

namespace aml.validator {

	public class Type {

		private Regex regex;

		public Type(Regex regex) {

			this.regex = regex;

		}

		public bool validate(string source) {

			return this.regex.IsMatch(source);

		}

	}

	public class Node {

		public string name;

		public Hashtable attributes = new Hashtable();

		public ArrayList children = new ArrayList();

		public Node(string name) {

			this.name = name;

		}

	}

	public class Validator {

		private Node document;

		private Node definition;

		public Validator(Node document, Node definition) {

			this.document = document;

			this.definition = definition;

		}

		public bool validate() {

			return true;

		}

	}	

}