A Simple Compiler for the Common Language Runtime

/*
Sharp Compiler
Copyright (C) 2003  Michael Bebenita

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
using System;
using System.Collections;

namespace Core.Compilation
{
	public enum SymbolType
	{
		None,
		Function,
		Structure,
		Variable
	}

	public class Symbol
	{
		public string Name;
		public SymbolType Type = SymbolType.None;
		public object SyntaxObject;
		public object CodeObject;

		public Symbol(string name, SymbolType type, object syntaxObject, object codeObject)
		{
			Name = name;	Type = type;	SyntaxObject = syntaxObject;	CodeObject = codeObject;
		}
	}

	public class SymbolTable
	{
		private SymbolTable m_Parent = null;
		private Hashtable m_Hashtable = new Hashtable();

		public SymbolTable()
		{

		}

		public SymbolTable(SymbolTable parent)
		{
			m_Parent = parent;
		}

		public Symbol Add(Variable variable)
		{
			return Add(variable.Name,SymbolType.Variable,variable,null);
		}

		public Symbol Add(Function function)
		{
			return Add(function.Name,SymbolType.Function,function,null);
		}

		public Symbol Add(Structure structure)
		{
			return Add(structure.Name,SymbolType.Structure,structure,null);
		}

		public Symbol Add(string name,SymbolType type, object syntaxObject, object codeObject)
		{
			string prefix = PrefixFromType(type);

			if(m_Hashtable.Contains(prefix + name))
				throw new SymbolException("Symbol already exists in symbol table.");

			Symbol symbol = new Symbol(name,type,syntaxObject,codeObject);
			m_Hashtable.Add(prefix + name,symbol);

			return symbol;
		}

		public bool Contains(string name, SymbolType type)
		{
			return Find(name,type) != null;
		}

		public Symbol Find(string name, SymbolType type)
		{
			string prefix = PrefixFromType(type);

			if(m_Hashtable.Contains(prefix + name))
				return (Symbol)m_Hashtable[prefix + name];
			else if(m_Parent != null)
			{
				return m_Parent.Find(name,type);
			}
			else
				return null;
		}

		private string PrefixFromType(SymbolType type)
		{
			if(type == SymbolType.Function)
				return "f_";
			else if(type == SymbolType.Structure)
				return "s_";
			else if(type == SymbolType.Variable)
				return "v_";
			return "";
		}		
	}

	public delegate void VerifierEventHandler(string message);

	public class Verifier
	{
		public event VerifierEventHandler Error;

		private Module m_Module = null;

		public Verifier(Module module)
		{
			m_Module = module;

			//
			// Build symbol tables.
			//

			//m_Module.Body.SymbolTable = new SymbolTable();
			//BuildSymbolTable(m_Module.Body.SymbolTable,m_Module.Body);

		}

		private void BuildSymbolTable(SymbolTable parent, Body body)
		{
			if(body.Structures != null)
				foreach(Structure structure in body.Structures)
					parent.Add(structure).SyntaxObject = structure;

			if(body.Functions != null)
			{
				foreach(Function function in body.Functions)
				{
					parent.Add(function).SyntaxObject = function;
					function.Body.SymbolTable = new SymbolTable();
					BuildSymbolTable(function.Body.SymbolTable,function.Body);
				}
			}

			if(body.Statements != null)
			{
				foreach(Statement statement in body.Statements)
				{
					if(statement is Variable)
						parent.Add(statement as Variable).SyntaxObject = statement;
				}
			}
		}

		public bool VerifyExpression(SymbolTable symbolTable, Expression expression)
		{
			//
			// Verify expression.
			//

			try
			{
				GetExpressionType(symbolTable,expression);
				return true;
			}
			catch(VerifierException x)
			{
				System.Diagnostics.Debug.WriteLine(x.Message);
				return false;
			}
		}

		public Type GetExpressionType(SymbolTable symbolTable, Expression expression)
		{
			if(expression is UnaryExpression)
			{
				UnaryExpression unary = (UnaryExpression)expression;
				return FindType(GetExpressionType(symbolTable,unary.Value),unary.UnaryOperatorType);
			}
			else if(expression is BinaryExpression)
			{
				BinaryExpression binary = (BinaryExpression)expression;
				return FindType(GetExpressionType(symbolTable,binary.Left),GetExpressionType(symbolTable,binary.Right),binary.BinaryOperatorType);
			}
			else if(expression is Literal)
			{
				Literal literal = expression as Literal;

				if(literal.LiteralType == LiteralType.Boolean)
					return new Type(PrimitiveType.Boolean);
				if(literal.LiteralType == LiteralType.Character)
					return new Type(PrimitiveType.Character);
				if(literal.LiteralType == LiteralType.Integer)
					return new Type(PrimitiveType.Integer);
				if(literal.LiteralType == LiteralType.Real)
					return new Type(PrimitiveType.Real);
				if(literal.LiteralType == LiteralType.String)
					return new Type(PrimitiveType.Void);
			}
			else if(expression is Name)
			{
				return ((Variable)symbolTable.Find(((Name)expression).Value,SymbolType.Variable).SyntaxObject).Type;
			}
			else if(expression is Call)
			{
				return ((Call)expression).Type;
			}
			return null;
		}

		public Type FindType(Type leftType, Type rightType, BinaryOperatorType operatorType)
		{
			//
			// Binary operations can only be performed on primitive types.
			//

			if((leftType.VariableType != VariableType.Primitive) || (rightType.VariableType != VariableType.Primitive))
				throw new VerifierException("Binary operations can only be performed on primitive types.");

			//
			// Boolean operations.
			//

			if(leftType.PrimitiveType == PrimitiveType.Boolean && rightType.PrimitiveType == PrimitiveType.Boolean)
			{
				switch(operatorType)
				{
					case BinaryOperatorType.And:
					case BinaryOperatorType.Or:
					case BinaryOperatorType.NotEqual:
						return new Type(PrimitiveType.Boolean);
						break;
					default:
						throw new VerifierException("Specified operator cannot be applied to boolean types.");
						break;
				}
			}

			//
			// Integer operations.
			//

			else if(leftType.PrimitiveType == PrimitiveType.Integer && rightType.PrimitiveType == PrimitiveType.Integer)
			{
				switch(operatorType)
				{
					case BinaryOperatorType.And:
					case BinaryOperatorType.Or:
						throw new VerifierException("Specified operator cannot be applied to integer types.");
						break;
					case BinaryOperatorType.GraterOrEqualTo:
					case BinaryOperatorType.GreaterThen:
					case BinaryOperatorType.LessOrEqualTo:
					case BinaryOperatorType.LessThen:
					case BinaryOperatorType.Equal:
					case BinaryOperatorType.NotEqual:
						return new Type(PrimitiveType.Boolean);
						break;
					default:
						return new Type(PrimitiveType.Integer);
				}
			}

			//
			// Real operations.
			//

			else if(leftType.PrimitiveType == PrimitiveType.Real && rightType.PrimitiveType == PrimitiveType.Real)
			{
				switch(operatorType)
				{
					case BinaryOperatorType.And:
					case BinaryOperatorType.Or:
						throw new VerifierException("Specified operator cannot be applied to real types.");
						break;
					default:
						return new Type(PrimitiveType.Real);
				}
			}

			//
			// Character operations.
			//

			else if(leftType.PrimitiveType == PrimitiveType.Character && rightType.PrimitiveType == PrimitiveType.Character)
			{
				switch(operatorType)
				{
					case BinaryOperatorType.And:
					case BinaryOperatorType.Or:
						throw new VerifierException("Specified operator cannot be applied to character types.");
						break;
					default:
						return new Type(PrimitiveType.Character);
				}
			}

			throw new VerifierException("Incompatible types for specified operation.");
		}

		public Type FindType(Type type, UnaryOperatorType operatorType)
		{
			switch(operatorType)
			{
				case UnaryOperatorType.Indexer:
					if(type.VariableType == VariableType.PrimitiveArray)
						return new Type(type.PrimitiveType);
					else if(type.VariableType == VariableType.StructureArray)
						return new Type(type.Name);
					else
						throw new VerifierException("The indexer operator cannot be applied to the specified type.");
					break;
				case UnaryOperatorType.Not:
					if(type.PrimitiveType == PrimitiveType.Boolean)
						return new Type(type.PrimitiveType);
					else
						throw new VerifierException("The NOT operator cannot be applied to the specified type.");
					break;
				default:
					if(type.VariableType == VariableType.Primitive)
						return new Type(type.PrimitiveType);
					else
						throw new VerifierException("The +/- operators cannot be applied to the specified type.");
					break;
			}
		}


		public bool VerifyBody(Body body)
		{
			//
			// Check variable declarations.
			//

			foreach(Statement statement in body.Statements)
			{
				if(statement is Variable)
				{
					Variable variable = (Variable)statement;
					if(variable.Value is Expression)
					{
						if(VerifyExpression(body.SymbolTable,(Expression)variable.Value))
							System.Diagnostics.Debug.WriteLine("Fuck yah");
						else
							System.Diagnostics.Debug.WriteLine("Fuck nahh");
					}
				}
			}

			return false;
		}

		


	}
}