diff --git a/dead/mbas/.cvsignore b/dead/mbas/.cvsignore
new file mode 100644
index 00000000..b2a1b4e1
--- /dev/null
+++ b/dead/mbas/.cvsignore
@@ -0,0 +1,16 @@
+mb-parser.cs
+y.output
+log
+mbas.csproj
+mbas.csproj.user
+mbas.sln
+mbas.suo
+mbas.xml
+mbas.*.log
+mbas.p*
+*.exe
+*.pdb
+*.dll
+*~
+.*
+*.mdb
diff --git a/dead/mbas/AssemblyInfo.cs b/dead/mbas/AssemblyInfo.cs
new file mode 100644
index 00000000..800b396b
--- /dev/null
+++ b/dead/mbas/AssemblyInfo.cs
@@ -0,0 +1,53 @@
+// MonoBASIC Compiler, this is a compiler for the MonoBASIC language, which is a superset of Visual Basic.NET
+// Copyright (C) 2002  Rafael Teixeira
+//
+// 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.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: AssemblyTitle("MonoBASIC Compiler")]
+[assembly: AssemblyDescription("This is a compiler for the MonoBASIC language, \nwhich is a superset of Visual Basic.NET")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("(c)2002, 2003, 2004, 2005 Rafael Teixeira")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]		
+
+[assembly: Mono.Author("Sudharsan V")]
+[assembly: Mono.Author("Satya Sudha K")]
+[assembly: Mono.Author("Manjula GHM")]
+[assembly: Mono.Author("Anirban Bhattacharjee")]
+[assembly: Mono.Author("Martin Baulig")]
+[assembly: Mono.Author("Marco Ridoni")]
+[assembly: Mono.Author("Rafael Teixeira")]
+[assembly: Mono.Author("Miguel de Icaza")]
+[assembly: Mono.Author("Ravi Pratap")]
+
+[assembly: Mono.About("Distributed under the GPL 2.0")]
+
+[assembly: Mono.UsageComplement("SOURCE-FILES")]
+
+//[assembly: Mono.LicensingWith(Mono.GetOptions.Licenses.GPL)]
+[assembly: Mono.AdditionalInfo("For more information: http://www.mono-project.com/Language_BASIC")]
+[assembly: Mono.ReportBugsTo(" http://bugzilla.ximian.com/enter_bug.cgi?product=Mono%3A+Compilers&component=Basic ")]
+
+[assembly: AssemblyVersion(Consts.MonoVersion)]
+
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyKeyName("")]
diff --git a/dead/mbas/ChangeLog b/dead/mbas/ChangeLog
new file mode 100644
index 00000000..db231782
--- /dev/null
+++ b/dead/mbas/ChangeLog
@@ -0,0 +1,2073 @@
+2006-02-21 Jelmer Vernooij <jelmer@samba.org>
+	* Test/tests/statements/AssignmentStatementsJ.vb: Add test that 
+	demonstrates bug in incremental property assignment.
+
+2006-01-23 Jelmer Vernooij <jelmer@samba.org>
+	* Test/tests/typemembers/EventP.vb: Add tests that check for 
+	more complex constructions in AddHandler / RemoveHandler.
+	* Test/tests/typemembers/EventO.vb: Test for parsing a WITHEVENTS 
+	variable declaration after it is being used in a 'Handles ...' clause.
+
+2005-12-21 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+ 	* ecore.cs, cfold.cs: Changed for reflecting correct Error Number/Message with
+	Implict Convertions when Option Strict is On.
+
+2005-12-07 Jelmer Vernooij <jelmer@samba.org>
+ 	* Makefile: allow build of only mbas, without the need to built the 
+	class library
+
+2005-11-29 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+       * test-mbas.pl: Parsing Test Files in order to find necessary
+       compilerOptions and generate the correct CompileCommand.
+
+2005-11-28 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+ 	* decl.cs: Avoid to stop searching for class members after encountering
+  	the first member, in order to find the inherited or overloaded members.
+ 
+2005-11-28 Jelmer Vernooij <jelmer@samba.org>
+	* Fix to Bugzilla Bug #76476: bash-specific code in 
+	mbas/Test/misc/Makefile
+ 	
+2005-11-20 Jelmer Vernooij <jelmer@samba.org>
+	* genericparser.cs,decl.cs,class.cs: allow members with the same name 
+ 	as their enclosing type, just like vbc does
+
+2005-11-19 Jelmer Vernooij <jelmer@samba.org>
+ 	* mb-parser.jay: fix error handling when array modifiers are specified
+ 	on both type and variable name
+
+2005-11-18 Jelmer Vernooij <jelmer@samba.org>
+ 	* mb-tokenizer.cs: add fix so the tokenizer no longer parses label 
+ 	names at the start of continuation lines
+
+2005-11-16 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+	* mb-parser.jay: Do not create a set_block with ReadOnly Properties.
+	* typemanager.cs: Search for correct DefaultPropName and the class
+	Type that contains the Default Property.
+	* expression.cs: Send the correct Type for porperties search;
+	Fix Error with uses of default properties without a Default Property
+	definition.
+	
+2005-11-09 Renato Suga <renato.suga@gmail.com>
+	* mb-parser.jay: added STOP to statement rule to allow a keyword STOP
+	in an iteration_statement.
+
+2005-11-07 Renato Suga <renato.suga@gmail.com>
+	* Expression.cs: commented this line: 
+	 //      SimpleName.Error_ObjectRefRequired (ec, loc, me.Name);
+
+
+2005-11-05  Kornél Pál  <kornelpal@hotmail.com>
+
+	* AssemblyInfo.cs: Use Consts.MonoVersion as AssemblyVersion.
+	* mbas.exe.sources: Added Consts.cs.
+
+2005-11-02  Rafael Teixeira <rafaelteixeirabr@hotmail.com> 
+	* typemanager.cs: avoiding some Null Pointer Exceptions in GetPertinentStandardModules
+
+2005-11-01 Aldo Monteiro do Nascimento <aldo@psl-pr.softwarelivre.org>
+ 	* mb-parser.jay: created a new parser rule to match a interface
+ 	declared inside another interface: "opt_interface_declaration"
+ 	* mb-parser.jay: when redeclare compiler constants no compilation
+ 	error is raised, and than the redeclaring works as expected.
+ 
+2005-10-31 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+ 	* ecore.cs: Fix UnboxCast Emit calling Activator.CreateInstance when
+ 	necessary.
+
+2005-10-29 Renato Suga<renato@psl-pr.softwarelivre.org>
+ 	* codegen.cs: Added static global ArrayList ArrListVersion to keep the 
+ 	assembly's version numbers. reating a new Version(string str) is not 
+ 	working. The Init() method was modified to correctly set the version value;
+ 	* attribute.cs: one of its constructor was modified to pass the string 
+ 	version to CodeGen.ArrListVersion so that at Init () CodeGen sets the 
+ 	correct version.
+ 
+2005-10-19 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+	* class.cs: Casting TypeContainer to Interface in order to call the
+	correct overload of RootContext.RegisterOrder.
+
+2005-10-12 Renato Suga <renato@psl-pr.softwarelivre.org>
+ 	* mb-parser.jay: foreach_statement now emits the correct error code for 
+ 	test ForEachC1.vb, which is an error test
+
+2005-10-11 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+           
+  	* block.cs, statements.cs, mb-parser.jay: Support for On Error Goto 0,
+  	On Error Goto -1 and On Error Goto <Label>
+  	
+2005-10-07 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+           Alexandre Rocha Lima e Marcondes <alexandre@psl-pr.softwarelivre.org>       
+           Rafael Teixeira <rafaelteixeirabr@hotmail.com>  
+           
+  	* block.cs, statements.cs, expression.cs: Fix ForEach when iterating fields
+  	
+2005-10-05 Aldo Monteiro <aldo@psl-pr.softwarelivre.org>
+ 
+ 	* ecore.cs : Created a public property (Id) to access externally the field
+ 	id in DecoratedIdentifier class
+ 	* assign.cs : Before get the expression for construct 'Mid' statement
+ 	testing if that expression is 'DecoratedIdentifier', and, if it is,
+ 	getting the expression assigned in its 'id' field.
+
+2005-09-26 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+           Alexandre Rocha Lima e Marcondes <alexandre@psl-pr.softwarelivre.org>       
+	* mb-parser.jay: Fix ForEach when using fields as the variable used
+	to iterate through the elements.
+	* expression.cs: Created new LocalVariableReference EmitAssign used in
+	for each with non Static fields.
+	* statement.cs: Created new attribute of VariableInfo - FieldAlias wich
+	references a FieldBase indicated by the alias.
+		Added a field assign treatment if the foreach variable references
+	a non static field, in EmitCollectionForeach and EmitArrayForeach.
+	* mb-parser.jay, block.cs, statement.cs, expression.cs: Remove Bool Static
+	Attribute from VariableInfo class.
+
+2005-09-22 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+	* mb-parser.jay: Throws error for Option Strict on with Propeties
+	whitout an 'As' clause or a type character. Fix Interfaces errors with
+	Shared modifiers.
+
+2005-09-16  Renato Suga <renato@psl-pr.softwarelivre.org>
+	* mb-parser.jay:rules goto_statement and for_statement changed in order 
+	to recognize error BC30757
+	* statement.cs: class added property LabelName and uncomented string 
+	label_name. These changes allow one to get the LabelName when reporting 
+	an error
+	* block.cs: added property bool HasGotoStatement and property String 
+	LabelName. The first one combined with HasLabeledStatement allows one to
+	identify the aforementioned error.
+
+2005-09-15  Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+	    Alexandre Rocha Lima e Marcondes
+	    <alexandre@psl-pr.softwarelivre.org>
+	*  mb-parser.jay : Error statement statemet support.
+
+2005-08-23 Satya Sudha K <ksathyasudha@novell.com>
+	* statement.cs : 
+		StatementSequence : Avoid Resolving multiple times
+	* ecore.cs :
+		Minor fix to 'Constantify' method
+
+2005-08-22 Satya Sudha K <ksathyasudha@novell.com>
+	* expression.cs : 
+		Invocation's DoResolve method : Avoid resolving multiple times.
+	* typemanager.cs :
+		'GetPertinentStandardModules' : Case-insensitive name lookup
+
+2005-08-19 Satya Sudha K <ksathyasudha@novell.com>
+	* expression.cs :
+		Preventing conversion of an 'object' to 't[]' where the latter is a 
+		ParamArray parameter
+	* statement.cs :
+	* codegen.cs :
+		Fixed handling of 'Return' and 'Exit' statements from within 
+		Try/Catch blocks
+
+2005-08-09 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+	* mb-parser.jay: Define as used the function's return variable,
+	because of bug #75747.
+	Fix Event errors with Shared modifiers.
+
+2005-08-05 Gert Driesen <drieseng@users.sourceforge.net>
+
+	* expression.cs: Initialize FieldBase variable. Fixes build using csc
+	because of bug #75721.
+
+2005-08-05 Satya Sudha K <ksathyasudha@novell.com>
+	* expression.cs :
+		'ConstructArgumentList': Converting the default value to the param type before
+					 appending to the arg list
+
+2005-08-04:2  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* statement.cs:  
+		Oops, line number on Redim errors as Aldo/Renato intended
+		Better logic flow when redim errors occur to avoid exceptions later
+		
+2005-08-04  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* statement.cs:  Refactored code/fields from Redim to RedimClause 
+	so that it works for multiple arrays being redimensioned in the same statement 
+	* mb-parser.jay: redim_clauses rule was losing additional items
+
+2005-08-04  Aldo Monteiro <aldo@psl-pr.softwarelivre.org>, 
+	Renato Suga <renato@psl-pr.softwarelivre.org>
+	* mb-parser.jay: treatment of opt_type_spec in redim_clause
+	* statement.cs: changed constructor in class RedimClause so that it gets
+	an Expression. Report.Error now emits the line number too for ReDim
+	errors. New attribute in RedimClause: Expression ExprAs 
+
+2005-08-04 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+	* mb-parser.jay: Fix local static variables initialization
+	
+2005-07-29 Satya Sudha K <ksathyasudha@novell.com>
+	* mb-parser.jay, expression.cs: Fixed concat operation with compound assign statements
+	* support.cs : Returning 'NullLiteral.Null', when a parameter default value is null
+
+2005-07-22 Maverson Eduardo Schulze Rosa <maverson@gmail.com> and Alexandre
+Rocha Lima e Marcondes <alexandre@psl-pr.softwarelivre.org>
+	* block.cs: Local variable alias and static flag  support and
+  	  MethodBlock class that knows the name of the Method that owns it
+	* class.cs: Static local specialname modificator emission
+	* expression.cs: Hidden static field access using the static local
+	  alias
+	* statement.cs: Local variable alias support and Static local flag
+	* mb-parser.jay: Static local identification and related erros
+	
+	
+2005-07-26 Ankit Jain <jankit@novell.com>
+
+	* typemanager.cs (TypeManager): Change types of system_*_expr from Expression
+	  to TypeExpr.
+	  (TypeToCoreTypExpr): New.
+	* ecore.cs (DecoratedIdentifier): New. For an identifier with a typecharacter.
+	* mb-tokenizer.cs: Allow type characters for numbers.
+	* constant.cs (IntConstant.ConvertToDecimal): New.
+	  (DoubleConstant.ConvertToFloat): Return FloatConstant.
+	  (DoubleConstant.ConvertToDecimal): New. 
+	* mb-parser.jay (type_character): Return Type instead of TypeExpr.
+	  (primary_expression): Add 'literal type_character' variant.
+	  	(qualified_identifier) : Use DecoratedIdentifier in case of a typecharacter.
+	  (ConvertLiteral): New. Convert literal to a different type.
+
+2005-07-25 Ankit Jain <jankit@novell.com>
+
+	* mb-parser.jay: RaiseEvent: Add code to check for null event.
+
+2005-07-22 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+	* block.cs: Fix dead code detection
+ 
+2005-07-22 Satya Sudha K <ksathyasudha@novell.com>
+	* mb-tokenizer.cs: Fix for statements ending with ':'
+
+2005-07-22 Manjula GHM <mmanjula@novell.com>
+	*mb-parser.jay: Check for type before resolving
+	
+2005-07-22 Ankit Jain <jankit@novell.com>
+
+	* mb-parser.jay: evt_handler_list: New.
+	  opt_evt_handler, sub_declaration: Support multiple event handlers.
+
+2005-07-21 Manjula GHM <mmanjula@novell.com>
+	*assign.cs: Support conversions in "new" assignment statement
+
+2005-07-21 Satya Sudha K <ksathyasudha@novell.com>
+	* Support method invocation without '()'
+
+2005-07-21 Manjula GHM <mmanjula@novell.com>
+	*assign.cs: Support conversions in "new" assignment statement
+
+2005-07-21 Manjula GHM <mmanjula@novell.com>
+	* mb-parser.jay: Support type specifier for "ReDim" statements
+
+2005-07-18 Satya Sudha K <ksathyasudha@novell.com>
+	* Supported overloading of properties (has to be tested thoroughly)
+
+2005-07-13 Maverson Eduardo Schulze Rosa <maverson@gmail.com>
+	* mb-parser.jay:
+	* block.cs: Support and successfully find goto target labels
+	declared out of block that contains the goto statement.
+
+2005-07-13 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	*statement.cs: extract class Block into new source block.cs
+	*mbas.exe.sources: added newly extracted block.cs
+	*block.cs: eliminated "block.cs(252) warning CS0219: The variable 'cur' 
+	is assigned but its value is never used"
+
+2005-07-12 Manjula GHM <mmanjula@novell.com>
+	* parameter.cs , ecore.cs : Changed error number and message according to .NET
+
+2005-07-12 Manjula GHM <mmanjula@novell.com>
+	* cfold.cs: Support 'Nothing' for Constants.
+		 Added exception 	
+		
+2005-07-07 Manjula GHM <mmanjula@novell.com>
+	* mb-parser.jay: To avoid Array modifiers specified on both a variable and its type
+
+2005-07-06 Umadevi S <sumadevi@novell.com>
+	* statement.cs - suppressing warnings due to unused variables in mbas compiler.
+
+2005-07-05 Umadevi S <sumadevi@novell.com>
+	* expression.cs - added support to handle DBNull
+
+2005-06-30:5 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	*ecore.cs: some tentative code preparing to support automatic definition of variables
+	on first usage with Option Explicit Off commented out as it breaks on emit phase, and 
+	guesses wrong what should be automatically defined
+
+2005-06-30:4 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	*statement.cs: some tentative code preparing to support automatic definition of variables
+	on first usage with Option Explicit Off. Converting backticks to apostrophes on messages
+
+2005-06-30:3 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	*mb-parser.jay: small bits preparing to support automatic definition of variables
+	on first usage with Option Explicit Off
+	
+2005-06-30:2 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	*assign.cs: Killed exception occurring when resolving an assignment 
+	to an undefined symbol (Explicit On scenario)
+
+2005-06-30 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	*mb-parser.jay: Eliminating 'reduce/reduce conflicts' and 'rule never reduced'
+	by simplifying the directive_expression rule (formerly directive_exp).
+
+2005-06-30 Manjula GHM <mmanjula@novell.com>
+	*mb-parser.jay: To support signed exponent
+
+2005-06-30 Manjula GHM <mmanjula@novell.com>
+	*mb-tokenizer.c : Support hexadecimal literals - supports binary value 
+	of the integer literal - like &H8000S is "-32768" and not an overflow exception
+
+2005-06-28 Manjula GHM <mmanjula@novell.com>
+	*class.cs : Support suitable property to override
+
+2005-06-27 Manjula GHM <mmanjula@novell.com>
+	* mb-parser.jay:
+	*statement.cs: Support and successfully find label definition inside child block
+
+2005-06-23 Manjula GHM <mmanjula@novell.com>
+	*mb-parser.jay: Clear the hashtable in end of block
+
+2005-06-23 Manjula GHM <mmanjula@novell.com>
+	*mb-parser.jay: To disallow reassignment of object inside 'With...End With' block
+
+2005-06-13 Manjula GHM <mmanjula@novell.com>
+	*statement.cs: To handle Goto in Try, Catch block
+
+2005-06-10 Manjula GHM <mmanjula@novell.com>
+	*assign: To Support other types of source in Mid statement
+
+2005-06-10 Manjula GHM <mmanjula@novell.com>
+	*assign: To Support Optional Max. Insert length value in Mid statement
+
+2005-06-10 Manjula GHM <mmanjula@novell.com>
+	*assign.cs: Allow New Date assignment to other types
+
+2005-06-08 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* AssemblyInfo.cs : 
+		- Added informational attributes that Mono.GetOptions shows in the help screen.
+		- Bumped up the version number a bit 
+	
+2005-06-07 Satya Sudha K <ksathyasudha@novell.com>
+	* class.cs : Disallowing default properties without parameters.
+	* Some cleanups in other files to get rid of warnings.
+
+2005-06-03 Satya Sudha K <ksathyasudha@novell.com>
+	* expression.cs : Allowing '()' for property invocation with no args.
+	* typemanager.cs : 
+		- Caching a property's arguments (as 'NoTypes') while registering a property
+		- If a name resolves to a field as well as a property, treat it as a field
+		- If a name resolves to a field as well as a event, giving preference to event
+	* parameters.cs : Case-insensitive search/comparison of parameter/arg names
+
+2005-05-30 Satya Sudha K <ksathyasudha@novell.com>
+	* statement.cs : 'For Each' statement : Wrapping the body of the For loop inside an exception block 
+			 if the enumerator implements 'IDisposable' interface
+
+2005-05-27 Satya Sudha K <ksathyasudha@novell.com>
+	* statement.cs :
+	* mb-parser.jay :
+		- Supporting all kinds of case clauses (like 'A To B', 'Is >= 30')
+ 		- Expressions of all primitive types can now be specified as 'Select' 
+		  and 'Case' expressions
+
+2005-05-27 Manjula GHM <mmanjula@novell.com>
+	* mb-parser.jay : To support "Sub New()" without modifier	
+
+2005-05-26 Manjula GHM <mmanjula@novell.com>
+	* typemanager.cs : Fix Enum conversion for two level assignment and added few more cases
+
+2005-05-26 Manjula GHM <mmanjula@novell.com>
+	* statement.cs : Fix problem w.r.t 'Exit Sub' 
+
+2005-05-24 Satya Sudha K <ksathyasudha@novell.com>
+	* statement.cs : Added few more members like 'memberName' and 'type_expr' to the 'StatementSequence'
+			 class. Added an appropriate constructor for the same.
+	* expression.cs: Late binding for method invocations involving object arguments
+			 
+
+2005-05-23 Satya Sudha K <ksathyasudha@novell.com>
+	* statement.cs : Copying back the arguments (matching 'ByRef' parameters) in the reverse 
+			 order (starting with the last argument backwards) as done by vbc
+
+2005-05-23 Satya Sudha K <ksathyasudha@novell.com>
+	* statement.cs : Support named arguments in late binding
+
+2005-05-17 Satya Sudha K <ksathyasudha@novell.com>
+	* ecore.cs : Removed char <-> numeric/date conversions as they are not supported in vbc
+
+2005-05-17 Satya Sudha K <ksathyasudha@novell.com>
+	* expressions.cs :
+		- Disallowing named arguments for 'ParamArray' parameters
+		- Creating named arguments (to replace missing arguments), in case other arguments are also named
+
+2005-05-16 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : correcting/refactoring EntryPoint fixing as per #74955
+		adjusting references changed by Gonzalo to their new containing namespace.
+		small renaming refactorings to make things clearer.
+	* CompilerOptions.cs : refactored out all things that now live in 
+		Mono.GetOptions.Useful.CommonCompilerOptions
+
+2005-05-16 Gonzalo Paniagua Javier <gonzalo@ximian.com>
+
+	* driver.cs: fix ambiguous reference.
+
+2005-05-16 Manjula GHM <mmanjula@novell.com>
+	* literal.cs: Declare NullType
+	* typemanager.cs: Invoke proper Decimal constructor
+      	* ecore.cs : Support Decimal type in literalized version
+        * const.cs : 
+        * constant.cs :
+      	* expression.cs :
+		Support Decimal constant declaration  and retrieval of Decimal structure 
+		members from corelib
+
+2005-05-16 Satya Sudha K <ksathyasudha@novell.com>
+	* parameter.cs : Converting the default value (for optional param) to param type.
+	* ecore.cs     : Fixed string <-> char constant conversions.
+	* expression.cs :
+	* argument.cs   :
+	* mb-parser.jay :
+			Support for named arguments
+		
+2005-05-12:2 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : mcs having C# 2.0 features makes me slip some simplified delegate creation 
+		code, that breaks with csc in Windows (as pointed by Atsushi)
+	* CompilerOptions.cs : moved some delegate definitions outside the class for shorter name when using.
+
+2005-05-12 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : slimmed down, most non-specific code moved to new class/source CompilerOptions.
+		Also steps where individualized and put on a array of delegates for sequencial execution
+		with stop-on-first-blunder behavior. It is similar to the configurable pipeline of the
+		boo compiler.
+	* CompilerOptions.cs: added, refactored from inside driver.cs (some code/properties will migrate
+		further to Mono.GetOptions.Usefull.CommonCompilerOptions)
+	* mbas.exe.sources: added CompilerOptions.cs
+
+2005-05-11 Ankit Jain  <ankit@corewars.org>
+
+	* expression.cs (Invocation.CheckParameterAgainstArgument): Return ConversionType.Widening
+	for a NoArg argument. Fix earlier patch.
+
+2005-05-11 Ankit Jain  <ankit@corewars.org>
+
+	* expression.cs (Invocation.CheckParameterAgainstArgument): Return ConversionType.Narrowing
+	for a NoArg argument.
+	(Invocation.IsApplicable): Don't create a REF type argument if it is NoArg.
+	(Invocation.ConstructArgumentList): Create argument with its DefaultValue for a NoArg.
+
+2005-05-10 Satya Sudha K <ksathyasudha@novell.com>
+	* statement.cs, expression.cs, assign.cs :
+		Patch to allow latebinding expressions to be specified as ByRef arguments 
+		
+2005-05-10  Raja R Harinath  <rharinath@novell.com>
+
+	* driver.cs (InitializeRootContextAndOthersFromOptions):
+	Overwrite RootContext.RootNamespace only if there's a value.
+
+2005-05-09 Satya Sudha K <ksathyasudha@novell.com>
+	* parameter.cs : Support 'Optional ByRef' parameters
+	* statement.cs : Using 'System.Reflection.Missing.Value' in case of missing argument for 
+			 LateBinding cases
+		
+2005-05-07 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : Oops, correcting some find-and-replace mishaps
+
+2005-05-06 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+        * driver.cs : Refactored to use Mono.GetOptions.Useful.CommonCompilerOptions
+
+2005-05-05 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+        * mb-parser.jay : Correction to allow optional type caracters in some situations.
+        Now 6 more tests under mbas/Test/tests/types compile and 3 more compile and run.
+        Patch contributed by Brazilian MonoBASIC Team:
+                Aldo Monteiro do Nascimento <aldomonteiro@gmail.com>
+                Alessandro de Oliveira Binhara <binhara@psl-pr.softwarelivre.org>
+                Alexandre Rocha Lima e Marcondes <alexandre.marcondes@psl-pr.softwarelivre.org>
+                Ramiro Batista da Luz <ramiroluz@gmail.com>
+                Renato Suga <renatos@techresult.com.br>
+
+2005-05-05 Satya Sudha K <ksathyasudha@novell.com>
+	* statement.cs
+	* mb-parser.jay:
+		Changed the 'For' class to :
+		- Handle negative step values
+		- Supporting all types (numeric/object) of loop control variables
+
+	* expression.cs : Removed some unused methods
+	* ecore.cs      : Added float/double -> decimal conversion to NarrowingConversion
+
+2005-05-02 Manjula GHM <mmanjula@novell.com>
+	* expression.cs : Support Reference Parameter - when argument and parameter are different.
+
+2005-04-29 Satya Sudha K <ksathyasudha@novell.com>
+	* argument.cs
+	* statement.cs
+	* expression.cs
+	* assign.cs
+	* mb-parser.jay:
+		Support for 'LateSet', 'LateIndexGet', 'LateIndexSet'
+
+	* ecore.cs :
+		Minor fixes in conversions
+
+2005-04-26 Manjula GHM <mmanjula@novell.com>
+      	*statement.cs
+		"out" is not supported as Parameter Modifier in VB.NET
+
+2005-04-26 Manjula GHM <mmanjula@novell.com>
+	*support.cs
+      	*parameter.cs
+      	*argument.cs
+      	*expression.cs
+      	*statement.cs
+		"out" is not supported as Parameter Modifier in VB.NET
+2005-04-21 Satya Sudha K <ksathyasudha@novell.com>
+	* ecore.cs :
+		Fixed object to bool/float/double conversions
+		Fixed numeric <--> Enum conversions 
+	* statement.cs :
+	* expression.cs :
+	* mb-parser.jay :
+		(Initial) Support for 'LateGet'
+
+2005-04-18 Manjula GHM <mmanjula@novell.com>
+	* mb-parser.jay:
+		Support expressions for Directives
+2005-04-19 Satya Sudha K <ksathyasudha@novell.com>
+	* ecore.cs :
+		Fixed conversions from 'object' to double, float, decimal and long
+
+2005-04-18 Manjula GHM <mmanjula@novell.com>
+	* mb-parser.jay:
+		Support Conditional Constant Directives
+
+2005-04-13 Manjula GHM <mmanjula@novell.com>
+	* expression.cs : To support  'Or' argument of AttributeTargets in AttributeUsage
+2005-04-12 Satya Sudha K <ksathyasudha@novell.com>
+	* statement.cs :
+		Introduced a class 'StatementSequence', to translate a late-binding call to a block of statements
+	* expression.cs :
+		Support for late binding (Not complete yet. Some basic method invocations work as of now)
+	
+2005-04-06 Ritvik Mayank <mritvik@novell.com>
+  	   by Sudharsan V <vsudharsan@novell.com>
+	* class.cs: correction for reflecting the correct Line No. in the Error message	
+2005-04-05 Ritvik Mayank <mritvik@novell.com>
+  	   Patch Submitted by Sudharsan V <vsudharsan@novell.com>
+	* mb-parser.jay : correction for reflecting the correct Line No. in the Error message	
+
+2005-03-31 Manjula GHM <mmanjula@novell.com>
+	*mb-tokenizer.cs:To fix make test failure
+2005-03-31 Manjula GHM <mmanjula@novell.com>
+	*mb-tokenizer.cs: Support declaration of decimal numbers with no digits before point like '.52' instead of '0.52'
+
+2005-03-29 Manjula GHM <mmanjula@novell.com>
+	*assign.cs: Disallow New Date assignment with types other than date and object type
+
+2005-03-25:3 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* AssemblyInfo.cs: Small increment in the version number to publicize --codepage support
+
+2005-03-25:2 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* genericparser.cs: another static Parse overload to support specifying encoding when parsing from a file.
+	* driver.cs: obsoletes --tokenize, record currentEncoding for each source-file to be processed, call the new Parse overload
+		Implement support for a --codepage option similar to mcs. Example: 
+			mono mbas.exe --codepage:1252 WindowsANSI.vb --codepage:utf8 UTF8.vb --codepage:reset currentcharset.vb
+
+2005-03-25:1 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* genericparser.cs: another Parse overload to support specifying encoding when parsing from a file.
+	Preparing to implement support for a /codepage option similar to mcs
+
+2005-03-24 Manjula GHM <mmanjula@novell.com>
+	* mb-tokenizer.cs: To fix parser error for ExternalSource Directives
+
+2005-03-24 Satya Sudha K <ksathyasudha@novell.com>
+	* mb-parser.jay : 
+			- Support for Dictionary Member Access Expressions
+			- Exponentiation operator in compound assignments
+	* expression.cs : Merged 'Exponentiation' class with 'Binary' class
+	* cfold.cs	: Fixed constant division (both '\' and '/')
+
+2005-03-24 Manjula GHM <mmanjula@novell.com>
+          * mb-parser.jay,mb-tokenizer.cs: Support 'End Statement' in parser and tokenizer file
+
+2005-03-24 Manjula GHM <mmanjula@novell.com>
+           Sudharsan V <vsudharsan@novell.com>
+          * mb-parser.jay,mb-tokenizer.cs:
+		Revamped end of block logic 
+
+2005-03-24 Manjula GHM <mmanjula@novell.com>
+        * statement.cs: Fix bug in 'Exit Function'
+
+2005-03-23 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* AssemblyInfo.cs: Some more diligent authors
+	* ecore.cs, cfold.cs, delegate.cs: remove warnings-causing code 
+
+2005-03-22 Satya Sudha K <ksathyasudha@novell.com>
+	* mb-parser.jay
+	* expression.cs :
+			Fix for 'MyClass' instance expressions 
+
+2005-03-22 Satya Sudha K <ksathyasudha@novell.com>
+	   Sudharsan V <vsudharsan@novell.com>
+	* mb-parser.jay : 
+			Removed some conflicts in the grammar
+
+2005-03-21 Manjula GHM <mmanjula@novell.com>
+	* statement.cs: Implementation of 'End' Statement which terminates execution immediately
+
+2005-03-18 Satya Sudha K <ksathyasudha@novell.com>
+	* mb-parser.jay :
+	* mb-tokenizer.cs :
+	* expression.cs :
+		Supported 'Like' operator
+
+2005-03-18 Manjula GHM <mmanjula@novell.com>
+           Sudharsan V <vsudharsan@novell.com>
+          * mb-parser.jay:
+              Some more fixes related to displaying correct line number
+
+2005-03-17 Manjula GHM <mmanjula@novell.com>
+	*ecore.cs : rounding the double values before converting to Integer types
+
+2005-03-17 Manjula GHM <mmanjula@novell.com>
+	*ecore.cs : Support Double in case statement and do necessary conversion to Int Literal
+
+2005-03-16 Manjula GHM <mmanjula@novell.com>
+	* mb-parser.jay:
+		Support 'expression TO expression' case clause for select statement
+
+2005-03-15 Satya Sudha K <ksathyasudha@novell.com>
+	* mb-parser.jay :
+	* expression.cs :
+		Supported '\' (int division) operator
+
+2005-03-11 Manjula GHM <mmanjula@novell.com>
+           Sudharsan V <vsudharsan@novell.com>
+          * mb-parser.jay:
+              Fixes related to displaying correct line number,error message and handle End of blocks
+
+2005-03-11 Satya Sudha K <ksathyasudha@novell.com>
+	* expression.cs :
+			 Support for 'Nothing' with all operators.
+			 A few fixes to the 'DoNumericPromotions' method
+	* ecore.cs      :
+			 Fixed Boolean constant conversions
+			 Supported conversion of 'nothing' to value types
+
+2005-03-10 Manjula GHM <mmanjula@novell.com>
+	*expression.cs :
+		Support 'Is' for all reference types
+
+2005-03-10 Satya Sudha K <sathyasudha@novell.com>
+	* mb-parser.jay :
+	* expression.cs :
+			Support for 'AndAlso' and 'OrElse' operator
+
+2005-03-09 Manjula GHM <mmanjula@novell.com>
+	*mb-parser.jay :
+	*expression.cs :
+		Support 'Is' Expression
+
+2005-03-08 Satya Sudha K <ksathyasudha@novell.com>
+	* ecore.cs      : Included Decimal -> Single/double conversions in 'WideningConversionExists' method
+	* expression.cs : Fixed the behaviour of some Unary operators
+			  Allowing Exponentiation on object types
+
+2005-03-08 Manjula GHM <mmanjula@novell.com>
+	*assign.cs : Bug fix - new Object creation and object assignment
+
+2005-03-07 Satya Sudha K <ksathyasudha@novell.com>
+	* mb-parser.jay : Support for shift operators
+	* assign.cs     : Calling 'RuntimeHelpers.GetObjectValue' during new Object creation 
+			   (to make it consistent with vbc)
+	* ecore.cs      : Implicit constant conversions - rounding the float/double values before 
+			  converting to Integer types
+	* expression.cs : 
+			 Unary class :
+				* Corrected the opertor names
+				* Allowing unary plus and minus on strings (by converting 
+				  to double)
+				* Allowing 'Not' operator on all numeric/string types 
+				  (float/double/decimal/strings are converted to long)
+				* In case of short/byte operations, changing the end result back to short/byte
+			Exponentiation class :
+				* Disallowing '^' operator on dates/char/ reference types
+			Binary class :
+				* Corrected operator names
+				* And-ing the right operand with appropriate mask in case of shift operators
+				* In case of short/byte operations, changing the end result back to short/byte
+				* Re-organised the code of the 'ResolveOperator' method:
+					* code organised according to expression types
+					* Performing the required conversions before 'OverloadResolve'
+					* Did the following fixes :
+						* Fixed string/bool behaviour with logical/shift operators
+						* Disallow arithmatic operators on char and dates
+						* Fixed DateTime comparisons
+						* Using methods of 'System.Decimal' for all Decimal operations
+						* Supporting all operators with enum types
+						* Allowing arithmatic/relational/shift/logical operators on type 'object'
+
+2005-03-04 Manjula GHM <mmanjula@novell.com>
+	* mb-parser.jay:
+	* assign.cs:
+		Support Mid Assignment Statement
+
+2004-12-01 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs: correcting the handling of many options. 
+	* Upgraded to latest Mono.GetOptions that supports vbc style boolean arguments /debug+ /debug-, and /help2 to hide less used options
+
+2005-02-25 Satya Sudha K <ksathyasudha@novell.com>
+	* ecore.cs 
+	* expression.cs: 
+		Fix for default properties by Raja Harinath
+
+2005-02-22 Manjula GHM <mmanjula@novell.com>
+	*expression.cs: Handle String and date before Overloadresolve
+			Added code for char + char
+			Handle One of operands is value type in Relational operators 
+			Handle when both are Object types
+
+2005-02-22 Manjula GHM <mmanjula@novell.com>
+	*expression.cs: Handle Bool w.r.t Logical operators 
+
+2005-02-21 Manjula GHM <mmanjula@novell.com>
+	*expression.cs: Handle  all cases of relational Operators w.r.t String types 
+
+2005-02-21 Manjula GHM <mmanjula@novell.com>
+	*mb-parser.jay: Throws error for missing END statements - by Sudharsan V
+
+2005-02-18 Satya Sudha K <ksathyasudha@novell.com>
+	* ecore.cs :
+		 Modified Implicit Constant conversions to :
+		 * Handle Long/Float/Double Constants also
+		 * Throw a compile time error if constant cannot be converted to a specified type
+		   (as with vbc)
+	* assign.cs :
+	* expression.cs :
+		Widening Enum constants to constants of underlying type before doing the conversions
+	* cfold.cs :
+		Added support for exponentiation operator for constants
+	* enum.cs : Allowing double values to be specified as enum values
+
+
+2005-02-17 Manjula GHM <mmanjula@novell.com>
+	* expression.cs :
+		 Support relational operator for other types
+
+2005-02-15 Manjula GHM <mmanjula@novell.com>
+	* ecore.cs :
+		 Fixed conversion from char[] to String
+
+2005-02-15 Manjula GHM <mmanjula@novell.com>
+	* expression.cs: Fixed concat of string and char using '+" operator 
+
+2005-02-14 Manjula GHM <mmanjula@novell.com>
+	* ecore.cs :
+		 Fixed all String to char conversions
+
+2005-02-14 Satya Sudha K <ksathyasudha@novell.com>
+	* expression.cs: 
+		 - Fixed one of my previous checkin, which was breaking some test cases.
+	* ecore.cs :
+		 - Fixed the explicit conversion of float/double to integral types in some places.
+
+2005-02-11 Ritvik Mayank <mritvik@novell.com>
+	* class.cs
+	* decl.cs
+	* mb-parser.jay
+	* statement.cs
+		Changed for reflecting correct Error Number
+						
+2005-02-10 Satya Sudha K <ksathyasudha@novell.com>
+	* expression.cs: 
+		 - Implemented Exponentiation operator (^)
+		 - Fixed the behaviour of strings in arithmatic operations (only addition 
+		   was supported before)
+		 - Fixed Decimal arithmatic with float/double types
+		 - If operation = Division, promoting both operands to double, otherwise
+		   doing numeric promotions
+	* mb-parser.jay : Changes related to the Exponentiation operator
+
+2005-02-10 Manjula GHM <mmanjula@novell.com>
+	* expression.cs: Fixed concat of date and string using '+" operator 
+
+2005-02-08  Satya Sudha K  <ksathyasudha@novell.com>
+	* assign.cs: Fix for implicit conversions in Compound Assignments
+	* ecore.cs :
+		- Fixed the explicit conversion of float/double to integral types
+		  by rounding the float/double values before performing the actual 
+		  conversion
+		- Using 'ConvCast' instead of 'OpcodeCast' for Narrowing conversions
+
+2005-02-07  Ritvik Mayank <mritvik@novell.com>
+	* modifiers.cs
+	* class.cs
+	* decl.cs
+	* expression.cs
+	* tree.cs
+	* statement.cs
+	            Changed for reflecting correct Error Number.
+
+2005-02-07  Manjula GHM  <mmanjula@novell.com>
+	* mb-parser.jay: Some more fixes related to displaying correct line number
+
+2005-02-04  Satya Sudha K  <ksathyasudha@novell.com>
+	* ecore.cs 	: Fixed the implicit conversion of float/double to integral types:
+				- Rounding the float/double values before performing the actual conversion
+
+	* expression.cs : 1) Added a class 'StringConcat' to handle string concatenations
+			  2) Fixed string conversions in arithmatic operations
+
+	* mb-parser.jay : Create a new 'StringConcat' object (instead of Binary) for concat_expression
+ 
+2005-02-03  Manjula GHM  <mmanjula@novell.com>
+	*mb-parser.jay : Reports error with correct line number in most of the cases covered by existing testcases. Need to cover in expressions and few more areas. 
+ 
+2005-02-03  Manjula GHM  <mmanjula@novell.com>
+	* mbas.csproj
+        * mbas.sln
+	Modified Project and solution files to reflect new changes
+
+2005-01-29  Ritvik Mayank  <mritvik@novell.com>
+	* ecore.cs : 
+	* class.cs : 
+	* cfold.cs : 
+	* attribute.cs : 
+	* statement.cs : 
+	* mb-parser.jay : 
+		Changed for reflecting correct Error Number/Message.
+	
+2005/01/29 Satya Sudha K <ksathyasudha@novell.com>
+	* ecore.cs : Added code for String conversions.
+
+2005/01/28 Satya Sudha K <ksathyasudha@novell.com>
+	* ecore.cs : Added a few fixes for Boolean to Numeric Conversions
+
+2005/01/25 Satya Sudha K <ksathyasudha@novell.com>
+	* ecore.cs : Added support for Implicit numeric conversions.
+		Most of the work on this patch done by Jambunathan K
+
+2005/01/17 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : correct handling of /imports command-line option.
+		Patch from Hans Kratz <kratz@omnicore.com>
+
+2005-01-13  Ritvik Mayank  <mritvik@novell.com>
+	* mb-parser.jay: Changed Error Number for Modifiers.PRIVATE to throw the right ExceptionNumber as 31089 . 	
+	* mb-parser.jay: Added Modifiers.PROTECTED to throw the right Error Number as 31047 . 
+  		  
+2005-01-13  Ritvik Mayank  <mritvik@novell.com>	
+	* ecore.cs: Changed the Error Number for setter as 30526 and getter as 30524 in Expression DoResolveLValue .
+	* expression.cs: Changed the Error Number for set == null as 30526 and get == null as 30524 .
+
+2005-01-13  Ritvik Mayank  <mritvik@novell.com>
+	* statement.cs: For 'if (RedimTarget.Type.GetArrayRank() != args.Count)' changed the Error Number as 3415 .
+
+2005-01-12 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Replaced "logical_end_of_line" with "end_of_stmt" in couple of places
+			 to support delemeter ':' along with "EOL" as end of statement
+
+2005-01-12 Anirban Bhattacharjee <banirban@novell.com>
+	* statement.cs: Another trivial correction 
+
+2005-01-11 Anirban Bhattacharjee <banirban@novell.com>
+	* statement.cs: A trivial correction in yesterday's check-in
+
+2005-01-10 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay:
+	* class.cs:
+	* statement.cs:
+	* rootcontext.cs:
+	* mb-tokenizer.cs:
+	* decl.cs:
+	* expression.cs:
+	* attribute.cs:
+	* enum.cs:
+	* codegen.cs:
+		Removed warnings from all the above files which were showing up during make
+
+
+2005-01-10 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Check for the overloaded property  
+
+2005-01-10 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: A better check provided before adding a property to TypeContainer
+
+2004-12-21 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs:
+	* Attribute.cs
+	* mb-parser.jay
+	* pending.cs:
+	* typemanager.cs:
+		IndexerName variable is now known as DefaultPropName in the above files
+
+2004-12-21 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: A check which restrict declaring more than one property
+			as default within same class
+
+2004-12-21 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: -Mbas will emit DefaultMemberConstuctor attribute for the class
+		    which is having Default Property so that it can be recognized by
+		    other assemblies
+		    - Removed Indexer class and some of the legacy code inherited from mcs
+	* typemanager.cs: Initialized DefaultMemberAttribute constructor info	
+
+2004-12-01 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	Ooops small bits on:
+	* driver.cs: -q --quiet works, inclusive for the "Alpha" message
+	* Test/misc/Makefile : Added dependency on newly compiled compiler for the test executable
+
+2004-12-01 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs: it was "monostyled" and some extract method refactorings to make things clear
+	now -q --quiet works, inclusive for the "Alpha" message
+	* Test/misc/Makefile : Added dependency on newly compiled compiler for the test executable
+
+2004-11-30 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* Test/misc/Makefile : Compile new RedimPreserve.vb test source
+	* Added Test/misc/RedimPreserve.vb
+    
+2004-11-30  Alexandre Rocha Lima e Marcondes <alexandremarcondes@psl-pr.softwarelivre.org>
+	* Makefile: Included Microsoft.VisualBasic.dll assembly on LOCAL_MCS_FLAGS.
+	* expression.cs: Created class Preserve to implement REDIM PRESERVE syntax.
+	* statement.cs: Implemented REDIM PRESERVE syntax on Redim.Resolve().
+
+2004-11-25  Raja R Harinath  <rharinath@novell.com>
+	* Makefile (SUBDIRS): Just list Test.
+	(mb-parser.cs): Depend on jay/skeleton.cs.
+
+2004-11-25  Raja R Harinath  <rharinath@novell.com>
+
+	Update to changes in jay/skeleton.cs.
+	* genericparser.cs (yacc_verbose_flag): Change to 'int'.
+	* mb-parser.jay (parse): Update to changes.
+	* driver.cs (verbose): Likewise.
+
+2004-11-24  Jambunathan K  <kjambunathan@novell.com>
+	* class.cs: Factored out classes - 1) GetMethod and SetMethod from
+	Property and 2) AddDelegateMethod and RemoveDelegateMethod from
+	Event respectively.
+	
+	* mb-parser.jay: Related changes.
+
+2004-11-22  Jambunathan K  <kjambunathan@novell.com>
+	* enum.cs: Factored out a new class EnumMember from the existing
+	class Enum. Much of the functionality that existed in
+	Enum.LookupEnumValue() is now moved in to
+	EnumMember.DoDefineMember().
+
+	One significant departure from the previous Enum implmenentation
+	is that now the resolution of an EnumMember's value happens in the
+	EmitContext set up for the Enum.
+	
+	* attribute.cs: 
+	* expression.cs: Trivial changes related to the above change.
+
+2004-11-22  Jambunathan K  <kjambunathan@novell.com>
+	* Makefile: Added new make target 'consolidate-test-results'.
+
+2004-11-22  Jambunathan K  <kjambunathan@novell.com>
+	* Makefile: Run "make run-test" or "make run-test-ondotnet" to
+	exercise mbas test cases.
+
+	* testmbas: Moved the test files under this directory to Test/misc
+	where it rightfully belongs.
+
+2004-11-17  Jambunathan K  <kjambunathan@novell.com>
+	* attribute.cs: Temporarily made Attribute.UnManagedType public.
+	
+	* class.cs: Removed the instance method
+	MethodCore.LabelParameters() and moved it's functionality to the
+	new instance methods Parameters.LabelParameters() and
+	Parameter.DefineParameter().
+	
+	* parameter.cs: Introduced new instance methods
+	Parameters.LabelParameters() and Parameter.DefineParameter() and
+	slightly improved Parameter.ApplyAttributeBuilder().
+	
+2004-11-17  Jambunathan K  <kjambunathan@novell.com>
+	* mb-parser.jay: During multi-file compilation, global attributes
+	were not getting parsed properly. Fixed the same.
+	
+2004/10/22 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-parser.jay : correcting global attributes handling, because it was 
+	   issuing wrong warnings for trivial files like testmbas/WriteOK.vb.
+	* Makefile : adding testmbas/AssemblyInfo.vb to some test compilations 
+
+2004-11-10  Jambunathan K  <kjambunathan@novell.com>
+	* attribute.cs: 1) Replaced the static method
+	Attribute.GetValidPlaces() with an equivalent instance method
+	Attribute.GetValidTargets() 2) Added new methods Attributes.Emit
+	() and Attribute.Emit(). 3) Migrated functionality of
+	ApplyAttributes to ApplyAttributeBuilder of respective classes.
+
+	* class.cs, decl.cs, codegen.cs, const.cs, parameter.cs :
+	Implemented ApplyAttributeBuilder() in the following classes:
+	TypeContainer, Constructor, Field, Property, Event, DeclSpace,
+	AssemblyClass, ModuleClass, Const, Method, Parameter.
+	
+	* codegen.cs: Implemented Emit() in the following classes:
+	AssemblyClass and ModuleClass.
+
+	The ApplyAttributeBuilder() is currently just a placeholder for
+	future code that is yet to come.
+
+2004-11-09  Jambunathan K  <kjambunathan@novell.com>
+	* class.cs: Coalesced the functionality of Property and
+	PropertyBase in to Property class and removed the class
+	PropertyBase.
+
+
+2004-11-09  Jambunathan K  <kjambunathan@novell.com>
+
+	* attribute.cs: Injected a new virtual property
+	Attributable.AttributeTargets
+
+	* decl.cs: Made MemeberCore a derived class of
+	Attributable.
+
+	* parameter.cs: Made Parameter a derived class of
+	Attributable.
+	
+	* class.cs: Commented out the "never used" class Indexer. I
+	suspect that the class will never be required in VB.NET context
+	and can possibly be stripped off after careful inspection.
+
+	* tree.cs, module.cs, interface.cs, enum.cs, delegate.cs,
+	const.cs, codegen.cs: Changes necessiated by the above changes.
+
+2004-11-07  Jambunathan K  <kjambunathan@novell.com>
+	* typemanager.cs: Removed TypeManager.builder_to_attr which was
+	redundant and replaced LookupAttr with LookupClass.
+
+	* rootcontext.cs: 
+	* module.cs: Miscellaneous changes
+
+	* mb-parser.jay: Upadted actions of the attributes grammar
+
+	* codegen.cs: 1) Introduced new classes CommonAssemblyModulClass,
+	AssemblyClass, ModuleClass 2) Introduced following methods
+	CodeGen.AddGlobalAttributes, CodeGen.EmitGlobalAttributes
+
+	* class.cs: Factored out TypeContainer.AttributeUsage
+
+	* attribute.cs: 1) Factored out Attribute.UsageAttribute and
+	Attribute.GetAttributeUsage 2) Introducing the new base class
+	Attributable from which all Attributable types will be derived in
+	the future 3) Added new accessors Attribute.IsAssemblyAttribute
+	and Attribute.IsModuleAttribute
+
+2004-11-06  Jambunathan K  <kjambunathan@novell.com>
+	* rootcontext.cs: Removed the static field -
+	RootContext:global_attribute.
+
+2004-11-06  Jambunathan K  <kjambunathan@novell.com>
+	* class.cs: 
+	* attribute.cs: Removed the incomplete and (for now) unnecessary
+	Mono.MonoBASIC.Operator class. Let us bother about this later.
+
+	Stripping off these unused bits will help me in 1) refactoring the
+	mbas Attributes related code 2) reusing the code from the mcs code
+	base.
+	
+2004-11-06  Jambunathan K  <kjambunathan@novell.com>
+	* class.cs: Removed the incomplete and (for now) unnecessary
+	operator methods. Let us bother about this later.
+
+2004-11-06  Jambunathan K  <kjambunathan@novell.com>
+	* attribute.cs: Removed the redundant AttributeSection class and
+	moved it's functionality to Attributes class. 
+	* class.cs: 
+	* mb-parser.jay: 
+	* module.cs: Replaced references to AttributeSection with the equivalent constructs.
+	* rootcontext.cs: Removed the following unused methods
+	AddGlobalAttribute and AddGlobalAttributeSection.
+
+2004-11-03 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Trivial fix for bug #68985
+
+2004-11-04  Jambunathan K  <kjambunathan@novell.com>
+	* mb-parser.jay: Syntactic error handling for attribute grammar.
+
+2004-10-25 Anirban Bhattacharjee <banirban@novell.com>
+	* statement.cs: VB .Net specific exception number
+
+2004-10-25 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Enhanced catch grammar to accept
+			'When' clause
+	* statement.cs: Changed Catch and Try classes accordingly
+			to emit catch statement conditionally		
+
+2004/10/22 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : accept also -t:library as vbc does, besides /target:library
+
+2004-10-21 Anirban Bhattacharjee <banirban@novell.com>
+	* statement.cs: Introduced few specific execptions
+			Changed exception number
+
+2004-10-21 Anirban Bhattacharjee <banirban@novell.com>
+	* statement.cs: A trivial fix to get Exit Try working 
+
+2004-10-21  Jambunathan K  <kjambunathan@novell.com>
+	* typemanager.cs (LookupType, LookupTypeDirect): Added a negative
+	cache for failed type lookups (stolen from mcs' typemanager.cs).
+	mbas gets a performance boost of about 20 times due to this
+	change.
+
+	* driver.cs (MainDriver): Made the warning message a little less
+	scary and more inviting for first time users.
+
+2004-10-19 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Enhanced For Each...Next statement grammar
+
+2004-10-15 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Little improvement in For...next statement
+
+2004-10-14 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: For statement is enabled to take
+		optional declaration of the counter variable.
+		E.g. now for statement can be declared as
+		For i as integer = 0 to 5
+		End For
+
+2004/10/08 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* Makefile: added target 'profile', changed some sources in testmbas/ to use for that purpose.
+
+2004-10-11 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: More improvement in 'IF' statement
+
+2004-10-11 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: If statement is enabled to parse
+		following type of statement
+		If <condition> Then <statement> else <statement>
+
+2004/10/08 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* typemanager.cs: Changing StandardModule to use less memory, by doing string 
+		concatenation only once. It was wasting 1 MB on the test case.
+
+2004-10-06 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Added support for Call keyword in invocation statement
+
+2004-10-01 Anirban Bhattacharjee <banirban@novell.com>
+	* ecore.cs: Bug fixing - when event raised from other assembly
+
+2004-09-30 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay:
+	* statement.cs:
+		Removed unused event_target field from
+		AddHandler and RemoveHandler
+
+2004-09-30 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: RemoveHandler function made cleaner
+
+2004-09-30 Anirban Bhattacharjee <banirban@novell.com>
+	* expression.cs:
+	* ecore.cs:
+		Fix for resolution of event expression 
+		when we have a AddHandler statement 
+		like 
+		AddHandler Me.E, AddressOf Me.EH
+		Submitted by Raja Harinath<rharinath@novell.com>
+
+2004-09-30 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Unnecessary to and fro conversion of types
+			is removed from AddHandler function
+
+2004-09-23 Anirban Bhattacharjee <banirban@novell.com>
+	* expression.cs: Enhanced mbas to resolve Default property or indexer
+
+2004-09-21 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Fixed bug #66231 -
+	 Now, Me.SubName, MyBase.SubName or any other qualified name 
+	 is supported by AddressOf operator
+
+2004-09-15 Anirban Bhattacharjee <banirban@novell.com>
+	* enum.cs: Made Enum member lookup case insensitive
+
+2004-09-15 Anirban Bhattacharjee <banirban@novell.com>
+	* support.cs: Retrieving default value from another assembly in ReflectionParameters class
+
+2004-09-15 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Support for enum in default constant value for optional parameters
+
+2004-09-14 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Fixed exception number for type confliction in method parameter
+
+2004-09-14 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Set default constant value for optional parameters in ParameterBuilder
+	* parameter.cs: Setting optional attribute
+		These two fixes makes sure that optional parameter with default value get emitted correctly
+
+2004-08-27 Anirban Bhattacharjee <banirban@novell.com>
+2004-09-08 Bernie Solomon <bernard@ugsolutions.com>
+	* mb-parser.jay: fix CopyTo args when parsing parameters
+
+2004-09-08 Bernie Solomon <bernard@ugsolutions.com>
+	* expression.cs: cope with ParamArray for no args
+	* mb-parser.jay: dump parsing exception with --stacktrace
+
+2004/08/19 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-parser.jay : some changes just not to stumble in global attributes definitions in multiple-lines 
+		like we have in VS.NET generated AssemblyInfo.vb files. still need to really process that definitions like mcs does
+
+2004-09-07 Bernie Solomon <bernard@ugsolutions.com>
+	* mb-parser.jay:
+	* mb-tokenizer.cs: first cut at implementing
+	op assign
+
+2004-09-07 Bernie Solomon <bernard@ugsolutions.com>
+	* ecore.cs:
+	* enum.cs:
+	* expression.cs:
+	* mb-parser.jay:
+	* support.cs: work on improving overload resolution
+
+2004-08-30 Bernie Solomon <bernard@ugsolutions.com>
+	* class.cs (FindMembers): filter on modflags
+	for constructors & constructors are never inherited
+
+	* decl.cs (SetupCache): constructors are not
+	inherited
+
+2004-08-27 Anirban Bhattacharjee <banirban@novell.com>
+	* driver.cs: bug fixing - #63580
+
+2004/08/19 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* testmbas/WriteOk.vb : Use Mono.GetOptions from VB.NET
+	* Makefile : exercise new option processing in test program [make-run-local target]
+
+2004-08-26 Bernie Solomon <bernard@ugsolutions.com>
+	* mb-parser.jay: rework parsing of ParamArray parameters
+
+2004-08-23 Bernie Solomon <bernard@ugsolutions.com>
+	* mb-parser.jay: cope with more varieties of array declarations
+
+2004-08-20 Anirban Bhattacharjee <banirban@novell.com>
+	* statement.cs: Bug fixing - Prevent AddHandler from getting resolved second time. This is critical for ASP programs with VB.
+
+2004-08-20 Anirban Bhattacharjee <banirban@novell.com>
+	* expression.cs: Bug fixing - reference to the current type is fixed during BaseAccess resolution
+
+2004/08/19  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : Some cleanup, also renamed checked option as it was removeintchecks in disguise
+
+2004-08-18 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: MyBase support in Handles clause e.g. 
+				Sub EH() Handles MyBase.E
+
+2004-08-13 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Trivial fix (#63213)
+
+2004-08-13 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs:
+	* typemanager.cs:
+		-Bug fixed to resolve the ReadOnly properties from base class
+		-Fixed bug in resolving properties from different assembly
+
+2004-08-14 Bernie Solomon <bernard@ugsolutions.com>
+	* mb-parser.jay: fix block used as body of For Each
+
+2004-08-13 Anirban Bhattacharjee <banirban@novell.com>
+	* expression.cs: Bug fixing for compiling VB script generated by ASP page - AddressOf operator in a method argument will resolve methods outside assembly
+
+2004-08-13 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: bug fixing to get PropertyE.vb test running - search of overridable property in base class was failing
+
+2004-08-13 Anirban Bhattacharjee <banirban@novell.com>
+	* typemanager.cs: Little correction in my last checked-in code - removed unnecessary return value from ExpandAllInterfaces function
+
+2004-08-13 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Trivial bug fixing to get test InterfaceB.vb going
+
+2004-08-13 Rob Tillie <Rob.Tillie@student.tul.edu>
+	* ecore.cs: added runtime conversion from string to DateTime (fixes test 13329).
+	
+2004-08-13 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs:
+	* typemanager.cs:
+	* pending.cs:
+		Multiple interface inheritance implemented - fix for getting InheritanceD.vb working in bteasts		
+
+2004-08-12 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Implements support in Abstract methods
+
+2004-08-12 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Support for abstract method resolution
+	* pending.cs: Type of pending_implementations is set to base type
+		      Changed method names IsInterfaceIndexer and IsInterfaceMethod to IsAbstractIndexer and IsAbstractMethod respectively to make them more meaningful
+
+2004-08-11 Bernie Solomon <bernard@ugsolutions.com>
+	* mb-parser.jay: first cut at TypeOf ... Is
+
+2004-08-11 Bernie Solomon <bernard@ugsolutions.com>
+	* expression.cs:
+	* ecore.cs: More enum changes to handle
+	implicit conversions better
+
+2004-08-11 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Interface inheritance made better
+
+2004-08-09  Jambunathan K  <kjambunathan@novell.com>
+	* mb-parser.jay: Sanitized parser's generic error message 
+
+2004-08-07 Anirban Bhattacharjee <banirban@novell.com>
+	* enum.cs: Enum members became enum type now, instead of underlying type
+
+2004-08-07 Bernie Solomon <bernard@ugsolutions.com>
+	* mb-parser.jay: Implement GetType(x) 
+	implement Is as equals for the moment so it can be used
+
+2004-08-07 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Check for empty enum declaration
+
+2004-08-07 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: 
+	* mb-parser.jay:
+		Multiple Implements for a particular type member got implemented
+
+2004-08-06  Bernie Solomon  <bernard@ugsolutions.com>
+
+	* support.cs: Make ReflectionParameter behave
+	like InternalParameter for byref args.
+	* expression.cs: Cope with byref args in
+	an imported DLL
+
+2004-08-06  Jambunathan K  <kjambunathan@novell.com>
+	* mb-parser.jay: Changed expression grammar so that it now has a
+	  better semblance to those defined in section 11 of VB.NET spec.
+	  The 'expression' rule as it is now could possibly be buggy. So
+	  another iteration is a must.
+
+2004-08-06 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Small bug fix in Event grammar
+
+2004-08-06 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Event still needed to have a constructor which takes value of Implements clause.
+	* mb-parser.jay: Passing Implements clause value to the constructor
+
+2004-08-06 Anirban Bhattacharjee <banirban@novell.com>
+	* decl.cs:
+	* rootcontext.cs:
+		Exception number made aligned to VB .net
+
+2004-08-06 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Improvements in the implementation of Implements clause in Type members
+
+2004-08-05 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser,jay: Implements clause added to Event grammar
+
+2004-08-05 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Interface event declaration grammar rewritten
+
+2004-08-04 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Introduced check for valid interface name in Implements clause. 
+
+2004-08-04  Jambunathan K  <kjambunathan@novell.com>
+	* mb-tokenizer.cs: 
+	* mb-parser.jay: 
+
+	1) Fixed the Attributes grammar starting with
+	   opt_attributes. Introduced new rules starting with
+	   opt_global_attributes rule - section 5.2 of VB.NET spec
+
+	2) Introduced new Tokens that correspond to reserved but unused
+	   VB.NET keywords. Added some comments as appropriate in the
+	   keywords hashtable of tokenizer - section 2.3 of VB.NET spec.
+
+	3) Corrected 'imports_term' - section 6.3.1 & 6.3.2 of VB.NET
+	   spec.
+
+	4) Introduced opt_argument_list - section 5.2 of VB.NET spec
+
+	5) Corrected namespace_declaration - section 6.4.1 of VB.NET spec
+	
+
+2004-08-04 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Added support for modifiers and attributes in interface member grammar
+
+2004-08-04 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Property types made optional
+
+2004-08-03 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Interface method and property grammar got changed
+			 Support for multiple implements in class 
+	* interface.cs: Interface class has got changed
+			All other interface types have been removed
+	* class.cs: Property's Define and CheckBase method changed significantly to be in sync with Interface
+	* pending.cs: few related changes 
+	* attribute.cs: few related changes
+
+2004/08/01  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-parser.jay : Some correction as pointed by Jambunathan, 
+		to allow preprocessor directives after a label that may 
+		leave it orphaned (without a explicit statement)
+	* testmbas/WriteOK.vb : some vb code to test this case
+
+2004/08/01  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-parser.jay : Some correction as pointed by Jambunathan, 
+		to allow intermixing preprocessor directives between 
+		the label and it's associated statement
+
+2004-08-02  Jambunathan K  <kjambunathan@novell.com>
+	* mb-tokenizer.cs: Oops. Also pulled out all of the old
+	pre-processor code that is no more used.
+
+2004-08-02  Jambunathan K  <kjambunathan@novell.com>
+	* mb-tokenizer.cs: Fixed a bug where line nos were 
+	failing to get incremented when the line continuation 
+	character was appearing by itself on contiguous lines.
+	
+	* mb-parser.jay: Fixed the #ExternalSource actions
+	so that ExternalSourceDirectivesC4.vb compiles and 
+	reports source & line nos as expected.
+
+	* location.cs: Replaced the existing unintuitive, not
+	so efficient implementation of struct Location {} with 
+	the one available in mcs with one minor difference: The
+	number of bits reserved for a file index in the Token
+	is statically fixed at 8 bits.
+
+2004/08/01  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-parser.jay : Revised patch from João Viegas for the labeled_statement accepting integer literals as labels
+
+2004-07-30  Jambunathan K  <kjambunathan@novell.com>
+	* mb-parser.jay: Oops. Reversed unintended checkin.
+	* mb-tokenizer.cs: Added comment in Tokenizer() 
+	* mb-parser.jay: Fixed miscellaneous bugs in handling of 
+	pre-processor directives. There are two positive test 
+	cases that fail currently: ExternalSourceDirectivesC4.vb
+	and RegionDirectivesC1.vb
+
+2004-07-30  Raja R Harinath  <rharinath@novell.com>
+
+	* mb-parser.jay (IfElseStateMachine.State, IfElseStateMachine.Token): 
+	Remove [Flags] attribute.
+
+2004-07-30  Jambunathan K  <kjambunathan@novell.com>
+	* mb-parser.jay: 
+	* mb-tokenizer.cs: Added support for #region, #externalsource
+	and conditional compilation pre-processor directives.
+	Conditonal directives currently accept only boolean literals
+	as conditonal expressions. 
+	
+	* mb-parser.jay: The original checkin hits a bug in mcs but
+	compiles fine with csc. This checkin is to workaround the mcs
+	bug so that cvs builds are not broken.
+	
+	
+2004/07/26  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-parser.jay : First try at SyncLock Statement #53230
+
+2004-07-22 Anirban Bhattacharjee <banirban@novell.com>
+	* argument.cs:
+	* expression.cs:
+		Little betterment in resolution of parameter with Addressof operator in method argument
+
+2004-07-20 Anirban Bhattacharjee <banirban@novell.com>
+	* expression.cs: Resolution of fully qualified type names - bug fixed
+
+2004-07-20 Anirban Bhattacharjee <banirban@novell.com>
+	* assign.cs: Added new argument to Expression.ConvertExplicit function call
+
+2004-07-20 Anirban Bhattacharjee <banirban@novell.com>
+	* expression.cs: Fixed resolution of overloaded functions with delegate as parameter
+	* ecore.cs: Changes made to stop program getting into an endless loop on not able to cast types of source to destination object.
+	* statement.cs: Added new argument to Expression.ConvertExplicit function call
+
+2004-07-18 Anirban Bhattacharjee <banirban@novell.com>
+	* argument.cs: Introduced AddressOf argument type for tracking AddressOf operator in method parameter
+	* expression.cs: A parameter with AddressOf operator will get converted to Delegate before overload resolution
+	* mb-parser.jay: Omitted two delegate creation expression grammar. This is now taken care by normal object creation expressions since Argument is capable of handling AddressOf operator now
+		This is a fix for bug #59555
+
+2004/07/15  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : Implemented support for -pkg to match mcs (bug #58673)
+
+2004/07/15  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : started implementing -pkg support to match mcs (bug #58673), also corrected multiplicity for addmodule option
+
+2004-07-13 Anirban Bhattacharjee <banirban@novell.com>
+	* driver.cs: Added support for AddModule compiler option
+	* typemanager.cs: AddModule function will now store list of Modules instaed of ModuleBuilders. This change has been made to get LoadModule function working of driver.cs.
+
+2004-07-13 Anirban Bhattacharjee <banirban@novell.com>
+	* driver.cs: Compilation to module is supported now
+
+2004-07-09 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay:
+	* class.cs:
+		Default modifier for constructor is set to Public
+
+2004-07-09 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Parentheses in method declarations made optional incase of empty parameter list. Thus, a method "Sub s()" can also be declared as "Sub s"
+
+2004-07-07 Anirban Bhattacharjee <banirban@novell.com>
+	* expression.cs: bug fixed - 60399
+
+2004-06-13 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Small correction in delegate declaration grammar
+
+2004-06-13 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: modified RemoveHandler function
+	* statement.cs: Added RemoveHandler statement class
+
+2004-06-13 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Modified grammar for several syntax of AddressOf operator
+
+2004/06/10  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* typemanager.cs : GetPertinentStandardModules receives the array now with params modifier to help usage
+	* ecore.cs : correcting lookup of semi-qualified standard modules members - A little better but not there yet
+
+2004-06-10 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Grammar added for RemoveHandler statement
+
+2004-06-10 Anirban Bhattacharjee <banirban@novell.com>
+        * mb-parser.jay:
+        * expression.cs:
+                Added support for statement like
+                        delgate_name = AddressOf sub_name
+
+2004-06-09  Raja R Harinath  <rharinath@novell.com>
+
+	* Makefile (HAS_TEST): Remove.
+	(run-test-local): Move rule to and depend on ...
+	(run-mbas-test): ... this.
+
+2004-06-08 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay:
+	* statement.cs:
+		Few exception checks for Event
+
+2004-06-07 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Resolved the problem in Sub statement with Handles cluse
+	* class.cs: Added a AddEventHandler function and a EventHandler readonly property. Also modified define of constructor to accommodate Handlers clause.		
+	            If one initialize a event handler as
+			Sub Handler() Handles x.Event
+		    The handler will be initialized by the constructor of the corresponding class by calling AddHandler.
+
+2004-06-04 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Modified WithEvents grammar	
+
+2004-06-04 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: - NotOverridable modifier support added to Property
+		    - Few overriding related checks put on Property
+ 
+2004-06-04 Anirban Bhattacharjee <banirban@novell.com>
+	* decl.cs: Check for duplicate member name within same container
+
+2004-06-04 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: changed exception number in event grammar
+
+2004-06-03 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: RaiseEvent grammar fixed to get it working
+
+2004-06-03 Anirban Bhattacharjee <banirban@novell.com>
+	* driver.cs: fixed bug - 59540
+
+2004-06-01 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Improved event declaration grammar
+
+2004/05/31  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* AssemblyInfo.cs : Anirban is and author too
+
+2004-05-27 Anirban Bhattacharjee <banirban@novell.com>
+	* delegate.cs:
+	* expression.cs:
+		Few exception checks for delegete
+
+2004-05-27 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay:
+	* delegate.cs:
+		Few more fixes in delegate grammar		
+
+2004-05-27 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Changed Delegate instantiation grammar to get it working
+
+2004-05-26 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay:
+	* class.cs:
+		Few property related checks applied
+
+2004-05-24 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Check for ReadOnly and WriteOnly modifiers added to property
+
+2004-05-24 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-paresr.jay: Support for abstruct property is added
+
+2004-05-24  Raja R Harinath  <rharinath@novell.com>
+
+	* Makefile (PROGRAM_INSTALL_DIR): Install mbas into
+	$(prefix)/lib/mono/1.0.
+
+2004-05-10 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: few Property related grammar changes
+
+2004-05-14 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-tokenizer.cs: Bug fixed - Got Property working
+
+2004-05-10 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Support added for attaching Attributes in methods
+
+2004/04/07  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* AssemblyInfo.cs : Correcting information and version number
+
+2004-04-29 Anirban Bhattacharjee <banirban@novell.com>
+	* enum.cs: bug fixing - setting one enum member to another
+
+2004-04-29 Anirban Bhattacharjee <banirban@novell.com>
+	* enum.cs:
+	* expression.cs:
+		Implemented check for access modifier in enum
+
+2004-04-29  Lluis Sanchez Gual  <lluis@ximian.com>
+
+	* typemanager.cs: Property.GetGetMethod() does not return the method if it
+	is private (it did until now because of a bug). Make sure it works as it 
+	worked before the fix.
+
+2004-04-28 Anirban Bhattacharjee <banirban@novell.com>
+	* expression.cs: fixed bug to get enum running
+	* enum.cs: handling several negative scenarios 
+		   Changed several exception numbers
+	* assign.cs: Changed exception number
+
+2004-04-26  Jackson Harper  <jackson@ximian.com>
+
+	* Makefile: Get libs from default profile directory.
+	
+2004-04-23 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Grammar changes for array
+	* expression.cs: exception number changed for "Incorrectly structured array initializer" exception
+
+2004-04-17 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay:
+	* class.cs:
+	* const.cs
+		a little better structure grammar
+
+2004-04-16 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: few clean-ups
+
+2004-04-16 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Duplicate entry point exception number changed
+		    Checked delaration of Types, fields, methods as Protected if they are member of Module type
+	* const.cs: Checked delaration of constructor as Protected if it is member of Module type
+	* driver.cs: exception number is changed for "Entry point does not exist" exception
+
+2004-04-15 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Classes can't be delared static impicitly as other module members
+
+2004-04-15 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Couple of bug fixes in defining default static constructor, partially imposed by the fix earlier
+
+2004-04-14 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Added support for Shadows modifier in Variables
+
+2004-04-14 Anirban Bhattacharjee <banirban@novell.com>
+	* const.cs: Added support for Shadows modifier in constant
+
+2004-04-14 Anirban Bhattacharjee <banirban@novell.com>
+	* expression.cs: Removed the check which was stoping type instances to access the shared variables
+
+2004-04-14 Anirban Bhattacharjee <banirban@novell.com>
+	* modifiers.cs: changed exception number for invalid modifiers exception
+
+2004-04-13 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Removed 'static_constructor_declaration' - this is not required as 'constructor_declaration' implementation is good enough to handle static constructors too
+	* class.cs: Handling couple of negative scenarios related to static constructors and bug fixes
+
+2004-04-13 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: Couple of negative scenario handling
+
+2004-04-13 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Few clean-up
+
+2004-04-12 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Bug fixed - Base class ctor was getting called twice when called explicitly from the derived class ctor as MyBase.New
+
+2004-04-12 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Fixed bugs for calling ctor from another ctor in the same class by using statments like
+		Me.New 
+		or 
+		MyClass.New
+
+2004/04/07  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-tokenizer.cs : Better error message when dealing with date literals
+
+2004-04-06 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs:
+	* ecore.cs:
+	* expression.cs:
+	* modifiers.cs:
+	Changed/added serveral Accessibility related expections 
+
+2004-04-05 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs:
+	* decl.cs:
+	* expression.cs:
+	* pending.cs: 
+	Several error messages and numbers are changed in all the above four classes
+
+2004-04-04 AnirbanBhattacharjee <banirban@novell.com>
+	* delegate.cs: changed default access modifier
+	* enum.cs: changed default access modifier
+	* interface.cs: changed default access modifier
+	* modifiers.cs: extension of bug fixed for getting NotOverridable modifier working for methods
+
+2004-04-04 AnirbanBhattacharjee <banirban@novell.com>
+	* class.cs: Changed exception messages and their numbers to align better with VB
+		    Changed default access modifier of method to Public
+		    Bug fixed to get NotOverridable modifier working
+	* decl.cs:  Changed exception messages and numbers
+
+2004-03-25 Anirban Bhattacharjee <banirban@novell.com>
+	* class.cs: bug fixing - creating default constructor when no constructor is specified
+	Few modifiers are changed to align with Vb
+
+2004/03/22  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* typemanager.cs :  being more carefull with null arguments in some places, 
+						null checking in GetPertinentStandardModules() loop
+	* namespace.cs : a helper ToString override 
+	* ecore.cs : Dealing with finding more than a pertinent standard module having a global member
+	* testmbas/WriteOk.vb : Exercising correct standard module resolution
+    NOTE: Almost there for Bug #52067 - just the semi-qualified case isn't working 
+
+2004-03-23 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: handled implicit static modifier for module members in const
+	* const.cs: changed supported modifiers
+
+2004-03-23 Anirban Bhattacharjee <banirban@novell.com>
+	* modifiers.cs: Return name of the modifiers' changed to vb specific
+
+2004/03/22  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* ecore.cs : now it gets the correct list of namespaces in scope (either imported or current) Almost there for Bug #52067 
+
+2004-03-22 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: One more negative scenario is addressed in const grammar
+
+2004-03-22 Anirban Bhattacharjee <banirban@novell.com>
+	* const.cs: Change type of constant to the type of its value if no explicit type declaration found
+
+2004-03-22 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Grammar for declaring constant inside block is changed
+
+2004-03-22 Anirban Bhattacharjee <banirban@novell.com>
+	* const.cs: Changed exception numbers
+
+2004-03-22 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: Changed grammar for constant
+
+2004/03/02  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-tokenizer.cs : handling better linebreak, specially when delaing with literals and preprocessing directives 
+
+2004-03-16 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-parser.jay: 
+		- changed variable declaration grammar and added support for multiple variables declartion under single type e.g. dim x, y as integer
+		- added few exception checks in variables
+		- added one exception check in property
+	
+2004/03/02  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* sourcebeingcompiled.cs : new source/class to hold things previously contained in namespaces.cs 
+			because in C# they were semantically tied to nested namespaces, and in VB.NET 
+			they can occur only once per file.
+	* mbas.exe.sources: added sourcebeingcompiled.cs
+	* mb-parser.jay: reference RootContext.Sourcebeingcompiled things
+	* namespace.cs: move pieces to sourcebeingcompiled
+	* rootcontext.cs: use SourceBeingCompiled class
+	* decl.cs: reference RootContext.Sourcebeingcompiled things
+
+2004-03-02 Anirban Bhattacharjee <banirban@novell.com>
+	* mb-tokenizer.cs: Support for '-' delimiter in DateTime
+
+2004-03-02 Anirban Bhattacharjee <banirban@novell.com>
+	* report.cs: Formatted warning thrown
+
+2004-03-02 Anirban Bhattacharjee <banirban@novell.com>
+
+	* class.cs
+	* decl.cs
+	* modifiers.cs
+	* mb-parser.jay
+	Added Overloads and Shadows modifiers to Function and Sub
+	Fixed few other modifier related problems in Function and Sub
+
+2004-01-07  Nick Drochak <ndrochak@ieee.org>
+
+	* genericparser.cs:
+	* mb-tokenizer.cs: 
+	* row.cs: Eliminate warnings about unused variables.
+
+2004/01/06  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* typemanager.cs : 	correcting translation of System types to language types, 
+			also temporarily circunventing a exception in ModuleBuilder.GetType inside LookupTypeReflection,
+			corrected many ` characters to ' in error messages
+	* testmbas/WriteOK.vb : testing newly implemented IsNumeric global function
+
+2004-01-04  David Sheldon <dave-mono@earth.li>
+
+  * expression.cs: Added matching ")" to error message for 
+  CS0077
+
+2003/12/23  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : added stubs for options "/netcf /sdkpath:path"
+	* namespace.cs, decl.cs, rootcontext.cs : use hashtable to avoid duplicate importation of namespaces 
+	  (especially between command-line option /imports and explicit Import clauses), what manifested itself as
+	  error messages for ambiguous names that where in truth identical
+	* statement.cs : trying to fix the 'exit' statement DoEmit, for "Exit Sub"
+	* mb-parser.jay, mb-tokenizer.cs : initial support for type_characters (dim az$ = dim az as string)
+
+2003/12/18  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* class.cs : case-sensitiveness when tracking the entry-point removed
+	* driver.cs : IsSWFApp would try to pass a null 'mainclass' to the hashtable indexer, throwing an exception
+		(even for correct programs because of the bug above). Now this condition is tested before
+
+2003/12/06  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* ecore.cs : problems trying to implicit convert OMITTED arguments, solved
+	* mb-tokenizer.cs, mb-parser.jay, typemanager.cs : support for the date primitive type and date literals
+	* testmbas/WriteOK.vb: testing date type and date literal
+
+2003/11/12  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs : /imports option now is implemented
+	* mb-parser.jay: support for pre-imported namespaces (the default Microsoft.VisualBasic and those from /imports)
+	
+2003/11/12  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-tokenizer.cs : integer literal (Hex starts with &H not 0x), handle Octal literals (&O)
+	* 	handle unicode specialized double-quotes in string literals	
+	* 	corrected some mishandling of conversions in numeric literals
+	*	implemented support for char literals ("z"c)
+	* Makefile : verbose target uses verbose argument
+	* testmbas/WriteOK.vb: many tests for literals implemented
+	* literal.cs: correcting lack of a ShortLiteral class
+	* mb-parser.jay: removed support for unsigned int literals, added support for short int literals
+	
+2003/11/10  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* *.cs, mb-parser.jay: Switched all from defining/using namespace Mono.CSharp to Mono.MonoBASIC 
+	* location.cs: SymbolDocument now returns a SymbolDocumentWriter using the right (SymLanguageType.Basic) GUID
+	
+2003/10/17  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* genericparser.cs: 
+	    Don't print exception when a file is not found to be parsed
+		File extensions not matched are now processed with the default parser
+		Better handle file/directory not found exceptions, and use Report.Error in that case
+	* added defaultparserattribute.cs
+	* mb-parser.jay : Mono.MonoBASIC.Parser is now the [DefaultParser]
+	* location.cs version 1.4 recovered (Marco Ridoni had it overwritten with an older version)
+	* mb-tokenizer.cs, rootcontext.cs, tree.cs: Location constructor needs column number now
+
+2003/09/17  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* .cvsignore: WHOOPS
+
+2003/09/17  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* .cvsignore: some more files to ignore
+
+2003/09/17  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-tokenizer.cs, driver.cs: Back to Linux line-endings, SORRY
+
+2003/09/16  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* Makefile: corrected testing in Windows/Cygwin (from mbas.exe to ./mbas.exe), because it was getting the installed compiler instead of the compiled one
+	* mb-tokenizer.cs: Redoing: Preprocessor directives must be case-insensitive (many .ToLower() used)
+	* driver.cs: No more 'linkpaths' option, use 'libpath' instead
+
+2003/09/15  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* driver.cs: Corrected handling of FileNotFoundException in LoadAssembly(), according to Bernie Solomon's patch
+
+2003/08/13  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-parser.jay: ReDim statement parses many variables now (but initializers aren't allowed)
+					 Erase statement implemented
+					 Lots of garbage (never reduced rules) deleted
+					 Reduce/Reduce problems eliminated (where due to having opt_modifiers duplicated inside property_declaration rule)
+	* statement.cs : class Redim is prepared to have ReDim Preserve copying code called,
+					 but we need to check if that code is lying in Microsoft.VisualBasic.dll
+					 New class Erase
+
+2003-07-26  Ben Maurer  <bmaurer@users.sourceforge.net>
+	
+	* statement.cs: Make Math.XXX System.Math.XXX, to fix the build.
+	
+2003-07-20  Peter Williams  <peter@newton.cx>
+
+	* Makefile: Remove the test target which conflicted with
+	the global target. (Change confirmed with Rafael.)
+
+2003-04-02  Duncan Mak  <duncan@ximian.com>
+
+	* mb-parser.jay: Temporarily remove the references to
+	Class.MustOverride to fix the build.
+
+2003/03/29  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-parser.jay: corrected some module related rules
+	* location.cs : now handles column information
+	
+2003/03/11  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* makefile.gnu : use $RUNTIME for all targets
+					 actually run the compiled program on 'test-gtk' target 
+	* mb-tokenizer.cs : no escaping of chars allowed in VB.NET (old mcs code removed)
+						handle doubled-doublequotes (VB idiom to escape a doublequote) 
+	
+2003/03/04  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-parser.jay: added rule for Imports with alias
+	* mb-parser.jay: Friend (internal) modifier was missing,
+					 Shared modifier was expecting Static token erroneously
+					 Modules must accept only a static constructor rule added
+					 Constant declaration rule added
+	* makefile & makefile.gnu : actually run the compiled program on test target 
+
+2003/03/03  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-tokenizer.cs : new semi-keywords: Compare, Explicit, Strict, On, Off, Binary, Text
+	* mb-parser.jay: tokens for above semi-keywords, and rules for option directives
+	* driver.cs: integrates command line options with parser flags for option directives
+	* makefile & makefile.gnu : added 'verbose' target that uses --verbose switch to compile 
+	  the test source and pipes it through 'less', also added a Extended Syntax source
+
+2003/02/22  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* class.cs : As, per vbc, there is a rootnamespace now, --main wasn't working anymore, 
+				 because it was expecting a fully qualified class name. 
+				 We now also test the name passed prepended by the rootnamespace.
+	* class.cs : Corrected warning "The keyword new is required on `Mono.CSharp.Property.Emit'
+				 because it hides inherited member `PropertyBase.Emit'", by making it virtual
+				 in PropertyBase and override in Property.
+	* makefile.gnu : test and test-gtk targets now depend on mbas.exe
+				 
+
+2003/02/19  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* mb-parser.jay : eliminated reduce/reduce conflict on duplicated rank_specifier rule
+	  by renaming the one using brackets to bracketed_rank_specifier
+
+2003/02/12  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* added argument.cs (extracted from expression.cs) makefiles corrected
+	* mb-parser.jay : eliminated reduce/reduce conflict on opt_argument_list rule, 
+	  by putting and if to make a argument list with just an empty argument list become an empty list
+
+2003/02/03  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* rootcontext.cs : added RootNamespace member
+	* mb-parser.jay : use RootContext.RootNamespace to initialize outermost namespace
+	* driver.cs : 
+		- implement rootnamespace parameter, and defaults it to the output file name
+		- like vbc if no source file name is provided just show help
+
+2003/01/22  Nick Drochak <ndrochak@gol.com>
+	* makefile: Use csc compiler in here. makefile.gnu assumes mono/mcs
+
+2003-01-13  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* added cleanup method to tokenizer as needed but modifications made in jay
+
+2003-01-12  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* changed test target in makefile work
+        * corrected authors list to include Marco
+
+2002-10-23  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged many sources from mcs/mcs, to resync
+
+2002-10-20  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* using Mono.GetOptions preliminar support for response files, 
+	  changed the makefile target 'test' for use o response file testmbas/filelist
+
+2002-10-20  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged many sources from mcs/mcs, to resync
+
+2002-10-05  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged many sources from mcs/mcs, to resync
+
+2002-08-31  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged many sources from mcs/mcs, to resync
+
+2002-09-03  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* integrated new version of Mono.GetOptions (reflection/attributes-based)
+
+2002-08-31  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged expression.cs from mcs/mcs, to resync
+
+2002-08-29  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged assign.cs, attribute.cs, class.cs, codegen.cs, const.cs, decl.cs, delegate.cs, ecore.cs, enum.cs,
+        expression.cs, interface.cs, pending.cs, report.cs, rootcontext.cs, statement.cs, support.cs and 
+        typemanager.cs from mcs/mcs, to resync
+
+2002-08-06  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* added "test" target to makefile
+	* merged assign.cs, attribute.cs, cfold.cs, class.cs, codegen.cs, const.cs, constant.cs, 
+	  decl.cs, delegate.cs, ecore.cs, enum.cs, expression.cs, interface.cs, modifiers.cs, parameter.cs, 
+	  pending.cs, report.cs, rootcontext.cs, statement.cs, support.cs and typemanager.cs from mcs/mcs, to resync
+
+2002-07-14  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged assign.cs, class.cs, ecore.cs, expression.cs, statement.cs and typemanager from mcs/mcs, to resync
+
+2002-07-09  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged attribute.cs, ecore.cs, namespace.cs and statement.cs from mcs/mcs, to resync
+
+2002-07-06  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged attribute.cs, class.cs, codegen.cs, ecore.cs, expression.cs, 
+	  modifiers.cs, namespace.cs, report.cs, rootcontext.cs, statement.cs and typemanager.cs from mcs/mcs, to resync
+	* changed driver.cs to follow mcs lead on error/warning counting and reporting
+
+2002-06-23  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged attribute.cs, class.cs, ecore.cs, rootcontext.cs, support.cs and typemanager.cs from mcs/mcs, to resync
+	* makefile makes csc reference a copy of Mono.GetOptions.dll (mbas.sln now compiles to mbas dir instead of mbas/bin/Debug)
+
+2002-06-21  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged attribute.cs, class.cs, interface.cs, expression.cs, ecore.cs, 
+	  modifiers.cs, rootcontext.cs, statement.cs and typemanager.cs from mcs/mcs, to resync
+	* added pending.cs from mcs/mcs, to resync
+
+2002-06-15  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged assign.cs, attribute.cs, enum.cs and namespace.cs from mcs/mcs, to resync
+	* namespace.cs needed some fixing, because CSharpParser isn?t available
+
+2002-06-15  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged delegate.cs, ecore.cs, typemanager.cs and rootcontext.cs from mcs/mcs, to resolve expression.cs blues
+
+2002-06-15  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* oops merged expression.cs from mcs/mcs is breaking my make
+	* driver.cs, assemblyinfo.cs wasn?t ready for prime time (offending lines were commented out)
+
+2002-06-15  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged expression.cs from mcs/mcs
+
+2002-06-12  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* corrected Module.TypeAttr property getter in module.cs
+	
+2002-06-12  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged typemanager.cs from mcs/mcs
+
+2002-06-10  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged expression.cs and interface.cs from mcs/mcs
+
+2002-06-09  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged const.cs, enum.cs, expression.cs and typemanager.cs from mcs/mcs
+    * comments on module.cs
+
+2002-06-07  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged class.cs, attribute.cs from mcs/mcs
+
+2002-06-07  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged class.cs, enum.cs, expression.cs, interface.cs, rootcontext.cs and typemanager.cs from mcs/mcs
+	* added module.cs (class Mono.MonoBASIC.Module - derived from Mono.CSharp.Class)
+	* added System.XML and Microsoft.VisualBasic to the default config (driver.cs)
+	
+2002-06-07  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged class.cs and ecore.cs from mcs/mcs
+
+2002-06-02  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* copied methods MakeName and CheckDef from mcs\cs-parser.jay to GenericParser.cs 
+	  where they are inherited by mb-parser.jay/cs
+	* put some code on the Module rule in mb-parser.jay to at least generate a class in the assembly,
+	  if I jump over the entry-point check code, while debugging
+	
+2002-05-31  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* class Mono.MonoBASIC.Tokenizer now handles 
+		- all valid line-terminators (CR, LF, CRLF, LS and PS)
+		- escaped identifiers (like [Integer])
+		- old-fashioned comments syntax (REM Blah-Blah)
+
+2002-05-31  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* modified mbas.ico to be a small version of mono?s logo (see mcs\MonoIcon.png)
+
+2002-05-31  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* squashed some reduce/reduce conflicts out of mb-parser.jay
+
+2002-05-31  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+	* merged codegen.cs from mcs
+	* altered Driver.cs to work with new codegen.cs
+
+2002-05-27  Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+
+	* merged all I could from mcs source files into mbas
+	* added VS.NET Solution and Project Files for mbas
+	* added icon file and a vb-sources-filled testmbas directory
+	* started this ChangeLog
diff --git a/dead/mbas/CompilerOptions.cs b/dead/mbas/CompilerOptions.cs
new file mode 100644
index 00000000..6f54ee73
--- /dev/null
+++ b/dead/mbas/CompilerOptions.cs
@@ -0,0 +1,119 @@
+//
+// CompilerOptions.cs: The compiler command line options processor.
+//
+// Author: Rafael Teixeira (rafaelteixeirabr@hotmail.com)
+// Based on mcs by : Miguel de Icaza (miguel@gnu.org)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2002, 2003, 2004 Rafael Teixeira
+//
+
+namespace Mono.MonoBASIC {
+
+	using System;
+	using System.Collections;
+	using System.Reflection;
+	using System.Reflection.Emit;
+	using System.Text;
+
+	using Mono.GetOptions;
+	using Mono.GetOptions.Useful;
+
+	public enum OptionCompare {
+		Binary, Text
+	};
+
+	/// <summary>
+	///    The compiler command line options processor.
+	/// </summary>
+	public class CompilerOptions : CommonCompilerOptions {
+	
+		public override string [] AssembliesToReferenceSoftly {
+			get {
+				//
+				// For now the "default config" is hardcoded into the compiler
+				// we can move this outside later
+				//
+				return new string [] {
+					"System",
+					"System.Data",
+					"System.Xml",
+					"Microsoft.VisualBasic" 
+#if EXTRA_DEFAULT_REFS
+					//
+					// Is it worth pre-loading all this stuff?
+					//
+					,
+					"Accessibility",
+					"System.Configuration.Install",
+					"System.Design",
+					"System.DirectoryServices",
+					"System.Drawing.Design",
+					"System.Drawing",
+					"System.EnterpriseServices",
+					"System.Management",
+					"System.Messaging",
+					"System.Runtime.Remoting",
+					"System.Runtime.Serialization.Formatters.Soap",
+					"System.Security",
+					"System.ServiceProcess",
+					"System.Web",
+					"System.Web.RegularExpressions",
+					"System.Web.Services" ,
+					"System.Windows.Forms"
+#endif
+				};
+			} 
+		}
+
+		public CompilerOptions(string [] args, ErrorReporter ReportError) : base(args, ReportError) {}
+		
+		protected override void InitializeOtherDefaults() 
+		{ 
+			DefineSymbol = "__MonoBASIC__";
+			ImportNamespaces = "Microsoft.VisualBasic";
+		}
+		
+		// TODO: remove next lines when the compler has matured enough
+		public override string AdditionalBannerInfo { get { return "--------\nTHIS IS AN ALPHA SOFTWARE.\n--------"; } }
+
+		// Temporary options
+		//------------------------------------------------------------------
+		[Option("[IGNORED] Only parses the source file (for debugging the tokenizer)", "parse", SecondLevelHelp = true)]
+		public bool OnlyParse = false;
+
+		[Option("[IGNORED] Only tokenizes source files", "tokenize", SecondLevelHelp = true)]
+		public bool Tokenize = false;
+
+		[Option("Shows stack trace at Error location", "stacktrace", SecondLevelHelp = true)]
+		public bool Stacktrace = false;
+		
+		[Option("Makes errors fatal", "fatal", SecondLevelHelp = true)]
+		public bool MakeErrorsFatal = false;
+		
+		// redefining some inherited options
+		//------------------------------------------------------------------
+		[Option("About the MonoBASIC compiler", "about")]
+		public override WhatToDoNext DoAbout() { return base.DoAbout(); }
+
+		[KillOption]
+		public override WhatToDoNext DoUsage() { return WhatToDoNext.GoAhead; }
+
+		// language options
+		//------------------------------------------------------------------
+
+		[Option("Require explicit declaration of variables", "optionexplicit", VBCStyleBoolean = true)]
+		public bool OptionExplicit = false;
+
+		[Option("Enforce strict language semantics", "optionstrict", VBCStyleBoolean = true)]
+		public bool OptionStrict = false;
+		
+		[Option("Specifies binary-style string comparisons. This is the default", "optioncompare:binary")]
+		public bool OptionCompareBinary = true; 
+
+		[Option("Specifies text-style string comparisons.", "optioncompare:text")]
+		public bool OptionCompareText { set { OptionCompareBinary = false; } }
+		
+	}
+}
diff --git a/dead/mbas/Makefile b/dead/mbas/Makefile
new file mode 100644
index 00000000..9ad774c4
--- /dev/null
+++ b/dead/mbas/Makefile
@@ -0,0 +1,23 @@
+thisdir = mbas
+SUBDIRS = Test
+include ../build/rules.make
+
+PROGRAM = mbas.exe
+BUILT_SOURCES = mb-parser.cs
+
+LOCAL_MCS_FLAGS = /r:System.dll /r:Mono.GetOptions.dll /r:Microsoft.VisualBasic.dll
+
+EXTRA_DISTFILES = mb-parser.jay mbas.csproj mbas.ico mbas.sln
+CLEAN_FILES = y.output 
+
+CONSOLIDATED_TEST_RESULTS_FILE = TestResults.log
+
+include ../build/executable.make
+
+mb-parser.cs: mb-parser.jay $(topdir)/jay/skeleton.cs
+	$(topdir)/jay/jay -ctv <$(topdir)/jay/skeleton.cs $< >$@
+
+consolidate-test-results:
+	@cp Test/tests/TestResults.log $(CONSOLIDATED_TEST_RESULTS_FILE)
+	@cat Test/errors/TestResults.log >> $(CONSOLIDATED_TEST_RESULTS_FILE)
+
diff --git a/dead/mbas/Makefile.mds b/dead/mbas/Makefile.mds
new file mode 100644
index 00000000..04575147
--- /dev/null
+++ b/dead/mbas/Makefile.mds
@@ -0,0 +1,16 @@
+<Combine name="mbas" fileversion="2.0">
+  <Configurations>
+    <Configuration name=".NET 1.1" ctype="CombineConfiguration">
+      <Entry build="True" name="mbas" />
+    </Configuration>
+    <Configuration name=".NET 2.0" ctype="CombineConfiguration">
+      <Entry build="True" name="mbas" />
+    </Configuration>
+  </Configurations>
+  <StartMode startupentry="mbas" single="True">
+    <Execute type="None" entry="mbas" />
+  </StartMode>
+  <Entries>
+    <Entry filename="./Makefile" />
+  </Entries>
+</Combine>
\ No newline at end of file
diff --git a/dead/mbas/argument.cs b/dead/mbas/argument.cs
new file mode 100644
index 00000000..9013630b
--- /dev/null
+++ b/dead/mbas/argument.cs
@@ -0,0 +1,182 @@
+//
+// argument.cs: Arguments representation for the IL tree.
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//
+// (C) 2001 Ximian, Inc.
+//
+//
+#define USE_OLD
+
+namespace Mono.MonoBASIC {
+	using System;
+	using System.Collections;
+	using System.Reflection;
+	using System.Reflection.Emit;
+	using System.Text;
+
+	
+	/// <summary>
+	///   Used for arguments to New(), Invocation()
+	/// </summary>
+	public class Argument {
+		public enum AType : byte {
+			Expression,
+			Ref,
+			NoArg,
+			AddressOf
+		};
+
+		public AType ArgType;
+		public Expression Expr;
+		public string ParamName;
+		
+		public Argument (Expression expr, AType type)
+			: this ("", expr, type)
+		{
+		}
+
+		public Argument (string paramName, Expression expr, AType type)
+		{
+			this.ParamName = paramName;
+			expr = Parser.SetValueRequiredFlag (expr);
+			if (type == AType.AddressOf)
+				expr = Parser.SetAddressOf (expr);
+			this.Expr = expr;
+			this.ArgType = type;
+		}
+
+		public Type Type {
+			get {
+				if (ArgType == AType.Ref )
+					return TypeManager.LookupType (Expr.Type.ToString () + "&");
+				else
+					return Expr.Type;
+			}
+		}
+
+		public Parameter.Modifier GetParameterModifier ()
+		{
+			switch (ArgType) {
+			case AType.Ref:
+				return Parameter.Modifier.REF | Parameter.Modifier.ISBYREF;
+
+			default:
+				return Parameter.Modifier.NONE;
+			}
+		}
+
+	        public static string FullDesc (Argument a)
+		{
+			return (a.ArgType == AType.Ref ? "ref " : "") +
+				TypeManager.MonoBASIC_Name (a.Expr.Type);
+		}
+
+		public bool ResolveMethodGroup (EmitContext ec, Location loc)
+		{
+			// FIXME: csc doesn't report any error if you try to use `ref' or
+			//        `out' in a delegate creation expression.
+			Expr = Expr.Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup);
+			if (Expr == null)
+				return false;
+
+			return true;
+		}
+
+		public bool Resolve (EmitContext ec, Location loc)
+		{
+			// Optional void arguments - MyCall (1,,2) - are resolved later
+			// in VerifyArgsCompat
+			if (ArgType == AType.NoArg || ArgType == AType.Ref) 
+			{
+				return true;				
+			}
+
+/*
+			if (ArgType == AType.Ref) {
+				Expr = Expr.Resolve (ec);
+				if (Expr == null)
+					return false;
+
+				Expr = Expr.ResolveLValue (ec, Expr);
+			} else */
+
+			if (ArgType == AType.AddressOf) {
+				Expression temp_expr = Expr;
+				
+				if (temp_expr is SimpleName) {
+					SimpleName sn = temp_expr as SimpleName;
+					temp_expr = sn.DoResolveAllowStatic(ec);
+				}
+				else if (temp_expr is MemberAccess)	{
+					MemberAccess ma = temp_expr as MemberAccess;
+					temp_expr = ma.DoResolve(ec);
+				}
+
+				if (temp_expr is MethodGroupExpr)
+					return true;
+
+				ArgType = AType.Expression;
+				Expr = Expr.Resolve (ec);
+			}
+			else
+				Expr = Expr.Resolve (ec);
+			
+			if (Expr == null)
+				return false;
+
+			if (ArgType == AType.Expression)
+				return true;
+
+			if (Expr.eclass != ExprClass.Variable){
+				//
+				// We just probe to match the CSC output
+				//
+				if (Expr.eclass == ExprClass.PropertyAccess ||
+				    Expr.eclass == ExprClass.IndexerAccess){
+					Report.Error (
+						206, loc,
+						"A property or indexer can not be passed as an out or ref " +
+						"parameter");
+				} else {
+					Report.Error (
+						1510, loc,
+						"An lvalue is required as an argument to out or ref");
+				}
+				return false;
+			}
+				
+			return true;
+		}
+
+		public void Emit (EmitContext ec)
+		{
+			//
+			// Ref  parameters need to have their addresses taken.
+			//
+			// ParameterReferences might already be references, so we want
+			// to pass just the value
+			//
+			if (ArgType == AType.Ref ){
+				AddressOp mode = AddressOp.Store;
+
+				if (ArgType == AType.Ref)
+					mode |= AddressOp.Load;
+				
+				if (Expr is ParameterReference){
+					ParameterReference pr = (ParameterReference) Expr;
+
+					if (pr.is_ref)
+						pr.EmitLoad (ec);
+					else {
+						
+						pr.AddressOf (ec, mode);
+					}
+				} else
+					((IMemoryLocation)Expr).AddressOf (ec, mode);
+			} else
+				Expr.Emit (ec);
+		}
+	}
+}
diff --git a/dead/mbas/assign.cs b/dead/mbas/assign.cs
new file mode 100644
index 00000000..c136bf7d
--- /dev/null
+++ b/dead/mbas/assign.cs
@@ -0,0 +1,621 @@
+
+// assign.cs: Assignments.
+//
+// Authors:
+//   Miguel de Icaza (miguel@ximian.com)
+//   Martin Baulig (martin@gnome.org)
+//   Manjula GHM (mmanjula@novell.com)
+//   Satya Sudha K (ksathyasudha@novell.com)
+//
+// (C) 2001, 2002 Ximian, Inc.
+//
+// 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;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///   This interface is implemented by expressions that can be assigned to.
+	/// </summary>
+	/// <remarks>
+	///   This interface is implemented by Expressions whose values can not
+	///   store the result on the top of the stack.
+	///
+	///   Expressions implementing this (Properties, Indexers and Arrays) would
+	///   perform an assignment of the Expression "source" into its final
+	///   location.
+	///
+	///   No values on the top of the stack are expected to be left by
+	///   invoking this method.
+	/// </remarks>
+	public interface IAssignMethod {
+		//
+		// This method will emit the code for the actual assignment
+		//
+		void EmitAssign (EmitContext ec, Expression source);
+
+		//
+		// This method is invoked before any code generation takes
+		// place, and it is a mechanism to inform that the expression
+		// will be invoked more than once, and that the method should
+		// use temporary values to avoid having side effects
+		//
+		// Example: a [ g () ] ++
+		//
+		void CacheTemporaries (EmitContext ec);
+	}
+
+	/// <summary>
+	///   An Expression to hold a temporary value.
+	/// </summary>
+	/// <remarks>
+	///   The LocalTemporary class is used to hold temporary values of a given
+	///   type to "simulate" the expression semantics on property and indexer
+	///   access whose return values are void.
+	///
+	///   The local temporary is used to alter the normal flow of code generation
+	///   basically it creates a local variable, and its emit instruction generates
+	///   code to access this value, return its address or save its value.
+	/// </remarks>
+	public class LocalTemporary : Expression, IMemoryLocation {
+		LocalBuilder builder;
+		
+		public LocalTemporary (EmitContext ec, Type t)
+		{
+			type = t;
+			eclass = ExprClass.Value;
+			loc = Location.Null;
+			builder = ec.GetTemporaryStorage (t);
+		}
+
+		public void Release (EmitContext ec)
+		{
+			ec.FreeTemporaryStorage (builder);
+			builder = null;
+		}
+		
+		public LocalTemporary (LocalBuilder b, Type t)
+		{
+			type = t;
+			eclass = ExprClass.Value;
+			loc = Location.Null;
+			builder = b;
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ec.ig.Emit (OpCodes.Ldloc, builder); 
+		}
+
+		public void Store (EmitContext ec)
+		{
+			ec.ig.Emit (OpCodes.Stloc, builder);
+		}
+
+		public void AddressOf (EmitContext ec, AddressOp mode)
+		{
+			ec.ig.Emit (OpCodes.Ldloca, builder);
+		}
+	}
+
+	/// <summary>
+	///   The Assign node takes care of assigning the value of source into
+	///   the expression represented by target. 
+	/// </summary>
+	public class Assign : ExpressionStatement {
+		protected Expression target, source, real_source;
+		protected LocalTemporary temp = null, real_temp = null;
+		protected Assign embedded = null;
+		protected bool is_embedded = false;
+		protected bool must_free_temp = false;
+
+		public Assign (Expression target, Expression source, Location l)
+		{
+			source = Parser.SetValueRequiredFlag (source);
+			target = Parser.SetLeftHandFlag (target);
+			if (target is MemberAccess)
+				((MemberAccess) target).IsLeftHand = true;
+			this.target = target;
+			this.source = this.real_source = source;
+			this.loc = l;
+		}
+
+		protected Assign (Assign embedded, Location l)
+			: this (embedded.target, embedded.source, l)
+		{
+			this.is_embedded = true;
+		}
+
+		public Expression Target {
+			get {
+				return target;
+			}
+
+			set {
+				target = value;
+			}
+		}
+
+		public Expression Source {
+			get {
+				return source;
+			}
+
+			set {
+				source = value;
+			}
+		}
+
+		public static void error70 (EventInfo ei, Location l)
+		{
+			Report.Error (70, l, "The event '" + ei.Name +
+				      "' can only appear on the left-side of a += or -= (except when" +
+				      " used from within the type '" + ei.DeclaringType + "')");
+		}
+
+		bool IsLateIndexSet(Expression target, EmitContext ec)
+		{
+			if (target is Invocation) 
+			{
+				Invocation i = (Invocation) target;
+				if (i.Expr is MethodGroupExpr) 
+				{
+					MethodGroupExpr mg = (MethodGroupExpr) i.Expr;
+					if (mg.Name == "LateIndexSet")
+						return true;
+				}
+			}
+			return false;
+		}
+
+		//
+		// Will return either `this' or an instance of `New'.
+		//
+		public override Expression DoResolve (EmitContext ec)
+		{
+			// Create an embedded assignment if our source is an assignment.
+			if (source is Assign)
+				source = embedded = new Assign ((Assign) source, loc);
+
+			real_source = source = source.Resolve (ec);
+			if (source == null)
+				return null;
+			
+			if (source is EnumConstant) 
+				source = ((EnumConstant)source).WidenToCompilerConstant();
+
+			//
+			// This is used in an embedded assignment.
+			// As an example, consider the statement "A = X = Y = Z".
+			//
+			if (is_embedded && !(source is Constant)) {
+				// If this is the innermost assignment (the "Y = Z" in our example),
+				// create a new temporary local, otherwise inherit that variable
+				// from our child (the "X = (Y = Z)" inherits the local from the
+				// "Y = Z" assignment).
+				if (embedded == null)
+					real_temp = temp = new LocalTemporary (ec, source.Type);
+				else
+					temp = embedded.temp;
+
+				// Set the source to the new temporary variable.
+				// This means that the following target.ResolveLValue () will tell
+				// the target to read it's source value from that variable.
+				source = temp;
+			}
+
+			// If we have an embedded assignment, use the embedded assignment's temporary
+			// local variable as source.
+			if (embedded != null)
+				source = (embedded.temp != null) ? embedded.temp : embedded.source;
+			//To support 'Mid' Assignment Statement
+			if (target is Invocation) {
+
+                        	Invocation i = (Invocation) target;
+                        	Expression mid_expr;
+				if (i.Expr is DecoratedIdentifier)
+					mid_expr = ((DecoratedIdentifier) i.Expr).Id;
+				else
+                        		mid_expr = i.Expr;
+					
+
+                        	if (mid_expr is SimpleName) {
+                                	SimpleName sn = mid_expr as SimpleName;
+                                	string s = sn.Name;
+                               
+				 	if (s == "Mid" || s == "Mid$") {
+					//It is Mid statement. Construct the function and 
+					//call corresponding Microsoft.VisualBasic.CompilerServices function 
+                        			Expression etmp;
+                        			ArrayList arglist = new ArrayList();
+	
+                        			Argument arg3,arg4;
+                        			Expression e = null;
+                        			eclass = ExprClass.Value;
+	
+                         			arglist  = i.Arguments;
+		
+						// If maximum Insert Length value is omitted	
+						if(arglist.Count == 2) {
+							string val = null;
+							val = source.ToString();
+							int maxInsertLength = val.Length;	
+		                        		arg3 = new Argument (new IntLiteral(maxInsertLength), Argument.AType.Expression);
+		                        		arglist.Add (arg3);
+						}
+
+                        			etmp = Mono.MonoBASIC.Parser.DecomposeQI("Microsoft.VisualBasic.CompilerServices.StringType.MidStmtStr", loc);
+						//Get fourth argument and add it to argument list
+	
+		                        	arg4 = new Argument (source, Argument.AType.Expression);
+		                        	arglist.Add (arg4);
+                        			e = (Expression) new Invocation (etmp, arglist, loc);
+                        			e = e.Resolve(ec);
+                        			return e;
+                			}
+				}
+			}
+
+			Expression tmpTarget = target.ResolveLValue (ec, source);
+			if (tmpTarget == null) {
+				// Case of LateBinding.
+				// Get the appropriate arguments, add the source as the last argument
+				Expression lateBindingExpr = null;
+				ArrayList arguments = null;
+				if (target is Invocation) {
+					lateBindingExpr = ((Invocation) target).Expr;
+					arguments = ((Invocation) target).Arguments;
+				}
+				if (target is MemberAccess) {
+					lateBindingExpr = target;
+				}
+				if (arguments == null)
+					arguments = new ArrayList ();
+
+				arguments.Add (new Argument (source, Argument.AType.Expression));
+
+				if (lateBindingExpr != null) {
+					Expression etmp = lateBindingExpr;
+					Type exprType = lateBindingExpr.Type;
+					// Get the target of the invocation/memberAccess
+					if (exprType == null) {
+						if (etmp is Invocation)
+							etmp = ((Invocation) etmp).Expr;
+						if (etmp is MemberAccess)
+							etmp = ((MemberAccess) etmp).Expr;
+						exprType = etmp.Type;
+					}
+
+					if (exprType == TypeManager.object_type) {
+						StatementSequence tmp = new StatementSequence (ec.CurrentBlock, loc, lateBindingExpr, 
+											arguments, false, true);
+						if (!tmp.ResolveArguments (ec))
+							return null;
+						tmp.GenerateLateBindingStatements ();
+						return tmp.Resolve (ec);
+					}
+				}
+				return null;
+			}
+
+			target = tmpTarget;
+
+			Type target_type = target.Type;
+			Type source_type = real_source.Type;
+			// If we're an embedded assignment, our parent will reuse our source as its
+			// source, it won't read from our target.
+			if (is_embedded)
+				type = source_type;
+			else
+				type = target_type;
+			eclass = ExprClass.Value;
+
+			//
+			// If we are doing a property assignment, then
+			// set the `value' field on the property, and Resolve
+			// it.
+			//
+			if (target is PropertyGroupExpr)
+				return target;
+
+			if (target is IndexerAccess) {
+				return this;
+			}
+
+			if (target is EventExpr) {
+				EventInfo ei = ((EventExpr) target).EventInfo;
+
+				Expression ml = MemberLookup (
+					ec, ec.ContainerType, ei.Name,
+					MemberTypes.Event, AllBindingFlags | BindingFlags.DeclaredOnly, loc);
+
+				if (ml == null) {
+				        //
+					// If this is the case, then the Event does not belong 
+					// to this Type and so, according to the spec
+					// is allowed to only appear on the left hand of
+					// the += and -= operators
+					//
+					// Note that target will not appear as an EventExpr
+					// in the case it is being referenced within the same type container;
+					// it will appear as a FieldExpr in that case.
+					//
+					
+					if (!(source is Binary)) {
+						error70 (ei, loc);
+						return null;
+					} else {
+						Binary tmp = ((Binary) source);
+						if (tmp.Oper != Binary.Operator.Addition &&
+						    tmp.Oper != Binary.Operator.Subtraction) {
+							error70 (ei, loc);
+							return null;
+						}
+					}
+				}
+			}
+			
+			if (source is New || target_type == TypeManager.object_type) {
+				if (source_type == TypeManager.object_type) {
+					Expression etmp = Mono.MonoBASIC.Parser.DecomposeQI (
+								"System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue",
+								 Location.Null);
+					ArrayList args = new ArrayList ();
+					args.Add (new Argument (source, Argument.AType.Expression));
+					Expression e = new Invocation (etmp, args, loc);
+					source = e.Resolve (ec);
+					return this;
+				}
+				if (target_type.IsValueType) {
+					if (source_type != target_type) {
+		 				source = ConvertImplicitRequired (ec, source, target_type, loc);
+                        			if (source == null)
+                                			return null;
+					}
+					New n = (New) source;
+					n.ValueTypeVariable = target;
+					return n;
+				}
+			}
+
+			if (target.eclass != ExprClass.Variable && target.eclass != ExprClass.EventAccess){
+				Report.Error (30074, loc,
+					      "Left hand of an assignment must be a variable, " +
+					      "a property or an indexer");
+				return null;
+			}
+
+			if ((source.eclass == ExprClass.Type) && (source is TypeExpr)) {
+				source.Error118 ("variable or value");
+				return null;
+			} else if (source is MethodGroupExpr){
+				((MethodGroupExpr) source).ReportUsageError ();
+				return null;
+			}
+
+			if (target_type == source_type)
+				return this;
+			
+			//
+			// If this assignemnt/operator was part of a compound binary
+			// operator, then we allow an explicit conversion, as detailed
+			// in the spec. 
+			//
+
+			if (this is CompoundAssign){
+				CompoundAssign a = (CompoundAssign) this;
+				
+				Binary b = source as Binary;
+				if (b != null && b.IsBuiltinOperator){
+					//
+					// 1. if the source is explicitly convertible to the
+					//    target_type
+					//
+					
+					source = ConvertExplicit (ec, source, target_type, false, loc);
+					if (source == null){
+						Error_CannotConvertImplicit (loc, source_type, target_type);
+						return null;
+					}
+				
+					//
+					// 2. and the original right side is implicitly convertible to
+					// the type of target_type.
+					//
+					source = ConvertImplicit(ec, source, target_type, loc);
+					if (source != null)
+						return this;
+
+					Error_CannotConvertImplicit (loc, a.original_source.Type, target_type);
+					return null;
+				}
+			}
+
+			if (IsLateIndexSet(target, ec)) 
+			{
+				// then we must rewrite the whole expression, since 
+				// THIS assign is no longer valid/needed
+				Invocation i = (Invocation) target;
+				return i;
+			}
+			source = ConvertImplicitRequired (ec, source, target_type, loc);
+			if (source == null)
+				return null;
+
+			// If we're an embedded assignment, we need to create a new temporary variable
+			// for the converted value.  Our parent will use this new variable as its source.
+			// The same applies when we have an embedded assignment - in this case, we need
+			// to convert our embedded assignment's temporary local variable to the correct
+			// type and store it in a new temporary local.
+			if (is_embedded || embedded != null) {
+				type = target_type;
+				temp = new LocalTemporary (ec, type);
+				must_free_temp = true;
+			}
+			
+			return this;
+		}
+
+		Expression EmitEmbedded (EmitContext ec)
+		{
+			// Emit an embedded assignment.
+			
+			if (real_temp != null) {
+				// If we're the innermost assignment, `real_source' is the right-hand
+				// expression which gets assigned to all the variables left of it.
+				// Emit this expression and store its result in real_temp.
+				real_source.Emit (ec);
+				real_temp.Store (ec);
+			}
+
+			if (embedded != null)
+				embedded.EmitEmbedded (ec);
+
+			// This happens when we've done a type conversion, in this case source will be
+			// the expression which does the type conversion from real_temp.
+			// So emit it and store the result in temp; this is the var which will be read
+			// by our parent.
+			if (temp != real_temp) {
+				source.Emit (ec);
+				temp.Store (ec);
+			}
+
+			Expression temp_source = (temp != null) ? temp : source;
+			((IAssignMethod) target).EmitAssign (ec, temp_source);
+			return temp_source;
+		}
+
+		void ReleaseEmbedded (EmitContext ec)
+		{
+			if (embedded != null)
+				embedded.ReleaseEmbedded (ec);
+
+			if (real_temp != null)
+				real_temp.Release (ec);
+
+			if (must_free_temp)
+				temp.Release (ec);
+		}
+
+		void Emit (EmitContext ec, bool is_statement)
+		{
+			if (target is EventExpr) {
+				((EventExpr) target).EmitAddOrRemove (ec, source);
+				return;
+			}
+
+			//
+			// FIXME! We need a way to "probe" if the process can
+			// just use `dup' to propagate the result
+			// 
+			IAssignMethod am = (IAssignMethod) target;
+
+			if (this is CompoundAssign){
+				am.CacheTemporaries (ec);
+			}
+
+			Expression temp_source;
+			if (embedded != null) {
+				temp_source = embedded.EmitEmbedded (ec);
+
+				if (temp != null) {
+					source.Emit (ec);
+					temp.Store (ec);
+					temp_source = temp;
+				}
+			} else
+				temp_source = source;
+
+			if (is_statement)
+				am.EmitAssign (ec, temp_source);
+			else {
+				LocalTemporary tempo;
+
+				tempo = new LocalTemporary (ec, source.Type);
+
+				temp_source.Emit (ec);
+				tempo.Store (ec);
+				am.EmitAssign (ec, tempo);
+				tempo.Emit (ec);
+				tempo.Release (ec);
+			}
+
+			if (embedded != null) {
+				if (temp != null)
+					temp.Release (ec);
+				embedded.ReleaseEmbedded (ec);
+			}
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			Emit (ec, false);
+		}
+
+		public override void EmitStatement (EmitContext ec)
+		{
+			Emit (ec, true);
+		}
+	}
+
+	
+	//
+	// This class is used for compound assignments.  
+	//
+	class CompoundAssign : Assign {
+		Binary.Operator op;
+		public Expression original_source;
+		
+		public CompoundAssign (Binary.Operator op, Expression target, Expression source, Location l)
+			: base (target, source, l)
+		{
+			original_source = source;
+			this.op = op;
+		}
+
+		public Expression ResolveSource (EmitContext ec)
+		{
+			return original_source.Resolve (ec);
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			target = target.ResolveLValue (ec, source);
+			if (target == null)
+				return null;
+
+			original_source = original_source.Resolve (ec);
+			if (original_source == null)
+				return null;
+
+			//
+			// Only now we can decouple the original source/target
+			// into a tree, to guarantee that we do not have side
+			// effects.
+			//
+			source = new Binary (op, target, original_source, loc);
+			return base.DoResolve (ec);
+		}
+	}
+}
diff --git a/dead/mbas/attribute.cs b/dead/mbas/attribute.cs
new file mode 100644
index 00000000..ad128648
--- /dev/null
+++ b/dead/mbas/attribute.cs
@@ -0,0 +1,902 @@
+//
+// attribute.cs: Attribute Handler
+//
+// Author: Ravi Pratap (ravi@ximian.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001 Ximian, Inc (http://www.ximian.com)
+//
+//
+
+using System;
+using System.Diagnostics;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Text.RegularExpressions;
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///   Base class for objects that can have Attributes applied to them.
+	/// </summary>
+	public abstract class Attributable {
+		/// <summary>
+		///   Attributes for this type
+		/// </summary>
+ 		Attributes attributes;
+
+		public Attributable(Attributes attrs)
+		{
+			attributes = attrs;
+		}
+
+		public Attributes OptAttributes 
+		{
+			get {
+				return attributes;
+			}
+			set {
+				attributes = value;
+			}
+		}
+
+		/// <summary>
+		/// Use member-specific procedure to apply attribute @a in @cb to the entity being built in @builder
+		/// </summary>
+		public abstract void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb);
+		/// <summary>
+		/// Returns one AttributeTarget for this element.
+		/// </summary>
+		public abstract AttributeTargets AttributeTargets { get; }
+	};
+	public class Attribute {
+		public readonly string ExplicitTarget;
+		public readonly string    Name;
+		
+		public readonly ArrayList Arguments;
+
+		public Location Location;
+
+		public Type Type;
+
+		// Is non-null if type is AttributeUsageAttribute
+		AttributeUsageAttribute usage_attribute;
+
+		public AttributeUsageAttribute UsageAttribute {
+			get {
+				return usage_attribute;
+			}
+		}
+		
+		bool usage_attr = false;
+		
+		MethodImplOptions ImplOptions;
+		public UnmanagedType     UnmanagedType;
+		CustomAttributeBuilder cb;
+
+		public Attribute (string name, ArrayList args, Location loc)
+		{
+			Name = name;
+			Arguments = args;
+			Location = loc;
+		}
+	
+		public Attribute (string target, string name, ArrayList args, Location loc) 
+		{
+			ExplicitTarget = target;
+			Object myObject;
+			if (name=="AssemblyVersion")
+			for (int i=0;i<args.Count;i++)
+				{
+				myObject=args[i];
+				
+					ArrayList arrList=(ArrayList)myObject;
+					for (int j=0;j<arrList.Count;j++)
+						{
+						
+						Argument arg = (Argument)arrList[i];
+						string strVersion = Regex.Replace(arg.Expr.ToString(),"StringLiteral","");
+						strVersion = Regex.Replace(strVersion,@"\(|\)","");
+						
+						//Version = new Version(strVersion); it does not work. but it should
+						//Making an ArrayList of integer to instatiate a new Version
+						for(int cont=0; cont<strVersion.Length;cont++)
+							if (Regex.IsMatch(strVersion[cont].ToString(),@"\d"))
+							{
+								
+								CodeGen.ArrListVersion.Add(Convert.ToInt32(strVersion[cont].ToString()));
+								
+							}//for
+						
+						}//for
+				}//for
+			
+		}
+
+		void Error_InvalidNamedArgument (string name)
+		{
+			Report.Error (617, Location, "'" + name + "' is not a valid named attribute " +
+				      "argument. Named attribute arguments must be fields which are not " +
+				      "readonly, static or const, or properties with a set accessor which "+
+				      "are not static.");
+		}
+
+		void Error_AttributeArgumentNotValid ()
+		{
+			Report.Error (182, Location,
+				      "An attribute argument must be a constant expression, typeof " +
+				      "expression or array creation expression");
+		}
+
+		static void Error_AttributeConstructorMismatch (Location loc)
+		{
+			Report.Error (
+					-6, loc,
+					"Could not find a constructor for this argument list.");
+		}
+		
+		private Type CheckAttributeType (EmitContext ec) {
+			Type t;
+			bool isattributeclass = true;
+			
+			t = RootContext.LookupType (ec.DeclSpace, Name, true, Location);
+			if (t != null) {
+				isattributeclass = t.IsSubclassOf (TypeManager.attribute_type);
+				if (isattributeclass)
+					return t;
+			}
+			t = RootContext.LookupType (ec.DeclSpace, Name + "Attribute", true, Location);
+			if (t != null) {
+				if (t.IsSubclassOf (TypeManager.attribute_type))
+					return t;
+			}
+			if (!isattributeclass) {
+				Report.Error (616, Location, "'" + Name + "': is not an attribute class");
+				return null;
+			}
+			if (t != null) {
+				Report.Error (616, Location, "'" + Name + "Attribute': is not an attribute class");
+				return null;
+			}
+			Report.Error (
+				246, Location, "Could not find attribute '" + Name + "' (are you" +
+				" missing a using directive or an assembly reference ?)");
+			return null;
+		}
+		
+
+		public Type ResolveType (EmitContext ec)
+		{
+			Type = CheckAttributeType (ec);
+			return Type;
+		}
+
+		
+		public CustomAttributeBuilder Resolve (EmitContext ec)
+		{
+			if (Type == null)
+				Type = CheckAttributeType (ec);
+			if (Type == null)
+				return null;
+
+			bool MethodImplAttr = false;
+			bool MarshalAsAttr = false;
+
+			usage_attr = false;
+
+			if (Type == TypeManager.attribute_usage_type)
+				usage_attr = true;
+			if (Type == TypeManager.methodimpl_attr_type)
+				MethodImplAttr = true;
+			if (Type == TypeManager.marshal_as_attr_type)
+				MarshalAsAttr = true;
+
+			// Now we extract the positional and named arguments
+			
+			ArrayList pos_args = new ArrayList ();
+			ArrayList named_args = new ArrayList ();
+			int pos_arg_count = 0;
+			
+			if (Arguments != null) {
+				pos_args = (ArrayList) Arguments [0];
+				if (pos_args != null)
+					pos_arg_count = pos_args.Count;
+				if (Arguments.Count > 1)
+					named_args = (ArrayList) Arguments [1];
+			}
+
+			object [] pos_values = new object [pos_arg_count];
+
+			//
+			// First process positional arguments 
+			//
+
+			int i;
+			for (i = 0; i < pos_arg_count; i++) {
+				Argument a = (Argument) pos_args [i];
+				Expression e;
+
+				if (!a.Resolve (ec, Location))
+					return null;
+
+				e = a.Expr;
+
+				if (e is Constant) {
+					pos_values [i] = ((Constant) e).GetValue ();
+				} else if (e is TypeOf) {
+					pos_values [i] = ((TypeOf) e).TypeArg;
+				} else {
+					Error_AttributeArgumentNotValid ();
+					return null;
+				}
+				
+				if (usage_attr)
+					usage_attribute = new AttributeUsageAttribute ((AttributeTargets) pos_values [0]);
+				
+				if (MethodImplAttr)
+					this.ImplOptions = (MethodImplOptions) pos_values [0];
+				
+				if (MarshalAsAttr)
+					this.UnmanagedType =
+					(System.Runtime.InteropServices.UnmanagedType) pos_values [0];
+			}
+
+			//
+			// Now process named arguments
+			//
+
+			ArrayList field_infos = new ArrayList ();
+			ArrayList prop_infos  = new ArrayList ();
+			ArrayList field_values = new ArrayList ();
+			ArrayList prop_values = new ArrayList ();
+			
+			for (i = 0; i < named_args.Count; i++) {
+				DictionaryEntry de = (DictionaryEntry) named_args [i];
+				string member_name = (string) de.Key;
+				Argument a  = (Argument) de.Value;
+				Expression e;
+				
+				if (!a.Resolve (ec, Location))
+					return null;
+
+				Expression member = Expression.MemberLookup (
+					ec, Type, member_name,
+					MemberTypes.Field | MemberTypes.Property,
+					BindingFlags.Public | BindingFlags.Instance,
+					Location);
+
+				if (member == null || !(member is PropertyGroupExpr || member is FieldExpr)) {
+					Error_InvalidNamedArgument (member_name);
+					return null;
+				}
+
+				e = a.Expr;
+				if (member is PropertyGroupExpr) {
+					PropertyGroupExpr pe = (PropertyGroupExpr) member;
+					PropertyInfo pi = null;
+					if (pe.Properties.Length == 1) 
+						pi = pe.Properties [0];
+					else {
+						// find a property which doesnt take any arguments
+						// Might be wrong, but this is just a temporary work-around
+						foreach (PropertyInfo p in pe.Properties) {
+							MethodInfo mi = p.GetGetMethod ();
+							if (mi.GetParameters().Length == 0) {
+								pi = p;
+								break;
+							}
+						}
+					}
+
+					if (!pi.CanWrite) {
+						Error_InvalidNamedArgument (member_name);
+						return null;
+					}
+
+					if (e is Constant) {
+						object o = ((Constant) e).GetValue ();
+						prop_values.Add (o);
+						
+						if (usage_attr) {
+							if (member_name == "AllowMultiple")
+								usage_attribute.AllowMultiple = (bool) o;
+							if (member_name == "Inherited")
+								usage_attribute.Inherited = (bool) o;
+						}
+						
+					} else if (e is TypeOf) {
+						prop_values.Add (((TypeOf) e).TypeArg);
+					} else {
+						Error_AttributeArgumentNotValid ();
+						return null;
+					}
+					
+					prop_infos.Add (pi);
+					
+				} else if (member is FieldExpr) {
+					FieldExpr fe = (FieldExpr) member;
+					FieldInfo fi = fe.FieldInfo;
+
+					if (fi.IsInitOnly) {
+						Error_InvalidNamedArgument (member_name);
+						return null;
+					}
+
+					//
+					// Handle charset here, and set the TypeAttributes
+					
+					if (e is Constant){
+						object value = ((Constant) e).GetValue ();
+						
+						field_values.Add (value);
+					} else if (e is TypeOf) {
+						field_values.Add (((TypeOf) e).TypeArg);
+					} else {
+						Error_AttributeArgumentNotValid ();
+						return null;
+					}
+					
+					field_infos.Add (fi);
+				}
+			}
+
+			Expression mg = Expression.MemberLookup (
+				ec, Type, ".ctor", MemberTypes.Constructor,
+				BindingFlags.Public | BindingFlags.Instance, Location);
+
+			if (mg == null) {
+				Error_AttributeConstructorMismatch (Location);
+				return null;
+			}
+
+			MethodBase constructor = Invocation.OverloadResolve (
+				ec, (MethodGroupExpr) mg, pos_args, Location);
+
+			if (constructor == null) {
+				Error_AttributeConstructorMismatch (Location);
+				return null;
+			}
+
+			//
+			// Now we perform some checks on the positional args as they
+			// cannot be null for a constructor which expects a parameter
+			// of type object
+			//
+
+			ParameterData pd = Invocation.GetParameterData (constructor);
+
+			for (int j = 0; j < pos_arg_count; ++j) {
+				Argument a = (Argument) pos_args [j];
+				
+				if (a.Expr is NullLiteral && pd.ParameterType (j) == TypeManager.object_type) {
+					Error_AttributeArgumentNotValid ();
+					return null;
+				}
+			}
+			
+			PropertyInfo [] prop_info_arr = new PropertyInfo [prop_infos.Count];
+			FieldInfo [] field_info_arr = new FieldInfo [field_infos.Count];
+			object [] field_values_arr = new object [field_values.Count];
+			object [] prop_values_arr = new object [prop_values.Count];
+
+			field_infos.CopyTo  (field_info_arr, 0);
+			field_values.CopyTo (field_values_arr, 0);
+
+			prop_values.CopyTo  (prop_values_arr, 0);
+			prop_infos.CopyTo   (prop_info_arr, 0);
+
+			try {
+			
+				cb = new CustomAttributeBuilder (
+					(ConstructorInfo) constructor, pos_values,
+					prop_info_arr, prop_values_arr,
+					field_info_arr, field_values_arr); 
+				
+			} catch (NullReferenceException) {
+				// 
+				// Don't know what to do here
+				//
+			} catch {
+				//
+				// Sample:
+				// using System.ComponentModel;
+				// [DefaultValue (CollectionChangeAction.Add)]
+				// class X { static void Main () {} }
+				//
+				Report.Warning (
+					-23, Location,
+					"The compiler can not encode this attribute in .NET due to\n" +
+					"\ta bug in the .NET runtime.  Try the Mono runtime");
+			}
+			
+			return cb;
+		}
+
+		public string GetValidTargets ()
+		{
+			StringBuilder sb = new StringBuilder ();
+			AttributeTargets targets = GetAttributeUsage ().ValidOn;
+			
+			if ((targets & AttributeTargets.Assembly) != 0)
+				sb.Append ("'assembly' ");
+
+			if ((targets & AttributeTargets.Class) != 0)
+				sb.Append ("'class' ");
+
+			if ((targets & AttributeTargets.Constructor) != 0)
+				sb.Append ("'constructor' ");
+
+			if ((targets & AttributeTargets.Delegate) != 0)
+				sb.Append ("'delegate' ");
+
+			if ((targets & AttributeTargets.Enum) != 0)
+				sb.Append ("'enum' ");
+
+			if ((targets & AttributeTargets.Event) != 0)
+				sb.Append ("'event' ");
+
+			if ((targets & AttributeTargets.Field) != 0)
+				sb.Append ("'field' ");
+
+			if ((targets & AttributeTargets.Interface) != 0)
+				sb.Append ("'interface' ");
+
+			if ((targets & AttributeTargets.Method) != 0)
+				sb.Append ("'method' ");
+
+			if ((targets & AttributeTargets.Module) != 0)
+				sb.Append ("'module' ");
+
+			if ((targets & AttributeTargets.Parameter) != 0)
+				sb.Append ("'parameter' ");
+
+			if ((targets & AttributeTargets.Property) != 0)
+				sb.Append ("'property' ");
+
+			if ((targets & AttributeTargets.ReturnValue) != 0)
+				sb.Append ("'return value' ");
+
+			if ((targets & AttributeTargets.Struct) != 0)
+				sb.Append ("'struct' ");
+
+			return sb.ToString ();
+
+		}
+
+		public static void Error_AttributeNotValidForElement (Attribute a, Location loc)
+		{
+			Report.Error (
+				30662, loc, "Attribute '" + a.Name +
+				"' is not valid on this declaration type. " +
+				"It is valid on " + a.GetValidTargets () + "declarations only.");
+		}
+
+		public static bool CheckAttribute (Attribute a, object element)
+		{
+			//TypeContainer attr = TypeManager.LookupClass (a.Type);
+			AttributeTargets targets = a.GetAttributeUsage ().ValidOn;
+
+
+			if (element is Class) {
+				if ((targets & AttributeTargets.Class) != 0)
+					return true;
+				else
+					return false;
+				
+			} else if (element is Struct) {
+				if ((targets & AttributeTargets.Struct) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is Constructor) {
+				if ((targets & AttributeTargets.Constructor) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is Delegate) {
+				if ((targets & AttributeTargets.Delegate) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is Enum) {
+				if ((targets & AttributeTargets.Enum) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is Event /*|| element is InterfaceEvent*/) {
+				if ((targets & AttributeTargets.Event) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is Field || element is FieldBuilder) {
+				if ((targets & AttributeTargets.Field) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is Interface) {
+				if ((targets & AttributeTargets.Interface) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is Method || element is Accessor) {
+				if ((targets & AttributeTargets.Method) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is ParameterBuilder) {
+				if ((targets & AttributeTargets.Parameter) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is Property /* || element is Indexer ||
+				   element is InterfaceProperty || element is InterfaceIndexer*/) {
+				if ((targets & AttributeTargets.Property) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is AssemblyBuilder){
+				if ((targets & AttributeTargets.Assembly) != 0)
+					return true;
+				else
+					return false;
+			} else if (element is ModuleBuilder){
+					if ((targets & AttributeTargets.Module) != 0)
+						return true;
+					else
+						return false;
+				}  
+
+			return false;
+		}
+
+		/// <summary>
+		/// Returns AttributeUsage attribute for this type
+		/// </summary>
+		public AttributeUsageAttribute GetAttributeUsage ()
+		{
+			Class attr_class = (Class) TypeManager.LookupClass (Type);
+
+			if (attr_class == null) {
+				object[] usage_attr = Type.GetCustomAttributes (TypeManager.attribute_usage_type, true);
+				return (AttributeUsageAttribute)usage_attr [0];
+			}
+		
+			return attr_class.AttributeUsage;
+		}
+
+		//
+		// This method should be invoked to pull the DefaultPropName attribute from an
+		// Indexer if it exists.
+		//
+		public static string ScanForIndexerName (EmitContext ec, Attributes opt_attrs)
+		{
+			if (opt_attrs == null)
+				return null;
+
+			foreach (Attribute a in opt_attrs.Attrs) {
+				if (a.ResolveType (ec) == null)
+					return null;
+					
+				if (a.Type != TypeManager.indexer_name_type)
+					continue;
+
+				//
+				// So we have found an DefaultPropName, pull the data out.
+				//
+				if (a.Arguments == null || a.Arguments [0] == null){
+					Error_AttributeConstructorMismatch (a.Location);
+					return null;
+				}
+				ArrayList pos_args = (ArrayList) a.Arguments [0];
+				if (pos_args.Count == 0){
+					Error_AttributeConstructorMismatch (a.Location);
+					return null;
+				}
+					
+				Argument arg = (Argument) pos_args [0];
+				if (!arg.Resolve (ec, a.Location))
+					return null;
+					
+				Expression e = arg.Expr;
+				if (!(e is StringConstant)){
+					Error_AttributeConstructorMismatch (a.Location);
+					return null;
+				}
+
+				//
+				// Remove the attribute from the list
+				//
+				opt_attrs.Attrs.Remove (a);
+
+				return (((StringConstant) e).Value);
+			}
+			return null;
+		}
+
+		//
+		// This pulls the condition name out of a Conditional attribute
+		//
+		public string Conditional_GetConditionName ()
+		{
+			//
+			// So we have a Conditional, pull the data out.
+			//
+			if (Arguments == null || Arguments [0] == null){
+				Error_AttributeConstructorMismatch (Location);
+				return null;
+			}
+
+			ArrayList pos_args = (ArrayList) Arguments [0];
+			if (pos_args.Count != 1){
+				Error_AttributeConstructorMismatch (Location);
+				return null;
+			}
+
+			Argument arg = (Argument) pos_args [0];	
+			if (!(arg.Expr is StringConstant)){
+				Error_AttributeConstructorMismatch (Location);
+				return null;
+			}
+
+			return ((StringConstant) arg.Expr).Value;
+		}
+
+		//
+		// This pulls the obsolete message and error flag out of an Obsolete attribute
+		//
+		public string Obsolete_GetObsoleteMessage (out bool is_error)
+		{
+			is_error = false;
+			//
+			// So we have an Obsolete, pull the data out.
+			//
+			if (Arguments == null || Arguments [0] == null)
+				return "";
+
+			ArrayList pos_args = (ArrayList) Arguments [0];
+			if (pos_args.Count == 0)
+				return "";
+			else if (pos_args.Count > 2){
+				Error_AttributeConstructorMismatch (Location);
+				return null;
+			}
+
+			Argument arg = (Argument) pos_args [0];	
+			if (!(arg.Expr is StringConstant)){
+				Error_AttributeConstructorMismatch (Location);
+				return null;
+			}
+
+			if (pos_args.Count == 2){
+				Argument arg2 = (Argument) pos_args [1];
+				if (!(arg2.Expr is BoolConstant)){
+					Error_AttributeConstructorMismatch (Location);
+					return null;
+				}
+				is_error = ((BoolConstant) arg2.Expr).Value;
+			}
+
+			return ((StringConstant) arg.Expr).Value;
+		}
+
+		
+		/// <summary>
+		/// Emit attribute for Attributable symbol
+		/// </summary>
+		public void Emit (EmitContext ec, Attributable ias, ListDictionary emitted_attr)
+		{
+			CustomAttributeBuilder cb = Resolve (ec);
+			if (cb == null)
+				return;
+		
+			AttributeUsageAttribute usage_attr = GetAttributeUsage ();
+			if ((usage_attr.ValidOn & ias.AttributeTargets) == 0) {
+				Report.Error (30662, Location, "Attribute" + Name + "is not valid on this declaration type. It is valid on " + GetValidTargets () + " declarations only.");
+				return;
+			}
+		
+			ias.ApplyAttributeBuilder (this, cb);
+		}
+
+		//
+		// Applies the attributes to the `builder'.
+		//							    		
+		public static void ApplyAttributes (EmitContext ec, object builder, object kind,
+						    Attributes opt_attrs, Location loc)
+		{
+			if (opt_attrs == null)
+				return;
+
+			foreach (Attribute a in opt_attrs.Attrs) {
+				CustomAttributeBuilder cb = a.Resolve (ec);
+
+				if (cb == null)
+					continue;
+
+				if (!(kind is TypeContainer))
+					if (!CheckAttribute (a, kind)) {
+							Error_AttributeNotValidForElement (a, loc);
+							return;
+					}
+
+				if (kind is Method || kind is Accessor) {
+					if (a.Type == TypeManager.methodimpl_attr_type) {
+						if (a.ImplOptions == MethodImplOptions.InternalCall)
+								((MethodBuilder) builder).SetImplementationFlags (MethodImplAttributes.InternalCall |	MethodImplAttributes.Runtime);
+					} else if (a.Type != TypeManager.dllimport_type){
+							((MethodBuilder) builder).SetCustomAttribute (cb);
+					}
+				}  else
+					throw new Exception ("Unknown kind: " + kind);
+			}
+		}
+
+		public MethodBuilder DefinePInvokeMethod (EmitContext ec, TypeBuilder builder, string name,
+							  MethodAttributes flags, Type ret_type, Type [] param_types)
+		{
+			//
+			// We extract from the attribute the information we need 
+			//
+
+			if (Arguments == null) {
+				Console.WriteLine ("Internal error : this is not supposed to happen !");
+				return null;
+			}
+
+			Type = CheckAttributeType (ec);
+			if (Type == null)
+				return null;
+			
+			ArrayList named_args = new ArrayList ();
+			
+			ArrayList pos_args = (ArrayList) Arguments [0];
+			if (Arguments.Count > 1)
+				named_args = (ArrayList) Arguments [1];
+			
+
+			string dll_name = null;
+			
+			Argument tmp = (Argument) pos_args [0];
+
+			if (!tmp.Resolve (ec, Location))
+				return null;
+			
+			if (tmp.Expr is Constant)
+				dll_name = (string) ((Constant) tmp.Expr).GetValue ();
+			else { 
+				Error_AttributeArgumentNotValid ();
+				return null;
+			}
+
+			// Now we process the named arguments
+			CallingConvention cc = CallingConvention.Winapi;
+			CharSet charset = CharSet.Ansi;
+			bool preserve_sig = true;
+			/*bool exact_spelling = false;
+			bool set_last_err = false;*/
+			string entry_point = null;
+
+			for (int i = 0; i < named_args.Count; i++) {
+
+				DictionaryEntry de = (DictionaryEntry) named_args [i];
+
+				string member_name = (string) de.Key;
+				Argument a  = (Argument) de.Value;
+
+				if (!a.Resolve (ec, Location))
+					return null;
+
+				Expression member = Expression.MemberLookup (
+					ec, Type, member_name, 
+					MemberTypes.Field | MemberTypes.Property,
+					BindingFlags.Public | BindingFlags.Instance,
+					Location);
+
+				if (member == null || !(member is FieldExpr)) {
+					Error_InvalidNamedArgument (member_name);
+					return null;
+				}
+
+				if (member is FieldExpr) {
+					FieldExpr fe = (FieldExpr) member;
+					FieldInfo fi = fe.FieldInfo;
+
+					if (fi.IsInitOnly) {
+						Error_InvalidNamedArgument (member_name);
+						return null;
+					}
+
+					if (a.Expr is Constant) {
+						Constant c = (Constant) a.Expr;
+						
+						if (member_name == "CallingConvention")
+							cc = (CallingConvention) c.GetValue ();
+						else if (member_name == "CharSet")
+							charset = (CharSet) c.GetValue ();
+						else if (member_name == "EntryPoint")
+							entry_point = (string) c.GetValue ();
+						/*else if (member_name == "SetLastError")
+							set_last_err = (bool) c.GetValue ();
+						else if (member_name == "ExactSpelling")
+							exact_spelling = (bool) c.GetValue ();*/
+						else if (member_name == "PreserveSig")
+							preserve_sig = (bool) c.GetValue ();
+					} else { 
+						Error_AttributeArgumentNotValid ();
+						return null;
+					}
+					
+				}
+			}
+
+			if (entry_point == null)
+				entry_point = name;
+			
+			MethodBuilder mb = builder.DefinePInvokeMethod (
+				name, dll_name, entry_point, flags | MethodAttributes.HideBySig,
+				CallingConventions.Standard,
+				ret_type,
+				param_types,
+				cc,
+				charset);
+
+			if (preserve_sig)
+				mb.SetImplementationFlags (MethodImplAttributes.PreserveSig);
+			
+			return mb;
+		}
+
+		public bool IsAssemblyAttribute {
+			get {
+				return ExplicitTarget == "assembly";
+			}
+		}
+
+		public bool IsModuleAttribute {
+			get {
+				return ExplicitTarget == "module";
+			}
+		}
+	}
+	
+	public class Attributes {
+		public ArrayList Attrs;
+		public Location Location;
+		
+		public Attributes (Attribute a)
+		{
+			Attrs = new ArrayList ();
+			Attrs.Add (a);
+		}
+
+		public Attributes (ArrayList attrs)
+		{
+			Attrs = attrs;
+		}
+
+		public void Add (Attribute attr)
+		{
+			Attrs.Add (attr);
+		}
+
+		public void Add (ArrayList attrs)
+		{
+			Attrs.AddRange (attrs);
+		}
+
+ 		public void Emit (EmitContext ec, Attributable ias)
+ 		{
+ 			ListDictionary ld = new ListDictionary ();
+	
+ 			foreach (Attribute a in Attrs)
+ 				a.Emit (ec, ias, ld);
+ 		}
+	}
+}
+
+
diff --git a/dead/mbas/block.cs b/dead/mbas/block.cs
new file mode 100644
index 00000000..6d76661e
--- /dev/null
+++ b/dead/mbas/block.cs
@@ -0,0 +1,938 @@
+//
+// block.cs: Block representation for the IL tree.
+//
+// Author:
+//   Rafael Teixeira (rafaelteixeirabr@hotmail.com)
+//   Miguel de Icaza (miguel@ximian.com)
+//   Martin Baulig (martin@gnome.org)
+//	 Anirban Bhattacharjee (banirban@novell.com)
+//   Manjula GHM (mmanjula@novell.com)
+//   Satya Sudha K (ksathyasudha@novell.com)
+//
+// (C) 2001, 2002, 2003, 2004, 2005 Ximian, Inc.
+//
+
+using System;
+using System.Text;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Diagnostics;
+
+namespace Mono.MonoBASIC {
+
+	using System.Collections;
+
+	/// <summary>
+	///   Block represents a VB.NET block.
+	/// </summary>
+	///
+	/// <remarks>
+	///   This class is used in a number of places: either to represent
+	///   explicit blocks that the programmer places or implicit blocks.
+	///
+	///   Implicit blocks are used as labels or to introduce variable
+	///   declarations.
+	/// </remarks>
+	public class Block : Statement {
+		public Block     Parent;
+		public readonly bool      Implicit;
+		public readonly Location  StartLocation;
+		public Location	   EndLocation;
+
+		//
+		// The statements in this block
+		//
+		public ArrayList statements;
+
+		//
+		// An array of Blocks.  We keep track of children just
+		// to generate the local variable declarations.
+		//
+		// Statements and child statements are handled through the
+		// statements.
+		//
+		ArrayList children;
+		
+		//
+		// Labels.  (label, block) pairs.
+		//
+		CaseInsensitiveHashtable labels;
+
+		//
+		// Keeps track of (name, type) pairs
+		//
+		CaseInsensitiveHashtable variables;
+
+		//
+		// Keeps track of constants
+		CaseInsensitiveHashtable constants;
+
+		//
+		// Maps variable names to ILGenerator.LocalBuilders
+		//
+		//CaseInsensitiveHashtable local_builders;
+
+		// to hold names of variables required for late binding
+		public const string lateBindingArgs = "1_LBArgs";
+		public const string lateBindingArgNames = "1_LBArgsNames";
+		public const string lateBindingCopyBack = "1_LBCopyBack";
+
+		bool isLateBindingRequired = false;
+
+		bool used = false;
+
+		static int id;
+
+		int this_id;
+		
+		public Block (Block parent)
+			: this (parent, false, Location.Null, Location.Null)
+		{ }
+
+		public Block (Block parent, bool implicit_block)
+			: this (parent, implicit_block, Location.Null, Location.Null)
+		{ }
+
+		public Block (Block parent, bool implicit_block, Parameters parameters)
+			: this (parent, implicit_block, parameters, Location.Null, Location.Null)
+		{ }
+
+		public Block (Block parent, Location start, Location end)
+			: this (parent, false, start, end)
+		{ }
+
+		public Block (Block parent, Parameters parameters, Location start, Location end)
+			: this (parent, false, parameters, start, end)
+		{ }
+
+		public Block (Block parent, bool implicit_block, Location start, Location end)
+			: this (parent, implicit_block, Parameters.EmptyReadOnlyParameters,
+				start, end)
+		{ }
+
+		public Block (Block parent, bool implicit_block, Parameters parameters,
+			      Location start, Location end)
+		{
+			if (parent != null)
+				parent.AddChild (this);
+			else {
+				// Top block
+				// Add variables that may be required for late binding
+				variables = new CaseInsensitiveHashtable ();
+				ArrayList rank_specifier = new ArrayList ();
+				ArrayList element = new ArrayList ();
+				element.Add (new EmptyExpression ());
+				rank_specifier.Add (element);
+				Expression e = Mono.MonoBASIC.Parser.DecomposeQI ("System.Object[]", start);
+				AddVariable (e, Block.lateBindingArgs, null, start);
+				e = Mono.MonoBASIC.Parser.DecomposeQI ("System.String[]", start);
+				AddVariable (e, Block.lateBindingArgNames, null, start);
+				e = Mono.MonoBASIC.Parser.DecomposeQI ("System.Boolean[]", start);
+				AddVariable (e, Block.lateBindingCopyBack, null, start);
+			}
+			
+			this.Parent = parent;
+			this.Implicit = implicit_block;
+			this.parameters = parameters;
+			this.StartLocation = start;
+			this.EndLocation = end;
+			this.loc = start;
+			this_id = id++;
+			statements = new ArrayList ();
+		}
+
+		public bool IsLateBindingRequired {
+			get {
+				return isLateBindingRequired;
+			}
+			set {
+				isLateBindingRequired = value;
+			}
+		}
+
+		public int ID {
+			get {
+				return this_id;
+			}
+		}
+
+		public void AddChild (Block b)
+		{
+			if (children == null)
+				children = new ArrayList ();
+			
+			children.Add (b);
+		}
+
+		public void SetEndLocation (Location loc)
+		{
+			EndLocation = loc;
+		}
+
+		/// <summary>
+		///   Verify if the current block has a labeled statement. 
+		/// </summary>
+		///
+		/// <returns>
+		///   false if desn't exist a labeled statement in this block or in its children. true
+		///   otherwise.
+		/// </returns>
+		public bool HasLabeledStatement {
+			get {
+				foreach( Statement s in statements ) {
+					if( s is LabeledStatement )
+						return true;
+					else if (s is Block )
+						return ( ((Block) s).HasLabeledStatement);
+				}
+				return false;
+			}
+		}
+		
+		public bool HasGotoStatement {
+			get {
+				foreach( Statement s in statements ) {
+					if( s is Goto )
+						return true;
+					else if (s is Block )
+						return ( ((Block) s).HasLabeledStatement);
+				}
+				return false;
+			}
+		}
+		
+		public string LabelName {
+			get {
+				foreach( Statement s in statements ) {
+					if( s is LabeledStatement )
+						return ((LabeledStatement)s).LabelName;
+					else if (s is Block )
+						return ( ((Block) s).LabelName);
+				}
+				return "";
+			}
+		}
+				
+		/// <summary>
+		///   Adds a label to the current block. 
+		/// </summary>
+		///
+		/// <returns>
+		///   false if the name already exists in this block. true
+		///   otherwise.
+		/// </returns>
+		///
+/**
+		public bool AddLabel (string name, LabeledStatement target)
+		{
+			if (labels == null)
+				labels = new CaseInsensitiveHashtable ();
+			if (labels.Contains (name))
+				return false;
+			
+			labels.Add (name, target);
+			return true;
+		}
+**/
+
+
+		 public bool AddLabel (string name, LabeledStatement target, Location loc)
+		{
+/**
+			if (switch_block != null)
+				return switch_block.AddLabel (name, target, loc);
+**/
+			Block cur = this;
+			while (cur != null) {
+
+				if (cur.DoLookupLabel (name) != null) {
+					Report.Error (
+						140, loc, "The label '" + name +"' is a duplicate");
+					return false;
+				}
+
+				if (!Implicit)
+					break;
+
+				cur = cur.Parent;
+			}
+
+			 while (cur != null) {
+				if (cur.DoLookupLabel (name) != null) {
+					Report.Error (
+						158, loc,
+						"The label '"+ name +"' shadows another label " +
+						"by the same name in a containing scope.");
+					return false;
+				}
+
+				if (children != null) {
+					foreach (Block b in children) {
+						LabeledStatement s = b.DoLookupLabel (name);
+						if (s == null)
+							continue;
+						Report.Error (
+							158, s.Location,
+							"The label '"+ name +"' shadows another " +
+							"label by the same name in a " +
+							"containing scope.");
+						return false;
+					}
+				}
+				cur = cur.Parent;
+			}
+			 if (labels == null)
+				labels = new CaseInsensitiveHashtable ();
+			if (labels.Contains (name))
+				return false;
+
+			labels.Add (name, target);
+			return true;
+
+		}
+		
+		public LabeledStatement LookupLabel (string name)
+		{
+			LabeledStatement s = DoLookupLabel (name);
+			if (s != null) 
+				return s;
+			
+			if (children == null)
+				return null;
+
+			foreach (Block child in children) {
+			//	if (!child.Implicit)
+			//		continue;
+
+				s = child.LookupLabel (name);
+				if (s != null) 
+					return s;
+			}
+
+			return null;
+		}
+
+		public LabeledStatement DoLookupLabel (string name)
+		{
+			if (labels != null){
+				if (labels.Contains (name))
+					return ((LabeledStatement) labels [name]);
+			}
+/**
+			if (Parent != null)
+				return Parent.LookupLabel (name);
+**/
+			return null;
+		}
+
+		VariableInfo this_variable = null;
+
+		// <summary>
+		//   Returns the "this" instance variable of this block.
+		//   See AddThisVariable() for more information.
+		// </summary>
+		public VariableInfo ThisVariable {
+			get {
+				if (this_variable != null)
+					return this_variable;
+				else if (Parent != null)
+					return Parent.ThisVariable;
+				else
+					return null;
+			}
+		}
+
+		Hashtable child_variable_names;
+
+		// <summary>
+		//   Marks a variable with name @name as being used in a child block.
+		//   If a variable name has been used in a child block, it's illegal to
+		//   declare a variable with the same name in the current block.
+		// </summary>
+		public void AddChildVariableName (string name)
+		{
+			if (child_variable_names == null)
+				child_variable_names = new CaseInsensitiveHashtable ();
+
+			if (!child_variable_names.Contains (name))
+				child_variable_names.Add (name, true);
+		}
+
+		// <summary>
+		//   Marks all variables from block @block and all its children as being
+		//   used in a child block.
+		// </summary>
+		public void AddChildVariableNames (Block block)
+		{
+			if (block.Variables != null) {
+				foreach (string name in block.Variables.Keys)
+					AddChildVariableName (name);
+			}
+
+			foreach (Block child in block.children) {
+				if (child.Variables != null) {
+					foreach (string name in child.Variables.Keys)
+						AddChildVariableName (name);
+				}
+			}
+		}
+
+		// <summary>
+		//   Checks whether a variable name has already been used in a child block.
+		// </summary>
+		public bool IsVariableNameUsedInChildBlock (string name)
+		{
+			if (child_variable_names == null)
+				return false;
+
+			return child_variable_names.Contains (name);
+		}
+
+		// <summary>
+		//   This is used by non-static 'struct' constructors which do not have an
+		//   initializer - in this case, the constructor must initialize all of the
+		//   struct's fields.  To do this, we add a "this" variable and use the flow
+		//   analysis code to ensure that it's been fully initialized before control
+		//   leaves the constructor.
+		// </summary>
+		public VariableInfo AddThisVariable (TypeContainer tc, Location l)
+		{
+			if (this_variable != null)
+				return this_variable;
+
+			this_variable = new VariableInfo (tc, ID, l);
+
+			if (variables == null)
+				variables = new CaseInsensitiveHashtable ();
+			variables.Add ("this", this_variable);
+
+			return this_variable;
+		}
+
+		public VariableInfo AddVariable (EmitContext ec, Expression type, string name, Location l)
+		{
+			if (!variables_initialized)
+				throw new InvalidOperationException();
+				
+			VariableInfo vi = AddVariable(type, name, null, loc);
+
+			int priorCount = count_variables;
+			DeclSpace ds = ec.DeclSpace;
+
+			if (!vi.Resolve (ds)) {
+				vi.Number = -1;
+			} else {
+				vi.Number = ++count_variables;
+				if (vi.StructInfo != null)
+					count_variables += vi.StructInfo.Count;
+			}
+			if (priorCount < count_variables)
+				ec.CurrentBranching.CurrentUsageVector.AddExtraLocals(count_variables - priorCount);
+				
+			return vi;
+		}
+		
+		
+		
+		public VariableInfo AddVariable (Expression type, string name, Parameters pars, Location l, string Alias)
+		{
+			VariableInfo vi = AddVariable (type, name, pars, l);
+			if (vi != null) 
+				vi.Alias = Alias;
+					
+			return vi;
+		}
+		
+		public VariableInfo AddVariable (Expression type, string name, Parameters pars, Location l)
+		{
+			if (variables == null)
+				variables = new CaseInsensitiveHashtable ();
+
+			VariableInfo vi = GetVariableInfo (name);
+			if (vi != null) {
+				if (vi.Block != ID)
+					Report.Error (30616, l, "A local variable named '" + name + "' " +
+						      "cannot be declared in this scope since it would " +
+						      "give a different meaning to '" + name + "', which " +
+						      "is already used in a 'parent or current' scope to " +
+						      "denote something else");
+				else
+					Report.Error (30290, l, "A local variable '" + name + "' is already " +
+						      "defined in this scope");
+				return null;
+			}
+
+			if (IsVariableNameUsedInChildBlock (name)) {
+				Report.Error (136, l, "A local variable named '" + name + "' " +
+					      "cannot be declared in this scope since it would " +
+					      "give a different meaning to '" + name + "', which " +
+					      "is already used in a 'child' scope to denote something " +
+					      "else");
+				return null;
+			}
+
+			if (pars != null) {
+				int idx = 0;
+				Parameter p = pars.GetParameterByName (name, out idx);
+				if (p != null) {
+					Report.Error (30616, l, "A local variable named '" + name + "' " +
+						      "cannot be declared in this scope since it would " +
+						      "give a different meaning to '" + name + "', which " +
+						      "is already used in a 'parent or current' scope to " +
+						      "denote something else");
+					return null;
+				}
+			}
+			
+			vi = new VariableInfo (type, name, ID, l);
+
+			variables.Add (name, vi);
+
+			return vi;
+		}
+
+		public bool AddConstant (Expression type, string name, Expression value, Parameters pars, Location l)
+		{
+			if (AddVariable (type, name, pars, l) == null)
+				return false;
+			
+			if (constants == null)
+				constants = new CaseInsensitiveHashtable ();
+
+			constants.Add (name, value);
+			return true;
+		}
+
+		public Hashtable Variables {
+			get {
+				return variables;
+			}
+		}
+
+		public VariableInfo GetVariableInfo (string name)
+		{
+			if (variables != null) {
+				object temp;
+				temp = variables [name];
+
+				if (temp != null){
+					return (VariableInfo) temp;
+				}
+			}
+
+			if (Parent != null)
+				return Parent.GetVariableInfo (name);
+
+			return null;
+		}
+		
+		public Expression GetVariableType (string name)
+		{
+			VariableInfo vi = GetVariableInfo (name);
+
+			if (vi != null)
+				return vi.Type;
+
+			return null;
+		}
+
+		public Expression GetConstantExpression (string name)
+		{
+			if (constants != null) {
+				object temp;
+				temp = constants [name];
+				
+				if (temp != null)
+					return (Expression) temp;
+			}
+			
+			if (Parent != null)
+				return Parent.GetConstantExpression (name);
+
+			return null;
+		}
+		
+		/// <summary>
+		///   True if the variable named @name has been defined
+		///   in this block
+		/// </summary>
+		public bool IsVariableDefined (string name)
+		{
+			// Console.WriteLine ("Looking up {0} in {1}", name, ID);
+			if (variables != null) {
+				if (variables.Contains (name))
+					return true;
+			}
+			
+			if (Parent != null)
+				return Parent.IsVariableDefined (name);
+
+			return false;
+		}
+
+		/// <summary>
+		///   True if the variable named @name is a constant
+		///  </summary>
+		public bool IsConstant (string name)
+		{
+			Expression e = null;
+			
+			e = GetConstantExpression (name);
+			
+			return e != null;
+		}
+		
+		/// <summary>
+		///   Use to fetch the statement associated with this label
+		/// </summary>
+		public Statement this [string name] {
+			get {
+				return (Statement) labels [name];
+			}
+		}
+
+		Parameters parameters = null;
+		public Parameters Parameters {
+			get {
+				if (Parent != null)
+					return Parent.Parameters;
+
+				return parameters;
+			}
+		}
+
+		/// <returns>
+		///   A list of labels that were not used within this block
+		/// </returns>
+		public string [] GetUnreferenced ()
+		{
+			// FIXME: Implement me
+			return null;
+		}
+
+		public void AddStatement (Statement s)
+		{
+			statements.Add (s);
+			used = true;
+		}
+
+		public bool Used {
+			get {
+				return used;
+			}
+		}
+
+		public void Use ()
+		{
+			used = true;
+		}
+
+		bool variables_initialized = false;
+		int count_variables = 0, first_variable = 0;
+
+		void UpdateVariableInfo (EmitContext ec)
+		{
+			DeclSpace ds = ec.DeclSpace;
+
+			first_variable = 0;
+
+			if (Parent != null)
+				first_variable += Parent.CountVariables;
+
+			count_variables = first_variable;
+			if (variables != null) {
+				foreach (VariableInfo vi in variables.Values) {
+					if (!vi.Resolve (ds)) {
+						vi.Number = -1;
+						continue;
+					}
+
+					vi.Number = ++count_variables;
+
+					if (vi.StructInfo != null)
+						count_variables += vi.StructInfo.Count;
+				}
+			}
+
+			variables_initialized = true;
+		}
+
+		//
+		// <returns>
+		//   The number of local variables in this block
+		// </returns>
+		public int CountVariables
+		{
+			get {
+				if (!variables_initialized)
+					throw new Exception ();
+
+				return count_variables;
+			}
+		}
+
+		/// <summary>
+		///   Emits the variable declarations and labels.
+		/// </summary>
+		/// <remarks>
+		///   tc: is our typecontainer (to resolve type references)
+		///   ig: is the code generator:
+		///   toplevel: the toplevel block.  This is used for checking 
+		///   		that no two labels with the same name are used.
+		/// </remarks>
+		public void EmitMeta (EmitContext ec, Block toplevel)
+		{
+			//DeclSpace ds = ec.DeclSpace;
+			ILGenerator ig = ec.ig;
+
+			if (!variables_initialized)
+				UpdateVariableInfo (ec);
+
+			//
+			// Process this block variables
+			//
+			if (variables != null){
+				//local_builders = new CaseInsensitiveHashtable ();
+				
+				foreach (DictionaryEntry de in variables){
+					string name = (string) de.Key;
+					/*
+					if (!isLateBindingRequired) {
+						if (name.Equals (Block.lateBindingArgs) || 
+						    name.Equals (Block.lateBindingArgNames) ||
+						    name.Equals (Block.lateBindingCopyBack))
+							continue;
+					}
+					*/
+					VariableInfo vi = (VariableInfo) de.Value;
+
+					if (vi.VariableType == null)
+						continue;
+
+                                       if (vi.Alias == null)
+                                               vi.LocalBuilder = ig.DeclareLocal (vi.VariableType);
+
+                                       if (CodeGen.SymbolWriter != null && vi.LocalBuilder != null)
+						vi.LocalBuilder.SetLocalSymInfo (name);
+
+					if (constants == null)
+						continue;
+
+					Expression cv = (Expression) constants [name];
+					if (cv == null)
+						continue;
+
+					Expression e = cv.Resolve (ec);
+					if (e == null)
+						continue;
+
+					if (!(e is Constant)){
+						Report.Error (133, vi.Location,
+							      "The expression being assigned to '" +
+							      name + "' must be constant (" + e + ")");
+						continue;
+					}
+
+					constants.Remove (name);
+					constants.Add (name, e);
+				}
+			}
+
+			//
+			// Now, handle the children
+			//
+			if (children != null){
+				foreach (Block b in children)
+					b.EmitMeta (ec, toplevel);
+			}
+		}
+
+		public void UsageWarning ()
+		{
+			string name;
+			
+			if (variables != null){
+				foreach (DictionaryEntry de in variables){
+					VariableInfo vi = (VariableInfo) de.Value;
+					
+					if (vi.Used)
+						continue;
+					
+					name = (string) de.Key;
+						
+					if (vi.Assigned){
+						Report.Warning (
+							219, vi.Location, "The variable '" + name +
+							"' is assigned but its value is never used");
+					} else {
+						if (!(name.Equals(lateBindingArgs)||name.Equals(lateBindingArgNames)||name.Equals(lateBindingCopyBack)))
+						Report.Warning (
+							168, vi.Location, "The variable '" +
+							name +"' is declared but never used");
+					} 
+				}
+			}
+
+			if (children != null)
+				foreach (Block b in children)
+					b.UsageWarning ();
+		}
+
+		bool has_ret = false;
+
+		public override bool Resolve (EmitContext ec)
+		{
+			Block prev_block = ec.CurrentBlock;
+			bool ok = true;
+
+			ec.CurrentBlock = this;
+
+			if (!variables_initialized)
+				UpdateVariableInfo (ec);
+				
+			ec.StartFlowBranching (this);
+
+			Report.Debug (1, "RESOLVE BLOCK", StartLocation, ec.CurrentBranching);
+
+			ArrayList new_statements = new ArrayList ();
+			bool unreachable = false, warning_shown = false;
+
+			foreach (Statement s in statements) {
+				
+				if (unreachable && !(s is LabeledStatement)) {
+					if ( !(s is Block && ((Block)s).HasLabeledStatement) ) {
+						if (!warning_shown && !(s is EmptyStatement)) {
+							warning_shown = true;
+							Warning_DeadCodeFound (s.loc);
+						}
+						continue;
+					}
+				}			
+
+				if (s.Resolve (ec) == false) {
+					ok = false;
+					continue;
+				}
+
+				if (s is LabeledStatement)
+					unreachable = false;
+				else
+					unreachable = ! ec.CurrentBranching.IsReachable ();
+
+				new_statements.Add (s);
+			}
+
+			statements = new_statements;
+
+			Report.Debug (1, "RESOLVE BLOCK DONE", StartLocation, ec.CurrentBranching);
+
+			FlowReturns returns = ec.EndFlowBranching ();
+			ec.CurrentBlock = prev_block;
+
+			// If we're a non-static 'struct' constructor which doesn't have an
+			// initializer, then we must initialize all of the struct's fields.
+			if ((this_variable != null) && (returns != FlowReturns.EXCEPTION) &&
+			    !this_variable.IsAssigned (ec, loc))
+				ok = false;
+
+			if ((labels != null) && (RootContext.WarningLevel >= 2)) {
+				foreach (LabeledStatement label in labels.Values)
+					if (!label.HasBeenReferenced)
+						Report.Warning (164, label.Location,
+								"This label has not been referenced");
+			}
+
+			if ((returns == FlowReturns.ALWAYS) ||
+			    (returns == FlowReturns.EXCEPTION) ||
+			    (returns == FlowReturns.UNREACHABLE))
+				has_ret = true;
+
+			return ok;
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			Block prev_block = ec.CurrentBlock;
+
+			ec.CurrentBlock = this;
+
+			ec.Mark (StartLocation);
+			foreach (Statement s in statements)
+				s.Emit (ec);
+				
+			ec.Mark (EndLocation); 
+			
+			ec.CurrentBlock = prev_block;
+			return has_ret;
+		}
+		
+		public override string ToString ()
+		{
+			return String.Format ("{0} ({1}:{2})", GetType (),ID, StartLocation);
+		}
+
+	} // class Block
+	
+	/// <summary>
+	///   Block represents a VB.NET method block.
+	/// </summary>
+	///
+	/// <remarks>
+	///   This class is used in a number of places: either to represent
+	///   explicit blocks that the programmer places or implicit blocks.
+	///
+	///   Implicit blocks are used as labels or to introduce variable
+	///   declarations.
+	/// </remarks>
+	public class MethodBlock : Block {
+		public readonly string MethodName;
+		public Block onerror;
+		public ArrayList Pending_Assigns;
+		
+		public MethodBlock (Block parent, string MethodName)
+			: base (parent, false, Location.Null, Location.Null)
+		{
+			this.MethodName = MethodName;
+		}
+
+		public MethodBlock (Block parent, bool implicit_block, string MethodName)
+			: base (parent, implicit_block, Location.Null, Location.Null)
+		{
+			this.MethodName = MethodName;
+		}
+
+		public MethodBlock (Block parent, bool implicit_block, Parameters parameters, string MethodName)
+			: base (parent, implicit_block, parameters, Location.Null, Location.Null)
+		{
+			this.MethodName = MethodName;
+		}
+
+		public MethodBlock (Block parent, Location start, Location end, String MethodName)
+			: base (parent, false, start, end)
+		{
+			this.MethodName = MethodName;
+		}
+
+		public MethodBlock (Block parent, Parameters parameters, Location start, Location end, string MethodName)
+			: base (parent, false, parameters, start, end)
+		{
+			this.MethodName = MethodName;
+		}
+
+		public MethodBlock (Block parent, bool implicit_block, Location start, Location end, string MethodName)
+			: base (parent, implicit_block, Parameters.EmptyReadOnlyParameters,
+				start, end)
+		{
+			this.MethodName = MethodName;
+		}
+
+		public MethodBlock (Block parent, bool implicit_block, Parameters parameters,
+			      Location start, Location end, string MethodName)
+			: base (parent, implicit_block, parameters, start, end)
+		{
+			this.MethodName = MethodName;
+		}
+		
+	}
+
+} // namespace Mono.MonoBASIC
diff --git a/dead/mbas/cfold.cs b/dead/mbas/cfold.cs
new file mode 100644
index 00000000..a8d81e57
--- /dev/null
+++ b/dead/mbas/cfold.cs
@@ -0,0 +1,1170 @@
+//
+// cfold.cs: Constant Folding
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//
+// (C) 2002 Ximian, Inc.
+//
+
+using System;
+
+namespace Mono.MonoBASIC {
+
+	public class ConstantFold {
+
+		 static public Constant ConvertNothingToDefaultConst (EmitContext ec, 
+                                                                        Type target_type, Location loc)
+                {
+                        switch (Type.GetTypeCode (target_type)) {
+                        case TypeCode.Boolean  :
+                                return new BoolConstant (false);
+                        case TypeCode.Byte  :
+                                return new ByteConstant (0);
+                        case TypeCode.Char  :
+                                return new CharConstant ((char)0);
+                        case TypeCode.SByte :
+                                return new SByteConstant (0);
+                        case TypeCode.Int16 :
+                                return new ShortConstant (0);
+                        case TypeCode.Int32 :
+                                return new IntConstant (0);
+                        case TypeCode.Int64 :
+                                return new LongConstant (0);
+                        case TypeCode.Decimal :
+                                return new DecimalConstant (System.Decimal.Zero);
+                        case TypeCode.Single :
+                                return new FloatConstant (0.0F);
+                        case TypeCode.Double :
+				 return new DoubleConstant (0.0);
+                        }
+
+                        return null;
+                }
+
+
+		//
+		// Performs the numeric promotions on the left and right expresions
+		// and desposits the results on `lc' and `rc'.
+		//
+		// On success, the types of `lc' and `rc' on output will always match,
+		// and the pair will be one of:
+		//
+		//   (double, double)
+		//   (float, float)
+		//   (ulong, ulong)
+		//   (long, long)
+		//   (uint, uint)
+		//   (int, int)
+		//
+		static void DoConstantNumericPromotions (EmitContext ec, Binary.Operator oper,
+							 ref Constant left, ref Constant right,
+							 Location loc)
+		{
+			
+			Type conv_left_as = null;
+			Type conv_right_as = null;
+			Type lt = left.Type;
+			Type rt = right.Type;
+	
+			
+                        if (left is NullLiteral)
+                                conv_left_as = rt;
+                        if (right is NullLiteral)
+                                conv_right_as = lt;
+			
+			 if (conv_left_as != null)
+                                left = ConvertNothingToDefaultConst (ec, conv_left_as, loc);
+                        if (conv_right_as != null)
+                                right = ConvertNothingToDefaultConst (ec, conv_right_as, loc);
+			if (left is DoubleConstant || right is DoubleConstant || 
+			    oper == Binary.Operator.Exponentiation || oper == Binary.Operator.Division) {
+				//
+				// If either side is a double, convert the other to a double
+				//
+				if (!(left is DoubleConstant))
+					left = left.ToDouble (loc);
+
+				if (!(right is DoubleConstant))
+					right = right.ToDouble (loc);
+				return;
+			} else if (left is FloatConstant || right is FloatConstant) {
+				//
+				// If either side is a float, convert the other to a float
+				//
+				if (!(left is FloatConstant))
+					left = left.ToFloat (loc);
+
+				if (!(right is FloatConstant))
+					right = right.ToFloat (loc);
+;				return;
+			} else if (left is ULongConstant || right is ULongConstant){
+				//
+				// If either operand is of type ulong, the other operand is
+				// converted to type ulong.  or an error ocurrs if the other
+				// operand is of type sbyte, short, int or long
+				//
+#if WRONG
+				Constant match, other;
+#endif
+					
+				if (left is ULongConstant){
+#if WRONG
+					other = right;
+					match = left;
+#endif
+					if (!(right is ULongConstant))
+						right = right.ToULong (loc);
+				} else {
+#if WRONG
+					other = left;
+					match = right;
+#endif
+					left = left.ToULong (loc);
+				}
+
+#if WRONG
+				if (other is SByteConstant || other is ShortConstant ||
+				    other is IntConstant || other is LongConstant){
+					Binary.Error_OperatorAmbiguous
+						(loc, oper, other.Type, match.Type);
+					left = null;
+					right = null;
+				}
+#endif
+				return;
+			} else if (left is LongConstant || right is LongConstant){
+				//
+				// If either operand is of type long, the other operand is converted
+				// to type long.
+				//
+				if (!(left is LongConstant))
+					left = left.ToLong (loc);
+				else if (!(right is LongConstant))
+					right = right.ToLong (loc);
+				return;
+			} else if (left is UIntConstant || right is UIntConstant){
+				//
+				// If either operand is of type uint, and the other
+				// operand is of type sbyte, short or int, the operands are
+				// converted to type long.
+				//
+				Constant other;
+				if (left is UIntConstant){
+					other = right;
+				} else {
+					other = left;
+				}
+
+				// Nothing to do.
+				if (other is UIntConstant)
+					return;
+
+				if (other is SByteConstant || other is ShortConstant ||
+				    other is IntConstant){
+					left = left.ToLong (loc);
+					right = right.ToLong (loc);
+				}
+
+				return;
+			} else if (left is EnumConstant || right is EnumConstant){
+				//
+				// If either operand is an enum constant, the other one must
+				// be implicitly convertable to that enum's underlying type.
+				//
+				EnumConstant match;
+				Constant other;
+				if (left is EnumConstant){
+					other = right;
+					match = (EnumConstant) left;
+				} else {
+					other = left;
+					match = (EnumConstant) right;
+				}
+
+				bool need_check = (other is EnumConstant) ||
+					((oper != Binary.Operator.Addition) &&
+					 (oper != Binary.Operator.Subtraction));
+
+				if (need_check &&
+				    !Expression.ImplicitConversionExists (ec, match, other.Type)) {
+					Expression.Error_CannotConvertImplicit (loc, match.Type, other.Type);
+					left = null;
+					right = null;
+					return;
+				}
+
+				if (left is EnumConstant)
+					left = ((EnumConstant) left).Child;
+				if (right is EnumConstant)
+					right = ((EnumConstant) right).Child;
+				return;
+
+			} else {
+				//
+				// Force conversions to int32
+				//
+				if (!(left is IntConstant))
+					left = left.ToInt (loc);
+				if (!(right is IntConstant))
+					right = right.ToInt (loc);
+			}
+			return;
+		}
+
+		static void Error_CompileTimeOverflow (Location loc)
+		{
+			Report.Error (220, loc, "The operation overflows at compile time in checked mode");
+		}
+		
+		/// <summary>
+		///   Constant expression folder for binary operations.
+		///
+		///   Returns null if the expression can not be folded.
+		/// </summary>
+		static public Expression BinaryFold (EmitContext ec, Binary.Operator oper,
+						     Constant left, Constant right, Location loc)
+		{
+			Type lt = left.Type;
+			Type rt = right.Type;
+			Type result_type = null;
+			bool bool_res;
+			
+			//
+			// Enumerator folding
+			//
+			if (rt == lt && left is EnumConstant)
+				result_type = lt;
+
+			//
+			// During an enum evaluation, we need to unwrap enumerations
+			//
+			if (ec.InEnumContext){
+				if (left is EnumConstant)
+					left = ((EnumConstant) left).Child;
+				
+				if (right is EnumConstant)
+					right = ((EnumConstant) right).Child;
+			}
+
+			Type wrap_as;
+			Constant result = null;
+			switch (oper){
+			case Binary.Operator.BitwiseOr:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+				
+				if (left is IntConstant){
+					IntConstant v;
+					int res = ((IntConstant) left).Value | ((IntConstant) right).Value;
+					
+					v = new IntConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				} else if (left is UIntConstant){
+					UIntConstant v;
+					uint res = ((UIntConstant)left).Value | ((UIntConstant)right).Value;
+					
+					v = new UIntConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				} else if (left is LongConstant){
+					LongConstant v;
+					long res = ((LongConstant)left).Value | ((LongConstant)right).Value;
+					
+					v = new LongConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				} else if (left is ULongConstant){
+					ULongConstant v;
+					ulong res = ((ULongConstant)left).Value |
+						((ULongConstant)right).Value;
+					
+					v = new ULongConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				}
+				break;
+				
+			case Binary.Operator.BitwiseAnd:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+				
+				if (left is IntConstant){
+					IntConstant v;
+					int res = ((IntConstant) left).Value & ((IntConstant) right).Value;
+					
+					v = new IntConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				} else if (left is UIntConstant){
+					UIntConstant v;
+					uint res = ((UIntConstant)left).Value & ((UIntConstant)right).Value;
+					
+					v = new UIntConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				} else if (left is LongConstant){
+					LongConstant v;
+					long res = ((LongConstant)left).Value & ((LongConstant)right).Value;
+					
+					v = new LongConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				} else if (left is ULongConstant){
+					ULongConstant v;
+					ulong res = ((ULongConstant)left).Value &
+						((ULongConstant)right).Value;
+					
+					v = new ULongConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				}
+				break;
+
+			case Binary.Operator.ExclusiveOr:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+				
+				if (left is IntConstant){
+					IntConstant v;
+					int res = ((IntConstant) left).Value ^ ((IntConstant) right).Value;
+					
+					v = new IntConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				} else if (left is UIntConstant){
+					UIntConstant v;
+					uint res = ((UIntConstant)left).Value ^ ((UIntConstant)right).Value;
+					
+					v = new UIntConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				} else if (left is LongConstant){
+					LongConstant v;
+					long res = ((LongConstant)left).Value ^ ((LongConstant)right).Value;
+					
+					v = new LongConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				} else if (left is ULongConstant){
+					ULongConstant v;
+					ulong res = ((ULongConstant)left).Value ^
+						((ULongConstant)right).Value;
+					
+					v = new ULongConstant (res);
+					if (result_type == null)
+						return v;
+					else
+						return new EnumConstant (v, result_type);
+				}
+				break;
+
+			case Binary.Operator.Addition:
+				bool left_is_string = left is StringConstant;
+				bool right_is_string = right is StringConstant;
+
+				//
+				// If both sides are strings, then concatenate, if
+				// one is a string, and the other is not, then defer
+				// to runtime concatenation
+				//
+				wrap_as = null;
+				if (left_is_string || right_is_string){
+					if (left_is_string && right_is_string)
+						return new StringConstant (
+							((StringConstant) left).Value +
+							((StringConstant) right).Value);
+					
+					return null;
+				}
+
+				//
+				// handle "E operator + (E x, U y)"
+				// handle "E operator + (Y y, E x)"
+				//
+				// note that E operator + (E x, E y) is invalid
+				//
+				if (left is EnumConstant){
+					if (right is EnumConstant){
+						return null;
+					}
+					if (((EnumConstant) left).Child.Type != right.Type)
+						return null;
+
+					wrap_as = left.Type;
+				} else if (right is EnumConstant){
+					if (((EnumConstant) right).Child.Type != left.Type)
+						return null;
+					wrap_as = right.Type;
+				}
+
+				result = null;
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				try {
+					if (left is DoubleConstant){
+						double res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((DoubleConstant) left).Value +
+								       ((DoubleConstant) right).Value);
+						else
+							res = unchecked (((DoubleConstant) left).Value +
+									 ((DoubleConstant) right).Value);
+						
+						result = new DoubleConstant (res);
+					} else if (left is FloatConstant){
+						float res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((FloatConstant) left).Value +
+								       ((FloatConstant) right).Value);
+						else
+							res = unchecked (((FloatConstant) left).Value +
+									 ((FloatConstant) right).Value);
+						
+						result = new FloatConstant (res);
+					} else if (left is ULongConstant){
+						ulong res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((ULongConstant) left).Value +
+								       ((ULongConstant) right).Value);
+						else
+							res = unchecked (((ULongConstant) left).Value +
+									 ((ULongConstant) right).Value);
+
+						result = new ULongConstant (res);
+					} else if (left is LongConstant){
+						long res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((LongConstant) left).Value +
+								       ((LongConstant) right).Value);
+						else
+							res = unchecked (((LongConstant) left).Value +
+									 ((LongConstant) right).Value);
+						
+						result = new LongConstant (res);
+					} else if (left is UIntConstant){
+						uint res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((UIntConstant) left).Value +
+								       ((UIntConstant) right).Value);
+						else
+							res = unchecked (((UIntConstant) left).Value +
+									 ((UIntConstant) right).Value);
+						
+						result = new UIntConstant (res);
+					} else if (left is IntConstant){
+						int res;
+
+						if (ec.ConstantCheckState)
+							res = checked (((IntConstant) left).Value +
+								       ((IntConstant) right).Value);
+						else
+							res = unchecked (((IntConstant) left).Value +
+									 ((IntConstant) right).Value);
+
+						result = new IntConstant (res);
+					} else {
+						throw new Exception ( "Unexepected input: " + left);
+					}
+				} catch (OverflowException){
+					Error_CompileTimeOverflow (loc);
+				}
+
+				if (wrap_as != null)
+					return new EnumConstant (result, wrap_as);
+				else
+					return result;
+
+			case Binary.Operator.Subtraction:
+				//
+				// handle "E operator - (E x, U y)"
+				// handle "E operator - (Y y, E x)"
+				// handle "U operator - (E x, E y)"
+				//
+				wrap_as = null;
+				if (left is EnumConstant){
+					if (right is EnumConstant){
+						if (left.Type == right.Type)
+							wrap_as = TypeManager.EnumToUnderlying (left.Type);
+						else
+							return null;
+					}
+					if (((EnumConstant) left).Child.Type != right.Type)
+						return null;
+
+					wrap_as = left.Type;
+				} else if (right is EnumConstant){
+					if (((EnumConstant) right).Child.Type != left.Type)
+						return null;
+					wrap_as = right.Type;
+				}
+
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				try {
+					if (left is DoubleConstant){
+						double res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((DoubleConstant) left).Value -
+								       ((DoubleConstant) right).Value);
+						else
+							res = unchecked (((DoubleConstant) left).Value -
+									 ((DoubleConstant) right).Value);
+						
+						result = new DoubleConstant (res);
+					} else if (left is FloatConstant){
+						float res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((FloatConstant) left).Value -
+								       ((FloatConstant) right).Value);
+						else
+							res = unchecked (((FloatConstant) left).Value -
+									 ((FloatConstant) right).Value);
+						
+						result = new FloatConstant (res);
+					} else if (left is ULongConstant){
+						ulong res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((ULongConstant) left).Value -
+								       ((ULongConstant) right).Value);
+						else
+							res = unchecked (((ULongConstant) left).Value -
+									 ((ULongConstant) right).Value);
+						
+						result = new ULongConstant (res);
+					} else if (left is LongConstant){
+						long res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((LongConstant) left).Value -
+								       ((LongConstant) right).Value);
+						else
+							res = unchecked (((LongConstant) left).Value -
+									 ((LongConstant) right).Value);
+						
+						result = new LongConstant (res);
+					} else if (left is UIntConstant){
+						uint res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((UIntConstant) left).Value -
+								       ((UIntConstant) right).Value);
+						else
+							res = unchecked (((UIntConstant) left).Value -
+									 ((UIntConstant) right).Value);
+						
+						result = new UIntConstant (res);
+					} else if (left is IntConstant){
+						int res;
+
+						if (ec.ConstantCheckState)
+							res = checked (((IntConstant) left).Value -
+								       ((IntConstant) right).Value);
+						else
+							res = unchecked (((IntConstant) left).Value -
+									 ((IntConstant) right).Value);
+
+						result = new IntConstant (res);
+					} else {
+						throw new Exception ( "Unexepected input: " + left);
+					}
+				} catch (OverflowException){
+					Error_CompileTimeOverflow (loc);
+				}
+				if (wrap_as != null)
+					return new EnumConstant (result, wrap_as);
+				else
+					return result;
+				
+			case Binary.Operator.Multiply:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				try {
+					if (left is DoubleConstant){
+						double res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((DoubleConstant) left).Value *
+								       ((DoubleConstant) right).Value);
+						else
+							res = unchecked (((DoubleConstant) left).Value *
+									 ((DoubleConstant) right).Value);
+						
+						return new DoubleConstant (res);
+					} else if (left is FloatConstant){
+						float res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((FloatConstant) left).Value *
+								       ((FloatConstant) right).Value);
+						else
+							res = unchecked (((FloatConstant) left).Value *
+									 ((FloatConstant) right).Value);
+						
+						return new FloatConstant (res);
+					} else if (left is ULongConstant){
+						ulong res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((ULongConstant) left).Value *
+								       ((ULongConstant) right).Value);
+						else
+							res = unchecked (((ULongConstant) left).Value *
+									 ((ULongConstant) right).Value);
+						
+						return new ULongConstant (res);
+					} else if (left is LongConstant){
+						long res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((LongConstant) left).Value *
+								       ((LongConstant) right).Value);
+						else
+							res = unchecked (((LongConstant) left).Value *
+									 ((LongConstant) right).Value);
+						
+						return new LongConstant (res);
+					} else if (left is UIntConstant){
+						uint res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((UIntConstant) left).Value *
+								       ((UIntConstant) right).Value);
+						else
+							res = unchecked (((UIntConstant) left).Value *
+									 ((UIntConstant) right).Value);
+						
+						return new UIntConstant (res);
+					} else if (left is IntConstant){
+						int res;
+
+						if (ec.ConstantCheckState)
+							res = checked (((IntConstant) left).Value *
+								       ((IntConstant) right).Value);
+						else
+							res = unchecked (((IntConstant) left).Value *
+									 ((IntConstant) right).Value);
+
+						return new IntConstant (res);
+					} else {
+						throw new Exception ( "Unexepected input: " + left);
+					}
+				} catch (OverflowException){
+					Error_CompileTimeOverflow (loc);
+				}
+				break;
+
+			case Binary.Operator.IntDivision:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				try {
+					if (Mono.MonoBASIC.Parser.OptionStrict && (!(left is LongConstant) && !(left is IntConstant)) )
+					{
+						Expression.Error_CannotConvertTypeStrict (left.Type, Type.GetType("System.Int64"), loc);
+						
+						return null;
+					}
+					
+					if (left is DoubleConstant) {
+						long left_val, right_val, res;
+						left_val = (long) ((DoubleConstant) left).Value;
+						right_val = (long) ((DoubleConstant) right).Value;
+						
+						if (ec.ConstantCheckState)
+							res = checked (left_val / right_val);
+						else
+							res = unchecked (left_val / right_val);
+						
+						return new LongConstant (res);
+					} else if (left is FloatConstant) {
+						long left_val, right_val, res;
+						left_val = (long) ((FloatConstant) left).Value;
+						right_val = (long) ((FloatConstant) right).Value;
+						
+						if (ec.ConstantCheckState)
+							res = checked (left_val / right_val);
+						else
+							res = unchecked (left_val / right_val);
+						
+						return new LongConstant (res);
+					} else if (left is DecimalConstant) {
+						long left_val, right_val, res;
+						left_val = (long) ((DecimalConstant) left).Value;
+						right_val = (long) ((DecimalConstant) right).Value;
+						
+						if (ec.ConstantCheckState)
+							res = checked (left_val / right_val);
+						else
+							res = unchecked (left_val / right_val);
+						
+						return new LongConstant (res);
+					} else if (left is LongConstant) {
+						long res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((LongConstant) left).Value /
+								       ((LongConstant) right).Value);
+						else
+							res = unchecked (((LongConstant) left).Value /
+									 ((LongConstant) right).Value);
+						
+						return new LongConstant (res);
+					} else {
+						int res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((IntConstant) left).Value /
+								       ((IntConstant) right).Value);
+						else
+							res = unchecked (((IntConstant) left).Value /
+									 ((IntConstant) right).Value);
+						
+						return new IntConstant (res);
+					}
+				} catch (OverflowException){
+					Error_CompileTimeOverflow (loc);
+
+				} catch (DivideByZeroException) {
+					Report.Error (30542, loc, "Division by constant zero");
+				}
+				
+				break;
+			case Binary.Operator.Division:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				try {
+					double res;
+					
+					if (ec.ConstantCheckState)
+						res = checked (((DoubleConstant) left).Value /
+							       ((DoubleConstant) right).Value);
+					else
+						res = unchecked (((DoubleConstant) left).Value /
+								 ((DoubleConstant) right).Value);
+					
+					return new DoubleConstant (res);
+				} catch (OverflowException){
+					Error_CompileTimeOverflow (loc);
+
+				} catch (DivideByZeroException) {
+					Report.Error (30542, loc, "Division by constant zero");
+				}
+				
+				break;
+				
+			case Binary.Operator.Modulus:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				try {
+					if (left is DoubleConstant){
+						double res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((DoubleConstant) left).Value %
+								       ((DoubleConstant) right).Value);
+						else
+							res = unchecked (((DoubleConstant) left).Value %
+									 ((DoubleConstant) right).Value);
+						
+						return new DoubleConstant (res);
+					} else if (left is FloatConstant){
+						float res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((FloatConstant) left).Value %
+								       ((FloatConstant) right).Value);
+						else
+							res = unchecked (((FloatConstant) left).Value %
+									 ((FloatConstant) right).Value);
+						
+						return new FloatConstant (res);
+					} else if (left is ULongConstant){
+						ulong res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((ULongConstant) left).Value %
+								       ((ULongConstant) right).Value);
+						else
+							res = unchecked (((ULongConstant) left).Value %
+									 ((ULongConstant) right).Value);
+						
+						return new ULongConstant (res);
+					} else if (left is LongConstant){
+						long res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((LongConstant) left).Value %
+								       ((LongConstant) right).Value);
+						else
+							res = unchecked (((LongConstant) left).Value %
+									 ((LongConstant) right).Value);
+						
+						return new LongConstant (res);
+					} else if (left is UIntConstant){
+						uint res;
+						
+						if (ec.ConstantCheckState)
+							res = checked (((UIntConstant) left).Value %
+								       ((UIntConstant) right).Value);
+						else
+							res = unchecked (((UIntConstant) left).Value %
+									 ((UIntConstant) right).Value);
+						
+						return new UIntConstant (res);
+					} else if (left is IntConstant){
+						int res;
+
+						if (ec.ConstantCheckState)
+							res = checked (((IntConstant) left).Value %
+								       ((IntConstant) right).Value);
+						else
+							res = unchecked (((IntConstant) left).Value %
+									 ((IntConstant) right).Value);
+
+						return new IntConstant (res);
+					} else {
+						throw new Exception ( "Unexepected input: " + left);
+					}
+				} catch (OverflowException){
+					Error_CompileTimeOverflow (loc);
+
+				} catch (DivideByZeroException) {
+                                        Report.Error (30542, loc, "Division by constant zero");
+                                }
+				break;
+
+			case Binary.Operator.Exponentiation:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				double powVal = System.Math.Pow(((DoubleConstant) left).Value, 
+								((DoubleConstant) right).Value);
+
+				return new DoubleConstant(powVal);
+
+				//
+				// There is no overflow checking on left shift
+				//
+			case Binary.Operator.LeftShift:
+				IntConstant ic = right.ToInt (loc);
+				if (ic == null){
+					Binary.Error_OperatorCannotBeApplied (loc, "<<", lt, rt);
+					return null;
+				}
+				int lshift_val = ic.Value;
+
+				IntConstant lic;
+				if ((lic = left.ConvertToInt ()) != null)
+					return new IntConstant (lic.Value << lshift_val);
+
+				UIntConstant luic;
+				if ((luic = left.ConvertToUInt ()) != null)
+					return new UIntConstant (luic.Value << lshift_val);
+
+				LongConstant llc;
+				if ((llc = left.ConvertToLong ()) != null)
+					return new LongConstant (llc.Value << lshift_val);
+
+				ULongConstant lulc;
+				if ((lulc = left.ConvertToULong ()) != null)
+					return new ULongConstant (lulc.Value << lshift_val);
+
+				Binary.Error_OperatorCannotBeApplied (loc, "<<", lt, rt);
+				break;
+
+				//
+				// There is no overflow checking on right shift
+				//
+			case Binary.Operator.RightShift:
+				IntConstant sic = right.ToInt (loc);
+				if (sic == null){
+					Binary.Error_OperatorCannotBeApplied (loc, ">>", lt, rt);
+					return null;
+				}
+				int rshift_val = sic.Value;
+
+				IntConstant ric;
+				if ((ric = left.ConvertToInt ()) != null)
+					return new IntConstant (ric.Value >> rshift_val);
+
+				UIntConstant ruic;
+				if ((ruic = left.ConvertToUInt ()) != null)
+					return new UIntConstant (ruic.Value >> rshift_val);
+
+				LongConstant rlc;
+				if ((rlc = left.ConvertToLong ()) != null)
+					return new LongConstant (rlc.Value >> rshift_val);
+
+				ULongConstant rulc;
+				if ((rulc = left.ConvertToULong ()) != null)
+					return new ULongConstant (rulc.Value >> rshift_val);
+
+				Binary.Error_OperatorCannotBeApplied (loc, ">>", lt, rt);
+				break;
+
+			case Binary.Operator.LogicalAnd:
+				if (left is BoolConstant && right is BoolConstant){
+					return new BoolConstant (
+						((BoolConstant) left).Value &&
+						((BoolConstant) right).Value);
+				}
+				break;
+
+			case Binary.Operator.LogicalOr:
+				if (left is BoolConstant && right is BoolConstant){
+					return new BoolConstant (
+						((BoolConstant) left).Value ||
+						((BoolConstant) right).Value);
+				}
+				break;
+				
+			case Binary.Operator.Equality:
+				if (left is BoolConstant && right is BoolConstant){
+					return new BoolConstant (
+						((BoolConstant) left).Value ==
+						((BoolConstant) right).Value);
+				
+				}
+				if (left is StringConstant && right is StringConstant){
+					return new BoolConstant (
+						((StringConstant) left).Value ==
+						((StringConstant) right).Value);
+					
+				}
+				
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				bool_res = false;
+				if (left is DoubleConstant)
+					bool_res = ((DoubleConstant) left).Value ==
+						((DoubleConstant) right).Value;
+				else if (left is FloatConstant)
+					bool_res = ((FloatConstant) left).Value ==
+						((FloatConstant) right).Value;
+				else if (left is ULongConstant)
+					bool_res = ((ULongConstant) left).Value ==
+						((ULongConstant) right).Value;
+				else if (left is LongConstant)
+					bool_res = ((LongConstant) left).Value ==
+						((LongConstant) right).Value;
+				else if (left is UIntConstant)
+					bool_res = ((UIntConstant) left).Value ==
+						((UIntConstant) right).Value;
+				else if (left is IntConstant)
+					bool_res = ((IntConstant) left).Value ==
+						((IntConstant) right).Value;
+				else
+					return null;
+
+				return new BoolConstant (bool_res);
+
+			case Binary.Operator.Inequality:
+				if (left is BoolConstant && right is BoolConstant){
+					return new BoolConstant (
+						((BoolConstant) left).Value !=
+						((BoolConstant) right).Value);
+				}
+				if (left is StringConstant && right is StringConstant){
+					return new BoolConstant (
+						((StringConstant) left).Value !=
+						((StringConstant) right).Value);
+					
+				}
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				bool_res = false;
+				if (left is DoubleConstant)
+					bool_res = ((DoubleConstant) left).Value !=
+						((DoubleConstant) right).Value;
+				else if (left is FloatConstant)
+					bool_res = ((FloatConstant) left).Value !=
+						((FloatConstant) right).Value;
+				else if (left is ULongConstant)
+					bool_res = ((ULongConstant) left).Value !=
+						((ULongConstant) right).Value;
+				else if (left is LongConstant)
+					bool_res = ((LongConstant) left).Value !=
+						((LongConstant) right).Value;
+				else if (left is UIntConstant)
+					bool_res = ((UIntConstant) left).Value !=
+						((UIntConstant) right).Value;
+				else if (left is IntConstant)
+					bool_res = ((IntConstant) left).Value !=
+						((IntConstant) right).Value;
+				else
+					return null;
+
+				return new BoolConstant (bool_res);
+
+			case Binary.Operator.LessThan:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				bool_res = false;
+				if (left is DoubleConstant)
+					bool_res = ((DoubleConstant) left).Value <
+						((DoubleConstant) right).Value;
+				else if (left is FloatConstant)
+					bool_res = ((FloatConstant) left).Value <
+						((FloatConstant) right).Value;
+				else if (left is ULongConstant)
+					bool_res = ((ULongConstant) left).Value <
+						((ULongConstant) right).Value;
+				else if (left is LongConstant)
+					bool_res = ((LongConstant) left).Value <
+						((LongConstant) right).Value;
+				else if (left is UIntConstant)
+					bool_res = ((UIntConstant) left).Value <
+						((UIntConstant) right).Value;
+				else if (left is IntConstant)
+					bool_res = ((IntConstant) left).Value <
+						((IntConstant) right).Value;
+				else
+					return null;
+
+				return new BoolConstant (bool_res);
+				
+			case Binary.Operator.GreaterThan:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				bool_res = false;
+				if (left is DoubleConstant)
+					bool_res = ((DoubleConstant) left).Value >
+						((DoubleConstant) right).Value;
+				else if (left is FloatConstant)
+					bool_res = ((FloatConstant) left).Value >
+						((FloatConstant) right).Value;
+				else if (left is ULongConstant)
+					bool_res = ((ULongConstant) left).Value >
+						((ULongConstant) right).Value;
+				else if (left is LongConstant)
+					bool_res = ((LongConstant) left).Value >
+						((LongConstant) right).Value;
+				else if (left is UIntConstant)
+					bool_res = ((UIntConstant) left).Value >
+						((UIntConstant) right).Value;
+				else if (left is IntConstant)
+					bool_res = ((IntConstant) left).Value >
+						((IntConstant) right).Value;
+				else
+					return null;
+
+				return new BoolConstant (bool_res);
+
+			case Binary.Operator.GreaterThanOrEqual:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				bool_res = false;
+				if (left is DoubleConstant)
+					bool_res = ((DoubleConstant) left).Value >=
+						((DoubleConstant) right).Value;
+				else if (left is FloatConstant)
+					bool_res = ((FloatConstant) left).Value >=
+						((FloatConstant) right).Value;
+				else if (left is ULongConstant)
+					bool_res = ((ULongConstant) left).Value >=
+						((ULongConstant) right).Value;
+				else if (left is LongConstant)
+					bool_res = ((LongConstant) left).Value >=
+						((LongConstant) right).Value;
+				else if (left is UIntConstant)
+					bool_res = ((UIntConstant) left).Value >=
+						((UIntConstant) right).Value;
+				else if (left is IntConstant)
+					bool_res = ((IntConstant) left).Value >=
+						((IntConstant) right).Value;
+				else
+					return null;
+
+				return new BoolConstant (bool_res);
+
+			case Binary.Operator.LessThanOrEqual:
+				DoConstantNumericPromotions (ec, oper, ref left, ref right, loc);
+				if (left == null || right == null)
+					return null;
+
+				bool_res = false;
+				if (left is DoubleConstant)
+					bool_res = ((DoubleConstant) left).Value <=
+						((DoubleConstant) right).Value;
+				else if (left is FloatConstant)
+					bool_res = ((FloatConstant) left).Value <=
+						((FloatConstant) right).Value;
+				else if (left is ULongConstant)
+					bool_res = ((ULongConstant) left).Value <=
+						((ULongConstant) right).Value;
+				else if (left is LongConstant)
+					bool_res = ((LongConstant) left).Value <=
+						((LongConstant) right).Value;
+				else if (left is UIntConstant)
+					bool_res = ((UIntConstant) left).Value <=
+						((UIntConstant) right).Value;
+				else if (left is IntConstant)
+					bool_res = ((IntConstant) left).Value <=
+						((IntConstant) right).Value;
+				else
+					return null;
+
+				return new BoolConstant (bool_res);
+			}
+					
+			return null;
+		}
+	}
+}
diff --git a/dead/mbas/class.cs b/dead/mbas/class.cs
new file mode 100644
index 00000000..535d3d5a
--- /dev/null
+++ b/dead/mbas/class.cs
@@ -0,0 +1,4669 @@
+
+//
+// class.cs: Class and Struct handlers
+//
+// Authors: Miguel de Icaza (miguel@gnu.org)
+//          Martin Baulig (martin@gnome.org)
+//			Anirban Bhattacharjee (banirban@novell.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001, 2002 Ximian, Inc (http://www.ximian.com)
+//
+//
+//  2002-10-11  Miguel de Icaza  <miguel@ximian.com>
+//
+//	* class.cs: Following the comment from 2002-09-26 to AddMethod, I
+//	have fixed a remaining problem: not every AddXXXX was adding a
+//	fully qualified name.  
+//
+//	Now everyone registers a fully qualified name in the DeclSpace as
+//	being defined instead of the partial name.  
+//
+//	Downsides: we are slower than we need to be due to the excess
+//	copies and the names being registered this way.  
+//
+//	The reason for this is that we currently depend (on the corlib
+//	bootstrap for instance) that types are fully qualified, because
+//	we dump all the types in the namespace, and we should really have
+//	types inserted into the proper namespace, so we can only store the
+//	basenames in the defined_names array.
+//
+//
+#define CACHE
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.SymbolStore;
+
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///   This is the base class for structs and classes.  
+	/// </summary>
+	public class TypeContainer : DeclSpace, IMemberContainer {
+		// Holds a list of classes and structures
+		ArrayList types;
+
+		// Holds the list of properties
+		ArrayList properties;
+
+		// Holds the list of enumerations
+		ArrayList enums;
+
+		// Holds the list of delegates
+		ArrayList delegates;
+		
+		// Holds the list of constructors
+		ArrayList instance_constructors;
+
+		// Holds the list of fields
+		ArrayList fields;
+
+		// Holds a list of fields that have initializers
+		ArrayList initialized_fields;
+
+		// Holds a list of static fields that have initializers
+		ArrayList initialized_static_fields;
+
+		// Holds the list of constants
+		ArrayList constants;
+
+		// Holds the list of
+		ArrayList interfaces;
+
+		// Holds order in which interfaces must be closed
+		ArrayList interface_order;
+		
+		// Holds the methods.
+		ArrayList methods;
+
+		// Holds the events
+		ArrayList events;
+
+		// Holds AddHandlers statements for events
+		ArrayList handlers;
+
+		// The emit context for toplevel objects.
+		EmitContext ec;
+
+		//
+		// Pointers to the default constructor and the default static constructor
+		//
+		Constructor default_constructor;
+		Constructor default_static_constructor;
+
+		//
+		// Whether we have seen a static constructor for this class or not
+		//
+		bool have_static_constructor = false;
+
+		//
+		// Whether we have at least one non-static field
+		//
+		bool have_nonstatic_fields = false;
+		
+		//
+		// This one is computed after we can distinguish interfaces
+		// from classes from the arraylist `type_bases' 
+		//
+		string     base_class_name;
+		public Type base_class_type;
+		
+		ArrayList type_bases;
+
+		// Information in the case we are an attribute type
+
+		AttributeUsageAttribute attribute_usage = new AttributeUsageAttribute (AttributeTargets.All);
+
+		public AttributeUsageAttribute AttributeUsage {
+			get {
+				return attribute_usage;
+			}
+
+			set {
+				attribute_usage = value;
+			}				
+		}
+
+		// The interfaces we implement.
+		Type [] ifaces;
+
+		// The parent member container and our member cache
+		IMemberContainer parent_container;
+		MemberCache member_cache;
+		
+		//
+		// The indexer name for this class
+		//
+		public string DefaultPropName;
+
+		public TypeContainer (TypeContainer parent, string name, Attributes attrs, Location l)
+			: base (parent, name, attrs, l)
+		{
+			types = new ArrayList ();
+			
+			base_class_name = null;
+
+			/* string n;
+			  
+			if (parent == null)
+				n = "";
+			else
+				n = parent.Name;
+
+			Console.WriteLine ("New class " + name + " inside " + n);*/
+		}
+
+		public AdditionResult AddConstant (Const constant)
+		{
+			AdditionResult res;
+			string basename = constant.Name;
+
+			if ((res = IsValid (basename)) != AdditionResult.Success)
+				return res;
+			
+			if (constants == null)
+				constants = new ArrayList ();
+
+			constants.Add (constant);
+			DefineName (Name + "." + basename, constant);
+
+			return AdditionResult.Success;
+		}
+
+		public AdditionResult AddEnum (Mono.MonoBASIC.Enum e)
+		{
+			AdditionResult res;
+
+			if ((res = IsValid (e.Basename)) != AdditionResult.Success)
+				return res;
+
+			if (enums == null)
+				enums = new ArrayList ();
+
+			enums.Add (e);
+			DefineName (e.Name, e);
+
+			return AdditionResult.Success;
+		}
+		
+		public AdditionResult AddClass (Class c)
+		{
+			AdditionResult res;
+			
+			if ((res = IsValid (c.Basename)) != AdditionResult.Success)
+				return res;
+				
+	
+					
+			DefineName (c.Name, c);
+			types.Add (c);
+			
+			// FIXME: Do we really need to explicitly add an empty default static constructor?
+			// Apparently we don't
+/*			if (c.default_static_constructor == null) 
+			{
+				bool isModule = c is Mono.MonoBASIC.Module;
+				Constructor dc = new Constructor ("New", Parameters.EmptyReadOnlyParameters, null, c.Location);
+				dc.ModFlags = isModule ? Modifiers.PUBLIC | Modifiers.STATIC : Modifiers.PUBLIC;				
+				c.AddConstructor (dc);		
+			} 
+*/
+			//--------------------------------------------------------------				
+				
+			return AdditionResult.Success;
+		}
+
+		public AdditionResult AddStruct (Struct s)
+		{
+			AdditionResult res;
+			
+			if ((res = IsValid (s.Basename)) != AdditionResult.Success)
+				return res;
+
+			DefineName (s.Name, s);
+			types.Add (s);
+
+			return AdditionResult.Success;
+		}
+
+		public AdditionResult AddDelegate (Delegate d)
+		{
+			AdditionResult res;
+
+			if ((res = IsValid (d.Basename)) != AdditionResult.Success)
+				return res;
+
+			if (delegates == null)
+				delegates = new ArrayList ();
+			
+			DefineName (d.Name, d);
+			delegates.Add (d);
+
+			return AdditionResult.Success;
+		}
+
+		public AdditionResult AddMethod (Method method)
+		{
+			string basename = method.Name;
+			string fullname = Name + "." + basename;
+
+			Object value = defined_names [fullname];
+
+			if (value != null && (!(value is Method)))
+				return AdditionResult.NameExists;
+
+			if (methods == null)
+				methods = new ArrayList ();
+
+			if (method.Name.IndexOf (".") != -1)
+				methods.Insert (0, method);
+			else 
+				methods.Add (method);
+			
+			if (value == null)
+				DefineName (fullname, method);
+
+			return AdditionResult.Success;
+		}
+
+		public AdditionResult AddConstructor (Constructor c)
+		{
+			if (c.Name != "New") 
+				return AdditionResult.NotAConstructor;
+
+			bool is_static = (c.ModFlags & Modifiers.STATIC) != 0;
+
+			if (is_static){
+				have_static_constructor = true;
+				if (default_static_constructor != null){
+					Console.WriteLine ("I have a static constructor already");
+					Console.WriteLine ("   " + default_static_constructor);
+					return AdditionResult.MethodExists;
+				}
+
+				default_static_constructor = c;
+			} else {
+				if (c.IsDefault ()){
+					/*if (default_constructor != null)
+						return AdditionResult.MethodExists;*/
+					default_constructor = c;
+				}
+				
+				if (instance_constructors == null)
+					instance_constructors = new ArrayList ();
+				
+				instance_constructors.Add (c);
+			}
+			
+			return AdditionResult.Success;
+		}
+		
+		public AdditionResult AddInterface (Interface iface)
+		{
+			AdditionResult res;
+
+			if ((res = IsValid (iface.Basename)) != AdditionResult.Success)
+				return res;
+			
+			if (interfaces == null)
+				interfaces = new ArrayList ();
+			interfaces.Add (iface);
+			DefineName (iface.Name, iface);
+			
+			return AdditionResult.Success;
+		}
+
+		public AdditionResult AddField (Field field)
+		{
+			AdditionResult res;
+			string basename = field.Name;
+
+			if ((res = IsValid (basename)) != AdditionResult.Success)
+				return res;
+			
+			if (fields == null)
+				fields = new ArrayList ();
+			
+			fields.Add (field);
+			
+			if (field.HasInitializer){	
+				if ((field.ModFlags & Modifiers.STATIC) != 0) {
+					if (initialized_static_fields == null)
+						initialized_static_fields = new ArrayList ();
+
+					initialized_static_fields.Add (field);
+
+					//
+					// We have not seen a static constructor,
+					// but we will provide static initialization of fields
+					//
+					have_static_constructor = true;
+				} else {
+					if (initialized_fields == null)
+						initialized_fields = new ArrayList ();
+				
+					initialized_fields.Add (field);
+				}
+			}
+
+			if ((field.ModFlags & Modifiers.STATIC) == 0)
+				have_nonstatic_fields = true;
+
+			DefineName (Name + "." + basename, field);
+			return AdditionResult.Success;
+		}
+
+		public AdditionResult AddProperty (Property prop)
+		{
+			AdditionResult res;
+			string basename = prop.Name;
+
+			string fullname = Name + "." + basename;
+
+			Object value = defined_names [fullname];
+
+			if (value != null && (!(value is Property)))
+				return AdditionResult.NameExists;
+
+			if ((res = IsValid (basename)) != AdditionResult.Success)
+				return res;
+
+			if (properties == null)
+				properties = new ArrayList ();
+
+			if (prop.Name.IndexOf (".") != -1)
+				properties.Insert (0, prop);
+			else
+				properties.Add (prop);
+
+			if (value == null)
+				DefineName (Name + "." + basename, prop);
+
+			return AdditionResult.Success;
+		}
+
+		public AdditionResult AddEvent (Event e)
+		{
+			AdditionResult res;
+			string basename = e.Name;
+
+			if ((res = IsValid (basename)) != AdditionResult.Success)
+				return res;
+
+			if (events == null)
+				events = new ArrayList ();
+			
+			events.Add (e);
+			DefineName (Name + "." + basename, e);
+
+			return AdditionResult.Success;
+		}
+
+		public AdditionResult AddEventHandler (Statement stmt)
+		{
+			if (handlers == null)
+				handlers = new ArrayList ();
+
+			handlers.Add (stmt);
+			return AdditionResult.Success;
+		}
+
+		public void RegisterOrder (Interface iface)
+		{
+			if (interface_order == null)
+				interface_order = new ArrayList ();
+
+			interface_order.Add (iface);
+		}
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+		{
+			base.ApplyAttributeBuilder (a, cb);
+		} 
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				throw new NotSupportedException ();
+			}
+		}
+
+		public ArrayList Types {
+			get {
+				return types;
+			}
+		}
+
+		public ArrayList Methods {
+			get {
+				return methods;
+			}
+		}
+
+		public ArrayList Constants {
+			get {
+				return constants;
+			}
+		}
+
+		public ArrayList Interfaces {
+			get {
+				return interfaces;
+			}
+		}
+		
+		public string Base {
+			get {
+				return base_class_name;
+			}
+		}
+		
+		public ArrayList Bases {
+			get {
+				return type_bases;
+			}
+
+			set {
+				type_bases = value;
+			}
+		}
+
+		public ArrayList Fields {
+			get {
+				return fields;
+			}
+
+			set {
+				fields = value;
+			}
+		}
+
+		public ArrayList InstanceConstructors {
+			get {
+				return instance_constructors;
+			}
+		}
+
+		public ArrayList Properties {
+			get {
+				return properties;
+			}
+		}
+
+		public ArrayList Events {
+			get {
+				return events;
+			}
+		}
+		
+		public ArrayList Enums {
+			get {
+				return enums;
+			}
+		}
+
+		public ArrayList Delegates {
+			get {
+				return delegates;
+			}
+		}
+		
+		public bool HaveStaticConstructor {
+			get {
+				return have_static_constructor;
+			}
+		}
+		
+		public virtual TypeAttributes TypeAttr {
+			get {
+				return Modifiers.TypeAttr (ModFlags, this);
+			}
+		}
+
+		public ArrayList EventHandlers {
+			get {
+				return handlers;
+			}
+		}
+
+		//
+		// Emits the instance field initializers
+		//
+		public bool EmitFieldInitializers (EmitContext ec)
+		{
+			ArrayList fields;
+			//ILGenerator ig = ec.ig;
+			Expression instance_expr;
+			
+			if (ec.IsStatic){
+				fields = initialized_static_fields;
+				instance_expr = null;
+			} else {
+				fields = initialized_fields;
+				instance_expr = new This (Location.Null).Resolve (ec);
+			}
+
+			if (fields == null)
+				return true;
+
+			foreach (Field f in fields){
+				Expression e = f.GetInitializerExpression (ec);
+				if (e == null)
+					return false;
+
+				Location l = f.Location;
+				FieldExpr fe = new FieldExpr (f.FieldBuilder, l);
+				fe.InstanceExpression = instance_expr;
+				Expression a = new Assign (fe, e, l);
+
+				a = a.Resolve (ec);
+				if (a == null)
+					return false;
+
+				if (a is ExpressionStatement)
+					((ExpressionStatement) a).EmitStatement (ec);
+				else {
+					throw new Exception ("Assign.Resolve returned a non ExpressionStatement");
+				}
+			}
+
+			return true;
+		}
+		
+		//
+		// Defines the default constructors
+		//
+		void DefineDefaultConstructor (bool is_static)
+		{
+			Constructor c;
+			int mods = 0;
+
+			c = new Constructor ("New", Parameters.EmptyReadOnlyParameters,
+					     null,
+					     Location.Null);
+			
+			if (is_static) {
+				mods = Modifiers.STATIC;
+				c.ModFlags = mods;
+			}
+			else 
+				c.Initializer = new ConstructorBaseInitializer (
+					null, Parameters.EmptyReadOnlyParameters,
+					Location.Null);
+
+			AddConstructor (c);
+			
+			c.Block = new Block (null);
+			
+		}
+
+		public void ReportStructInitializedInstanceError ()
+		{
+			string n = TypeBuilder.FullName;
+			
+			foreach (Field f in initialized_fields){
+				Report.Error (
+					31049, Location,
+					"`" + n + "." + f.Name + "': can not have " +
+					"instance field initializers in structs");
+			}
+		}
+
+		/// <remarks>
+		///  The pending methods that need to be implemented (interfaces or abstract methods)
+		/// </remarks>
+		public PendingImplementation Pending;
+
+		/// <summary>
+		///   This function computes the Base class and also the
+		///   list of interfaces that the class or struct @c implements.
+		///   
+		///   The return value is an array (might be null) of
+		///   interfaces implemented (as Types).
+		///   
+		///   The @parent argument is set to the parent object or null
+		///   if this is `System.Object'. 
+		/// </summary>
+		Type [] GetClassBases (bool is_class, out Type parent, out bool error)
+		{
+			ArrayList bases = Bases;
+			int count;
+			int start, j, i;
+
+			error = false;
+
+			if (is_class)
+				parent = null;
+			else
+				parent = TypeManager.value_type;
+
+			if (bases == null){
+				if (is_class){
+					if (RootContext.StdLib)
+						parent = TypeManager.object_type;
+					else if (Name != "System.Object")
+						parent = TypeManager.object_type;
+				} else {
+					//
+					// If we are compiling our runtime,
+					// and we are defining ValueType, then our
+					// parent is `System.Object'.
+					//
+					if (!RootContext.StdLib && Name == "System.ValueType")
+						parent = TypeManager.object_type;
+				}
+
+				return null;
+			}
+
+			//
+			// Bases should be null if there are no bases at all
+			//
+			count = bases.Count;
+
+			if (is_class && (!(this is Interface))){
+				Expression name = (Expression) bases [0];
+				name = ResolveTypeExpr (name, false, Location);
+
+				if (name == null){
+					error = true;
+					return null;
+				}
+
+				Type first = name.Type;
+
+				if (first.IsClass){
+					parent = first;
+					start = 1;
+				} else {
+					parent = TypeManager.object_type;
+					start = 0;
+				}
+
+				if (parent.IsSealed )
+					Report.Error (30299, Location,
+								"Class " + Name + " cannot inherit " +
+								"'NotInheritable' class " + TypeManager.MonoBASIC_Name (parent));
+					
+				if (!AsAccessible (parent, ModFlags))
+					 Report.Error (30389, Location,
+						      "Inconsistent accessibility: base class `" +
+						      TypeManager.MonoBASIC_Name (parent) + "' is less " +
+						      "accessible than class `" +
+						      Name + "'");
+
+			} else {
+				start = 0;
+			}
+
+			Type [] ifaces = new Type [count-start];
+			
+			for (i = start, j = 0; i < count; i++, j++){
+				Expression name = (Expression) bases [i];
+				Expression resolved = ResolveTypeExpr (name, false, Location);
+				bases [i] = resolved;
+				Type t = resolved.Type;
+				if (t == null){
+					error = true;
+					return null;
+				}
+
+				if (is_class == false && !t.IsInterface){
+					Report.Error (527, Location, "In Struct `" + Name + "', type `"+
+						      name +"' is not an interface");
+					error = true;
+					return null;
+				}
+			
+				if (t.IsSealed) {
+					if (t.IsValueType)
+						Report.Error (30258, Location, "class `"+ Name +
+							"': a class can not inherit from a struct/enum");
+							
+					/*Report.Error (509, Location, "class `"+ Name +
+						      "': Cannot inherit from sealed class `"+
+						      bases [i]);*/
+					error = true;
+					return null;
+				}
+
+				if (t.IsClass) {
+					if (parent != null){
+						Report.Error (30121, Location, Name + ": A class cannot inherit " +
+							"more than one class");
+						error = true;
+						return null;
+					}
+				}
+
+				for (int x = 0; x < j; x++) {
+					if (t == ifaces [x]) {
+						Report.Error (528,Location, "`" + name + "' is already listed in interface list");
+						error = true;
+						return null;
+					}
+				}
+
+				ifaces [j] = t;
+			}
+
+			return ifaces;
+		}
+		
+		//
+		// Defines the type in the appropriate ModuleBuilder or TypeBuilder.
+		//
+		public override TypeBuilder DefineType ()
+		{
+			bool error;
+			bool is_class;
+
+			if (TypeBuilder != null)
+				return TypeBuilder;
+			
+			if (InTransit)
+				return null;
+			
+			InTransit = true;
+
+			if (this is Class)
+				is_class = true;
+			else
+				is_class = false;
+
+			ec = new EmitContext (this, Mono.MonoBASIC.Location.Null, null, null, ModFlags);
+
+			if (((ModFlags & Modifiers.ABSTRACT ) != 0) && 
+						((ModFlags & Modifiers.SEALED) != 0)){
+				Report.Error (31408, Location,
+					"Class declared as 'MustInherit' cannot be declared as 'NotInheritable'");
+			}
+			
+			ifaces = GetClassBases (is_class, out base_class_type, out error); 
+			if (error)
+				return null;
+
+			if (this is Interface)
+				base_class_type = null;
+
+			if (is_class && base_class_type != null){
+				if (base_class_type == TypeManager.enum_type ||
+				    (base_class_type == TypeManager.value_type && RootContext.StdLib) ||
+				    base_class_type == TypeManager.delegate_type ||
+				    base_class_type == TypeManager.array_type){
+					Report.Error (
+						644, Location, "`" + Name + "' cannot inherit from " +
+						"special class `" + TypeManager.MonoBASIC_Name (base_class_type) + "'");
+					return null;
+				}
+			}
+
+			if (!is_class && TypeManager.value_type == null)
+				throw new Exception ();
+
+			if (is_class  && Parent.Parent == null && (!(this is Interface))) 
+			{
+				if ((ModFlags & Modifiers.PRIVATE) != 0)
+					Report.Error (31089, Location,
+						"Only internal classes can be declared as 'Private'");
+
+				if ((ModFlags & Modifiers.PROTECTED) != 0)
+					Report.Error (31047, Location,
+						"Only internal classes can be declared as 'Protected'");
+			}
+
+			if ((Parent is Module) && ((ModFlags & Modifiers.PROTECTED) != 0))
+				Report.Error (30735, Location,
+					"'Type' inside a 'Module' can not be " +
+					"declared as 'Protected'");
+
+			if ((Parent is Struct) && ((ModFlags & Modifiers.PROTECTED) != 0))
+				Report.Error (30435, Location,
+					"'Type' inside a 'Structure' can not be " +
+					"declared as 'Protected'");
+			
+			TypeAttributes type_attributes = TypeAttr;
+
+			if (IsTopLevel){
+				ModuleBuilder builder = CodeGen.ModuleBuilder;
+				TypeBuilder = builder.DefineType (
+					Name, type_attributes, base_class_type, ifaces);
+				
+			} else {
+				TypeBuilder builder = Parent.TypeBuilder;
+				TypeBuilder = builder.DefineNestedType (
+					Basename, type_attributes, base_class_type, ifaces);
+			}
+				
+			if (!is_class)
+			{
+				// structure must contain atleast one member variable
+				if(!have_nonstatic_fields){
+					Report.Error (
+						30281, Location, "Structure `" + Name + "' do not " +
+						"contain any member Variable");
+
+					/*TypeBuilder.DefineField ("$PRIVATE$", TypeManager.byte_type,
+								 FieldAttributes.Private);*/
+				}
+
+				// add interfaces that were not added at type creation (weird API issue)
+				if (!have_nonstatic_fields && (ifaces != null)) {
+					foreach (Type i in ifaces)
+						TypeBuilder.AddInterfaceImplementation (i);
+				}
+			}
+
+			
+			//
+			// Finish the setup for the EmitContext
+			//
+			ec.ContainerType = TypeBuilder;
+
+			TypeManager.AddUserType (Name, TypeBuilder, this, ifaces);
+
+			if ((base_class_type != null) &&
+			    (base_class_type == TypeManager.attribute_type ||
+			     base_class_type.IsSubclassOf (TypeManager.attribute_type))) {
+				RootContext.RegisterAttribute (this);
+			}
+		       	else
+			{
+				if ( this is Interface)
+					RootContext.RegisterOrder ((Interface) this); 
+				else	
+					RootContext.RegisterOrder (this); 
+			}
+				
+			if (Interfaces != null) {
+				foreach (Interface iface in Interfaces)
+					iface.DefineType ();
+			}
+			
+			if (Types != null) {
+				foreach (TypeContainer tc in Types)
+					tc.DefineType ();
+			}
+
+			if (Delegates != null) {
+				foreach (Delegate d in Delegates)
+					d.DefineType ();
+			}
+
+			if (Enums != null) {
+				foreach (Enum en in Enums)
+					en.DefineType ();
+			}
+
+			InTransit = false;
+			return TypeBuilder;
+		}
+
+
+		/// <summary>
+		///   Defines the MemberCore objects that are in the `list' Arraylist
+		///
+		///   The `defined_names' array contains a list of members defined in
+		///   a base class
+		/// </summary>
+		static ArrayList remove_list = new ArrayList ();
+		void DefineMembers (ArrayList list, MemberInfo [] defined_names)
+		{
+			int idx;
+
+			// if one of the overloaded method is having
+			// Shadows or Overloads modifier all other should 
+			// have the same modifier
+			Hashtable members = new Hashtable();
+			int modval;
+			foreach (MemberCore mc in list)
+			{
+				modval = 0;
+				if(members[mc.Name] == null)
+				{
+					foreach (MemberCore m in list)
+					{
+						if(m.Name == mc.Name) 
+						{
+							if ((m.ModFlags & Modifiers.SHADOWS) != 0)
+							{
+								modval = Modifiers.SHADOWS;
+								break;
+							}
+							else if((m.ModFlags & Modifiers.NEW) != 0)
+							{
+								modval = Modifiers.NEW;
+							}
+						}
+					}
+					members.Add(mc.Name, modval);
+				}
+				
+				modval = (int)members[mc.Name];
+				if(modval != 0)
+				{
+					if(((modval & Modifiers.SHADOWS) != 0) && ((mc.ModFlags & Modifiers.SHADOWS) == 0))
+						Report.Error (
+							30695, mc.Location,
+							"Function '" + mc.Name + "': must be declared 'Shadows' " +
+							"because another '" + mc.Name + "' declared 'Shadows'");
+					else if(((modval & Modifiers.NEW) != 0) && ((mc.ModFlags & Modifiers.NEW) == 0))
+						Report.Error (
+							31409, mc.Location,
+							"Function '" + mc.Name + "': must be declared 'Overloads' " +
+							"because another '" + mc.Name + "' declared 'Overloads'");
+				}
+			}
+			members.Clear ();
+			remove_list.Clear ();
+
+			foreach (MemberCore mc in list){
+				if (!mc.Define (this)){
+					remove_list.Add (mc);
+					continue;
+				}
+						
+				if (defined_names == null)
+					continue;
+
+				idx = Array.BinarySearch (defined_names, mc.Name, mif_compare);
+				if (idx < 0){
+					if (RootContext.WarningLevel >= 4){
+						if ((mc.ModFlags & Modifiers.NEW) != 0)
+							Warning_KewywordNewNotRequired (mc.Location, mc);
+						if ((mc.ModFlags & Modifiers.SHADOWS) != 0)
+							Warning_KewywordShadowsNotRequired (mc.Location, mc);
+					}
+					continue;
+				}
+
+				MemberInfo match = defined_names [idx];
+
+				if (match is PropertyInfo && ((mc.ModFlags & Modifiers.OVERRIDE) != 0))
+					continue;
+
+				//
+				// If we are both methods, let the method resolution emit warnings
+				//
+				if (match is MethodBase && mc is MethodCore)
+					continue; 
+				
+				if (((mc.ModFlags & Modifiers.SHADOWS) == 0) && idx > 0)
+					Warning_KeywordShadowsRequired (mc.Location, defined_names [idx]);
+				
+			}
+			
+			foreach (object o in remove_list)
+				list.Remove (o);
+			
+			remove_list.Clear ();
+		}
+
+		static void Error_KeywordNotAllowed (Location loc)
+		{
+			Report.Error (1530, loc, "Keyword new not allowed for namespace elements");
+		}
+
+		/// <summary>
+		///   Populates our TypeBuilder with fields and methods
+		/// </summary>
+		public override bool DefineMembers (TypeContainer parent)
+		{
+			MemberInfo [] defined_names = null;
+
+			if (interface_order != null){
+				foreach (Interface iface in interface_order)
+					if ((iface.ModFlags & Modifiers.NEW) == 0)
+						iface.DefineMembers (this);
+					else
+						Error_KeywordNotAllowed (iface.Location);
+			}
+
+			if (RootContext.WarningLevel > 1){
+				Type ptype;
+
+				//
+				// This code throws an exception in the comparer
+				// I guess the string is not an object?
+				//
+				ptype = TypeBuilder.BaseType;
+				if (ptype != null){
+					defined_names = (MemberInfo []) FindMembers (
+						ptype, MemberTypes.All & ~MemberTypes.Constructor,
+						BindingFlags.Public | BindingFlags.Instance |
+						BindingFlags.Static, null, null);
+
+					Array.Sort (defined_names, mif_compare);
+				}
+			}
+			
+			if (constants != null)
+				DefineMembers (constants, defined_names);
+
+			if (fields != null)
+				DefineMembers (fields, defined_names);
+
+			if (this is Class && (!(this is Interface))){
+				if (instance_constructors == null){
+					if (default_constructor == null) 
+						DefineDefaultConstructor (false);
+				}
+
+				if (initialized_static_fields != null &&
+				    default_static_constructor == null)
+					DefineDefaultConstructor (true);
+			}
+
+			if (this is Struct){
+				//
+				// Structs can not have initialized instance
+				// fields
+				//
+				if (initialized_static_fields != null &&
+				    default_static_constructor == null)
+					DefineDefaultConstructor (true);
+
+				if (initialized_fields != null)
+					ReportStructInitializedInstanceError ();
+			}
+
+			if (!(this is Interface))
+				Pending = PendingImplementation.GetPendingImplementations (this);
+			//
+			// Constructors are not in the defined_names array
+			//
+			if (instance_constructors != null)
+				DefineMembers (instance_constructors, null);
+		
+			if (default_static_constructor != null)
+				default_static_constructor.Define (this);
+			
+			if (methods != null)
+				DefineMembers (methods, defined_names);
+
+			if (properties != null)
+				DefineMembers (properties, defined_names);
+
+			if (events != null)
+				DefineMembers (events, defined_names);
+
+			if (enums != null)
+				DefineMembers (enums, defined_names);
+			
+			if (delegates != null)
+				DefineMembers (delegates, defined_names);
+
+#if CACHE
+			if (TypeBuilder.BaseType != null)
+				parent_container = TypeManager.LookupMemberContainer (TypeBuilder.BaseType);
+
+			member_cache = new MemberCache (this);
+#endif
+
+			return true;
+		}
+
+		public override bool Define (TypeContainer parent)
+		{
+			if (interface_order != null){
+				foreach (Interface iface in interface_order)
+					if ((iface.ModFlags & Modifiers.NEW) == 0)
+						iface.Define (this);
+			}
+
+			return true;
+		}
+
+		/// <summary>
+		///   This function is based by a delegate to the FindMembers routine
+		/// </summary>
+		static bool AlwaysAccept (MemberInfo m, object filterCriteria)
+		{
+			return true;
+		}
+
+		/// <summary>
+		///   This filter is used by FindMembers, and we just keep
+		///   a global for the filter to `AlwaysAccept'
+		/// </summary>
+		static MemberFilter accepting_filter;
+
+		
+		/// <summary>
+		///   A member comparission method based on name only
+		/// </summary>
+		static IComparer mif_compare;
+
+		static TypeContainer ()
+		{
+			accepting_filter = new MemberFilter (AlwaysAccept);
+			mif_compare = new MemberInfoCompare ();
+		}
+		
+		/// <summary>
+		///   This method returns the members of this type just like Type.FindMembers would
+		///   Only, we need to use this for types which are _being_ defined because MS' 
+		///   implementation can't take care of that.
+		/// </summary>
+		//
+		// FIXME: return an empty static array instead of null, that cleans up
+		// some code and is consistent with some coding conventions I just found
+		// out existed ;-)
+		//
+		//
+		// Notice that in various cases we check if our field is non-null,
+		// something that would normally mean that there was a bug elsewhere.
+		//
+		// The problem happens while we are defining p-invoke methods, as those
+		// will trigger a FindMembers, but this happens before things are defined
+		//
+		// Since the whole process is a no-op, it is fine to check for null here.
+		//
+		public override MemberList FindMembers (MemberTypes mt, BindingFlags bf,
+							MemberFilter filter, object criteria)
+		{
+			ArrayList members = new ArrayList ();
+
+			int modflags = 0;
+			if ((bf & BindingFlags.Public) != 0)
+				modflags |= Modifiers.PUBLIC | Modifiers.PROTECTED |
+					Modifiers.INTERNAL;
+			if ((bf & BindingFlags.NonPublic) != 0)
+				modflags |= Modifiers.PRIVATE;
+
+			int static_mask = 0, static_flags = 0;
+			switch (bf & (BindingFlags.Static | BindingFlags.Instance)) {
+			case BindingFlags.Static:
+				static_mask = static_flags = Modifiers.STATIC;
+				break;
+
+			case BindingFlags.Instance:
+				static_mask = Modifiers.STATIC;
+				static_flags = 0;
+				break;
+
+			default:
+				static_mask = static_flags = 0;
+				break;
+			}
+
+			Timer.StartTimer (TimerType.TcFindMembers);
+
+			if (filter == null)
+				filter = accepting_filter; 
+
+			if ((mt & MemberTypes.Field) != 0) {
+				if (fields != null) {
+					foreach (Field f in fields) {
+						if ((f.ModFlags & modflags) == 0)
+							continue;
+						if ((f.ModFlags & static_mask) != static_flags)
+							continue;
+
+						FieldBuilder fb = f.FieldBuilder;
+						if (fb != null && filter (fb, criteria) == true)
+							members.Add (fb);
+					}
+				}
+
+				if (constants != null) {
+					foreach (Const con in constants) {
+						if ((con.ModFlags & modflags) == 0)
+							continue;
+						if ((con.ModFlags & static_mask) != static_flags)
+							continue;
+
+						FieldBuilder fb = con.FieldBuilder;
+						if (fb != null && filter (fb, criteria) == true)
+							members.Add (fb);
+					}
+				}
+			}
+
+			if ((mt & MemberTypes.Method) != 0) {
+				if (methods != null) {
+					foreach (Method m in methods) {
+						if ((m.ModFlags & modflags) == 0)
+							continue;
+						if ((m.ModFlags & static_mask) != static_flags)
+							continue;
+						
+						MethodBuilder mb = m.MethodBuilder;
+
+						if (mb != null && filter (mb, criteria) == true)
+							members.Add (mb);
+					}
+				}
+
+				if (properties != null){
+					foreach (Property p in properties){
+						if ((p.ModFlags & modflags) == 0)
+							continue;
+						if ((p.ModFlags & static_mask) != static_flags)
+							continue;
+						
+						MethodBuilder b;
+
+						b = p.GetBuilder;
+						if (b != null && filter (b, criteria) == true)
+							members.Add (b);
+
+						b = p.SetBuilder;
+						if (b != null && filter (b, criteria) == true)
+							members.Add (b);
+					}
+				}
+			}
+
+			if ((mt & MemberTypes.Event) != 0) {
+				if (events != null)
+				        foreach (Event e in events) {
+						if ((e.ModFlags & modflags) == 0)
+							continue;
+						if ((e.ModFlags & static_mask) != static_flags)
+							continue;
+
+						MemberInfo eb = e.EventBuilder;
+						if (eb != null && filter (eb, criteria) == true)
+						        members.Add (e.EventBuilder);
+					}
+			}
+			
+			if ((mt & MemberTypes.Property) != 0){
+				if (properties != null)
+					foreach (Property p in properties) {
+						if ((p.ModFlags & modflags) == 0)
+							continue;
+						if ((p.ModFlags & static_mask) != static_flags)
+							continue;
+						
+						MemberInfo pb = p.PropertyBuilder;
+
+						if (pb != null && filter (pb, criteria) == true)
+							members.Add (p.PropertyBuilder);
+					}
+			}
+			
+			if ((mt & MemberTypes.NestedType) != 0) {
+				if (types != null){
+					foreach (TypeContainer t in types) {
+						if ((t.ModFlags & modflags) == 0)
+							continue;
+
+						TypeBuilder tb = t.TypeBuilder;
+						if (tb != null && (filter (tb, criteria) == true))
+								members.Add (tb);
+					}
+				}
+
+				if (enums != null){
+					foreach (Enum en in enums){
+						if ((en.ModFlags & modflags) == 0)
+							continue;
+
+						TypeBuilder tb = en.TypeBuilder;
+						if (tb != null && (filter (tb, criteria) == true))
+							members.Add (tb);
+					}
+				}
+				
+				if (delegates != null){
+					foreach (Delegate d in delegates){
+						if ((d.ModFlags & modflags) == 0)
+							continue;
+
+						TypeBuilder tb = d.TypeBuilder;
+						if (tb != null && (filter (tb, criteria) == true))
+							members.Add (tb);
+					}
+				}
+
+				if (interfaces != null){
+					foreach (Interface iface in interfaces){
+						if ((iface.ModFlags & modflags) == 0)
+							continue;
+
+						TypeBuilder tb = iface.TypeBuilder;
+						if (tb != null && (filter (tb, criteria) == true))
+							members.Add (tb);
+					}
+				}
+			}
+
+			if ((mt & MemberTypes.Constructor) != 0){
+				if (((bf & BindingFlags.Instance) != 0) && (instance_constructors != null)){
+					foreach (Constructor c in instance_constructors){
+						if ((c.ModFlags & modflags) == 0)
+							continue;
+
+						ConstructorBuilder cb = c.ConstructorBuilder;
+						if (cb != null)
+							if (filter (cb, criteria) == true)
+								members.Add (cb);
+					}
+				}
+
+				if (((bf & BindingFlags.Static) != 0) && (default_static_constructor != null) &&
+					((default_static_constructor.ModFlags & modflags) != 0)){
+					ConstructorBuilder cb =
+						default_static_constructor.ConstructorBuilder;
+					
+					if (cb != null)
+						if (filter (cb, criteria) == true)
+							members.Add (cb);
+				}
+			}
+
+			//
+			// Lookup members in parent if requested.
+			//
+			if (((bf & BindingFlags.DeclaredOnly) == 0) && (TypeBuilder.BaseType != null)) {
+				if ((mt & ~MemberTypes.Constructor) != 0) {
+					MemberList list = FindMembers (TypeBuilder.BaseType, mt & ~MemberTypes.Constructor, bf, filter, criteria);
+					members.AddRange (list);
+				}
+			}
+
+			Timer.StopTimer (TimerType.TcFindMembers);
+
+			return new MemberList (members);
+		}
+
+		public override MemberCache MemberCache {
+			get {
+				return member_cache;
+			}
+		}
+
+		public static MemberList FindMembers (Type t, MemberTypes mt, BindingFlags bf,
+						      MemberFilter filter, object criteria)
+		{
+			TypeContainer tc = TypeManager.LookupTypeContainer (t);
+
+			if (tc != null)
+				return tc.FindMembers (mt, bf, filter, criteria);
+			else
+				return new MemberList (t.FindMembers (mt, bf, filter, criteria));
+		}
+
+		//
+		// FindMethods will look for methods not only in the type `t', but in
+		// any interfaces implemented by the type.
+		//
+		public static MethodInfo [] FindMethods (Type t, BindingFlags bf,
+							 MemberFilter filter, object criteria)
+		{
+			return null;
+		}
+
+		/// <summary>
+		///   Emits the values for the constants
+		/// </summary>
+		public void EmitConstants ()
+		{
+			if (constants != null)
+				foreach (Const con in constants)
+					con.EmitConstant (this);
+			return;
+		}
+
+		/// <summary>
+		///   Emits the code, this step is performed after all
+		///   the types, enumerations, constructors
+		/// </summary>
+		public void Emit ()
+		{
+			if (instance_constructors != null)
+				foreach (Constructor c in instance_constructors)
+					c.Emit (this);
+
+			if (default_static_constructor != null)
+				default_static_constructor.Emit (this);
+			
+			if (methods != null)
+				foreach (Method m in methods)
+					m.Emit (this);
+
+			if (properties != null)
+				foreach (Property p in properties)
+					p.Emit (this);
+
+			if (this.DefaultPropName != null) {
+				CustomAttributeBuilder cb = new CustomAttributeBuilder (TypeManager.default_member_ctor, new string [] { DefaultPropName });
+				TypeBuilder.SetCustomAttribute (cb);
+			}
+			
+			if (fields != null)
+				foreach (Field f in fields)
+					f.Emit (this);
+
+			if (events != null){
+				foreach (Event e in Events)
+					e.Emit (this);
+			}
+
+			if (Pending != null)
+				if (Pending.VerifyPendingMethods ())
+					return;
+
+			if (OptAttributes != null)
+				OptAttributes.Emit (ec, this);
+			
+			//
+			// Check for internal or private fields that were never assigned
+			//
+			if (fields != null && RootContext.WarningLevel >= 3) {
+				foreach (Field f in fields) {
+					if ((f.ModFlags & Modifiers.PUBLIC) != 0)
+						continue;
+						
+					if (f.Name.StartsWith(@"$STATIC$"))
+						continue;
+
+					if (f.status == 0){
+						Report.Warning (
+							169, f.Location, "Private field " +
+							MakeName (f.Name) + " is never used");
+						continue;
+					}
+
+					//
+					// Only report 649 on level 4
+					//
+					if (RootContext.WarningLevel < 4)
+						continue;
+
+					if ((f.status & Field.Status.ASSIGNED) != 0)
+						continue;
+
+					Report.Warning (
+						649, f.Location,
+						"Field " + MakeName (f.Name) + " is never assigned " +
+						" to and will always have its default value");
+				}
+			}
+			
+//			if (types != null)
+//				foreach (TypeContainer tc in types)
+//					tc.Emit ();
+		}
+
+		public override void CloseType ()
+		{
+			try {
+				if (!Created){
+					Created = true;
+					TypeBuilder.CreateType ();
+				}
+			} catch (TypeLoadException){
+				//
+				// This is fine, the code still created the type
+				//
+//				Report.Warning (-20, "Exception while creating class: " + TypeBuilder.Name);
+//				Console.WriteLine (e.Message);
+			} catch {
+				Console.WriteLine ("In type: " + Name);
+				throw;
+			}
+			
+			if (Enums != null)
+				foreach (Enum en in Enums)
+					en.CloseType ();
+
+			if (interface_order != null){
+				foreach (Interface iface in interface_order)
+					iface.CloseType ();
+			}
+			
+			if (Types != null){
+				foreach (TypeContainer tc in Types)
+					if (tc is Struct)
+						tc.CloseType ();
+
+				foreach (TypeContainer tc in Types)
+					if (!(tc is Struct))
+						tc.CloseType ();
+			}
+
+			if (Delegates != null)
+				foreach (Delegate d in Delegates)
+					d.CloseType ();
+		}
+
+		public string MakeName (string n)
+		{
+			return "`" + Name + "." + n + "'";
+		}
+
+		public void Warning_KeywordShadowsRequired (Location l, MemberInfo mi)
+		{
+			Report.Warning (
+				108, l, "The keyword 'Shadows' is required on " + 
+				MakeName (mi.Name) + " because it shadows `" +
+				mi.ReflectedType.Name + "." + mi.Name + "'");
+		}
+
+		public void Warning_KewywordShadowsNotRequired (Location l, MemberCore mc)
+		{
+			Report.Warning (
+				109, l, "The member " + MakeName (mc.Name) + " does not hide an " +
+				"inherited member, the keyword shadows is not required");
+		}
+
+		public void Warning_KewywordNewNotRequired (Location l, MemberCore mc)
+		{
+			Report.Warning (
+				109, l, "The member " + MakeName (mc.Name) + " does not hide an " +
+				"inherited member, the keyword new is not required");
+		}
+		
+		public static int CheckMember (string name, MemberInfo mi, int ModFlags)
+		{
+			return 0;
+		}
+
+		//
+		// Performs the validation on a Method's modifiers (properties have
+		// the same properties).
+		//
+		public bool MethodModifiersValid (int flags, string n, Location loc)
+		{
+			const int vao = (Modifiers.VIRTUAL | Modifiers.ABSTRACT | Modifiers.OVERRIDE);
+			const int va = (Modifiers.VIRTUAL | Modifiers.ABSTRACT);
+			//const int nv = (Modifiers.SHADOWS | Modifiers.VIRTUAL);
+			bool ok = true;
+			string name = MakeName (n);
+			
+			//
+			// At most one of static, virtual or override
+			//
+			if ((flags & Modifiers.STATIC) != 0){
+				if ((flags & vao) != 0){
+					Report.Error (
+						30501, loc, "Shared method " + name + " can not be " +
+						"declared as Overridable");
+					ok = false;
+				}
+			}
+
+			if (this is Struct){
+				if ((flags & va) != 0){
+					Modifiers.Error_InvalidModifier (loc, "virtual or abstract");
+					ok = false;
+				}
+			}
+
+			if ((flags & Modifiers.OVERRIDE) != 0 && (flags & Modifiers.VIRTUAL) != 0)
+			{
+				Report.Error (
+					30730, loc, name +
+					": Methods marked as Overrides cannot be made Overridable");
+				ok = false;
+			}
+
+			if ((flags & Modifiers.OVERRIDE) != 0 && (flags & Modifiers.SHADOWS) != 0){
+				Report.Error (
+					31408, loc, name +
+					": Methods marked as Overrides cannot be marked as Shadows");
+				ok = false;
+			}
+
+			//
+			// If the declaration includes the abstract modifier, then the
+			// declaration does not include static, virtual or extern
+			//
+			if ((flags & Modifiers.ABSTRACT) != 0){
+				if ((flags & Modifiers.EXTERN) != 0){
+					Report.Error (
+						180, loc, name + " can not be both abstract and extern");
+					ok = false;
+				}
+
+				if ((flags & Modifiers.VIRTUAL) != 0){
+					Report.Error (
+						503, loc, name + " can not be both abstract and virtual");
+					ok = false;
+				}
+
+				if((ModFlags & Modifiers.SEALED) != 0){
+					Report.Error (
+						30607, loc, 
+						"Class declared as 'NotInheritable' " +
+						"cannot have a 'MustOverride' member");
+					ok = false;
+				}
+				else if ((ModFlags & Modifiers.ABSTRACT) == 0){
+					Report.Error (
+						31411, loc, name +
+						" is declared as 'MustOverride', hence its container " +
+						"class should be declared as 'MustInherit'");
+					ok = false;
+
+				}
+			}
+
+			if ((flags & Modifiers.PRIVATE) != 0){
+				if ((flags & vao) != 0){
+					Report.Error (
+						30266, loc, name +
+						": Members marked as Overridable or Overrides can not be Private");
+					ok = false;
+				}
+			}
+
+			if ((flags & Modifiers.SEALED) != 0){
+				if ((flags & Modifiers.OVERRIDE) == 0){
+					Report.Error (
+						238, loc, name +
+						": cannot be sealed because it is not an override");
+					ok = false;
+				}
+			}
+			if ((flags & Modifiers.NEW) != 0){
+				if ((flags & Modifiers.SHADOWS) != 0){
+					Report.Error (
+						31408, loc, 
+						" 'Overloads' and 'Shadows' cannot be combined ");
+					ok = false;
+				}
+			}
+
+			return ok;
+		}
+
+		// Access level of a type.
+		enum AccessLevel {
+			Public			= 0,
+			ProtectedInternal	= 1,
+			Internal		= 2,
+			Protected		= 3,
+			Private			= 4
+		}
+
+		// Check whether `flags' denotes a more restricted access than `level'
+		// and return the new level.
+		static AccessLevel CheckAccessLevel (AccessLevel level, int flags)
+		{
+			//AccessLevel old_level = level;
+
+			if ((flags & Modifiers.INTERNAL) != 0) {
+				if ((flags & Modifiers.PROTECTED) != 0) {
+					if ((int) level < (int) AccessLevel.ProtectedInternal)
+						level = AccessLevel.ProtectedInternal;
+				} else {
+					if ((int) level < (int) AccessLevel.Internal)
+						level = AccessLevel.Internal;
+				}
+			} else if ((flags & Modifiers.PROTECTED) != 0) {
+				if ((int) level < (int) AccessLevel.Protected)
+					level = AccessLevel.Protected;
+			} else if ((flags & Modifiers.PRIVATE) != 0)
+				level = AccessLevel.Private;
+
+			return level;
+		}
+
+		// Return the access level for a new member which is defined in the current
+		// TypeContainer with access modifiers `flags'.
+		AccessLevel GetAccessLevel (int flags)
+		{
+			if ((flags & Modifiers.PRIVATE) != 0)
+				return AccessLevel.Private;
+
+			AccessLevel level;
+			if (!IsTopLevel && (Parent != null))
+				level = Parent.GetAccessLevel (flags);
+			else
+				level = AccessLevel.Public;
+
+			return CheckAccessLevel (CheckAccessLevel (level, flags), ModFlags);
+		}
+
+		// Return the access level for type `t', but don't give more access than `flags'.
+		static AccessLevel GetAccessLevel (Type t, int flags)
+		{
+			if (((flags & Modifiers.PRIVATE) != 0) || t.IsNestedPrivate)
+				return AccessLevel.Private;
+
+			AccessLevel level;
+			if (TypeManager.IsBuiltinType (t))
+				return AccessLevel.Public;
+			else if ((t.DeclaringType != null) && (t != t.DeclaringType))
+				level = GetAccessLevel (t.DeclaringType, flags);
+			else {
+				level = CheckAccessLevel (AccessLevel.Public, flags);
+			}
+
+			if (t.IsNestedPublic)
+				return level;
+
+			if (t.IsNestedAssembly || t.IsNotPublic) {
+				if ((int) level < (int) AccessLevel.Internal)
+					level = AccessLevel.Internal;
+			}
+
+			if (t.IsNestedFamily) {
+				if ((int) level < (int) AccessLevel.Protected)
+					level = AccessLevel.Protected;
+			}
+
+			if (t.IsNestedFamORAssem) {
+				if ((int) level < (int) AccessLevel.ProtectedInternal)
+					level = AccessLevel.ProtectedInternal;
+			}
+
+			return level;
+		}
+
+		//
+		// Returns true if `parent' is as accessible as the flags `flags'
+		// given for this member.
+		//
+		public bool AsAccessible (Type parent, int flags)
+		{
+			while (parent.IsArray || parent.IsPointer || parent.IsByRef)
+				parent = parent.GetElementType ();
+
+			AccessLevel level = GetAccessLevel (flags);
+			AccessLevel level2 = GetAccessLevel (parent, flags);
+
+			return (int) level >= (int) level2;
+		}
+
+		Hashtable builder_and_args;
+		
+		public bool RegisterMethod (MethodBuilder mb, InternalParameters ip, Type [] args)
+		{
+			if (builder_and_args == null)
+				builder_and_args = new Hashtable ();
+			return true;
+		}
+
+		/// <summary>
+		///   Performs checks for an explicit interface implementation.  First it
+		///   checks whether the `interface_type' is a base inteface implementation.
+		///   Then it checks whether `name' exists in the interface type.
+		/// </summary>
+		public bool VerifyImplements (Type interface_type, string full, string name, Location loc)
+		{
+			bool found = false;
+
+			if (ifaces != null){
+				foreach (Type t in ifaces){
+					if (t == interface_type){
+						found = true;
+						break;
+					}
+				}
+			}
+			
+			if (!found){
+				Report.Error (540, "`" + full + "': containing class does not implement interface `" + interface_type.FullName + "'");
+				return false;
+			}
+
+			return true;
+		}
+
+		public static void Error_NotInterfaceMember (Location loc, string member_name, string iface_name)
+		{
+			Report.Error (30401, loc, "'" + member_name + "' is not a member of the interface '" + iface_name + "'");
+		}
+
+		//
+		// IMemberContainer
+		//
+
+		string IMemberContainer.Name {
+			get {
+				return Name;
+			}
+		}
+
+		Type IMemberContainer.Type {
+			get {
+				return TypeBuilder;
+			}
+		}
+
+		IMemberContainer IMemberContainer.Parent {
+			get {
+				return parent_container;
+			}
+		}
+
+		MemberCache IMemberContainer.MemberCache {
+			get {
+				return member_cache;
+			}
+		}
+
+		bool IMemberContainer.IsInterface {
+			get {
+				return this is Interface;
+			}
+		}
+
+		MemberList IMemberContainer.GetMembers (MemberTypes mt, BindingFlags bf)
+		{
+			return FindMembers (mt, bf | BindingFlags.DeclaredOnly, null, null);
+		}
+
+	}
+
+	public class Class : TypeContainer {
+		// <summary>
+		//   Modifiers allowed in a class declaration
+		// </summary>
+		public const int AllowedModifiers =
+			Modifiers.NEW |
+			Modifiers.PUBLIC |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL |
+			Modifiers.PRIVATE |
+			Modifiers.ABSTRACT |
+			Modifiers.SEALED ;
+		
+		public Class (TypeContainer parent, string name, int mod, Attributes attrs, Location l)
+			: base (parent, name, attrs, l)
+		{
+			int accmods;
+
+			if (parent.Parent == null)
+				accmods = Modifiers.INTERNAL;
+			else
+				accmods = Modifiers.PUBLIC;
+
+			this.ModFlags = Modifiers.Check (AllowedModifiers, mod, accmods, l);
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Class;
+			}
+		}
+
+		public override void ApplyAttributeBuilder(Attribute a, CustomAttributeBuilder cb)
+		{
+			if (a.UsageAttribute != null) {
+				if (base_class_type != TypeManager.attribute_type && !base_class_type.IsSubclassOf (TypeManager.attribute_type) &&
+					TypeBuilder.FullName != "System.Attribute") {
+					Report.Error (641, a.Location, "Attribute '" + a.Name + "' is only valid on classes derived from System.Attribute");
+				}
+				AttributeUsage = a.UsageAttribute;
+			} 
+			base.ApplyAttributeBuilder (a, cb);
+		}
+
+		//
+		// FIXME: How do we deal with the user specifying a different
+		// layout?
+		//
+		public override TypeAttributes TypeAttr {
+			get {
+				return base.TypeAttr | TypeAttributes.AutoLayout | TypeAttributes.Class;
+			}
+		}
+	}
+
+	public class Struct : TypeContainer {
+		// <summary>
+		//   Modifiers allowed in a struct declaration
+		// </summary>
+		public const int AllowedModifiers =
+			Modifiers.NEW       |
+			Modifiers.PUBLIC    |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL  |
+			Modifiers.UNSAFE    |
+			Modifiers.PRIVATE;
+
+		public Struct (TypeContainer parent, string name, int mod, Attributes attrs, Location l)
+			: base (parent, name, attrs, l)
+		{
+			int accmods;
+			
+			if (parent.Parent == null)
+				accmods = Modifiers.INTERNAL;
+			else
+				accmods = Modifiers.PUBLIC;
+			
+			this.ModFlags = Modifiers.Check (AllowedModifiers, mod, accmods, l);
+
+			this.ModFlags |= Modifiers.SEALED;
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Struct;
+			}
+		}
+
+		//
+		// FIXME: Allow the user to specify a different set of attributes
+		// in some cases (Sealed for example is mandatory for a class,
+		// but what SequentialLayout can be changed
+		//
+		public override TypeAttributes TypeAttr {
+			get {
+				return base.TypeAttr |
+					TypeAttributes.SequentialLayout |
+					TypeAttributes.Sealed |
+					TypeAttributes.BeforeFieldInit;
+			}
+		}
+	}
+
+	public abstract class MethodCore : MemberBase {
+		public /* readonly */ Parameters Parameters;
+		Block block;
+		
+		//
+		// Parameters, cached for semantic analysis.
+		//
+		protected InternalParameters parameter_info;
+		protected Type [] parameter_types;
+	
+		// Whether this is an operator
+		public bool IsOperator;
+
+		public MethodCore (Expression type, int mod, int allowed_mod, string name,
+				   Attributes attrs, Parameters parameters, Location loc)
+			: base (type, mod, allowed_mod, name, attrs, loc)
+		{
+			Parameters = parameters;
+		}
+		
+		//
+		//  Returns the System.Type array for the parameters of this method
+		//
+		public Type [] ParameterTypes {
+			get {
+				return parameter_types;
+			}
+		}
+
+		public InternalParameters ParameterInfo
+		{
+			get {
+				return parameter_info;
+			}
+		}
+		
+		public Block Block {
+			get {
+				return block;
+			}
+
+			set {
+				block = value;
+			}
+		}
+
+		protected virtual bool DoDefineParameters (TypeContainer parent)
+		{
+			// Check if arguments were correct
+			parameter_types = Parameters.GetParameterInfo (parent);
+			if ((parameter_types == null) || !CheckParameters (parent, parameter_types))
+				return false;
+
+			parameter_info = new InternalParameters (parent, Parameters);
+
+			return true;
+		}
+
+		public CallingConventions GetCallingConvention (bool is_class)
+		{
+			CallingConventions cc = 0;
+			
+			cc = Parameters.GetCallingConvention ();
+
+			if (is_class)
+				if ((ModFlags & Modifiers.STATIC) == 0)
+					cc |= CallingConventions.HasThis;
+
+			// FIXME: How is `ExplicitThis' used in C#?
+			
+			return cc;
+		}
+	}
+	
+	public class Method : MethodCore {
+		public MethodBuilder MethodBuilder;
+		public MethodData MethodData;
+
+		/// <summary>
+		///   Modifiers allowed in a class declaration
+		/// </summary>
+		const int AllowedModifiers =
+			Modifiers.NEW |
+			Modifiers.PUBLIC |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL |
+			Modifiers.PRIVATE |
+			Modifiers.STATIC |
+			Modifiers.VIRTUAL |
+			Modifiers.NONVIRTUAL |
+			Modifiers.OVERRIDE |
+			Modifiers.ABSTRACT |
+		    	Modifiers.UNSAFE |
+			Modifiers.EXTERN|
+			Modifiers.SHADOWS;
+
+		//
+		// return_type can be "null" for VOID values.
+		//
+		public Method (Expression return_type, int mod, string name, Parameters parameters,
+			       Attributes attrs, Location l)
+			: base (return_type, mod, AllowedModifiers, name, attrs, parameters, l)
+		{ 
+			Implements = null;
+		}
+
+		public Method (Expression return_type, int mod, string name, Parameters parameters,
+			Attributes attrs, ArrayList impl_what, Location l)
+			: base (return_type, mod, AllowedModifiers, name, attrs, parameters, l)
+		{ 
+			Implements = impl_what;
+		}
+		
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Method;
+			}
+		}
+		
+		//
+		// Returns the `System.Type' for the ReturnType of this
+		// function.  Provides a nice cache.  (used between semantic analysis
+		// and actual code generation
+		//
+		public Type GetReturnType ()
+		{
+			return MemberType;
+		}
+
+		void DuplicateEntryPoint (MethodInfo b, Location location)
+		{
+				Report.Error (
+						30738, location,
+						"Program `" + CodeGen.FileName +
+						"'  has more than one entry point defined: `" +
+						TypeManager.MonoBASIC_Signature(b) + "'");
+		}
+
+		void Report28 (MethodInfo b)
+		{
+			if (RootContext.WarningLevel < 4) 
+				return;
+				
+			Report.Warning (
+					28, Location,
+					"`" + TypeManager.MonoBASIC_Signature(b) +
+					"' has the wrong signature to be an entry point");
+		}
+
+		public bool IsEntryPoint (MethodBuilder b, InternalParameters pinfo)
+		{
+			if (b.ReturnType != TypeManager.void_type &&
+				b.ReturnType != TypeManager.int32_type)
+					return false;
+
+			if (pinfo.Count == 0)
+					return true;
+
+			if (pinfo.Count > 1)
+					return false;
+
+			Type t = pinfo.ParameterType(0);
+			if (t.IsArray &&
+				(t.GetArrayRank() == 1) &&
+				(t.GetElementType() == TypeManager.string_type) &&
+				(pinfo.ParameterModifier(0) == Parameter.Modifier.NONE))
+					return true;
+			else
+					return false;
+		}
+
+		//
+		// Checks our base implementation if any
+		//
+		protected override bool CheckBase (TypeContainer parent)
+		{
+			// Check whether arguments were correct.
+			if (!DoDefineParameters (parent))
+				return false;
+
+			MethodSignature ms = new MethodSignature (Name, null, ParameterTypes);
+			if (!IsOperator) {
+				MemberList mi_this;
+
+				mi_this = TypeContainer.FindMembers (
+					parent.TypeBuilder, MemberTypes.Method,
+					BindingFlags.NonPublic | BindingFlags.Public |
+					BindingFlags.Static | BindingFlags.Instance |
+					BindingFlags.DeclaredOnly,
+					MethodSignature.method_signature_filter, ms);
+
+				if (mi_this.Count > 0) {
+					Report.Error (111, Location, "Class `" + parent.Name + "' " +
+						      "already defines a member called `" + Name + "' " +
+						      "with the same parameter types");
+					return false;
+				}
+			}
+
+			//
+			// Verify if the parent has a type with the same name, and then
+			// check whether we have to create a new slot for it or not.
+			//
+			Type ptype = parent.TypeBuilder.BaseType;
+
+			// ptype is only null for System.Object while compiling corlib.
+			if (ptype != null){
+				MemberList mi, mi_static, mi_instance;
+
+				mi_static = TypeContainer.FindMembers (
+					ptype, MemberTypes.Method,
+					BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static,
+					MethodSignature.inheritable_method_signature_filter, ms);
+
+				mi_instance = TypeContainer.FindMembers (
+					ptype, MemberTypes.Method,
+					BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance,
+					MethodSignature.inheritable_method_signature_filter,
+					ms);
+
+				if (mi_instance.Count > 0){
+					mi = mi_instance;
+				} else if (mi_static.Count > 0)
+					mi = mi_static;
+				else
+					mi = null;
+
+				if (mi != null && mi.Count > 0){
+					parent_method = (MethodInfo) mi [0];
+					string name = parent_method.DeclaringType.Name + "." +
+						parent_method.Name;
+
+					if (!CheckMethodAgainstBase (parent, flags, parent_method, name))
+						return false;
+
+					if ((ModFlags & Modifiers.NEW) == 0) {
+						Type parent_ret = TypeManager.TypeToCoreType (
+							parent_method.ReturnType);
+
+						if (parent_ret != MemberType) {
+							Report.Error (
+								508, parent.MakeName (Name) + ": cannot " +
+								"change return type when overriding " +
+								"inherited member " + name);
+							return false;
+						}
+					}
+				} else {
+					/*if ((ModFlags & Modifiers.NEW) != 0)
+						WarningNotHiding (parent);*/
+
+					if ((ModFlags & Modifiers.OVERRIDE) != 0){
+						Report.Error (30398, Location,
+							      parent.MakeName (Name) +
+							      " : No suitable methods found to override");
+					}
+					if ((ModFlags & ( Modifiers.NEW | Modifiers.SHADOWS | Modifiers.OVERRIDE )) == 0) 
+					{
+						if ((ModFlags & Modifiers.NONVIRTUAL) != 0)
+						{
+							Report.Error (31088, Location,
+								parent.MakeName (Name) + " : Cannot " +
+								"be declared NotOverridable since this method is " +
+								"not maked as Overrides");
+						}
+					}
+					// if a member of module is not inherited from Object class
+					// can not be declared protected
+					if ((parent is Module) && ((ModFlags & Modifiers.PROTECTED) != 0))
+						Report.Error (31066, Location,
+								"'Sub' or 'Function' inside a 'Module' can not be declared as " +
+								"'Protected' or 'Protected Friend'");
+				}
+			}
+			/* else if ((ModFlags & Modifiers.NEW) != 0)
+				WarningNotHiding (parent);
+			*/
+
+			return true;
+		}
+
+		//
+		// Creates the type
+		//
+		public override bool Define (TypeContainer parent)
+		{
+			if (!DoDefine (parent))
+				return false;
+
+			if (!CheckBase (parent))
+				return false;
+
+			if ((parent is Struct) && ((ModFlags & Modifiers.PROTECTED) != 0))
+				Report.Error (31067, Location,
+					"'Sub' or 'Function' inside a 'Structure' can not be declared as " +
+					"'Protected' or 'Protected Friend'");
+
+			CallingConventions cc = GetCallingConvention (parent is Class);
+
+			MethodData = new MethodData (this, null, MemberType, ParameterTypes,
+						     ParameterInfo, cc, OptAttributes,
+						     ModFlags, flags, true);
+
+			if (!MethodData.Define (parent))
+				return false;
+
+			MethodBuilder = MethodData.MethodBuilder;
+			
+			//
+			// This is used to track the Entry Point,
+			//
+			if (Name.ToUpper() == "MAIN" &&
+			    ((ModFlags & Modifiers.STATIC) != 0) && 
+			    (RootContext.MainClass == null ||
+			     RootContext.MainClass == parent.TypeBuilder.FullName ||
+			     (RootContext.RootNamespace != null &&
+				  RootContext.RootNamespace.Length > 0 &&
+				  (RootContext.RootNamespace + "." + RootContext.MainClass) == parent.TypeBuilder.FullName))) {
+                                if (IsEntryPoint (MethodBuilder, ParameterInfo)) {
+                                        if (RootContext.EntryPoint == null) {
+                                                RootContext.EntryPoint = MethodBuilder;
+                                                RootContext.EntryPointLocation = Location;
+                                        } else {
+                                                DuplicateEntryPoint (RootContext.EntryPoint, RootContext.EntryPointLocation);
+                                                DuplicateEntryPoint (MethodBuilder, Location);
+                                        }
+                                } else                                 	
+                               	        Report28(MethodBuilder);
+			}
+
+			return true;
+		}
+
+		//
+		// Emits the code
+		// 
+		public void Emit (TypeContainer parent)
+		{
+			MethodData.Emit (parent, Block, this);
+		}
+
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+		{
+			throw new Exception ("FIXME: I am just a placeholder implementation");
+		}
+	}
+
+	public abstract class ConstructorInitializer {
+		ArrayList argument_list;
+		ConstructorInfo parent_constructor;
+		Parameters parameters;
+		Location loc;
+		public bool implicit_initialization;
+		
+		public ConstructorInitializer (ArrayList argument_list, Parameters parameters,
+					       Location loc)
+		{
+			this.argument_list = argument_list;
+			this.parameters = parameters;
+			this.loc = loc;
+			this.implicit_initialization = false;
+		}
+
+		public ArrayList Arguments {
+			get {
+				return argument_list;
+			}
+		}
+
+		public ConstructorInfo ParentConstructor
+		{
+			get
+			{
+				return parent_constructor;
+			}
+		}
+	
+		public bool Resolve (EmitContext ec)
+		{
+			Expression parent_constructor_group;
+			Type t;
+
+			ec.CurrentBlock = new Block (null, true, parameters);
+
+			if (argument_list != null){
+				foreach (Argument a in argument_list){
+					if (!a.Resolve (ec, loc))
+						return false;
+				}
+			}
+
+			ec.CurrentBlock = null;
+
+			if (this is ConstructorBaseInitializer) {
+				if (ec.ContainerType.BaseType == null)
+					return true;
+
+				t = ec.ContainerType.BaseType;
+				if (ec.ContainerType.IsValueType){
+					Report.Error (522, loc,
+						"structs cannot call base class constructors");
+					return false;
+				}
+			}
+			else
+				t = ec.ContainerType;
+			
+			parent_constructor_group = Expression.MemberLookup (
+				ec, t, t, ".ctor", 
+				MemberTypes.Constructor,
+				BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly,
+				loc);
+			
+			if (parent_constructor_group == null){
+				Report.Error (30455, loc, "Class '" + t + "' can not find a constructor for this argument list" );
+				return false;
+			}
+
+			parent_constructor = (ConstructorInfo) Invocation.OverloadResolve (ec, 
+				(MethodGroupExpr) parent_constructor_group, argument_list, loc);
+
+			if (parent_constructor == null) {
+				if (this.implicit_initialization)
+					Report.Error (30148, loc, "Must declare 'MyBase.New' in the constructor " +
+					"of the class '" + ec.TypeContainer.Name + "' with appropriate arguments, since the base class '" +
+						t.FullName + "' does not contain a definition of 'New' without any parameter");
+				else
+					Report.Error (30455, loc, "Class '" + t + "' can not find a constructor for this argument list" );
+
+				return false;
+			}
+
+			return true;
+		}
+
+		public void Emit (EmitContext ec)
+		{
+			if (parent_constructor != null){
+				if (ec.IsStatic)
+					Invocation.EmitCall (ec, true, true, null, parent_constructor, argument_list, loc);
+				else
+					Invocation.EmitCall (ec, true, false, ec.This, parent_constructor, argument_list, loc);
+			}
+		}
+
+
+	}
+
+	public class ConstructorBaseInitializer : ConstructorInitializer {
+		public ConstructorBaseInitializer (ArrayList argument_list, Parameters pars, Location l) :
+			base (argument_list, pars, l)
+		{
+		}
+	}
+
+	public class ConstructorThisInitializer : ConstructorInitializer {
+		public ConstructorThisInitializer (ArrayList argument_list, Parameters pars, Location l) :
+			base (argument_list, pars, l)
+		{
+		}
+	}
+	
+	public class Constructor : MethodCore {
+		public ConstructorBuilder ConstructorBuilder;
+		public ConstructorInitializer Initializer;
+
+		// <summary>
+		//   Modifiers allowed for a constructor.
+		// </summary>
+		public const int AllowedModifiers =
+			Modifiers.PUBLIC |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL |
+			Modifiers.STATIC |
+			Modifiers.UNSAFE |
+			Modifiers.EXTERN |		
+			Modifiers.PRIVATE;
+
+		//
+		// The spec claims that static is not permitted, but
+		// my very own code has static constructors.
+		//
+		public Constructor (string name, Parameters args, ConstructorInitializer init, Location l)
+			: base (null, 0, AllowedModifiers, name, null, args, l)
+		{
+			Initializer = init;
+		}
+
+		public Constructor (string name, int mod, Parameters args, ConstructorInitializer init, Location l)
+			: base (null, mod, AllowedModifiers, name, null, args, l)
+		{
+			Initializer = init;
+		}
+
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+		{
+			ConstructorBuilder.SetCustomAttribute (cb);
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Constructor;
+			}
+		}
+
+		//
+		// Returns true if this is a default constructor
+		//
+		public bool IsDefault ()
+		{
+			if ((ModFlags & Modifiers.STATIC) != 0)
+				return  (Parameters.FixedParameters == null ? true : Parameters.Empty) &&
+					(Parameters.ArrayParameter == null ? true : Parameters.Empty);
+			
+			else
+				return  (Parameters.FixedParameters == null ? true : Parameters.Empty) &&
+					(Parameters.ArrayParameter == null ? true : Parameters.Empty) &&
+					(Initializer is ConstructorBaseInitializer) &&
+					(Initializer.Arguments == null);
+		}
+
+		//
+		// Creates the ConstructorBuilder
+		//
+		public override bool Define (TypeContainer parent)
+		{
+			MethodAttributes ca = (MethodAttributes.RTSpecialName |
+					       MethodAttributes.SpecialName);
+
+			if (parent.EventHandlers != null) {
+				ArrayList hdlrs = parent.EventHandlers;
+				foreach(Statement stmt in hdlrs)
+                    this.Block.AddStatement (stmt);
+			}
+
+
+			// Check if arguments were correct.
+			if (!DoDefineParameters (parent))
+				return false;
+
+			if ((ModFlags & Modifiers.STATIC) != 0) {
+				ca |= MethodAttributes.Static;
+
+				if (this.Parameters != Parameters.EmptyReadOnlyParameters)
+					Report.Error (
+						30479, Location, 
+						"Shared constructor can not have parameters");
+
+				if ((ModFlags & Modifiers.Accessibility) != 0)
+					Report.Error (
+						30480, Location, 
+						"Shared constructor can not be declared " +
+						"explicitly as public, private, friend or protected");
+
+				if (this.Initializer != null)
+					Report.Error (
+						30043, Location, 
+						"Keywords like MyBase, MyClass, Me are not " +
+						"valid inside a Shared Constructor");
+			}
+			else {
+				if (parent is Struct && ParameterTypes.Length == 0)	{
+					Report.Error (
+						30629, Location, 
+						"Structs can not contain explicit parameterless " +
+						"constructors");
+					return false;
+				}
+				ca |= MethodAttributes.HideBySig;
+
+				if ((ModFlags & Modifiers.PUBLIC) != 0)
+					ca |= MethodAttributes.Public;
+				else if ((ModFlags & Modifiers.PROTECTED) != 0)	{
+					if ((ModFlags & Modifiers.INTERNAL) != 0)
+						ca |= MethodAttributes.FamORAssem;
+					else 
+						ca |= MethodAttributes.Family;
+				}
+				else if ((ModFlags & Modifiers.INTERNAL) != 0)
+					ca |= MethodAttributes.Assembly;
+				else if (IsDefault ())
+					ca |= MethodAttributes.Public;
+				else
+					ca |= MethodAttributes.Private;
+			}
+
+			ConstructorBuilder = parent.TypeBuilder.DefineConstructor (
+				ca, GetCallingConvention (parent is Class), ParameterTypes);
+
+			//
+			// HACK because System.Reflection.Emit is lame
+			//
+			if (!TypeManager.RegisterMethod (ConstructorBuilder, ParameterInfo, ParameterTypes)) {
+				Report.Error (
+					111, Location,
+					"Class `" +parent.Name+ "' already contains a definition with the " +
+					"same return value and parameter types for constructor `" + Name
+					+ "'");
+				return false;
+			}
+
+			return true;
+		}
+
+		//
+		// Emits the code
+		//
+		public void Emit (TypeContainer parent)
+		{
+			ILGenerator ig = ConstructorBuilder.GetILGenerator ();
+			EmitContext ec = new EmitContext (parent, Location, ig, null, ModFlags, true);
+
+			if ((ModFlags & Modifiers.STATIC) == 0){
+				if (parent is Class && Initializer == null) {
+					Initializer = new ConstructorBaseInitializer (
+						null, Parameters.EmptyReadOnlyParameters, parent.Location);
+					Initializer.implicit_initialization = true;
+				}
+
+				//
+				// Spec mandates that Initializers will not have
+				// `this' access
+				//
+				ec.IsStatic = true;
+				if (Initializer != null && !Initializer.Resolve (ec))
+					return;
+				ec.IsStatic = false;
+			}
+
+			Parameters.LabelParameters (ec, ConstructorBuilder, Location);
+			
+			//
+			// Classes can have base initializers and instance field initializers.
+			//
+			if (parent is Class){
+				if ((ModFlags & Modifiers.STATIC) == 0)
+					parent.EmitFieldInitializers (ec);
+			}
+
+			if (Initializer != null) {
+				if (this.ConstructorBuilder.Equals (Initializer.ParentConstructor))
+					Report.Error (
+						30297, Location,
+						"A constructor can not call itself" );
+
+				Initializer.Emit (ec);
+			}
+			
+			if ((ModFlags & Modifiers.STATIC) != 0)
+				parent.EmitFieldInitializers (ec);
+
+			if (OptAttributes != null)
+				OptAttributes.Emit (ec, this);
+
+			// If this is a non-static `struct' constructor and doesn't have any
+			// initializer, it must initialize all of the struct's fields.
+			if ((parent is Struct) && ((ModFlags & Modifiers.STATIC) == 0) &&
+			    (Initializer == null))
+				Block.AddThisVariable (parent, Location);
+
+			ec.EmitTopBlock (Block, ParameterInfo, Location);
+		}
+	}
+
+	public class MethodData {
+		//
+		// The return type of this method
+		//
+		public readonly Type ReturnType;
+		public readonly Type[] ParameterTypes;
+		public readonly InternalParameters ParameterInfo;
+		public readonly CallingConventions CallingConventions;
+		public readonly Attributes OptAttributes;
+		public readonly Location Location;
+
+		//
+		// Are we implementing an interface ?
+		//
+		public bool IsImplementing = false;
+
+		//
+		// Protected data.
+		//
+		readonly MemberBase member;
+		readonly int modifiers;
+		MethodAttributes flags;
+		readonly bool is_method;
+		readonly string accessor_name;
+		ArrayList conditionals;
+
+		MethodBuilder builder = null;
+		public MethodBuilder MethodBuilder {
+			get {
+				return builder;
+			}
+		}
+
+		public MethodData (MemberBase member, string name, Type return_type,
+				   Type [] parameter_types, InternalParameters parameters,
+				   CallingConventions cc, Attributes opt_attrs,
+				   int modifiers, MethodAttributes flags, bool is_method)
+		{
+			this.member = member;
+			this.accessor_name = name;
+			this.ReturnType = return_type;
+			this.ParameterTypes = parameter_types;
+			this.ParameterInfo = parameters;
+			this.CallingConventions = cc;
+			this.OptAttributes = opt_attrs;
+			this.modifiers = modifiers;
+			this.flags = flags;
+			this.is_method = is_method;
+			this.Location = member.Location;
+			this.conditionals = new ArrayList ();
+		}
+
+		//
+		// Attributes.
+		//
+		Attribute dllimport_attribute = null;
+		string obsolete = null;
+		bool obsolete_error = false;
+
+		public virtual bool ApplyAttributes (Attributes opt_attrs, bool is_method)
+		{
+			if ((opt_attrs == null) || (opt_attrs.Attrs == null))
+				return true;
+
+			foreach (Attribute a in opt_attrs.Attrs) {
+				if (a.Name == "Conditional") {
+					if (!ApplyConditionalAttribute (a))
+						return false;
+				} else if (a.Name == "Obsolete") {
+					if (!ApplyObsoleteAttribute (a))
+						return false;
+				} else if (a.Name.IndexOf ("DllImport") != -1) {
+					if (!is_method) {
+						a.Type = TypeManager.dllimport_type;
+						Attribute.Error_AttributeNotValidForElement (a, Location);
+						return false;
+					}
+					if (!ApplyDllImportAttribute (a))
+						return false;
+				}
+			}
+			
+			return true;
+		}
+
+		//
+		// Applies the `DllImport' attribute to the method.
+		//
+		protected virtual bool ApplyDllImportAttribute (Attribute a)
+		{
+			const int extern_static = Modifiers.EXTERN | Modifiers.STATIC;
+			if ((modifiers & extern_static) != extern_static) {
+				Report.Error (601, Location,
+					      "The DllImport attribute must be specified on a method " +
+					      "marked `static' and `extern'.");
+				return false;
+			}
+
+			flags |= MethodAttributes.PinvokeImpl;
+			dllimport_attribute = a;
+			return true;
+		}
+
+		//
+		// Applies the `Obsolete' attribute to the method.
+		//
+		protected virtual bool ApplyObsoleteAttribute (Attribute a)
+		{
+			if (obsolete != null) {
+				Report.Error (579, Location, "Duplicate `Obsolete' attribute");
+				return false;
+			}
+
+			obsolete = a.Obsolete_GetObsoleteMessage (out obsolete_error);
+			return obsolete != null;
+		}
+
+		//
+		// Applies the `Conditional' attribute to the method.
+		//
+		protected virtual bool ApplyConditionalAttribute (Attribute a)
+		{
+			// The Conditional attribute is only valid on methods.
+			if (!is_method) {
+				Attribute.Error_AttributeNotValidForElement (a, Location);
+				return false;
+			}
+
+			string condition = a.Conditional_GetConditionName ();
+
+			if (condition == null)
+				return false;
+
+			if (ReturnType != TypeManager.void_type) {
+				Report.Error (578, Location,
+					      "Conditional not valid on `" + member.Name + "' " +
+					      "because its return type is not void");
+				return false;
+			}
+
+			if ((modifiers & Modifiers.OVERRIDE) != 0) {
+				Report.Error (243, Location,
+					      "Conditional not valid on `" + member.Name + "' " +
+					      "because it is an override method");
+				return false;
+			}
+
+			if (member.IsExplicitImpl) {
+				Report.Error (577, Location,
+					      "Conditional not valid on `" + member.Name + "' " +
+					      "because it is an explicit interface implementation");
+				return false;
+			}
+
+			if (IsImplementing) {
+				Report.Error (623, Location,
+					      "Conditional not valid on `" + member.Name + "' " +
+					      "because it is an interface method");
+				return false;
+			}
+
+			conditionals.Add (condition);
+
+			return true;
+		}
+
+		//
+		// Checks whether this method should be ignored due to its Conditional attributes.
+		//
+		bool ShouldIgnore (Location loc)
+		{
+			// When we're overriding a virtual method, we implicitly inherit the
+			// Conditional attributes from our parent.
+			if (member.ParentMethod != null) {
+				TypeManager.MethodFlags flags = TypeManager.GetMethodFlags (
+					member.ParentMethod, loc);
+
+				if ((flags & TypeManager.MethodFlags.ShouldIgnore) != 0)
+					return true;
+			}
+
+			foreach (string condition in conditionals)
+				if (RootContext.AllDefines [condition] == null)
+					return true;
+
+			return false;
+		}
+
+		//
+		// Returns the TypeManager.MethodFlags for this method.
+		// This emits an error 619 / warning 618 if the method is obsolete.
+		// In the former case, TypeManager.MethodFlags.IsObsoleteError is returned.
+		//
+		public virtual TypeManager.MethodFlags GetMethodFlags (Location loc)
+		{
+			TypeManager.MethodFlags flags = 0;
+
+			if (obsolete != null) {
+				if (obsolete_error) {
+					Report.Error (619, loc, "Method `" + member.Name +
+						      "' is obsolete: `" + obsolete + "'");
+					return TypeManager.MethodFlags.IsObsoleteError;
+				} else
+					Report.Warning (618, loc, "Method `" + member.Name +
+							"' is obsolete: `" + obsolete + "'");
+
+				flags |= TypeManager.MethodFlags.IsObsolete;
+			}
+
+			if (ShouldIgnore (loc))
+			    flags |= TypeManager.MethodFlags.ShouldIgnore;
+
+			return flags;
+		}
+		
+		//
+		// Search all the interface bases recursively for unimplemented methods
+		//
+		bool SearchBasesForAbstractMethods (
+			TypeContainer parent, Type iface_type, 
+			string method_name, ref ArrayList implementing_list, 
+			ref ArrayList implementing_iface)
+		{
+			MethodInfo implementing = null;
+			bool IsImplementing = false;
+			Type current_iface_type = iface_type;
+
+			implementing = parent.Pending.IsAbstractMethod (
+			current_iface_type, method_name, ReturnType, ParameterTypes);
+
+			if (implementing != null) {
+				if (!implementing_list.Contains (implementing)) {
+					implementing_list.Add (implementing);
+					implementing_iface.Add(current_iface_type);
+				}
+				IsImplementing = true;
+			} else {
+				Type[] current_iface_types = current_iface_type.GetInterfaces();
+				if (current_iface_types.Length == 0)
+					return false;
+
+				foreach (Type curr_iface_type in current_iface_types) {
+					IsImplementing = SearchBasesForAbstractMethods (
+						parent, curr_iface_type, method_name, 
+						ref implementing_list, ref implementing_iface);
+
+					if (IsImplementing)
+						break;
+				}
+			}
+
+			return IsImplementing;
+		}
+
+		public virtual bool Define (TypeContainer parent)
+		{
+			MethodInfo implementing = null;
+			ArrayList implementing_list = null;
+			ArrayList implementing_iface = null;
+			string method_name, name, prefix, impl_method_name;
+			int pos = -1;
+
+			if (OptAttributes != null)
+				if (!ApplyAttributes (OptAttributes, is_method))
+					return false;
+
+			if (accessor_name != null)
+				name = accessor_name + "_" + member.ShortName;
+			else
+				name = member.ShortName;
+
+			method_name = name;
+			impl_method_name = name;
+
+			if ((member.ModFlags & Modifiers.OVERRIDE) != 0) {
+				if (parent.Pending == null)
+					implementing = null;
+				else
+					implementing = parent.Pending.IsAbstractMethod (
+						(Type) parent.TypeBuilder.BaseType, name, 
+						ReturnType, ParameterTypes);
+				
+				if (implementing != null)
+					IsImplementing = true;
+			}
+
+			if (member.Implements != null) {
+				implementing_list = new ArrayList();
+				implementing_iface = new ArrayList();
+
+				foreach (Expression Impl in member.Implements) {
+					name = Impl.ToString();
+					prefix = name.Substring(0, name.LastIndexOf("."));
+					name = name.Substring(name.LastIndexOf(".") + 1);
+
+					if (accessor_name != null)
+						impl_method_name = accessor_name + "_" + name;
+					else
+						impl_method_name = name;
+
+					Type current_iface_type = (Type) member.InterfaceTypes[++pos];
+					IsImplementing = SearchBasesForAbstractMethods (
+						parent, current_iface_type, impl_method_name, 
+						ref implementing_list, ref implementing_iface);
+
+					if (IsImplementing == false) {
+						TypeContainer.Error_NotInterfaceMember (
+							Location, name, prefix);
+						return false;
+					}
+				}
+			} 
+
+			//
+			// For implicit implementations, make sure we are public, for
+			// explicit implementations, make sure we are private.
+			//
+			//if (IsImplementing){
+				//
+				// Setting null inside this block will trigger a more
+				// verbose error reporting for missing interface implementations
+				//
+				// The "candidate" function has been flagged already
+				// but it wont get cleared
+				//
+			/*	if (!member.IsExplicitImpl){
+					//
+					// We already catch different accessibility settings
+					// so we just need to check that we are not private
+					//
+					if ((modifiers & Modifiers.PRIVATE) != 0)
+						implementing = null;
+					
+					//
+					// Static is not allowed
+					//
+					if ((modifiers & Modifiers.STATIC) != 0)
+						implementing = null;
+				} else {
+					if ((modifiers & (Modifiers.PUBLIC | Modifiers.ABSTRACT | Modifiers.VIRTUAL)) != 0){
+						Modifiers.Error_InvalidModifier (Location, "public, virtual or abstract");
+						implementing = null;
+					}
+				}*/
+			//}
+			
+			//
+			// If implementing is still valid, set flags
+			//
+			if (IsImplementing){
+				//
+				// When implementing interface methods, set NewSlot.
+				//
+				if (implementing_list != null && implementing_list.Count != 0)
+						flags |= MethodAttributes.NewSlot;
+
+				flags |=
+					MethodAttributes.Virtual |
+					MethodAttributes.HideBySig;
+			}
+
+			//
+			// Create the MethodBuilder for the method
+			//
+			if ((flags & MethodAttributes.PinvokeImpl) != 0) {
+				if ((modifiers & Modifiers.STATIC) == 0) {
+					Report.Error (601, Location,
+						      "The DllImport attribute must be specified on " +
+						      "a method marked 'static' and 'extern'.");
+					return false;
+				}
+				
+				EmitContext ec = new EmitContext (
+					parent, Location, null, ReturnType, modifiers);
+				
+				builder = dllimport_attribute.DefinePInvokeMethod (
+					ec, parent.TypeBuilder, method_name, flags,
+					ReturnType, ParameterTypes);
+			} else
+				builder = parent.TypeBuilder.DefineMethod (
+					method_name, flags, CallingConventions,
+					ReturnType, ParameterTypes);
+
+			if (builder == null)
+				return false;
+
+			if (IsImplementing) {
+				//
+				// implement abstract methods from abstract classes
+				//
+				if ((member.ModFlags & Modifiers.OVERRIDE) != 0) {
+					/*
+					if (member is Indexer)
+						parent.Pending.ImplementIndexer (
+							(Type) parent.TypeBuilder.BaseType, 
+							builder, ReturnType,
+							ParameterTypes, true);
+					else
+					*/
+						parent.Pending.ImplementMethod (
+							(Type) parent.TypeBuilder.BaseType, 
+							name, ReturnType,
+							ParameterTypes, member.IsExplicitImpl);
+				}
+				
+				//
+				// implement abstract methods of interfaces
+				//
+				if (member.Implements != null)	{
+					pos = 0;
+					foreach (MethodInfo Impl in implementing_list)	{
+
+						/* 
+						if (member is Indexer)
+							parent.Pending.ImplementIndexer (
+								(Type) implementing_iface[pos++],
+								builder, ReturnType,
+								ParameterTypes, true);
+						else
+						*/
+							parent.Pending.ImplementMethod (
+								(Type) implementing_iface[pos++],
+								Impl.Name, ReturnType,
+								ParameterTypes, member.IsExplicitImpl);
+
+						parent.TypeBuilder.DefineMethodOverride (
+							builder, Impl);
+					}
+				}
+				
+			}
+
+			if (!TypeManager.RegisterMethod (builder, ParameterInfo, ParameterTypes)) {
+				Report.Error (111, Location,
+					      "Class `" + parent.Name +
+					      "' already contains a definition with the " +
+					      "same return value and parameter types as the " +
+					      "'get' method of property `" + member.Name + "'");
+				return false;
+			}
+
+			TypeManager.AddMethod (builder, this);
+			return true;
+		}
+
+		//
+		// Emits the code
+		// 
+		public virtual void Emit (TypeContainer parent, Block block, object kind)
+		{
+			ILGenerator ig;
+			EmitContext ec;
+
+			if ((flags & MethodAttributes.PinvokeImpl) == 0)
+				ig = builder.GetILGenerator ();
+			else
+				ig = null;
+
+			ec = new EmitContext (parent, Location, ig, ReturnType, modifiers);
+
+			if (OptAttributes != null)
+				Attribute.ApplyAttributes (ec, builder, kind, OptAttributes, Location);
+
+			if (member is MethodCore)
+				((MethodCore) member).Parameters.LabelParameters (ec, MethodBuilder, ((MethodCore) member).Location);
+
+			//
+			// abstract or extern methods have no bodies
+			//
+			if ((modifiers & (Modifiers.ABSTRACT | Modifiers.EXTERN)) != 0){
+				if (block == null)
+					return;
+
+				//
+				// abstract or extern methods have no bodies.
+				//
+				if ((modifiers & Modifiers.ABSTRACT) != 0)
+					Report.Error (
+						500, Location, "Abstract method `" +
+						TypeManager.MonoBASIC_Signature (builder) +
+						"' can not have a body");
+
+				if ((modifiers & Modifiers.EXTERN) != 0)
+					Report.Error (
+						179, Location, "External method `" +
+						TypeManager.MonoBASIC_Signature (builder) +
+						"' can not have a body");
+
+				return;
+			}
+
+			//
+			// Methods must have a body unless they're extern or abstract
+			//
+			if (block == null) {
+				Report.Error (
+					501, Location, "Method `" +
+					TypeManager.MonoBASIC_Signature (builder) +
+					"' must declare a body since it is not marked " +
+					"abstract or extern");
+				return;
+			}
+
+			//
+			// Handle destructors specially
+			//
+			// FIXME: This code generates buggy code
+			//
+			if (member.Name == "Finalize" && ReturnType == TypeManager.void_type)
+				EmitDestructor (ec, block);
+			else {
+				ISymbolWriter sw = CodeGen.SymbolWriter;
+
+				if ((sw != null) && !Location.IsNull (Location) &&
+				    !Location.IsNull (block.EndLocation)) {
+					Location end = block.EndLocation;
+					MethodToken token = MethodBuilder.GetToken ();
+					sw.OpenMethod (new SymbolToken (token.Token));
+					// Avoid error if we don't support debugging for the platform
+					try {
+						sw.SetMethodSourceRange (Location.SymbolDocument,
+									 Location.Row, 0,
+									 end.SymbolDocument,
+									 end.Row, 0);
+					} catch (Exception) {
+					}
+
+					ec.EmitTopBlock (block, member.Name, ParameterInfo, Location);
+
+					sw.CloseMethod ();
+				} else
+					ec.EmitTopBlock (block, member.Name, ParameterInfo, Location);
+			}
+		}
+
+		void EmitDestructor (EmitContext ec, Block block)
+		{
+			ILGenerator ig = ec.ig;
+			
+			Label finish = ig.DefineLabel ();
+			bool old_in_try = ec.InTry;
+			
+			ig.BeginExceptionBlock ();
+			ec.InTry = true;
+			ec.ReturnLabel = finish;
+			ec.HasReturnLabel = true;
+			ec.EmitTopBlock (block, null, Location);
+			ec.InTry = old_in_try;
+			
+			// ig.MarkLabel (finish);
+			bool old_in_finally = ec.InFinally;
+			ec.InFinally = true;
+			ig.BeginFinallyBlock ();
+			
+			if (ec.ContainerType.BaseType != null) {
+				Expression member_lookup = Expression.MemberLookup (
+					ec, ec.ContainerType.BaseType, ec.ContainerType.BaseType, "Finalize",
+					MemberTypes.Method, Expression.AllBindingFlags, Location);
+
+				if (member_lookup != null){
+					MethodGroupExpr parent_destructor = ((MethodGroupExpr) member_lookup);
+				
+					ig.Emit (OpCodes.Ldarg_0);
+					ig.Emit (OpCodes.Call, (MethodInfo) parent_destructor.Methods [0]);
+				}
+			}
+			ec.InFinally = old_in_finally;
+			
+			ig.EndExceptionBlock ();
+			//ig.MarkLabel (ec.ReturnLabel);
+			ig.Emit (OpCodes.Ret);
+		}
+	}
+
+	abstract public class MemberBase : MemberCore {
+		public Expression Type;
+		public ArrayList Implements;
+
+		protected MethodAttributes flags;
+
+		//
+		// The "short" name of this property / indexer / event.  This is the
+		// name without the explicit interface.
+		//
+		public string ShortName;
+
+		//
+		// The type of this property / indexer / event
+		//
+		public Type MemberType;
+
+		//
+		// If true, this is an explicit interface implementation
+		//
+		public bool IsExplicitImpl = false;
+
+		//
+		// The name of the interface we are explicitly implementing
+		//
+		public string ExplicitInterfaceName = null;
+
+		//
+		// If true, the interface type we are explicitly implementing
+		//
+		public Type InterfaceType = null;
+		public ArrayList InterfaceTypes = null;
+
+		//
+		// The method we're overriding if this is an override method.
+		//
+		protected MethodInfo parent_method = null;
+		public MethodInfo ParentMethod {
+			get {
+				return parent_method;
+			}
+		}
+
+		//
+		// The constructor is only exposed to our children
+		//
+		protected MemberBase (Expression type, int mod, int allowed_mod, string name,
+				      Attributes attrs, Location loc)
+			: base (name, attrs, loc)
+		{
+			Type = type;
+			ModFlags = Modifiers.Check (allowed_mod, mod, Modifiers.PUBLIC, loc);
+		}
+
+		protected virtual bool CheckBase (TypeContainer parent)
+		{
+			return true;
+		}
+
+		protected virtual bool CheckParameters (TypeContainer parent, Type [] parameters)
+		{
+			bool error = false;
+
+			foreach (Type partype in parameters){
+				if (partype.IsPointer && !UnsafeOK (parent))
+					error = true;
+
+				if (parent.AsAccessible (partype, ModFlags))
+					continue;
+
+				Report.Error (51, Location,
+						    "Inconsistent accessibility: parameter type `" +
+						    TypeManager.MonoBASIC_Name (partype) + "' is less " +
+						    "accessible than method `" + Name + "'");
+				error = true;
+			}
+
+			return !error;
+		}
+
+		protected virtual bool DoDefine (TypeContainer parent)
+		{
+			if (Name == null)
+				Name = "this";
+
+			if (!parent.MethodModifiersValid (ModFlags, Name, Location))
+				return false;
+
+			flags = Modifiers.MethodAttr (ModFlags);
+
+			// Lookup Type, verify validity
+			MemberType = parent.ResolveType (Type, false, Location);
+			if (MemberType == null)
+				return false;
+
+			// check for whether the Interface is implemented by the class
+			if (Implements != null) {
+				InterfaceTypes = new ArrayList ();
+				foreach (Expression Impls in Implements) {
+					string iname = Impls.ToString();
+					iname = iname.Substring(0, iname.LastIndexOf("."));
+					bool iface_found = false;
+
+					InterfaceType  = RootContext.LookupType (
+						parent, iname, false, Location);
+					if (InterfaceType == null)
+						return false;
+
+					InterfaceTypes.Add (InterfaceType);
+					Type[] tbases = parent.TypeBuilder.GetInterfaces();
+
+				    if (tbases.Length != 0)	{
+						ArrayList bases = new ArrayList();
+						TypeManager.ExpandAllInterfaces (tbases, ref bases);
+
+						foreach (Type tbase in bases) {
+							/*
+							string bname = tbase.Name;
+							if (bname.LastIndexOf(".") != -1)
+								bname = bname.Substring(bname.LastIndexOf("."));
+							*/
+
+							//if (bname == iname)	{
+							if (tbase == InterfaceType) {
+								iface_found = true;
+								break;
+							}
+						}
+					}
+
+					if (!iface_found) {
+						Report.Error (31035, Location,
+							"Class '" + parent.Name + "' doesn't implement interface '" + iname + "'");
+						return false;
+					}
+				}
+			}
+
+			// verify accessibility
+			if (!parent.AsAccessible (MemberType, ModFlags)) {
+				if (this is Property)
+					Report.Error (53, Location,
+						      "Inconsistent accessibility: property type `" +
+						      TypeManager.MonoBASIC_Name (MemberType) + "' is less " +
+						      "accessible than property `" + Name + "'");
+				else if (this is Method)
+					Report.Error (30508, Location,
+						      "Inconsistent accessibility: return type `" +
+						      TypeManager.MonoBASIC_Name (MemberType) + "' is less " +
+						      "accessible than method `" + Name + "'");
+				else
+					Report.Error (52, Location,
+						      "Inconsistent accessibility: field type `" +
+						      TypeManager.MonoBASIC_Name (MemberType) + "' is less " +
+						      "accessible than field `" + Name + "'");
+				return false;
+			}
+
+			if (MemberType.IsPointer && !UnsafeOK (parent))
+				return false;
+			
+			//
+			// Check for explicit interface implementation
+			//
+			if ((ExplicitInterfaceName == null) && (Name.IndexOf (".") != -1)) {
+				int pos = Name.LastIndexOf (".");
+
+				ExplicitInterfaceName = Name.Substring (0, pos);
+				ShortName = Name.Substring (pos + 1);
+			} else
+				ShortName = Name;
+
+			return true;
+		}
+	}
+
+	//
+	// Fields and Events both generate FieldBuilders, we use this to share 
+	// their common bits.  This is also used to flag usage of the field
+	//
+	abstract public class FieldBase : MemberBase {
+		public FieldBuilder  FieldBuilder;
+		public Status status;
+
+		[Flags]
+		public enum Status : byte { ASSIGNED = 1, USED = 2 }
+
+		//
+		// The constructor is only exposed to our children
+		//
+		protected FieldBase (Expression type, int mod, int allowed_mod, string name,
+				     object init, Attributes attrs, Location loc)
+			: base (type, mod, allowed_mod, name, attrs, loc)
+		{
+			this.init = init;
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Field;
+			}
+		}
+
+
+		//
+		// Whether this field has an initializer.
+		//
+		public bool HasInitializer {
+			get {
+				return init != null;
+			}
+		}
+
+		// Private.
+		readonly Object init;
+		Expression init_expr;
+		bool init_expr_initialized = false;
+
+		//
+		// Resolves and returns the field initializer.
+		//
+		public Expression GetInitializerExpression (EmitContext ec)
+		{
+			if (init_expr_initialized)
+				return init_expr;
+
+			Expression e;
+			if (init is Expression)
+				e = (Expression) init;
+			else
+				e = new ArrayCreation (Type, "", (ArrayList)init, Location);
+
+			ec.IsFieldInitializer = true;
+			e = e.DoResolve (ec);
+			ec.IsFieldInitializer = false;
+
+			init_expr = e;
+			init_expr_initialized = true;
+
+			return init_expr;
+		}
+
+	}
+
+	//
+	// The Field class is used to represents class/struct fields during parsing.
+	//
+	public class Field : FieldBase {
+		// <summary>
+		//   Modifiers allowed in a class declaration
+		// </summary>
+		const int AllowedModifiers =
+			Modifiers.SHADOWS |
+			Modifiers.PUBLIC |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL |
+			Modifiers.PRIVATE |
+			Modifiers.STATIC |
+		   //     Modifiers.VOLATILE |
+		   //     Modifiers.UNSAFE |
+			Modifiers.READONLY;
+
+		public Field (Expression type, int mod, string name, Object expr_or_array_init,
+			      Attributes attrs, Location loc)
+			: base (type, mod, AllowedModifiers, name, expr_or_array_init, attrs, loc)
+		{
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Field;
+			}
+		}
+
+		public override bool Define (TypeContainer parent)
+		{
+			Type t = parent.ResolveType (Type, false, Location);
+			
+			if (t == null)
+				return false;
+
+			if (!parent.AsAccessible (t, ModFlags)) {
+				Report.Error (52, Location,
+					      "Inconsistent accessibility: field type `" +
+					      TypeManager.MonoBASIC_Name (t) + "' is less " +
+					      "accessible than field `" + Name + "'");
+				return false;
+			}
+
+			if (t.IsPointer && !UnsafeOK (parent))
+				return false;
+				
+			Type ptype = parent.TypeBuilder.BaseType;
+
+			// ptype is only null for System.Object while compiling corlib.
+			if (ptype != null){
+				MemberList list = TypeContainer.FindMembers (
+					ptype, MemberTypes.Field,
+					BindingFlags.Public |
+					BindingFlags.Static | BindingFlags.Instance,
+					System.Type.FilterName, Name);
+
+				if (RootContext.WarningLevel > 1){	
+					if ((list.Count > 0) && ((ModFlags & Modifiers.SHADOWS) == 0)) 
+					{
+						Report.Warning (
+							40004, 2, Location, 
+							"Variable '" + Name + "' should be declared " +
+							"Shadows since the base type '" + ptype.Name + 
+							"' has a variable with same name");
+
+						ModFlags |= Modifiers.SHADOWS;
+					}
+				}
+				if (list.Count == 0)
+					// if a member of module is not inherited from Object class
+					// can not be declared protected
+					if ((parent is Module) && ((ModFlags & Modifiers.PROTECTED) != 0))
+					Report.Error (30593, Location,
+						"'Variable' inside a 'Module' can not be " +
+						"declared as 'Protected'");
+			}
+			
+			if ((parent is Struct) && ((ModFlags & Modifiers.PROTECTED) != 0))
+				Report.Error (30435, Location,
+					"'Variable' inside a 'Structure' can not be " +
+					"declared as 'Protected'");
+
+			if ((ModFlags & Modifiers.VOLATILE) != 0){
+				if (!t.IsClass){
+					if (TypeManager.IsEnumType (t))
+						t = TypeManager.EnumToUnderlying (t);
+
+					if (!((t == TypeManager.bool_type) ||
+					      (t == TypeManager.sbyte_type) ||
+					      (t == TypeManager.byte_type) ||
+					      (t == TypeManager.short_type) ||    
+					      (t == TypeManager.ushort_type) ||
+					      (t == TypeManager.int32_type) ||    
+					      (t == TypeManager.uint32_type) ||    
+					      (t == TypeManager.char_type) ||    
+					      (t == TypeManager.float_type))){
+						Report.Error (
+							677, Location, parent.MakeName (Name) +
+							" A volatile field can not be of type `" +
+							TypeManager.MonoBASIC_Name (t) + "'");
+						return false;
+					}
+				}
+			}
+
+			FieldAttributes fa = Modifiers.FieldAttr (ModFlags);
+
+			if (parent is Struct && 
+			    ((fa & FieldAttributes.Static) == 0) &&
+			    t == parent.TypeBuilder &&
+			    !TypeManager.IsBuiltinType (t)){
+				Report.Error (523, Location, "Struct member `" + parent.Name + "." + Name + 
+					      "' causes a cycle in the structure layout");
+				return false;
+			}
+			
+			//Local Static Variable
+                        if (Name.StartsWith(@"$STATIC$"))
+                                FieldBuilder = parent.TypeBuilder.DefineField (
+                                        Name, t, Modifiers.FieldAttr (ModFlags) | FieldAttributes.SpecialName);
+                        else
+                                FieldBuilder = parent.TypeBuilder.DefineField (
+                                        Name, t, Modifiers.FieldAttr (ModFlags));
+
+			TypeManager.RegisterFieldBase (FieldBuilder, this);
+			return true;
+		}
+
+		public void Emit (TypeContainer tc)
+		{
+			EmitContext ec = new EmitContext (tc, Location, null,
+							  FieldBuilder.FieldType, ModFlags);
+
+			if (OptAttributes != null)
+				OptAttributes.Emit (ec, this);
+		}
+		
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+		{
+			FieldBuilder.SetCustomAttribute (cb);
+		}
+		
+	}
+
+	//
+	// `set' and `get' accessors are represented with an Accessor.
+	// 
+	public class Accessor {
+		//
+		// Null if the accessor is empty, or a Block if not
+		//
+		public Block Block;
+		public Attributes OptAttributes;
+		
+		public Accessor (Block b, Attributes attrs)
+		{
+			Block = b;
+			OptAttributes = attrs;
+		}
+	}
+
+	public class GetMethod {
+		private Accessor Get;
+		public MethodData GetData;
+		public MethodBuilder GetBuilder;
+
+		Property parent_property;
+		Location Location;
+
+		Parameters get_params;
+		
+		public GetMethod (Property parent_property, Accessor get_block, Attributes attrs, Parameters p_get, Location loc)
+		{
+			this.parent_property = parent_property;
+			Get = get_block;
+			get_params = p_get;
+			Location = loc;
+		}		
+		
+		public MethodBuilder Define (TypeContainer parent)
+		{
+			Type [] g_parameters=null;
+			Parameter [] g_parms;
+			InternalParameters g_ip=null;
+
+			if (get_params == Parameters.EmptyReadOnlyParameters) {
+				g_parameters = TypeManager.NoTypes;
+				g_ip = new InternalParameters (parent, Parameters.EmptyReadOnlyParameters);
+			} else	{
+				g_parameters = new Type [get_params.FixedParameters.Length];
+				for (int i = 0; i < get_params.FixedParameters.Length; i ++) {
+					g_parameters[i] = get_params.FixedParameters[i].ParameterType;
+				}
+				g_parms = new Parameter [get_params.FixedParameters.Length];
+				for (int i = 0; i < get_params.FixedParameters.Length; i ++) {
+					Parameter tp = get_params.FixedParameters[i];
+					g_parms[i] = new Parameter (tp.TypeName, tp.Name,
+						Parameter.Modifier.NONE, null);
+				}
+				g_ip = new InternalParameters (
+					parent, new Parameters (g_parms, null, Location));
+			}
+
+			GetData = new MethodData (parent_property, "get", parent_property.MemberType,
+						  g_parameters, g_ip, CallingConventions.Standard,
+						  Get.OptAttributes, parent_property.ModFlags, parent_property.MethodAttributeFlags, false);
+
+			if (!GetData.Define (parent))
+					return null;
+
+			GetBuilder = GetData.MethodBuilder;
+			
+			return GetBuilder;
+		}
+
+ 		public void Emit (TypeContainer tc)
+ 		{
+ 			if (GetData != null) 
+ 			{
+ 				parent_property.Parameters = get_params;
+ 				GetData.Emit (tc, Get.Block, Get);
+ 			}
+ 		}
+	}
+
+	public class SetMethod {
+		Accessor Set;
+		MethodData SetData;
+		MethodBuilder SetBuilder;
+
+		Property parent_property;
+		Location Location;
+
+		string set_parameter_name;
+		Parameters set_params;
+		
+		public SetMethod (Property parent_property, Accessor set_block, string set_name, 
+				Parameters p_set, Location loc)
+		{
+			this.parent_property = parent_property;
+			Set = set_block;
+			set_params = p_set;
+			set_parameter_name = set_name;
+			this.Location = loc;
+		}		
+		
+		public MethodBuilder Define (TypeContainer parent)
+		{
+			Type [] s_parameters=null;
+			Parameter [] s_parms;
+			InternalParameters s_ip=null;
+			
+			if (set_params == Parameters.EmptyReadOnlyParameters) 
+			{
+				s_parameters = new Type [1];
+				s_parameters [0] = parent_property.MemberType;
+
+				s_parms = new Parameter [1];
+				s_parms [0] = new Parameter (parent_property.Type, set_parameter_name, 
+					Parameter.Modifier.NONE, null);
+			} else {
+				s_parameters = new Type [set_params.FixedParameters.Length];
+				for (int i = 0; i < set_params.FixedParameters.Length; i ++) {
+					s_parameters[i] = set_params.FixedParameters[i].ParameterType;
+				}
+
+				s_parms = new Parameter [set_params.FixedParameters.Length];
+				for (int i = 0; i < set_params.FixedParameters.Length; i ++) {
+					Parameter tp = set_params.FixedParameters[i];
+					s_parms[i] = new Parameter (tp.TypeName, tp.Name,
+						Parameter.Modifier.NONE, null);
+				}
+			}
+
+			s_ip = new InternalParameters (
+				parent, new Parameters (s_parms, null, Location));
+
+			SetData = new MethodData (parent_property, "set", TypeManager.void_type,
+				s_parameters, s_ip, CallingConventions.Standard,
+				Set.OptAttributes, parent_property.ModFlags, parent_property.MethodAttributeFlags, false);
+
+			if (!SetData.Define (parent))
+				return null;
+
+			SetBuilder = SetData.MethodBuilder;
+			SetBuilder.DefineParameter (1, ParameterAttributes.None, 
+				set_parameter_name); 
+
+			return SetBuilder;
+		}
+
+		public void Emit (TypeContainer tc)
+		{
+			if (SetData != null) 
+			{
+				parent_property.Parameters = set_params;
+				SetData.Emit (tc, Set.Block, Set);
+			}
+		}
+	}
+
+	public class Property : MethodCore {
+		GetMethod GetMethod;
+		SetMethod SetMethod;
+		
+		public Accessor Set;
+		public PropertyBuilder PropertyBuilder;
+		public MethodBuilder GetBuilder;
+		public MethodBuilder SetBuilder;
+		public MethodData SetData;
+
+		protected EmitContext ec;
+
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+		{
+			PropertyBuilder.SetCustomAttribute (cb);
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Property;
+			}
+		}
+
+		protected override bool DoDefine (TypeContainer parent)
+		{
+			if (!base.DoDefine (parent))
+				return false;
+
+			ec = new EmitContext (parent, Location, null, MemberType, ModFlags);
+
+			return true;
+		}
+
+		//
+		// Checks our base implementation if any
+		//
+		protected override bool CheckBase (TypeContainer container)
+		{
+			base.CheckBase (container);
+			
+			// Check whether arguments were correct.
+			if (!DoDefineParameters (container))
+				return false;
+
+			if (IsExplicitImpl)
+				return true;
+
+			MethodSignature ms = new MethodSignature (Name, null, ParameterTypes);
+			if (!IsOperator) 
+			{
+				MemberList mi_this;
+
+				mi_this = TypeContainer.FindMembers (
+					container.TypeBuilder, MemberTypes.Property,
+					BindingFlags.NonPublic | BindingFlags.Public |
+					BindingFlags.Static | BindingFlags.Instance |
+					BindingFlags.DeclaredOnly,
+					MethodSignature.method_signature_filter, ms);
+
+				if (mi_this.Count > 0) {
+					Report.Error (111, Location, "Class `" + container.Name + "' " +
+						"already defines a member called `" + Name + "' " +
+						"with the same parameter types");
+					return false;
+				}
+			}
+
+			if (container is Interface)
+				return true;
+
+			Type retval = null;
+			if ((ModFlags & Modifiers.READONLY) != 0)
+				retval = MemberType;
+
+			//string report_name;
+			MethodSignature base_ms;
+			
+			/*
+			if (this is Indexer) {
+				string name, base_name;
+
+				report_name = "this";
+				name = TypeManager.IndexerPropertyName (container.TypeBuilder);
+				ms = new MethodSignature (name, null, ParameterTypes);
+				base_name = TypeManager.IndexerPropertyName (container.TypeBuilder.BaseType);
+				base_ms = new MethodSignature (base_name, retval, ParameterTypes);
+			} else */ {
+				//report_name = Name;
+				ms = base_ms = new MethodSignature (Name, retval, ParameterTypes);
+			}
+
+			//
+			// Verify if the parent has a type with the same name, and then
+			// check whether we have to create a new slot for it or not.
+			//
+			Type ptype = container.TypeBuilder.BaseType;
+
+			MemberInfo parent_member = null;
+			MemberList mi, mi_static, mi_instance;
+
+			//
+			// Find properties with the same name on the base class
+			//
+			mi_static = TypeContainer.FindMembers (
+				ptype, MemberTypes.Property,
+				BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static,
+				MethodSignature.inheritable_property_signature_filter, base_ms);
+
+			mi_instance = TypeContainer.FindMembers (
+				ptype, MemberTypes.Property,
+				BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance,
+				MethodSignature.inheritable_property_signature_filter,
+				base_ms);
+
+			if (mi_instance.Count > 0)
+				mi = mi_instance;
+			else if (mi_static.Count > 0)
+				mi = mi_static;
+			else
+				mi = null;
+
+			if (mi != null && mi.Count > 0) 
+				parent_member = (PropertyInfo) mi [0];
+			if (parent_member is PropertyInfo) {
+				PropertyInfo parent_property = (PropertyInfo)parent_member;
+
+				string name = parent_property.DeclaringType.Name + "." +
+					parent_property.Name;
+
+				MethodInfo get, set, parent_method;
+				get = parent_property.GetGetMethod (true);
+				set = parent_property.GetSetMethod (true);
+
+				if (get != null)
+					parent_method = get;
+				else if (set != null)
+					parent_method = set;
+				else
+					throw new Exception ("Internal error!");
+
+				if (!CheckMethodAgainstBase (container, flags, parent_method, name))
+					return false;
+
+				if ((ModFlags & Modifiers.NEW) == 0) {
+					Type parent_type = TypeManager.TypeToCoreType (
+						parent_property.PropertyType);
+
+					if (parent_type != MemberType) {
+						Report.Error (
+							508, Location, container.MakeName (Name) + ": cannot " +
+							"change return type when overriding " +
+							"inherited member " + name);
+						return false;
+					}
+				}
+			} else if (parent_member == null) {
+				/*if ((ModFlags & Modifiers.NEW) != 0)
+					WarningNotHiding (container);
+				*/
+
+				if ((ModFlags & ( Modifiers.NEW | Modifiers.SHADOWS | Modifiers.OVERRIDE )) == 0) {
+					if ((ModFlags & Modifiers.NONVIRTUAL) != 0)	{
+						Report.Error (31088, Location,
+							container.MakeName (Name) + " : Cannot " +
+							"be declared NotOverridable since this method is " +
+							"not maked as Overrides");
+					}
+				}
+				// if a member of module is not inherited from Object class
+				// can not be declared protected
+				if ((container is Module) && ((ModFlags & Modifiers.PROTECTED) != 0))
+					Report.Error (31066, Location,
+						"'Property' inside a 'Module' can not be declared as " +
+						"'Protected' or 'Protected Friend'");
+			}
+			return true;
+		}
+
+
+		const int AllowedModifiers =
+			Modifiers.NEW |
+			Modifiers.PUBLIC |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL |
+			Modifiers.PRIVATE |
+			Modifiers.STATIC |
+			Modifiers.SEALED |
+			Modifiers.OVERRIDE |
+			Modifiers.ABSTRACT |
+		    	Modifiers.UNSAFE |
+			Modifiers.EXTERN |
+			Modifiers.VIRTUAL |
+			Modifiers.NONVIRTUAL |
+			Modifiers.DEFAULT |
+			Modifiers.READONLY |
+			Modifiers.WRITEONLY |
+			Modifiers.SHADOWS;
+
+		//string set_parameter_name;
+		//Parameters get_params;
+		//Parameters set_params;
+		
+		public Property (Expression type, string name, int mod_flags,
+				Accessor get_block, Accessor set_block,
+				Attributes attrs, Location loc, string set_name, 
+				Parameters p_get, Parameters p_set, ArrayList impl_what)
+			: base (type, mod_flags, AllowedModifiers, name, attrs, p_set, loc)
+		
+		{
+			if (get_block != null)
+				GetMethod = new GetMethod (this, get_block, attrs, p_get, loc);
+
+			if (set_block != null)
+				SetMethod = new SetMethod (this, set_block, set_name, p_set, loc);
+			
+			Implements = impl_what;
+		}		
+		
+		public Property (Expression type, string name, int mod_flags,
+				 Accessor get_block, Accessor set_block,
+				 Attributes attrs, Location loc)
+			: this (type, name, mod_flags, get_block, set_block, attrs, loc, 
+					"Value", Parameters.EmptyReadOnlyParameters, Parameters.EmptyReadOnlyParameters, null)
+		{
+		}
+
+		public override bool Define (TypeContainer parent)
+		{
+			/*Type [] s_parameters=null;
+			Parameter [] s_parms;
+			InternalParameters s_ip=null;*/
+			
+			if ((parent is Struct) && ((ModFlags & Modifiers.PROTECTED) != 0))
+				Report.Error (30435, Location,
+					"'Property' inside a 'Structure' can not be declared as " +
+					"'Protected' or 'Protected Friend'");
+
+			if (((ModFlags & Modifiers.DEFAULT) != 0) && (Parameters == null || Parameters.CountStandardParams () == 0)) {
+				Report.Error (31048, Location, "Properties with no required " +
+					"parameters cannot be declared 'Default'");
+				return false;
+			}
+
+			if (!DoDefine (parent))
+				return false;
+
+			if (!CheckBase (parent))
+				return false;
+
+			flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName;
+
+			if (GetMethod == null) {
+				if ((ModFlags & Modifiers.WRITEONLY) == 0)
+					Report.Error (
+						30124, Location,
+						"Property without 'Get' accessor must have a 'WriteOnly' modifier");
+			} else
+				GetBuilder = GetMethod.Define (parent);
+
+			if (SetMethod== null) {
+				if ((ModFlags & Modifiers.READONLY) == 0)
+					Report.Error (
+						30124, Location,
+						"Property without 'Set' accessor must have a 'ReadOnly' modifier");
+						
+			}
+			else 
+				SetBuilder = SetMethod.Define (parent);
+
+			// FIXME - PropertyAttributes.HasDefault ?
+			
+			PropertyAttributes prop_attr =
+			PropertyAttributes.RTSpecialName |
+			PropertyAttributes.SpecialName;
+
+			if (!IsExplicitImpl){
+				PropertyBuilder = parent.TypeBuilder.DefineProperty (
+					Name, prop_attr, MemberType, null);
+				
+				PropertyBuilder.SetGetMethod (GetBuilder);
+				PropertyBuilder.SetSetMethod (SetBuilder);
+
+				//
+				// HACK for the reasons exposed above
+				//
+				if (!TypeManager.RegisterProperty (PropertyBuilder, GetBuilder, SetBuilder)) {
+					Report.Error (
+						111, Location,
+						"Class `" + parent.Name +
+						"' already contains a definition for the property `" +
+						Name + "'");
+					return false;
+				}
+			}
+			return true;
+		}
+
+		public void Emit (TypeContainer tc)
+		{
+			//
+			// The PropertyBuilder can be null for explicit implementations, in that
+			// case, we do not actually emit the ".property", so there is nowhere to
+			// put the attribute
+			//
+			
+			if (PropertyBuilder != null && OptAttributes != null)
+				OptAttributes.Emit (ec, this);
+			
+			if (GetMethod != null) 
+			{
+				GetMethod.Emit (tc);
+			}
+
+			if (SetMethod != null) 
+			{
+				SetMethod.Emit (tc);
+			}
+		}
+
+		public MethodAttributes MethodAttributeFlags {
+			get {
+				return flags;
+			}
+		}
+
+	}
+
+	/// </summary>
+	///  Gigantic workaround  for lameness in SRE follows :
+	///  This class derives from EventInfo and attempts to basically
+	///  wrap around the EventBuilder so that FindMembers can quickly
+	///  return this in it search for members
+	/// </summary>
+	public class MyEventBuilder : EventInfo {
+		
+		//
+		// We use this to "point" to our Builder which is
+		// not really a MemberInfo
+		//
+		EventBuilder MyBuilder;
+		
+		//
+		// We "catch" and wrap these methods
+		//
+		MethodInfo raise, remove, add;
+
+		EventAttributes attributes;
+		Type declaring_type, reflected_type, event_type;
+		string name;
+
+		public MyEventBuilder (TypeBuilder type_builder, string name, EventAttributes event_attr, Type event_type)
+		{
+			MyBuilder = type_builder.DefineEvent (name, event_attr, event_type);
+
+			// And now store the values in our own fields.
+			
+			declaring_type = type_builder;
+
+			reflected_type = type_builder;
+			
+			attributes = event_attr;
+			this.name = name;
+			this.event_type = event_type;
+		}
+		
+		//
+		// Methods that you have to override.  Note that you only need 
+		// to "implement" the variants that take the argument (those are
+		// the "abstract" methods, the others (GetAddMethod()) are 
+		// regular.
+		//
+		public override MethodInfo GetAddMethod (bool nonPublic)
+		{
+			return add;
+		}
+		
+		public override MethodInfo GetRemoveMethod (bool nonPublic)
+		{
+			return remove;
+		}
+		
+		public override MethodInfo GetRaiseMethod (bool nonPublic)
+		{
+			return raise;
+		}
+		
+		//
+		// These methods make "MyEventInfo" look like a Builder
+		//
+		public void SetRaiseMethod (MethodBuilder raiseMethod)
+		{
+			raise = raiseMethod;
+			MyBuilder.SetRaiseMethod (raiseMethod);
+		}
+
+		public void SetRemoveOnMethod (MethodBuilder removeMethod)
+		{
+			remove = removeMethod;
+			MyBuilder.SetRemoveOnMethod (removeMethod);
+		}
+
+		public void SetAddOnMethod (MethodBuilder addMethod)
+		{
+			add = addMethod;
+			MyBuilder.SetAddOnMethod (addMethod);
+		}
+
+		public void SetCustomAttribute (CustomAttributeBuilder cb)
+		{
+			MyBuilder.SetCustomAttribute (cb);
+		}
+		
+		public override object [] GetCustomAttributes (bool inherit)
+		{
+			// FIXME : There's nothing which can be seemingly done here because
+			// we have no way of getting at the custom attribute objects of the
+			// EventBuilder !
+			return null;
+		}
+
+		public override object [] GetCustomAttributes (Type t, bool inherit)
+		{
+			// FIXME : Same here !
+			return null;
+		}
+
+		public override bool IsDefined (Type t, bool b)
+		{
+			return true;
+		}
+
+		public override EventAttributes Attributes {
+			get {
+				return attributes;
+			}
+		}
+
+		public override string Name {
+			get {
+				return name;
+			}
+		}
+
+		public override Type DeclaringType {
+			get {
+				return declaring_type;
+			}
+		}
+
+		public override Type ReflectedType {
+			get {
+				return reflected_type;
+			}
+		}
+
+		public Type EventType {
+			get {
+				return event_type;
+			}
+		}
+	}
+
+	
+	public class AddDelegateMethod {
+		MethodBuilder AddBuilder;
+		MethodData AddData;
+		Event parent_event;
+		Location Location;
+		
+		public AddDelegateMethod (Event parent_event, Location loc)
+		{
+			this.parent_event = parent_event;
+			Location = loc;
+		}
+
+		public MethodBuilder Define (TypeContainer parent)
+		{
+			Type [] parameter_types = new Type [1];
+			parameter_types [0] = parent_event.MemberType;
+
+			Parameter [] parms = new Parameter [1];
+			parms [0] = new Parameter (parent_event.Type, /* was "value" */ parent_event.Name, Parameter.Modifier.NONE, null);
+			InternalParameters ip = new InternalParameters (
+				parent, new Parameters (parms, null, Location)); 
+
+			AddData = new MethodData (parent_event, "add", TypeManager.void_type,
+						  parameter_types, ip, CallingConventions.Standard, null,
+						  parent_event.ModFlags, parent_event.MethodAttributeFlags, false);
+
+			if (!AddData.Define (parent))
+				return null;
+
+			AddBuilder = AddData.MethodBuilder;
+			AddBuilder.DefineParameter (1, ParameterAttributes.None, /* was "value" */ parent_event.Name);
+
+
+			return AddBuilder;
+		}
+
+
+		public void Emit (TypeContainer tc)
+		{
+			ILGenerator ig = AddData.MethodBuilder.GetILGenerator ();
+			EmitContext ec = new EmitContext (tc, Location, ig, TypeManager.void_type, parent_event.ModFlags);
+			parent_event.EmitDefaultMethod (ec, true);
+		}
+	}
+
+	public class RemoveDelegateMethod {
+		MethodBuilder RemoveBuilder;
+		MethodData RemoveData;
+		Event parent_event;
+		Location Location;
+		
+		public RemoveDelegateMethod (Event parent_event, Location loc)
+		{
+			this.parent_event = parent_event;
+			Location = loc;
+		}
+
+		public MethodBuilder Define (TypeContainer parent)
+		{
+			//EventAttributes e_attr = EventAttributes.RTSpecialName | EventAttributes.SpecialName;
+
+			Type [] parameter_types = new Type [1];
+			parameter_types [0] = parent_event.MemberType;
+
+			Parameter [] parms = new Parameter [1];
+			parms [0] = new Parameter (parent_event.Type, /* was "value" */ parent_event.Name, Parameter.Modifier.NONE, null);
+			InternalParameters ip = new InternalParameters (
+				parent, new Parameters (parms, null, Location)); 
+
+
+			RemoveData = new MethodData (parent_event, "remove", TypeManager.void_type,
+						     parameter_types, ip, CallingConventions.Standard, null,
+						     parent_event.ModFlags, parent_event.MethodAttributeFlags, false);
+
+			if (!RemoveData.Define (parent))
+				return null;
+
+			RemoveBuilder = RemoveData.MethodBuilder;
+			RemoveBuilder.DefineParameter (1, ParameterAttributes.None, /* was "value" */ parent_event.Name);
+
+			return RemoveBuilder;
+		}
+
+		public void Emit (TypeContainer tc)
+		{
+			ILGenerator ig = RemoveData.MethodBuilder.GetILGenerator ();
+			EmitContext ec = new EmitContext (tc, Location, ig, TypeManager.void_type, parent_event.ModFlags);
+			parent_event.EmitDefaultMethod (ec, false);
+		}
+	}
+	
+	public class Event : FieldBase {
+		const int AllowedModifiers =
+			Modifiers.NEW |
+			Modifiers.PUBLIC |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL |
+			Modifiers.PRIVATE |
+			Modifiers.STATIC |
+			Modifiers.VIRTUAL |
+			Modifiers.SEALED |
+			Modifiers.OVERRIDE |
+			Modifiers.UNSAFE |
+			Modifiers.ABSTRACT;
+
+		public readonly AddDelegateMethod  Add;
+		public readonly RemoveDelegateMethod  Remove;
+		public MyEventBuilder     EventBuilder;
+
+		MethodBuilder AddBuilder, RemoveBuilder;
+		
+		public Event (Expression type, string name, Object init, int mod, Attributes attrs, Location loc)
+	      			: base (type, mod, AllowedModifiers, name, init, attrs, loc)
+		{
+			Add = new AddDelegateMethod (this, loc);
+			Remove = new RemoveDelegateMethod (this, loc);
+
+			Implements = null;
+		}
+
+		public Event (Expression type, string name, Object init, int mod,  Attributes attrs, ArrayList impl_what, Location loc)
+			: base (type, mod, AllowedModifiers, name, init, attrs, loc)
+		{
+			Add = new AddDelegateMethod (this, loc);
+			Remove = new RemoveDelegateMethod (this, loc);
+
+			Implements = impl_what;
+		}
+
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+		{
+			EventBuilder.SetCustomAttribute (cb);
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Event;
+			}
+		}
+		
+		public override bool Define (TypeContainer parent)
+		{
+			EventAttributes e_attr = EventAttributes.RTSpecialName | EventAttributes.SpecialName;
+
+			if (!DoDefine (parent))
+				return false;
+
+			if (!MemberType.IsSubclassOf (TypeManager.delegate_type)) {
+				Report.Error (31044, Location, "'" + parent.Name + "." + Name +
+					      "' : event must be of a delegate type");
+				return false;
+			}
+
+			Type [] parameter_types = new Type [1];
+			parameter_types [0] = MemberType;
+
+			Parameter [] parms = new Parameter [1];
+			parms [0] = new Parameter (Type, /* was "value" */ this.Name, Parameter.Modifier.NONE, null);
+			/*InternalParameters ip = new InternalParameters (
+				parent, new Parameters (parms, null, Location)); 
+			*/
+
+			if (!CheckBase (parent))
+				return false;
+
+			AddBuilder = Add.Define (parent);
+			RemoveBuilder = Remove.Define (parent);
+			
+
+			if (!IsExplicitImpl){
+				EventBuilder = new MyEventBuilder (
+					parent.TypeBuilder, Name, e_attr, MemberType);
+					
+				FieldBuilder = parent.TypeBuilder.DefineField (Name, MemberType,
+						FieldAttributes.FamANDAssem | ((ModFlags & Modifiers.STATIC) != 0 ? FieldAttributes.Static : 0));
+				TypeManager.RegisterPrivateFieldOfEvent ((EventInfo) EventBuilder, FieldBuilder);
+				TypeManager.RegisterFieldBase (FieldBuilder, this);
+			
+				EventBuilder.SetAddOnMethod (AddBuilder);
+				EventBuilder.SetRemoveOnMethod (RemoveBuilder);
+
+				if (!TypeManager.RegisterEvent (EventBuilder, AddBuilder, RemoveBuilder)) {
+					Report.Error (111, Location,
+					  	    "Class `" + parent.Name +
+					     	 "' already contains a definition for the event `" +
+					     	 Name + "'");
+					return false;
+				}
+			}
+			
+			return true;
+		}
+
+		public void EmitDefaultMethod (EmitContext ec, bool is_add)
+		{
+			ILGenerator ig = ec.ig;
+			MethodInfo method = null;
+			
+			if (is_add)
+				method = TypeManager.delegate_combine_delegate_delegate;
+			else
+				method = TypeManager.delegate_remove_delegate_delegate;
+
+			if ((ModFlags & Modifiers.STATIC) != 0) {
+				ig.Emit (OpCodes.Ldsfld, (FieldInfo) FieldBuilder);
+				ig.Emit (OpCodes.Ldarg_0);
+				ig.Emit (OpCodes.Call, method);
+				ig.Emit (OpCodes.Castclass, MemberType);
+				ig.Emit (OpCodes.Stsfld, (FieldInfo) FieldBuilder);
+			} else {
+				ig.Emit (OpCodes.Ldarg_0);
+				ig.Emit (OpCodes.Ldarg_0);
+				ig.Emit (OpCodes.Ldfld, (FieldInfo) FieldBuilder);
+				ig.Emit (OpCodes.Ldarg_1);
+				ig.Emit (OpCodes.Call, method);
+				ig.Emit (OpCodes.Castclass, MemberType);
+				ig.Emit (OpCodes.Stfld, (FieldInfo) FieldBuilder);
+			}
+			ig.Emit (OpCodes.Ret);
+		}
+
+		public void Emit (TypeContainer tc)
+		{
+			EmitContext ec;
+
+			ec = new EmitContext (tc, Location, null, MemberType, ModFlags);
+
+			if (OptAttributes != null)
+				OptAttributes.Emit (ec, this);
+
+			Add.Emit (tc);
+			Remove.Emit (tc);
+		}
+
+		public MethodAttributes MethodAttributeFlags {
+			get {
+				return flags;
+			}
+		}
+		
+	}
+
+	struct MethodSignature {
+		public string Name;
+		public Type RetType;
+		public Type [] Parameters;
+		
+		/// <summary>
+		///    This delegate is used to extract methods which have the
+		///    same signature as the argument
+		/// </summary>
+		public static MemberFilter method_signature_filter;
+
+		/// <summary>
+		///    This delegate is used to extract methods which have the
+		///    same signature as the argument except for the name
+		/// </summary>
+		public static MemberFilter method_signature_noname_filter;
+
+		/// <summary>
+		///   This delegate is used to extract inheritable methods which
+		///   have the same signature as the argument.  By inheritable,
+		///   this means that we have permissions to override the method
+		///   from the current assembly and class
+		/// </summary>
+		public static MemberFilter inheritable_method_signature_filter;
+
+		/// <summary>
+		///   This delegate is used to extract inheritable methods which
+		///   have the same signature as the argument.  By inheritable,
+		///   this means that we have permissions to override the method
+		///   from the current assembly and class
+		/// </summary>
+		public static MemberFilter inheritable_property_signature_filter;
+		
+		static MethodSignature ()
+		{
+			method_signature_filter = new MemberFilter (MemberSignatureCompare);
+			method_signature_noname_filter = new MemberFilter (MemberSignatureCompareNoName);
+			inheritable_method_signature_filter = new MemberFilter (
+				InheritableMemberSignatureCompare);
+			inheritable_property_signature_filter = new MemberFilter (
+				InheritablePropertySignatureCompare);
+		}
+		
+		public MethodSignature (string name, Type ret_type, Type [] parameters)
+		{
+			Name = name;
+			RetType = ret_type;
+
+			if (parameters == null)
+				Parameters = TypeManager.NoTypes;
+			else
+				Parameters = parameters;
+		}
+		
+		public override int GetHashCode ()
+		{
+			return Name.GetHashCode ();
+		}
+
+		public override bool Equals (Object o)
+		{
+			MethodSignature other = (MethodSignature) o;
+
+			if (other.Name != Name)
+				return false;
+
+			if (other.RetType != RetType)
+				return false;
+			
+			if (Parameters == null){
+				if (other.Parameters == null)
+					return true;
+				return false;
+			}
+
+			if (other.Parameters == null)
+				return false;
+			
+			int c = Parameters.Length;
+			if (other.Parameters.Length != c)
+				return false;
+
+			for (int i = 0; i < c; i++)
+				if (other.Parameters [i] != Parameters [i])
+					return false;
+
+			return true;
+		}
+
+		static bool MemberSignatureCompareNoName (MemberInfo m, object filter_criteria)
+		{
+			return MemberSignatureCompare (m, filter_criteria, false);
+		}
+
+		static bool MemberSignatureCompare (MemberInfo m, object filter_criteria)
+		{
+			return MemberSignatureCompare (m, filter_criteria, true);
+		}
+
+		static bool MemberSignatureCompare (MemberInfo m, object filter_criteria, bool use_name)
+		{
+			MethodSignature sig = (MethodSignature) filter_criteria;
+
+			if (use_name && (m.Name != sig.Name))
+				return false;
+
+			Type ReturnType;
+			MethodInfo mi = m as MethodInfo;
+			PropertyInfo pi = m as PropertyInfo;
+
+			if (mi != null)
+				ReturnType = mi.ReturnType;
+			else if (pi != null)
+				ReturnType = pi.PropertyType;
+			else
+				return false;
+
+			//
+			// we use sig.RetType == null to mean `do not check the
+			// method return value.  
+			//
+			if (sig.RetType != null)
+				if (ReturnType != sig.RetType)
+					return false;
+
+			Type [] args;
+			if (mi != null)
+				args = TypeManager.GetArgumentTypes (mi);
+			else
+				args = TypeManager.GetArgumentTypes (pi);
+
+			Type [] sigp = sig.Parameters;
+
+			if (args.Length != sigp.Length)
+				return false;
+
+			for (int i = args.Length; i > 0; ){
+				i--;
+				if (args [i] != sigp [i])
+					return false;
+			}
+			return true;
+		}
+
+		//
+		// This filter should be used when we are requesting methods that
+		// we want to override.
+		//
+		// This makes a number of assumptions, for example
+		// that the methods being extracted are of a parent
+		// class (this means we know implicitly that we are
+		// being called to find out about members by a derived
+		// class).
+		// 
+		static bool InheritableMemberSignatureCompare (MemberInfo m, object filter_criteria)
+		{
+		        if (MemberSignatureCompare (m, filter_criteria)){
+				MethodInfo mi = (MethodInfo) m;
+				MethodAttributes prot = mi.Attributes & MethodAttributes.MemberAccessMask;
+
+				// If only accessible to the current class.
+				if (prot == MethodAttributes.Private)
+					return false;
+
+				// If only accessible to the defining assembly or 
+				if (prot == MethodAttributes.FamANDAssem ||
+				    prot == MethodAttributes.Assembly){
+					if (m.DeclaringType.Assembly == CodeGen.AssemblyBuilder)
+						return true;
+					else
+						return false;
+				}
+
+				// Anything else (FamOrAssembly and Public) is fine
+				return true;
+			}
+			return false;
+		}
+
+		//
+		// This filter should be used when we are requesting properties that
+		// we want to override.
+		//
+		// This makes a number of assumptions, for example
+		// that the methods being extracted are of a parent
+		// class (this means we know implicitly that we are
+		// being called to find out about members by a derived
+		// class).
+		// 
+		static bool InheritablePropertySignatureCompare (MemberInfo m, object filter_criteria)
+		{
+	        if (MemberSignatureCompare (m, filter_criteria)){
+				PropertyInfo pi = (PropertyInfo) m;
+
+				MethodInfo inherited_get = TypeManager.GetPropertyGetter (pi);
+				MethodInfo inherited_set = TypeManager.GetPropertySetter (pi);
+
+				MethodInfo mi = inherited_get == null ? inherited_set : inherited_get;
+
+				MethodAttributes prot = mi.Attributes & MethodAttributes.MemberAccessMask;
+
+				// If only accessible to the current class.
+				if (prot == MethodAttributes.Private)
+					return false;
+
+				// If only accessible to the defining assembly or 
+				if (prot == MethodAttributes.FamANDAssem ||
+				    prot == MethodAttributes.Assembly){
+					if (m.DeclaringType.Assembly == CodeGen.AssemblyBuilder)
+						return true;
+					else
+						return false;
+				}
+
+				// Anything else (FamOrAssembly and Public) is fine
+				return true;
+			}
+			return false;
+		}
+	}
+}
diff --git a/dead/mbas/codegen.cs b/dead/mbas/codegen.cs
new file mode 100644
index 00000000..163ad3c8
--- /dev/null
+++ b/dead/mbas/codegen.cs
@@ -0,0 +1,841 @@
+//
+// codegen.cs: The code generator
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//
+// (C) 2001 Ximian, Inc.
+//
+
+using System;
+using System.IO;
+using System.Collections;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Diagnostics.SymbolStore;
+
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///    Code generator class.
+	/// </summary>
+	public class CodeGen {
+		static AppDomain current_domain;
+
+		public static AssemblyBuilder AssemblyBuilder {
+			get { 
+				return Assembly.Builder;
+			}				
+
+			set {
+				Assembly.Builder = value;
+			}				
+		}
+
+		public static ModuleBuilder ModuleBuilder {
+			get { 
+				return Module.Builder;
+			}				
+
+			set {
+				Module.Builder = value;
+			}				
+		}
+
+		public static AssemblyClass Assembly;
+		public static ModuleClass Module;
+		public static ArrayList ArrListVersion = new ArrayList();//keeps the version's 4 numbers
+
+		static public ISymbolWriter SymbolWriter;
+
+		static CodeGen ()
+		{
+			Assembly = new AssemblyClass ();
+			Module = new ModuleClass ();
+		}
+
+		public static string Basename (string name)
+		{
+			int pos = name.LastIndexOf ("/");
+
+			if (pos != -1)
+				return name.Substring (pos + 1);
+
+			pos = name.LastIndexOf ("\\");
+			if (pos != -1)
+				return name.Substring (pos + 1);
+
+			return name;
+		}
+
+		public static string Dirname (string name)
+		{
+			int pos = name.LastIndexOf ("/");
+
+			if (pos != -1)
+				return name.Substring (0, pos);
+
+			pos = name.LastIndexOf ("\\");
+			if (pos != -1)
+				return name.Substring (0, pos);
+
+			return ".";
+		}
+
+		static string TrimExt (string name)
+		{
+			int pos = name.LastIndexOf (".");
+
+			return name.Substring (0, pos);
+		}
+
+		static public string FileName;
+
+		//
+		// This routine initializes the Mono runtime SymbolWriter.
+		//
+		static bool InitMonoSymbolWriter (string basename, string symbol_output,
+						  string exe_output_file, string[] debug_args)
+		{
+			Type itype = SymbolWriter.GetType ();
+			if (itype == null)
+				return false;
+
+			Type[] arg_types = new Type [3];
+			arg_types [0] = typeof (string);
+			arg_types [1] = typeof (string);
+			arg_types [2] = typeof (string[]);
+
+			MethodInfo initialize = itype.GetMethod ("Initialize", arg_types);
+			if (initialize == null)
+				return false;
+
+			object[] args = new object [3];
+			args [0] = exe_output_file;
+			args [1] = symbol_output;
+			args [2] = debug_args;
+
+			initialize.Invoke (SymbolWriter, args);
+			return true;
+		}
+
+		//
+		// Initializes the symbol writer
+		//
+		static void InitializeSymbolWriter (string basename, string symbol_output,
+						    string exe_output_file, string[] args)
+		{
+			SymbolWriter = ModuleBuilder.GetSymWriter ();
+
+			//
+			// If we got an ISymbolWriter instance, initialize it.
+			//
+			if (SymbolWriter == null) {
+				Report.Warning (
+					-18, "Cannot find any symbol writer");
+				return;
+			}
+			
+			//
+			// Due to lacking documentation about the first argument of the
+			// Initialize method, we cannot use Microsoft's default symbol
+			// writer yet.
+			//
+			// If we're using the mono symbol writer, the SymbolWriter object
+			// is of type MonoSymbolWriter - but that's defined in a dynamically
+			// loaded DLL - that's why we're doing a comparision based on the type
+			// name here instead of using `SymbolWriter is MonoSymbolWriter'.
+			//
+			Type sym_type = ((object) SymbolWriter).GetType ();
+			
+			switch (sym_type.Name){
+			case "MonoSymbolWriter":
+				if (!InitMonoSymbolWriter (basename, symbol_output,
+							   exe_output_file, args))
+					Report.Warning (
+						-18, "Cannot initialize the symbol writer");
+				break;
+
+			default:
+				Report.Warning (
+					-18, "Cannot generate debugging information on this platform");
+				break;
+			}
+		}
+
+		//
+		// Initializes the code generator variables
+		//
+		static public void Init (string name, string output, bool want_debugging_support,
+					 string[] debug_args)
+		{
+			AssemblyName an;
+
+			FileName = output;
+			an = new AssemblyName ();
+			an.Name = TrimExt (Basename (name));
+			current_domain = AppDomain.CurrentDomain;
+			
+			if (ArrListVersion.Count < 4)//4 -> Major, Minor,Version, Build
+			for(int i=ArrListVersion.Count-1;i<4;i++)
+				ArrListVersion.Add(0);
+			an.Version = new Version (Convert.ToInt32(ArrListVersion[0]), Convert.ToInt32(ArrListVersion[1]), Convert.ToInt32(ArrListVersion[2]), Convert.ToInt32(ArrListVersion[3]));
+	
+			AssemblyBuilder = current_domain.DefineDynamicAssembly (
+				an, AssemblyBuilderAccess.RunAndSave, Dirname (name));
+
+			//
+			// Pass a path-less name to DefineDynamicModule.  Wonder how
+			// this copes with output in different directories then.
+			// FIXME: figure out how this copes with --output /tmp/blah
+			//
+			// If the third argument is true, the ModuleBuilder will dynamically
+			// load the default symbol writer.
+			//
+			
+			ModuleBuilder = AssemblyBuilder.DefineDynamicModule (
+				Basename (name), Basename (output), want_debugging_support);
+
+			int pos = output.LastIndexOf (".");
+
+			string basename;
+			if (pos > 0)
+				basename = output.Substring (0, pos);
+			else
+				basename = output;
+
+			string symbol_output = basename + ".dbg";
+
+			if (want_debugging_support)
+				InitializeSymbolWriter (basename, symbol_output, output, debug_args);
+			else {
+				try {
+					File.Delete (symbol_output);
+				} catch {
+					// Ignore errors.
+				}
+			}
+		}
+
+		static public void Save (string name)
+		{
+			try {
+				AssemblyBuilder.Save (Basename (name));
+			} catch (System.IO.IOException io){
+				Report.Error (16, "Coult not write to file `"+name+"', cause: " + io.Message);
+			}
+		}
+
+		static public void SaveSymbols ()
+		{
+			if (SymbolWriter != null) {
+				// If we have a symbol writer, call its Close() method to write
+				// the symbol file to disk.
+				//
+				// When using Mono's default symbol writer, the Close() method must
+				// be called after the assembly has already been written to disk since
+				// it opens the assembly and reads its metadata.
+				SymbolWriter.Close ();
+			}
+		}
+
+		public static void AddGlobalAttributes (ArrayList attrs)
+		{
+			foreach (Attribute attr in attrs) {
+				if (attr.IsAssemblyAttribute)
+				{
+					Assembly.AddAttribute (attr);
+				}
+				else if (attr.IsModuleAttribute)
+				{
+					Module.AddAttribute (attr);
+				}
+			}
+		}
+
+		public static void EmitGlobalAttributes ()
+		{
+			//Assembly.Emit (Tree.Types);
+			//Module.Emit (Tree.Types);
+			
+
+		}
+	}
+
+	/// <summary>
+	///   An Emit Context is created for each body of code (from methods,
+	///   properties bodies, indexer bodies or constructor bodies)
+	/// </summary>
+	public class EmitContext {
+		
+		public DeclSpace DeclSpace;
+		public TypeContainer TypeContainer;
+		public ILGenerator   ig;
+	
+
+		/// <summary>
+		///   This variable tracks the `checked' state of the compilation,
+		///   it controls whether we should generate code that does overflow
+		///   checking, or if we generate code that ignores overflows.
+		///
+		///   The default setting comes from the command line option to generate
+		///   checked or unchecked code plus any source code changes using the
+		///   checked/unchecked statements or expressions.   Contrast this with
+		///   the ConstantCheckState flag.
+		/// </summary>
+		
+		public bool CheckState;
+
+		/// <summary>
+		///   The constant check state is always set to `true' and cant be changed
+		///   from the command line.  The source code can change this setting with
+		///   the `checked' and `unchecked' statements and expressions. 
+		/// </summary>
+		public bool ConstantCheckState;
+
+		/// <summary>
+		///   Whether we are emitting code inside a static or instance method
+		/// </summary>
+		public bool IsStatic;
+
+		/// <summary>
+		///   Whether we are emitting a field initializer
+		/// </summary>
+		public bool IsFieldInitializer;
+
+		/// <summary>
+		///   The value that is allowed to be returned or NULL if there is no
+		///   return type.
+		/// </summary>
+		public Type ReturnType;
+
+		/// <summary>
+		///   Points to the Type (extracted from the TypeContainer) that
+		///   declares this body of code
+		/// </summary>
+		public Type ContainerType;
+		
+		/// <summary>
+		///   Whether this is generating code for a constructor
+		/// </summary>
+		public bool IsConstructor;
+
+		/// <summary>
+		///   Whether we're control flow analysis enabled
+		/// </summary>
+		public bool DoFlowAnalysis;
+		
+		/// <summary>
+		///   Keeps track of the Type to LocalBuilder temporary storage created
+		///   to store structures (used to compute the address of the structure
+		///   value on structure method invocations)
+		/// </summary>
+		public Hashtable temporary_storage;
+
+		public Block CurrentBlock;
+
+		/// <summary>
+		///   The location where we store the return value.
+		/// </summary>
+		LocalBuilder return_value;
+
+		/// <summary>
+		///   The location where return has to jump to return the
+		///   value
+		/// </summary>
+		public Label ReturnLabel;
+
+		/// <summary>
+		///   If we already defined the ReturnLabel
+		/// </summary>
+		public bool HasReturnLabel;
+
+		/// <summary>
+		///   The location where to exit
+		/// </summary>
+		public Label ExitLabel;
+
+		/// <summary>
+		///   If we already defined the ExitLabel
+		/// </summary>
+		public bool HasExitLabel;
+
+		/// <summary>
+		///   Whether we are in a Finally block
+		/// </summary>
+		public bool InFinally;
+
+		/// <summary>
+		///   Whether we are in a Try block
+		/// </summary>
+		public bool InTry;
+
+		/// <summary>
+		///   Whether we are in a Catch block
+		/// </summary>
+		public bool InCatch;
+
+		/// <summary>
+		///  Whether we are inside an unsafe block
+		/// </summary>
+		public bool InUnsafe;
+		
+		/// <summary>
+		///  Whether we are inside an unsafe block
+		/// </summary>
+		public bool InvokingOwnOverload;		
+
+		/// <summary>
+		///   Location for this EmitContext
+		/// </summary>
+		public Location loc;
+
+		/// <summary>
+		///   Used to flag that it is ok to define types recursively, as the
+		///   expressions are being evaluated as part of the type lookup
+		///   during the type resolution process
+		/// </summary>
+		public bool ResolvingTypeTree;
+		
+		/// <summary>
+		///   Inside an enum definition, we do not resolve enumeration values
+		///   to their enumerations, but rather to the underlying type/value
+		///   This is so EnumVal + EnumValB can be evaluated.
+		///
+		///   There is no "E operator + (E x, E y)", so during an enum evaluation
+		///   we relax the rules
+		/// </summary>
+		public bool InEnumContext;
+		
+		public string BlockName;
+
+		protected Stack FlowStack;
+		
+		public EmitContext (TypeContainer parent, DeclSpace ds, Location l, ILGenerator ig,
+				    Type return_type, int code_flags, bool is_constructor)
+		{
+			this.ig = ig;
+			TypeContainer = parent;
+			DeclSpace = ds;
+			CheckState = RootContext.Checked;
+			ConstantCheckState = true;
+			
+			IsStatic = (code_flags & Modifiers.STATIC) != 0;
+			ReturnType = return_type;
+			IsConstructor = is_constructor;
+			CurrentBlock = null;
+			BlockName = "";
+			InvokingOwnOverload = false;
+			
+			if (parent != null){
+				// Can only be null for the ResolveType contexts.
+				ContainerType = parent.TypeBuilder;
+				if (parent.UnsafeContext)
+					InUnsafe = true;
+				else
+					InUnsafe = (code_flags & Modifiers.UNSAFE) != 0;
+			}
+			loc = l;
+
+			FlowStack = new Stack ();
+			
+			if (ReturnType == TypeManager.void_type)
+				ReturnType = null;
+		}
+
+		public EmitContext (TypeContainer tc, Location l, ILGenerator ig,
+				    Type return_type, int code_flags, bool is_constructor)
+			: this (tc, tc, l, ig, return_type, code_flags, is_constructor)
+		{
+		}
+
+		public EmitContext (TypeContainer tc, Location l, ILGenerator ig,
+				    Type return_type, int code_flags)
+			: this (tc, tc, l, ig, return_type, code_flags, false)
+		{
+		}
+
+		public FlowBranching CurrentBranching {
+			get {
+				return (FlowBranching) FlowStack.Peek ();
+			}
+		}
+
+		// <summary>
+		//   Starts a new code branching.  This inherits the state of all local
+		//   variables and parameters from the current branching.
+		// </summary>
+		public FlowBranching StartFlowBranching (FlowBranchingType type, Location loc)
+		{
+			FlowBranching cfb = new FlowBranching (CurrentBranching, type, null, loc);
+
+			FlowStack.Push (cfb);
+
+			return cfb;
+		}
+
+		// <summary>
+		//   Starts a new code branching for block `block'.
+		// </summary>
+		public FlowBranching StartFlowBranching (Block block)
+		{
+			FlowBranching cfb;
+			FlowBranchingType type;
+
+			if (CurrentBranching.Type == FlowBranchingType.SWITCH)
+				type = FlowBranchingType.SWITCH_SECTION;
+			else
+				type = FlowBranchingType.BLOCK;
+
+			cfb = new FlowBranching (CurrentBranching, type, block, block.StartLocation);
+
+			FlowStack.Push (cfb);
+
+			return cfb;
+		}
+
+		// <summary>
+		//   Ends a code branching.  Merges the state of locals and parameters
+		//   from all the children of the ending branching.
+		// </summary>
+		public FlowReturns EndFlowBranching ()
+		{
+			FlowBranching cfb = (FlowBranching) FlowStack.Pop ();
+
+			return CurrentBranching.MergeChild (cfb);
+		}
+
+		// <summary>
+		//   Kills the current code branching.  This throws away any changed state
+		//   information and should only be used in case of an error.
+		// </summary>
+		public void KillFlowBranching ()
+		{
+			/*FlowBranching cfb = (FlowBranching)*/ FlowStack.Pop ();
+		}
+
+		// <summary>
+		//   Checks whether the local variable `vi' is already initialized
+		//   at the current point of the method's control flow.
+		//   If this method returns false, the caller must report an
+		//   error 165.
+		// </summary>
+		public bool IsVariableAssigned (VariableInfo vi)
+		{
+			if (DoFlowAnalysis)
+				return CurrentBranching.IsVariableAssigned (vi);
+			else
+				return true;
+		}
+
+		// <summary>
+		//   Marks the local variable `vi' as being initialized at the current
+		//   current point of the method's control flow.
+		// </summary>
+		public void SetVariableAssigned (VariableInfo vi)
+		{
+			if (DoFlowAnalysis)
+				CurrentBranching.SetVariableAssigned (vi);
+		}
+
+		// <summary>
+		//   Checks whether the parameter `number' is already initialized
+		//   at the current point of the method's control flow.
+		//   If this method returns false, the caller must report an
+		//   error 165.  This is only necessary for `out' parameters and the
+		//   call will always succeed for non-`out' parameters.
+		// </summary>
+		public bool IsParameterAssigned (int number)
+		{
+			if (DoFlowAnalysis)
+				return CurrentBranching.IsParameterAssigned (number);
+			else
+				return true;
+		}
+
+		// <summary>
+		//   Marks the parameter `number' as being initialized at the current
+		//   current point of the method's control flow.  This is only necessary
+		//   for `out' parameters.
+		// </summary>
+		public void SetParameterAssigned (int number)
+		{
+			if (DoFlowAnalysis)
+				CurrentBranching.SetParameterAssigned (number);
+		}
+
+		// These are two overloaded methods for EmitTopBlock
+		// since in MonoBasic functions we need the Function name
+		// along with its top block, in order to be able to
+		// retrieve the return value when there is no explicit 
+		// 'Return' statement
+		public void EmitTopBlock (Block block, InternalParameters ip, Location loc)
+		{
+			EmitTopBlock (block, "", ip, loc);
+		}
+
+		public void EmitTopBlock (Block block, string bname, InternalParameters ip, Location loc)
+		{
+			bool has_ret = false;
+
+			//Console.WriteLine ("Emitting: '{0}", bname);
+			BlockName = bname;
+			if (CodeGen.SymbolWriter != null)
+				Mark (loc);
+
+			if (block != null){
+				int errors = Report.Errors;
+
+				block.EmitMeta (this, block);
+
+				if (Report.Errors == errors){
+					bool old_do_flow_analysis = DoFlowAnalysis;
+					DoFlowAnalysis = true;
+
+					FlowBranching cfb = new FlowBranching (block, ip, loc);
+					FlowStack.Push (cfb);
+
+					if (!block.Resolve (this)) {
+						FlowStack.Pop ();
+						DoFlowAnalysis = old_do_flow_analysis;
+						return;
+					}
+
+					cfb = (FlowBranching) FlowStack.Pop ();
+					FlowReturns returns = cfb.MergeTopBlock ();
+
+					DoFlowAnalysis = old_do_flow_analysis;
+
+					has_ret = block.Emit (this);
+
+					if ((returns == FlowReturns.ALWAYS) ||
+					    (returns == FlowReturns.EXCEPTION) ||
+					    (returns == FlowReturns.UNREACHABLE))
+						has_ret = true;
+
+					if (Report.Errors == errors){
+						if (RootContext.WarningLevel >= 3)
+							block.UsageWarning ();
+					}
+				}
+			}
+
+			if (HasReturnLabel)
+				ig.MarkLabel (ReturnLabel);
+			if (return_value != null){
+				ig.Emit (OpCodes.Ldloc, return_value);
+				ig.Emit (OpCodes.Ret);
+				return;
+			}
+
+			if (ReturnType != null && !has_ret){
+				//
+				// mcs here would report an error (and justly so), but functions without
+				// an explicit return value are perfectly legal in MonoBasic
+				//
+				
+				VariableInfo vi = block.GetVariableInfo (bname);
+				if (vi != null) 
+				{
+					ig.Emit (OpCodes.Ldloc, vi.LocalBuilder);
+					ig.Emit (OpCodes.Ret);
+				}
+				else
+					Report.Error (-200, "This is not supposed to happen !");
+				return;
+			}
+
+			if (!InTry){
+				if (!has_ret)
+					ig.Emit (OpCodes.Ret);
+				else if (ReturnType == null)
+					ig.Emit (OpCodes.Ret);
+			}
+		}
+
+		/// <summary>
+		///   This is called immediately before emitting an IL opcode to tell the symbol
+		///   writer to which source line this opcode belongs.
+		/// </summary>
+		public void Mark (Location loc)
+		{
+			if ((CodeGen.SymbolWriter != null) && !Location.IsNull (loc)) {
+				ISymbolDocumentWriter doc = loc.SymbolDocument;
+
+				if (doc != null)
+					ig.MarkSequencePoint (doc, loc.Row, 0,  loc.Row, 0);
+			}
+		}
+
+		/// <summary>
+		///   Returns a temporary storage for a variable of type t as 
+		///   a local variable in the current body.
+		/// </summary>
+		public LocalBuilder GetTemporaryStorage (Type t)
+		{
+			LocalBuilder location;
+			
+			if (temporary_storage != null){
+				location = (LocalBuilder) temporary_storage [t];
+				if (location != null)
+					return location;
+			}
+			
+			location = ig.DeclareLocal (t);
+			
+			return location;
+		}
+
+		public void FreeTemporaryStorage (LocalBuilder b)
+		{
+			// Empty for now.
+		}
+
+		/// <summary>
+		///   Current loop begin and end labels.
+		/// </summary>
+		public Label LoopBegin, LoopEnd;
+
+		/// <summary>
+		///   Whether we are inside a loop and break/continue are possible.
+		/// </summary>
+		public bool  InLoop;
+
+		/// <summary>
+		///   This is incremented each time we enter a try/catch block and
+		///   decremented if we leave it.
+		/// </summary>
+		public int   TryCatchLevel;
+
+		/// <summary>
+		///   The TryCatchLevel at the begin of the current loop.
+		/// </summary>
+		public int   LoopBeginTryCatchLevel;
+
+		/// <summary>
+		///   Default target in a switch statement.   Only valid if
+		///   InSwitch is true
+		/// </summary>
+		public Label DefaultTarget;
+
+		/// <summary>
+		///   If this is non-null, points to the current switch statement
+		/// </summary>
+		public Switch Switch;
+
+		/// <summary>
+		///   ReturnValue creates on demand the LocalBuilder for the
+		///   return value from the function.  By default this is not
+		///   used.  This is only required when returns are found inside
+		///   Try or Catch statements.
+		/// </summary>
+		public LocalBuilder TemporaryReturn ()
+		{
+			if (return_value == null){
+				return_value = ig.DeclareLocal (ReturnType);
+				ReturnLabel = ig.DefineLabel ();
+				HasReturnLabel = true;
+			}
+
+			return return_value;
+		}
+
+		/// <summary>
+	        ///   A dynamic This that is shared by all variables in a emitcontext.
+		///   Created on demand.
+		/// </summary>
+		public Expression my_this;
+		public Expression This {
+			get {
+				if (my_this == null) {
+					if (CurrentBlock != null)
+						my_this = new This (CurrentBlock, loc);
+					else
+						my_this = new This (loc);
+
+					my_this = my_this.Resolve (this);
+				}
+
+				return my_this;
+			}
+		}
+	}
+
+	
+	public abstract class CommonAssemblyModulClass: Attributable {
+		protected CommonAssemblyModulClass ():
+			base (null)
+		{
+		}
+
+		public void AddAttribute (Attribute attr)
+		{
+			if (OptAttributes == null) {
+				OptAttributes = new Attributes (attr);
+			} else {
+				OptAttributes.Add (attr);
+			}
+		}
+
+ 		public virtual void Emit (TypeContainer tc) 
+ 		{
+ 			if (OptAttributes == null)
+ 				return;
+			EmitContext ec = new EmitContext (tc, Location.Null, null, null, 0, false);
+			
+			if (OptAttributes != null)
+	 			OptAttributes.Emit (ec, this);
+  		}
+		
+		
+	}
+
+	public class AssemblyClass: CommonAssemblyModulClass 
+	{
+		public AssemblyBuilder Builder;
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Assembly;
+			}
+		}
+		
+ 		public override void Emit (TypeContainer tc)
+ 		{
+			base.Emit (tc);
+ 		}
+
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder customBuilder)
+		{
+			Builder.SetCustomAttribute (customBuilder);
+		}
+
+	}
+	
+	public class ModuleClass: CommonAssemblyModulClass 
+	{
+		public ModuleBuilder Builder;
+
+		public ModuleClass ()
+		{
+		}
+
+ 		public override void Emit (TypeContainer tc)
+ 		{
+ 			base.Emit (tc);
+ 		}
+	
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Module;
+			}
+		}
+
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder customBuilder)
+		{
+			Builder.SetCustomAttribute (customBuilder);
+		}
+	}
+}
+
+
diff --git a/dead/mbas/const.cs b/dead/mbas/const.cs
new file mode 100644
index 00000000..ac28eb06
--- /dev/null
+++ b/dead/mbas/const.cs
@@ -0,0 +1,383 @@
+//
+// const.cs: Constant declarations.
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//
+// (C) 2001 Ximian, Inc.
+//
+//
+
+//
+// This is needed because the following situation arises:
+//
+//     The FieldBuilder is declared with the real type for an enumeration
+//
+//     When we attempt to set the value for the constant, the FieldBuilder.SetConstant
+//     function aborts because it requires its argument to be of the same type
+//
+
+using System;
+
+namespace Mono.MonoBASIC {
+
+
+	using System;
+	using System.Reflection;
+	using System.Reflection.Emit;
+	using System.Collections;
+
+	public class Const : MemberCore {
+		public Expression ConstantType;
+		public Expression Expr;
+		public FieldBuilder FieldBuilder;
+
+
+		bool resolved = false;
+		object ConstantValue = null;
+		Type type;
+
+		bool in_transit = false;
+
+		public const int AllowedModifiers =
+			Modifiers.PUBLIC |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL |
+			Modifiers.PRIVATE |
+			Modifiers.SHADOWS;
+
+		public Const (Expression constant_type, string name, Expression expr, int mod_flags,
+			      Attributes attrs, Location loc)
+			: base (name, attrs, loc)
+		{
+			ConstantType = constant_type;
+			Name = name;
+			Expr = expr;
+			ModFlags = Modifiers.Check (AllowedModifiers, mod_flags, Modifiers.PRIVATE, loc);
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Field;
+			}
+		}
+
+		public FieldAttributes FieldAttr {
+			get {
+				return FieldAttributes.Literal | FieldAttributes.Static |
+					Modifiers.FieldAttr (ModFlags) ;
+			}
+		}
+
+#if DEBUG
+		void dump_tree (Type t)
+		{
+			Console.WriteLine ("Dumping hierarchy");
+			while (t != null){
+				Console.WriteLine ("   " + t.FullName + " " +
+					(t.GetType ().IsEnum ? "yes" : "no"));
+				t = t.BaseType;
+			}
+		}
+#endif
+
+		/// <summary>
+		///   Defines the constant in the @parent
+		/// </summary>
+		public override bool Define (TypeContainer parent)
+		{
+			type = parent.ResolveType (ConstantType, false, Location);
+
+			if (type == null)
+				return false;
+
+			if (!TypeManager.IsBuiltinType (type) &&
+			    (!type.IsSubclassOf (TypeManager.enum_type))) {
+				Report.Error (
+					30424, Location,
+					"Constant type is not valid (only system types are allowed)");
+				return false;
+			}
+
+			// if no type is declared expicitely 
+			// set the expression type as the type of constant
+			if (type == TypeManager.object_type){
+				if (Expr is IntLiteral)
+					type = TypeManager.int32_type;
+				else if (Expr is UIntLiteral)
+					type = TypeManager.uint32_type;
+				else if (Expr is LongLiteral)
+					type = TypeManager.int64_type;
+				else if (Expr is ULongLiteral)
+					type = TypeManager.uint64_type;
+				else if (Expr is FloatLiteral)
+					type = TypeManager.float_type;
+				else if (Expr is DoubleLiteral)
+					type = TypeManager.double_type;
+				else if (Expr is StringLiteral)
+					type = TypeManager.string_type;
+				else if (Expr is ShortLiteral)
+					type = TypeManager.short_type;
+				else if (Expr is UShortConstant)
+					type = TypeManager.ushort_type;
+				else if (Expr is SByteConstant)
+					type = TypeManager.sbyte_type;
+				else if (Expr is ByteConstant)
+					type = TypeManager.byte_type;
+				else if (Expr is CharConstant)
+					type = TypeManager.char_type;
+				else if (Expr is BoolConstant)
+					type = TypeManager.bool_type;
+				else if (Expr is DateConstant)
+					type = TypeManager.date_type;
+			}
+			Type ptype = parent.TypeBuilder.BaseType;
+
+			if (ptype != null) {
+				MemberList list = TypeContainer.FindMembers (
+					ptype, MemberTypes.Field, BindingFlags.Public,
+					Type.FilterName, Name);
+				
+				if ((list.Count > 0) && ((ModFlags & Modifiers.SHADOWS) == 0))
+					Report.Warning (
+						40004, 2, Location, 
+						"Const '" + Name + "' should be declared " +
+						"Shadows since the base type '" + ptype.Name + 
+						"' has a Const with same name");
+				if (list.Count == 0) {
+					// if a member of module is not inherited from Object class
+					// can not be declared protected
+					if ((parent is Module) && ((ModFlags & Modifiers.PROTECTED) != 0))
+						Report.Error (30593, Location,
+							"'Const' inside a 'Module' can not be " +
+							"declared as 'Protected'");
+
+					/*if ((ModFlags & Modifiers.NEW) != 0)
+						WarningNotHiding (parent);*/
+				}
+			} 
+			/*else if ((ModFlags & Modifiers.NEW) != 0)
+				WarningNotHiding (parent);*/
+
+			if ((parent is Struct) && ((ModFlags & Modifiers.PROTECTED) != 0))
+				Report.Error (30435, Location,
+					"'Const' inside a 'Structure' can not be " +
+					"declared as 'Protected'");
+
+			FieldBuilder = parent.TypeBuilder.DefineField (Name, type, FieldAttr);
+
+			TypeManager.RegisterConstant (FieldBuilder, this);
+
+			return true;
+		}
+
+		//
+                // Changes the type of the constant expression `expr' to the Type `type'
+                // Returns null on failure.
+                //
+                public static Constant ChangeType (Location loc, Constant expr, Type type, EmitContext ec)
+                {
+                        if (type == TypeManager.object_type)
+                                return expr;
+
+                        bool fail;
+
+                        // from the null type to any reference-type.
+                        if (expr.Type == TypeManager.null_type && !type.IsValueType && !TypeManager.IsEnumType (type))
+                                return NullLiteral.Null;
+                        
+			if (!Expression.ImplicitConversionExists (ec, expr, type)){
+                                Expression.Error_CannotConvertImplicit (loc, expr.Type, type);
+                                return null;
+			  }
+
+                        // Special-case: The 0 literal can be converted to an enum value,
+                        // and ImplicitStandardConversionExists will return true in that case.
+                        if (expr.Type == TypeManager.int32_type && TypeManager.IsEnumType (type)){
+                                if (expr is IntLiteral && ((IntLiteral) expr).Value == 0)
+                                        return new EnumConstant (expr, type);
+                        }
+
+                        object constant_value = TypeManager.ChangeType1 (expr.GetValue (), type, out fail);
+                        if (fail){
+                                // Error_CannotImplicitConversion (loc, expr.Type, type);
+
+                                //
+                                // We should always catch the error before this is ever
+                                // reached, by calling Convert.ImplicitStandardConversionExists
+                                //
+                                throw new Exception (
+                                                     String.Format ("LookupConstantValue: This should never be reached {0} {1}", expr.Type, type));
+                        }
+
+                        Constant retval;
+			if (type == TypeManager.int32_type)
+                                retval = new IntConstant ((int) constant_value);
+                        else if (type == TypeManager.uint32_type)
+                                retval = new UIntConstant ((uint) constant_value);
+                        else if (type == TypeManager.int64_type)
+                                retval = new LongConstant ((long) constant_value);
+                        else if (type == TypeManager.uint64_type)
+                                retval = new ULongConstant ((ulong) constant_value);
+                        else if (type == TypeManager.float_type)
+                                retval = new FloatConstant ((float) constant_value);
+                        else if (type == TypeManager.double_type)
+                                retval = new DoubleConstant ((double) constant_value);
+                        else if (type == TypeManager.string_type)
+                                retval = new StringConstant ((string) constant_value);
+                        else if (type == TypeManager.short_type)
+                                retval = new ShortConstant ((short) constant_value);
+                        else if (type == TypeManager.ushort_type)
+                                retval = new UShortConstant ((ushort) constant_value);
+                        else if (type == TypeManager.sbyte_type)
+                                retval = new SByteConstant ((sbyte) constant_value);
+                        else if (type == TypeManager.byte_type)
+                                retval = new ByteConstant ((byte) constant_value);
+                        else if (type == TypeManager.char_type)
+                                retval = new CharConstant ((char) constant_value);
+                        else if (type == TypeManager.bool_type)
+                                retval = new BoolConstant ((bool) constant_value);
+                        else if (type == TypeManager.decimal_type)
+                                retval = new DecimalConstant ((decimal) constant_value);
+                        else
+				 throw new Exception ("LookupConstantValue: Unhandled constant type: " + type);
+
+                        return retval;
+                }
+		
+		 /// <summary>
+                ///  Looks up the value of a constant field. Defines it if it hasn't
+                ///  already been. Similar to LookupEnumValue in spirit.
+                /// </summary>
+                public bool LookupConstantValue (out object value, EmitContext ec)
+                {
+                        if (resolved) {
+                                value = ConstantValue;
+                                return true;
+                        }
+
+                        if (in_transit) {
+                                Report.Error (110, Location,
+                                              "The evaluation of the constant value for `" +
+                                              Name + "' involves a circular definition.");
+                                value = null;
+                                return false;
+                        }
+
+                        in_transit = true;
+                        int errors = Report.Errors;
+
+			 //
+                        // We might have cleared Expr ourselves in a recursive definition
+                        //
+                        if (Expr == null){
+                                value = null;
+                                return false;
+                        }
+
+                        Expr = Expr.Resolve (ec);
+
+                        in_transit = false;
+
+                        if (Expr == null) {
+                                if (errors == Report.Errors)
+                                        Report.Error (150, Location, "A constant value is expected");
+                                value = null;
+                                return false;
+                        }
+
+
+                        Constant ce = Expr as Constant;
+                        if (ce == null){
+                                UnCheckedExpr un_expr = Expr as UnCheckedExpr;
+                                CheckedExpr ch_expr = Expr as CheckedExpr;
+				 if ((un_expr != null) && (un_expr.Expr is Constant))
+                                        Expr = un_expr.Expr;
+                                else if ((ch_expr != null) && (ch_expr.Expr is Constant))
+                                        Expr = ch_expr.Expr;
+                                //else if ((ec_expr != null) && (ec_expr.Child is Constant))
+                                 //       Expr = ec_expr.Child;
+                                else if (Expr is ArrayCreation){
+                                        Report.Error (133, Location, "Arrays can not be constant");
+                                } else {
+                                        if (errors == Report.Errors)
+                                                Report.Error (150, Location, "A constant value is expected");
+                                        value = null;
+                                        return false;
+                                }
+
+                                ce = Expr as Constant;
+                        }
+
+                     //   if (MemberType != real_expr.Type) {
+			   if (type != Expr.Type) {
+
+                                ce = ChangeType (Location, ce, type, ec);
+                                if (ce == null){
+                                        value = null;
+                                        return false;
+                                }
+                                Expr = ce;
+                        }
+			
+			if (ce != null)
+                                ConstantValue = ce.GetValue ();
+
+                        if (type.IsEnum){
+                                //
+                                // This sadly does not work for our user-defined enumerations types ;-(
+                                //
+                                try {
+                                        ConstantValue = System.Enum.ToObject (
+                                                type, ConstantValue);
+                                } catch (ArgumentException){
+                                        Report.Error (
+                                                -16, Location,
+                                                ".NET SDK 1.0 does not permit to create the constant "+
+                                                " field from a user-defined enumeration");
+                                }
+                        }
+
+                        if (ce is DecimalConstant) {
+                                Decimal d = ((DecimalConstant)ce).Value;
+                                int[] bits = Decimal.GetBits (d);
+                                object[] args = new object[] { (byte)(bits [3] >> 16), (byte)(bits [3] >> 31), (uint)bits [2], (uint)bits [1], (uint)bits [0] };
+                                CustomAttributeBuilder cab = new CustomAttributeBuilder (TypeManager.decimal_constant_attribute_ctor, args);
+                                FieldBuilder.SetCustomAttribute (cab);
+                        }
+			else{
+                                FieldBuilder.SetConstant (ConstantValue);
+                        }
+
+                        if (!TypeManager.RegisterFieldValue (FieldBuilder, ConstantValue))
+                                throw new Exception ("Cannot register const value");
+
+                        value = ConstantValue;
+                        resolved = true;
+                        return true;
+                }
+
+
+
+		
+		
+		
+		/// <summary>
+		///  Emits the field value by evaluating the expression
+		/// </summary>
+		public void EmitConstant (TypeContainer parent)
+		{
+			EmitContext ec = new EmitContext (parent, Location, null, type, ModFlags);
+			object value;
+			 LookupConstantValue (out value,ec);
+			
+			return;
+		}
+		
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+		{
+			FieldBuilder.SetCustomAttribute (cb);
+		}
+		
+	}
+}
diff --git a/dead/mbas/constant.cs b/dead/mbas/constant.cs
new file mode 100644
index 00000000..d42d674c
--- /dev/null
+++ b/dead/mbas/constant.cs
@@ -0,0 +1,1032 @@
+//
+// constant.cs: Constants.
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//
+// (C) 2001 Ximian, Inc.
+//
+//
+
+namespace Mono.MonoBASIC {
+
+	using System;
+	using System.Reflection.Emit;
+
+	/// <summary>
+	///   Base class for constants and literals.
+	/// </summary>
+	public abstract class Constant : Expression {
+		/// <remarks>
+		///   This is different from ToString in that ToString
+		///   is supposed to be there for debugging purposes,
+		///   and is not guaranteed to be useful for anything else,
+		///   AsString() will provide something that can be used
+		///   for round-tripping C# code.  Maybe it can be used
+		///   for IL assembly as well.
+		/// </remarks>
+		public abstract string AsString ();
+
+		override public string ToString ()
+		{
+			return this.GetType ().Name + " (" + AsString () + ")";
+		}
+
+		/// <summary>
+		///  This is used to obtain the actual value of the literal
+		///  cast into an object.
+		/// </summary>
+		public abstract object GetValue ();
+
+		/// <summary>
+		///   Constants are always born in a fully resolved state
+		/// </summary>
+		public override Expression DoResolve (EmitContext ec)
+		{
+			return this;
+		}
+
+		//
+		// The various ToXXXX conversion functions are used by the constant
+		// folding evaluator.   A null value is returned if the conversion is
+		// not possible.   
+		//
+		// Note: not all the patterns for catching `implicit_conv' are the same.
+		// some implicit conversions can never be performed between two types
+		// even if the conversion would be lossless (for example short to uint),
+		// but some conversions are explicitly permitted by the standard provided
+		// that there will be no loss of information (for example, int to uint).
+		//
+		public DoubleConstant ToDouble (Location loc)
+		{
+			DoubleConstant c = ConvertToDouble ();
+
+			if (c == null)
+				Error_CannotConvertImplicit (loc, Type, TypeManager.double_type);
+
+			return c;
+		}
+
+		public FloatConstant ToFloat (Location loc)
+		{
+			FloatConstant c = ConvertToFloat ();
+
+			if (c == null)
+				Error_CannotConvertImplicit (loc, Type, TypeManager.float_type);
+
+			return c;
+		}
+
+		public ULongConstant ToULong (Location loc)
+		{
+			ULongConstant c = ConvertToULong ();
+
+			if (c == null)
+				Error_CannotConvertImplicit (loc, Type, TypeManager.uint64_type);
+
+			return c;
+		}
+
+		public LongConstant ToLong (Location loc)
+		{
+			LongConstant c = ConvertToLong ();
+
+			if (c == null)
+				Error_CannotConvertImplicit (loc, Type, TypeManager.int64_type);
+
+			return c;
+		}
+		
+		public UIntConstant ToUInt (Location loc)
+		{
+			UIntConstant c = ConvertToUInt ();
+
+			if (c == null)
+				Error_CannotConvertImplicit (loc, Type, TypeManager.uint32_type);
+
+			return c;
+		}
+
+		public IntConstant ToInt (Location loc)
+		{
+			IntConstant c = ConvertToInt ();
+
+			if (c == null)
+				Error_CannotConvertImplicit (loc, Type, TypeManager.int32_type);
+
+			return c;
+		}
+		
+		public DecimalConstant ToDecimal (Location loc)
+                {
+                        DecimalConstant c = ConvertToDecimal ();
+
+                        if (c == null)
+                                Error_CannotConvertImplicit (loc, Type, TypeManager.decimal_type);
+
+                        return c;
+                }
+
+                public virtual DecimalConstant ConvertToDecimal ()
+                {
+                        return null;
+                }
+
+		
+		public virtual DoubleConstant ConvertToDouble ()
+		{
+			return null;
+		}
+
+		public virtual FloatConstant ConvertToFloat ()
+		{
+			return null;
+		}
+
+		public virtual ULongConstant ConvertToULong ()
+		{
+			return null;
+		}
+
+		public virtual LongConstant ConvertToLong ()
+		{
+			return null;
+		}
+
+		public virtual UIntConstant ConvertToUInt ()
+		{
+			return null;
+		}
+
+		public virtual IntConstant ConvertToInt ()
+		{
+			return null;
+		}
+	}
+	
+	public class BoolConstant : Constant {
+		public readonly bool Value;
+		
+		public BoolConstant (bool val)
+		{
+			type = TypeManager.bool_type;
+			eclass = ExprClass.Value;
+
+			Value = val;
+		}
+
+		override public string AsString ()
+		{
+			return Value ? "true" : "false";
+		}
+
+		public override object GetValue ()
+		{
+			return (object) Value;
+		}
+				
+		
+		public override void Emit (EmitContext ec)
+		{
+			if (Value)
+				ec.ig.Emit (OpCodes.Ldc_I4_1);
+			else
+				ec.ig.Emit (OpCodes.Ldc_I4_0);
+		}
+	}
+
+	public class ByteConstant : Constant {
+		public readonly byte Value;
+
+		public ByteConstant (byte v)
+		{
+			type = TypeManager.byte_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			IntLiteral.EmitInt (ec.ig, Value);
+		}
+
+		public override string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return new DoubleConstant (Value);
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return new FloatConstant (Value);
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			return new ULongConstant (Value);
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return new LongConstant (Value);
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return new UIntConstant (Value);
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return new IntConstant (Value);
+		}
+	}
+
+	public class CharConstant : Constant {
+		public readonly char Value;
+
+		public CharConstant (char v)
+		{
+			type = TypeManager.char_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			IntLiteral.EmitInt (ec.ig, Value);
+		}
+
+		static public string descape (char c)
+		{
+			switch (c){
+			case '\a':
+				return "\\a"; 
+			case '\b':
+				return "\\b"; 
+			case '\n':
+				return "\\n"; 
+			case '\t':
+				return "\\t"; 
+			case '\v':
+				return "\\v"; 
+			case '\r':
+				return "\\r"; 
+			case '\\':
+				return "\\\\";
+			case '\f':
+				return "\\f"; 
+			case '\0':
+				return "\\0"; 
+			case '"':
+				return "\\\""; 
+			case '\'':
+				return "\\\'"; 
+			}
+			return c.ToString ();
+		}
+
+		public override string AsString ()
+		{
+			return "\"" + descape (Value) + "\"";
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return new DoubleConstant (Value);
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return new FloatConstant (Value);
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			return new ULongConstant (Value);
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return new LongConstant (Value);
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return new UIntConstant (Value);
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return new IntConstant (Value);
+		}
+	}
+
+	public class SByteConstant : Constant {
+		public readonly sbyte Value;
+
+		public SByteConstant (sbyte v)
+		{
+			type = TypeManager.sbyte_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			IntLiteral.EmitInt (ec.ig, Value);
+		}
+
+		public override string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return new DoubleConstant (Value);
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return new FloatConstant (Value);
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			if (Value >= 0)
+				return new ULongConstant ((ulong) Value);
+			
+			return null;
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return new LongConstant (Value);
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return null;
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return new IntConstant (Value);
+		}
+	}
+
+	public class ShortConstant : Constant {
+		public readonly short Value;
+
+		public ShortConstant (short v)
+		{
+			type = TypeManager.short_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			IntLiteral.EmitInt (ec.ig, Value);
+		}
+
+		public override string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return new DoubleConstant (Value);
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return new FloatConstant (Value);
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			return null;
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return new LongConstant (Value);
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return null;
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return new IntConstant (Value);
+		}
+	}
+
+	public class UShortConstant : Constant {
+		public readonly ushort Value;
+
+		public UShortConstant (ushort v)
+		{
+			type = TypeManager.ushort_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			IntLiteral.EmitInt (ec.ig, Value);
+		}
+
+		public override string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return new DoubleConstant (Value);
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return new FloatConstant (Value);
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			return new ULongConstant (Value);
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return new LongConstant (Value);
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return new UIntConstant (Value);
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return new IntConstant (Value);
+		}
+	}
+
+	public class IntConstant : Constant {
+		public readonly int Value;
+
+		public IntConstant (int v)
+		{
+			type = TypeManager.int32_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		static public void EmitInt (ILGenerator ig, int i)
+		{
+			switch (i){
+			case -1:
+				ig.Emit (OpCodes.Ldc_I4_M1);
+				break;
+				
+			case 0:
+				ig.Emit (OpCodes.Ldc_I4_0);
+				break;
+				
+			case 1:
+				ig.Emit (OpCodes.Ldc_I4_1);
+				break;
+				
+			case 2:
+				ig.Emit (OpCodes.Ldc_I4_2);
+				break;
+				
+			case 3:
+				ig.Emit (OpCodes.Ldc_I4_3);
+				break;
+				
+			case 4:
+				ig.Emit (OpCodes.Ldc_I4_4);
+				break;
+				
+			case 5:
+				ig.Emit (OpCodes.Ldc_I4_5);
+				break;
+				
+			case 6:
+				ig.Emit (OpCodes.Ldc_I4_6);
+				break;
+				
+			case 7:
+				ig.Emit (OpCodes.Ldc_I4_7);
+				break;
+				
+			case 8:
+				ig.Emit (OpCodes.Ldc_I4_8);
+				break;
+
+			default:
+				if (i >= -128 && i <= 127){
+					ig.Emit (OpCodes.Ldc_I4_S, (sbyte) i);
+				} else
+					ig.Emit (OpCodes.Ldc_I4, i);
+				break;
+			}
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			EmitInt (ec.ig, Value);
+		}
+
+		public override string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return new DoubleConstant (Value);
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return new FloatConstant (Value);
+		}
+		
+		public override DecimalConstant ConvertToDecimal ()
+		{
+			return new DecimalConstant (Value);
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			if (Value < 0)
+				return null;
+
+			return new ULongConstant ((ulong) Value);
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return new LongConstant (Value);
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			if (Value < 0)
+				return null;
+
+			return new UIntConstant ((uint) Value);
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return this;
+		}
+	}
+
+	public class UIntConstant : Constant {
+		public readonly uint Value;
+
+		public UIntConstant (uint v)
+		{
+			type = TypeManager.uint32_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			IntLiteral.EmitInt (ec.ig, unchecked ((int) Value));
+		}
+
+		public override string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return new DoubleConstant (Value);
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return new FloatConstant (Value);
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			return new ULongConstant (Value);
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return new LongConstant (Value);
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return this;
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return null;
+		}
+	}
+
+	public class LongConstant : Constant {
+		public readonly long Value;
+
+		public LongConstant (long v)
+		{
+			type = TypeManager.int64_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+
+			EmitLong (ig, Value);
+		}
+
+		static public void EmitLong (ILGenerator ig, long l)
+		{
+			ig.Emit (OpCodes.Ldc_I8, l);
+		}
+
+		public override string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return new DoubleConstant (Value);
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return new FloatConstant (Value);
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			if (Value < 0)
+				return null;
+			
+			return new ULongConstant ((ulong) Value);
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return this;
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return null;
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return null;
+		}
+	}
+
+	public class ULongConstant : Constant {
+		public readonly ulong Value;
+
+		public ULongConstant (ulong v)
+		{
+			type = TypeManager.uint64_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+
+			LongLiteral.EmitLong (ig, unchecked ((long) Value));
+		}
+
+		public override string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return new DoubleConstant (Value);
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return new FloatConstant (Value);
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			return this;
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return null;
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return null;
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return null;
+		}
+	}
+
+	public class FloatConstant : Constant {
+		public readonly float Value;
+
+		public FloatConstant (float v)
+		{
+			type = TypeManager.float_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ec.ig.Emit (OpCodes.Ldc_R4, Value);
+		}
+
+		public override string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return new DoubleConstant (Value);
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return this;
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return null;
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return null;
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return null;
+		}
+	}
+
+	public class DoubleConstant : Constant {
+		public readonly double Value;
+
+		public DoubleConstant (double v)
+		{
+			type = TypeManager.double_type;
+			eclass = ExprClass.Value;
+			Value = v;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ec.ig.Emit (OpCodes.Ldc_R8, Value);
+		}
+
+		public override string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return this;
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return new FloatConstant ((float) Value);
+		}
+
+		public override DecimalConstant ConvertToDecimal ()
+		{
+			return new DecimalConstant ((decimal) Value);
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			return null;
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return null;
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return null;
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return null;
+		}
+	}
+
+	public class DecimalConstant : Constant {
+		public readonly decimal Value;
+
+		public DecimalConstant (decimal d)
+		{
+			type = TypeManager.decimal_type;
+			eclass = ExprClass.Value;
+			Value = d;
+		}
+
+		override public string AsString ()
+		{
+			return Value.ToString ();
+		}
+
+		public override object GetValue ()
+		{
+			return (object) Value;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			 ILGenerator ig = ec.ig;
+
+			
+                        int [] words = Decimal.GetBits (Value);
+                        int power = (words [3] >> 16) & 0xff;
+
+                        if (power == 0 && Value <= int.MaxValue && Value >= int.MinValue)
+                        {
+                                IntConstant.EmitInt (ig, (int)Value);
+                                ig.Emit (OpCodes.Newobj, TypeManager.void_decimal_ctor_int_arg);
+
+                                return;
+                        }
+
+
+                        //
+                        // FIXME: we could optimize this, and call a better
+                        // constructor
+                        //
+
+                        IntConstant.EmitInt (ig, words [0]);
+			IntConstant.EmitInt (ig, words [1]);
+                        IntConstant.EmitInt (ig, words [2]);
+
+                        // sign
+                        IntConstant.EmitInt (ig, words [3] >> 31);
+
+                        // power
+                        IntConstant.EmitInt (ig, power);
+
+                        ig.Emit (OpCodes.Newobj, TypeManager.void_decimal_ctor_five_args);
+                }
+
+	}
+
+	public class StringConstant : Constant {
+		public readonly string Value;
+
+		public StringConstant (string s)
+		{
+			type = TypeManager.string_type;
+			eclass = ExprClass.Value;
+			Value = s;
+		}
+
+		// FIXME: Escape the string.
+		override public string AsString ()
+		{
+			return "\"" + Value + "\"";
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			ec.ig.Emit (OpCodes.Ldstr, Value);
+		}
+	}
+
+	public class DateConstant : Constant {
+		public readonly DateTime Value;
+
+		public DateConstant (DateTime s)
+		{
+			type = TypeManager.date_type;
+			eclass = ExprClass.Value;
+			Value = s;
+		}
+
+		override public string AsString ()
+		{
+			return "#" + Value.ToString() + "#";
+		}
+
+		public override object GetValue ()
+		{
+			return Value;
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			ec.ig.Emit (OpCodes.Ldc_I8, Value.Ticks);
+			ec.ig.Emit (OpCodes.Newobj, TypeManager.void_datetime_ctor_ticks_arg);
+		}
+	}
+
+}
diff --git a/dead/mbas/decl.cs b/dead/mbas/decl.cs
new file mode 100644
index 00000000..4f17b352
--- /dev/null
+++ b/dead/mbas/decl.cs
@@ -0,0 +1,1268 @@
+//
+// decl.cs: Declaration base class for structs, classes, enums and interfaces.
+//
+// Author: Miguel de Icaza (miguel@gnu.org)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001 Ximian, Inc (http://www.ximian.com)
+//
+// TODO: Move the method verification stuff from the class.cs and interface.cs here
+//
+
+using System;
+using System.Collections;
+using System.Reflection.Emit;
+using System.Reflection;
+
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///   Base representation for members.  This is only used to keep track
+	///   of Name, Location and Modifier flags.
+	/// </summary>
+	public abstract class MemberCore : Attributable
+	{
+		/// <summary>
+		///   Public name
+		/// </summary>
+		public string Name;
+
+		/// <summary>
+		///   Modifier flags that the user specified in the source code
+		/// </summary>
+		public int ModFlags;
+
+		/// <summary>
+		///   Location where this declaration happens
+		/// </summary>
+		public readonly Location Location;
+
+		public MemberCore (string name, Attributes attrs, Location loc)
+			: base (attrs)
+		{
+			Name = name;
+			Location = loc;
+		}
+
+		protected void WarningNotHiding (TypeContainer parent)
+		{
+			/*Report.Warning (
+				109, Location,
+				"The member " + parent.MakeName (Name) + " does not hide an " +
+				"inherited member.  The keyword new is not required");
+			*/				   
+		}
+
+		void Error_CannotChangeAccessModifiers (TypeContainer parent, MethodInfo parent_method,
+							string name)
+		{
+			//
+			// FIXME: report the old/new permissions?
+			//
+			Report.Error (
+				31048, Location, parent.MakeName (Name) +
+				": can't change the access modifiers when overriding inherited " +
+				"member `" + name + "'");
+		}
+		
+		//
+		// Performs various checks on the MethodInfo `mb' regarding the modifier flags
+		// that have been defined.
+		//
+		// `name' is the user visible name for reporting errors (this is used to
+		// provide the right name regarding method names and properties)
+		//
+		protected bool CheckMethodAgainstBase (TypeContainer parent, MethodAttributes my_attrs,
+						       MethodInfo mb, string name)
+		{
+			bool ok = true;
+
+			if ((ModFlags & Modifiers.OVERRIDE) != 0){
+				// Now we check that the overriden method is not final
+				if (mb.IsFinal) 
+				{
+					Report.Error (30267, Location, parent.MakeName (Name) + " : cannot " +
+						"override inherited member `" + name +
+						"' because it is NotOverridable.");
+					ok = false;
+				}
+				else if (!(mb.IsAbstract || mb.IsVirtual)){
+					Report.Error (
+						31086, Location, parent.MakeName (Name) +
+						": Cannot override inherited member `" +
+						name + "' because it is not " +
+						"declared as Overridable");
+					ok = false;
+				}
+				
+				//
+				// Check that the permissions are not being changed
+				//
+				MethodAttributes thisp = my_attrs & MethodAttributes.MemberAccessMask;
+				MethodAttributes parentp = mb.Attributes & MethodAttributes.MemberAccessMask;
+
+				if (thisp != parentp){
+					Error_CannotChangeAccessModifiers (parent, mb, name);
+					ok = false;
+				}
+			}
+
+			if ((ModFlags & ( Modifiers.NEW | Modifiers.SHADOWS | Modifiers.OVERRIDE )) == 0) {
+				if ((ModFlags & Modifiers.NONVIRTUAL) != 0)	{
+					Report.Error (31088, Location,
+						parent.MakeName (Name) + " cannot " +
+						"be declared NotOverridable since this method is " +
+						"not marked as Overrides");
+				}
+			}
+
+			if (mb.IsAbstract) {
+				if ((ModFlags & (Modifiers.OVERRIDE)) == 0)	{
+					if (Name != "Finalize") {
+						Report.Error (
+							31404, Location, 
+							name + " cannot Shadows the method " +
+							parent.MakeName (Name) + " since it is declared " +
+							"'MustOverride' in base class");
+					}
+				}
+			}
+			else if (mb.IsVirtual){
+				if ((ModFlags & (Modifiers.NEW | Modifiers.OVERRIDE | Modifiers.SHADOWS)) == 0){
+					if (Name != "Finalize"){
+						Report.Warning (
+							40005, 2, Location, parent.MakeName (Name) + 
+							" shadows overridable member `" + name +
+							"'.  To make the current member override that " +
+							"implementation, add the overrides keyword." );
+						ModFlags |= Modifiers.SHADOWS;
+					}
+				}
+			} 
+			else {
+				if ((ModFlags & (Modifiers.NEW | Modifiers.OVERRIDE | 
+					Modifiers.SHADOWS)) == 0){
+					if (Name != "Finalize"){
+						Report.Warning (
+							40004, 1, Location, "The keyword Shadows is required on " +
+							parent.MakeName (Name) + " because it hides " +
+							"inherited member `" + name + "'");
+						ModFlags |= Modifiers.SHADOWS;
+					}
+				}
+			}
+
+			return ok;
+		}
+
+		public abstract bool Define (TypeContainer parent);
+
+		// 
+		// Whehter is it ok to use an unsafe pointer in this type container
+		//
+		public bool UnsafeOK (DeclSpace parent)
+		{
+			//
+			// First check if this MemberCore modifier flags has unsafe set
+			//
+			if ((ModFlags & Modifiers.UNSAFE) != 0)
+				return true;
+
+			if (parent.UnsafeContext)
+				return true;
+
+			Expression.UnsafeError (Location);
+			return false;
+		}
+	}
+
+	//
+	// FIXME: This is temporary outside DeclSpace, because I have to fix a bug
+	// in MCS that makes it fail the lookup for the enum
+	//
+
+		/// <summary>
+		///   The result value from adding an declaration into
+		///   a struct or a class
+		/// </summary>
+		public enum AdditionResult {
+			/// <summary>
+			/// The declaration has been successfully
+			/// added to the declation space.
+			/// </summary>
+			Success,
+
+			/// <summary>
+			///   The symbol has already been defined.
+			/// </summary>
+			NameExists,
+
+			/// <summary>
+			///   Returned if a constructor was created (because syntactically
+			///   it looked like a constructor) but was not (because the name
+			///   of the method is not the same as the container class
+			/// </summary>
+			NotAConstructor,
+
+			/// <summary>
+			///   This is only used by static constructors to emit the
+			///   error 111, but this error for other things really
+			///   happens at another level for other functions.
+			/// </summary>
+			MethodExists
+		}
+
+	/// <summary>
+	///   Base class for structs, classes, enumerations and interfaces.  
+	/// </summary>
+	/// <remarks>
+	///   They all create new declaration spaces.  This
+	///   provides the common foundation for managing those name
+	///   spaces.
+	/// </remarks>
+	public abstract class DeclSpace : MemberCore {
+		/// <summary>
+		///   this points to the actual definition that is being
+		///   created with System.Reflection.Emit
+		/// </summary>
+		public TypeBuilder TypeBuilder;
+
+		/// <summary>
+		///   This variable tracks whether we have Closed the type
+		/// </summary>
+		public bool Created = false;
+		
+		//
+		// This is the namespace in which this typecontainer
+		// was declared.  We use this to resolve names.
+		//
+		public Namespace Namespace;
+
+		public Hashtable Cache = new Hashtable ();
+		
+		public string Basename;
+		
+		/// <summary>
+		///   defined_names is used for toplevel objects
+		/// </summary>
+		protected Hashtable defined_names;
+
+		TypeContainer parent;		
+
+		public DeclSpace (TypeContainer parent, string name, Attributes attrs, Location l)
+			: base (name, attrs, l)
+		{
+			Basename = name.Substring (1 + name.LastIndexOf ('.'));
+			defined_names = new Hashtable ();
+			this.parent = parent;
+		}
+
+		/// <summary>
+		///   Returns a status code based purely on the name
+		///   of the member being added
+		/// </summary>
+		protected AdditionResult IsValid (string name)
+		{
+			if (defined_names.Contains (name))
+				return AdditionResult.NameExists;
+
+			return AdditionResult.Success;
+		}
+
+		/// <summary>
+		///   Introduce @name into this declaration space and
+		///   associates it with the object @o.  Note that for
+		///   methods this will just point to the first method. o
+		/// </summary>
+		protected void DefineName (string name, object o)
+		{
+			try {
+				defined_names.Add (name, o);
+			} 
+			catch (ArgumentException exp) {
+				Report.Error (30260, /*Location,*/
+					"More than one defination with same name '" + name + 
+					"' is found in the container '" + Name + "'");	
+		    }
+
+		}
+
+		/// <summary>
+		///   Returns the object associated with a given name in the declaration
+		///   space.  This is the inverse operation of `DefineName'
+		/// </summary>
+		public object GetDefinition (string name)
+		{
+			return defined_names [name];
+		}
+		
+		bool in_transit = false;
+		
+		/// <summary>
+		///   This function is used to catch recursive definitions
+		///   in declarations.
+		/// </summary>
+		public bool InTransit {
+			get {
+				return in_transit;
+			}
+
+			set {
+				in_transit = value;
+			}
+		}
+
+		public TypeContainer Parent {
+			get {
+				return parent;
+			}
+		}
+
+		/// <summary>
+		///   Looks up the alias for the name
+		/// </summary>
+		public string LookupAlias (string name)
+		{
+			return RootContext.SourceBeingCompiled.LookupAlias (name);
+		}
+		
+		// 
+		// root_types contains all the types.  All TopLevel types
+		// hence have a parent that points to `root_types', that is
+		// why there is a non-obvious test down here.
+		//
+		public bool IsTopLevel {
+			get {
+				if (parent != null){
+					if (parent.parent == null)
+						return true;
+				}
+				return false;
+			}
+		}
+
+		public virtual void CloseType ()
+		{
+			if (!Created){
+				try {
+					TypeBuilder.CreateType ();
+				} catch {
+					//
+					// The try/catch is needed because
+					// nested enumerations fail to load when they
+					// are defined.
+					//
+					// Even if this is the right order (enumerations
+					// declared after types).
+					//
+					// Note that this still creates the type and
+					// it is possible to save it
+				}
+				Created = true;
+			}
+		}
+
+		/// <remarks>
+		///  Should be overriten by the appropriate declaration space
+		/// <remarks>
+		public abstract TypeBuilder DefineType ();
+		
+		/// <summary>
+		///   Define all members, but don't apply any attributes or do anything which may
+		///   access not-yet-defined classes.  This method also creates the MemberCache.
+		/// </summary>
+		public abstract bool DefineMembers (TypeContainer parent);
+
+		//
+		// Whether this is an `unsafe context'
+		//
+		public bool UnsafeContext {
+			get {
+				if ((ModFlags & Modifiers.UNSAFE) != 0)
+					return true;
+				if (parent != null)
+					return parent.UnsafeContext;
+				return false;
+			}
+		}
+
+		public static string MakeFQN (string nsn, string name)
+		{
+			string prefix = (nsn == "" ? "" : nsn + ".");
+
+			return prefix + name;
+		}
+
+		EmitContext type_resolve_ec;
+		EmitContext GetTypeResolveEmitContext (TypeContainer parent, Location loc)
+		{
+			type_resolve_ec = new EmitContext (parent, this, loc, null, null, ModFlags, false);
+			type_resolve_ec.ResolvingTypeTree = true;
+
+			return type_resolve_ec;
+		}
+
+		// <summary>
+		//    Looks up the type, as parsed into the expression `e' 
+		// </summary>
+		public Type ResolveType (Expression e, bool silent, Location loc)
+		{
+			if (type_resolve_ec == null)
+				type_resolve_ec = GetTypeResolveEmitContext (parent, loc);
+			type_resolve_ec.loc = loc;
+
+			int errors = Report.Errors;
+			Expression d = e.Resolve (type_resolve_ec, ResolveFlags.Type);
+			if (d == null || d.eclass != ExprClass.Type){
+				if (!silent && errors == Report.Errors){
+					Report.Error (30002, loc, "Cannot find type `"+ e.ToString () +"'");
+				}
+				return null;
+			}
+
+			return d.Type;
+		}
+
+		// <summary>
+		//    Resolves the expression `e' for a type, and will recursively define
+		//    types. 
+		// </summary>
+		public Expression ResolveTypeExpr (Expression e, bool silent, Location loc)
+		{
+			if (type_resolve_ec == null)
+				type_resolve_ec = GetTypeResolveEmitContext (parent, loc);
+
+			Expression d = e.Resolve (type_resolve_ec, ResolveFlags.Type);
+			if (d == null || d.eclass != ExprClass.Type){
+				if (!silent){
+					Report.Error (30002, loc, "Cannot find type `"+ e +"'");
+				}
+				return null;
+			}
+
+			return d;
+		}
+		
+		Type LookupInterfaceOrClass (string ns, string name, out bool error)
+		{
+			DeclSpace parent;
+			Type t;
+
+			error = false;
+			name = MakeFQN (ns, name);
+			
+			t  = TypeManager.LookupType (name);
+			if (t != null)
+				return t;
+
+			parent = (DeclSpace) RootContext.Tree.Decls [name];
+			if (parent == null)
+				return null;
+			
+			t = parent.DefineType ();
+			if (t == null){
+				Report.Error (30256, Location, "Class definition is circular: `"+name+"'");
+				error = true;
+				return null;
+			}
+			return t;
+		}
+
+		public static void Error_AmbiguousTypeReference (Location loc, string name, Type t1, Type t2)
+		{
+			Report.Error (104, loc,
+				      String.Format ("`{0}' is an ambiguous reference ({1} or {2}) ", name,
+						     t1.FullName, t2.FullName));
+		}
+
+		/// <summary>
+		///   GetType is used to resolve type names at the DeclSpace level.
+		///   Use this to lookup class/struct bases, interface bases or 
+		///   delegate type references
+		/// </summary>
+		///
+		/// <remarks>
+		///   Contrast this to LookupType which is used inside method bodies to 
+		///   lookup types that have already been defined.  GetType is used
+		///   during the tree resolution process and potentially define
+		///   recursively the type
+		/// </remarks>
+		public Type FindType (Location loc, string name)
+		{
+			Type t;
+			bool error;
+
+			//
+			// For the case the type we are looking for is nested within this one
+			// or is in any base class
+			//
+			DeclSpace containing_ds = this;
+
+			while (containing_ds != null){
+				Type current_type = containing_ds.TypeBuilder;
+
+				while (current_type != null) {
+					string pre = current_type.FullName;
+					
+					t = LookupInterfaceOrClass (pre, name, out error);
+					if (error)
+						return null;
+				
+					if (t != null) 
+						return t;
+
+					current_type = current_type.BaseType;
+				}
+				containing_ds = containing_ds.Parent;
+			}
+			
+			//
+			// Attempt to lookup the class on our namespace and all it's implicit parents
+			//
+			for (string ns = Namespace.Name; ns != null; ns = RootContext.ImplicitParent (ns)) {
+
+				t = LookupInterfaceOrClass (ns, name, out error);
+				if (error)
+					return null;
+				
+				if (t != null) 
+					return t;
+			}
+			
+			//
+			// Attempt to do a direct unqualified lookup
+			//
+			t = LookupInterfaceOrClass ("", name, out error);
+			if (error)
+				return null;
+			
+			if (t != null)
+				return t;
+			
+			//
+			// Attempt to lookup the class on any of the `using'
+			// namespaces
+			//
+
+			for (Namespace ns = Namespace; ns != null; ns = ns.Parent){
+
+				t = LookupInterfaceOrClass (ns.Name, name, out error);
+				if (error)
+					return null;
+
+				if (t != null)
+					return t;
+
+				//
+				// Now check the using clause list
+				//
+				ICollection imports_list = RootContext.SourceBeingCompiled.ImportsTable;
+
+				if (imports_list == null)
+					continue;
+
+				Type match = null;
+				foreach (SourceBeingCompiled.ImportsEntry ue in imports_list){
+					match = LookupInterfaceOrClass (ue.Name, name, out error);
+					if (error)
+						return null;
+
+					if (match != null){
+						if (t != null){
+							Error_AmbiguousTypeReference (loc, name, t, match);
+							return null;
+						}
+						
+						t = match;
+						ue.Used = true;
+					}
+				}
+				if (t != null)
+					return t;
+			}
+
+			//Report.Error (246, Location, "Can not find type `"+name+"'");
+			return null;
+		}
+
+		/// <remarks>
+		///   This function is broken and not what you're looking for.  It should only
+		///   be used while the type is still being created since it doesn't use the cache
+		///   and relies on the filter doing the member name check.
+		/// </remarks>
+		public abstract MemberList FindMembers (MemberTypes mt, BindingFlags bf,
+							MemberFilter filter, object criteria);
+
+		/// <remarks>
+		///   If we have a MemberCache, return it.  This property may return null if the
+		///   class doesn't have a member cache or while it's still being created.
+		/// </remarks>
+		public abstract MemberCache MemberCache {
+			get;
+		}
+
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+		{
+			try {
+				TypeBuilder.SetCustomAttribute (cb);
+			} catch (System.ArgumentException e) {
+				Report.Warning (-21, a.Location,
+						"The CharSet named property on StructLayout\n"+
+						"\tdoes not work correctly on Microsoft.NET\n"+
+						"\tYou might want to remove the CharSet declaration\n"+
+						"\tor compile using the Mono runtime instead of the\n"+
+						"\tMicrosoft .NET runtime\n"+
+						"\tThe runtime gave the error: " + e);
+			}
+		}
+	}
+
+
+	/// <summary>
+	///   This is a readonly list of MemberInfo's.      
+	/// </summary>
+	public class MemberList : IList {
+		public readonly IList List;
+		int count;
+
+		/// <summary>
+		///   Create a new MemberList from the given IList.
+		/// </summary>
+		public MemberList (IList list)
+		{
+			if (list != null)
+				this.List = list;
+			else
+				this.List = new ArrayList ();
+			count = List.Count;
+		}
+
+		/// <summary>
+		///   Concatenate the ILists `first' and `second' to a new MemberList.
+		/// </summary>
+		public MemberList (IList first, IList second)
+		{
+			ArrayList list = new ArrayList ();
+			list.AddRange (first);
+			list.AddRange (second);
+			count = list.Count;
+			List = list;
+		}
+
+		public static readonly MemberList Empty = new MemberList (new ArrayList ());
+
+		/// <summary>
+		///   Cast the MemberList into a MemberInfo[] array.
+		/// </summary>
+		/// <remarks>
+		///   This is an expensive operation, only use it if it's really necessary.
+		/// </remarks>
+		public static explicit operator MemberInfo [] (MemberList list)
+		{
+			Timer.StartTimer (TimerType.MiscTimer);
+			MemberInfo [] result = new MemberInfo [list.Count];
+			list.CopyTo (result, 0);
+			Timer.StopTimer (TimerType.MiscTimer);
+			return result;
+		}
+
+		// ICollection
+
+		public int Count {
+			get {
+				return count;
+			}
+		}
+
+		public bool IsSynchronized {
+			get {
+				return List.IsSynchronized;
+			}
+		}
+
+		public object SyncRoot {
+			get {
+				return List.SyncRoot;
+			}
+		}
+
+		public void CopyTo (Array array, int index)
+		{
+			List.CopyTo (array, index);
+		}
+
+		// IEnumerable
+
+		public IEnumerator GetEnumerator ()
+		{
+			return List.GetEnumerator ();
+		}
+
+		// IList
+
+		public bool IsFixedSize {
+			get {
+				return true;
+			}
+		}
+
+		public bool IsReadOnly {
+			get {
+				return true;
+			}
+		}
+
+		object IList.this [int index] {
+			get {
+				return List [index];
+			}
+
+			set {
+				throw new NotSupportedException ();
+			}
+		}
+
+		// FIXME: try to find out whether we can avoid the cast in this indexer.
+		public MemberInfo this [int index] {
+			get {
+				return (MemberInfo) List [index];
+			}
+		}
+
+		public int Add (object value)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public void Clear ()
+		{
+			throw new NotSupportedException ();
+		}
+
+		public bool Contains (object value)
+		{
+			return List.Contains (value);
+		}
+
+		public int IndexOf (object value)
+		{
+			return List.IndexOf (value);
+		}
+
+		public void Insert (int index, object value)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public void Remove (object value)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public void RemoveAt (int index)
+		{
+			throw new NotSupportedException ();
+		}
+	}
+
+	/// <summary>
+	///   This interface is used to get all members of a class when creating the
+	///   member cache.  It must be implemented by all DeclSpace derivatives which
+	///   want to support the member cache and by TypeHandle to get caching of
+	///   non-dynamic types.
+	/// </summary>
+	public interface IMemberContainer {
+		/// <summary>
+		///   The name of the IMemberContainer.  This is only used for
+		///   debugging purposes.
+		/// </summary>
+		string Name {
+			get;
+		}
+
+		/// <summary>
+		///   The type of this IMemberContainer.
+		/// </summary>
+		Type Type {
+			get;
+		}
+
+		/// <summary>
+		///   Returns the IMemberContainer of the parent class or null if this
+		///   is an interface or TypeManger.object_type.
+		///   This is used when creating the member cache for a class to get all
+		///   members from the parent class.
+		/// </summary>
+		IMemberContainer Parent {
+			get;
+		}
+
+		/// <summary>
+		///   Whether this is an interface.
+		/// </summary>
+		bool IsInterface {
+			get;
+		}
+
+		/// <summary>
+		///   Returns all members of this class with the corresponding MemberTypes
+		///   and BindingFlags.
+		/// </summary>
+		/// <remarks>
+		///   When implementing this method, make sure not to return any inherited
+		///   members and check the MemberTypes and BindingFlags properly.
+		///   Unfortunately, System.Reflection is lame and doesn't provide a way to
+		///   get the BindingFlags (static/non-static,public/non-public) in the
+		///   MemberInfo class, but the cache needs this information.  That's why
+		///   this method is called multiple times with different BindingFlags.
+		/// </remarks>
+		MemberList GetMembers (MemberTypes mt, BindingFlags bf);
+
+		/// <summary>
+		///   Return the container's member cache.
+		/// </summary>
+		MemberCache MemberCache {
+			get;
+		}
+	}
+
+	/// <summary>
+	///   The MemberCache is used by dynamic and non-dynamic types to speed up
+	///   member lookups.  It has a member name based hash table; it maps each member
+	///   name to a list of CacheEntry objects.  Each CacheEntry contains a MemberInfo
+	///   and the BindingFlags that were initially used to get it.  The cache contains
+	///   all members of the current class and all inherited members.  If this cache is
+	///   for an interface types, it also contains all inherited members.
+	///
+	///   There are two ways to get a MemberCache:
+	///   * if this is a dynamic type, lookup the corresponding DeclSpace and then
+	///     use the DeclSpace.MemberCache property.
+	///   * if this not a dynamic type, call TypeHandle.GetTypeHandle() to get a
+	///     TypeHandle instance for the type and then use TypeHandle.MemberCache.
+	/// </summary>
+	public class MemberCache {
+		public readonly IMemberContainer Container;
+		protected CaseInsensitiveHashtable member_hash;
+		protected CaseInsensitiveHashtable method_hash;
+		protected CaseInsensitiveHashtable interface_hash;
+
+		/// <summary>
+		///   Create a new MemberCache for the given IMemberContainer `container'.
+		/// </summary>
+		public MemberCache (IMemberContainer container)
+		{
+			this.Container = container;
+
+			Timer.IncrementCounter (CounterType.MemberCache);
+			Timer.StartTimer (TimerType.CacheInit);
+
+			interface_hash = new CaseInsensitiveHashtable ();
+
+			// If we have a parent class (we have a parent class unless we're
+			// TypeManager.object_type), we deep-copy its MemberCache here.
+			if (Container.Parent != null)
+				member_hash = SetupCache (Container.Parent.MemberCache);
+			else if (Container.IsInterface)
+				member_hash = SetupCacheForInterface ();
+			else
+				member_hash = new CaseInsensitiveHashtable ();
+
+			// If this is neither a dynamic type nor an interface, create a special
+			// method cache with all declared and inherited methods.
+			Type type = container.Type;
+			if (!(type is TypeBuilder) && !type.IsInterface) {
+				method_hash = new CaseInsensitiveHashtable ();
+				AddMethods (type);
+			}
+
+			// Add all members from the current class.
+			AddMembers (Container);
+
+			Timer.StopTimer (TimerType.CacheInit);
+		}
+
+		/// <summary>
+		///   Bootstrap this member cache by doing a deep-copy of our parent.
+		/// </summary>
+		CaseInsensitiveHashtable SetupCache (MemberCache parent)
+		{
+			CaseInsensitiveHashtable hash = new CaseInsensitiveHashtable ();
+
+			IDictionaryEnumerator it = parent.member_hash.GetEnumerator ();
+			while (it.MoveNext ()) {
+				ArrayList al = (ArrayList) it.Value;
+				// Constructors are never inherited and all have the same key
+				if ((((CacheEntry)al [0]).EntryType & EntryType.Constructor) == 0)
+					hash [it.Key] = ((ArrayList) it.Value).Clone ();
+			}
+
+			return hash;
+		}
+
+		void AddInterfaces (MemberCache parent)
+		{
+			foreach (Type iface in parent.interface_hash.Keys) {
+				if (!interface_hash.Contains (iface))
+					interface_hash.Add (iface, true);
+			}
+		}
+
+		/// <summary>
+		///   Add the contents of `new_hash' to `hash'.
+		/// </summary>
+		void AddHashtable (Hashtable hash, Hashtable new_hash)
+		{
+			IDictionaryEnumerator it = new_hash.GetEnumerator ();
+			while (it.MoveNext ()) {
+				ArrayList list = (ArrayList) hash [it.Key];
+				if (list != null)
+					list.AddRange ((ArrayList) it.Value);
+				else
+					hash [it.Key] = ((ArrayList) it.Value).Clone ();
+			}
+		}
+
+		/// <summary>
+		///   Bootstrap the member cache for an interface type.
+		///   Type.GetMembers() won't return any inherited members for interface types,
+		///   so we need to do this manually.  Interfaces also inherit from System.Object.
+		/// </summary>
+		CaseInsensitiveHashtable SetupCacheForInterface ()
+		{
+			CaseInsensitiveHashtable hash = SetupCache (TypeHandle.ObjectType.MemberCache);
+			Type [] ifaces = TypeManager.GetInterfaces (Container.Type);
+
+			foreach (Type iface in ifaces) {
+				if (interface_hash.Contains (iface))
+					continue;
+				interface_hash.Add (iface, true);
+
+				IMemberContainer iface_container =
+					TypeManager.LookupMemberContainer (iface);
+
+				MemberCache iface_cache = iface_container.MemberCache;
+				AddHashtable (hash, iface_cache.member_hash);
+				AddInterfaces (iface_cache);
+			}
+
+			return hash;
+		}
+
+		/// <summary>
+		///   Add all members from class `container' to the cache.
+		/// </summary>
+		void AddMembers (IMemberContainer container)
+		{
+			// We need to call AddMembers() with a single member type at a time
+			// to get the member type part of CacheEntry.EntryType right.
+			AddMembers (MemberTypes.Constructor, container);
+			AddMembers (MemberTypes.Field, container);
+			AddMembers (MemberTypes.Method, container);
+			AddMembers (MemberTypes.Property, container);
+			AddMembers (MemberTypes.Event, container);
+			// Nested types are returned by both Static and Instance searches.
+			AddMembers (MemberTypes.NestedType,
+				    BindingFlags.Static | BindingFlags.Public, container);
+			AddMembers (MemberTypes.NestedType,
+				    BindingFlags.Static | BindingFlags.NonPublic, container);
+		}
+
+		void AddMembers (MemberTypes mt, IMemberContainer container)
+		{
+			AddMembers (mt, BindingFlags.Static | BindingFlags.Public, container);
+			AddMembers (mt, BindingFlags.Static | BindingFlags.NonPublic, container);
+			AddMembers (mt, BindingFlags.Instance | BindingFlags.Public, container);
+			AddMembers (mt, BindingFlags.Instance | BindingFlags.NonPublic, container);
+		}
+
+		/// <summary>
+		///   Add all members from class `container' with the requested MemberTypes and
+		///   BindingFlags to the cache.  This method is called multiple times with different
+		///   MemberTypes and BindingFlags.
+		/// </summary>
+		void AddMembers (MemberTypes mt, BindingFlags bf, IMemberContainer container)
+		{
+			MemberList members = container.GetMembers (mt, bf);
+			/*BindingFlags new_bf = (container == Container) ?
+				bf | BindingFlags.DeclaredOnly : bf;
+			*/
+			foreach (MemberInfo member in members) {
+				string name = member.Name;
+
+				// We use a name-based hash table of ArrayList's.
+				ArrayList list = (ArrayList) member_hash [name];
+				if (list == null) {
+					list = new ArrayList ();
+					member_hash.Add (name, list);
+				}
+
+				// When this method is called for the current class, the list will
+				// already contain all inherited members from our parent classes.
+				// We cannot add new members in front of the list since this'd be an
+				// expensive operation, that's why the list is sorted in reverse order
+				// (ie. members from the current class are coming last).
+				list.Add (new CacheEntry (container, member, mt, bf));
+			}
+		}
+
+		/// <summary>
+		///   Add all declared and inherited methods from class `type' to the method cache.
+		/// </summary>
+		void AddMethods (Type type)
+		{
+			AddMethods (BindingFlags.Static | BindingFlags.Public, type);
+			AddMethods (BindingFlags.Static | BindingFlags.NonPublic, type);
+			AddMethods (BindingFlags.Instance | BindingFlags.Public, type);
+			AddMethods (BindingFlags.Instance | BindingFlags.NonPublic, type);
+		}
+
+		void AddMethods (BindingFlags bf, Type type)
+		{
+			MemberInfo [] members = type.GetMethods (bf);
+
+			foreach (MethodBase member in members) {
+				string name = member.Name;
+
+				// Varargs methods aren't allowed in C# code.
+				if ((member.CallingConvention & CallingConventions.VarArgs) != 0)
+					continue;
+
+				// We use a name-based hash table of ArrayList's.
+				ArrayList list = (ArrayList) method_hash [name];
+				if (list == null) {
+					list = new ArrayList ();
+					method_hash.Add (name, list);
+				}
+
+				// Unfortunately, the elements returned by Type.GetMethods() aren't
+				// sorted so we need to do this check for every member.
+				BindingFlags new_bf = bf;
+				if (member.DeclaringType == type)
+					new_bf |= BindingFlags.DeclaredOnly;
+
+				list.Add (new CacheEntry (Container, member, MemberTypes.Method, new_bf));
+			}
+		}
+
+		/// <summary>
+		///   Compute and return a appropriate `EntryType' magic number for the given
+		///   MemberTypes and BindingFlags.
+		/// </summary>
+		protected static EntryType GetEntryType (MemberTypes mt, BindingFlags bf)
+		{
+			EntryType type = EntryType.None;
+
+			if ((mt & MemberTypes.Constructor) != 0)
+				type |= EntryType.Constructor;
+			if ((mt & MemberTypes.Event) != 0)
+				type |= EntryType.Event;
+			if ((mt & MemberTypes.Field) != 0)
+				type |= EntryType.Field;
+			if ((mt & MemberTypes.Method) != 0)
+				type |= EntryType.Method;
+			if ((mt & MemberTypes.Property) != 0)
+				type |= EntryType.Property;
+			// Nested types are returned by static and instance searches.
+			if ((mt & MemberTypes.NestedType) != 0)
+				type |= EntryType.NestedType | EntryType.Static | EntryType.Instance;
+
+			if ((bf & BindingFlags.Instance) != 0)
+				type |= EntryType.Instance;
+			if ((bf & BindingFlags.Static) != 0)
+				type |= EntryType.Static;
+			if ((bf & BindingFlags.Public) != 0)
+				type |= EntryType.Public;
+			if ((bf & BindingFlags.NonPublic) != 0)
+				type |= EntryType.NonPublic;
+			if ((bf & BindingFlags.DeclaredOnly) != 0)
+				type |= EntryType.Declared;
+
+			return type;
+		}
+
+		/// <summary>
+		///   The `MemberTypes' enumeration type is a [Flags] type which means that it may
+		///   denote multiple member types.  Returns true if the given flags value denotes a
+		///   single member types.
+		/// </summary>
+		public static bool IsSingleMemberType (MemberTypes mt)
+		{
+			switch (mt) {
+			case MemberTypes.Constructor:
+			case MemberTypes.Event:
+			case MemberTypes.Field:
+			case MemberTypes.Method:
+			case MemberTypes.Property:
+			case MemberTypes.NestedType:
+				return true;
+
+			default:
+				return false;
+			}
+		}
+
+		/// <summary>
+		///   We encode the MemberTypes and BindingFlags of each members in a "magic"
+		///   number to speed up the searching process.
+		/// </summary>
+		[Flags]
+		protected enum EntryType {
+			None		= 0x000,
+
+			Instance	= 0x001,
+			Static		= 0x002,
+			MaskStatic	= Instance|Static,
+
+			Public		= 0x004,
+			NonPublic	= 0x008,
+			MaskProtection	= Public|NonPublic,
+
+			Declared	= 0x010,
+
+			Constructor	= 0x020,
+			Event		= 0x040,
+			Field		= 0x080,
+			Method		= 0x100,
+			Property	= 0x200,
+			NestedType	= 0x400,
+
+			MaskType	= Constructor|Event|Field|Method|Property|NestedType
+		}
+
+		protected struct CacheEntry {
+			public readonly IMemberContainer Container;
+			public readonly EntryType EntryType;
+			public readonly MemberInfo Member;
+
+			public CacheEntry (IMemberContainer container, MemberInfo member,
+					   MemberTypes mt, BindingFlags bf)
+			{
+				this.Container = container;
+				this.Member = member;
+				this.EntryType = GetEntryType (mt, bf);
+			}
+		}
+
+		/// <summary>
+		///   This is called each time we're walking up one level in the class hierarchy
+		///   and checks whether we can abort the search since we've already found what
+		///   we were looking for.
+		/// </summary>
+		protected bool DoneSearching (ArrayList list)
+		{
+			//
+			// We've found exactly one member in the current class and it's not
+			// a method or constructor.
+			//
+			if (list.Count == 1 && !(list [0] is MethodBase))
+				return true;
+
+			//
+			// Multiple properties: we query those just to find out the indexer
+			// name
+			//
+			if ((list.Count > 0) && (list [0] is PropertyInfo))
+				return true;
+
+			return false;
+		}
+
+		/// <summary>
+		///   Looks up members with name `name'.  If you provide an optional
+		///   filter function, it'll only be called with members matching the
+		///   requested member name.
+		///
+		///   This method will try to use the cache to do the lookup if possible.
+		///
+		///   Unlike other FindMembers implementations, this method will always
+		///   check all inherited members - even when called on an interface type.
+		///
+		///   If you know that you're only looking for methods, you should use
+		///   MemberTypes.Method alone since this speeds up the lookup a bit.
+		///   When doing a method-only search, it'll try to use a special method
+		///   cache (unless it's a dynamic type or an interface) and the returned
+		///   MemberInfo's will have the correct ReflectedType for inherited methods.
+		///   The lookup process will automatically restart itself in method-only
+		///   search mode if it discovers that it's about to return methods.
+		/// </summary>
+		public MemberList FindMembers (MemberTypes mt, BindingFlags bf, string name,
+					       MemberFilter filter, object criteria)
+		{
+			bool declared_only = (bf & BindingFlags.DeclaredOnly) != 0;
+			bool method_search = mt == MemberTypes.Method;
+			// If we have a method cache and we aren't already doing a method-only search,
+			// then we restart a method search if the first match is a method.
+			bool do_method_search = !method_search && (method_hash != null);
+bf |= BindingFlags.IgnoreCase;
+			ArrayList applicable;
+
+			// If this is a method-only search, we try to use the method cache if
+			// possible; a lookup in the method cache will return a MemberInfo with
+			// the correct ReflectedType for inherited methods.
+			if (method_search && (method_hash != null))
+				applicable = (ArrayList) method_hash [name];
+			else
+				applicable = (ArrayList) member_hash [name];
+
+			if (applicable == null)
+				return MemberList.Empty;
+
+			ArrayList list = new ArrayList ();
+
+			Timer.StartTimer (TimerType.CachedLookup);
+
+			EntryType type = GetEntryType (mt, bf);
+
+			IMemberContainer current = Container;
+
+			// `applicable' is a list of all members with the given member name `name'
+			// in the current class and all its parent classes.  The list is sorted in
+			// reverse order due to the way how the cache is initialy created (to speed
+			// things up, we're doing a deep-copy of our parent).
+
+			for (int i = applicable.Count-1; i >= 0; i--) {
+				CacheEntry entry = (CacheEntry) applicable [i];
+
+				// This happens each time we're walking one level up in the class
+				// hierarchy.  If we're doing a DeclaredOnly search, we must abort
+				// the first time this happens (this may already happen in the first
+				// iteration of this loop if there are no members with the name we're
+				// looking for in the current class).
+				if (entry.Container != current) {
+					//if (declared_only || DoneSearching (list))
+					if (declared_only)
+						break;
+
+					current = entry.Container;
+				}
+
+				// Is the member of the correct type ?
+				if ((entry.EntryType & type & EntryType.MaskType) == 0)
+					continue;
+
+				// Is the member static/non-static ?
+				if ((entry.EntryType & type & EntryType.MaskStatic) == 0)
+					continue;
+
+				// Apply the filter to it.
+				if (filter (entry.Member, criteria)) {
+					if ((entry.EntryType & EntryType.MaskType) != EntryType.Method)
+						do_method_search = false;
+					list.Add (entry.Member);
+				}
+			}
+
+			Timer.StopTimer (TimerType.CachedLookup);
+
+			// If we have a method cache and we aren't already doing a method-only
+			// search, we restart in method-only search mode if the first match is
+			// a method.  This ensures that we return a MemberInfo with the correct
+			// ReflectedType for inherited methods.
+			if (do_method_search && (list.Count > 0))
+				return FindMembers (MemberTypes.Method, bf, name, filter, criteria);
+
+			return new MemberList (list);
+		}
+	}
+}
diff --git a/dead/mbas/defaultparserattribute.cs b/dead/mbas/defaultparserattribute.cs
new file mode 100644
index 00000000..2a6b6878
--- /dev/null
+++ b/dead/mbas/defaultparserattribute.cs
@@ -0,0 +1,22 @@
+//
+// DefaultParserAttribute.cs: Marks a parser as the default one
+//    						  for file extensions not matched against the map
+//
+// Author: A Rafael D Teixeira (rafaelteixeirabr@hotmail.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// Copyright (C) 2003 Ximian, Inc.
+//
+
+namespace Mono.Languages
+{
+	using System;
+	using System.Reflection;
+
+	[AttributeUsage(AttributeTargets.Class)]
+	public class DefaultParserAttribute : System.Attribute 
+	{
+		// just a boolean marker
+	}
+}
diff --git a/dead/mbas/delegate.cs b/dead/mbas/delegate.cs
new file mode 100644
index 00000000..84a7ecb0
--- /dev/null
+++ b/dead/mbas/delegate.cs
@@ -0,0 +1,776 @@
+//
+// delegate.cs: Delegate Handler
+//
+// Author: Ravi Pratap (ravi@ximian.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001 Ximian, Inc (http://www.ximian.com)
+//
+//
+
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Text;
+
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///   Holds Delegates
+	/// </summary>
+	public class Delegate : DeclSpace {
+ 		public Expression ReturnType;
+		public Parameters      Parameters;
+
+		public ConstructorBuilder ConstructorBuilder;
+		public MethodBuilder      InvokeBuilder;
+		public MethodBuilder      BeginInvokeBuilder;
+		public MethodBuilder      EndInvokeBuilder;
+		
+		Type [] param_types;
+		Type ret_type;
+		
+		Expression instance_expr;
+		MethodBase delegate_method;
+	
+		const int AllowedModifiers =
+			Modifiers.SHADOWS |
+			Modifiers.PUBLIC |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL |
+		    Modifiers.UNSAFE |
+			Modifiers.PRIVATE;
+
+ 		public Delegate (TypeContainer parent, Expression type, int mod_flags,
+				 string name, Parameters param_list,
+				 Attributes attrs, Location l)
+			: base (parent, name, attrs, l)
+		{
+			this.ReturnType = type;
+
+			ModFlags        = Modifiers.Check (AllowedModifiers, mod_flags,
+							   IsTopLevel ? Modifiers.INTERNAL :
+							   Modifiers.PUBLIC, l);
+			Parameters      = param_list;
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Delegate;
+			}
+		}
+
+		public override TypeBuilder DefineType ()
+		{
+			TypeAttributes attr;
+
+			if (TypeBuilder != null)
+				return TypeBuilder;
+			
+			if (IsTopLevel) {
+				ModuleBuilder builder = CodeGen.ModuleBuilder;
+				attr = TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Sealed;
+
+				TypeBuilder = builder.DefineType (
+					Name, attr, TypeManager.multicast_delegate_type);
+			} else {
+				TypeBuilder builder = Parent.TypeBuilder;
+				attr = TypeAttributes.NestedPublic | TypeAttributes.Class |
+					TypeAttributes.Sealed;
+
+				string name = Name.Substring (1 + Name.LastIndexOf ('.'));
+				TypeBuilder = builder.DefineNestedType (
+					name, attr, TypeManager.multicast_delegate_type);
+			}
+
+			TypeManager.AddDelegateType (Name, TypeBuilder, this);
+
+			return TypeBuilder;
+		}
+
+ 		public override bool DefineMembers (TypeContainer container)
+		{
+			return true;
+		}
+
+ 		public override bool Define (TypeContainer container)
+		{
+			MethodAttributes mattr;
+			int i;
+
+			// FIXME: POSSIBLY make this static, as it is always constant
+			//
+			Type [] const_arg_types = new Type [2];
+			const_arg_types [0] = TypeManager.object_type;
+			const_arg_types [1] = TypeManager.intptr_type;
+
+			mattr = MethodAttributes.RTSpecialName | MethodAttributes.SpecialName |
+				MethodAttributes.HideBySig | MethodAttributes.Public;
+
+			ConstructorBuilder = TypeBuilder.DefineConstructor (mattr,
+									    CallingConventions.Standard,
+									    const_arg_types);
+
+			ConstructorBuilder.DefineParameter (1, ParameterAttributes.None, "object");
+			ConstructorBuilder.DefineParameter (2, ParameterAttributes.None, "method");
+			//
+			// HACK because System.Reflection.Emit is lame
+			//
+			//
+			// FIXME: POSSIBLY make these static, as they are always the same
+			Parameter [] fixed_pars = new Parameter [2];
+			fixed_pars [0] = new Parameter (null, null, Parameter.Modifier.NONE, null);
+			fixed_pars [1] = new Parameter (null, null, Parameter.Modifier.NONE, null);
+			Parameters const_parameters = new Parameters (fixed_pars, null, Location);
+			
+			TypeManager.RegisterMethod (
+				ConstructorBuilder,
+				new InternalParameters (const_arg_types, const_parameters),
+				const_arg_types);
+				
+			
+			ConstructorBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
+
+			//
+			// Here the various methods like Invoke, BeginInvoke etc are defined
+			//
+			// First, call the `out of band' special method for
+			// defining recursively any types we need:
+			
+			if (!Parameters.ComputeAndDefineParameterTypes (this))
+				return false;
+			
+ 			param_types = Parameters.GetParameterInfo (this);
+			if (param_types == null)
+				return false;
+
+			//
+			// Invoke method
+			//
+
+			// Check accessibility
+			foreach (Type partype in param_types)
+				if (!container.AsAccessible (partype, ModFlags)) {
+					Report.Error (59, Location,
+						      "Inconsistent accessibility: parameter type `" +
+						      TypeManager.MonoBASIC_Name (partype) + "` is less " +
+						      "accessible than delegate `" + Name + "'");
+					return false;
+				}
+			
+ 			ReturnType = ResolveTypeExpr (ReturnType, false, Location);
+   			ret_type = ReturnType.Type;
+			if (ret_type == null)
+				return false;
+
+			if (!container.AsAccessible (ret_type, ModFlags)) {
+				Report.Error (58, Location,
+					      "Inconsistent accessibility: return type `" +
+					      TypeManager.MonoBASIC_Name (ret_type) + "` is less " +
+					      "accessible than delegate `" + Name + "'");
+				return false;
+			}
+
+			//
+			// We don't have to check any others because they are all
+			// guaranteed to be accessible - they are standard types.
+			//
+			
+  			CallingConventions cc = Parameters.GetCallingConvention ();
+
+ 			mattr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual;
+
+ 			InvokeBuilder = TypeBuilder.DefineMethod ("Invoke", 
+ 								  mattr,		     
+ 								  cc,
+ 								  ret_type,		     
+ 								  param_types);
+
+			i = 0;
+			if (Parameters.FixedParameters != null){
+				int top = Parameters.FixedParameters.Length;
+				Parameter p;
+				
+				for (; i < top; i++) {
+					p = Parameters.FixedParameters [i];
+
+					InvokeBuilder.DefineParameter (
+						i+1, p.Attributes, p.Name);
+				}
+			}
+			if (Parameters.ArrayParameter != null){
+				Parameter p = Parameters.ArrayParameter;
+				
+				InvokeBuilder.DefineParameter (
+					i+1, p.Attributes, p.Name);
+			}
+			
+			InvokeBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
+
+			TypeManager.RegisterMethod (InvokeBuilder,
+						    new InternalParameters (container, Parameters),
+						    param_types);
+
+			//
+			// BeginInvoke
+			//
+			int params_num = param_types.Length;
+			Type [] async_param_types = new Type [params_num + 2];
+
+			param_types.CopyTo (async_param_types, 0);
+
+			async_param_types [params_num] = TypeManager.asynccallback_type;
+			async_param_types [params_num + 1] = TypeManager.object_type;
+
+			mattr = MethodAttributes.Public | MethodAttributes.HideBySig |
+				MethodAttributes.Virtual | MethodAttributes.NewSlot;
+			
+			BeginInvokeBuilder = TypeBuilder.DefineMethod ("BeginInvoke",
+								       mattr,
+								       cc,
+								       TypeManager.iasyncresult_type,
+								       async_param_types);
+
+			i = 0;
+			if (Parameters.FixedParameters != null){
+				int top = Parameters.FixedParameters.Length;
+				Parameter p;
+				
+				for (i = 0 ; i < top; i++) {
+					p = Parameters.FixedParameters [i];
+
+					BeginInvokeBuilder.DefineParameter (
+						i+1, p.Attributes, p.Name);
+				}
+			}
+			if (Parameters.ArrayParameter != null){
+				Parameter p = Parameters.ArrayParameter;
+				
+				BeginInvokeBuilder.DefineParameter (
+					i+1, p.Attributes, p.Name);
+				i++;
+			}
+
+			BeginInvokeBuilder.DefineParameter (i + 1, ParameterAttributes.None, "callback");
+			BeginInvokeBuilder.DefineParameter (i + 2, ParameterAttributes.None, "object");
+			
+			BeginInvokeBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
+
+			Parameter [] async_params = new Parameter [params_num + 2];
+			int n = 0;
+			if (Parameters.FixedParameters != null){
+				Parameters.FixedParameters.CopyTo (async_params, 0);
+				n = Parameters.FixedParameters.Length;
+			}
+			if (Parameters.ArrayParameter != null)
+				async_params [n] = Parameters.ArrayParameter;
+			
+			async_params [params_num] = new Parameter (
+				TypeManager.system_asynccallback_expr, "callback",
+								   Parameter.Modifier.NONE, null);
+			async_params [params_num + 1] = new Parameter (
+				TypeManager.system_object_expr, "object",
+								   Parameter.Modifier.NONE, null);
+
+			Parameters async_parameters = new Parameters (async_params, null, Location);
+			
+			async_parameters.ComputeAndDefineParameterTypes (this);
+			TypeManager.RegisterMethod (BeginInvokeBuilder,
+						    new InternalParameters (container, async_parameters),
+						    async_param_types);
+
+			//
+			// EndInvoke
+			//
+			Type [] end_param_types = new Type [1];
+			end_param_types [0] = TypeManager.iasyncresult_type;
+			
+			EndInvokeBuilder = TypeBuilder.DefineMethod ("EndInvoke",
+								     mattr,
+								     cc,
+								     ret_type,
+								     end_param_types);
+			EndInvokeBuilder.DefineParameter (1, ParameterAttributes.None, "result");
+			
+			EndInvokeBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
+
+			Parameter [] end_params = new Parameter [1];
+			end_params [0] = new Parameter (
+				TypeManager.system_iasyncresult_expr, "result",
+							Parameter.Modifier.NONE, null);
+
+			TypeManager.RegisterMethod (
+				EndInvokeBuilder, new InternalParameters (
+					container,
+					new Parameters (
+						end_params, null, Location)),
+						    end_param_types);
+
+			return true;
+		}
+
+		/// <summary>
+		///  Verifies whether the method in question is compatible with the delegate
+		///  Returns the method itself if okay and null if not.
+		/// </summary>
+		public static MethodBase VerifyMethod (EmitContext ec, Type delegate_type, MethodBase mb,
+						       Location loc)
+		{
+			ParameterData pd = Invocation.GetParameterData (mb);
+
+			int pd_count = pd.Count;
+
+			Expression ml = Expression.MemberLookup (
+				ec, delegate_type, "Invoke", loc);
+
+			if (!(ml is MethodGroupExpr)) {
+				Report.Error (-100, loc, "Internal error: could not find Invoke method!");
+				return null;
+			}
+
+			MethodBase invoke_mb = ((MethodGroupExpr) ml).Methods [0];
+
+			ParameterData invoke_pd = Invocation.GetParameterData (invoke_mb);
+
+			if (invoke_pd.Count != pd_count)
+				return null;
+
+			for (int i = pd_count; i > 0; ) {
+				i--;
+
+				if (invoke_pd.ParameterType (i) == pd.ParameterType (i))
+					continue;
+				else
+					return null;
+			}
+
+			if (((MethodInfo) invoke_mb).ReturnType == ((MethodInfo) mb).ReturnType)
+				return mb;
+			else
+				return null;
+		}
+
+		// <summary>
+		//  Verifies whether the invocation arguments are compatible with the
+		//  delegate's target method
+		// </summary>
+		public static bool VerifyApplicability (EmitContext ec,
+							Type delegate_type,
+							ArrayList args,
+							Location loc)
+		{
+			int arg_count;
+
+			if (args == null)
+				arg_count = 0;
+			else
+				arg_count = args.Count;
+
+			Expression ml = Expression.MemberLookup (
+				ec, delegate_type, "Invoke", loc);
+
+			if (!(ml is MethodGroupExpr)) {
+				Report.Error (-100, loc, "Internal error: could not find Invoke method!" + delegate_type);
+				return false;
+			}
+			
+			MethodBase mb = ((MethodGroupExpr) ml).Methods [0];
+			ParameterData pd = Invocation.GetParameterData (mb);
+
+			int pd_count = pd.Count;
+
+			bool not_params_method = (pd_count == 0) ||
+				(pd.ParameterModifier (pd_count - 1) != Parameter.Modifier.PARAMS);
+
+			if (not_params_method && pd_count != arg_count) {
+				Report.Error (1593, loc,
+					      "Delegate '" + delegate_type.ToString ()
+					      + "' does not take '" + arg_count + "' arguments");
+				return false;
+			}
+
+			return Invocation.VerifyArgumentsCompat (ec, args, arg_count, mb, !not_params_method,
+								 delegate_type, loc);
+		}
+		
+		/// <summary>
+		///  Verifies whether the delegate in question is compatible with this one in
+		///  order to determine if instantiation from the same is possible.
+		/// </summary>
+		public static bool VerifyDelegate (EmitContext ec, Type delegate_type, Type probe_type, Location loc)
+		{
+			Expression ml = Expression.MemberLookup (
+				ec, delegate_type, "Invoke", loc);
+			
+			if (!(ml is MethodGroupExpr)) {
+				Report.Error (-100, loc, "Internal error: could not find Invoke method!");
+				return false;
+			}
+			
+			MethodBase mb = ((MethodGroupExpr) ml).Methods [0];
+			ParameterData pd = Invocation.GetParameterData (mb);
+
+			Expression probe_ml = Expression.MemberLookup (
+				ec, delegate_type, "Invoke", loc);
+			
+			if (!(probe_ml is MethodGroupExpr)) {
+				Report.Error (-100, loc, "Internal error: could not find Invoke method!");
+				return false;
+			}
+			
+			MethodBase probe_mb = ((MethodGroupExpr) probe_ml).Methods [0];
+			ParameterData probe_pd = Invocation.GetParameterData (probe_mb);
+			
+			if (((MethodInfo) mb).ReturnType != ((MethodInfo) probe_mb).ReturnType)
+				return false;
+
+			if (pd.Count != probe_pd.Count)
+				return false;
+
+			for (int i = pd.Count; i > 0; ) {
+				i--;
+
+				if (pd.ParameterType (i) != probe_pd.ParameterType (i) ||
+				    pd.ParameterModifier (i) != probe_pd.ParameterModifier (i))
+					return false;
+			}
+			
+			return true;
+		}
+		
+		public static string FullDelegateDesc (Type del_type, MethodBase mb, ParameterData pd)
+		{
+			StringBuilder sb = new StringBuilder (TypeManager.MonoBASIC_Name (((MethodInfo) mb).ReturnType));
+			
+			sb.Append (" " + del_type.ToString ());
+			sb.Append (" (");
+
+			int length = pd.Count;
+			
+			for (int i = length; i > 0; ) {
+				i--;
+				
+				sb.Append (TypeManager.MonoBASIC_Name (pd.ParameterType (length - i - 1)));
+				if (i != 0)
+					sb.Append (", ");
+			}
+			
+			sb.Append (")");
+			return sb.ToString ();
+			
+		}
+		
+		// Hack around System.Reflection as found everywhere else
+		public override MemberList FindMembers (MemberTypes mt, BindingFlags bf,
+							MemberFilter filter, object criteria)
+		{
+			ArrayList members = new ArrayList ();
+
+			if ((mt & MemberTypes.Method) != 0) {
+				if (ConstructorBuilder != null)
+				if (filter (ConstructorBuilder, criteria))
+					members.Add (ConstructorBuilder);
+
+				if (InvokeBuilder != null)
+				if (filter (InvokeBuilder, criteria))
+					members.Add (InvokeBuilder);
+
+				if (BeginInvokeBuilder != null)
+				if (filter (BeginInvokeBuilder, criteria))
+					members.Add (BeginInvokeBuilder);
+
+				if (EndInvokeBuilder != null)
+				if (filter (EndInvokeBuilder, criteria))
+					members.Add (EndInvokeBuilder);
+			}
+
+			return new MemberList (members);
+		}
+
+		public override MemberCache MemberCache {
+			get {
+				return null;
+			}
+		}
+
+		public Expression InstanceExpression {
+			get {
+				return instance_expr;
+			}
+			set {
+				instance_expr = value;
+			}
+		}
+
+		public MethodBase TargetMethod {
+			get {
+				return delegate_method;
+			}
+			set {
+				delegate_method = value;
+			}
+		}
+
+		public Type TargetReturnType {
+			get {
+				return ret_type;
+			}
+		}
+
+		public Type [] ParameterTypes {
+			get {
+				return param_types;
+			}
+		}
+		
+	}
+
+	public class NewDelegate : Expression {
+
+		public ArrayList Arguments;
+
+		MethodBase constructor_method;
+		MethodBase delegate_method;
+		Expression delegate_instance_expr;
+
+		public NewDelegate (Type type, ArrayList Arguments, Location loc)
+		{
+			this.type = type;
+			this.Arguments = Arguments;
+			this.loc  = loc; 
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (Arguments == null) {
+				Report.Error (-11, loc,
+					      "Delegate creation expression takes only one argument");
+				return null;
+			}
+
+			if (Arguments.Count != 1) {
+				Report.Error (-11, loc,
+					      "Delegate creation expression takes only one argument");
+				return null;
+			}
+
+			Expression ml = Expression.MemberLookup (
+				ec, type, ".ctor", loc);
+
+			if (!(ml is MethodGroupExpr)) {
+				Report.Error (-100, loc, "Internal error: Could not find delegate constructor!");
+				return null;
+			}
+
+			constructor_method = ((MethodGroupExpr) ml).Methods [0];
+			Argument a = (Argument) Arguments [0];
+			
+			if (!a.ResolveMethodGroup (ec, Location))
+				return null;
+			
+			Expression e = a.Expr;
+
+			Expression invoke_method = Expression.MemberLookup (
+				ec, type, "Invoke", MemberTypes.Method,
+				Expression.AllBindingFlags, loc);
+
+			if (invoke_method == null) {
+				Report.Error (-200, loc, "Internal error ! Could not find Invoke method!");
+				return null;
+			}
+
+			if (e is MethodGroupExpr) {
+				MethodGroupExpr mg = (MethodGroupExpr) e;
+
+				foreach (MethodInfo mi in mg.Methods){
+					delegate_method  = Delegate.VerifyMethod (ec, type, mi, loc);
+
+					if (delegate_method != null)
+						break;
+				}
+					
+				if (delegate_method == null) {
+					string method_desc;
+					if (mg.Methods.Length > 1)
+						method_desc = mg.Methods [0].Name;
+					else
+						method_desc = Invocation.FullMethodDesc (mg.Methods [0]);
+
+					MethodBase dm = ((MethodGroupExpr) invoke_method).Methods [0];
+					ParameterData param = Invocation.GetParameterData (dm);
+					string delegate_desc = Delegate.FullDelegateDesc (type, dm, param);
+
+					Report.Error (30408, loc, "Method '" + method_desc + "' does not " +
+						      "match delegate '" + delegate_desc + "'");
+
+					return null;
+				}
+
+				//
+				// Check safe/unsafe of the delegate
+				//
+				if (!ec.InUnsafe){
+					ParameterData param = Invocation.GetParameterData (delegate_method);
+					int count = param.Count;
+					
+					for (int i = 0; i < count; i++){
+						if (param.ParameterType (i).IsPointer){
+							Expression.UnsafeError (loc);
+							return null;
+						}
+					}
+				}
+						
+				if (mg.InstanceExpression != null)
+					delegate_instance_expr = mg.InstanceExpression.Resolve (ec);
+				else {
+					if (!ec.IsStatic)
+						delegate_instance_expr = ec.This;
+					else
+						delegate_instance_expr = null;
+				}
+
+				if (delegate_instance_expr != null)
+					if (delegate_instance_expr.Type.IsValueType)
+						delegate_instance_expr = new BoxedCast (delegate_instance_expr);
+				
+				eclass = ExprClass.Value;
+				return this;
+			}
+
+			Type e_type = e.Type;
+
+			if (!TypeManager.IsDelegateType (e_type)) {
+				Report.Error (-12, loc, "Cannot create a delegate from something " +
+					      "not a delegate or a method.");
+				return null;
+			}
+
+			// This is what MS' compiler reports. We could always choose
+			// to be more verbose and actually give delegate-level specifics
+			
+			if (!Delegate.VerifyDelegate (ec, type, e_type, loc)) {
+				Report.Error (29, loc, "Cannot implicitly convert type '" + e_type + "' " +
+					      "to type '" + type + "'");
+				return null;
+			}
+				
+			delegate_instance_expr = e;
+			delegate_method = ((MethodGroupExpr) invoke_method).Methods [0];
+			
+			eclass = ExprClass.Value;
+			return this;
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			if (delegate_instance_expr == null ||
+			    delegate_method.IsStatic)
+				ec.ig.Emit (OpCodes.Ldnull);
+			else
+				delegate_instance_expr.Emit (ec);
+			
+			if (delegate_method.IsVirtual) {
+				ec.ig.Emit (OpCodes.Dup);
+				ec.ig.Emit (OpCodes.Ldvirtftn, (MethodInfo) delegate_method);
+			} else
+				ec.ig.Emit (OpCodes.Ldftn, (MethodInfo) delegate_method);
+			ec.ig.Emit (OpCodes.Newobj, (ConstructorInfo) constructor_method);
+		}
+	}
+
+	public class DelegateInvocation : ExpressionStatement {
+
+		public Expression InstanceExpr;
+		public ArrayList  Arguments;
+
+		MethodBase method;
+		
+		public DelegateInvocation (Expression instance_expr, ArrayList args, Location loc)
+		{
+			this.InstanceExpr = instance_expr;
+			this.Arguments = args;
+			this.loc = loc;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (InstanceExpr is EventExpr) {
+				
+				EventInfo ei = ((EventExpr) InstanceExpr).EventInfo;
+				
+				Expression ml = MemberLookup (
+					ec, ec.ContainerType, ei.Name,
+					MemberTypes.Event, AllBindingFlags | BindingFlags.DeclaredOnly, loc);
+
+				if (ml == null) {
+				        //
+					// If this is the case, then the Event does not belong 
+					// to this Type and so, according to the spec
+					// cannot be accessed directly
+					//
+					// Note that target will not appear as an EventExpr
+					// in the case it is being referenced within the same type container;
+					// it will appear as a FieldExpr in that case.
+					//
+					
+					Assign.error70 (ei, loc);
+					return null;
+				}
+			}
+			
+			
+			Type del_type = InstanceExpr.Type;
+			if (del_type == null)
+				return null;
+			
+			if (Arguments != null){
+				foreach (Argument a in Arguments){
+					if (!a.Resolve (ec, loc))
+						return null;
+				}
+			}
+			
+			if (!Delegate.VerifyApplicability (ec, del_type, Arguments, loc))
+				return null;
+
+			Expression lookup = Expression.MemberLookup (ec, del_type, "Invoke", loc);
+			if (!(lookup is MethodGroupExpr)) {
+				Report.Error (-100, loc, "Internal error: could not find Invoke method!");
+				return null;
+			}
+			
+			method = ((MethodGroupExpr) lookup).Methods [0];
+			type = ((MethodInfo) method).ReturnType;
+			eclass = ExprClass.Value;
+			
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			// Delegate del = TypeManager.LookupDelegate (InstanceExpr.Type);
+
+			//
+			// Invocation on delegates call the virtual Invoke member
+			// so we are always `instance' calls
+			//
+			Invocation.EmitCall (ec, false, false, InstanceExpr, method, Arguments, loc);
+		}
+
+		public override void EmitStatement (EmitContext ec)
+		{
+			Emit (ec);
+			// 
+			// Pop the return value if there is one
+			//
+			if (method is MethodInfo){
+				if (((MethodInfo) method).ReturnType != TypeManager.void_type)
+					ec.ig.Emit (OpCodes.Pop);
+			}
+		}
+
+	}
+}
diff --git a/dead/mbas/driver.cs b/dead/mbas/driver.cs
new file mode 100644
index 00000000..36467863
--- /dev/null
+++ b/dead/mbas/driver.cs
@@ -0,0 +1,304 @@
+//
+// driver.cs: The compiler command line driver.
+//
+// Author: Rafael Teixeira (rafaelteixeirabr@hotmail.com)
+// Based on mcs by : Miguel de Icaza (miguel@gnu.org)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2002, 2003, 2004 Rafael Teixeira
+//
+
+namespace Mono.Languages {
+
+	using System;
+	using System.Collections;
+	using System.IO;
+	using System.Text;
+	using System.Globalization;
+	using System.Reflection;
+	using System.Reflection.Emit;
+
+	using Mono.GetOptions;
+	using Mono.GetOptions.Useful;
+
+	using Mono.MonoBASIC;
+
+	public class Driver {
+		CompilerOptions options;
+		
+		private void InitializeRootContextAndOthersFromOptions()
+		{
+			Report.Stacktrace = options.Stacktrace;
+			Report.WarningsAreErrors = options.WarningsAreErrors;
+			// TODO: change Report to receive the whole array
+			for(int i = 0; i < options.WarningsToIgnore.Length; i++)
+				Report.SetIgnoreWarning(options.WarningsToIgnore[i]);
+			Report.Fatal = options.MakeErrorsFatal;
+
+			RootContext.WarningLevel = options.WarningLevel;
+			RootContext.Checked = options.CheckedContext;
+			RootContext.MainClass = options.MainClassName;
+			RootContext.StdLib = !options.NoStandardLibraries;
+			RootContext.Unsafe = options.AllowUnsafeCode;
+			if (options.RootNamespace != null)
+				RootContext.RootNamespace = options.RootNamespace;
+			
+			// TODO: semantics are different and should be adjusted
+			GenericParser.yacc_verbose_flag = options.Verbose ? 1 : 0;
+			
+			Mono.MonoBASIC.Parser.InitialOptionExplicit = options.OptionExplicit;
+			Mono.MonoBASIC.Parser.InitialOptionStrict = options.OptionStrict;
+		    Mono.MonoBASIC.Parser.InitialOptionCompareBinary = options.OptionCompareBinary;
+		    Mono.MonoBASIC.Parser.ImportsList = options.Imports;
+		}
+		
+		bool ParseAllSourceFiles()
+		{
+			options.StartTime("Parsing Source Files");
+			foreach(FileToCompile file in options.SourceFilesToCompile)
+				GenericParser.Parse(file.Filename, file.Encoding);
+			options.ShowTime("   Done");
+			return (Report.Errors == 0);
+		}
+		
+		private bool InitializeDebuggingSupport()
+		{
+			string[] debug_args = new string [options.DebugListOfArguments.Count];
+			options.DebugListOfArguments.CopyTo(debug_args);
+			CodeGen.Init(options.OutputFileName, options.OutputFileName, options.WantDebuggingSupport, debug_args);
+			TypeManager.AddModule(CodeGen.ModuleBuilder);
+			return true;
+		}
+		
+		private bool LoadReferencedAssemblies()
+		{
+			return 
+				options.LoadReferencedAssemblies(
+					new Mono.GetOptions.Useful.AssemblyAdder(TypeManager.AddAssembly));
+		}
+
+		private bool AdjustCodegenWhenTargetIsNetModule()
+		{
+			options.AdjustCodegenWhenTargetIsNetModule(CodeGen.AssemblyBuilder);
+			return true;
+		}
+		
+		private bool LoadAddedNetModules()
+		{
+			return 
+				options.LoadAddedNetModules(
+					CodeGen.AssemblyBuilder, 
+					new Mono.GetOptions.Useful.ModuleAdder(TypeManager.AddModule));
+		}
+		
+		private bool InitializeCoreTypes()
+		{
+			//
+			// Before emitting, we need to get the core
+			// types emitted from the user defined types
+			// or from the system ones.
+			//
+			options.StartTime("Initializing Core Types");
+
+			if (!RootContext.StdLib)
+				RootContext.ResolveCore ();
+			if (Report.Errors > 0)
+				return false;
+			
+			TypeManager.InitCoreTypes();
+				
+			options.ShowTime("Core Types Done");
+			return Report.Errors == 0;
+		}
+
+		private bool ResolveTree()
+		{
+			options.StartTime("Resolving tree");
+			RootContext.ResolveTree (); // The second pass of the compiler
+			options.ShowTime("Tree resolved");
+			return Report.Errors == 0;
+		}
+		
+		private bool PopulateCoreTypes()
+		{
+			if (!RootContext.StdLib) {
+				options.StartTime("Populate core types");
+				RootContext.BootCorlib_PopulateCoreTypes();
+				options.ShowTime("   Done");
+			}
+			return Report.Errors == 0;
+		}
+						
+		private bool PopulateTypes()
+		{
+			options.StartTime("Populate types");
+			RootContext.PopulateTypes();
+			options.ShowTime("   Done");
+			return Report.Errors == 0;
+		}
+						
+		private bool InitCodeHelpers()
+		{
+			options.StartTime("Initialize code helpers");
+			TypeManager.InitCodeHelpers();
+			options.ShowTime("   Done");
+			return Report.Errors == 0;
+		}
+						
+		void CookUpEntryPointForWinFormsApplication(Type t)
+		{
+			Type SystemWindowsFormsFormType = TypeManager.LookupType ("System.Windows.Forms.Form");
+			if (SystemWindowsFormsFormType == null || !t.IsSubclassOf (SystemWindowsFormsFormType)) 
+				return;
+				
+			TypeBuilder tb = t as TypeBuilder;
+			MethodBuilder mb = tb.DefineMethod ("Main", MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, 
+				typeof(void), new Type[0]);
+
+			Type SystemWindowsFormsApplicationType = TypeManager.LookupType ("System.Windows.Forms.Application");
+			MethodInfo mi = SystemWindowsFormsApplicationType.GetMethod ("Run", new Type[] { SystemWindowsFormsFormType } );
+			ILGenerator ig = mb.GetILGenerator();
+			ConstructorInfo ci = TypeManager.GetConstructor (TypeManager.LookupType(t.FullName), new Type[0]);
+					
+			ig.Emit (OpCodes.Newobj, ci);
+			ig.Emit (OpCodes.Call, mi);
+			ig.Emit (OpCodes.Ret);
+
+			RootContext.EntryPoint = mb as MethodInfo;
+		}
+		
+		void FixEntryPoint()
+		{
+			if (options.TargetFileType == TargetType.Exe || options.TargetFileType == TargetType.WinExe) {
+				if (RootContext.EntryPoint == null && RootContext.MainClass != null) {
+					// If we don't have a valid entry point yet AND if System.Windows.Forms is included
+					// among the dependencies, we have to build a new entry point on-the-fly for the specified
+					// main class.
+					// Otherwise we won't be able to compile SWF code out of the box.
+					Type t = TypeManager.LookupType(RootContext.MainClass);
+					if (t == null) 
+						Report.Error(-1, string.Format("Specified main class {0} doesn't exist", RootContext.MainClass));					
+					else
+						CookUpEntryPointForWinFormsApplication (t);
+				}
+			}
+		}
+		
+		private bool EmitCode()
+		{
+			options.StartTime("Emitting code");			
+			RootContext.EmitCode();
+			FixEntryPoint();
+			options.ShowTime("   Done");
+			return Report.Errors == 0;
+		}
+
+		private bool CloseTypes()
+		{
+			options.StartTime("Closing types");			
+			RootContext.CloseTypes ();
+			options.ShowTime("   Done");
+			return Report.Errors == 0;
+		}
+
+		private bool SetEntryPoint()
+		{
+			if (options.TargetFileType == TargetType.Exe || options.TargetFileType == TargetType.WinExe) {
+				options.StartTime("Setting entry point");			
+				MethodInfo ep = RootContext.EntryPoint;
+			
+				if (ep == null) {
+					Report.Error (30737, "Program " + options.OutputFileName + " does not have an entry point defined");
+					return false;
+				}
+							
+				CodeGen.AssemblyBuilder.SetEntryPoint (ep, 
+					(options.TargetFileType == TargetType.Exe)?PEFileKinds.ConsoleApplication:PEFileKinds.WindowApplication);
+				options.ShowTime("   Done");
+			}
+			return Report.Errors == 0;
+		}
+
+/*
+		private bool EmbedResources()
+		{
+			options.StartTime("Embedding resources");			
+			options.EmbedResources(CodeGen.AssemblyBuilder);
+			options.ShowTime("   Done");
+			return Report.Errors == 0;
+		}
+*/
+
+		private bool SaveOutput()
+		{
+			options.StartTime("Saving Output");			
+			CodeGen.Save(options.OutputFileName);
+			options.ShowTime("   Done");
+			return Report.Errors == 0;
+		}
+
+
+		private bool SaveDebugSymbols()
+		{
+			if (options.WantDebuggingSupport)  {
+				options.StartTime("Saving Debug Symbols");			
+				CodeGen.SaveSymbols ();
+				options.ShowTime ("   Done");
+			}
+			return true;
+		}
+
+		delegate bool CompilerStep();
+		
+		private CompilerStep[] Steps {
+			get {
+				return new CompilerStep[] {
+					new CompilerStep(ParseAllSourceFiles),
+					new CompilerStep(InitializeDebuggingSupport),
+					new CompilerStep(LoadReferencedAssemblies),
+					new CompilerStep(AdjustCodegenWhenTargetIsNetModule),
+					new CompilerStep(LoadAddedNetModules),
+					new CompilerStep(InitializeCoreTypes),
+					new CompilerStep(ResolveTree),
+					new CompilerStep(PopulateCoreTypes),
+					new CompilerStep(PopulateTypes),
+					new CompilerStep(InitCodeHelpers),
+					new CompilerStep(EmitCode),
+					new CompilerStep(CloseTypes),
+					new CompilerStep(SetEntryPoint),
+					new CompilerStep(SaveOutput),
+					new CompilerStep(SaveDebugSymbols) } ;
+			}
+		}
+
+		/// <summary>
+		///    Parses the arguments, and calls the compilation process.
+		/// </summary>
+		int Execute(string [] args)
+		{
+			options = new CompilerOptions(args, new ErrorReporter(Report.Error));		
+			if (options.NothingToCompile)
+				return 2;		
+			try {
+				InitializeRootContextAndOthersFromOptions();
+				
+				foreach(CompilerStep step in Steps)
+					if (!step())
+						break;
+						
+			} catch (Exception ex) {
+				Report.Error(0, "Exception: " + ex.ToString());
+			}
+			return Report.ProcessResults(options.BeQuiet);
+		}
+
+		public static int Main (string[] args)
+		{
+			Driver driver = new Driver();
+			
+			return driver.Execute(args);
+		}
+
+	}
+}
diff --git a/dead/mbas/ecore.cs b/dead/mbas/ecore.cs
new file mode 100644
index 00000000..623e22ef
--- /dev/null
+++ b/dead/mbas/ecore.cs
@@ -0,0 +1,5596 @@
+//
+// ecore.cs: Core of the Expression representation for the intermediate tree.
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//   Manjula GHM (mmanjula@novell.com)
+//
+// (C) 2001 Ximian, Inc.
+//
+//
+
+namespace Mono.MonoBASIC {
+	using System;
+	using System.Collections;
+	using System.Diagnostics;
+	using System.Reflection;
+	using System.Reflection.Emit;
+	using System.Text;
+
+	/// <remarks>
+	///   The ExprClass class contains the is used to pass the 
+	///   classification of an expression (value, variable, namespace,
+	///   type, method group, property access, event access, indexer access,
+	///   nothing).
+	/// </remarks>
+	public enum ExprClass : byte {
+		Invalid,
+		
+		Value,
+		Variable,
+		Namespace,
+		Type,
+		MethodGroup,
+		PropertyAccess,
+		EventAccess,
+		IndexerAccess,
+		Nothing, 
+	}
+
+	/// <remarks>
+	///   This is used to tell Resolve in which types of expressions we're
+	///   interested.
+	/// </remarks>
+	[Flags]
+	public enum ResolveFlags {
+		// Returns Value, Variable, PropertyAccess, EventAccess or IndexerAccess.
+		VariableOrValue		= 1,
+
+		// Returns a type expression.
+		Type			= 2,
+
+		// Returns a method group.
+		MethodGroup		= 4,
+
+		// Allows SimpleNames to be returned.
+		// This is used by MemberAccess to construct long names that can not be
+		// partially resolved (namespace-qualified names for example).
+		SimpleName		= 8,
+
+		// Mask of all the expression class flags.
+		MaskExprClass		= 15,
+
+		// Disable control flow analysis while resolving the expression.
+		// This is used when resolving the instance expression of a field expression.
+		DisableFlowAnalysis	= 16
+	}
+
+	//
+	// This is just as a hint to AddressOf of what will be done with the
+	// address.
+	[Flags]
+	public enum AddressOp {
+		Store = 1,
+		Load  = 2,
+		LoadStore = 3
+	};
+	
+	/// <summary>
+	///   This interface is implemented by variables
+	/// </summary>
+	public interface IMemoryLocation {
+		/// <summary>
+		///   The AddressOf method should generate code that loads
+		///   the address of the object and leaves it on the stack.
+		///
+		///   The 'mode' argument is used to notify the expression
+		///   of whether this will be used to read from the address or
+		///   write to the address.
+		///
+		///   This is just a hint that can be used to provide good error
+		///   reporting, and should have no other side effects. 
+		/// </summary>
+		void AddressOf (EmitContext ec, AddressOp mode);
+	}
+
+	/// <summary>
+	///   This interface is implemented by variables
+	/// </summary>
+	public interface IVariable {
+		/// <summary>
+		///   Checks whether the variable has already been assigned at
+		///   the current position of the method's control flow and
+		///   reports an appropriate error message if not.
+		///
+		///   If the variable is a struct, then this call checks whether
+		///   all of its fields (including all private ones) have been
+		///   assigned.
+		/// </summary>
+		bool IsAssigned (EmitContext ec, Location loc);
+
+		/// <summary>
+		///   Checks whether field 'name' in this struct has been assigned.
+		/// </summary>
+		bool IsFieldAssigned (EmitContext ec, string name, Location loc);
+
+		/// <summary>
+		///   Tells the flow analysis code that the variable has already
+		///   been assigned at the current code position.
+		///
+		///   If the variable is a struct, this call marks all its fields
+		///   (including private fields) as being assigned.
+		/// </summary>
+		void SetAssigned (EmitContext ec);
+
+		/// <summary>
+		///   Tells the flow analysis code that field 'name' in this struct
+		///   has already been assigned atthe current code position.
+		/// </summary>
+		void SetFieldAssigned (EmitContext ec, string name);
+	}
+
+	/// <summary>
+	///   This interface denotes an expression which evaluates to a member
+	///   of a struct or a class.
+	/// </summary>
+	public interface IMemberExpr
+	{
+		/// <summary>
+		///   The name of this member.
+		/// </summary>
+		string Name {
+			get;
+		}
+
+		/// <summary>
+		///   Whether this is an instance member.
+		/// </summary>
+		bool IsInstance {
+			get;
+		}
+
+		/// <summary>
+		///   Whether this is a static member.
+		/// </summary>
+		bool IsStatic {
+			get;
+		}
+
+		/// <summary>
+		///   The type which declares this member.
+		/// </summary>
+		Type DeclaringType {
+			get;
+		}
+
+		/// <summary>
+		///   The instance expression associated with this member, if it's a
+		///   non-static member.
+		/// </summary>
+		Expression InstanceExpression {
+			get; set;
+		}
+	}
+
+	/// <summary>
+	///   Expression which resolves to a type.
+	/// </summary>
+	public interface ITypeExpression
+	{
+		/// <summary>
+		///   Resolve the expression, but only lookup types.
+		/// </summary>
+		Expression DoResolveType (EmitContext ec);
+	}
+
+	/// <remarks>
+	///   Base class for expressions
+	/// </remarks>
+	public abstract class Expression {
+		public ExprClass eclass;
+		protected Type type;
+		protected Location loc;
+		
+		public Type Type {
+			get {
+				return type;
+			}
+
+			set {
+				type = value;
+			}
+		}
+
+		public Location Location {
+			get {
+				return loc;
+			}
+		}
+
+		/// <summary>
+		///   Utility wrapper routine for Error, just to beautify the code
+		/// </summary>
+		public void Error (int error, string s)
+		{
+			if (!Location.IsNull (loc))
+				Report.Error (error, loc, s);
+			else
+				Report.Error (error, s);
+		}
+
+		/// <summary>
+		///   Utility wrapper routine for Warning, just to beautify the code
+		/// </summary>
+		public void Warning (int warning, string s)
+		{
+			if (!Location.IsNull (loc))
+				Report.Warning (warning, loc, s);
+			else
+				Report.Warning (warning, s);
+		}
+
+		/// <summary>
+		///   Utility wrapper routine for Warning, only prints the warning if
+		///   warnings of level 'level' are enabled.
+		/// </summary>
+		public void Warning (int warning, int level, string s)
+		{
+			if (level <= RootContext.WarningLevel)
+				Warning (warning, s);
+		}
+
+		static public void Error_CannotConvertType (Location loc, Type source, Type target)
+		{
+			Report.Error (30, loc, "Cannot convert type '" +
+				      TypeManager.MonoBASIC_Name (source) + "' to '" +
+				      TypeManager.MonoBASIC_Name (target) + "'");
+		}
+
+		/// <summary>
+		///   Performs semantic analysis on the Expression
+		/// </summary>
+		///
+		/// <remarks>
+		///   The Resolve method is invoked to perform the semantic analysis
+		///   on the node.
+		///
+		///   The return value is an expression (it can be the
+		///   same expression in some cases) or a new
+		///   expression that better represents this node.
+		///   
+		///   For example, optimizations of Unary (LiteralInt)
+		///   would return a new LiteralInt with a negated
+		///   value.
+		///   
+		///   If there is an error during semantic analysis,
+		///   then an error should be reported (using Report)
+		///   and a null value should be returned.
+		///   
+		///   There are two side effects expected from calling
+		///   Resolve(): the the field variable "eclass" should
+		///   be set to any value of the enumeration
+		///   'ExprClass' and the type variable should be set
+		///   to a valid type (this is the type of the
+		///   expression).
+		/// </remarks>
+		public abstract Expression DoResolve (EmitContext ec);
+
+		public virtual Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			return DoResolve (ec);
+		}
+		
+		/// <summary>
+		///   Resolves an expression and performs semantic analysis on it.
+		/// </summary>
+		///
+		/// <remarks>
+		///   Currently Resolve wraps DoResolve to perform sanity
+		///   checking and assertion checking on what we expect from Resolve.
+		/// </remarks>
+		public Expression Resolve (EmitContext ec, ResolveFlags flags)
+		{
+			// Are we doing a types-only search ?
+			if ((flags & ResolveFlags.MaskExprClass) == ResolveFlags.Type) {
+				ITypeExpression type_expr = this as ITypeExpression;
+
+				if (type_expr == null)
+					return null;
+
+				return type_expr.DoResolveType (ec);
+			}
+
+			bool old_do_flow_analysis = ec.DoFlowAnalysis;
+			if ((flags & ResolveFlags.DisableFlowAnalysis) != 0)
+				ec.DoFlowAnalysis = false;
+			
+			Expression e;
+			try {
+				if (this is SimpleName)
+					e = ((SimpleName) this).DoResolveAllowStatic (ec);
+				else 
+					e = DoResolve (ec);
+			} finally {
+				ec.DoFlowAnalysis = old_do_flow_analysis;
+			}
+
+			if (e == null)
+				return null;
+
+			if (e is SimpleName){
+				SimpleName s = (SimpleName) e;
+
+				if ((flags & ResolveFlags.SimpleName) == 0) {
+
+					object lookup = TypeManager.MemberLookup (
+						ec.ContainerType, ec.ContainerType, AllMemberTypes,
+						AllBindingFlags | BindingFlags.NonPublic, s.Name);
+					if (lookup != null)
+						Error (30390, "'" + s.Name + "' " +
+						       "is inaccessible because of its protection level");
+					else
+						Error (30451, "The name '" + s.Name + "' could not be " +
+						       "found in '" + ec.DeclSpace.Name + "'");
+					return null;
+				}
+
+				return s;
+			}
+			
+			if ((e is TypeExpr) || (e is ComposedCast)) {
+				if ((flags & ResolveFlags.Type) == 0) {
+					e.Error118 (flags);
+					return null;
+				}
+
+				return e;
+			}
+
+			switch (e.eclass) {
+			case ExprClass.Type:
+				if ((flags & ResolveFlags.VariableOrValue) == 0) {
+					e.Error118 (flags);
+					return null;
+				}
+				break;
+
+			case ExprClass.MethodGroup:
+				if ((flags & ResolveFlags.MethodGroup) == 0) {
+					MethodGroupExpr mg = (MethodGroupExpr) e;
+					Invocation i = new Invocation (mg, new ArrayList(), Location.Null);
+					Expression te = i.Resolve(ec);
+					//((MethodGroupExpr) e).ReportUsageError ();
+					//return null;
+					return te;
+				}
+				break;
+
+			case ExprClass.Value:
+			case ExprClass.Variable:
+			case ExprClass.PropertyAccess:
+			case ExprClass.EventAccess:
+			case ExprClass.IndexerAccess:
+				if ((flags & ResolveFlags.VariableOrValue) == 0) {
+					e.Error118 (flags);
+					return null;
+				}
+				break;
+
+			default:
+				throw new Exception ("Expression " + e.GetType () +
+						     " ExprClass is Invalid after resolve");
+			}
+
+			if (e.type == null)
+				throw new Exception (
+					"Expression " + e.GetType () +
+					" did not set its type after Resolve\n" +
+					"called from: " + this.GetType ());
+
+			return e;
+		}
+
+		/// <summary>
+		///   Resolves an expression and performs semantic analysis on it.
+		/// </summary>
+		public Expression Resolve (EmitContext ec)
+		{
+			return Resolve (ec, ResolveFlags.VariableOrValue);
+		}
+
+		/// <summary>
+		///   Resolves an expression for LValue assignment
+		/// </summary>
+		///
+		/// <remarks>
+		///   Currently ResolveLValue wraps DoResolveLValue to perform sanity
+		///   checking and assertion checking on what we expect from Resolve
+		/// </remarks>
+		public Expression ResolveLValue (EmitContext ec, Expression right_side)
+		{
+			Expression e = DoResolveLValue (ec, right_side);
+
+			if (e != null){
+				if (e is SimpleName){
+					SimpleName s = (SimpleName) e;
+
+					Report.Error (
+						30451, loc,
+						"The name '" + s.Name + "' could not be found in '" +
+						ec.DeclSpace.Name + "'");
+					return null;
+				}
+
+				if (e.eclass == ExprClass.Invalid)
+					throw new Exception ("Expression " + e +
+							     " ExprClass is Invalid after resolve");
+
+				if (e.eclass == ExprClass.MethodGroup) {
+					MethodGroupExpr mg = (MethodGroupExpr) e;
+					Invocation i = new Invocation (mg, new ArrayList(), Location.Null);
+					Expression te = i.Resolve(ec);
+					return te;
+					//((MethodGroupExpr) e).ReportUsageError ();
+					//return null;
+				}
+
+				if (e.type == null)
+					throw new Exception ("Expression " + e +
+							     " did not set its type after Resolve");
+			}
+
+			return e;
+		}
+		
+		/// <summary>
+		///   Emits the code for the expression
+		/// </summary>
+		///
+		/// <remarks>
+		///   The Emit method is invoked to generate the code
+		///   for the expression.  
+		/// </remarks>
+		public abstract void Emit (EmitContext ec);
+
+		/// <summary>
+		///   Protected constructor.  Only derivate types should
+		///   be able to be created
+		/// </summary>
+
+		protected Expression ()
+		{
+			eclass = ExprClass.Invalid;
+			type = null;
+		}
+
+		/// <summary>
+		///   Returns a literalized version of a literal FieldInfo
+		/// </summary>
+		///
+		/// <remarks>
+		///   The possible return values are:
+		///      IntConstant, UIntConstant
+		///      LongLiteral, ULongConstant
+		///      FloatConstant, DoubleConstant
+		///      StringConstant
+		///
+		///   The value returned is already resolved.
+		/// </remarks>
+		public static Constant Constantify (object v, Type t)
+		{
+			if (t == TypeManager.int32_type)
+				return new IntConstant ((int) v);
+			else if (t == TypeManager.uint32_type)
+				return new UIntConstant ((uint) v);
+			else if (t == TypeManager.int64_type)
+				return new LongConstant ((long) v);
+			else if (t == TypeManager.uint64_type)
+				return new ULongConstant ((ulong) v);
+			else if (t == TypeManager.float_type)
+				return new FloatConstant ((float) v);
+			else if (t == TypeManager.double_type)
+				return new DoubleConstant ((double) v);
+			else if (t == TypeManager.string_type)
+				return new StringConstant ((string) v);
+			else if (t == TypeManager.short_type)
+				return new ShortConstant ((short)v);
+			else if (t == TypeManager.ushort_type)
+				return new UShortConstant ((ushort)v);
+			else if (t == TypeManager.sbyte_type)
+				return new SByteConstant (((sbyte)v));
+			else if (t == TypeManager.byte_type)
+				return new ByteConstant ((byte)v);
+			else if (t == TypeManager.char_type)
+				return new CharConstant ((char)v);
+			else if (t == TypeManager.bool_type)
+				return new BoolConstant ((bool) v);
+			else if (t == TypeManager.decimal_type)
+				return new DecimalConstant ((decimal)v);
+			else if (TypeManager.IsEnumType (t)){
+				Constant e = Constantify (v, TypeManager.EnumToUnderlying (v.GetType ()));
+
+				return new EnumConstant (e, t);
+			} else
+				throw new Exception ("Unknown type for constant (" + t +
+						     "), details: " + v);
+		}
+
+		/// <summary>
+		///   Returns a fully formed expression after a MemberLookup
+		/// </summary>
+		public static Expression ExprClassFromMemberInfo (EmitContext ec, MemberInfo mi, Location loc)
+		{
+			if (mi is EventInfo)
+				return new EventExpr ((EventInfo) mi, loc);
+			else if (mi is FieldInfo)
+				return new FieldExpr ((FieldInfo) mi, loc);
+			else if (mi is PropertyInfo)
+				return new PropertyExpr (ec, (PropertyInfo) mi, loc);
+		        else if (mi is Type){
+				return new TypeExpr ((System.Type) mi, loc);
+			}
+
+			return null;
+		}
+
+		//
+		// FIXME: Probably implement a cache for (t,name,current_access_set)?
+		//
+		// This code could use some optimizations, but we need to do some
+		// measurements.  For example, we could use a delegate to 'flag' when
+		// something can not any longer be a method-group (because it is something
+		// else).
+		//
+		// Return values:
+		//     If the return value is an Array, then it is an array of
+		//     MethodBases
+		//   
+		//     If the return value is an MemberInfo, it is anything, but a Method
+		//
+		//     null on error.
+		//
+		// FIXME: When calling MemberLookup inside an 'Invocation', we should pass
+		// the arguments here and have MemberLookup return only the methods that
+		// match the argument count/type, unlike we are doing now (we delay this
+		// decision).
+		//
+		// This is so we can catch correctly attempts to invoke instance methods
+		// from a static body (scan for error 120 in ResolveSimpleName).
+		//
+		//
+		// FIXME: Potential optimization, have a static ArrayList
+		//
+
+		public static Expression MemberLookup (EmitContext ec, Type t, string name,
+						       MemberTypes mt, BindingFlags bf, Location loc)
+		{
+			return MemberLookup (ec, ec.ContainerType, t, name, mt, bf, loc);
+		}
+
+		//
+		// Lookup type 't' for code in class 'invocation_type'.  Note that it's important
+		// to set 'invocation_type' correctly since this method also checks whether the
+		// invoking class is allowed to access the member in class 't'.  When you want to
+		// explicitly do a lookup in the base class, you must set both 't' and 'invocation_type'
+		// to the base class (although a derived class can access protected members of its base
+		// class it cannot do so through an instance of the base class (error CS1540)).
+		// 
+
+		public static Expression MemberLookup (EmitContext ec, Type invocation_type, Type t,
+						       string name, MemberTypes mt, BindingFlags bf,
+						       Location loc)
+		{
+			MemberInfo [] mi = TypeManager.MemberLookup (invocation_type, t, mt, bf, name);
+
+			if (mi == null)
+				return null;
+
+			int count = mi.Length;
+
+			if (mi [0] is MethodBase)
+				return new MethodGroupExpr (mi, loc);
+
+			if (mi [0] is PropertyInfo)
+				return new PropertyGroupExpr (mi, loc);
+
+			if (count > 1)
+				return null;
+
+			return ExprClassFromMemberInfo (ec, mi [0], loc);
+		}
+
+		public const MemberTypes AllMemberTypes =
+			MemberTypes.Constructor |
+			MemberTypes.Event       |
+			MemberTypes.Field       |
+			MemberTypes.Method      |
+			MemberTypes.NestedType  |
+			MemberTypes.Property;
+		
+		public const BindingFlags AllBindingFlags =
+			BindingFlags.Public |
+			BindingFlags.Static |
+			BindingFlags.Instance |
+			BindingFlags.IgnoreCase;
+
+		public static Expression MemberLookup (EmitContext ec, Type t, string name, Location loc)
+		{
+			return MemberLookup (ec, ec.ContainerType, t, name, AllMemberTypes, AllBindingFlags, loc);
+		}
+
+		public static Expression MethodLookup (EmitContext ec, Type t, string name, Location loc)
+		{
+			return MemberLookup (ec, ec.ContainerType, t, name,
+					     MemberTypes.Method, AllBindingFlags, loc);
+		}
+
+		/// <summary>
+		///   This is a wrapper for MemberLookup that is not used to "probe", but
+		///   to find a final definition.  If the final definition is not found, we
+		///   look for private members and display a useful debugging message if we
+		///   find it.
+		/// </summary>
+		public static Expression MemberLookupFinal (EmitContext ec, Type t, string name, 
+							    Location loc)
+		{
+			return MemberLookupFinal (ec, t, name, MemberTypes.Method, AllBindingFlags, loc);
+		}
+
+		public static Expression MemberLookupFinal (EmitContext ec, Type t, string name,
+							    MemberTypes mt, BindingFlags bf, Location loc)
+		{
+			Expression e;
+
+			int errors = Report.Errors;
+
+			e = MemberLookup (ec, ec.ContainerType, t, name, mt, bf, loc);
+
+			if (e != null)
+				return e;
+
+			// Error has already been reported.
+			if (errors < Report.Errors)
+				return null;
+			
+			e = MemberLookup (ec, t, name, AllMemberTypes,
+					  AllBindingFlags | BindingFlags.NonPublic, loc);
+			if (e == null){
+				Report.Error (
+					30456, loc, "'" + t + "' does not contain a definition " +
+					"for '" + name + "'");
+			} else {
+					Report.Error (
+						30390, loc, "'" + t + "." + name +
+						"' is inaccessible due to its protection level");
+			}
+			
+			return null;
+		}
+
+		static public MemberInfo GetFieldFromEvent (EventExpr event_expr)
+		{
+			EventInfo ei = event_expr.EventInfo;
+
+			return TypeManager.GetPrivateFieldOfEvent (ei);
+		}
+		
+		static EmptyExpression MyEmptyExpr;
+		static public Expression ImplicitReferenceConversion (Expression expr, Type target_type)
+		{
+			Type expr_type = expr.Type;
+
+			if (expr_type == null && expr.eclass == ExprClass.MethodGroup){
+				// if we are a method group, emit a warning
+
+				expr.Emit (null);
+			}
+
+			//
+			// notice that it is possible to write "ValueType v = 1", the ValueType here
+			// is an abstract class, and not really a value type, so we apply the same rules.
+			//
+			if (target_type == TypeManager.object_type || target_type == TypeManager.value_type) {
+				//
+				// A pointer type cannot be converted to object
+				// 
+				if (expr_type.IsPointer)
+					return null;
+
+				if (expr_type.IsValueType)
+					return new BoxedCast (expr);
+				if (expr_type.IsClass || expr_type.IsInterface)
+					return new EmptyCast (expr, target_type);
+			} else if (expr_type.IsSubclassOf (target_type)) {
+				//
+				// Special case: enumeration to System.Enum.
+				// System.Enum is not a value type, it is a class, so we need
+				// a boxing conversion
+				//
+				if (expr_type.IsEnum)
+					return new BoxedCast (expr);
+			
+				return new EmptyCast (expr, target_type);
+			} else {
+
+				// This code is kind of mirrored inside StandardConversionExists
+				// with the small distinction that we only probe there
+				//
+				// Always ensure that the code here and there is in sync
+				
+				// from the null type to any reference-type.
+				if (expr is NullLiteral && !target_type.IsValueType)
+					return new EmptyCast (expr, target_type);
+
+				// from any class-type S to any interface-type T.
+				if (target_type.IsInterface) {
+					if (TypeManager.ImplementsInterface (expr_type, target_type)){
+						if (expr_type.IsClass)
+							return new EmptyCast (expr, target_type);
+						else if (expr_type.IsValueType)
+							return new BoxedCast (expr);
+					}
+				}
+
+				// from any interface type S to interface-type T.
+				if (expr_type.IsInterface && target_type.IsInterface) {
+					if (TypeManager.ImplementsInterface (expr_type, target_type))
+						return new EmptyCast (expr, target_type);
+					else
+						return null;
+				}
+				
+				// from an array-type S to an array-type of type T
+				if (expr_type.IsArray && target_type.IsArray) {
+					if (expr_type.GetArrayRank () == target_type.GetArrayRank ()) {
+
+						Type expr_element_type = expr_type.GetElementType ();
+
+						if (MyEmptyExpr == null)
+							MyEmptyExpr = new EmptyExpression ();
+						
+						MyEmptyExpr.SetType (expr_element_type);
+						Type target_element_type = target_type.GetElementType ();
+
+						if (!expr_element_type.IsValueType && !target_element_type.IsValueType)
+							if (StandardConversionExists (MyEmptyExpr,
+										      target_element_type))
+								return new EmptyCast (expr, target_type);
+					}
+				}
+				
+				
+				// from an array-type to System.Array
+				if (expr_type.IsArray && target_type == TypeManager.array_type)
+					return new EmptyCast (expr, target_type);
+				
+				// from any delegate type to System.Delegate
+				if (expr_type.IsSubclassOf (TypeManager.delegate_type) &&
+				    target_type == TypeManager.delegate_type)
+					return new EmptyCast (expr, target_type);
+					
+				// from any array-type or delegate type into System.ICloneable.
+				if (expr_type.IsArray || expr_type.IsSubclassOf (TypeManager.delegate_type))
+					if (target_type == TypeManager.icloneable_type)
+						return new EmptyCast (expr, target_type);
+				
+				return null;
+
+			}
+			
+			return null;
+		}
+
+		/// <summary>
+		///   Implicit Numeric Conversions.
+		///
+		///   expr is the expression to convert, returns a new expression of type
+		///   target_type or null if an implicit conversion is not possible.
+		/// </summary>
+		static public Expression ImplicitNumericConversion (EmitContext ec, Expression expr,
+								    Type target_type, Location loc)
+		{
+			Type expr_type = expr.Type;
+			
+			//
+			// Attempt to do the implicit constant expression conversions
+
+			if (expr is BoolConstant || expr is IntConstant || expr is LongConstant || expr is DoubleConstant || expr is FloatConstant){
+				Expression e;
+				
+				e = TryImplicitNumericConversion (target_type, (Constant) expr);
+
+				if (e != null)
+					return e;
+				if (target_type == TypeManager.byte_type || 
+				    target_type == TypeManager.short_type ||
+				    target_type == TypeManager.int32_type ||
+				    target_type == TypeManager.int64_type ||
+				    target_type == TypeManager.float_type) {
+					
+					string val = null;
+					if (expr is IntConstant)
+						val = ((IntConstant) expr).Value.ToString();
+					if (expr is LongConstant)
+						val = ((LongConstant) expr).Value.ToString();
+					if (expr is FloatConstant)
+						val = ((FloatConstant) expr).Value.ToString();
+					if (expr is DoubleConstant)
+						val = ((DoubleConstant) expr).Value.ToString();
+					Error_ConstantValueCannotBeConverted(loc, val, target_type);
+					return null;
+				}
+			} else if (expr is LongConstant && target_type == TypeManager.uint64_type) {
+				//
+				// Try the implicit constant expression conversion
+				// from long to ulong, instead of a nice routine,
+				// we just inline it
+				//
+				long v = ((LongConstant) expr).Value;
+				if (v > 0)
+					return new ULongConstant ((ulong) v);
+			}
+
+ 			Type real_target_type = target_type;
+
+			if (target_type == TypeManager.bool_type) {
+
+				if (expr_type == TypeManager.decimal_type) {
+					return RTConversionExpression (ec, "System.Convert",".ToBoolean" , expr, loc);
+				}
+
+				if ((expr_type != TypeManager.char_type) && 
+				    (expr_type != TypeManager.string_type) &&
+				    (expr_type != TypeManager.object_type))
+					return new NumericToBoolCast (expr, expr.Type);
+			}
+
+			if (expr_type == TypeManager.bool_type){
+				//
+				if (real_target_type == TypeManager.sbyte_type)
+					return new BoolToNumericCast (expr, target_type);
+				if (real_target_type == TypeManager.byte_type) 
+					return new BoolToNumericCast (expr, target_type);
+				if (real_target_type == TypeManager.int32_type)
+					return new BoolToNumericCast (expr, target_type);
+				if (real_target_type == TypeManager.int64_type)
+					return new BoolToNumericCast (expr, target_type);
+				if (real_target_type == TypeManager.double_type)
+					return new BoolToNumericCast (expr, target_type);
+				if (real_target_type == TypeManager.float_type)
+					return new BoolToNumericCast (expr, target_type);
+				if (real_target_type == TypeManager.short_type)
+					return new BoolToNumericCast (expr, target_type);
+				if (real_target_type == TypeManager.decimal_type)
+					return RTConversionExpression(ec, "DecimalType.FromBoolean", expr, loc);
+      			} else if (expr_type == TypeManager.sbyte_type){
+				//
+				// From sbyte to short, int, long, float, double.
+				//
+				if (real_target_type == TypeManager.int32_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
+				if (real_target_type == TypeManager.int64_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
+				if (real_target_type == TypeManager.double_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
+				if (real_target_type == TypeManager.float_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
+				if (real_target_type == TypeManager.short_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_I2);
+			} else if (expr_type == TypeManager.byte_type){
+				//
+				// From byte to short, ushort, int, uint, long, ulong, float, double
+				// 
+				if ((real_target_type == TypeManager.short_type) ||
+				    (real_target_type == TypeManager.ushort_type) ||
+				    (real_target_type == TypeManager.int32_type) ||
+				    (real_target_type == TypeManager.uint32_type))
+					return new EmptyCast (expr, target_type);
+
+				if (real_target_type == TypeManager.uint64_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
+				if (real_target_type == TypeManager.int64_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
+				if (real_target_type == TypeManager.float_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
+				if (real_target_type == TypeManager.double_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
+			} else if (expr_type == TypeManager.short_type){
+				//
+				// From short to int, long, float, double
+				// 
+				if (real_target_type == TypeManager.int32_type)
+					return new EmptyCast (expr, target_type);
+				if (real_target_type == TypeManager.int64_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
+				if (real_target_type == TypeManager.double_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
+				if (real_target_type == TypeManager.float_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
+			} else if (expr_type == TypeManager.ushort_type){
+				//
+				// From ushort to int, uint, long, ulong, float, double
+				//
+				if (real_target_type == TypeManager.uint32_type)
+					return new EmptyCast (expr, target_type);
+
+				if (real_target_type == TypeManager.uint64_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
+				if (real_target_type == TypeManager.int32_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_I4);
+				if (real_target_type == TypeManager.int64_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
+				if (real_target_type == TypeManager.double_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
+				if (real_target_type == TypeManager.float_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
+			} else if (expr_type == TypeManager.int32_type){
+				//
+				// From int to long, float, double
+				//
+				if (real_target_type == TypeManager.int64_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_I8);
+				if (real_target_type == TypeManager.double_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
+				if (real_target_type == TypeManager.float_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);
+			} else if (expr_type == TypeManager.uint32_type){
+				//
+				// From uint to long, ulong, float, double
+				//
+				if (real_target_type == TypeManager.int64_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
+				if (real_target_type == TypeManager.uint64_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_U8);
+				if (real_target_type == TypeManager.double_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un,
+							       OpCodes.Conv_R8);
+				if (real_target_type == TypeManager.float_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un,
+							       OpCodes.Conv_R4);
+			} else if (expr_type == TypeManager.int64_type){
+				//
+				// From long/ulong to float, double
+				//
+				if (real_target_type == TypeManager.double_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
+				if (real_target_type == TypeManager.float_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R4);	
+			} else if (expr_type == TypeManager.uint64_type){
+				//
+				// From ulong to float, double
+				//
+				if (real_target_type == TypeManager.double_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un,
+							       OpCodes.Conv_R8);
+				if (real_target_type == TypeManager.float_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R_Un,
+							       OpCodes.Conv_R4);	
+			} else if (expr_type == TypeManager.string_type){
+
+				if (real_target_type == TypeManager.bool_type)
+					return RTConversionExpression (ec, "BooleanType.FromString" , expr, loc);
+				if (real_target_type == TypeManager.decimal_type)
+					return RTConversionExpression (ec, "DecimalType.FromString" , expr, loc);
+				if (real_target_type == TypeManager.float_type)
+					return RTConversionExpression (ec, "SingleType.FromString" , expr, loc);
+				if (real_target_type == TypeManager.short_type)
+					return RTConversionExpression (ec, "ShortType.FromString" , expr, loc);
+				if (real_target_type == TypeManager.int64_type)
+					return RTConversionExpression (ec, "LongType.FromString" , expr, loc);
+				if (real_target_type == TypeManager.int32_type)
+					return RTConversionExpression (ec, "IntegerType.FromString" , expr, loc);
+				if (real_target_type == TypeManager.double_type)
+					return RTConversionExpression (ec, "DoubleType.FromString" , expr, loc);
+				if (real_target_type == TypeManager.byte_type)
+					return RTConversionExpression (ec, "ByteType.FromString" , expr, loc);
+			} else if (expr_type == TypeManager.float_type){
+				//
+				// float to double
+				//
+				if (real_target_type == TypeManager.decimal_type)
+					return RTConversionExpression (ec, "System.Convert", ".ToDecimal" , expr, loc);
+				if (real_target_type == TypeManager.double_type)
+					return new OpcodeCast (expr, target_type, OpCodes.Conv_R8);
+
+			} else if (expr_type == TypeManager.double_type){
+
+				if (real_target_type == TypeManager.decimal_type)
+					return RTConversionExpression (ec, "System.Convert", ".ToDecimal" , expr, loc);
+			} else if (expr_type == TypeManager.decimal_type){
+
+				if (real_target_type == TypeManager.bool_type)
+	  				return RTConversionExpression (ec, "BooleanType.FromDecimal" , expr, loc);
+				if (real_target_type == TypeManager.short_type)
+					return RTConversionExpression(ec, "System.Convert", ".ToInt16", expr, loc);
+				if (real_target_type == TypeManager.byte_type)
+					return RTConversionExpression(ec, "System.Convert", ".ToByte", expr, loc);
+				if (real_target_type == TypeManager.int32_type)
+					return RTConversionExpression(ec, "System.Convert", ".ToInt32", expr, loc);
+				if (real_target_type == TypeManager.int64_type)
+					return RTConversionExpression(ec, "System.Convert", ".ToInt64", expr, loc);
+				if (real_target_type == TypeManager.float_type)
+					return RTConversionExpression(ec, "System.Convert", ".ToSingle", expr, loc);
+				if (real_target_type == TypeManager.double_type)
+					return RTConversionExpression(ec, "System.Convert", ".ToDouble", expr, loc);
+      			}
+
+			return null;
+		}
+
+		//
+		// Tests whether an implicit reference conversion exists between expr_type
+		// and target_type
+		//
+		public static bool ImplicitReferenceConversionExists (Expression expr, Type expr_type, Type target_type)
+		{
+			//
+			// This is the boxed case.
+			//
+			if (target_type == TypeManager.object_type) {
+				if ((expr_type.IsClass) ||
+				    (expr_type.IsValueType) ||
+				    (expr_type.IsInterface))
+					return true;
+				
+			} else if (expr_type.IsSubclassOf (target_type)) {
+				return true;
+			} else {
+				// Please remember that all code below actually comes
+				// from ImplicitReferenceConversion so make sure code remains in sync
+				
+				// from any class-type S to any interface-type T.
+				if (target_type.IsInterface) {
+					if (TypeManager.ImplementsInterface (expr_type, target_type))
+						return true;
+				}
+				
+				// from any interface type S to interface-type T.
+				if (expr_type.IsInterface && target_type.IsInterface)
+					if (TypeManager.ImplementsInterface (expr_type, target_type))
+						return true;
+				
+				// from an array-type S to an array-type of type T
+				if (expr_type.IsArray && target_type.IsArray) {
+					if (expr_type.GetArrayRank () == target_type.GetArrayRank ()) {
+						
+						Type expr_element_type = expr_type.GetElementType ();
+
+						if (MyEmptyExpr == null)
+							MyEmptyExpr = new EmptyExpression ();
+						
+						MyEmptyExpr.SetType (expr_element_type);
+						Type target_element_type = target_type.GetElementType ();
+						
+						if (!expr_element_type.IsValueType && !target_element_type.IsValueType)
+							if (StandardConversionExists (MyEmptyExpr,
+										      target_element_type))
+								return true;
+					}
+				}
+				
+				// from an array-type to System.Array
+				if (expr_type.IsArray && (target_type == TypeManager.array_type))
+					return true;
+				
+				// from any delegate type to System.Delegate
+				if (expr_type.IsSubclassOf (TypeManager.delegate_type) &&
+				    target_type == TypeManager.delegate_type)
+					if (target_type.IsAssignableFrom (expr_type))
+						return true;
+					
+				// from any array-type or delegate type into System.ICloneable.
+				if (expr_type.IsArray || expr_type.IsSubclassOf (TypeManager.delegate_type))
+					if (target_type == TypeManager.icloneable_type)
+						return true;
+				
+				// from the null type to any reference-type.
+				if (expr is NullLiteral && !target_type.IsValueType &&
+				    !TypeManager.IsEnumType (target_type))
+					return true;
+				
+			}
+
+			return false;
+		}
+
+		/// <summary>
+		///  Same as StandardConversionExists except that it also looks at
+		///  implicit user defined conversions - needed for overload resolution
+		/// </summary>
+		public static bool ImplicitConversionExists (EmitContext ec, Expression expr, Type target_type)
+		{
+			if (StandardConversionExists (expr, target_type) == true)
+				return true;
+
+#if false
+			Expression dummy = ImplicitUserConversion (ec, expr, target_type, Location.Null);
+
+			if (dummy != null)
+				return true;
+#endif
+
+			return false;
+		}
+
+		/// <summary>
+		///  Determines if a standard implicit conversion exists from
+		///  expr_type to target_type
+		/// </summary>
+		public static bool StandardConversionExists (Expression expr, Type target_type)
+		{
+			return WideningConversionExists (expr, expr.type, target_type);
+		}
+
+		public static bool WideningConversionExists (Type expr_type, Type target_type)
+		{
+			return WideningConversionExists (null, expr_type, target_type);
+		}
+
+		public static bool WideningConversionExists (Expression expr, Type target_type)
+		{
+			return WideningConversionExists (expr, expr.Type, target_type);
+		}
+
+		public static bool WideningConversionExists (Expression expr, Type expr_type, Type target_type)
+		{
+
+			if (expr_type == null || expr_type == TypeManager.void_type)
+				return false;
+			
+			if (expr_type == target_type)
+				return true;
+
+			// Conversions from enum to underlying type are widening.
+			if (expr_type.IsSubclassOf (TypeManager.enum_type))
+				expr_type = TypeManager.EnumToUnderlying (expr_type);
+
+			if (expr_type == target_type)
+				return true;
+
+			// First numeric conversions 
+			
+			if (expr_type == TypeManager.sbyte_type){
+				//
+				// From sbyte to short, int, long, float, double.
+				//
+				if ((target_type == TypeManager.int32_type) || 
+				    (target_type == TypeManager.int64_type) ||
+				    (target_type == TypeManager.double_type) ||
+				    (target_type == TypeManager.float_type)  ||
+				    (target_type == TypeManager.short_type) ||
+				    (target_type == TypeManager.decimal_type))
+					return true;
+				
+			} else if (expr_type == TypeManager.byte_type){
+				//
+				// From byte to short, ushort, int, uint, long, ulong, float, double
+				// 
+				if ((target_type == TypeManager.short_type) ||
+				    (target_type == TypeManager.bool_type) ||
+				    (target_type == TypeManager.ushort_type) ||
+				    (target_type == TypeManager.int32_type) ||
+				    (target_type == TypeManager.uint32_type) ||
+				    (target_type == TypeManager.uint64_type) ||
+				    (target_type == TypeManager.int64_type) ||
+				    (target_type == TypeManager.float_type) ||
+				    (target_type == TypeManager.double_type) ||
+				    (target_type == TypeManager.decimal_type))
+					return true;
+	
+			} else if (expr_type == TypeManager.short_type){
+				//
+				// From short to int, long, float, double
+				// 
+				if ((target_type == TypeManager.int32_type) ||
+				    (target_type == TypeManager.bool_type) ||
+				    (target_type == TypeManager.int64_type) ||
+				    (target_type == TypeManager.double_type) ||
+				    (target_type == TypeManager.float_type) ||
+				    (target_type == TypeManager.decimal_type))
+					return true;
+					
+			} else if (expr_type == TypeManager.ushort_type){
+				//
+				// From ushort to int, uint, long, ulong, float, double
+				//
+				if ((target_type == TypeManager.uint32_type) ||
+				    (target_type == TypeManager.uint64_type) ||
+				    (target_type == TypeManager.int32_type) ||
+				    (target_type == TypeManager.int64_type) ||
+				    (target_type == TypeManager.double_type) ||
+				    (target_type == TypeManager.float_type) ||
+				    (target_type == TypeManager.decimal_type))
+					return true;
+				    
+			} else if (expr_type == TypeManager.int32_type){
+				//
+				// From int to long, float, double
+				//
+				if ((target_type == TypeManager.int64_type) ||
+				    (target_type == TypeManager.bool_type) ||
+				    (target_type == TypeManager.double_type) ||
+				    (target_type == TypeManager.float_type) ||
+				    (target_type == TypeManager.decimal_type))
+					return true;
+					
+			} else if (expr_type == TypeManager.uint32_type){
+				//
+				// From uint to long, ulong, float, double
+				//
+				if ((target_type == TypeManager.int64_type) ||
+				    (target_type == TypeManager.bool_type) ||
+				    (target_type == TypeManager.uint64_type) ||
+				    (target_type == TypeManager.double_type) ||
+				    (target_type == TypeManager.float_type) ||
+				    (target_type == TypeManager.decimal_type))
+					return true;
+					
+			} else if ((expr_type == TypeManager.uint64_type) ||
+				   (expr_type == TypeManager.int64_type)) {
+				//
+				// From long/ulong to float, double
+				//
+				if ((target_type == TypeManager.double_type) ||
+				    (target_type == TypeManager.bool_type) ||
+				    (target_type == TypeManager.float_type) ||
+				    (target_type == TypeManager.decimal_type))
+					return true;
+				    
+			} else if (expr_type == TypeManager.decimal_type) {
+				if (target_type == TypeManager.float_type ||
+				    target_type == TypeManager.double_type)
+					return true;
+			} else if (expr_type == TypeManager.float_type){
+				//
+				// float to double, decimal
+				//
+				if (target_type == TypeManager.double_type)
+					return true;
+			} else if (expr_type == TypeManager.double_type){
+
+				if ((target_type == TypeManager.bool_type))
+					return true;
+			}		
+			
+			if (ImplicitReferenceConversionExists (expr, expr_type, target_type))
+				return true;
+			
+/*
+			if (expr is IntConstant){
+				int value = ((IntConstant) expr).Value;
+
+				if (target_type == TypeManager.sbyte_type){
+					if (value >= SByte.MinValue && value <= SByte.MaxValue)
+						return true;
+				} else if (target_type == TypeManager.byte_type){
+					if (Byte.MinValue >= 0 && value <= Byte.MaxValue)
+						return true;
+				} else if (target_type == TypeManager.short_type){
+					if (value >= Int16.MinValue && value <= Int16.MaxValue)
+						return true;
+				} else if (target_type == TypeManager.ushort_type){
+					if (value >= UInt16.MinValue && value <= UInt16.MaxValue)
+						return true;
+				} else if (target_type == TypeManager.uint32_type){
+					if (value >= 0)
+						return true;
+				} else if (target_type == TypeManager.uint64_type){
+					 //
+					 // we can optimize this case: a positive int32
+					 // always fits on a uint64.  But we need an opcode
+					 // to do it.
+					 //
+					if (value >= 0)
+						return true;
+				}
+				
+				if (value == 0 && expr is IntLiteral && TypeManager.IsEnumType (target_type))
+					return true;
+			}
+
+			if (expr is LongConstant && target_type == TypeManager.uint64_type){
+				//
+				// Try the implicit constant expression conversion
+				// from long to ulong, instead of a nice routine,
+				// we just inline it
+				//
+				long v = ((LongConstant) expr).Value;
+				if (v > 0)
+					return true;
+			}
+*/
+			
+			if (target_type.IsSubclassOf (TypeManager.enum_type) && expr is IntLiteral){
+				IntLiteral i = (IntLiteral) expr;
+
+				if (i.Value == 0)
+					return true;
+			}
+
+			if (target_type == TypeManager.void_ptr_type && expr_type.IsPointer)
+				return true;
+
+			return false;
+		}
+
+		//
+		// Used internally by FindMostEncompassedType, this is used
+		// to avoid creating lots of objects in the tight loop inside
+		// FindMostEncompassedType
+		//
+		static EmptyExpression priv_fmet_param;
+		
+		/// <summary>
+		///  Finds "most encompassed type" according to the spec (13.4.2)
+		///  amongst the methods in the MethodGroupExpr
+		/// </summary>
+		static Type FindMostEncompassedType (ArrayList types)
+		{
+			Type best = null;
+
+			if (priv_fmet_param == null)
+				priv_fmet_param = new EmptyExpression ();
+
+			foreach (Type t in types){
+				priv_fmet_param.SetType (t);
+				
+				if (best == null) {
+					best = t;
+					continue;
+				}
+				
+				if (StandardConversionExists (priv_fmet_param, best))
+					best = t;
+			}
+
+			return best;
+		}
+
+		//
+		// Used internally by FindMostEncompassingType, this is used
+		// to avoid creating lots of objects in the tight loop inside
+		// FindMostEncompassingType
+		//
+		static EmptyExpression priv_fmee_ret;
+		
+		/// <summary>
+		///  Finds "most encompassing type" according to the spec (13.4.2)
+		///  amongst the types in the given set
+		/// </summary>
+		static Type FindMostEncompassingType (ArrayList types)
+		{
+			Type best = null;
+
+			if (priv_fmee_ret == null)
+				priv_fmee_ret = new EmptyExpression ();
+
+			foreach (Type t in types){
+				priv_fmee_ret.SetType (best);
+
+				if (best == null) {
+					best = t;
+					continue;
+				}
+
+				if (StandardConversionExists (priv_fmee_ret, t))
+					best = t;
+			}
+			
+			return best;
+		}
+
+		//
+		// Used to avoid creating too many objects
+		//
+		static EmptyExpression priv_fms_expr;
+		
+		/// <summary>
+		///   Finds the most specific source Sx according to the rules of the spec (13.4.4)
+		///   by making use of FindMostEncomp* methods. Applies the correct rules separately
+		///   for explicit and implicit conversion operators.
+		/// </summary>
+		static public Type FindMostSpecificSource (MethodGroupExpr me, Expression source,
+							   bool apply_explicit_conv_rules,
+							   Location loc)
+		{
+			ArrayList src_types_set = new ArrayList ();
+			
+			if (priv_fms_expr == null)
+				priv_fms_expr = new EmptyExpression ();
+
+			//
+			// If any operator converts from S then Sx = S
+			//
+			Type source_type= source.Type;
+			foreach (MethodBase mb in me.Methods){
+				ParameterData pd = Invocation.GetParameterData (mb);
+				Type param_type = pd.ParameterType (0);
+
+				if (param_type == source_type)
+					return param_type;
+
+				if (apply_explicit_conv_rules) {
+					//
+					// From the spec :
+					// Find the set of applicable user-defined conversion operators, U.  This set
+					// consists of the
+					// user-defined implicit or explicit conversion operators declared by
+					// the classes or structs in D that convert from a type encompassing
+					// or encompassed by S to a type encompassing or encompassed by T
+					//
+					priv_fms_expr.SetType (param_type);
+					if (StandardConversionExists (priv_fms_expr, source_type))
+						src_types_set.Add (param_type);
+					else {
+						if (StandardConversionExists (source, param_type))
+							src_types_set.Add (param_type);
+					}
+				} else {
+					//
+					// Only if S is encompassed by param_type
+					//
+					if (StandardConversionExists (source, param_type))
+						src_types_set.Add (param_type);
+				}
+			}
+			
+			//
+			// Explicit Conv rules
+			//
+			if (apply_explicit_conv_rules) {
+				ArrayList candidate_set = new ArrayList ();
+
+				foreach (Type param_type in src_types_set){
+					if (StandardConversionExists (source, param_type))
+						candidate_set.Add (param_type);
+				}
+
+				if (candidate_set.Count != 0)
+					return FindMostEncompassedType (candidate_set);
+			}
+
+			//
+			// Final case
+			//
+			if (apply_explicit_conv_rules)
+				return FindMostEncompassingType (src_types_set);
+			else
+				return FindMostEncompassedType (src_types_set);
+		}
+
+		//
+		// Useful in avoiding proliferation of objects
+		//
+		static EmptyExpression priv_fmt_expr;
+		
+		/// <summary>
+		///  Finds the most specific target Tx according to section 13.4.4
+		/// </summary>
+		static public Type FindMostSpecificTarget (MethodGroupExpr me, Type target,
+							   bool apply_explicit_conv_rules,
+							   Location loc)
+		{
+			ArrayList tgt_types_set = new ArrayList ();
+			
+			if (priv_fmt_expr == null)
+				priv_fmt_expr = new EmptyExpression ();
+			
+			//
+			// If any operator converts to T then Tx = T
+			//
+			foreach (MethodInfo mi in me.Methods){
+				Type ret_type = mi.ReturnType;
+
+				if (ret_type == target)
+					return ret_type;
+
+				if (apply_explicit_conv_rules) {
+					//
+					// From the spec :
+					// Find the set of applicable user-defined conversion operators, U.
+					//
+					// This set consists of the
+					// user-defined implicit or explicit conversion operators declared by
+					// the classes or structs in D that convert from a type encompassing
+					// or encompassed by S to a type encompassing or encompassed by T
+					//
+					priv_fms_expr.SetType (ret_type);
+					if (StandardConversionExists (priv_fms_expr, target))
+						tgt_types_set.Add (ret_type);
+					else {
+						priv_fms_expr.SetType (target);
+						if (StandardConversionExists (priv_fms_expr, ret_type))
+							tgt_types_set.Add (ret_type);
+					}
+				} else {
+					//
+					// Only if T is encompassed by param_type
+					//
+					priv_fms_expr.SetType (ret_type);
+					if (StandardConversionExists (priv_fms_expr, target))
+						tgt_types_set.Add (ret_type);
+				}
+			}
+
+			//
+			// Explicit conv rules
+			//
+			if (apply_explicit_conv_rules) {
+				ArrayList candidate_set = new ArrayList ();
+
+				foreach (Type ret_type in tgt_types_set){
+					priv_fmt_expr.SetType (ret_type);
+					
+					if (StandardConversionExists (priv_fmt_expr, target))
+						candidate_set.Add (ret_type);
+				}
+
+				if (candidate_set.Count != 0)
+					return FindMostEncompassingType (candidate_set);
+			}
+			
+			//
+			// Okay, final case !
+			//
+			if (apply_explicit_conv_rules)
+				return FindMostEncompassedType (tgt_types_set);
+			else 
+				return FindMostEncompassingType (tgt_types_set);
+		}
+		
+		/// <summary>
+		///  User-defined Implicit conversions
+		/// </summary>
+		static public Expression ImplicitUserConversion (EmitContext ec, Expression source,
+								 Type target, Location loc)
+		{
+			return UserDefinedConversion (ec, source, target, loc, false);
+		}
+
+		/// <summary>
+		///  User-defined Explicit conversions
+		/// </summary>
+		static public Expression ExplicitUserConversion (EmitContext ec, Expression source,
+								 Type target, Location loc)
+		{
+			return UserDefinedConversion (ec, source, target, loc, true);
+		}
+
+		/// <summary>
+		///   Computes the MethodGroup for the user-defined conversion
+		///   operators from source_type to target_type.  'look_for_explicit'
+		///   controls whether we should also include the list of explicit
+		///   operators
+		/// </summary>
+		static MethodGroupExpr GetConversionOperators (EmitContext ec,
+							       Type source_type, Type target_type,
+							       Location loc, bool look_for_explicit)
+		{
+			Expression mg1 = null, mg2 = null;
+			Expression mg5 = null, mg6 = null, mg7 = null, mg8 = null;
+			string op_name;
+
+			//
+			// FIXME : How does the False operator come into the picture ?
+			// This doesn't look complete and very correct !
+			//
+			if (target_type == TypeManager.bool_type && !look_for_explicit)
+				op_name = "op_True";
+			else
+				op_name = "op_Implicit";
+
+			MethodGroupExpr union3;
+			
+			mg1 = MethodLookup (ec, source_type, op_name, loc);
+			if (source_type.BaseType != null)
+				mg2 = MethodLookup (ec, source_type.BaseType, op_name, loc);
+
+			if (mg1 == null)
+				union3 = (MethodGroupExpr) mg2;
+			else if (mg2 == null)
+				union3 = (MethodGroupExpr) mg1;
+			else
+				union3 = Invocation.MakeUnionSet (mg1, mg2, loc);
+
+			mg1 = MethodLookup (ec, target_type, op_name, loc);
+			if (mg1 != null){
+				if (union3 != null)
+					union3 = Invocation.MakeUnionSet (union3, mg1, loc);
+				else
+					union3 = (MethodGroupExpr) mg1;
+			}
+
+			if (target_type.BaseType != null)
+				mg1 = MethodLookup (ec, target_type.BaseType, op_name, loc);
+			
+			if (mg1 != null){
+				if (union3 != null)
+					union3 = Invocation.MakeUnionSet (union3, mg1, loc);
+				else
+					union3 = (MethodGroupExpr) mg1;
+			}
+
+			MethodGroupExpr union4 = null;
+
+			if (look_for_explicit) {
+				op_name = "op_Explicit";
+
+				mg5 = MemberLookup (ec, source_type, op_name, loc);
+				if (source_type.BaseType != null)
+					mg6 = MethodLookup (ec, source_type.BaseType, op_name, loc);
+				
+				mg7 = MemberLookup (ec, target_type, op_name, loc);
+				if (target_type.BaseType != null)
+					mg8 = MethodLookup (ec, target_type.BaseType, op_name, loc);
+				
+				MethodGroupExpr union5 = Invocation.MakeUnionSet (mg5, mg6, loc);
+				MethodGroupExpr union6 = Invocation.MakeUnionSet (mg7, mg8, loc);
+
+				union4 = Invocation.MakeUnionSet (union5, union6, loc);
+			}
+			
+			return Invocation.MakeUnionSet (union3, union4, loc);
+		}
+		
+		/// <summary>
+		///   User-defined conversions
+		/// </summary>
+		static public Expression UserDefinedConversion (EmitContext ec, Expression source,
+								Type target, Location loc,
+								bool look_for_explicit)
+		{
+			MethodGroupExpr union;
+			Type source_type = source.Type;
+			MethodBase method = null;
+			
+			union = GetConversionOperators (ec, source_type, target, loc, look_for_explicit);
+			if (union == null)
+				return null;
+			
+			Type most_specific_source, most_specific_target;
+
+#if BLAH
+			foreach (MethodBase m in union.Methods){
+				Console.WriteLine ("Name: " + m.Name);
+				Console.WriteLine ("    : " + ((MethodInfo)m).ReturnType);
+			}
+#endif
+			
+			most_specific_source = FindMostSpecificSource (union, source, look_for_explicit, loc);
+			if (most_specific_source == null)
+				return null;
+
+			most_specific_target = FindMostSpecificTarget (union, target, look_for_explicit, loc);
+			if (most_specific_target == null) 
+				return null;
+
+			int count = 0;
+
+			foreach (MethodBase mb in union.Methods){
+				ParameterData pd = Invocation.GetParameterData (mb);
+				MethodInfo mi = (MethodInfo) mb;
+				
+				if (pd.ParameterType (0) == most_specific_source &&
+				    mi.ReturnType == most_specific_target) {
+					method = mb;
+					count++;
+				}
+			}
+			
+			if (method == null || count > 1)
+				return null;
+			
+			
+			//
+			// This will do the conversion to the best match that we
+			// found.  Now we need to perform an implict standard conversion
+			// if the best match was not the type that we were requested
+			// by target.
+			//
+			if (look_for_explicit)
+				source = ConvertExplicitStandard (ec, source, most_specific_source, loc);
+			else
+				source = ConvertImplicitStandard (ec, source, most_specific_source, loc);
+
+			if (source == null)
+				return null;
+
+			Expression e;
+			e =  new UserCast ((MethodInfo) method, source, loc);
+			if (e.Type != target){
+				if (!look_for_explicit)
+					e = ConvertImplicitStandard (ec, e, target, loc);
+				else
+					e = ConvertExplicitStandard (ec, e, target, loc);
+			} 
+			return e;
+		}
+		
+		/// <summary>
+		///   Converts implicitly the resolved expression 'expr' into the
+		///   'target_type'.  It returns a new expression that can be used
+		///   in a context that expects a 'target_type'. 
+		/// </summary>
+		static public Expression ConvertImplicit (EmitContext ec, Expression expr,
+							  Type target_type, Location loc)
+		{
+			Type expr_type = expr.Type;
+			Expression e;
+
+
+			if (expr_type == target_type)
+				return expr;
+
+			if (target_type == null)
+				throw new Exception ("Target type is null");
+
+			e = ConvertImplicitStandard (ec, expr, target_type, loc);
+			if (e != null)
+				return e;
+					
+			e = ImplicitUserConversion (ec, expr, target_type, loc);
+			
+			if (e != null)
+				return e;
+
+			e = NarrowingConversion (ec, expr, target_type, loc);
+			if (e != null)
+				return e;				
+
+			return null;
+		}
+
+		/// <summary>
+		///   Converts the resolved expression 'expr' into the
+		///   'target_type' using the Microsoft.VisualBasic runtime.
+		///   It returns a new expression that can be used
+		///   in a context that expects a 'target_type'. 
+		/// </summary>
+		static private Expression RTConversionExpression (EmitContext ec, string s, Expression expr, Location loc)
+		{
+			Expression etmp, e;
+			ArrayList args;
+			Argument arg;
+			
+		 	etmp = Mono.MonoBASIC.Parser.DecomposeQI("Microsoft.VisualBasic.CompilerServices." + s, loc);
+		 	args = new ArrayList();
+		 	arg = new Argument (expr, Argument.AType.Expression);
+		 	args.Add (arg);
+			e = (Expression) new Invocation (etmp, args, loc);
+			e = e.Resolve(ec);	
+			return (e);		
+		}
+
+		static private Expression RTConversionExpression (EmitContext ec, string ns, string method, Expression expr, Location loc)
+		{
+			Expression etmp, e;
+			ArrayList args;
+			Argument arg;
+			
+		 	etmp = Mono.MonoBASIC.Parser.DecomposeQI(ns+method, loc);
+		 	args = new ArrayList();
+		 	arg = new Argument (expr, Argument.AType.Expression);
+		 	args.Add (arg);
+			e = (Expression) new Invocation (etmp, args, loc);
+			e = e.Resolve(ec);	
+			return (e);		
+		}
+
+		
+		static public bool NarrowingConversionExists (EmitContext ec, Expression expr, Type target_type)
+		{
+			Type expr_type = expr.Type;
+			if (expr_type.IsSubclassOf (TypeManager.enum_type))
+				expr_type = TypeManager.EnumToUnderlying (expr_type);
+	
+			if (target_type.IsSubclassOf (TypeManager.enum_type))
+				target_type = TypeManager.EnumToUnderlying (target_type);
+
+
+			if (expr_type == target_type)
+				return true;
+
+			if (target_type == TypeManager.sbyte_type){
+				//
+				// To sbyte from short, int, long, float, double.
+				//
+				if ((expr_type == TypeManager.int32_type) || 
+				    (expr_type == TypeManager.int64_type) ||
+				    (expr_type == TypeManager.double_type) ||
+				    (expr_type == TypeManager.float_type)  ||
+				    (expr_type == TypeManager.short_type) ||
+				    (expr_type == TypeManager.decimal_type))
+					return true;
+				
+			} else if (target_type == TypeManager.byte_type){
+				//
+				// To byte from short, ushort, int, uint, long, ulong, float, double
+				// 
+				if ((expr_type == TypeManager.short_type) ||
+				    (expr_type == TypeManager.ushort_type) ||
+				    (expr_type == TypeManager.int32_type) ||
+				    (expr_type == TypeManager.uint32_type) ||
+				    (expr_type == TypeManager.uint64_type) ||
+				    (expr_type == TypeManager.int64_type) ||
+				    (expr_type == TypeManager.float_type) ||
+				    (expr_type == TypeManager.double_type) ||
+				    (expr_type == TypeManager.decimal_type))
+					return true;
+	
+			} else if (target_type == TypeManager.short_type){
+				//
+				// To short from int, long, float, double
+				// 
+				if ((expr_type == TypeManager.int32_type) ||
+				    (expr_type == TypeManager.int64_type) ||
+				    (expr_type == TypeManager.double_type) ||
+				    (expr_type == TypeManager.float_type) ||
+				    (expr_type == TypeManager.decimal_type))
+					return true;
+					
+			} else if (target_type == TypeManager.ushort_type){
+				//
+				// To ushort from int, uint, long, ulong, float, double
+				//
+				if ((expr_type == TypeManager.uint32_type) ||
+				    (expr_type == TypeManager.uint64_type) ||
+				    (expr_type == TypeManager.int32_type) ||
+				    (expr_type == TypeManager.int64_type) ||
+				    (expr_type == TypeManager.double_type) ||
+				    (expr_type == TypeManager.float_type) ||
+				    (expr_type == TypeManager.decimal_type))
+					return true;
+				    
+			} else if (target_type == TypeManager.int32_type){
+				//
+				// To int from long, float, double
+				//
+				if ((expr_type == TypeManager.int64_type) ||
+				    (expr_type == TypeManager.double_type) ||
+				    (expr_type == TypeManager.float_type) ||
+				    (expr_type == TypeManager.decimal_type))
+					return true;
+					
+			} else if (target_type == TypeManager.uint32_type){
+				//
+				// To uint from long, ulong, float, double
+				//
+				if ((expr_type == TypeManager.int64_type) ||
+				    (expr_type == TypeManager.uint64_type) ||
+				    (expr_type == TypeManager.double_type) ||
+				    (expr_type == TypeManager.float_type) ||
+				    (expr_type == TypeManager.decimal_type))
+					return true;
+					
+			} else if ((target_type == TypeManager.uint64_type) ||
+				   (target_type == TypeManager.int64_type)) {
+				//
+				// To long/ulong from float, double
+				//
+				if ((expr_type == TypeManager.double_type) ||
+				    (expr_type == TypeManager.float_type) ||
+				    (expr_type == TypeManager.decimal_type))
+					return true;
+				    
+			} else if (target_type == TypeManager.decimal_type){
+				if (expr_type == TypeManager.float_type ||
+				    expr_type == TypeManager.double_type)
+					return true;
+			} else if (target_type == TypeManager.float_type){
+				//
+				// To float from double
+				//
+				if (expr_type == TypeManager.double_type)
+					return true;
+			}	
+
+			return (NarrowingConversion (ec, expr, target_type,Location.Null)) != null;	
+		}
+		
+		static public Expression NarrowingConversion (EmitContext ec, Expression expr,
+								Type target_type, Location loc)
+		{
+			Type expr_type = expr.Type;
+
+			if (expr_type.IsSubclassOf (TypeManager.enum_type))
+				expr_type = TypeManager.EnumToUnderlying (expr_type);
+	
+			if (target_type.IsSubclassOf (TypeManager.enum_type))
+				target_type = TypeManager.EnumToUnderlying (target_type);
+
+			if (expr_type == target_type)
+				return expr;
+
+			if (target_type == TypeManager.sbyte_type){
+				//
+				// To sbyte from short, int, long, float, double.
+				//
+				if (expr_type == TypeManager.int32_type) 
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_I1);
+				if (expr_type == TypeManager.int64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I1);
+				if (expr_type == TypeManager.short_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_I1);
+
+				if (expr_type == TypeManager.float_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I1);
+				}
+				if (expr_type == TypeManager.double_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I1);
+				}
+				
+			} else if (target_type == TypeManager.byte_type){
+				//
+				// To byte from short, ushort, int, uint, long, ulong, float, double
+				// 
+				if (expr_type == TypeManager.short_type) 
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_U1);
+				if (expr_type == TypeManager.ushort_type) 
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U2_U1);
+				if (expr_type == TypeManager.int32_type) 
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U1);
+				if (expr_type == TypeManager.uint32_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_U1);
+				if (expr_type == TypeManager.uint64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_U1);
+				if (expr_type == TypeManager.int64_type) 
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U1);
+
+				if (expr_type == TypeManager.float_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U1);
+				}
+				if (expr_type == TypeManager.double_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U1);
+				}
+	
+			} else if (target_type == TypeManager.short_type) {
+				//
+				// To short from int, long, float, double
+				// 
+				if (expr_type == TypeManager.int32_type) 
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_I2);
+				if (expr_type == TypeManager.int64_type) 
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I2);
+
+				if (expr_type == TypeManager.float_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I2);
+				}
+				if (expr_type == TypeManager.double_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I2);
+				}
+					
+			} else if (target_type == TypeManager.ushort_type) {
+				//
+				// To ushort from int, uint, long, ulong, float, double
+				//
+				if (expr_type == TypeManager.uint32_type) 
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_U2);
+				if (expr_type == TypeManager.uint64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_U2);
+				if (expr_type == TypeManager.int32_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U2);
+				if (expr_type == TypeManager.int64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U2);
+
+				if (expr_type == TypeManager.float_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U2);
+				}
+
+				if (expr_type == TypeManager.double_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U2);
+				}
+				    
+			} else if (target_type == TypeManager.int32_type){
+				//
+				// To int from long, float, double
+				//
+				if (expr_type == TypeManager.int64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I4);
+
+				if (expr_type == TypeManager.float_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I4);
+				}
+				if (expr_type == TypeManager.double_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I4);
+				}
+					
+			} else if (target_type == TypeManager.uint32_type){
+				//
+				// To uint from long, ulong, float, double
+				//
+				if (expr_type == TypeManager.int64_type) 
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U4);
+				if (expr_type == TypeManager.uint64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_I4);
+				if (expr_type == TypeManager.float_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U4);
+				}
+				if (expr_type == TypeManager.double_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U4);
+				}
+					
+			} else if (target_type == TypeManager.uint64_type) {
+				//
+				// To long/ulong from float, double
+				//
+				if (expr_type == TypeManager.float_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U8);
+				}
+				if (expr_type == TypeManager.double_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U8);
+				}
+				    
+			} else if (target_type == TypeManager.int64_type) {
+				//
+				// To long/ulong from float, double
+				//
+				if (expr_type == TypeManager.float_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I8);
+				}
+				if (expr_type == TypeManager.double_type) {
+					Expression rounded_expr = RTConversionExpression(ec, "System.Math", ".Round", expr, loc);
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I8);
+				}
+
+			} else if (target_type == TypeManager.float_type){
+				//
+				// To float from double
+				//
+				if (expr_type == TypeManager.double_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_R4);
+			}	
+
+			TypeCode dest_type = Type.GetTypeCode (target_type);
+			TypeCode src_type = Type.GetTypeCode (expr_type);
+			Expression e = null;
+
+			switch (dest_type) {
+				case TypeCode.String:
+					switch (src_type) {
+						case TypeCode.SByte:						
+						case TypeCode.Byte:
+							e = RTConversionExpression(ec, "StringType.FromByte", expr, loc);
+							break;	
+						case TypeCode.UInt16:
+						case TypeCode.Int16:
+							e = RTConversionExpression(ec, "StringType.FromShort", expr, loc);
+							break;		
+						case TypeCode.UInt32:					
+						case TypeCode.Int32:
+							e = RTConversionExpression(ec, "StringType.FromInteger", expr, loc);
+							break;							
+						case TypeCode.UInt64:	
+						case TypeCode.Int64:
+							e = RTConversionExpression(ec, "StringType.FromLong", expr, loc);
+							break;							
+						case TypeCode.Char:
+							e = RTConversionExpression(ec, "StringType.FromChar", expr, loc);
+							break;								
+						case TypeCode.Single:
+							e = RTConversionExpression(ec, "StringType.FromSingle", expr, loc);
+							break;		
+						case TypeCode.Double:
+							e = RTConversionExpression(ec, "StringType.FromDouble", expr, loc);
+							break;																			
+						case TypeCode.Boolean:
+							e = RTConversionExpression(ec, "StringType.FromBoolean", expr, loc);
+							break;	
+						case TypeCode.DateTime:
+							e = RTConversionExpression(ec, "StringType.FromDate", expr, loc);
+							break;		
+						case TypeCode.Decimal:
+							e = RTConversionExpression(ec, "StringType.FromDecimal", expr, loc);
+							break;		
+						case TypeCode.Object:
+							e = RTConversionExpression(ec, "StringType.FromObject", expr, loc);
+							break;																												
+					}
+					break;
+					
+				case TypeCode.Double:
+					switch (src_type) {						
+						case TypeCode.String:				
+							e = RTConversionExpression(ec, "DoubleType.FromString", expr, loc);
+							break;		
+						case TypeCode.Object:				
+							e = RTConversionExpression(ec, "DoubleType.FromObject", expr, loc);
+							break;											
+					}
+					break;	
+					
+				case TypeCode.Single:
+					switch (src_type) {						
+						case TypeCode.String:				
+							e = RTConversionExpression(ec, "SingleType.FromString", expr, loc);
+							break;		
+						case TypeCode.Object:				
+							e = RTConversionExpression(ec, "SingleType.FromObject", expr, loc);
+							break;											
+					}
+					break;	
+					
+				case TypeCode.Decimal:
+					switch (src_type) {						
+						case TypeCode.String:				
+							e = RTConversionExpression(ec, "DecimalType.FromString", expr, loc);
+							break;		
+						case TypeCode.Object:				
+							e = RTConversionExpression(ec, "DecimalType.FromObject", expr, loc);
+							break;											
+					}
+					break;	
+					
+				case TypeCode.Int64:
+				case TypeCode.UInt64:	
+					switch (src_type) {						
+						case TypeCode.String:				
+							e = RTConversionExpression(ec, "LongType.FromString", expr, loc);
+							break;		
+						case TypeCode.Object:				
+							e = RTConversionExpression(ec, "LongType.FromObject", expr, loc);
+							break;											
+					}
+					break;	
+				case TypeCode.Int32:
+				case TypeCode.UInt32:	
+					switch (src_type) {						
+						case TypeCode.String:				
+							e = RTConversionExpression(ec, "IntegerType.FromString", expr, loc);
+							break;		
+						case TypeCode.Object:				
+							e = RTConversionExpression(ec, "IntegerType.FromObject", expr, loc);
+							break;											
+					}
+					break;	
+
+				case TypeCode.Int16:
+				case TypeCode.UInt16:	
+					switch (src_type) {						
+						case TypeCode.String:				
+							e = RTConversionExpression(ec, "ShortType.FromString", expr, loc);
+							break;		
+						case TypeCode.Object:				
+							e = RTConversionExpression(ec, "ShortType.FromObject", expr, loc);
+							break;											
+					}
+					break;	
+				case TypeCode.Byte:
+					
+					switch (src_type) {						
+						case TypeCode.String:				
+							e = RTConversionExpression(ec, "BooleanType.FromString", expr, loc);
+							break;		
+						case TypeCode.Object:				
+							e = RTConversionExpression(ec, "ByteType.FromObject", expr, loc);
+							break;	
+					}
+					break;
+				case TypeCode.Boolean:	
+					switch (src_type) {						
+						case TypeCode.String:				
+							e = RTConversionExpression(ec, "BooleanType.FromString", expr, loc);
+							break;		
+						case TypeCode.Object:				
+							e = RTConversionExpression(ec, "BooleanType.FromObject", expr, loc);
+							break;											
+					}
+					break;
+				case TypeCode.DateTime:	
+					switch (src_type) {						
+						case TypeCode.String:				
+							e = RTConversionExpression(ec, "DateType.FromString", expr, loc);
+							break;		
+						case TypeCode.Object:				
+							e = RTConversionExpression(ec, "DateType.FromObject", expr, loc);
+							break;											
+					}
+					break;
+				case TypeCode.Char:
+ 					switch (src_type) {
+
+ 						case TypeCode.String:
+ 							e = RTConversionExpression(ec, "CharType.FromString", expr, loc);
+ 							break;			
+					
+ 				}	
+				break;														
+			}
+			
+			// We must examine separately some types that
+			// don't have a TypeCode but are supported 
+			// in the runtime
+			if (expr_type == typeof(System.String) && target_type == typeof (System.Char[])) {
+				e = RTConversionExpression(ec, "CharArrayType.FromString", expr, loc);
+			}
+			if (e != null)	
+				return e;
+			// VB.NET Objects can be converted to anything by default
+			// unless, that is, an exception at runtime blows it all
+			if (src_type == TypeCode.Object) {
+				Expression cast_type = Mono.MonoBASIC.Parser.DecomposeQI(target_type.ToString(), loc);
+				Cast ce = new Cast (cast_type, expr, loc);
+				ce.IsRuntimeCast = true;
+				return ce.Resolve (ec);
+			}
+		      return null;
+		}
+
+		static public Expression ConvertNothingToDefaultValues (EmitContext ec, Expression expr,
+									Type target_type, Location loc)
+		{
+			switch (Type.GetTypeCode (target_type)) {
+			case TypeCode.Boolean  :
+				return new BoolConstant (false);
+			case TypeCode.Byte  :
+				return new ByteConstant (0);
+			case TypeCode.Char  :
+				return new CharConstant ((char)0);
+			case TypeCode.SByte :
+				return new SByteConstant (0);
+			case TypeCode.Int16 :
+				return new ShortConstant (0);
+			case TypeCode.Int32 :
+				return new IntConstant (0);
+			case TypeCode.Int64 :
+				return new LongConstant (0);
+			case TypeCode.Decimal :
+				return new DecimalConstant (System.Decimal.Zero);
+			case TypeCode.Single :
+				return new FloatConstant (0.0F);
+			case TypeCode.Double :
+				return new DoubleConstant (0.0);
+			}
+
+			return null;
+		}
+										  		
+		/// <summary>
+		///   Attempts to apply the 'Standard Implicit
+		///   Conversion' rules to the expression 'expr' into
+		///   the 'target_type'.  It returns a new expression
+		///   that can be used in a context that expects a
+		///   'target_type'.
+		///
+		///   This is different from 'ConvertImplicit' in that the
+		///   user defined implicit conversions are excluded. 
+		/// </summary>
+		static public Expression ConvertImplicitStandard (EmitContext ec, Expression expr,
+								  Type target_type, Location loc)
+		{
+			Type expr_type = expr.Type;
+
+			if (expr_type.IsSubclassOf (TypeManager.enum_type))
+				expr_type = TypeManager.EnumToUnderlying (expr_type);
+
+			Expression e;
+
+			if (expr is NullLiteral) {
+				if (target_type == TypeManager.string_type)
+					return expr;
+				e = ConvertNothingToDefaultValues (ec, expr, target_type, loc);
+				if (e != null)
+					return e;
+			}
+
+			if (expr_type == target_type)
+				return expr;
+
+			e = ImplicitNumericConversion (ec, expr, target_type, loc);
+
+			if (e != null)
+				return e;
+
+			if (expr is StringConstant && target_type == TypeManager.char_type)
+				return new CharConstant (((StringConstant) expr).Value [0]);
+
+			if (expr is CharConstant && target_type == TypeManager.string_type)
+				return new StringConstant (((CharConstant) expr).Value.ToString ());
+
+			e = ImplicitReferenceConversion (expr, target_type);
+			if (e != null)
+				return e;
+
+			if (expr.Type.IsSubclassOf (TypeManager.enum_type)) {
+				expr_type = TypeManager.EnumToUnderlying (expr.Type);
+				expr = new EmptyCast (expr, expr_type);
+				if (expr_type == target_type)
+					return expr;
+				e = ImplicitNumericConversion (ec, expr, target_type, loc);
+				if (e != null)
+					return e;
+			}
+
+			if (ec.InUnsafe) {
+				if (expr_type.IsPointer){
+					if (target_type == TypeManager.void_ptr_type)
+						return new EmptyCast (expr, target_type);
+
+					//
+					// yep, comparing pointer types cant be done with
+					// t1 == t2, we have to compare their element types.
+					//
+					if (target_type.IsPointer){
+						if (target_type.GetElementType()==expr_type.GetElementType())
+							return expr;
+					}
+				}
+				
+				if (target_type.IsPointer){
+					if (expr is NullLiteral)
+						return new EmptyCast (expr, target_type);
+				}
+			}
+
+			return null;
+		}
+
+		/// <summary>
+		///   Attemps to perform an implict constant conversion of the any Numeric Constant
+		///   into a different data type using casts (See Implicit Constant
+		///   Expression Conversions)
+		/// </summary>
+		static protected Expression TryImplicitNumericConversion (Type target_type, Constant ic)
+		{
+			double value = 0;
+			if (ic is BoolConstant) {
+				bool val = (bool) ((BoolConstant)ic).Value;
+				if (val) {
+					if (target_type == TypeManager.byte_type)
+						value = Byte.MaxValue;
+					else 
+						value = -1;
+				}
+			}
+			if (ic is IntConstant) 
+				value = (double)((IntConstant)ic).Value;
+			
+			if (ic is LongConstant) 
+				value = (double) ((LongConstant)ic).Value;
+
+			if (ic is FloatConstant) {
+				value = (double) ((FloatConstant)ic).Value;
+			}
+
+			if (ic is DoubleConstant) {
+				value = ((DoubleConstant)ic).Value;
+			}
+
+			//
+			// FIXME: This could return constants instead of EmptyCasts
+			//
+			if (target_type == TypeManager.bool_type){
+				if (value != 0)
+					return new BoolConstant (true);
+				return new BoolConstant (false);
+			} else if (target_type == TypeManager.sbyte_type){
+				if (value >= SByte.MinValue && value <= SByte.MaxValue)
+					return new SByteConstant ((sbyte) System.Math.Round (value));
+			} else if (target_type == TypeManager.byte_type){
+				if (value >= Byte.MinValue && value <= Byte.MaxValue)
+					return new ByteConstant ((byte) System.Math.Round (value));
+			} else if (target_type == TypeManager.short_type){
+				if (value >= Int16.MinValue && value <= Int16.MaxValue)
+					return new ShortConstant ((short) System.Math.Round (value));
+			} else if (target_type == TypeManager.ushort_type){
+				if (value >= UInt16.MinValue && value <= UInt16.MaxValue)
+					return new UShortConstant ((ushort) System.Math.Round (value));
+			} else if (target_type == TypeManager.int32_type){
+				if (value >= Int32.MinValue && value <= Int32.MaxValue)
+					return new IntConstant ((int) System.Math.Round (value));
+			} else if (target_type == TypeManager.uint32_type){
+				if (value >= 0)
+					return new UIntConstant ((uint) System.Math.Round (value));
+			} else if (target_type == TypeManager.int64_type){
+					return new LongConstant ((long) System.Math.Round (value));
+			} else if (target_type == TypeManager.uint64_type){
+				//
+				// we can optimize this case: a positive int32
+				// always fits on a uint64.  But we need an opcode
+				// to do it.
+				//
+				if (value >= 0)
+					return new ULongConstant ((ulong)System.Math.Round ( value));
+			} else if (target_type == TypeManager.float_type){
+					return new FloatConstant ((float) value);
+			} else if (target_type == TypeManager.double_type){
+					return new DoubleConstant ((double) value);
+			}
+			
+			if (value == 0 && ic is IntLiteral && TypeManager.IsEnumType (target_type)){
+				Type underlying = TypeManager.EnumToUnderlying (target_type);
+				Constant e = (Constant) ic;
+				
+				//
+				// Possibly, we need to create a different 0 literal before passing
+				// to EnumConstant
+				//n
+				if (underlying == TypeManager.int64_type)
+					e = new LongLiteral (0);
+				else if (underlying == TypeManager.uint64_type)
+					e = new ULongLiteral (0);
+
+				return new EnumConstant (e, target_type);
+			}
+			return null;
+		}
+
+		static public void Error_CannotConvertImplicit (Location loc, Type source, Type target)
+		{
+			string msg = "Cannot convert implicitly from '"+
+				TypeManager.MonoBASIC_Name (source) + "' to '" +
+				TypeManager.MonoBASIC_Name (target) + "'";
+
+			throw new Exception (msg);
+
+			// Report.Error (30512, loc, msg);
+		}
+
+                static public void Error_CannotConvertTypeStrict (Type source, Type target, Location loc)
+	        {
+		        Report.Error (
+				30512, loc, "Cannot convert implicitly from '" +
+				TypeManager.MonoBASIC_Name (source) + "' to '" +
+				TypeManager.MonoBASIC_Name (target) + "' with Option Strict On.");
+		}		
+
+		/// <summary>
+		///   Attemptes to implicityly convert 'target' into 'type', using
+		///   ConvertImplicit.  If there is no implicit conversion, then
+		///   an error is signaled
+		/// </summary>
+		static public Expression ConvertImplicitRequired (EmitContext ec, Expression source,
+								  Type target_type, Location loc)
+		{
+			Expression e;
+			
+			e = ConvertImplicit (ec, source, target_type, loc);
+
+			if (e != null)
+				return e;
+
+
+			if (source is DoubleLiteral && target_type == TypeManager.float_type){
+				Report.Error (664, loc,
+					      "Double literal cannot be implicitly converted to " +
+					      "float type, use F suffix to create a float literal");
+			}
+
+			Error_CannotConvertImplicit (loc, source.Type, target_type);
+
+			return null;
+		}
+
+		/// <summary>
+		///   Performs the explicit numeric conversions
+		/// </summary>
+		static Expression ConvertNumericExplicit (EmitContext ec, Expression expr, Type target_type, Location loc)
+		{
+			Type expr_type = expr.Type;
+
+			//
+			// If we have an enumeration, extract the underlying type,
+			// use this during the comparison, but wrap around the original
+			// target_type
+			//
+			Type real_target_type = target_type;
+
+			if (TypeManager.IsEnumType (real_target_type))
+				real_target_type = TypeManager.EnumToUnderlying (real_target_type);
+
+			if (StandardConversionExists (expr, real_target_type)){
+ 				Expression ce = ConvertImplicitStandard (ec, expr, real_target_type, loc);
+
+				if (real_target_type != target_type)
+					return new EmptyCast (ce, target_type);
+				return ce;
+			}
+			
+			if (expr_type == TypeManager.sbyte_type){
+				//
+				// From sbyte to byte, ushort, uint, ulong, char
+				//
+				if (real_target_type == TypeManager.byte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I1_U1);
+				if (real_target_type == TypeManager.ushort_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I1_U2);
+				if (real_target_type == TypeManager.uint32_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I1_U4);
+				if (real_target_type == TypeManager.uint64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I1_U8);
+			} else if (expr_type == TypeManager.byte_type){
+				//
+				// From byte to sbyte and char
+				//
+				if (real_target_type == TypeManager.sbyte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U1_I1);
+			} else if (expr_type == TypeManager.short_type){
+				//
+				// From short to sbyte, byte, ushort, uint, ulong, char
+				//
+				if (real_target_type == TypeManager.sbyte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_I1);
+				if (real_target_type == TypeManager.byte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_U1);
+				if (real_target_type == TypeManager.ushort_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_U2);
+				if (real_target_type == TypeManager.uint32_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_U4);
+				if (real_target_type == TypeManager.uint64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I2_U8);
+			} else if (expr_type == TypeManager.ushort_type){
+				//
+				// From ushort to sbyte, byte, short, char
+				//
+				if (real_target_type == TypeManager.sbyte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U2_I1);
+				if (real_target_type == TypeManager.byte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U2_U1);
+				if (real_target_type == TypeManager.short_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U2_I2);
+			} else if (expr_type == TypeManager.int32_type){
+				//
+				// From int to sbyte, byte, short, ushort, uint, ulong, char
+				//
+				if (real_target_type == TypeManager.sbyte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_I1);
+				if (real_target_type == TypeManager.byte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U1);
+				if (real_target_type == TypeManager.short_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_I2);
+				if (real_target_type == TypeManager.ushort_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U2);
+				if (real_target_type == TypeManager.uint32_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U4);
+				if (real_target_type == TypeManager.uint64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I4_U8);
+			} else if (expr_type == TypeManager.uint32_type){
+				//
+				// From uint to sbyte, byte, short, ushort, int, char
+				//
+				if (real_target_type == TypeManager.sbyte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_I1);
+				if (real_target_type == TypeManager.byte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_U1);
+				if (real_target_type == TypeManager.short_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_I2);
+				if (real_target_type == TypeManager.ushort_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_U2);
+				if (real_target_type == TypeManager.int32_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U4_I4);
+			} else if (expr_type == TypeManager.int64_type){
+				//
+				// From long to sbyte, byte, short, ushort, int, uint, ulong, char
+				//
+				if (real_target_type == TypeManager.sbyte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I1);
+				if (real_target_type == TypeManager.byte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U1);
+				if (real_target_type == TypeManager.short_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I2);
+				if (real_target_type == TypeManager.ushort_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U2);
+				if (real_target_type == TypeManager.int32_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_I4);
+				if (real_target_type == TypeManager.uint32_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U4);
+				if (real_target_type == TypeManager.uint64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.I8_U8);
+			} else if (expr_type == TypeManager.uint64_type){
+				//
+				// From ulong to sbyte, byte, short, ushort, int, uint, long, char
+				//
+				if (real_target_type == TypeManager.sbyte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_I1);
+				if (real_target_type == TypeManager.byte_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_U1);
+				if (real_target_type == TypeManager.short_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_I2);
+				if (real_target_type == TypeManager.ushort_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_U2);
+				if (real_target_type == TypeManager.int32_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_I4);
+				if (real_target_type == TypeManager.uint32_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_U4);
+				if (real_target_type == TypeManager.int64_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.U8_I8);
+			} else if (expr_type == TypeManager.float_type){
+				//
+				// From float to sbyte, byte, short,
+				// ushort, int, uint, long, ulong, char
+				// or decimal
+				//
+				Expression rounded_expr = RTConversionExpression(ec, "System.Math",".Round" , expr, loc);
+				if (real_target_type == TypeManager.sbyte_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I1);
+				if (real_target_type == TypeManager.byte_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U1);
+				if (real_target_type == TypeManager.short_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I2);
+				if (real_target_type == TypeManager.ushort_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U2);
+				if (real_target_type == TypeManager.int32_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I4);
+				if (real_target_type == TypeManager.uint32_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U4);
+				if (real_target_type == TypeManager.int64_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_I8);
+				if (real_target_type == TypeManager.uint64_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R4_U8);
+			} else if (expr_type == TypeManager.double_type){
+				//
+				// From double to byte, byte, short,
+				// ushort, int, uint, long, ulong,
+				// char, float or decimal
+				//
+				Expression rounded_expr = RTConversionExpression(ec, "System.Math",".Round" , expr, loc);
+				if (real_target_type == TypeManager.sbyte_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I1);
+				if (real_target_type == TypeManager.byte_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U1);
+				if (real_target_type == TypeManager.short_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I2);
+				if (real_target_type == TypeManager.ushort_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U2);
+				if (real_target_type == TypeManager.int32_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I4);
+				if (real_target_type == TypeManager.uint32_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U4);
+				if (real_target_type == TypeManager.int64_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_I8);
+				if (real_target_type == TypeManager.uint64_type)
+					return new ConvCast (ec, rounded_expr, target_type, ConvCast.Mode.R8_U8);
+				if (real_target_type == TypeManager.float_type)
+					return new ConvCast (ec, expr, target_type, ConvCast.Mode.R8_R4);
+			} 
+
+			// decimal is taken care of by the op_Explicit methods.
+
+			return null;
+		}
+
+		/// <summary>
+		///  Returns whether an explicit reference conversion can be performed
+		///  from source_type to target_type
+		/// </summary>
+		public static bool ExplicitReferenceConversionExists (Type source_type, Type target_type)
+		{
+			bool target_is_value_type = target_type.IsValueType;
+			
+			if (source_type == target_type)
+				return true;
+			
+			//
+			// From object to any reference type
+			//
+			if (source_type == TypeManager.object_type && !target_is_value_type)
+				return true;
+					
+			//
+			// From any class S to any class-type T, provided S is a base class of T
+			//
+			if (target_type.IsSubclassOf (source_type))
+				return true;
+
+			//
+			// From any interface type S to any interface T provided S is not derived from T
+			//
+			if (source_type.IsInterface && target_type.IsInterface){
+				if (!target_type.IsSubclassOf (source_type))
+					return true;
+			}
+			    
+			//
+			// From any class type S to any interface T, provided S is not sealed
+			// and provided S does not implement T.
+			//
+			if (target_type.IsInterface && !source_type.IsSealed &&
+			    !TypeManager.ImplementsInterface (source_type, target_type))
+				return true;
+
+			//
+			// From any interface-type S to to any class type T, provided T is not
+			// sealed, or provided T implements S.
+			//
+			if (source_type.IsInterface &&
+			    (!target_type.IsSealed || TypeManager.ImplementsInterface (target_type, source_type)))
+				return true;
+			
+			
+			// From an array type S with an element type Se to an array type T with an 
+			// element type Te provided all the following are true:
+			//     * S and T differe only in element type, in other words, S and T
+			//       have the same number of dimensions.
+			//     * Both Se and Te are reference types
+			//     * An explicit referenc conversions exist from Se to Te
+			//
+			if (source_type.IsArray && target_type.IsArray) {
+				if (source_type.GetArrayRank () == target_type.GetArrayRank ()) {
+					
+					Type source_element_type = source_type.GetElementType ();
+					Type target_element_type = target_type.GetElementType ();
+					
+					if (!source_element_type.IsValueType && !target_element_type.IsValueType)
+						if (ExplicitReferenceConversionExists (source_element_type,
+										       target_element_type))
+							return true;
+				}
+			}
+			
+
+			// From System.Array to any array-type
+			if (source_type == TypeManager.array_type &&
+			    target_type.IsArray){
+				return true;
+			}
+
+			//
+			// From System delegate to any delegate-type
+			//
+			if (source_type == TypeManager.delegate_type &&
+			    target_type.IsSubclassOf (TypeManager.delegate_type))
+				return true;
+
+			//
+			// From ICloneable to Array or Delegate types
+			//
+			if (source_type == TypeManager.icloneable_type &&
+			    (target_type == TypeManager.array_type ||
+			     target_type == TypeManager.delegate_type))
+				return true;
+			
+			return false;
+		}
+
+		/// <summary>
+		///   Implements Explicit Reference conversions
+		/// </summary>
+		static Expression ConvertReferenceExplicit (Expression source, Type target_type)
+		{
+			Type source_type = source.Type;
+			bool target_is_value_type = target_type.IsValueType;
+
+			//
+			// From object to any reference type
+			//
+			if (source_type == TypeManager.object_type && !target_is_value_type)
+				return new ClassCast (source, target_type);
+
+
+			//
+			// From any class S to any class-type T, provided S is a base class of T
+			//
+			if (target_type.IsSubclassOf (source_type))
+				return new ClassCast (source, target_type);
+
+			//
+			// From any interface type S to any interface T provided S is not derived from T
+			//
+			if (source_type.IsInterface && target_type.IsInterface){
+				if (TypeManager.ImplementsInterface (source_type, target_type))
+					return null;
+				else
+					return new ClassCast (source, target_type);
+			}
+			    
+			//
+			// From any class type S to any interface T, provides S is not sealed
+			// and provided S does not implement T.
+			//
+			if (target_type.IsInterface && !source_type.IsSealed) {
+				if (TypeManager.ImplementsInterface (source_type, target_type))
+					return null;
+				else
+					return new ClassCast (source, target_type);
+				
+			}
+
+			//
+			// From any interface-type S to to any class type T, provided T is not
+			// sealed, or provided T implements S.
+			//
+			if (source_type.IsInterface) {
+				if (!target_type.IsSealed || TypeManager.ImplementsInterface (target_type, source_type))
+					return new ClassCast (source, target_type);
+				else
+					return null;
+			}
+			
+			// From an array type S with an element type Se to an array type T with an 
+			// element type Te provided all the following are true:
+			//     * S and T differe only in element type, in other words, S and T
+			//       have the same number of dimensions.
+			//     * Both Se and Te are reference types
+			//     * An explicit referenc conversions exist from Se to Te
+			//
+			if (source_type.IsArray && target_type.IsArray) {
+				if (source_type.GetArrayRank () == target_type.GetArrayRank ()) {
+					
+					Type source_element_type = source_type.GetElementType ();
+					Type target_element_type = target_type.GetElementType ();
+					
+					if (!source_element_type.IsValueType && !target_element_type.IsValueType)
+						if (ExplicitReferenceConversionExists (source_element_type,
+										       target_element_type))
+							return new ClassCast (source, target_type);
+				}
+			}
+			
+
+			// From System.Array to any array-type
+			if (source_type == TypeManager.array_type &&
+			    target_type.IsArray) {
+				return new ClassCast (source, target_type);
+			}
+
+			//
+			// From System delegate to any delegate-type
+			//
+			if (source_type == TypeManager.delegate_type &&
+			    target_type.IsSubclassOf (TypeManager.delegate_type))
+				return new ClassCast (source, target_type);
+
+			//
+			// From ICloneable to Array or Delegate types
+			//
+			if (source_type == TypeManager.icloneable_type &&
+			    (target_type == TypeManager.array_type ||
+			     target_type == TypeManager.delegate_type))
+				return new ClassCast (source, target_type);
+			
+			return null;
+		}
+		
+		/// <summary>
+		///   Performs an explicit conversion of the expression 'expr' whose
+		///   type is expr.Type to 'target_type'.
+		/// </summary>
+		static public Expression ConvertExplicit (EmitContext ec, Expression expr,
+							  Type target_type, bool runtimeconv, Location loc)
+		{
+			Type expr_type = expr.Type;
+			Expression ne = ConvertImplicitStandard (ec, expr, target_type, loc);
+
+			if (ne != null)
+				return ne;
+
+			ne = ConvertNumericExplicit (ec, expr, target_type, loc);
+			if (ne != null)
+				return ne;
+
+			//
+			// Unboxing conversion.
+			//
+			if (expr_type == TypeManager.object_type && target_type.IsValueType)
+				return new UnboxCast (expr, target_type);
+
+			//
+			// Enum types
+			//
+			if (expr_type.IsSubclassOf (TypeManager.enum_type)) {
+				Expression e;
+
+				//
+				// FIXME: Is there any reason we should have EnumConstant
+				// dealt with here instead of just using always the
+				// UnderlyingSystemType to wrap the type?
+				//
+				if (expr is EnumConstant)
+					e = ((EnumConstant) expr).Child;
+				else {
+					e = new EmptyCast (expr, TypeManager.EnumToUnderlying (expr_type));
+				}
+				
+				Expression t = ConvertImplicit (ec, e, target_type, loc);
+				if (t != null)
+					return t;
+				
+				t = ConvertNumericExplicit (ec, e, target_type, loc);
+				if (t != null)
+					return t;
+				
+				t = NarrowingConversion (ec, e, target_type, loc);
+				if (t != null)
+					return t;	
+								
+				Error_CannotConvertType (loc, expr_type, target_type);
+				return null;
+			}
+			
+			ne = ConvertReferenceExplicit (expr, target_type);
+			if (ne != null)
+				return ne;
+
+			if (ec.InUnsafe){
+				if (target_type.IsPointer){
+					if (expr_type.IsPointer)
+						return new EmptyCast (expr, target_type);
+					
+					if (expr_type == TypeManager.sbyte_type ||
+					    expr_type == TypeManager.byte_type ||
+					    expr_type == TypeManager.short_type ||
+					    expr_type == TypeManager.ushort_type ||
+					    expr_type == TypeManager.int32_type ||
+					    expr_type == TypeManager.uint32_type ||
+					    expr_type == TypeManager.uint64_type ||
+					    expr_type == TypeManager.int64_type)
+						return new OpcodeCast (expr, target_type, OpCodes.Conv_U);
+				}
+				if (expr_type.IsPointer){
+					if (target_type == TypeManager.sbyte_type ||
+					    target_type == TypeManager.byte_type ||
+					    target_type == TypeManager.short_type ||
+					    target_type == TypeManager.ushort_type ||
+					    target_type == TypeManager.int32_type ||
+					    target_type == TypeManager.uint32_type ||
+					    target_type == TypeManager.uint64_type ||
+					    target_type == TypeManager.int64_type){
+						Expression e = new EmptyCast (expr, TypeManager.uint32_type);
+						Expression ci, ce;
+
+						ci = ConvertImplicitStandard (ec, e, target_type, loc);
+
+						if (ci != null)
+							return ci;
+
+						ce = ConvertNumericExplicit (ec, e, target_type, loc);
+						if (ce != null)
+							return ce;
+						//
+						// We should always be able to go from an uint32
+						// implicitly or explicitly to the other integral
+						// types
+						//
+						throw new Exception ("Internal compiler error");
+					}
+				}
+			}
+			
+			ne = ExplicitUserConversion (ec, expr, target_type, loc);
+			if (ne != null)
+				return ne;
+
+			if (!(runtimeconv))	{
+				ne = NarrowingConversion (ec, expr, target_type, loc);
+				if (ne != null)
+					return ne;
+				
+				Error_CannotConvertType (loc, expr_type, target_type);
+			}
+			return null;
+		}
+
+		/// <summary>
+		///   Same as ConvertExplicit, only it doesn't include user defined conversions
+		/// </summary>
+		static public Expression ConvertExplicitStandard (EmitContext ec, Expression expr,
+								  Type target_type, Location l)
+		{
+			Expression ne = ConvertImplicitStandard (ec, expr, target_type, l);
+
+			if (ne != null)
+				return ne;
+
+			ne = ConvertNumericExplicit (ec, expr, target_type, l);
+			if (ne != null)
+				return ne;
+
+			ne = ConvertReferenceExplicit (expr, target_type);
+			if (ne != null)
+				return ne;
+
+			ne = NarrowingConversion (ec, expr, target_type, l);
+			if (ne != null)
+				return ne;				
+
+			Error_CannotConvertType (l, expr.Type, target_type);
+			return null;
+		}
+
+		static string ExprClassName (ExprClass c)
+		{
+			switch (c){
+			case ExprClass.Invalid:
+				return "Invalid";
+			case ExprClass.Value:
+				return "value";
+			case ExprClass.Variable:
+				return "variable";
+			case ExprClass.Namespace:
+				return "namespace";
+			case ExprClass.Type:
+				return "type";
+			case ExprClass.MethodGroup:
+				return "method group";
+			case ExprClass.PropertyAccess:
+				return "property access";
+			case ExprClass.EventAccess:
+				return "event access";
+			case ExprClass.IndexerAccess:
+				return "indexer access";
+			case ExprClass.Nothing:
+				return "null";
+			}
+			throw new Exception ("Should not happen");
+		}
+		
+		/// <summary>
+		///   Reports that we were expecting 'expr' to be of class 'expected'
+		/// </summary>
+		public void Error118 (string expected)
+		{
+			string kind = "Unknown";
+			
+			kind = ExprClassName (eclass);
+
+			Error (118, "Expression denotes a '" + kind +
+			       "' where a '" + expected + "' was expected");
+		}
+
+		public void Error118 (ResolveFlags flags)
+		{
+			ArrayList valid = new ArrayList (10);
+
+			if ((flags & ResolveFlags.VariableOrValue) != 0) {
+				valid.Add ("variable");
+				valid.Add ("value");
+			}
+
+			if ((flags & ResolveFlags.Type) != 0)
+				valid.Add ("type");
+
+			if ((flags & ResolveFlags.MethodGroup) != 0)
+				valid.Add ("method group");
+
+			if ((flags & ResolveFlags.SimpleName) != 0)
+				valid.Add ("simple name");
+
+			if (valid.Count == 0)
+				valid.Add ("unknown");
+
+			StringBuilder sb = new StringBuilder ();
+			for (int i = 0; i < valid.Count; i++) {
+				if (i > 0)
+					sb.Append (", ");
+				else if (i == valid.Count)
+					sb.Append (" or ");
+				sb.Append (valid [i]);
+			}
+
+			string kind = ExprClassName (eclass);
+
+			Error (119, "Expression denotes a '" + kind + "' where " +
+			       "a '" + sb.ToString () + "' was expected");
+		}
+		
+		static void Error_ConstantValueCannotBeConverted (Location l, string val, Type t)
+		{
+			Report.Error (30439, l, "Constant value '" + val + "' not representable in type " +
+				      TypeManager.MonoBASIC_Name (t));
+		}
+
+		public static void UnsafeError (Location loc)
+		{
+			Report.Error (214, loc, "Pointers may only be used in an unsafe context");
+		}
+		
+		/// <summary>
+		///   Converts the IntConstant, UIntConstant, LongConstant or
+		///   ULongConstant,Double into the integral target_type.   Notice
+		///   that we do not return an 'Expression' we do return
+		///   a boxed integral type.
+		///
+		///   FIXME: Since I added the new constants, we need to
+		///   also support conversions from CharConstant, ByteConstant,
+		///   SByteConstant, UShortConstant, ShortConstant
+		///
+		///   This is used by the switch statement, so the domain
+		///   of work is restricted to the literals above, and the
+		///   targets are int32, uint32, char, byte, sbyte, ushort,
+		///   short, uint64 and int64
+		/// </summary>
+		public static object ConvertIntLiteral (Constant c, Type target_type, Location loc)
+		{
+			string s = "";
+
+			if (c.Type == target_type)
+				return ((Constant) c).GetValue ();
+
+			//
+			// Make into one of the literals we handle, we dont really care
+			// about this value as we will just return a few limited types
+			// 
+			if (c is EnumConstant)
+				c = ((EnumConstant)c).WidenToCompilerConstant ();
+
+			if (c is IntConstant){
+				int v = ((IntConstant) c).Value;
+				
+				if (target_type == TypeManager.uint32_type){
+					if (v >= 0)
+						return (uint) v;
+				} else if (target_type == TypeManager.byte_type){
+					if (v >= Byte.MinValue && v <= Byte.MaxValue)
+						return (byte) v;
+				} else if (target_type == TypeManager.sbyte_type){
+					if (v >= SByte.MinValue && v <= SByte.MaxValue)
+						return (sbyte) v;
+				} else if (target_type == TypeManager.short_type){
+					if (v >= Int16.MinValue && v <= UInt16.MaxValue)
+						return (short) v;
+				} else if (target_type == TypeManager.ushort_type){
+					if (v >= UInt16.MinValue && v <= UInt16.MaxValue)
+						return (ushort) v;
+				} else if (target_type == TypeManager.int64_type)
+					return (long) v;
+			        else if (target_type == TypeManager.uint64_type){
+					if (v > 0)
+						return (ulong) v;
+				}
+
+				s = v.ToString ();
+			} else if (c is	UIntConstant){
+				uint v = ((UIntConstant) c).Value;
+
+				if (target_type == TypeManager.int32_type){
+					if (v <= Int32.MaxValue)
+						return (int) v;
+				} else if (target_type == TypeManager.byte_type){
+					if (v <= Byte.MaxValue)
+						return (byte) v;
+				} else if (target_type == TypeManager.sbyte_type){
+					if (v <= SByte.MaxValue)
+						return (sbyte) v;
+				} else if (target_type == TypeManager.short_type){
+					if (v <= UInt16.MaxValue)
+						return (short) v;
+				} else if (target_type == TypeManager.ushort_type){
+					if (v <= UInt16.MaxValue)
+						return (ushort) v;
+				} else if (target_type == TypeManager.int64_type)
+					return (long) v;
+			        else if (target_type == TypeManager.uint64_type)
+					return (ulong) v;
+				s = v.ToString ();
+			} else if (c is	LongConstant){ 
+				long v = ((LongConstant) c).Value;
+
+				if (target_type == TypeManager.int32_type){
+					if (v >= UInt32.MinValue && v <= UInt32.MaxValue)
+						return (int) v;
+				} else if (target_type == TypeManager.uint32_type){
+					if (v >= 0 && v <= UInt32.MaxValue)
+						return (uint) v;
+				} else if (target_type == TypeManager.byte_type){
+					if (v >= Byte.MinValue && v <= Byte.MaxValue)
+						return (byte) v;
+				} else if (target_type == TypeManager.sbyte_type){
+					if (v >= SByte.MinValue && v <= SByte.MaxValue)
+						return (sbyte) v;
+				} else if (target_type == TypeManager.short_type){
+					if (v >= Int16.MinValue && v <= UInt16.MaxValue)
+						return (short) v;
+				} else if (target_type == TypeManager.ushort_type){
+					if (v >= UInt16.MinValue && v <= UInt16.MaxValue)
+						return (ushort) v;
+			        } else if (target_type == TypeManager.uint64_type){
+					if (v > 0)
+						return (ulong) v;
+				}
+				s = v.ToString ();
+			} else if (c is	ULongConstant){
+				ulong v = ((ULongConstant) c).Value;
+
+				if (target_type == TypeManager.int32_type){
+					if (v <= Int32.MaxValue)
+						return (int) v;
+				} else if (target_type == TypeManager.uint32_type){
+					if (v <= UInt32.MaxValue)
+						return (uint) v;
+				} else if (target_type == TypeManager.byte_type){
+					if (v >= Byte.MinValue && v <= Byte.MaxValue)
+						return (byte) v;
+				} else if (target_type == TypeManager.sbyte_type){
+					if (v <= (int) SByte.MaxValue)
+						return (sbyte) v;
+				} else if (target_type == TypeManager.short_type){
+					if (v <= UInt16.MaxValue)
+						return (short) v;
+				} else if (target_type == TypeManager.ushort_type){
+					if (v <= UInt16.MaxValue)
+						return (ushort) v;
+			        } else if (target_type == TypeManager.int64_type){
+					if (v <= Int64.MaxValue)
+						return (long) v;
+				}
+				s = v.ToString ();
+			} else if (c is ByteConstant){
+				byte v = ((ByteConstant) c).Value;
+				
+				if (target_type == TypeManager.int32_type)
+					return (int) v;
+				else if (target_type == TypeManager.uint32_type)
+					return (uint) v;
+				else if (target_type == TypeManager.sbyte_type){
+					if (v <= SByte.MaxValue)
+						return (sbyte) v;
+				} else if (target_type == TypeManager.short_type)
+					return (short) v;
+				else if (target_type == TypeManager.ushort_type)
+					return (ushort) v;
+			        else if (target_type == TypeManager.int64_type)
+					return (long) v;
+				else if (target_type == TypeManager.uint64_type)
+					return (ulong) v;
+				s = v.ToString ();
+			} else if (c is SByteConstant){
+				sbyte v = ((SByteConstant) c).Value;
+				
+				if (target_type == TypeManager.int32_type)
+					return (int) v;
+				else if (target_type == TypeManager.uint32_type){
+					if (v >= 0)
+						return (uint) v;
+				} else if (target_type == TypeManager.byte_type){
+					if (v >= 0)
+						return (byte) v;
+				} else if (target_type == TypeManager.short_type)
+					return (short) v;
+				else if (target_type == TypeManager.ushort_type){
+					if (v >= 0)
+						return (ushort) v;
+			        } else if (target_type == TypeManager.int64_type)
+					return (long) v;
+				else if (target_type == TypeManager.uint64_type){
+					if (v >= 0)
+						return (ulong) v;
+				}
+				s = v.ToString ();
+			} else if (c is ShortConstant){
+				short v = ((ShortConstant) c).Value;
+				
+				if (target_type == TypeManager.int32_type){
+					return (int) v;
+				} else if (target_type == TypeManager.uint32_type){
+					if (v >= 0)
+						return (uint) v;
+				} else if (target_type == TypeManager.byte_type){
+					if (v >= Byte.MinValue && v <= Byte.MaxValue)
+						return (byte) v;
+				} else if (target_type == TypeManager.sbyte_type){
+					if (v >= SByte.MinValue && v <= SByte.MaxValue)
+						return (sbyte) v;
+				} else if (target_type == TypeManager.ushort_type){
+					if (v >= 0)
+						return (ushort) v;
+			        } else if (target_type == TypeManager.int64_type)
+					return (long) v;
+				else if (target_type == TypeManager.uint64_type)
+					return (ulong) v;
+
+				s = v.ToString ();
+			} else if (c is UShortConstant){
+				ushort v = ((UShortConstant) c).Value;
+				
+				if (target_type == TypeManager.int32_type)
+					return (int) v;
+				else if (target_type == TypeManager.uint32_type)
+					return (uint) v;
+				else if (target_type == TypeManager.byte_type){
+					if (v >= Byte.MinValue && v <= Byte.MaxValue)
+						return (byte) v;
+				} else if (target_type == TypeManager.sbyte_type){
+					if (v <= SByte.MaxValue)
+						return (byte) v;
+				} else if (target_type == TypeManager.short_type){
+					if (v <= Int16.MaxValue)
+						return (short) v;
+			        } else if (target_type == TypeManager.int64_type)
+					return (long) v;
+				else if (target_type == TypeManager.uint64_type)
+					return (ulong) v;
+
+				s = v.ToString ();
+			} else if (c is CharConstant){
+				char v = ((CharConstant) c).Value;
+				
+				if (target_type == TypeManager.int32_type)
+					return (int) v;
+				else if (target_type == TypeManager.uint32_type)
+					return (uint) v;
+				else if (target_type == TypeManager.byte_type){
+					if (v >= Byte.MinValue && v <= Byte.MaxValue)
+						return (byte) v;
+				} else if (target_type == TypeManager.sbyte_type){
+					if (v <= SByte.MaxValue)
+						return (sbyte) v;
+				} else if (target_type == TypeManager.short_type){
+					if (v <= Int16.MaxValue)
+						return (short) v;
+				} else if (target_type == TypeManager.ushort_type)
+					return (short) v;
+			        else if (target_type == TypeManager.int64_type)
+					return (long) v;
+				else if (target_type == TypeManager.uint64_type)
+					return (ulong) v;
+
+				s = v.ToString ();
+
+			 } else if (c is DoubleConstant){
+                                double v = ((DoubleConstant) c).Value;
+
+                                if (target_type == TypeManager.sbyte_type){
+                                        if (v >= SByte.MinValue && v <= SByte.MaxValue)
+						return new SByteConstant ((sbyte) System.Math.Round (v));
+                                } else if (target_type == TypeManager.byte_type){
+                                        if (v >= Byte.MinValue && v <= Byte.MaxValue)
+						return new ByteConstant ((byte) System.Math.Round (v));
+                                } else if (target_type == TypeManager.short_type){
+                                        if (v >= Int16.MinValue && v <= Int16.MaxValue)
+						return new ShortConstant ((short) System.Math.Round (v));
+                                } else if (target_type == TypeManager.ushort_type){
+                                        if (v >= UInt16.MinValue && v <= UInt16.MaxValue)
+						 return new UShortConstant ((ushort) System.Math.Round (v));
+				} else if (target_type == TypeManager.int32_type){
+                                        if (v >= Int32.MinValue && v <= Int32.MaxValue)
+						return new IntConstant ((int) System.Math.Round (v));
+                                } else if (target_type == TypeManager.uint32_type){
+                                        if (v >= 0 && v <= UInt32.MaxValue)
+						return new UIntConstant ((uint) System.Math.Round (v));
+                                } else if (target_type == TypeManager.uint64_type){
+                                        if (v > 0)
+						return new ULongConstant ((ulong) System.Math.Round (v));
+                                }
+                                s = v.ToString ();
+			}
+
+			Error_ConstantValueCannotBeConverted (loc, s, target_type);
+			return null;
+		}
+
+		//
+		// Load the object from the pointer.  
+		//
+		public static void LoadFromPtr (ILGenerator ig, Type t)
+		{
+			if (t == TypeManager.int32_type)
+				ig.Emit (OpCodes.Ldind_I4);
+			else if (t == TypeManager.uint32_type)
+				ig.Emit (OpCodes.Ldind_U4);
+			else if (t == TypeManager.short_type)
+				ig.Emit (OpCodes.Ldind_I2);
+			else if (t == TypeManager.ushort_type)
+				ig.Emit (OpCodes.Ldind_U2);
+			else if (t == TypeManager.char_type)
+				ig.Emit (OpCodes.Ldind_U2);
+			else if (t == TypeManager.byte_type)
+				ig.Emit (OpCodes.Ldind_U1);
+			else if (t == TypeManager.sbyte_type)
+				ig.Emit (OpCodes.Ldind_I1);
+			else if (t == TypeManager.uint64_type)
+				ig.Emit (OpCodes.Ldind_I8);
+			else if (t == TypeManager.int64_type)
+				ig.Emit (OpCodes.Ldind_I8);
+			else if (t == TypeManager.float_type)
+				ig.Emit (OpCodes.Ldind_R4);
+			else if (t == TypeManager.double_type)
+				ig.Emit (OpCodes.Ldind_R8);
+			else if (t == TypeManager.bool_type)
+				ig.Emit (OpCodes.Ldind_I1);
+			else if (t == TypeManager.intptr_type)
+				ig.Emit (OpCodes.Ldind_I);
+			else if (TypeManager.IsEnumType (t)) {
+				if (t == TypeManager.enum_type)
+					ig.Emit (OpCodes.Ldind_Ref);
+				else
+					LoadFromPtr (ig, TypeManager.EnumToUnderlying (t));
+			} else if (t.IsValueType)
+				ig.Emit (OpCodes.Ldobj, t);
+			else
+				ig.Emit (OpCodes.Ldind_Ref);
+		}
+
+		//
+		// The stack contains the pointer and the value of type 'type'
+		//
+		public static void StoreFromPtr (ILGenerator ig, Type type)
+		{
+			if (TypeManager.IsEnumType (type))
+				type = TypeManager.EnumToUnderlying (type);
+			if (type == TypeManager.int32_type || type == TypeManager.uint32_type)
+				ig.Emit (OpCodes.Stind_I4);
+			else if (type == TypeManager.int64_type || type == TypeManager.uint64_type)
+				ig.Emit (OpCodes.Stind_I8);
+			else if (type == TypeManager.char_type || type == TypeManager.short_type ||
+				 type == TypeManager.ushort_type)
+				ig.Emit (OpCodes.Stind_I2);
+			else if (type == TypeManager.float_type)
+				ig.Emit (OpCodes.Stind_R4);
+			else if (type == TypeManager.double_type)
+				ig.Emit (OpCodes.Stind_R8);
+			else if (type == TypeManager.byte_type || type == TypeManager.sbyte_type ||
+				 type == TypeManager.bool_type)
+				ig.Emit (OpCodes.Stind_I1);
+			else if (type == TypeManager.intptr_type)
+				ig.Emit (OpCodes.Stind_I);
+			else if (type.IsValueType)
+				ig.Emit (OpCodes.Stobj, type);
+			else
+				ig.Emit (OpCodes.Stind_Ref);
+		}
+		
+		//
+		// Returns the size of type 't' if known, otherwise, 0
+		//
+		public static int GetTypeSize (Type t)
+		{
+			t = TypeManager.TypeToCoreType (t);
+			if (t == TypeManager.int32_type ||
+			    t == TypeManager.uint32_type ||
+			    t == TypeManager.float_type)
+			        return 4;
+			else if (t == TypeManager.int64_type ||
+				 t == TypeManager.uint64_type ||
+				 t == TypeManager.double_type)
+			        return 8;
+			else if (t == TypeManager.byte_type ||
+				 t == TypeManager.sbyte_type ||
+				 t == TypeManager.bool_type) 	
+			        return 1;
+			else if (t == TypeManager.short_type ||
+				 t == TypeManager.char_type ||
+				 t == TypeManager.ushort_type)
+				return 2;
+			else if (t == TypeManager.decimal_type)
+				return 16;
+			else
+				return 0;
+		}
+
+		//
+		// Default implementation of IAssignMethod.CacheTemporaries
+		//
+		public void CacheTemporaries (EmitContext ec)
+		{
+		}
+
+		static void Error_NegativeArrayIndex (Location loc)
+		{
+			Report.Error (284, loc, "Can not create array with a negative size");
+		}
+		
+		//
+		// Converts 'source' to an int, uint, long or ulong.
+		//
+		public Expression ExpressionToArrayArgument (EmitContext ec, Expression source, Location loc)
+		{
+			Expression target;
+			
+			bool old_checked = ec.CheckState;
+			ec.CheckState = true;
+			
+			target = ConvertImplicit (ec, source, TypeManager.int32_type, loc);
+			if (target == null){
+				target = ConvertImplicit (ec, source, TypeManager.uint32_type, loc);
+				if (target == null){
+					target = ConvertImplicit (ec, source, TypeManager.int64_type, loc);
+					if (target == null){
+						target = ConvertImplicit (ec, source, TypeManager.uint64_type, loc);
+						if (target == null)
+							Expression.Error_CannotConvertImplicit (loc, source.Type, TypeManager.int32_type);
+					}
+				}
+			} 
+			ec.CheckState = old_checked;
+
+			//
+			// Only positive constants are allowed at compile time
+			//
+			if (target is Constant){
+				if (target is IntConstant){
+					if (((IntConstant) target).Value < 0){
+						Error_NegativeArrayIndex (loc);
+						return null;
+					}
+				}
+
+				if (target is LongConstant){
+					if (((LongConstant) target).Value < 0){
+						Error_NegativeArrayIndex (loc);
+						return null;
+					}
+				}
+				
+			}
+
+			return target;
+		}
+		
+	}
+
+	/// <summary>
+	///   This is just a base class for expressions that can
+	///   appear on statements (invocations, object creation,
+	///   assignments, post/pre increment and decrement).  The idea
+	///   being that they would support an extra Emition interface that
+	///   does not leave a result on the stack.
+	/// </summary>
+	public abstract class ExpressionStatement : Expression {
+
+		/// <summary>
+		///   Requests the expression to be emitted in a 'statement'
+		///   context.  This means that no new value is left on the
+		///   stack after invoking this method (constrasted with
+		///   Emit that will always leave a value on the stack).
+		/// </summary>
+		public abstract void EmitStatement (EmitContext ec);
+	}
+
+	/// <summary>
+	///   This kind of cast is used to encapsulate the child
+	///   whose type is child.Type into an expression that is
+	///   reported to return "return_type".  This is used to encapsulate
+	///   expressions which have compatible types, but need to be dealt
+	///   at higher levels with.
+	///
+	///   For example, a "byte" expression could be encapsulated in one
+	///   of these as an "unsigned int".  The type for the expression
+	///   would be "unsigned int".
+	///
+	/// </summary>
+	public class EmptyCast : Expression {
+		protected Expression child;
+
+		public EmptyCast (Expression child, Type return_type)
+		{
+			eclass = child.eclass;
+			type = return_type;
+			this.child = child;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			// This should never be invoked, we are born in fully
+			// initialized state.
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			child.Emit (ec);
+		}
+	}
+
+	/// <summary>
+	///  This class is used to wrap literals which belong inside Enums
+	/// </summary>
+	public class EnumConstant : Constant {
+		public Constant Child;
+
+		public EnumConstant (Constant child, Type enum_type)
+		{
+			eclass = child.eclass;
+			this.Child = child;
+			type = enum_type;
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			// This should never be invoked, we are born in fully
+			// initialized state.
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			Child.Emit (ec);
+		}
+
+		public override object GetValue ()
+		{
+			return Child.GetValue ();
+		}
+
+		//
+		// Converts from one of the valid underlying types for an enumeration
+		// (int32, uint32, int64, uint64, short, ushort, byte, sbyte) to
+		// one of the internal compiler literals: Int/UInt/Long/ULong Literals.
+		//
+		public Constant WidenToCompilerConstant ()
+		{
+			Type t = TypeManager.EnumToUnderlying (Child.Type);
+			object v = ((Constant) Child).GetValue ();;
+			
+			if (t == TypeManager.int32_type)
+				return new IntConstant ((int) v);
+			if (t == TypeManager.uint32_type)
+				return new UIntConstant ((uint) v);
+			if (t == TypeManager.int64_type)
+				return new LongConstant ((long) v);
+			if (t == TypeManager.uint64_type)
+				return new ULongConstant ((ulong) v);
+			if (t == TypeManager.short_type)
+				return new ShortConstant ((short) v);
+			if (t == TypeManager.ushort_type)
+				return new UShortConstant ((ushort) v);
+			if (t == TypeManager.byte_type)
+				return new ByteConstant ((byte) v);
+			if (t == TypeManager.sbyte_type)
+				return new SByteConstant ((sbyte) v);
+
+			throw new Exception ("Invalid enumeration underlying type: " + t);
+		}
+
+		//
+		// Extracts the value in the enumeration on its native representation
+		//
+		public object GetPlainValue ()
+		{
+			Type t = TypeManager.EnumToUnderlying (Child.Type);
+			object v = ((Constant) Child).GetValue ();;
+			
+			if (t == TypeManager.int32_type)
+				return (int) v;
+			if (t == TypeManager.uint32_type)
+				return (uint) v;
+			if (t == TypeManager.int64_type)
+				return (long) v;
+			if (t == TypeManager.uint64_type)
+				return (ulong) v;
+			if (t == TypeManager.short_type)
+				return (short) v;
+			if (t == TypeManager.ushort_type)
+				return (ushort) v;
+			if (t == TypeManager.byte_type)
+				return (byte) v;
+			if (t == TypeManager.sbyte_type)
+				return (sbyte) v;
+
+			return null;
+		}
+		
+		public override string AsString ()
+		{
+			return Child.AsString ();
+		}
+
+		public override DoubleConstant ConvertToDouble ()
+		{
+			return Child.ConvertToDouble ();
+		}
+
+		public override FloatConstant ConvertToFloat ()
+		{
+			return Child.ConvertToFloat ();
+		}
+
+		public override ULongConstant ConvertToULong ()
+		{
+			return Child.ConvertToULong ();
+		}
+
+		public override LongConstant ConvertToLong ()
+		{
+			return Child.ConvertToLong ();
+		}
+
+		public override UIntConstant ConvertToUInt ()
+		{
+			return Child.ConvertToUInt ();
+		}
+
+		public override IntConstant ConvertToInt ()
+		{
+			return Child.ConvertToInt ();
+		}
+	}
+
+	/// <summary>
+	///   This kind of cast is used to encapsulate Value Types in objects.
+	///
+	///   The effect of it is to box the value type emitted by the previous
+	///   operation.
+	/// </summary>
+	public class BoxedCast : EmptyCast {
+
+		public BoxedCast (Expression expr)
+			: base (expr, TypeManager.object_type)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			// This should never be invoked, we are born in fully
+			// initialized state.
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			base.Emit (ec);
+			
+			ec.ig.Emit (OpCodes.Box, child.Type);
+		}
+	}
+
+	public class UnboxCast : EmptyCast {
+		public UnboxCast (Expression expr, Type return_type)
+			: base (expr, return_type)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			// This should never be invoked, we are born in fully
+			// initialized state.
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			Type t = type;
+			ILGenerator ig = ec.ig;
+			
+			base.Emit (ec);
+			
+			ig.Emit (OpCodes.Dup);
+			Label unbox = ig.DefineLabel ();
+			ig.Emit (OpCodes.Brtrue, unbox);
+			ig.Emit (OpCodes.Pop);
+			ig.Emit (OpCodes.Ldtoken, t);
+			ig.Emit (OpCodes.Call, TypeManager.system_type_get_type_from_handle);
+			MethodInfo createInst =  Type.GetType("System.Activator").GetMethod ("CreateInstance", new Type[]{Type.GetType("System.Type")} );
+			ig.Emit (OpCodes.Call, createInst );
+			
+			ig.MarkLabel (unbox);		
+			ig.Emit (OpCodes.Unbox, t);
+
+			LoadFromPtr (ig, t);
+		}
+	}
+	
+	/// <summary>
+	///   This is used to perform explicit numeric conversions.
+	///
+	///   Explicit numeric conversions might trigger exceptions in a checked
+	///   context, so they should generate the conv.ovf opcodes instead of
+	///   conv opcodes.
+	/// </summary>
+	public class ConvCast : EmptyCast {
+		public enum Mode : byte {
+			I1_U1, I1_U2, I1_U4, I1_U8, I1_CH,
+			U1_I1, U1_CH,
+			I2_I1, I2_U1, I2_U2, I2_U4, I2_U8, I2_CH,
+			U2_I1, U2_U1, U2_I2, U2_CH,
+			I4_I1, I4_U1, I4_I2, I4_U2, I4_U4, I4_U8, I4_CH,
+			U4_I1, U4_U1, U4_I2, U4_U2, U4_I4, U4_CH,
+			I8_I1, I8_U1, I8_I2, I8_U2, I8_I4, I8_U4, I8_U8, I8_CH,
+			U8_I1, U8_U1, U8_I2, U8_U2, U8_I4, U8_U4, U8_I8, U8_CH,
+			CH_I1, CH_U1, CH_I2,
+			R4_I1, R4_U1, R4_I2, R4_U2, R4_I4, R4_U4, R4_I8, R4_U8, R4_CH,
+			R8_I1, R8_U1, R8_I2, R8_U2, R8_I4, R8_U4, R8_I8, R8_U8, R8_CH, R8_R4
+		}
+
+		Mode mode;
+		bool checked_state;
+		
+		public ConvCast (EmitContext ec, Expression child, Type return_type, Mode m)
+			: base (child, return_type)
+		{
+			checked_state = ec.CheckState;
+			mode = m;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			// This should never be invoked, we are born in fully
+			// initialized state.
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			
+			base.Emit (ec);
+
+			if (checked_state){
+				switch (mode){
+				case Mode.I1_U1: ig.Emit (OpCodes.Conv_Ovf_U1); break;
+				case Mode.I1_U2: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+				case Mode.I1_U4: ig.Emit (OpCodes.Conv_Ovf_U4); break;
+				case Mode.I1_U8: ig.Emit (OpCodes.Conv_Ovf_U8); break;
+				case Mode.I1_CH: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+
+				case Mode.U1_I1: ig.Emit (OpCodes.Conv_Ovf_I1_Un); break;
+				case Mode.U1_CH: /* nothing */ break;
+
+				case Mode.I2_I1: ig.Emit (OpCodes.Conv_Ovf_I1); break;
+				case Mode.I2_U1: ig.Emit (OpCodes.Conv_Ovf_U1); break;
+				case Mode.I2_U2: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+				case Mode.I2_U4: ig.Emit (OpCodes.Conv_Ovf_U4); break;
+				case Mode.I2_U8: ig.Emit (OpCodes.Conv_Ovf_U8); break;
+				case Mode.I2_CH: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+
+				case Mode.U2_I1: ig.Emit (OpCodes.Conv_Ovf_I1_Un); break;
+				case Mode.U2_U1: ig.Emit (OpCodes.Conv_Ovf_U1_Un); break;
+				case Mode.U2_I2: ig.Emit (OpCodes.Conv_Ovf_I2_Un); break;
+				case Mode.U2_CH: /* nothing */ break;
+
+				case Mode.I4_I1: ig.Emit (OpCodes.Conv_Ovf_I1); break;
+				case Mode.I4_U1: ig.Emit (OpCodes.Conv_Ovf_U1); break;
+				case Mode.I4_I2: ig.Emit (OpCodes.Conv_Ovf_I2); break;
+				case Mode.I4_U4: ig.Emit (OpCodes.Conv_Ovf_U4); break;
+				case Mode.I4_U2: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+				case Mode.I4_U8: ig.Emit (OpCodes.Conv_Ovf_U8); break;
+				case Mode.I4_CH: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+
+				case Mode.U4_I1: ig.Emit (OpCodes.Conv_Ovf_I1_Un); break;
+				case Mode.U4_U1: ig.Emit (OpCodes.Conv_Ovf_U1_Un); break;
+				case Mode.U4_I2: ig.Emit (OpCodes.Conv_Ovf_I2_Un); break;
+				case Mode.U4_U2: ig.Emit (OpCodes.Conv_Ovf_U2_Un); break;
+				case Mode.U4_I4: ig.Emit (OpCodes.Conv_Ovf_I4_Un); break;
+				case Mode.U4_CH: ig.Emit (OpCodes.Conv_Ovf_U2_Un); break;
+
+				case Mode.I8_I1: ig.Emit (OpCodes.Conv_Ovf_I1); break;
+				case Mode.I8_U1: ig.Emit (OpCodes.Conv_Ovf_U1); break;
+				case Mode.I8_I2: ig.Emit (OpCodes.Conv_Ovf_I2); break;
+				case Mode.I8_U2: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+				case Mode.I8_I4: ig.Emit (OpCodes.Conv_Ovf_I4); break;
+				case Mode.I8_U4: ig.Emit (OpCodes.Conv_Ovf_U4); break;
+				case Mode.I8_U8: ig.Emit (OpCodes.Conv_Ovf_U8); break;
+				case Mode.I8_CH: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+
+				case Mode.U8_I1: ig.Emit (OpCodes.Conv_Ovf_I1_Un); break;
+				case Mode.U8_U1: ig.Emit (OpCodes.Conv_Ovf_U1_Un); break;
+				case Mode.U8_I2: ig.Emit (OpCodes.Conv_Ovf_I2_Un); break;
+				case Mode.U8_U2: ig.Emit (OpCodes.Conv_Ovf_U2_Un); break;
+				case Mode.U8_I4: ig.Emit (OpCodes.Conv_Ovf_I4_Un); break;
+				case Mode.U8_U4: ig.Emit (OpCodes.Conv_Ovf_U4_Un); break;
+				case Mode.U8_I8: ig.Emit (OpCodes.Conv_Ovf_I8_Un); break;
+				case Mode.U8_CH: ig.Emit (OpCodes.Conv_Ovf_U2_Un); break;
+
+				case Mode.CH_I1: ig.Emit (OpCodes.Conv_Ovf_I1_Un); break;
+				case Mode.CH_U1: ig.Emit (OpCodes.Conv_Ovf_U1_Un); break;
+				case Mode.CH_I2: ig.Emit (OpCodes.Conv_Ovf_I2_Un); break;
+
+				case Mode.R4_I1: ig.Emit (OpCodes.Conv_Ovf_I1); break;
+				case Mode.R4_U1: ig.Emit (OpCodes.Conv_Ovf_U1); break;
+				case Mode.R4_I2: ig.Emit (OpCodes.Conv_Ovf_I2); break;
+				case Mode.R4_U2: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+				case Mode.R4_I4: ig.Emit (OpCodes.Conv_Ovf_I4); break;
+				case Mode.R4_U4: ig.Emit (OpCodes.Conv_Ovf_U4); break;
+				case Mode.R4_I8: ig.Emit (OpCodes.Conv_Ovf_I8); break;
+				case Mode.R4_U8: ig.Emit (OpCodes.Conv_Ovf_U8); break;
+				case Mode.R4_CH: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+
+				case Mode.R8_I1: ig.Emit (OpCodes.Conv_Ovf_I1); break;
+				case Mode.R8_U1: ig.Emit (OpCodes.Conv_Ovf_U1); break;
+				case Mode.R8_I2: ig.Emit (OpCodes.Conv_Ovf_I2); break;
+				case Mode.R8_U2: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+				case Mode.R8_I4: ig.Emit (OpCodes.Conv_Ovf_I4); break;
+				case Mode.R8_U4: ig.Emit (OpCodes.Conv_Ovf_U4); break;
+				case Mode.R8_I8: ig.Emit (OpCodes.Conv_Ovf_I8); break;
+				case Mode.R8_U8: ig.Emit (OpCodes.Conv_Ovf_U8); break;
+				case Mode.R8_CH: ig.Emit (OpCodes.Conv_Ovf_U2); break;
+				case Mode.R8_R4: ig.Emit (OpCodes.Conv_R4); break;
+				}
+			} else {
+				switch (mode){
+				case Mode.I1_U1: ig.Emit (OpCodes.Conv_U1); break;
+				case Mode.I1_U2: ig.Emit (OpCodes.Conv_U2); break;
+				case Mode.I1_U4: ig.Emit (OpCodes.Conv_U4); break;
+				case Mode.I1_U8: ig.Emit (OpCodes.Conv_I8); break;
+				case Mode.I1_CH: ig.Emit (OpCodes.Conv_U2); break;
+
+				case Mode.U1_I1: ig.Emit (OpCodes.Conv_I1); break;
+				case Mode.U1_CH: ig.Emit (OpCodes.Conv_U2); break;
+
+				case Mode.I2_I1: ig.Emit (OpCodes.Conv_I1); break;
+				case Mode.I2_U1: ig.Emit (OpCodes.Conv_U1); break;
+				case Mode.I2_U2: ig.Emit (OpCodes.Conv_U2); break;
+				case Mode.I2_U4: ig.Emit (OpCodes.Conv_U4); break;
+				case Mode.I2_U8: ig.Emit (OpCodes.Conv_I8); break;
+				case Mode.I2_CH: ig.Emit (OpCodes.Conv_U2); break;
+
+				case Mode.U2_I1: ig.Emit (OpCodes.Conv_I1); break;
+				case Mode.U2_U1: ig.Emit (OpCodes.Conv_U1); break;
+				case Mode.U2_I2: ig.Emit (OpCodes.Conv_I2); break;
+				case Mode.U2_CH: /* nothing */ break;
+
+				case Mode.I4_I1: ig.Emit (OpCodes.Conv_I1); break;
+				case Mode.I4_U1: ig.Emit (OpCodes.Conv_U1); break;
+				case Mode.I4_I2: ig.Emit (OpCodes.Conv_I2); break;
+				case Mode.I4_U4: /* nothing */ break;
+				case Mode.I4_U2: ig.Emit (OpCodes.Conv_U2); break;
+				case Mode.I4_U8: ig.Emit (OpCodes.Conv_I8); break;
+				case Mode.I4_CH: ig.Emit (OpCodes.Conv_U2); break;
+
+				case Mode.U4_I1: ig.Emit (OpCodes.Conv_I1); break;
+				case Mode.U4_U1: ig.Emit (OpCodes.Conv_U1); break;
+				case Mode.U4_I2: ig.Emit (OpCodes.Conv_I2); break;
+				case Mode.U4_U2: ig.Emit (OpCodes.Conv_U2); break;
+				case Mode.U4_I4: /* nothing */ break;
+				case Mode.U4_CH: ig.Emit (OpCodes.Conv_U2); break;
+
+				case Mode.I8_I1: ig.Emit (OpCodes.Conv_I1); break;
+				case Mode.I8_U1: ig.Emit (OpCodes.Conv_U1); break;
+				case Mode.I8_I2: ig.Emit (OpCodes.Conv_I2); break;
+				case Mode.I8_U2: ig.Emit (OpCodes.Conv_U2); break;
+				case Mode.I8_I4: ig.Emit (OpCodes.Conv_I4); break;
+				case Mode.I8_U4: ig.Emit (OpCodes.Conv_U4); break;
+				case Mode.I8_U8: /* nothing */ break;
+				case Mode.I8_CH: ig.Emit (OpCodes.Conv_U2); break;
+
+				case Mode.U8_I1: ig.Emit (OpCodes.Conv_I1); break;
+				case Mode.U8_U1: ig.Emit (OpCodes.Conv_U1); break;
+				case Mode.U8_I2: ig.Emit (OpCodes.Conv_I2); break;
+				case Mode.U8_U2: ig.Emit (OpCodes.Conv_U2); break;
+				case Mode.U8_I4: ig.Emit (OpCodes.Conv_I4); break;
+				case Mode.U8_U4: ig.Emit (OpCodes.Conv_U4); break;
+				case Mode.U8_I8: /* nothing */ break;
+				case Mode.U8_CH: ig.Emit (OpCodes.Conv_U2); break;
+
+				case Mode.CH_I1: ig.Emit (OpCodes.Conv_I1); break;
+				case Mode.CH_U1: ig.Emit (OpCodes.Conv_U1); break;
+				case Mode.CH_I2: ig.Emit (OpCodes.Conv_I2); break;
+
+				case Mode.R4_I1: ig.Emit (OpCodes.Conv_I1); break;
+				case Mode.R4_U1: ig.Emit (OpCodes.Conv_U1); break;
+				case Mode.R4_I2: ig.Emit (OpCodes.Conv_I2); break;
+				case Mode.R4_U2: ig.Emit (OpCodes.Conv_U2); break;
+				case Mode.R4_I4: ig.Emit (OpCodes.Conv_I4); break;
+				case Mode.R4_U4: ig.Emit (OpCodes.Conv_U4); break;
+				case Mode.R4_I8: ig.Emit (OpCodes.Conv_I8); break;
+				case Mode.R4_U8: ig.Emit (OpCodes.Conv_U8); break;
+				case Mode.R4_CH: ig.Emit (OpCodes.Conv_U2); break;
+
+				case Mode.R8_I1: ig.Emit (OpCodes.Conv_I1); break;
+				case Mode.R8_U1: ig.Emit (OpCodes.Conv_U1); break;
+				case Mode.R8_I2: ig.Emit (OpCodes.Conv_I2); break;
+				case Mode.R8_U2: ig.Emit (OpCodes.Conv_U2); break;
+				case Mode.R8_I4: ig.Emit (OpCodes.Conv_I4); break;
+				case Mode.R8_U4: ig.Emit (OpCodes.Conv_U4); break;
+				case Mode.R8_I8: ig.Emit (OpCodes.Conv_I8); break;
+				case Mode.R8_U8: ig.Emit (OpCodes.Conv_U8); break;
+				case Mode.R8_CH: ig.Emit (OpCodes.Conv_U2); break;
+				case Mode.R8_R4: ig.Emit (OpCodes.Conv_R4); break;
+				}
+			}
+		}
+	}
+	
+	public class OpcodeCast : EmptyCast {
+		OpCode op, op2;
+		bool second_valid;
+		
+		public OpcodeCast (Expression child, Type return_type, OpCode op)
+			: base (child, return_type)
+			
+		{
+			this.op = op;
+			second_valid = false;
+		}
+
+		public OpcodeCast (Expression child, Type return_type, OpCode op, OpCode op2)
+			: base (child, return_type)
+			
+		{
+			this.op = op;
+			this.op2 = op2;
+			second_valid = true;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			// This should never be invoked, we are born in fully
+			// initialized state.
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			base.Emit (ec);
+			ec.ig.Emit (op);
+
+			if (second_valid)
+				ec.ig.Emit (op2);
+		}			
+	}
+
+
+	public class NumericToBoolCast : EmptyCast 
+	{
+		Type src_type;
+		
+		public NumericToBoolCast (Expression src, Type src_type)
+			: base (src, TypeManager.bool_type)
+			
+		{
+			this.src_type = src_type;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			base.Emit (ec);
+
+			if (src_type == TypeManager.byte_type ||
+				src_type == TypeManager.short_type ||
+				src_type == TypeManager.int32_type) {
+				
+				ec.ig.Emit (OpCodes.Ldc_I4_0);
+				ec.ig.Emit (OpCodes.Cgt_Un);
+				return;
+			} 
+
+			if (src_type == TypeManager.int64_type) {
+				ec.ig.Emit (OpCodes.Ldc_I8, (long) 0);
+				ec.ig.Emit (OpCodes.Cgt_Un);
+				return;
+			} 
+
+			if (src_type == TypeManager.float_type) {
+				ec.ig.Emit (OpCodes.Ldc_R4, (float) 0);
+				ec.ig.Emit (OpCodes.Ceq);
+				ec.ig.Emit (OpCodes.Ldc_I4_0);
+				ec.ig.Emit (OpCodes.Ceq);
+				return;
+			} 
+
+			if (src_type == TypeManager.double_type) {
+				ec.ig.Emit (OpCodes.Ldc_R8, (double) 0);
+				ec.ig.Emit (OpCodes.Ceq);
+				ec.ig.Emit (OpCodes.Ldc_I4_0);
+				ec.ig.Emit (OpCodes.Ceq);
+				return;
+			}
+		}			
+	}
+
+	public class BoolToNumericCast : EmptyCast 
+	{
+		Type target_type;
+		OpCode conv;
+		
+		public BoolToNumericCast (Expression src, Type target_type)
+			: base (src, target_type)
+			
+		{
+			this.target_type = target_type;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			base.Emit (ec);
+
+			if (target_type == TypeManager.byte_type) {
+				conv = OpCodes.Conv_U1;
+			} else if (target_type == TypeManager.short_type) {
+				conv = OpCodes.Conv_I2;
+			} else if (target_type == TypeManager.int32_type) {
+				conv = OpCodes.Conv_I4;
+			} else if (target_type == TypeManager.int64_type) {
+				conv = OpCodes.Conv_I8;
+			} else if (target_type == TypeManager.float_type) {
+				conv = OpCodes.Conv_R4;
+			} else if (target_type == TypeManager.double_type) {
+				conv = OpCodes.Conv_R8;
+			}
+
+			ec.ig.Emit (OpCodes.Ldc_I4_0);
+			ec.ig.Emit (OpCodes.Cgt_Un);
+			ec.ig.Emit (OpCodes.Neg);
+			ec.ig.Emit (conv);
+			return;
+		}			
+	}
+
+	/// <summary>
+	///   This kind of cast is used to encapsulate a child and cast it
+	///   to the class requested
+	/// </summary>
+	public class ClassCast : EmptyCast {
+		public ClassCast (Expression child, Type return_type)
+			: base (child, return_type)
+			
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			// This should never be invoked, we are born in fully
+			// initialized state.
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			base.Emit (ec);
+
+			ec.ig.Emit (OpCodes.Castclass, type);
+		}			
+		
+	}
+	
+	/// <summary>
+	///   SimpleName expressions are initially formed of a single
+	///   word and it only happens at the beginning of the expression.
+	/// </summary>
+	///
+	/// <remarks>
+	///   The expression will try to be bound to a Field, a Method
+	///   group or a Property.  If those fail we pass the name to our
+	///   caller and the SimpleName is compounded to perform a type
+	///   lookup.  The idea behind this process is that we want to avoid
+	///   creating a namespace map from the assemblies, as that requires
+	///   the GetExportedTypes function to be called and a hashtable to
+	///   be constructed which reduces startup time.  If later we find
+	///   that this is slower, we should create a 'NamespaceExpr' expression
+	///   that fully participates in the resolution process. 
+	///   
+	///   For example 'System.Console.WriteLine' is decomposed into
+	///   MemberAccess (MemberAccess (SimpleName ("System"), "Console"), "WriteLine")
+	///   
+	///   The first SimpleName wont produce a match on its own, so it will
+	///   be turned into:
+	///   MemberAccess (SimpleName ("System.Console"), "WriteLine").
+	///   
+	///   System.Console will produce a TypeExpr match.
+	///   
+	///   The downside of this is that we might be hitting 'LookupType' too many
+	///   times with this scheme.
+	/// </remarks>
+	public class SimpleName : Expression, ITypeExpression {
+		public readonly string Name;
+		bool is_invocation = false;
+		bool is_addressof = false;
+
+		public bool IsInvocation {
+			set {
+				is_invocation = value;
+			}
+		}
+
+		public bool IsAddressOf {
+			set {
+				is_addressof = value;
+			}
+		}
+		
+		public SimpleName (string name, Location l)
+		{
+			Name = name;
+			loc = l;
+		}
+
+		public static void Error_ObjectRefRequired (EmitContext ec, Location l, string name)
+		{
+			if (ec.IsFieldInitializer)
+				Report.Error (
+					236, l,
+					"A field initializer cannot reference the non-static field, " +
+					"method or property '"+name+"'");
+			else
+				Report.Error (
+					120, l,
+					"An object reference is required " +
+					"for the non-static field '"+name+"'");
+		}
+		
+		//
+		// Checks whether we are trying to access an instance
+		// property, method or field from a static body.
+		//
+		Expression MemberStaticCheck (EmitContext ec, Expression e)
+		{
+			if (e is IMemberExpr){
+				IMemberExpr member = (IMemberExpr) e;
+				
+				if (!member.IsStatic){
+					Error_ObjectRefRequired (ec, loc, Name);
+					return null;
+				}
+			}
+
+			return e;
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			return SimpleNameResolve (ec, null, false);
+		}
+
+		public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			return SimpleNameResolve (ec, right_side, false);
+		}
+		
+
+		public Expression DoResolveAllowStatic (EmitContext ec)
+		{
+			return SimpleNameResolve (ec, null, true);
+		}
+
+		public Expression DoResolveType (EmitContext ec)
+		{
+			//
+			// Stage 3: Lookup symbol in the various namespaces. 
+			//
+			DeclSpace ds = ec.DeclSpace;
+			Type t;
+			string alias_value;
+
+			if (ec.ResolvingTypeTree){
+				int errors = Report.Errors;
+				Type dt = ec.DeclSpace.FindType (loc, Name);
+				if (Report.Errors != errors)
+					return null;
+				
+				if (dt != null)
+					return new TypeExpr (dt, loc);
+			}
+
+			if ((t = RootContext.LookupType (ds, Name, true, loc)) != null)
+				return new TypeExpr (t, loc);
+				
+
+			//
+			// Stage 2 part b: Lookup up if we are an alias to a type
+			// or a namespace.
+			//
+			// Since we are cheating: we only do the Alias lookup for
+			// namespaces if the name does not include any dots in it
+			//
+				
+			alias_value = ec.DeclSpace.LookupAlias (Name);
+				
+			if (Name.IndexOf ('.') == -1 && alias_value != null) {
+				if ((t = RootContext.LookupType (ds, alias_value, true, loc)) != null)
+					return new TypeExpr (t, loc);
+					
+				// we have alias value, but it isn't Type, so try if it's namespace
+				return new SimpleName (alias_value, loc);
+			}
+				
+			// No match, maybe our parent can compose us
+			// into something meaningful.
+			return this;
+		}
+
+		/// <remarks>
+		///   7.5.2: Simple Names. 
+		///
+		///   Local Variables and Parameters are handled at
+		///   parse time, so they never occur as SimpleNames.
+		///
+		///   The 'allow_static' flag is used by MemberAccess only
+		///   and it is used to inform us that it is ok for us to 
+		///   avoid the static check, because MemberAccess might end
+		///   up resolving the Name as a Type name and the access as
+		///   a static type access.
+		///
+		///   ie: Type Type; .... { Type.GetType (""); }
+		///
+		///   Type is both an instance variable and a Type;  Type.GetType
+		///   is the static method not an instance method of type.
+		/// </remarks>
+		Expression SimpleNameResolve (EmitContext ec, Expression right_side, bool allow_static)
+		{
+			Expression e = null;
+			
+			//
+			// Stage 1: Performed by the parser (binding to locals or parameters).
+			//
+			Block current_block = ec.CurrentBlock;
+			if (ec.InvokingOwnOverload == false && current_block != null && current_block.IsVariableDefined (Name)){
+				LocalVariableReference var;
+
+				var = new LocalVariableReference (current_block, Name, loc);
+
+				if (right_side != null)
+					return var.ResolveLValue (ec, right_side);
+				else
+					return var.Resolve (ec);
+			}
+
+			if (current_block != null){
+				int idx = -1;
+				Parameter par = null;
+				Parameters pars = current_block.Parameters;
+				if (pars != null)
+					par = pars.GetParameterByName (Name, out idx);
+
+				if (par != null) {
+					ParameterReference param;
+					
+					param = new ParameterReference (pars, idx, Name, loc);
+
+					if (right_side != null)
+						return param.ResolveLValue (ec, right_side);
+					else
+						return param.Resolve (ec);
+				}
+			}
+
+			//
+			// Stage 2: Lookup members 
+			//
+
+			//
+			// For enums, the TypeBuilder is not ec.DeclSpace.TypeBuilder
+			// Hence we have two different cases
+			//
+
+			DeclSpace lookup_ds = ec.DeclSpace;
+			do {
+				if (lookup_ds.TypeBuilder == null)
+					break;
+
+				e = MemberLookup (ec, lookup_ds.TypeBuilder, Name, loc);
+				if (e != null)
+					break;
+
+				//
+				// Classes/structs keep looking, enums break
+				//
+				if (lookup_ds is TypeContainer)
+					lookup_ds = ((TypeContainer) lookup_ds).Parent;
+				else
+					break;
+			} while (lookup_ds != null);
+				
+			if (e == null && ec.ContainerType != null)
+				e = MemberLookup (ec, ec.ContainerType, Name, loc);
+
+// #52067 - Start - Trying to solve
+
+			if (e == null) {
+				ArrayList lookups = new ArrayList();
+				ArrayList typelookups = new ArrayList();
+				
+				int split = Name.LastIndexOf('.');
+				if (split != -1) {
+					String nameSpacePart = Name.Substring(0, split);
+					String memberNamePart = Name.Substring(split + 1);
+					foreach(Type type in TypeManager.GetPertinentStandardModules(nameSpacePart)) {
+						e = MemberLookup(ec, type, memberNamePart, loc);
+						if (e != null) {
+							lookups.Add(e);
+							typelookups.Add(type);
+						}
+					}
+				}
+				
+				string[] NamespacesInScope = RootContext.SourceBeingCompiled.GetNamespacesInScope(ec.DeclSpace.Namespace.Name);
+				foreach(Type type in TypeManager.GetPertinentStandardModules(NamespacesInScope)) {
+					e = MemberLookup(ec, type, Name, loc);
+					if (e != null) {
+						lookups.Add(e);
+						typelookups.Add(type);
+					}
+				}
+				if (lookups.Count == 1) { 
+					e = (Expression)lookups[0];
+				} else {
+					if (lookups.Count > 1) {
+						StringBuilder sb = new StringBuilder();
+						foreach(Type type in typelookups)
+							sb.Append("'" + type.FullName + "'");						
+						Error (-1, "The name '" + Name + "' can be resolved to a member of more than one standard module: " + sb.ToString() + ". Please fully qualify it.");
+						return null;
+					}
+				}
+			}
+
+// #52067 - End
+
+			if (e == null) {
+			
+		/* preparing to support automatic definition of variables on first usage with Option Explicit Off
+			
+			Isn't good enough to enable just now (tries to define some internal links and breaks on emit)
+			
+				if (Name.IndexOf ('.') == -1 && current_block != null && !Mono.MonoBASIC.Parser.OptionExplicit) {
+				
+					// while looking for a real solution
+					if (Name != "anything")
+						return DoResolveType (ec);
+						
+					Console.WriteLine("Implicitly adding a variable named '{0}'", Name);
+					
+					// TODO: look at type-suffixes to correct name and type
+					Expression type = Mono.MonoBASIC.Parser.DecomposeQI("System.Object", loc);
+					
+					current_block.AddVariable(ec, type, Name, loc);
+				
+					LocalVariableReference var = new LocalVariableReference (current_block, Name, loc);
+					if (right_side != null)
+						return var.ResolveLValue (ec, right_side);
+					else
+						return var.Resolve (ec);
+				} else
+		*/
+					return DoResolveType (ec);
+			}
+			
+			if (e is TypeExpr)
+				return e;
+
+			if (e is IMemberExpr) {
+				if ((e is MethodGroupExpr) && !is_invocation && !is_addressof) {
+					Expression inv = new Invocation (this, new ArrayList (), loc);
+					return inv.Resolve (ec);
+				}
+				e = MemberAccess.ResolveMemberAccess (ec, e, null, loc, this);
+				if (e == null)
+					return null;
+
+				if (e is PropertyGroupExpr && is_invocation) // We dont know the arguments yet
+					return e;
+
+				IMemberExpr me = e as IMemberExpr;
+				if (me == null)
+					return e;
+
+				// This fails if ResolveMemberAccess() was unable to decide whether
+				// it's a field or a type of the same name.
+				if (!me.IsStatic && (me.InstanceExpression == null))
+					return e;
+
+/* FIXME    If this is not commented out, it seems that it's not possible to reach class members in mBas.
+            Maybe a grammar-related problem?
+
+				if (!me.IsStatic &&
+				    TypeManager.IsNestedChildOf (me.InstanceExpression.Type, me.DeclaringType)) {
+					Error (38, "Cannot access nonstatic member '" + me.Name + "' of " +
+					       "outer type '" + me.DeclaringType + "' via nested type '" +
+					       me.InstanceExpression.Type + "'");
+					return null;
+				}
+*/
+				bool isPropertyGroup = (e is PropertyGroupExpr);
+				if (right_side != null)
+					e = e.DoResolveLValue (ec, right_side);
+				else
+					e = e.DoResolve (ec);
+
+				if (e == null && isPropertyGroup && !is_invocation)
+					 Error (30057, "Property '" + Name + "' cannot be invoked with given arguments");
+					 
+				return e;
+			}
+
+			if (ec.IsStatic || ec.IsFieldInitializer) {
+				if (allow_static)
+					return e;
+
+				return MemberStaticCheck (ec, e);
+			}
+
+			return e;
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			//
+			// If this is ever reached, then we failed to
+			// find the name as a namespace
+			//
+
+			Error (30451, "The name '" + Name +
+			       "' does not exist in the class '" +
+			       ec.DeclSpace.Name + "'");
+		}
+
+		public override string ToString ()
+		{
+			return Name;
+		}
+	}
+
+	public class DecoratedIdentifier : Expression {
+		Expression id;
+		Type decoration;
+
+		public Expression Id
+		{
+			get
+			{
+				return this.id;
+			}
+		}
+		
+		public DecoratedIdentifier (Expression id, Type decoration)
+		{
+			this.id = id;
+			this.decoration = decoration;
+		}
+
+		override public Expression DoResolve (EmitContext ec)
+		{
+			if (id == null || decoration == null)
+				return null;
+			
+			Expression ret = id.DoResolve (ec);
+			if (ret.Type != TypeManager.TypeToCoreType (decoration)) {
+				Report.Error (30277, id.Location, "Type character '" + decoration + "' does not match declared type '" + ret.Type  + "'."); 
+				return null;
+			}
+
+			return ret;
+		}
+		
+		override public void Emit (EmitContext ec)
+		{
+			throw new InternalErrorException ("Should never be called");
+		}
+	}
+	
+	/// <summary>
+	///   Fully resolved expression that evaluates to a type
+	/// </summary>
+	public class TypeExpr : Expression, ITypeExpression {
+		public TypeExpr (Type t, Location l)
+		{
+			Type = t;
+			eclass = ExprClass.Type;
+			loc = l;
+		}
+
+		public virtual Expression DoResolveType (EmitContext ec)
+		{
+			return this;
+		}
+
+		override public Expression DoResolve (EmitContext ec)
+		{
+			return this;
+		}
+
+		override public void Emit (EmitContext ec)
+		{
+			throw new Exception ("Should never be called");
+		}
+
+		public override string ToString ()
+		{
+			return Type.ToString ();
+		}
+	}
+
+	/// <summary>
+	///   Used to create types from a fully qualified name.  These are just used
+	///   by the parser to setup the core types.  A TypeLookupExpression is always
+	///   classified as a type.
+	/// </summary>
+	public class TypeLookupExpression : TypeExpr {
+		string name;
+		
+		public TypeLookupExpression (string name) : base (null, Location.Null)
+		{
+			this.name = name;
+		}
+
+		public override Expression DoResolveType (EmitContext ec)
+		{
+			if (type == null)
+				type = RootContext.LookupType (ec.DeclSpace, name, false, Location.Null);
+			return this;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			return DoResolveType (ec);
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			throw new Exception ("Should never be called");
+		}
+
+		public override string ToString ()
+		{
+			return name;
+		}
+	}
+
+	/// <summary>
+	///   MethodGroup Expression.
+	///  
+	///   This is a fully resolved expression that evaluates to a type
+	/// </summary>
+	public class MethodGroupExpr : Expression, IMemberExpr {
+		public MethodBase [] Methods;
+		Expression instance_expression = null;
+		bool is_explicit_impl = false;
+		
+		public MethodGroupExpr (MemberInfo [] mi, Location l)
+		{
+			Methods = new MethodBase [mi.Length];
+			mi.CopyTo (Methods, 0);
+			eclass = ExprClass.MethodGroup;
+			type = TypeManager.object_type;
+			loc = l;
+		}
+
+		public MethodGroupExpr (ArrayList list, Location l)
+		{
+			Methods = new MethodBase [list.Count];
+
+			try {
+				list.CopyTo (Methods, 0);
+			} catch {
+				foreach (MemberInfo m in list){
+					if (!(m is MethodBase)){
+						Console.WriteLine ("Name " + m.Name);
+						Console.WriteLine ("Found a: " + m.GetType ().FullName);
+					}
+				}
+				throw;
+			}
+			loc = l;
+			eclass = ExprClass.MethodGroup;
+			type = TypeManager.object_type;
+		}
+
+		public Type DeclaringType {
+			get {
+				return Methods [0].DeclaringType;
+			}
+		}
+		
+		//
+		// 'A method group may have associated an instance expression' 
+		// 
+		public Expression InstanceExpression {
+			get {
+				return instance_expression;
+			}
+
+			set {
+				instance_expression = value;
+			}
+		}
+
+		public bool IsExplicitImpl {
+			get {
+				return is_explicit_impl;
+			}
+
+			set {
+				is_explicit_impl = value;
+			}
+		}
+
+		public string Name {
+			get {
+				return Methods [0].Name;
+			}
+		}
+
+		public bool IsInstance {
+			get {
+				foreach (MethodBase mb in Methods)
+					if (!mb.IsStatic)
+						return true;
+
+				return false;
+			}
+		}
+
+		public bool IsStatic {
+			get {
+				foreach (MethodBase mb in Methods)
+					if (mb.IsStatic)
+						return true;
+
+				return false;
+			}
+		}
+		
+		override public Expression DoResolve (EmitContext ec)
+		{
+			if (instance_expression != null) {
+				instance_expression = instance_expression.DoResolve (ec);
+				if (instance_expression == null)
+					return null;
+			}
+
+			return this;
+		}
+
+		public void ReportUsageError ()
+		{
+			Report.Error (654, loc, "Method '" + Methods [0].DeclaringType + "." +
+				      Methods [0].Name + "()' is referenced without parentheses");
+		}
+
+		override public void Emit (EmitContext ec)
+		{
+			ReportUsageError ();
+		}
+
+		bool RemoveMethods (bool keep_static)
+		{
+			ArrayList smethods = new ArrayList ();
+
+			foreach (MethodBase mb in Methods){
+				if (mb.IsStatic == keep_static)
+					smethods.Add (mb);
+			}
+
+			if (smethods.Count == 0)
+				return false;
+
+			Methods = new MethodBase [smethods.Count];
+			smethods.CopyTo (Methods, 0);
+
+			return true;
+		}
+		
+		/// <summary>
+		///   Removes any instance methods from the MethodGroup, returns
+		///   false if the resulting set is empty.
+		/// </summary>
+		public bool RemoveInstanceMethods ()
+		{
+			return RemoveMethods (true);
+		}
+
+		/// <summary>
+		///   Removes any static methods from the MethodGroup, returns
+		///   false if the resulting set is empty.
+		/// </summary>
+		public bool RemoveStaticMethods ()
+		{
+			return RemoveMethods (false);
+		}
+	}
+
+	/// <summary>
+	///   Property Group Expression.
+	///  
+	/// </summary>
+	public class PropertyGroupExpr : ExpressionStatement, IMemberExpr {
+		public PropertyInfo [] Properties;
+		Expression instance_expression = null;
+		bool is_explicit_impl = false;
+		MethodBase method = null;
+		bool indexer_access_req = false;
+		ArrayList arguments = null;
+		
+		public PropertyGroupExpr (MemberInfo [] mi, Location l)
+		{
+			Properties = new PropertyInfo [mi.Length];
+			mi.CopyTo (Properties, 0);
+			eclass = ExprClass.PropertyAccess;
+			type = TypeManager.object_type;
+			loc = l;
+		}
+
+		public PropertyGroupExpr (MemberInfo [] mi, ArrayList args, Expression expr, Location l)
+			: this (mi, l)
+		{
+			arguments = args;
+			instance_expression = expr;
+		}
+
+		public PropertyGroupExpr (ArrayList list, Location l)
+		{
+			Properties = new PropertyInfo [list.Count];
+
+			try {
+				list.CopyTo (Properties, 0);
+			} catch {
+				foreach (MemberInfo m in list){
+					if (!(m is PropertyInfo)){
+						Console.WriteLine ("Name " + m.Name);
+						Console.WriteLine ("Found a: " + m.GetType ().FullName);
+					}
+				}
+				throw;
+			}
+			loc = l;
+			eclass = ExprClass.PropertyAccess;
+			type = TypeManager.object_type;
+		}
+
+		public ArrayList Arguments {
+			get {
+				return arguments;
+			}
+			set {
+				arguments = value;
+			}
+		}
+
+		public Type DeclaringType {
+			get {
+				return Properties [0].DeclaringType;
+			}
+		}
+
+		public bool IndexerAccessRequired {
+			get {
+				return indexer_access_req;
+			}
+		}
+
+		//
+		// 'A method group may have associated an instance expression' 
+		// 
+		public Expression InstanceExpression {
+			get {
+				return instance_expression;
+			}
+
+			set {
+				instance_expression = value;
+			}
+		}
+
+		public bool IsExplicitImpl {
+			get {
+				return is_explicit_impl;
+			}
+
+			set {
+				is_explicit_impl = value;
+			}
+		}
+
+		public string Name {
+			get {
+				return Properties [0].Name;
+			}
+		}
+
+		public bool IsInstance {
+			get {
+				foreach (PropertyInfo pi in Properties) {
+					MethodInfo mi = pi.GetGetMethod ();
+					if (mi != null && !mi.IsStatic)
+						return true;
+					mi = pi.GetSetMethod ();
+					if (mi != null && !mi.IsStatic)
+						return true;
+				}		
+				return false;
+			}
+		}
+
+		public bool IsStatic {
+			get {
+				return (!IsInstance);
+			}
+		}
+		
+		public ArrayList GetAccessors () {
+			ArrayList GetAccessors = new ArrayList ();
+			foreach (PropertyInfo pi in Properties) {
+				if (pi.GetGetMethod () != null)
+					GetAccessors.Add (pi.GetGetMethod ());
+/*
+				else if (pi.GetGetMethod (true) != null)
+					GetAccessors.Add (pi.GetGetMethod (true));
+*/
+					
+			}
+			return GetAccessors;
+		}
+		
+		public ArrayList SetAccessors () {
+			ArrayList SetAccessors = new ArrayList ();
+			foreach (PropertyInfo pi in Properties) {
+				if (pi.GetSetMethod () != null)
+					SetAccessors.Add (pi.GetSetMethod ());
+/*
+				else if (pi.GetSetMethod (true) != null)
+					SetAccessors.Add (pi.GetSetMethod (true));
+*/
+			}
+			return SetAccessors;
+		}
+
+		override public Expression DoResolve (EmitContext ec)
+		{
+			if (instance_expression != null) {
+				instance_expression = instance_expression.DoResolve (ec);
+				if (instance_expression == null)
+					return null;
+			}
+
+			ArrayList members = GetAccessors ();
+			if (members == null || members.Count == 0) {
+				Report.Error (30524, loc, "Property '" + Name + "' lacks a 'get' accesor");
+				return null;
+			}
+
+			MethodGroupExpr m_expr = new MethodGroupExpr (members, loc);
+			method = Invocation.OverloadResolve (ec, m_expr, ref arguments, loc);
+			if ((method as MethodInfo) != null) {
+				MethodInfo mi = method as MethodInfo;
+				type = TypeManager.TypeToCoreType (mi.ReturnType);
+				indexer_access_req = false;
+				eclass = ExprClass.Value;
+				return this;
+			} else {
+				// find a get method that doesnt take any arguments. Check the return type of
+				// that method to find out if indexer access is required. Leave the rest to
+				// 'Invocation's Resolve'
+				method = Invocation.OverloadResolve (ec, m_expr, null, loc);
+				if (method != null) {
+					MethodInfo mi = method as MethodInfo;
+					Type ret_type = mi.ReturnType;
+					if (ret_type.IsArray)
+						indexer_access_req = true;
+					else {
+						Indexers list = Indexers.GetIndexersForType (ec.ContainerType, ret_type, loc);
+						if (list != null && list.getters.Count > 0)
+							indexer_access_req = true;
+						else 
+							return null;
+					}
+					Arguments = null;
+					type = mi.ReturnType;
+					return this;
+				}
+			}
+
+			return null;
+		}
+
+		override public Expression DoResolveLValue (EmitContext ec, Expression right_side) {
+			if (instance_expression != null) {
+				instance_expression = instance_expression.DoResolve (ec);
+				if (instance_expression == null)
+					return null;
+			}
+
+			ArrayList members = SetAccessors ();
+			if (members == null || members.Count == 0) {
+				Report.Error (30524, loc, "Property '" + Name + "' lacks a 'set' accesor");
+				return null;
+			}
+
+			MethodGroupExpr m_expr = new MethodGroupExpr (members, loc);
+			if (arguments == null)
+				arguments = new ArrayList ();
+			arguments.Add (new Argument (right_side, Argument.AType.Expression));
+			method = Invocation.OverloadResolve (ec, m_expr, ref arguments, loc);
+			if (method != null) {
+				//MethodInfo mi = method as MethodInfo;
+				type = TypeManager.void_type; //TypeManager.TypeToCoreType (mi.ReturnType);
+				eclass = ExprClass.Value;
+				indexer_access_req = false;
+				return this;
+			} else {
+				// Look for properties that do not take any arguments.
+				// Check if the return type has any indexers
+				arguments = null;
+				DoResolve (ec);
+				if (method != null) {
+					MethodInfo mi = method as MethodInfo;
+					Type ret_type = mi.ReturnType;
+					if (ret_type.IsArray)
+						indexer_access_req = true;
+					else {
+
+						Indexers list = Indexers.GetIndexersForType (ec.ContainerType, 
+									ret_type, loc);
+						if (list != null && list.setters.Count > 0)
+							indexer_access_req = true;
+						else 
+							return null;
+					}
+					type = mi.ReturnType;
+					return this;
+				}
+			}
+
+			return null;
+		}
+
+		override public void Emit (EmitContext ec)
+		{
+			if (Arguments == null)
+				Arguments = new ArrayList ();
+			Invocation.EmitCall (ec, false, IsStatic, instance_expression, method, null, Arguments, loc);
+		}
+
+		override public void EmitStatement (EmitContext ec) 
+		{
+			Emit (ec);
+		}
+
+	}
+
+	/// <summary>
+	///   Fully resolved expression that evaluates to a Field
+	/// </summary>
+	public class FieldExpr : Expression, IAssignMethod, IMemoryLocation, IMemberExpr {
+		public readonly FieldInfo FieldInfo;
+		Expression instance_expr;
+		
+		public FieldExpr (FieldInfo fi, Location l)
+		{
+			FieldInfo = fi;
+			eclass = ExprClass.Variable;
+			type = fi.FieldType;
+			loc = l;
+		}
+
+		public string Name {
+			get {
+				return FieldInfo.Name;
+			}
+		}
+
+		public bool IsInstance {
+			get {
+				return !FieldInfo.IsStatic;
+			}
+		}
+
+		public bool IsStatic {
+			get {
+				return FieldInfo.IsStatic;
+			}
+		}
+
+		public Type DeclaringType {
+			get {
+				return FieldInfo.DeclaringType;
+			}
+		}
+
+		public Expression InstanceExpression {
+			get {
+				return instance_expr;
+			}
+
+			set {
+				instance_expr = value;
+			}
+		}
+
+		override public Expression DoResolve (EmitContext ec)
+		{
+			if (!FieldInfo.IsStatic){
+				if (instance_expr == null){
+					throw new Exception ("non-static FieldExpr without instance var\n" +
+							     "You have to assign the Instance variable\n" +
+							     "Of the FieldExpr to set this\n");
+				}
+
+				// Resolve the field's instance expression while flow analysis is turned
+				// off: when accessing a field "a.b", we must check whether the field
+				// "a.b" is initialized, not whether the whole struct "a" is initialized.
+				instance_expr = instance_expr.Resolve (ec, ResolveFlags.VariableOrValue |
+								       ResolveFlags.DisableFlowAnalysis);
+				if (instance_expr == null)
+					return null;
+			}
+
+			// If the instance expression is a local variable or parameter.
+			IVariable var = instance_expr as IVariable;
+			if ((var != null) && !var.IsFieldAssigned (ec, FieldInfo.Name, loc))
+				return null;
+
+			return this;
+		}
+
+		void Report_AssignToReadonly (bool is_instance)
+		{
+			string msg;
+			
+			if (is_instance)
+				msg = "Readonly field can not be assigned outside " +
+				"of constructor or variable initializer";
+			else
+				msg = "A static readonly field can only be assigned in " +
+				"a static constructor";
+
+			Report.Error (is_instance ? 191 : 198, loc, msg);
+		}
+		
+		override public Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			IVariable var = instance_expr as IVariable;
+			if (var != null)
+				var.SetFieldAssigned (ec, FieldInfo.Name);
+
+			Expression e = DoResolve (ec);
+
+			if (e == null)
+				return null;
+			
+			if (!FieldInfo.IsInitOnly)
+				return this;
+
+			//
+			// InitOnly fields can only be assigned in constructors
+			//
+
+			if (ec.IsConstructor)
+				return this;
+
+			Report_AssignToReadonly (true);
+			
+			return null;
+		}
+
+		override public void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			bool is_volatile = false;
+
+			if (FieldInfo is FieldBuilder){
+				FieldBase f = TypeManager.GetField (FieldInfo);
+
+				if ((f.ModFlags & Modifiers.VOLATILE) != 0)
+					is_volatile = true;
+				
+				f.status |= Field.Status.USED;
+			}
+			
+			if (FieldInfo.IsStatic){
+				if (is_volatile)
+					ig.Emit (OpCodes.Volatile);
+				
+				ig.Emit (OpCodes.Ldsfld, FieldInfo);
+			} else {
+				if (instance_expr.Type.IsValueType){
+					IMemoryLocation ml;
+					LocalTemporary tempo = null;
+					
+					if (!(instance_expr is IMemoryLocation)){
+						tempo = new LocalTemporary (
+							ec, instance_expr.Type);
+
+						InstanceExpression.Emit (ec);
+						tempo.Store (ec);
+						ml = tempo;
+					} else
+						ml = (IMemoryLocation) instance_expr;
+
+					ml.AddressOf (ec, AddressOp.Load);
+				} else 
+					instance_expr.Emit (ec);
+
+				if (is_volatile)
+					ig.Emit (OpCodes.Volatile);
+				
+				ig.Emit (OpCodes.Ldfld, FieldInfo);
+			}
+		}
+
+		public void EmitAssign (EmitContext ec, Expression source)
+		{
+			FieldAttributes fa = FieldInfo.Attributes;
+			bool is_static = (fa & FieldAttributes.Static) != 0;
+			bool is_readonly = (fa & FieldAttributes.InitOnly) != 0;
+			ILGenerator ig = ec.ig;
+
+			if (is_readonly && !ec.IsConstructor){
+				Report_AssignToReadonly (!is_static);
+				return;
+			}
+			
+			if (!is_static){
+				Expression instance = instance_expr;
+
+				if (instance.Type.IsValueType){
+					if (instance is IMemoryLocation){
+						IMemoryLocation ml = (IMemoryLocation) instance;
+
+						ml.AddressOf (ec, AddressOp.Store);
+					} else
+						throw new Exception ("The " + instance + " of type " +
+								     instance.Type +
+								     " represents a ValueType and does " +
+								     "not implement IMemoryLocation");
+				} else
+					instance.Emit (ec);
+			}
+			source.Emit (ec);
+
+			if (FieldInfo is FieldBuilder){
+				FieldBase f = TypeManager.GetField (FieldInfo);
+				
+				if ((f.ModFlags & Modifiers.VOLATILE) != 0)
+					ig.Emit (OpCodes.Volatile);
+			}
+			
+			if (is_static)
+				ig.Emit (OpCodes.Stsfld, FieldInfo);
+			else 
+				ig.Emit (OpCodes.Stfld, FieldInfo);
+
+			if (FieldInfo is FieldBuilder){
+				FieldBase f = TypeManager.GetField (FieldInfo);
+
+				f.status |= Field.Status.ASSIGNED;
+			}
+		}
+		
+		public void AddressOf (EmitContext ec, AddressOp mode)
+		{
+			ILGenerator ig = ec.ig;
+			
+			if (FieldInfo is FieldBuilder){
+				FieldBase f = TypeManager.GetField (FieldInfo);
+				if ((f.ModFlags & Modifiers.VOLATILE) != 0)
+					ig.Emit (OpCodes.Volatile);
+			}
+
+			if (FieldInfo is FieldBuilder){
+				FieldBase f = TypeManager.GetField (FieldInfo);
+
+				if ((mode & AddressOp.Store) != 0)
+					f.status |= Field.Status.ASSIGNED;
+				if ((mode & AddressOp.Load) != 0)
+					f.status |= Field.Status.USED;
+			}
+
+			//
+			// Handle initonly fields specially: make a copy and then
+			// get the address of the copy.
+			//
+			if (FieldInfo.IsInitOnly && !ec.IsConstructor){
+				LocalBuilder local;
+				
+				Emit (ec);
+				local = ig.DeclareLocal (type);
+				ig.Emit (OpCodes.Stloc, local);
+				ig.Emit (OpCodes.Ldloca, local);
+				return;
+			}
+
+			if (FieldInfo.IsStatic)
+				ig.Emit (OpCodes.Ldsflda, FieldInfo);
+			else {
+				if (instance_expr is IMemoryLocation)
+					((IMemoryLocation)instance_expr).AddressOf (ec, AddressOp.LoadStore);
+				else
+					instance_expr.Emit (ec);
+				ig.Emit (OpCodes.Ldflda, FieldInfo);
+			}
+		}
+	}
+	
+	/// <summary>
+	///   Expression that evaluates to a Property.  The Assign class
+	///   might set the 'Value' expression if we are in an assignment.
+	///
+	///   This is not an LValue because we need to re-write the expression, we
+	///   can not take data from the stack and store it.  
+	/// </summary>
+	public class PropertyExpr : ExpressionStatement, IAssignMethod, IMemberExpr {
+		public readonly PropertyInfo PropertyInfo;
+		public bool IsBase;
+		MethodInfo getter, setter;
+		bool is_static;
+		public ArrayList PropertyArgs;
+
+		Expression instance_expr;
+
+		public PropertyExpr (EmitContext ec, PropertyInfo pi, Location l)
+		{
+			PropertyInfo = pi;
+			eclass = ExprClass.PropertyAccess;
+			PropertyArgs = null;
+			is_static = false;
+			loc = l;
+
+			type = TypeManager.TypeToCoreType (pi.PropertyType);
+
+			ResolveAccessors (ec);
+		}
+
+		public string Name {
+			get {
+				return PropertyInfo.Name;
+			}
+		}
+
+		public bool IsInstance {
+			get {
+				return !is_static;
+			}
+		}
+
+		public bool IsStatic {
+			get {
+				return is_static;
+			}
+		}
+		
+		public Type DeclaringType {
+			get {
+				return PropertyInfo.DeclaringType;
+			}
+		}
+
+		//
+		// The instance expression associated with this expression
+		//
+		public Expression InstanceExpression {
+			set {
+				instance_expr = value;
+			}
+
+			get {
+				return instance_expr;
+			}
+		}
+
+		public bool VerifyAssignable ()
+		{
+			if (!PropertyInfo.CanWrite){
+				Report.Error (200, loc, 
+					      "The property '" + PropertyInfo.Name +
+					      "' can not be assigned to, as it has not set accessor");
+				return false;
+			}
+
+			return true;
+		}
+
+		void ResolveAccessors (EmitContext ec)
+		{
+			BindingFlags flags = BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
+			MemberInfo [] group;
+			
+			group = TypeManager.MemberLookup (ec.ContainerType, PropertyInfo.DeclaringType,
+							      MemberTypes.Method, flags, "get_" + PropertyInfo.Name);
+
+			//
+			// The first method is the closest to us
+			//
+			if (group != null && group.Length > 0){
+				getter = (MethodInfo) group [0];
+
+				if (getter.IsStatic)
+					is_static = true;
+			} 			
+
+			//
+			// The first method is the closest to us
+			//
+			group = TypeManager.MemberLookup (ec.ContainerType, PropertyInfo.DeclaringType,
+							  MemberTypes.Method, flags, "set_" + PropertyInfo.Name);
+			if (group != null && group.Length > 0){
+				setter = (MethodInfo) group [0];
+				if (setter.IsStatic)
+					is_static = true;
+			}
+		}
+
+		override public Expression DoResolve (EmitContext ec)
+		{
+			if (getter == null){
+				Report.Error (30524, loc, 
+					      "The property '" + PropertyInfo.Name +
+					      "' can not be used in " +
+					      "this context because it lacks a get accessor");
+				return null;
+			}
+
+			if ((instance_expr == null) && ec.IsStatic && !is_static) {
+				SimpleName.Error_ObjectRefRequired (ec, loc, PropertyInfo.Name);
+				return null;
+			}
+
+			if (instance_expr != null) {
+				instance_expr = instance_expr.DoResolve (ec);
+				if (instance_expr == null)
+					return null;
+			}
+
+			return this;
+		}
+
+		override public Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			if (setter == null){
+				Report.Error (30526, loc, 
+					      "The property '" + PropertyInfo.Name +
+					      "' can not be used in " +
+					      "this context because it lacks a set accessor");
+				return null;
+			}
+
+			if (instance_expr != null) {
+				instance_expr = instance_expr.DoResolve (ec);
+				if (instance_expr == null)
+					return null;
+			}
+
+			return this;
+		}
+
+		override public void Emit (EmitContext ec)
+		{
+			//
+			// Special case: length of single dimension array property is turned into ldlen
+			//
+			if ((getter == TypeManager.system_int_array_get_length) ||
+			    (getter == TypeManager.int_array_get_length)){
+				Type iet = instance_expr.Type;
+
+				//
+				// System.Array.Length can be called, but the Type does not
+				// support invoking GetArrayRank, so test for that case first
+				//
+				if (iet != TypeManager.array_type && (iet.GetArrayRank () == 1)){
+					instance_expr.Emit (ec);
+					ec.ig.Emit (OpCodes.Ldlen);
+					return;
+				}
+			}
+			if (PropertyArgs == null)
+				PropertyArgs = new ArrayList ();
+			Invocation.EmitCall (ec, IsBase, IsStatic, instance_expr, getter, null, PropertyArgs, loc);
+		}
+
+		//
+		// Implements the IAssignMethod interface for assignments
+		//
+		public void EmitAssign (EmitContext ec, Expression source)
+		{
+			Argument arg = new Argument (source, Argument.AType.Expression);
+			ArrayList args = new ArrayList ();
+//HERE
+			args.Add (arg);
+			Invocation.EmitCall (ec, IsBase, IsStatic, instance_expr, setter, args, PropertyArgs,loc);
+		}
+
+		override public void EmitStatement (EmitContext ec)
+		{
+			Emit (ec);
+			ec.ig.Emit (OpCodes.Pop);
+		}
+	}
+
+	/// <summary>
+	///   Fully resolved expression that evaluates to an Event
+	/// </summary>
+	public class EventExpr : Expression, IMemberExpr {
+		public readonly EventInfo EventInfo;
+		public Expression instance_expr;
+
+		bool is_static;
+		MethodInfo add_accessor, remove_accessor;
+		
+		public EventExpr (EventInfo ei, Location loc)
+		{
+			EventInfo = ei;
+			this.loc = loc;
+			eclass = ExprClass.EventAccess;
+
+			add_accessor = TypeManager.GetAddMethod (ei);
+			remove_accessor = TypeManager.GetRemoveMethod (ei);
+			
+			if (add_accessor.IsStatic || remove_accessor.IsStatic)
+				is_static = true;
+
+			if (EventInfo is MyEventBuilder)
+				type = ((MyEventBuilder) EventInfo).EventType;
+			else
+				type = EventInfo.EventHandlerType;
+		}
+
+		public string Name {
+			get {
+				return EventInfo.Name;
+			}
+		}
+
+		public bool IsInstance {
+			get {
+				return !is_static;
+			}
+		}
+
+		public bool IsStatic {
+			get {
+				return is_static;
+			}
+		}
+
+		public Type DeclaringType {
+			get {
+				return EventInfo.DeclaringType;
+			}
+		}
+
+		public Expression InstanceExpression {
+			get {
+				return instance_expr;
+			}
+
+			set {
+				instance_expr = value;
+			}
+		}
+
+		Expression field_expr = null;
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (instance_expr != null) {
+				instance_expr = instance_expr.DoResolve (ec);
+				if (instance_expr == null)
+					return null;
+			}
+
+			if (this.DeclaringType == ec.ContainerType)	{
+				MemberInfo mi = GetFieldFromEvent (this);
+				if (mi == null)
+					return null;
+				field_expr = ExprClassFromMemberInfo (ec, mi, loc);
+				((FieldExpr) field_expr).InstanceExpression = instance_expr;
+				field_expr = field_expr.DoResolve (ec);
+				if (field_expr == null)
+					return null;
+			}
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			if (field_expr != null)
+				field_expr.Emit (ec);
+		}
+
+		public void EmitAddOrRemove (EmitContext ec, Expression source)
+		{
+			Expression handler = ((Binary) source).Right;
+			
+			Argument arg = new Argument (handler, Argument.AType.Expression);
+			ArrayList args = new ArrayList ();
+				
+			args.Add (arg);
+			
+			if (((Binary) source).Oper == Binary.Operator.Addition)
+				Invocation.EmitCall (
+					ec, false, IsStatic, instance_expr, add_accessor, args, loc);
+			else
+				Invocation.EmitCall (
+					ec, false, IsStatic, instance_expr, remove_accessor, args, loc);
+		}
+	}
+}
diff --git a/dead/mbas/enum.cs b/dead/mbas/enum.cs
new file mode 100644
index 00000000..c5db9189
--- /dev/null
+++ b/dead/mbas/enum.cs
@@ -0,0 +1,502 @@
+//
+// enum.cs: Enum handling.
+//
+// Author: Miguel de Icaza (miguel@gnu.org)
+//         Ravi Pratap     (ravi@ximian.com)
+//         Anirban Bhattacharjee (banirban@novell.com)
+//         Jambunathan K (kjambunathan@novell.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001 Ximian, Inc (http://www.ximian.com)
+//
+
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Mono.MonoBASIC {
+
+	public class EnumMember : MemberCore
+	{
+		Enum parent_enum;
+		Expression expr;
+		int index;
+		
+		FieldBuilder builder;
+		object enum_value;
+
+		bool in_transit = false;
+		FieldAttributes field_attrs = FieldAttributes.Public | FieldAttributes.Static
+						| FieldAttributes.Literal;
+
+		public EnumMember (Enum parent_enum, Expression expr, string name,
+				   Location loc, Attributes attrs, int index):
+			base (name, attrs, loc)
+		{
+			this.parent_enum = parent_enum;
+			this.expr = expr;
+			this.index = index;
+		}
+
+		public override void ApplyAttributeBuilder(Attribute a, CustomAttributeBuilder cb)
+		{
+			builder.SetCustomAttribute (cb);
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Field;
+			}
+		}
+
+		public override bool Define (TypeContainer tc)
+		{
+			throw new NotImplementedException ();
+		}
+
+		public object GetValue ()
+		{
+			if (builder == null) 
+				DefineMember ();
+
+			return enum_value;
+		}
+
+		public FieldBuilder DefineMember ()
+		{
+			if (builder != null)
+				return builder;
+
+			DoDefineMember ();
+
+			if (builder == null)
+				parent_enum.RemoveEnumMember (this.Name);
+
+			return builder;
+		}
+
+		public FieldBuilder DoDefineMember ()
+		{
+			object default_value = null;
+			Constant c = null;
+			Type UnderlyingType = parent_enum.UnderlyingType;
+			EmitContext ec = parent_enum.EmitContext;
+			
+			default_value = enum_value;
+			
+			if (in_transit) {
+				Report.Error (30500, Location, "The evaluation of the constant value for `" +
+					      parent_enum.Name + "." + Name + "' involves a circular definition.");
+				return null;
+			}
+
+			//
+			// So if the above doesn't happen, we have a member that is undefined
+			// We now proceed to define it 
+			//
+			Expression val = expr;
+			int idx = index;
+
+			if (val == null) {
+				if (idx == 0)
+					default_value = 0;
+				else {
+					int i = idx - 1;
+					EnumMember em = parent_enum [i];
+
+					in_transit = true;
+					default_value = em.GetValue ();
+					in_transit = false;
+
+					if (default_value == null)
+						return null;
+					
+					default_value = Enum.GetNextDefaultValue (default_value, UnderlyingType);
+				}
+				
+			} else {
+				bool old = ec.InEnumContext;
+				ec.InEnumContext = true;
+				in_transit = true;
+				val = val.Resolve (ec);
+				in_transit = false;
+				ec.InEnumContext = old;
+
+				if (val == null)
+					return null;
+
+				if (! Enum.IsValidEnumConstant (val)) {
+					Report.Error (
+						30650, Location,
+						"Type byte, sbyte, short, ushort, int, uint, long, or " +
+						"ulong expected (have: " + val + ")");
+					return null;
+				}
+
+				c = (Constant) val;
+			
+				default_value = c.GetValue ();
+
+				if (default_value == null) {
+					Enum.Error_ConstantValueCannotBeConverted (c, Location, UnderlyingType);
+					return null;
+				}
+			}
+
+			builder = parent_enum.TypeBuilder.DefineField (Name, parent_enum.TypeBuilder, field_attrs);
+
+			try {
+				//FXME: ChangeType is not the right thing to do. 
+				default_value = TypeManager.ChangeType (default_value, UnderlyingType);
+			} catch {
+				Enum.Error_ConstantValueCannotBeConverted (c, Location, UnderlyingType);
+				return null;
+			}
+
+			enum_value = default_value;
+
+			builder.SetConstant (enum_value);
+
+			if (!TypeManager.RegisterFieldValue (builder, enum_value))
+				return null;
+
+			if (OptAttributes != null)
+				OptAttributes.Emit (ec, this);
+
+			return builder;
+		}
+
+	}
+	
+
+	/// <summary>
+	///   Enumeration container
+	/// </summary>
+	public class Enum : DeclSpace {
+		ArrayList ordered_enums;
+		public Expression BaseType;
+		public Type UnderlyingType;
+		ArrayList field_builders;
+		
+		public const int AllowedModifiers =
+			Modifiers.NEW |
+			Modifiers.PUBLIC |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL |
+			Modifiers.PRIVATE;
+
+		EmitContext emit_context;
+
+		public Enum (TypeContainer parent, Expression type, int mod_flags, string name, Attributes attrs, Location l)
+			: base (parent, name, attrs, l)
+		{
+			this.BaseType = type;
+			ModFlags = Modifiers.Check (AllowedModifiers, mod_flags,
+						    IsTopLevel ? Modifiers.INTERNAL : Modifiers.PUBLIC, l);
+
+			ordered_enums = new ArrayList ();
+			field_builders = new ArrayList ();
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Enum;
+			}
+		}
+
+		/// <summary>
+		///   Adds @name to the enumeration space, with @expr
+		///   being its definition.  
+		/// </summary>
+		public AdditionResult AddEnumMember (string name, Expression expr, Location loc,
+						     Attributes opt_attrs)
+		{
+			int index;
+			EnumMember em;
+			
+			if (defined_names.Contains (name))
+				return AdditionResult.NameExists;
+
+			index = ordered_enums.Add (name);
+			em = new EnumMember (this, expr, name, loc, opt_attrs, index);
+			DefineName (name, em);
+
+			return AdditionResult.Success;
+		}
+
+		public void RemoveEnumMember (string name)
+		{
+			defined_names.Remove (name);
+		}
+
+		public override TypeBuilder DefineType ()
+		{
+			if (TypeBuilder != null)
+				return TypeBuilder;
+
+			emit_context = new EmitContext (Parent, this, Location, null,
+							  UnderlyingType, ModFlags, false);
+
+			TypeAttributes attr = Modifiers.TypeAttr (ModFlags, IsTopLevel);
+
+			attr |= TypeAttributes.Class | TypeAttributes.Sealed;
+
+			UnderlyingType = ResolveType (BaseType, false, Location);
+
+			if (UnderlyingType != TypeManager.int32_type &&
+			    UnderlyingType != TypeManager.uint32_type &&
+			    UnderlyingType != TypeManager.int64_type &&
+			    UnderlyingType != TypeManager.uint64_type &&
+			    UnderlyingType != TypeManager.short_type &&
+			    UnderlyingType != TypeManager.ushort_type &&
+			    UnderlyingType != TypeManager.byte_type  &&
+			    UnderlyingType != TypeManager.sbyte_type) {
+				Report.Error (30650, Location,
+					      "Type byte, sbyte, short, ushort, int, uint, " +
+					      "long, or ulong expected (got: " +
+					      TypeManager.MonoBASIC_Name (UnderlyingType) + ")");
+				return null;
+			}
+
+			if (IsTopLevel) {
+				ModuleBuilder builder = CodeGen.ModuleBuilder;
+
+				TypeBuilder = builder.DefineType (Name, attr, TypeManager.enum_type);
+			} else {
+				TypeBuilder builder = Parent.TypeBuilder;
+
+				TypeBuilder = builder.DefineNestedType (
+					Basename, attr, TypeManager.enum_type);
+			}
+
+			TypeBuilder.DefineField ("value__", UnderlyingType,
+						 FieldAttributes.Public | FieldAttributes.SpecialName
+						 | FieldAttributes.RTSpecialName);
+
+			TypeManager.AddEnumType (Name, TypeBuilder, this);
+
+			return TypeBuilder;
+		}
+
+	    	public static bool IsValidEnumConstant (Expression e)
+		{
+			if (!(e is Constant))
+				return false;
+
+			if (e is IntConstant || e is UIntConstant || e is LongConstant ||
+			    e is ByteConstant || e is SByteConstant || e is ShortConstant ||
+			    e is UShortConstant || e is ULongConstant || e is EnumConstant ||
+			    e is DoubleConstant)
+				return true;
+			else
+				return false;
+		}
+
+		static public object GetNextDefaultValue (object default_value, Type UnderlyingType)
+		{
+			if (UnderlyingType == TypeManager.int32_type) {
+				int i = (int) default_value;
+				
+				if (i < System.Int32.MaxValue)
+					return ++i;
+				else
+					return null;
+			} else if (UnderlyingType == TypeManager.uint32_type) {
+				uint i = (uint) default_value;
+
+				if (i < System.UInt32.MaxValue)
+					return ++i;
+				else
+					return null;
+			} else if (UnderlyingType == TypeManager.int64_type) {
+				long i = (long) default_value;
+
+				if (i < System.Int64.MaxValue)
+					return ++i;
+				else
+					return null;
+			} else if (UnderlyingType == TypeManager.uint64_type) {
+				ulong i = (ulong) default_value;
+
+				if (i < System.UInt64.MaxValue)
+					return ++i;
+				else
+					return null;
+			} else if (UnderlyingType == TypeManager.short_type) {
+				short i = (short) default_value;
+
+				if (i < System.Int16.MaxValue)
+					return ++i;
+				else
+					return null;
+			} else if (UnderlyingType == TypeManager.ushort_type) {
+				ushort i = (ushort) default_value;
+
+				if (i < System.UInt16.MaxValue)
+					return ++i;
+				else
+					return null;
+			} else if (UnderlyingType == TypeManager.byte_type) {
+				byte i = (byte) default_value;
+
+				if (i < System.Byte.MaxValue)
+					return ++i;
+				else
+					return null;
+			} else if (UnderlyingType == TypeManager.sbyte_type) {
+				sbyte i = (sbyte) default_value;
+
+				if (i < System.SByte.MaxValue)
+					return ++i;
+				else
+					return null;
+			}
+
+			return null;
+		}
+
+		public static void Error_ConstantValueCannotBeConverted (object val, Location loc, Type UnderlyingType)
+		{
+			if (val is Constant)
+				Report.Error (30439, loc, "Constant value '" + ((Constant) val).AsString () +
+					      "' cannot be converted" +
+					      " to a " + TypeManager.MonoBASIC_Name (UnderlyingType));
+			else 
+				Report.Error (30439, loc, "Constant value '" + val +
+					      "' cannot be converted" +
+					      " to a " + TypeManager.MonoBASIC_Name (UnderlyingType));
+			return;
+		}
+
+		/// <summary>
+		///  This is used to lookup the value of an enum member. If the member is undefined,
+		///  it attempts to define it and return its value
+		/// </summary>
+		public object LookupEnumValue (string name)
+		{
+			EnumMember em;
+
+			// first check whether the requested name is there
+			// in the member list of enum
+
+			em = this [name];
+
+			if (em == null)
+				return null;
+			
+			name = em.Name;
+			FieldBuilder fb = em.DefineMember ();
+			
+			if (fb == null) {
+				return null;
+			} 
+
+			if (! field_builders.Contains (fb)) {
+				field_builders.Add (fb);
+			}
+
+			return em.GetValue ();
+		}
+
+		public override bool DefineMembers (TypeContainer parent)
+		{
+			return true;
+		}
+		
+		public override bool Define (TypeContainer parent)
+		{
+			if (TypeBuilder == null)
+				return false;
+			/*
+			EmitContext ec = new EmitContext (parent, this, Location, null,
+							  UnderlyingType, ModFlags, false);
+			*/
+			foreach (string name in ordered_enums) {
+				EnumMember em = this [name];
+				FieldBuilder fb = em.DefineMember ();
+
+				if (fb == null) {
+					return false;
+				} 
+
+				if (!field_builders.Contains (fb)) {
+					field_builders.Add (fb);
+				}
+			}
+
+			if (OptAttributes != null)
+				OptAttributes.Emit (EmitContext, this);
+			
+			return true;
+		}
+		
+		//
+		// IMemberFinder
+		//
+		public override MemberList FindMembers (MemberTypes mt, BindingFlags bf,
+							MemberFilter filter, object criteria)
+		{
+			ArrayList members = new ArrayList ();
+
+			if ((mt & MemberTypes.Field) != 0) {
+				
+				if (criteria is string){
+					LookupEnumValue ((string) criteria);
+				}
+				
+				foreach (FieldBuilder fb in field_builders)
+					if (filter (fb, criteria) == true)
+						members.Add (fb);
+			}
+
+			return new MemberList (members);
+		}
+
+		public override MemberCache MemberCache {
+			get {
+				return null;
+			}
+		}
+
+		public ArrayList ValueNames {
+			get {
+				return ordered_enums;
+			}
+		}
+
+		// indexer
+		public EnumMember this [string name] {
+			get {
+				EnumMember em = (EnumMember) defined_names [name];
+
+				if (em != null)
+					return em;
+
+				name = name.ToLower();
+				foreach (string nm in ordered_enums) {
+					if (nm.ToLower() == name) {
+						em = (EnumMember) defined_names [name];
+						break;
+					}
+				}
+
+				return em;
+			}
+		}
+
+		public EnumMember this[int mem_index] {
+			get {
+				string mem_name = (string) ordered_enums [mem_index];;
+				return (EnumMember) defined_names[mem_name];
+			}
+		}
+
+		public EmitContext EmitContext {
+			get {
+				return emit_context;
+			}
+		}
+	}
+}
diff --git a/dead/mbas/expression.cs b/dead/mbas/expression.cs
new file mode 100644
index 00000000..49cd1915
--- /dev/null
+++ b/dead/mbas/expression.cs
@@ -0,0 +1,8004 @@
+//
+// expression.cs: Expression representation for the IL tree.
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//   Manjula GHM (mmanjula@novell.com)
+//   Satya Sudha K (ksathyasudha@novell.com)
+//
+// (C) 2001 Ximian, Inc.
+//
+//
+#define USE_OLD
+
+namespace Mono.MonoBASIC {
+	using System;
+	using System.Collections;
+	using System.Reflection;
+	using System.Reflection.Emit;
+	using System.Text;
+
+	/// <summary>
+	///   This is just a helper class, it is generated by Unary, UnaryMutator
+	///   when an overloaded method has been found.  It just emits the code for a
+	///   static call.
+	/// </summary>
+	public class StaticCallExpr : ExpressionStatement {
+		ArrayList args;
+		MethodInfo mi;
+
+		StaticCallExpr (MethodInfo m, ArrayList a, Location l)
+		{
+			mi = m;
+			args = a;
+
+			type = m.ReturnType;
+			eclass = ExprClass.Value;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			//
+			// We are born fully resolved
+			//
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			if (args != null) 
+				Invocation.EmitArguments (ec, mi, args);
+
+			ec.ig.Emit (OpCodes.Call, mi);
+			return;
+		}
+		
+		static public Expression MakeSimpleCall (EmitContext ec, MethodGroupExpr mg,
+							 Expression e, Location loc)
+		{
+			ArrayList args;
+			MethodBase method;
+			
+			args = new ArrayList (1);
+			args.Add (new Argument (e, Argument.AType.Expression));
+			method = Invocation.OverloadResolve (ec, (MethodGroupExpr) mg, args, loc);
+
+			if (method == null)
+				return null;
+
+			return new StaticCallExpr ((MethodInfo) method, args, loc);
+		}
+
+		public override void EmitStatement (EmitContext ec)
+		{
+			Emit (ec);
+			if (TypeManager.TypeToCoreType (type) != TypeManager.void_type)
+				ec.ig.Emit (OpCodes.Pop);
+		}
+	}
+	
+	/// <summary>
+	///   Unary expressions.  
+	/// </summary>
+	///
+	/// <remarks>
+	///   Unary implements unary expressions.   It derives from
+	///   ExpressionStatement becuase the pre/post increment/decrement
+	///   operators can be used in a statement context.
+	/// </remarks>
+	public class Unary : Expression {
+		public enum Operator : byte {
+			UnaryPlus, UnaryNegation, LogicalNot, OnesComplement,
+			Indirection, AddressOf,  TOP
+		}
+
+		public Operator Oper;
+		public Expression Expr;
+		
+		public Unary (Operator op, Expression expr, Location loc)
+		{
+			this.Oper = op;
+			this.Expr = expr;
+			this.loc = loc;
+		}
+
+		/// <summary>
+		///   Returns a stringified representation of the Operator
+		/// </summary>
+		static public string OperName (Operator oper)
+		{
+			switch (oper){
+			case Operator.UnaryPlus:
+				return "+";
+			case Operator.UnaryNegation:
+				return "-";
+			case Operator.LogicalNot:
+				return "Not";
+			case Operator.OnesComplement:
+				return "~";
+			case Operator.AddressOf:
+				return "AddressOf";
+			case Operator.Indirection:
+				return "*";
+			}
+
+			return oper.ToString ();
+		}
+
+		static string [] oper_names;
+
+		static Unary ()
+		{
+			oper_names = new string [(int)Operator.TOP];
+
+			oper_names [(int) Operator.UnaryPlus] = "op_UnaryPlus";
+			oper_names [(int) Operator.UnaryNegation] = "op_UnaryNegation";
+			oper_names [(int) Operator.LogicalNot] = "op_LogicalNot";
+			oper_names [(int) Operator.OnesComplement] = "op_OnesComplement";
+			oper_names [(int) Operator.Indirection] = "op_Indirection";
+			oper_names [(int) Operator.AddressOf] = "op_AddressOf";
+		}
+
+		void Error23 (Type t)
+		{
+			Error (
+				30311, "Operator " + OperName (Oper) +
+				" cannot be applied to operand of type '" +
+				TypeManager.MonoBASIC_Name (t) + "'");
+		}
+
+		/// <remarks>
+		///   The result has been already resolved:
+		///
+		///   FIXME: a minus constant -128 sbyte cant be turned into a
+		///   constant byte.
+		/// </remarks>
+		static Expression TryReduceNegative (Constant expr)
+		{
+			Expression e = null;
+			
+			if (expr is IntConstant)
+				e = new IntConstant (-((IntConstant) expr).Value);
+			else if (expr is UIntConstant){
+				uint value = ((UIntConstant) expr).Value;
+
+				if (value < 2147483649)
+					return new IntConstant (-(int)value);
+				else
+					e = new LongConstant (value);
+			}
+			else if (expr is LongConstant)
+				e = new LongConstant (-((LongConstant) expr).Value);
+			else if (expr is ULongConstant){
+				ulong value = ((ULongConstant) expr).Value;
+
+				if (value < 9223372036854775809)
+					return new LongConstant(-(long)value);
+			}
+			else if (expr is FloatConstant)
+				e = new FloatConstant (-((FloatConstant) expr).Value);
+			else if (expr is DoubleConstant)
+				e = new DoubleConstant (-((DoubleConstant) expr).Value);
+			else if (expr is DecimalConstant)
+				e = new DecimalConstant (-((DecimalConstant) expr).Value);
+			else if (expr is ShortConstant)
+				e = new IntConstant (-((ShortConstant) expr).Value);
+			else if (expr is UShortConstant)
+				e = new IntConstant (-((UShortConstant) expr).Value);
+			return e;
+		}
+
+		// <summary>
+		//   This routine will attempt to simplify the unary expression when the
+		//   argument is a constant.  The result is returned in 'result' and the
+		//   function returns true or false depending on whether a reduction
+		//   was performed or not
+		// </summary>
+		bool Reduce (EmitContext ec, Constant e, out Expression result)
+		{
+			Type expr_type = e.Type;
+			
+			switch (Oper){
+			case Operator.UnaryPlus:
+				result = e;
+				return true;
+				
+			case Operator.UnaryNegation:
+				result = TryReduceNegative (e);
+				return true;
+				
+			case Operator.LogicalNot:
+				if (expr_type != TypeManager.bool_type) {
+					result = null;
+					Error23 (expr_type);
+					return false;
+				}
+				
+				BoolConstant b = (BoolConstant) e;
+				result = new BoolConstant (!(b.Value));
+				return true;
+				
+			case Operator.OnesComplement:
+				if (!((expr_type == TypeManager.int32_type) ||
+				      (expr_type == TypeManager.uint32_type) ||
+				      (expr_type == TypeManager.int64_type) ||
+				      (expr_type == TypeManager.uint64_type) ||
+				      (expr_type.IsSubclassOf (TypeManager.enum_type)))){
+					result = null;
+					Error23 (expr_type);
+					return false;
+				}
+
+				if (e is EnumConstant){
+					EnumConstant enum_constant = (EnumConstant) e;
+					Expression reduced;
+					
+					if (Reduce (ec, enum_constant.Child, out reduced)){
+						result = new EnumConstant ((Constant) reduced, enum_constant.Type);
+						return true;
+					} else {
+						result = null;
+						return false;
+					}
+				}
+
+				if (expr_type == TypeManager.int32_type){
+					result = new IntConstant (~ ((IntConstant) e).Value);
+				} else if (expr_type == TypeManager.uint32_type){
+					result = new UIntConstant (~ ((UIntConstant) e).Value);
+				} else if (expr_type == TypeManager.int64_type){
+					result = new LongConstant (~ ((LongConstant) e).Value);
+				} else if (expr_type == TypeManager.uint64_type){
+					result = new ULongConstant (~ ((ULongConstant) e).Value);
+				} else {
+					result = null;
+					Error23 (expr_type);
+					return false;
+				}
+				return true;
+
+			case Operator.AddressOf:
+				result = this;
+				return false;
+
+			case Operator.Indirection:
+				result = this;
+				return false;
+			}
+			throw new Exception ("Can not constant fold: " + Oper.ToString());
+		}
+
+		Expression ResolveOperator (EmitContext ec)
+		{
+			Type expr_type = Expr.Type;
+
+			Expression mg;
+			string op_name;
+			if (Oper == Operator.LogicalNot && expr_type != TypeManager.bool_type) 
+				Oper = Operator.OnesComplement;
+
+
+			if ((expr_type == TypeManager.string_type) &&
+			    (Oper == Operator.UnaryPlus ||
+			     Oper == Operator.UnaryNegation)) {
+
+				Expr = ConvertImplicit (ec, Expr, TypeManager.double_type, loc);
+				if (Expr == null) {
+					Error23 (expr_type);
+					return null;
+				}
+				expr_type = Expr.Type;
+			}
+
+			//
+			// Step 1: Perform Operator Overload location
+			//
+			op_name = oper_names [(int) Oper];
+
+			mg = MemberLookup (ec, expr_type, op_name, MemberTypes.Method, AllBindingFlags, loc);
+			
+			if (mg != null) {
+				Expression e = StaticCallExpr.MakeSimpleCall (
+					ec, (MethodGroupExpr) mg, Expr, loc);
+
+				if (e == null){
+					Error23 (expr_type);
+					return null;
+				}
+				
+				return e;
+			}
+
+			// Only perform numeric promotions on:
+			// +, - 
+
+			if (expr_type == null)
+				return null;
+			
+			//
+			// Step 2: Default operations on CLI native types.
+			//
+
+			// Attempt to use a constant folding operation.
+			if (Expr is Constant){
+				Expression result;
+				
+				if (Reduce (ec, (Constant) Expr, out result))
+					return result;
+			}
+
+			switch (Oper){
+			case Operator.LogicalNot:
+				if (expr_type != TypeManager.bool_type) {
+					Error23 (Expr.Type);
+					return null;
+				}
+				
+				type = TypeManager.bool_type;
+				return this;
+
+			case Operator.OnesComplement:
+				if (expr_type == TypeManager.string_type ||
+				    expr_type == TypeManager.decimal_type ||
+				    expr_type == TypeManager.double_type ||
+				    expr_type == TypeManager.float_type) {
+					if ((Expr = ConvertImplicit (ec, Expr, TypeManager.int64_type, loc)) == null) {
+						Error23 (Expr.Type);
+						return null;
+					}
+					expr_type = Expr.Type;
+				}
+
+				if (expr_type == TypeManager.int64_type) {
+					type = expr_type;
+					return this;
+				}
+				if (expr_type == TypeManager.byte_type ||
+				    expr_type == TypeManager.short_type ||
+				    expr_type == TypeManager.int32_type) {
+					type = TypeManager.int32_type;
+					return this;
+				}
+
+				if (expr_type == TypeManager.object_type) {
+					Expression etmp = Parser.DecomposeQI ("Microsoft.VisualBasic.CompilerServices.ObjectType.NotObj", Location.Null);
+					ArrayList arguments = new ArrayList ();
+					arguments.Add (new Argument (Expr, Argument.AType.Expression));
+					Expression e = new Invocation (etmp, arguments, loc);
+					return e.Resolve (ec);
+				}
+
+				break;
+			case Operator.AddressOf:
+				// Not required in VB ??
+				if (Expr.eclass != ExprClass.Variable){
+					Error (211, "Cannot take the address of non-variables");
+					return null;
+				}
+				
+				if (!ec.InUnsafe) {
+					UnsafeError (loc); 
+					return null;
+				}
+				
+				if (!TypeManager.VerifyUnManaged (Expr.Type, loc)){
+					return null;
+				}
+				
+				string ptr_type_name = Expr.Type.FullName + "*";
+				type = TypeManager.LookupType (ptr_type_name);
+				
+				return this;
+
+			case Operator.Indirection:
+				if (!ec.InUnsafe){
+					UnsafeError (loc);
+					return null;
+				}
+				
+				if (!expr_type.IsPointer){
+					Error (
+						193,
+						"The * or -> operator can only be applied to pointers");
+					return null;
+				}
+				
+				//
+				// We create an Indirection expression, because
+				// it can implement the IMemoryLocation.
+				// 
+				return new Indirection (Expr, loc);
+			
+			case Operator.UnaryPlus:
+				//
+				// A plus in front of something is just a no-op, so return the child.
+				//
+				if (expr_type == TypeManager.string_type) {
+					Expression e = ConvertImplicit (ec, Expr, TypeManager.double_type, loc);
+					if (e != null){
+						type = TypeManager.double_type;
+						return e;
+					}
+				}
+
+				if (expr_type == TypeManager.bool_type) {
+					Expression e = ConvertImplicit (ec, Expr, TypeManager.short_type, loc);
+					if (e != null){
+						type = TypeManager.int32_type;
+						return e;
+					}
+				}
+
+				return Expr;
+
+			case Operator.UnaryNegation:
+				//
+				// Deals with -literals
+				// int     operator- (int x)
+				// long    operator- (long x)
+				// float   operator- (float f)
+				// double  operator- (double d)
+				// decimal operator- (decimal d)
+				//
+
+				//
+				// transform - - expr into expr
+				//
+				if (Expr is Unary){
+					Unary unary = (Unary) Expr;
+					
+					if (unary.Oper == Operator.UnaryNegation)
+						return unary.Expr;
+				}
+
+				//
+				// perform numeric promotions to int,
+				// long, double.
+				//
+				//
+				// The following is inneficient, because we call
+				// ConvertImplicit too many times.
+				//
+				// It is also not clear if we should convert to Float
+				// or Double initially.
+				//
+				if (expr_type == TypeManager.string_type) {
+					Expression e = ConvertImplicit (ec, Expr, TypeManager.double_type, loc);
+					if (e != null){
+						Expr = e;
+						type = TypeManager.double_type;
+						return this;
+					}
+				}
+
+				if (expr_type == TypeManager.bool_type) {
+					Expression e = ConvertImplicit (ec, Expr, TypeManager.short_type, loc);
+					if (e != null){
+						Expr = e;
+						type = TypeManager.int32_type;
+						return this;
+					}
+				}
+
+				if (expr_type == TypeManager.float_type || 
+				    expr_type == TypeManager.double_type) {
+					type = expr_type;
+					return this;
+				}
+
+				if (expr_type == TypeManager.short_type ||
+				    expr_type == TypeManager.byte_type) { 
+					type = TypeManager.int32_type;
+					return this;
+				}
+
+				if (expr_type == TypeManager.int32_type || 
+				    expr_type == TypeManager.int64_type) {
+					Expression e = new Binary (Binary.Operator.Subtraction, new IntLiteral (0), Expr, loc);
+					return e.Resolve (ec);
+				}
+				
+				Error23 (expr_type);
+				return null;
+			}
+
+			Error (187, "No such operator '" + OperName (Oper) + "' defined for type '" +
+			       TypeManager.MonoBASIC_Name (expr_type) + "'");
+			return null;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (Oper == Operator.AddressOf)
+				Expr = Expr.ResolveLValue (ec, new EmptyExpression ());
+			else
+				Expr = Expr.Resolve (ec);
+			
+			if (Expr == null)
+				return null;
+
+			Type init_type = Expr.Type;
+
+			eclass = ExprClass.Value;
+			Expression etmp = ResolveOperator (ec);
+			// Convert the result to byte/short if operands are of type byte/short/boolean
+			if (etmp.Type != init_type && 
+			    (init_type == TypeManager.byte_type || 
+			     init_type == TypeManager.short_type || 
+			     init_type == TypeManager.bool_type)) {
+				Expression conv_exp = null;
+				if (init_type == TypeManager.byte_type && Oper != Operator.UnaryNegation) {
+					return new OpcodeCast (etmp, TypeManager.byte_type, OpCodes.Conv_U1);
+				}
+				else
+					conv_exp = ConvertImplicit (ec, etmp, TypeManager.short_type, loc);
+
+				if (conv_exp != null)
+					return conv_exp;
+			}
+			return etmp;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			
+			switch (Oper) {
+			case Operator.UnaryPlus:
+				throw new Exception ("This should be caught by Resolve");
+				
+			case Operator.UnaryNegation:
+				Expr.Emit (ec);
+				ig.Emit (OpCodes.Neg);
+				break;
+				
+			case Operator.LogicalNot:
+				Expr.Emit (ec);
+				ig.Emit (OpCodes.Ldc_I4_0);
+				ig.Emit (OpCodes.Ceq);
+				break;
+				
+			case Operator.OnesComplement:
+				Expr.Emit (ec);
+				ig.Emit (OpCodes.Not);
+				break;
+				
+			case Operator.AddressOf:
+				((IMemoryLocation)Expr).AddressOf (ec, AddressOp.LoadStore);
+				break;
+				
+			default:
+				throw new Exception ("This should not happen: Operator = "
+						     + Oper.ToString ());
+			}
+		}
+
+		/// <summary>
+		///   This will emit the child expression for 'ec' avoiding the logical
+		///   not.  The parent will take care of changing brfalse/brtrue
+		/// </summary>
+		public void EmitLogicalNot (EmitContext ec)
+		{
+			if (Oper != Operator.LogicalNot)
+				throw new Exception ("EmitLogicalNot can only be called with !expr");
+
+			Expr.Emit (ec);
+		}
+
+		public override string ToString ()
+		{
+			return "Unary (" + Oper + ", " + Expr + ")";
+		}
+		
+	}
+
+	//
+	// Unary operators are turned into Indirection expressions
+	// after semantic analysis (this is so we can take the address
+	// of an indirection).
+	//
+	public class Indirection : Expression, IMemoryLocation, IAssignMethod {
+		Expression expr;
+		LocalTemporary temporary;
+		bool have_temporary;
+		
+		public Indirection (Expression expr, Location l)
+		{
+			this.expr = expr;
+			this.type = TypeManager.TypeToCoreType (expr.Type.GetElementType ());
+			eclass = ExprClass.Variable;
+			loc = l;
+		}
+
+/*
+		void LoadExprValue (EmitContext ec)
+		{
+		}
+*/
+		
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+
+			if (temporary != null){
+				if (have_temporary){
+					temporary.Emit (ec);
+					return;
+				}
+				expr.Emit (ec);
+				ec.ig.Emit (OpCodes.Dup);
+				temporary.Store (ec);
+				have_temporary = true;
+			} else
+				expr.Emit (ec);
+			
+			LoadFromPtr (ig, Type);
+		}
+
+		public void EmitAssign (EmitContext ec, Expression source)
+		{
+			if (temporary != null){
+				if (have_temporary){
+					temporary.Emit (ec);
+					return;
+				}
+				expr.Emit (ec);
+				ec.ig.Emit (OpCodes.Dup);
+				temporary.Store (ec);
+				have_temporary = true;
+			} else
+				expr.Emit (ec);
+
+			source.Emit (ec);
+			StoreFromPtr (ec.ig, type);
+		}
+		
+		public void AddressOf (EmitContext ec, AddressOp Mode)
+		{
+			if (temporary != null){
+				if (have_temporary){
+					temporary.Emit (ec);
+					return;
+				}
+				expr.Emit (ec);
+				ec.ig.Emit (OpCodes.Dup);
+				temporary.Store (ec);
+				have_temporary = true;
+			} else
+				expr.Emit (ec);
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			//
+			// Born fully resolved
+			//
+			return this;
+		}
+
+		public new void CacheTemporaries (EmitContext ec)
+		{
+			temporary = new LocalTemporary (ec, type);
+		}
+	}
+	
+	/// <summary>
+	///   Unary Mutator expressions (pre and post ++ and --)
+	/// </summary>
+	///
+	/// <remarks>
+	///   UnaryMutator implements ++ and -- expressions.   It derives from
+	///   ExpressionStatement becuase the pre/post increment/decrement
+	///   operators can be used in a statement context.
+	///
+	/// FIXME: Idea, we could split this up in two classes, one simpler
+	/// for the common case, and one with the extra fields for more complex
+	/// classes (indexers require temporary access;  overloaded require method)
+	///
+	/// Maybe we should have classes PreIncrement, PostIncrement, PreDecrement,
+	/// PostDecrement, that way we could save the 'Mode' byte as well.  
+	/// </remarks>
+	public class UnaryMutator : ExpressionStatement {
+		public enum Mode : byte {
+			PreIncrement, PreDecrement, PostIncrement, PostDecrement
+		}
+		
+		Mode mode;
+		Expression expr;
+		LocalTemporary temp_storage;
+
+		//
+		// This is expensive for the simplest case.
+		//
+		Expression method;
+			
+		public UnaryMutator (Mode m, Expression e, Location l)
+		{
+			mode = m;
+			loc = l;
+			expr = e;
+		}
+
+		static string OperName (Mode mode)
+		{
+			return (mode == Mode.PreIncrement || mode == Mode.PostIncrement) ?
+				"++" : "--";
+		}
+		
+		/// <summary>
+		///   Returns whether an object of type 't' can be incremented
+		///   or decremented with add/sub (ie, basically whether we can
+		///   use pre-post incr-decr operations on it, but it is not a
+		///   System.Decimal, which we require operator overloading to catch)
+		/// </summary>
+		static bool IsIncrementableNumber (Type t)
+		{
+			return (t == TypeManager.sbyte_type) ||
+				(t == TypeManager.byte_type) ||
+				(t == TypeManager.short_type) ||
+				(t == TypeManager.ushort_type) ||
+				(t == TypeManager.int32_type) ||
+				(t == TypeManager.uint32_type) ||
+				(t == TypeManager.int64_type) ||
+				(t == TypeManager.uint64_type) ||
+				(t == TypeManager.char_type) ||
+				(t.IsSubclassOf (TypeManager.enum_type)) ||
+				(t == TypeManager.float_type) ||
+				(t == TypeManager.double_type) ||
+				(t.IsPointer && t != TypeManager.void_ptr_type);
+		}
+
+		Expression ResolveOperator (EmitContext ec)
+		{
+			Type expr_type = expr.Type;
+
+			//
+			// Step 1: Perform Operator Overload location
+			//
+			Expression mg;
+			string op_name;
+			
+			if (mode == Mode.PreIncrement || mode == Mode.PostIncrement)
+				op_name = "op_Increment";
+			else 
+				op_name = "op_Decrement";
+
+			mg = MemberLookup (ec, expr_type, op_name, MemberTypes.Method, AllBindingFlags, loc);
+
+			if (mg == null && expr_type.BaseType != null)
+				mg = MemberLookup (ec, expr_type.BaseType, op_name,
+						   MemberTypes.Method, AllBindingFlags, loc);
+			
+			if (mg != null) {
+				method = StaticCallExpr.MakeSimpleCall (
+					ec, (MethodGroupExpr) mg, expr, loc);
+
+				type = method.Type;
+				return this;
+			}
+
+			//
+			// The operand of the prefix/postfix increment decrement operators
+			// should be an expression that is classified as a variable,
+			// a property access or an indexer access
+			//
+			type = expr_type;
+			if (expr.eclass == ExprClass.Variable){
+				if (IsIncrementableNumber (expr_type) ||
+				    expr_type == TypeManager.decimal_type){
+					return this;
+				}
+			} else if (expr.eclass == ExprClass.IndexerAccess){
+				IndexerAccess ia = (IndexerAccess) expr;
+				
+				temp_storage = new LocalTemporary (ec, expr.Type);
+				
+				expr = ia.ResolveLValue (ec, temp_storage);
+				if (expr == null)
+					return null;
+
+				return this;
+			} else if (expr.eclass == ExprClass.PropertyAccess){
+				PropertyExpr pe = (PropertyExpr) expr;
+
+				if (pe.VerifyAssignable ())
+					return this;
+
+				return null;
+			} else {
+				expr.Error118 ("variable, indexer or property access");
+				return null;
+			}
+
+			Error (187, "No such operator '" + OperName (mode) + "' defined for type '" +
+			       TypeManager.MonoBASIC_Name (expr_type) + "'");
+			return null;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			expr = expr.Resolve (ec);
+			
+			if (expr == null)
+				return null;
+
+			eclass = ExprClass.Value;
+			return ResolveOperator (ec);
+		}
+
+		static int PtrTypeSize (Type t)
+		{
+			return GetTypeSize (t.GetElementType ());
+		}
+
+		//
+		// Loads the proper "1" into the stack based on the type
+		//
+		static void LoadOne (ILGenerator ig, Type t)
+		{
+			if (t == TypeManager.uint64_type || t == TypeManager.int64_type)
+				ig.Emit (OpCodes.Ldc_I8, 1L);
+			else if (t == TypeManager.double_type)
+				ig.Emit (OpCodes.Ldc_R8, 1.0);
+			else if (t == TypeManager.float_type)
+				ig.Emit (OpCodes.Ldc_R4, 1.0F);
+			else if (t.IsPointer){
+				int n = PtrTypeSize (t);
+				
+				if (n == 0)
+					ig.Emit (OpCodes.Sizeof, t);
+				else
+					IntConstant.EmitInt (ig, n);
+			} else 
+				ig.Emit (OpCodes.Ldc_I4_1);
+		}
+
+		
+		//
+		// FIXME: We need some way of avoiding the use of temp_storage
+		// for some types of storage (parameters, local variables,
+		// static fields) and single-dimension array access.
+		//
+		void EmitCode (EmitContext ec, bool is_expr)
+		{
+			ILGenerator ig = ec.ig;
+			IAssignMethod ia = (IAssignMethod) expr;
+			Type expr_type = expr.Type;
+			
+			if (temp_storage == null)
+				temp_storage = new LocalTemporary (ec, expr_type);
+
+			ia.CacheTemporaries (ec);
+			ig.Emit (OpCodes.Nop);
+			switch (mode){
+			case Mode.PreIncrement:
+			case Mode.PreDecrement:
+				if (method == null){
+					expr.Emit (ec);
+
+					LoadOne (ig, expr_type);
+					
+					//
+					// Select the opcode based on the check state (then the type)
+					// and the actual operation
+					//
+					if (ec.CheckState){
+						if (expr_type == TypeManager.int32_type ||
+						    expr_type == TypeManager.int64_type){
+							if (mode == Mode.PreDecrement)
+								ig.Emit (OpCodes.Sub_Ovf);
+							else
+								ig.Emit (OpCodes.Add_Ovf);
+						} else if (expr_type == TypeManager.uint32_type ||
+							   expr_type == TypeManager.uint64_type){
+							if (mode == Mode.PreDecrement)
+								ig.Emit (OpCodes.Sub_Ovf_Un);
+							else
+								ig.Emit (OpCodes.Add_Ovf_Un);
+						} else {
+							if (mode == Mode.PreDecrement)
+								ig.Emit (OpCodes.Sub_Ovf);
+							else
+								ig.Emit (OpCodes.Add_Ovf);
+						}
+					} else {
+						if (mode == Mode.PreDecrement)
+							ig.Emit (OpCodes.Sub);
+						else
+							ig.Emit (OpCodes.Add);
+					}
+				} else 
+					method.Emit (ec);
+
+				temp_storage.Store (ec);
+				ia.EmitAssign (ec, temp_storage);
+				if (is_expr)
+					temp_storage.Emit (ec);
+				break;
+				
+			case Mode.PostIncrement:
+			case Mode.PostDecrement:
+				if (is_expr)
+					expr.Emit (ec);
+				
+				if (method == null){
+					if (!is_expr)
+						expr.Emit (ec);
+					else
+						ig.Emit (OpCodes.Dup);
+
+					LoadOne (ig, expr_type);
+					
+					if (ec.CheckState){
+						if (expr_type == TypeManager.int32_type ||
+						    expr_type == TypeManager.int64_type){
+							if (mode == Mode.PostDecrement)
+								ig.Emit (OpCodes.Sub_Ovf);
+							else
+								ig.Emit (OpCodes.Add_Ovf);
+						} else if (expr_type == TypeManager.uint32_type ||
+							   expr_type == TypeManager.uint64_type){
+							if (mode == Mode.PostDecrement)
+								ig.Emit (OpCodes.Sub_Ovf_Un);
+							else
+								ig.Emit (OpCodes.Add_Ovf_Un);
+						} else {
+							if (mode == Mode.PostDecrement)
+								ig.Emit (OpCodes.Sub_Ovf);
+							else
+								ig.Emit (OpCodes.Add_Ovf);
+						}
+					} else {
+						if (mode == Mode.PostDecrement)
+							ig.Emit (OpCodes.Sub);
+						else
+							ig.Emit (OpCodes.Add);
+					}
+				} else {
+					method.Emit (ec);
+				}
+				
+				temp_storage.Store (ec);
+				ia.EmitAssign (ec, temp_storage);
+				break;
+			}
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			EmitCode (ec, true);
+			
+		}
+		
+		public override void EmitStatement (EmitContext ec)
+		{
+			EmitCode (ec, false);
+		}
+
+	}
+
+	/// <summary>
+	///   Base class for the 'Is' and 'As' classes. 
+	/// </summary>
+	///
+	/// <remarks>
+	///   FIXME: Split this in two, and we get to save the 'Operator' Oper
+	///   size. 
+	/// </remarks>
+	public abstract class Probe : Expression {
+		public readonly Expression ProbeType;
+		protected Expression expr;
+		protected Type probe_type;
+		
+		public Probe (Expression expr, Expression probe_type, Location l)
+		{
+			ProbeType = probe_type;
+			loc = l;
+			this.expr = expr;
+		}
+
+		public Expression Expr {
+			get {
+				return expr;
+			}
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			 probe_type = ec.DeclSpace.ResolveType (ProbeType, false, loc);
+
+			if (probe_type == null)
+				return null;
+
+			expr = expr.Resolve (ec);
+			
+			return this;
+		}
+	}
+
+	/// <summary>
+	///   Implementation of the 'is' operator.
+	/// </summary>
+	public class Is : Probe {
+		public Is (Expression expr, Expression probe_type, Location l)
+			: base (expr, probe_type, l)
+		{
+		}
+
+		enum Action {
+			AlwaysTrue, AlwaysNull, AlwaysFalse, LeaveOnStack, Probe
+		}
+
+		Action action;
+		
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+
+			expr.Emit (ec);
+
+			switch (action){
+			case Action.AlwaysFalse:
+				ig.Emit (OpCodes.Pop);
+				IntConstant.EmitInt (ig, 0);
+				return;
+			case Action.AlwaysTrue:
+				ig.Emit (OpCodes.Pop);
+				ig.Emit (OpCodes.Nop);
+				IntConstant.EmitInt (ig, 1);
+				return;
+			case Action.LeaveOnStack:
+				// the 'e != null' rule.
+				return;
+			case Action.Probe:
+				ig.Emit (OpCodes.Isinst, probe_type);
+				ig.Emit (OpCodes.Ldnull);
+				ig.Emit (OpCodes.Cgt_Un);
+				return;
+			}
+			throw new Exception ("never reached");
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			Expression e = base.DoResolve (ec);
+
+			if ((e == null) || (expr == null))
+				return null;
+
+			Type etype = expr.Type;
+			bool warning_always_matches = false;
+			bool warning_never_matches = false;
+
+			type = TypeManager.bool_type;
+			eclass = ExprClass.Value;
+
+			//
+			// First case, if at compile time, there is an implicit conversion
+			// then e != null (objects) or true (value types)
+			//
+			e = ConvertImplicitStandard (ec, expr, probe_type, loc);
+			if (e != null){
+				expr = e;
+				if (etype.IsValueType)
+					action = Action.AlwaysTrue;
+				else
+					action = Action.LeaveOnStack;
+
+				warning_always_matches = true;
+			} else if (ExplicitReferenceConversionExists (etype, probe_type)){
+				//
+				// Second case: explicit reference convresion
+				//
+				if (expr is NullLiteral)
+					action = Action.AlwaysFalse;
+				else
+					action = Action.Probe;
+			} else {
+				action = Action.AlwaysFalse;
+				warning_never_matches = true;
+			}
+			
+			if (RootContext.WarningLevel >= 1){
+				if (warning_always_matches)
+					Warning (
+						183,
+						"The expression is always of type '" +
+						TypeManager.MonoBASIC_Name (probe_type) + "'");
+				else if (warning_never_matches){
+					if (!(probe_type.IsInterface || expr.Type.IsInterface))
+						Warning (
+							184,
+							"The expression is never of type '" +
+							TypeManager.MonoBASIC_Name (probe_type) + "'");
+				}
+			}
+
+			return this;
+		}				
+	}
+
+	/// <summary>
+	///   Implementation of the 'as' operator.
+	/// </summary>
+	public class As : Probe {
+		public As (Expression expr, Expression probe_type, Location l)
+			: base (expr, probe_type, l)
+		{
+		}
+
+		bool do_isinst = false;
+		
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+
+			expr.Emit (ec);
+
+			if (do_isinst)
+				ig.Emit (OpCodes.Isinst, probe_type);
+		}
+
+		static void Error_CannotConvertType (Type source, Type target, Location loc)
+		{
+			Report.Error (
+				39, loc, "as operator can not convert from '" +
+				TypeManager.MonoBASIC_Name (source) + "' to '" +
+				TypeManager.MonoBASIC_Name (target) + "'");
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			Expression e = base.DoResolve (ec);
+
+			if (e == null)
+				return null;
+
+			type = probe_type;
+			eclass = ExprClass.Value;
+			Type etype = expr.Type;
+
+			if (TypeManager.IsValueType (probe_type)){
+				Report.Error (77, loc, "The as operator should be used with a reference type only (" +
+					      TypeManager.MonoBASIC_Name (probe_type) + " is a value type)");
+				return null;
+			
+			}
+			
+			e = ConvertImplicit (ec, expr, probe_type, loc);
+			if (e != null){
+				expr = e;
+				do_isinst = false;
+				return this;
+			}
+
+			if (ExplicitReferenceConversionExists (etype, probe_type)){
+				do_isinst = true;
+				return this;
+			}
+
+			Error_CannotConvertType (etype, probe_type, loc);
+			return null;
+		}				
+	}
+	
+	/// <summary>
+	///   This represents a typecast in the source language.
+	///
+	///   FIXME: Cast expressions have an unusual set of parsing
+	///   rules, we need to figure those out.
+	/// </summary>
+	public class Cast : Expression {
+		Expression target_type;
+		Expression expr;
+		bool runtime_cast;
+			
+		public Cast (Expression cast_type, Expression expr, Location loc)
+		{
+			this.target_type = cast_type;
+			this.expr = expr;
+			this.loc = loc;
+			runtime_cast = false;
+		}
+
+		public Expression TargetType {
+			get {
+				return target_type;
+			}
+		}
+
+		public Expression Expr {
+			get {
+				return expr;
+			}
+			set {
+				expr = value;
+			}
+		}
+
+		public bool IsRuntimeCast
+		{
+			get {
+				return runtime_cast;
+			}
+			set{
+				runtime_cast = value;
+			}
+		}
+
+		/// <summary>
+		///   Attempts to do a compile-time folding of a constant cast.
+		/// </summary>
+		Expression TryReduce (EmitContext ec, Type target_type)
+		{
+			if (expr is ByteConstant){
+				byte v = ((ByteConstant) expr).Value;
+	
+				if (target_type == TypeManager.sbyte_type)
+					return new SByteConstant ((sbyte) v);
+				if (target_type == TypeManager.short_type)
+					return new ShortConstant ((short) v);
+				if (target_type == TypeManager.ushort_type)
+					return new UShortConstant ((ushort) v);
+				if (target_type == TypeManager.int32_type)
+					return new IntConstant ((int) v);
+				if (target_type == TypeManager.uint32_type)
+					return new UIntConstant ((uint) v);
+				if (target_type == TypeManager.int64_type)
+					return new LongConstant ((long) v);
+				if (target_type == TypeManager.uint64_type)
+					return new ULongConstant ((ulong) v);
+				if (target_type == TypeManager.float_type)
+					return new FloatConstant ((float) v);
+				if (target_type == TypeManager.double_type)
+					return new DoubleConstant ((double) v);
+				if (target_type == TypeManager.char_type)
+					return new CharConstant ((char) v);
+				if (target_type == TypeManager.decimal_type)
+					return new DecimalConstant ((decimal) v);
+			}
+			if (expr is SByteConstant){
+				sbyte v = ((SByteConstant) expr).Value;
+	
+				if (target_type == TypeManager.byte_type)
+					return new ByteConstant ((byte) v);
+				if (target_type == TypeManager.short_type)
+					return new ShortConstant ((short) v);
+				if (target_type == TypeManager.ushort_type)
+					return new UShortConstant ((ushort) v);
+				if (target_type == TypeManager.int32_type)
+					return new IntConstant ((int) v);
+				if (target_type == TypeManager.uint32_type)
+					return new UIntConstant ((uint) v);
+				if (target_type == TypeManager.int64_type)
+					return new LongConstant ((long) v);
+				if (target_type == TypeManager.uint64_type)
+					return new ULongConstant ((ulong) v);
+				if (target_type == TypeManager.float_type)
+					return new FloatConstant ((float) v);
+				if (target_type == TypeManager.double_type)
+					return new DoubleConstant ((double) v);
+				if (target_type == TypeManager.char_type)
+					return new CharConstant ((char) v);
+				if (target_type == TypeManager.decimal_type)
+					return new DecimalConstant ((decimal) v);
+			}
+			if (expr is ShortConstant){
+				short v = ((ShortConstant) expr).Value;
+	
+				if (target_type == TypeManager.byte_type)
+					return new ByteConstant ((byte) v);
+				if (target_type == TypeManager.sbyte_type)
+					return new SByteConstant ((sbyte) v);
+				if (target_type == TypeManager.ushort_type)
+					return new UShortConstant ((ushort) v);
+				if (target_type == TypeManager.int32_type)
+					return new IntConstant ((int) v);
+				if (target_type == TypeManager.uint32_type)
+					return new UIntConstant ((uint) v);
+				if (target_type == TypeManager.int64_type)
+					return new LongConstant ((long) v);
+				if (target_type == TypeManager.uint64_type)
+					return new ULongConstant ((ulong) v);
+				if (target_type == TypeManager.float_type)
+					return new FloatConstant ((float) v);
+				if (target_type == TypeManager.double_type)
+					return new DoubleConstant ((double) v);
+				if (target_type == TypeManager.char_type)
+					return new CharConstant ((char) v);
+				if (target_type == TypeManager.decimal_type)
+					return new DecimalConstant ((decimal) v);
+			}
+			if (expr is UShortConstant){
+				ushort v = ((UShortConstant) expr).Value;
+	
+				if (target_type == TypeManager.byte_type)
+					return new ByteConstant ((byte) v);
+				if (target_type == TypeManager.sbyte_type)
+					return new SByteConstant ((sbyte) v);
+				if (target_type == TypeManager.short_type)
+					return new ShortConstant ((short) v);
+				if (target_type == TypeManager.int32_type)
+					return new IntConstant ((int) v);
+				if (target_type == TypeManager.uint32_type)
+					return new UIntConstant ((uint) v);
+				if (target_type == TypeManager.int64_type)
+					return new LongConstant ((long) v);
+				if (target_type == TypeManager.uint64_type)
+					return new ULongConstant ((ulong) v);
+				if (target_type == TypeManager.float_type)
+					return new FloatConstant ((float) v);
+				if (target_type == TypeManager.double_type)
+					return new DoubleConstant ((double) v);
+				if (target_type == TypeManager.char_type)
+					return new CharConstant ((char) v);
+				if (target_type == TypeManager.decimal_type)
+					return new DecimalConstant ((decimal) v);
+			}
+			if (expr is IntConstant){
+				int v = ((IntConstant) expr).Value;
+	
+				if (target_type == TypeManager.byte_type)
+					return new ByteConstant ((byte) v);
+				if (target_type == TypeManager.sbyte_type)
+					return new SByteConstant ((sbyte) v);
+				if (target_type == TypeManager.short_type)
+					return new ShortConstant ((short) v);
+				if (target_type == TypeManager.ushort_type)
+					return new UShortConstant ((ushort) v);
+				if (target_type == TypeManager.uint32_type)
+					return new UIntConstant ((uint) v);
+				if (target_type == TypeManager.int64_type)
+					return new LongConstant ((long) v);
+				if (target_type == TypeManager.uint64_type)
+					return new ULongConstant ((ulong) v);
+				if (target_type == TypeManager.float_type)
+					return new FloatConstant ((float) v);
+				if (target_type == TypeManager.double_type)
+					return new DoubleConstant ((double) v);
+				if (target_type == TypeManager.char_type)
+					return new CharConstant ((char) v);
+				if (target_type == TypeManager.decimal_type)
+					return new DecimalConstant ((decimal) v);
+			}
+			if (expr is UIntConstant){
+				uint v = ((UIntConstant) expr).Value;
+	
+				if (target_type == TypeManager.byte_type)
+					return new ByteConstant ((byte) v);
+				if (target_type == TypeManager.sbyte_type)
+					return new SByteConstant ((sbyte) v);
+				if (target_type == TypeManager.short_type)
+					return new ShortConstant ((short) v);
+				if (target_type == TypeManager.ushort_type)
+					return new UShortConstant ((ushort) v);
+				if (target_type == TypeManager.int32_type)
+					return new IntConstant ((int) v);
+				if (target_type == TypeManager.int64_type)
+					return new LongConstant ((long) v);
+				if (target_type == TypeManager.uint64_type)
+					return new ULongConstant ((ulong) v);
+				if (target_type == TypeManager.float_type)
+					return new FloatConstant ((float) v);
+				if (target_type == TypeManager.double_type)
+					return new DoubleConstant ((double) v);
+				if (target_type == TypeManager.char_type)
+					return new CharConstant ((char) v);
+				if (target_type == TypeManager.decimal_type)
+					return new DecimalConstant ((decimal) v);
+			}
+			if (expr is LongConstant){
+				long v = ((LongConstant) expr).Value;
+	
+				if (target_type == TypeManager.byte_type)
+					return new ByteConstant ((byte) v);
+				if (target_type == TypeManager.sbyte_type)
+					return new SByteConstant ((sbyte) v);
+				if (target_type == TypeManager.short_type)
+					return new ShortConstant ((short) v);
+				if (target_type == TypeManager.ushort_type)
+					return new UShortConstant ((ushort) v);
+				if (target_type == TypeManager.int32_type)
+					return new IntConstant ((int) v);
+				if (target_type == TypeManager.uint32_type)
+					return new UIntConstant ((uint) v);
+				if (target_type == TypeManager.uint64_type)
+					return new ULongConstant ((ulong) v);
+				if (target_type == TypeManager.float_type)
+					return new FloatConstant ((float) v);
+				if (target_type == TypeManager.double_type)
+					return new DoubleConstant ((double) v);
+				if (target_type == TypeManager.char_type)
+					return new CharConstant ((char) v);
+				if (target_type == TypeManager.decimal_type)
+					return new DecimalConstant ((decimal) v);
+			}
+			if (expr is ULongConstant){
+				ulong v = ((ULongConstant) expr).Value;
+	
+				if (target_type == TypeManager.byte_type)
+					return new ByteConstant ((byte) v);
+				if (target_type == TypeManager.sbyte_type)
+					return new SByteConstant ((sbyte) v);
+				if (target_type == TypeManager.short_type)
+					return new ShortConstant ((short) v);
+				if (target_type == TypeManager.ushort_type)
+					return new UShortConstant ((ushort) v);
+				if (target_type == TypeManager.int32_type)
+					return new IntConstant ((int) v);
+				if (target_type == TypeManager.uint32_type)
+					return new UIntConstant ((uint) v);
+				if (target_type == TypeManager.int64_type)
+					return new LongConstant ((long) v);
+				if (target_type == TypeManager.float_type)
+					return new FloatConstant ((float) v);
+				if (target_type == TypeManager.double_type)
+					return new DoubleConstant ((double) v);
+				if (target_type == TypeManager.char_type)
+					return new CharConstant ((char) v);
+				if (target_type == TypeManager.decimal_type)
+					return new DecimalConstant ((decimal) v);
+			}
+			if (expr is FloatConstant){
+				float v = ((FloatConstant) expr).Value;
+	
+				if (target_type == TypeManager.byte_type)
+					return new ByteConstant ((byte) v);
+				if (target_type == TypeManager.sbyte_type)
+					return new SByteConstant ((sbyte) v);
+				if (target_type == TypeManager.short_type)
+					return new ShortConstant ((short) v);
+				if (target_type == TypeManager.ushort_type)
+					return new UShortConstant ((ushort) v);
+				if (target_type == TypeManager.int32_type)
+					return new IntConstant ((int) v);
+				if (target_type == TypeManager.uint32_type)
+					return new UIntConstant ((uint) v);
+				if (target_type == TypeManager.int64_type)
+					return new LongConstant ((long) v);
+				if (target_type == TypeManager.uint64_type)
+					return new ULongConstant ((ulong) v);
+				if (target_type == TypeManager.double_type)
+					return new DoubleConstant ((double) v);
+				if (target_type == TypeManager.char_type)
+					return new CharConstant ((char) v);
+				if (target_type == TypeManager.decimal_type)
+					return new DecimalConstant ((decimal) v);
+			}
+			if (expr is DoubleConstant){
+				double v = ((DoubleConstant) expr).Value;
+	
+				if (target_type == TypeManager.byte_type)
+					return new ByteConstant ((byte) v);
+				if (target_type == TypeManager.sbyte_type)
+					return new SByteConstant ((sbyte) v);
+				if (target_type == TypeManager.short_type)
+					return new ShortConstant ((short) v);
+				if (target_type == TypeManager.ushort_type)
+					return new UShortConstant ((ushort) v);
+				if (target_type == TypeManager.int32_type)
+					return new IntConstant ((int) v);
+				if (target_type == TypeManager.uint32_type)
+					return new UIntConstant ((uint) v);
+				if (target_type == TypeManager.int64_type)
+					return new LongConstant ((long) v);
+				if (target_type == TypeManager.uint64_type)
+					return new ULongConstant ((ulong) v);
+				if (target_type == TypeManager.float_type)
+					return new FloatConstant ((float) v);
+				if (target_type == TypeManager.char_type)
+					return new CharConstant ((char) v);
+				if (target_type == TypeManager.decimal_type)
+					return new DecimalConstant ((decimal) v);
+			}
+
+			return null;
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			expr = expr.Resolve (ec);
+			if (expr == null)
+				return null;
+
+			type = ec.DeclSpace.ResolveType (target_type, false, Location);
+
+			if (type == null)
+				return null;
+
+			eclass = ExprClass.Value;
+			
+			if (expr is Constant){
+				Expression e = TryReduce (ec, type);
+
+				if (e != null)
+					return e;
+			}
+			
+			expr = ConvertExplicit (ec, expr, type, runtime_cast, loc);
+			return expr;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			//
+			// This one will never happen
+			//
+			throw new Exception ("Should not happen");
+		}
+	}
+
+        public class StringConcat : Expression {
+
+		Expression left, right;
+		ArrayList Arguments; 
+		protected MethodBase method;
+	
+		public StringConcat(Location loc, Expression left, Expression right) {
+			this.left = left;
+			this.right = right;
+			this.loc = loc;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			left = left.Resolve (ec);
+			right = right.Resolve (ec);
+
+			if (left == null || right == null)
+				return null;
+
+			if (left.Type == null)
+				throw new Exception (
+					"Resolve returned non null, but did not set the type! (" +
+					left + ") at Line: " + loc.Row);
+			if (right.Type == null)
+				throw new Exception (
+					"Resolve returned non null, but did not set the type! (" +
+					right + ") at Line: "+ loc.Row);
+
+			eclass = ExprClass.Value;
+			if (left is StringConstant && right is StringConstant){
+				return new StringConstant (
+							   ((StringConstant) left).Value +
+							   ((StringConstant) right).Value);
+			}
+			
+			Type l = left.Type;
+			Type r = right.Type;
+
+			if (l == TypeManager.string_type && r == TypeManager.string_type) {
+				type = TypeManager.string_type;
+				method = TypeManager.string_concat_string_string;
+				Arguments = new ArrayList ();
+				Arguments.Add (new Argument (left, Argument.AType.Expression));
+				Arguments.Add (new Argument (right, Argument.AType.Expression));
+				return this;
+			}
+
+			if (l != TypeManager.string_type) {
+				method = TypeManager.string_concat_object_object;
+				left = ConvertImplicit (ec, left, TypeManager.string_type, loc);
+				if (left == null){
+					Error_OperatorCannotBeApplied (loc, "&", l, r);
+					return null;
+				}
+                                        
+				type = TypeManager.string_type;
+				Arguments = new ArrayList ();
+				Arguments.Add (new Argument (left, Argument.AType.Expression));
+				Arguments.Add (new Argument (right, Argument.AType.Expression));
+				return this;
+			}
+
+			if (r != TypeManager.string_type) {
+				method = TypeManager.string_concat_object_object;
+				right = ConvertImplicit (ec, right, TypeManager.string_type, loc);
+				if (right == null){
+					Error_OperatorCannotBeApplied (loc, "&", l, r);
+					return null;
+				}
+                                        
+				type = TypeManager.string_type;
+				Arguments = new ArrayList ();
+				Arguments.Add (new Argument (left, Argument.AType.Expression));
+				Arguments.Add (new Argument (right, Argument.AType.Expression));
+				return this;
+			}
+			return this;
+		}
+
+                public override void Emit (EmitContext ec)
+                {
+                        ILGenerator ig = ec.ig;
+                        if (method != null) {
+                                // Note that operators are static anyway
+                                if (Arguments != null)
+                                        Invocation.EmitArguments (ec, method, Arguments);
+                                if (method is MethodInfo)
+                                        ig.Emit (OpCodes.Call, (MethodInfo) method);
+                                else
+                                        ig.Emit (OpCodes.Call, (ConstructorInfo) method);
+
+                                return;
+                        }
+		}
+
+                static public void Error_OperatorCannotBeApplied (Location loc, string name, Type l, Type r)
+                {  
+	                 Report.Error (19, loc,
+                               "Operator " + name + " cannot be applied to operands of type '" +
+                               TypeManager.MonoBASIC_Name (l) + "' and '" +
+                               TypeManager.MonoBASIC_Name (r) + "'");
+                }
+
+        }
+
+
+	/// <summary>
+	///   Binary operators
+	/// </summary>
+	public class Binary : Expression {
+		public enum Operator : byte {
+			Exponentiation,
+			Multiply, Division, IntDivision, Modulus,
+			Addition, Subtraction, Concat,
+			LeftShift, RightShift,
+			LessThan, GreaterThan, LessThanOrEqual, GreaterThanOrEqual, 
+			Equality, Inequality,
+			Like,
+			BitwiseAnd,
+			ExclusiveOr,
+			BitwiseOr,
+			LogicalAnd,
+			LogicalOr,
+			Is,
+			TOP
+		}
+
+		Operator oper;
+		Expression left, right;
+
+		//
+		// After resolution, method might contain the operator overload
+		// method.
+		//
+		protected MethodBase method;
+		ArrayList  Arguments;
+
+		bool DelegateOperation;
+
+		// This must be kept in sync with Operator!!!
+		static string [] oper_names;
+
+		static Binary ()
+		{
+			oper_names = new string [(int) Operator.TOP];
+
+			oper_names [(int) Operator.Multiply] = "op_Multiply";
+			oper_names [(int) Operator.Division] = "op_Division";
+			oper_names [(int) Operator.IntDivision] = "op_Division";
+			oper_names [(int) Operator.Modulus] = "op_Modulus";
+			oper_names [(int) Operator.Addition] = "op_Addition";
+			oper_names [(int) Operator.Subtraction] = "op_Subtraction";
+			oper_names [(int) Operator.LeftShift] = "op_LeftShift";
+			oper_names [(int) Operator.RightShift] = "op_RightShift";
+			oper_names [(int) Operator.LessThan] = "op_LessThan";
+			oper_names [(int) Operator.GreaterThan] = "op_GreaterThan";
+			oper_names [(int) Operator.LessThanOrEqual] = "op_LessThanOrEqual";
+			oper_names [(int) Operator.GreaterThanOrEqual] = "op_GreaterThanOrEqual";
+			oper_names [(int) Operator.Equality] = "op_Equality";
+			oper_names [(int) Operator.Inequality] = "op_Inequality";
+			oper_names [(int) Operator.BitwiseAnd] = "op_BitwiseAnd";
+			oper_names [(int) Operator.BitwiseOr] = "op_BitwiseOr";
+			oper_names [(int) Operator.ExclusiveOr] = "op_ExclusiveOr";
+			oper_names [(int) Operator.LogicalOr] = "op_LogicalOr";
+			oper_names [(int) Operator.LogicalAnd] = "op_LogicalAnd";
+			oper_names [(int) Operator.Is] = "op_Is";
+		}
+
+		public Binary (Operator oper, Expression left, Expression right, Location loc)
+		{
+			left = Parser.SetValueRequiredFlag (left);
+			right = Parser.SetValueRequiredFlag (right);
+			this.oper = oper;
+			this.left = left;
+			this.right = right;
+			this.loc = loc;
+		}
+
+		public Operator Oper {
+			get {
+				return oper;
+			}
+			set {
+				oper = value;
+			}
+		}
+		
+		public Expression Left {
+			get {
+				return left;
+			}
+			set {
+				left = value;
+			}
+		}
+
+		public Expression Right {
+			get {
+				return right;
+			}
+			set {
+				right = value;
+			}
+		}
+
+
+		/// <summary>
+		///   Returns a stringified representation of the Operator
+		/// </summary>
+		static string OperName (Operator oper)
+		{
+			switch (oper){
+			case Operator.Exponentiation:
+				return "^";
+			case Operator.Multiply:
+				return "*";
+			case Operator.Division:
+				return "/";
+			case Operator.IntDivision:
+				return "\\";
+			case Operator.Modulus:
+				return "Mod";
+			case Operator.Addition:
+				return "+";
+			case Operator.Subtraction:
+				return "-";
+			case Operator.LeftShift:
+				return "<<";
+			case Operator.RightShift:
+				return ">>";
+			case Operator.LessThan:
+				return "<";
+			case Operator.GreaterThan:
+				return ">";
+			case Operator.LessThanOrEqual:
+				return "<=";
+			case Operator.GreaterThanOrEqual:
+				return ">=";
+			case Operator.Equality:
+				return "=";
+			case Operator.Inequality:
+				return "<>";
+			case Operator.BitwiseAnd:
+				return "And";
+			case Operator.BitwiseOr:
+				return "Or";
+			case Operator.ExclusiveOr:
+				return "^";
+			case Operator.LogicalOr:
+				return "Or";
+			case Operator.LogicalAnd:
+				return "And";
+			case Operator.Is:
+				return "Is";
+			}
+
+			return oper.ToString ();
+		}
+
+		public override string ToString ()
+		{
+			return "operator " + OperName (oper) + "(" + left.ToString () + ", " +
+				right.ToString () + ")";
+		}
+		
+		Expression ForceConversion (EmitContext ec, Expression expr, Type target_type)
+		{
+			if (expr.Type == target_type)
+				return expr;
+
+			return ConvertImplicit (ec, expr, target_type, Location.Null);
+		}
+
+		public static void Error_OperatorAmbiguous (Location loc, Operator oper, Type l, Type r)
+		{
+			Report.Error (
+				34, loc, "Operator '" + OperName (oper) 
+				+ "' is ambiguous on operands of type '"
+				+ TypeManager.MonoBASIC_Name (l) + "' "
+				+ "and '" + TypeManager.MonoBASIC_Name (r)
+				+ "'");
+		}
+
+		//
+		// Handles boolean types also
+		//
+		bool DoNumericPromotions (EmitContext ec, Type l, Type r, Operator oper)
+		{
+
+			Type conv_left_as = null;
+			Type conv_right_as = null;
+			if (left is NullLiteral)
+				conv_left_as = r;
+			if (right is NullLiteral)
+				conv_right_as = l;
+
+			// Need not do anything for shift operators, as this will be handled by the
+			// 'CheckShiftArguments' method
+			if (oper == Operator.LeftShift || oper == Operator.RightShift)
+				return true;
+			if (l == TypeManager.bool_type && r == TypeManager.bool_type) {
+				if (IsArithmaticOperator (oper) && oper != Operator.Division) {
+					type = TypeManager.int32_type;
+					conv_left_as = conv_right_as = TypeManager.short_type;
+				}
+			}
+
+			if (IsBitwiseOperator (oper)) {
+
+				if (l == TypeManager.decimal_type || 
+				    l == TypeManager.double_type ||
+				    l == TypeManager.float_type) {
+					conv_left_as = type = TypeManager.int64_type;
+					l = conv_left_as;
+				}
+				if (r == TypeManager.decimal_type || 
+				    r == TypeManager.double_type ||
+				    r == TypeManager.float_type) {
+					conv_right_as = type = TypeManager.int64_type;
+					r = conv_right_as;
+				}
+			}
+
+			if (oper == Operator.IntDivision) {
+				if (l == TypeManager.decimal_type || r == TypeManager.decimal_type ||
+				    l == TypeManager.float_type || r == TypeManager.float_type ||
+				    l == TypeManager.double_type || r == TypeManager.double_type) 
+					conv_left_as = conv_right_as = TypeManager.int64_type;
+					l = r = TypeManager.int64_type;
+			}
+
+			if (IsLogicalOperator (oper)) {
+				if (l == TypeManager.decimal_type)
+					conv_left_as = TypeManager.bool_type;
+				else if (r == TypeManager.decimal_type)
+					conv_right_as = TypeManager.bool_type;
+			} else if ((l == TypeManager.double_type || r == TypeManager.double_type) ||
+				   (oper == Operator.Exponentiation) ||
+			    	   (oper == Operator.Division && 
+			    	   !(l == TypeManager.decimal_type || r == TypeManager.decimal_type))) {
+				//
+				// If either operand is of type double, the other operand is
+				// conveted to type double.
+				//
+				type = conv_left_as = conv_right_as = TypeManager.double_type;
+				
+			} else if (l == TypeManager.float_type || r == TypeManager.float_type){
+				//
+				// if either operand is of type float, the other operand is
+				// converted to type float.
+				//
+				type = conv_left_as = conv_right_as = TypeManager.float_type;
+			} else if (l == TypeManager.decimal_type || r == TypeManager.decimal_type){
+				type = conv_left_as = conv_right_as = TypeManager.decimal_type;
+			} else if (l == TypeManager.int64_type || r == TypeManager.int64_type){
+				//
+				// If either operand is of type long, the other operand is converted
+				// to type long.
+				//
+				type = conv_left_as = conv_right_as = TypeManager.int64_type;
+			} else if (l == TypeManager.int32_type || r == TypeManager.int32_type){
+				type = conv_left_as = conv_right_as = TypeManager.int32_type;
+			} else if (l == TypeManager.short_type || r == TypeManager.short_type){
+				conv_left_as = conv_right_as = TypeManager.short_type;
+				type = TypeManager.int32_type;
+			} else {
+				type = TypeManager.int32_type;
+			}
+
+			if (conv_left_as != null)
+				left = ConvertImplicit (ec, left, conv_left_as, loc);
+			if (conv_right_as != null)
+				right = ConvertImplicit (ec, right, conv_right_as, loc);
+
+			return (left != null) && (right != null);
+		}
+
+		static public void Error_OperatorCannotBeApplied (Location loc, string name, Type l, Type r)
+		{
+			Report.Error (19, loc,
+			       "Operator '" + name + "' cannot be applied to operands of type '" +
+			       TypeManager.MonoBASIC_Name (l) + "' and '" +
+			       TypeManager.MonoBASIC_Name (r) + "'");
+		}
+		
+		void Error_OperatorCannotBeApplied ()
+		{
+			Error_OperatorCannotBeApplied (loc, OperName (oper), left.Type, right.Type);
+		}
+
+		static bool is_32_or_64 (Type t)
+		{
+			return (t == TypeManager.int32_type || t == TypeManager.uint32_type ||
+				t == TypeManager.int64_type || t == TypeManager.uint64_type);
+		}
+
+		static bool is_unsigned (Type t)
+		{
+			return (t == TypeManager.uint32_type || t == TypeManager.uint64_type ||
+				t == TypeManager.short_type || t == TypeManager.byte_type);
+		}
+					
+		Expression CheckShiftArguments (EmitContext ec)
+		{
+			Expression e;
+
+			e = ForceConversion (ec, right, TypeManager.int32_type);
+			if (e == null){
+				Error_OperatorCannotBeApplied ();
+				return null;
+			}
+
+			type = left.Type;
+			if (left is NullLiteral) {
+				type = right.Type; 
+				if (right.Type != TypeManager.bool_type) {
+					left =  ConvertImplicit (ec, left, right.Type, loc);
+					if (left == null) {
+						Error_OperatorCannotBeApplied (loc, OperName (oper), left.Type, right.Type);
+						return null;
+					}
+				}
+			}
+			right = e;
+
+			if (type == TypeManager.bool_type) {
+				left = ConvertImplicit (ec, left, TypeManager.short_type, loc);
+				if (left == null) {
+					Error_OperatorCannotBeApplied (loc, OperName (oper), left.Type, right.Type);
+					return null;
+				}
+				type = left.Type;
+			}
+
+			int mask = 0;
+			if ( type == TypeManager.byte_type)
+				mask = 7;
+			else if (type == TypeManager.short_type || type == TypeManager.bool_type)
+				mask = 15;
+			else if (type == TypeManager.int32_type || type == TypeManager.uint32_type)
+				mask = 31;
+			else 
+				mask = 63;
+			if (mask != 0) {
+				right = new Binary (Binary.Operator.BitwiseAnd, right, new IntLiteral (mask), loc);
+				right = right.DoResolve (ec);
+			}
+
+			if (type == TypeManager.byte_type || 
+			    type == TypeManager.short_type ||
+			    type == TypeManager.int32_type) {
+				type = TypeManager.int32_type;
+				return this;
+			}
+
+			if (type == TypeManager.int64_type)
+				return this;
+			if ((e = ConvertImplicit (ec, left, TypeManager.int64_type, loc)) != null) {
+				left = e;
+				type = TypeManager.int64_type;
+				return this;
+			}
+
+			Error_OperatorCannotBeApplied ();
+			return null;
+		}
+
+		bool IsRelationalOperator (Binary.Operator oper) {
+			return (oper == Operator.Equality ||
+				oper == Operator.Inequality ||	
+				oper == Operator.LessThan ||	
+				oper == Operator.LessThanOrEqual ||	
+				oper == Operator.GreaterThan ||	
+				oper == Operator.GreaterThanOrEqual);
+		}
+
+		bool IsArithmaticOperator (Binary.Operator oper) {
+			return (oper == Operator.Addition ||
+				oper == Operator.Subtraction ||	
+				oper == Operator.Multiply ||	
+				oper == Operator.Division ||	
+				oper == Operator.IntDivision ||	
+				oper == Operator.Exponentiation ||	
+				oper == Operator.Modulus);
+		}
+
+		bool IsShiftOperator (Binary.Operator oper) {
+			return (oper == Operator.LeftShift ||
+				oper == Operator.RightShift);
+		}
+
+		bool IsLogicalOperator (Binary.Operator oper) {
+			return (oper == Operator.LogicalOr ||
+				oper == Operator.LogicalAnd);
+		}
+
+		bool IsBitwiseOperator (Binary.Operator oper) {
+			return (oper == Operator.BitwiseOr ||
+				oper == Operator.BitwiseAnd ||
+				oper == Operator.ExclusiveOr);
+		}
+
+		Expression ResolveOperator (EmitContext ec)
+		{
+			Type l = left.Type;
+			Type r = right.Type;
+
+			Expression left_expr, right_expr;
+			left_expr = right_expr = null;
+
+			if (oper == Operator.Addition && right is Unary) {
+				Unary unary_right = (Unary) right;
+				if (unary_right.Oper == Unary.Operator.UnaryNegation) {
+					oper = Operator.Subtraction;
+					right = unary_right.Expr;
+					r = right.Type;
+				}
+			}
+
+			if (TypeManager.IsEnumType (l)) 
+				l = TypeManager.EnumToUnderlying (l);
+			if (TypeManager.IsEnumType (r)) 
+				r = TypeManager.EnumToUnderlying (r);
+
+			Type conv_left_as = null;
+			Type conv_right_as = null;
+
+			if ((left is NullLiteral ||(Type.GetTypeCode(l)==TypeCode.DBNull)) && (r.IsValueType || r == TypeManager.string_type)) {
+				// Just treat nothing as the other type, implicit conversion 
+				// will return the default value
+				conv_left_as = r;
+				l = r;
+				//incase of DBNull set to NullLiteral
+				left = NullLiteral.Null;
+			}
+
+			if ((right is NullLiteral ||(Type.GetTypeCode(r)==TypeCode.DBNull)) && (l.IsValueType || l == TypeManager.string_type)) {
+				// Just treat nothing as the other type, implicit conversion 
+				// will return the default value
+				conv_right_as = l;
+				r = l;
+				right = NullLiteral.Null;
+			}
+
+			// deal with objects and reference types first
+			if (l == TypeManager.object_type || r == TypeManager.object_type) {
+
+	                        //
+                                // operator != (object a, object b)
+                                // operator == (object a, object b)
+                                //
+                                // For this to be used, both arguments have to be reference-types.
+                                // Read the rationale on the spec (14.9.6)
+                                //
+                                // Also, if at compile time we know that the classes do not inherit
+                                // one from the other, then we catch the error there.
+
+				// If other type is a value type, convert it to object
+				if (r == TypeManager.object_type &&
+				    (l.IsValueType || l == TypeManager.string_type))
+					left = ConvertImplicit (ec, left, TypeManager.object_type, loc);
+				if (l == TypeManager.object_type &&
+				    (r.IsValueType || r == TypeManager.string_type))
+					right = ConvertImplicit (ec, right, TypeManager.object_type, loc);
+				if (left == null || right == null) {
+					Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+					return null;
+				}
+
+				l = left.Type;
+				r = right.Type;
+
+				if (l == TypeManager.object_type && r == TypeManager.object_type) {
+					string fqn = null;
+					switch (oper) {
+					case Operator.Addition :
+						fqn = "ObjectType.AddObj";
+						break;
+					case Operator.Subtraction :
+						fqn = "ObjectType.SubObj";
+						break;
+					case Operator.Multiply :
+						fqn = "ObjectType.MulObj";
+						break;
+					case Operator.Division :
+						fqn = "ObjectType.DivObj";
+						break;
+					case Operator.IntDivision :
+						fqn = "ObjectType.IDivObj";
+						break;
+					case Operator.Modulus :
+						fqn = "ObjectType.ModObj";
+						break;
+					case Operator.Exponentiation :
+						fqn = "ObjectType.PowObj";
+						break;
+					case Operator.Like :
+						fqn = "ObjectType.LikeObj";
+						break;
+					case Operator.Equality :
+					case Operator.Inequality :
+					case Operator.LessThan :
+					case Operator.LessThanOrEqual :
+					case Operator.GreaterThan :
+					case Operator.GreaterThanOrEqual :
+						fqn = "ObjectType.ObjTst";
+						break;
+					case Operator.BitwiseAnd:
+						fqn = "ObjectType.BitAndObj";
+						break;
+					case Operator.BitwiseOr:
+						fqn = "ObjectType.BitOrObj";
+						break;
+					case Operator.ExclusiveOr:
+						fqn = "ObjectType.BitXorObj";
+						break;
+					case Operator.LeftShift:
+						fqn = "ObjectType.ShiftLeftObj";
+						break;
+					case Operator.RightShift:
+						fqn = "ObjectType.ShiftRightObj";
+						break;
+					case Operator.Is:
+						eclass = ExprClass.Value;
+						type = TypeManager.bool_type;
+						return this;
+					}
+			
+					if (fqn == null) {
+						Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+						return null;
+					}
+
+					if (oper == Operator.LeftShift || oper == Operator.RightShift) {
+						right = ConvertImplicit (ec, right, TypeManager.object_type, loc);
+						if (right == null) {
+							Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+							return null;
+						}
+					}
+
+					Expression etmp = Mono.MonoBASIC.Parser.DecomposeQI (
+								"Microsoft.VisualBasic.CompilerServices." + fqn, 
+								Location.Null);
+
+					ArrayList args = new ArrayList ();
+					args.Add (new Argument (left, Argument.AType.Expression));
+					args.Add (new Argument (right, Argument.AType.Expression));
+					if (IsRelationalOperator (oper)) 
+						args.Add (new Argument (new BoolConstant (false), Argument.AType.Expression));
+					if (oper == Operator.Like) 
+						args.Add (new Argument(new IntLiteral (0), Argument.AType.Expression));
+					Expression e = new Invocation (etmp, args, loc);
+					if (IsRelationalOperator (oper)) {
+						e = new Binary (oper, e.Resolve(ec), new IntConstant (0), loc);
+					}
+					return e.Resolve (ec);
+				} else if (!l.IsValueType || !r.IsValueType) {
+
+			 		// If one of the operands are reference types and other is object, support for 'Is' operator
+                                	if (oper == Operator.Is) {
+                                        	eclass = ExprClass.Value;
+                                        	type = TypeManager.bool_type;
+                                        	return this;
+                                	}
+				}
+
+		
+			} else if (!l.IsValueType || !r.IsValueType) {
+				
+				if (!l.IsValueType && !r.IsValueType) {
+			 		// If both the operands are reference types, support for 'Is' operator
+                                	if (oper == Operator.Is) {
+                                       		eclass = ExprClass.Value;
+                                        	type = TypeManager.bool_type;
+                                        	return this;
+                                	}
+				}
+				// Either of the operands are reference types
+				if (l.IsSubclassOf (TypeManager.delegate_type) && 
+				    r.IsSubclassOf (TypeManager.delegate_type)) {
+					if (oper == Operator.Addition || oper == Operator.Subtraction) {
+	                                        Arguments = new ArrayList ();
+                                        	Arguments.Add (new Argument (left, Argument.AType.Expression));
+                                        	Arguments.Add (new Argument (right, Argument.AType.Expression));
+                                                                                                               
+                                        	if (oper == Operator.Addition)
+                                                	method = TypeManager.delegate_combine_delegate_delegate;
+                                        	else
+                                                	method = TypeManager.delegate_remove_delegate_delegate;
+                                                                                                              	 
+                                        	if (l != r) {
+                                                	Error_OperatorCannotBeApplied ();
+                                                	return null;
+                                        	}
+                                                                                                               
+                                        	DelegateOperation = true;
+                                        	type = l;
+                                        	return this;
+					}
+
+					if (oper != Operator.Equality) {
+						Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+						return null;
+					}
+				}
+
+				bool left_is_string = (left.Type == TypeManager.string_type);
+				bool right_is_string = (right.Type == TypeManager.string_type);
+
+				if (left_is_string || right_is_string) {
+	
+					if (left is NullLiteral) {
+						left_is_string = true;
+						l = r;
+					}
+					if (right is NullLiteral) {
+						right_is_string = true;
+						r = l;
+					}
+					if (left_is_string && right_is_string) {
+						if (oper == Operator.Addition) {
+						// Both operands are string 
+							Expression e = new StringConcat (loc, left, right);
+							return e.Resolve(ec);
+						}
+
+						if (IsRelationalOperator (oper)) {
+	
+							Expression etmp = Mono.MonoBASIC.Parser.DecomposeQI ("Microsoft.VisualBasic.CompilerServices.StringType.StrCmp", Location.Null);
+							eclass = ExprClass.Value;
+							type = TypeManager.bool_type;
+							ArrayList args = new ArrayList ();
+							args.Add (new Argument(left, Argument.AType.Expression));
+							args.Add (new Argument(right, Argument.AType.Expression));
+							args.Add (new Argument(new BoolConstant(false), Argument.AType.Expression));
+							Expression e = (Expression) new Invocation (etmp, args, loc);
+							e = new Binary (oper, e.Resolve(ec), new IntConstant(0), loc);
+							return e.Resolve(ec);
+						}
+
+						if (oper == Operator.Like) {
+							Expression etmp = Mono.MonoBASIC.Parser.DecomposeQI ("Microsoft.VisualBasic.CompilerServices.StringType.StrLike", Location.Null);
+							type = TypeManager.bool_type;
+							ArrayList args = new ArrayList ();
+							args.Add (new Argument(left, Argument.AType.Expression));
+							args.Add (new Argument(right, Argument.AType.Expression));
+							args.Add (new Argument(new IntLiteral (0), Argument.AType.Expression));
+							Expression e = (Expression) new Invocation (etmp, args, loc);
+							return e.Resolve (ec);
+						}
+					}
+
+					Expression other = right_is_string ? left: right;
+					Type other_type = other.Type;
+	
+					//
+					// Disallow arithmatic / shift / logical operators on dates and characters
+					//
+					if (other_type == TypeManager.date_type || other_type == TypeManager.char_type) {
+						if (!(oper == Operator.Addition || IsRelationalOperator (oper) || oper == Operator.Like)) {
+							Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+							return null;
+						}
+					}
+	
+					if (oper == Operator.Addition) {
+						if (other_type == TypeManager.void_type) {
+							Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+							return null;
+						}
+						if (other_type == TypeManager.date_type || 
+					    	other_type == TypeManager.char_type || 
+					    	other_type == typeof (System.Char[])) {
+							conv_left_as = conv_right_as = TypeManager.string_type;
+							type = TypeManager.string_type;
+						}  else {
+							// numeric operand
+							conv_right_as = conv_left_as = TypeManager.double_type;
+							type = TypeManager.double_type;
+						}
+					} else if (IsRelationalOperator (oper)) {
+						if (other_type == TypeManager.char_type || other_type == typeof (System.Char[])) {
+							conv_left_as = conv_right_as = TypeManager.string_type;
+						} else if (other_type == TypeManager.date_type) {
+							conv_right_as = conv_left_as = other_type;
+						} else if (other_type == TypeManager.bool_type) {
+							conv_right_as = conv_left_as = other_type;
+						} else if (! other_type.IsValueType) {
+							// Do Nothing, just return
+							type = TypeManager.bool_type;
+							return this;
+						} else {
+							conv_right_as = conv_left_as = TypeManager.double_type;
+						}
+						type = TypeManager.bool_type;
+	
+					} else if (oper == Operator.Like) {
+						conv_left_as = conv_right_as = TypeManager.string_type;
+					} else if (oper == Operator.LeftShift || oper == Operator.RightShift) {
+	
+						conv_left_as = TypeManager.int64_type;
+						conv_right_as = TypeManager.int32_type;
+						type = TypeManager.int64_type;
+	
+					} else if ( IsLogicalOperator (oper)) {
+						type = conv_right_as = conv_left_as = TypeManager.bool_type;
+					} else if ( IsBitwiseOperator (oper)) {
+	
+				    		if (other_type == TypeManager.bool_type) {
+							conv_right_as = conv_left_as = TypeManager.bool_type;
+							type = TypeManager.bool_type;
+						} else {
+							conv_left_as = conv_right_as = TypeManager.int64_type;
+							type = TypeManager.int64_type;
+						}
+					} else if (oper == Operator.Exponentiation) {
+						conv_left_as = conv_right_as = TypeManager.double_type;
+					} else if (oper == Operator.IntDivision) {
+						conv_left_as = conv_right_as = TypeManager.int64_type;
+					} else {
+						// Arithmatic operators
+						conv_right_as = conv_left_as = TypeManager.double_type;
+						type = TypeManager.double_type;
+					}
+				} else {
+					// Both are not of type string
+					if (oper == Operator.Equality || oper == Operator.Inequality || oper == Operator.Is) {
+						if (l.IsValueType || r.IsValueType) {
+							Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+							return null;
+						}
+						type = TypeManager.bool_type;
+						return this;
+					} else {
+						Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+						return null;
+					}
+				}
+			} else if (l == TypeManager.date_type || r == TypeManager.date_type) {
+				// Date with string operations handled above
+				// Only other possiblity is date with date
+				if (oper == Operator.Like) {
+					conv_right_as = conv_left_as = TypeManager.string_type;
+					type = TypeManager.bool_type;
+				} else if (l == TypeManager.date_type && r == TypeManager.date_type) {
+					if (oper == Operator.Addition) {
+						conv_left_as = conv_right_as = TypeManager.string_type;
+					} else if (IsRelationalOperator (oper)) { 
+						Expression etmp = Mono.MonoBASIC.Parser.DecomposeQI ("System.DateTime.Compare", Location.Null);
+						eclass = ExprClass.Value;
+						type = TypeManager.bool_type;
+						ArrayList args = new ArrayList ();
+						args.Add (new Argument(left, Argument.AType.Expression));
+						args.Add (new Argument(right, Argument.AType.Expression));
+						Expression e = (Expression) new Invocation (etmp, args, loc);
+						e = new Binary (oper, e.Resolve(ec), new IntConstant(0), loc);
+						return e.Resolve(ec);
+					} else {
+						Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+						return null;
+					}
+				} else {
+					Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+					return null;
+				}
+			} else if (l == TypeManager.char_type || r == TypeManager.char_type) {
+				// char op string handled above
+				if (oper == Operator.Like) {
+					conv_right_as = conv_left_as = TypeManager.string_type;
+					type = TypeManager.bool_type;
+				} else if (l == TypeManager.char_type && r == TypeManager.char_type) {
+					if (oper == Operator.Addition)
+						conv_left_as = conv_right_as = TypeManager.string_type;
+					else if (IsRelationalOperator (oper)) {
+						type = TypeManager.bool_type;
+					} else {
+						Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+						return null;
+					}
+				} else {
+					Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+					return null;
+				}
+			} else if (l.IsPointer || r.IsPointer) {
+				if (oper == Operator.Addition || oper == Operator.Subtraction) {
+					if (l.IsPointer){
+						if (r.IsPointer && oper == Operator.Subtraction){
+							if (r == l)
+								return new PointerArithmetic (
+									false, left, right, TypeManager.int64_type,
+									loc);
+					} else if (is_32_or_64 (r))
+						return new PointerArithmetic (
+							oper == Operator.Addition, left, right, l, loc);
+					} else if (r.IsPointer && is_32_or_64 (l) && oper == Operator.Addition)
+						return new PointerArithmetic (
+							true, right, left, r, loc);
+				}
+
+				//
+				// Pointer comparison
+				//
+				if (l.IsPointer && r.IsPointer){
+					if (oper == Operator.Equality || oper == Operator.Inequality ||
+					    oper == Operator.LessThan || oper == Operator.LessThanOrEqual ||
+					    oper == Operator.GreaterThan || oper == Operator.GreaterThanOrEqual){
+						type = TypeManager.bool_type;
+						return this;
+					}
+				}
+				Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+				return null;
+
+			} else if (oper == Operator.Like) {
+				conv_left_as = conv_right_as = TypeManager.string_type;
+			} else {
+
+				// Numeric Types
+				DoNumericPromotions (ec, l, r, oper);
+				if (left == null || right == null) {
+					Error_OperatorCannotBeApplied (loc, OperName(oper), l, r);
+					return null;
+				}
+
+				l = left.Type;
+				r = right.Type;
+				// Required conversions done by 'DoNumericPromotions' method
+				// So Reset 'conv_left_as', 'conv_right_as'
+				conv_left_as = conv_right_as = null;
+
+				if (l == TypeManager.decimal_type  && r == TypeManager.decimal_type) {
+					if (IsRelationalOperator (oper)) {
+						Expression etmp = Mono.MonoBASIC.Parser.DecomposeQI ("System.Decimal.Compare", Location.Null);
+						eclass = ExprClass.Value;
+						type = TypeManager.bool_type;
+						ArrayList args = new ArrayList ();
+						args.Add (new Argument(left, Argument.AType.Expression));
+						args.Add (new Argument(right, Argument.AType.Expression));
+						Expression e = (Expression) new Invocation (etmp, args, loc);
+						e = new Binary (oper, e.Resolve(ec), new IntConstant(0), loc);
+						return e.Resolve(ec);
+					} else if (IsArithmaticOperator (oper)) {
+						string fqn = null;
+						if (oper == Operator.Addition) 
+							fqn = "System.Decimal.Add";
+						else if (oper == Operator.Subtraction) 
+							fqn = "System.Decimal.Subtract";
+						else if (oper == Operator.Multiply) 
+							fqn = "System.Decimal.Multiply";
+						else if (oper == Operator.Division)
+							fqn = "System.Decimal.Divide";
+						else if (oper == Operator.Modulus) 
+							fqn = "System.Decimal.Remainder";
+						if (fqn != null) {
+
+							Expression etmp = Mono.MonoBASIC.Parser.DecomposeQI (fqn, Location.Null);
+							eclass = ExprClass.Value;
+							type = TypeManager.decimal_type;
+							ArrayList args = new ArrayList ();
+							args.Add (new Argument(left, Argument.AType.Expression));
+							args.Add (new Argument(right, Argument.AType.Expression));
+							Expression e = (Expression) new Invocation (etmp, args, loc);
+							return e.Resolve (ec);
+						}
+					}
+				}
+			}
+
+			bool conv_done = false;
+			if (conv_left_as != null && conv_left_as != l) {
+				conv_done = true;
+				left = ConvertImplicit (ec, left, conv_left_as, loc);
+				if (left == null) {
+					Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+					return null;
+				}
+				l = left.Type;
+			}
+
+			if (conv_right_as != null && conv_right_as != r) {
+				conv_done = true;
+				right = ConvertImplicit (ec, right, conv_right_as, loc);
+				if (right == null) {
+					Error_OperatorCannotBeApplied (loc, OperName (oper), l, r);
+					return null;
+				}
+				r = right.Type;
+			}
+
+			if (conv_done) 
+				return ResolveOperator (ec);
+
+
+			if (oper == Operator.Exponentiation) {
+				Expression etmp = Mono.MonoBASIC.Parser.DecomposeQI("System.Math.Pow", loc);
+				ArrayList args = new ArrayList();
+				args.Add (new Argument (left, Argument.AType.Expression));
+				args.Add (new Argument (right, Argument.AType.Expression));
+				Expression e = (Expression) new Invocation (etmp, args, loc);
+				return e.Resolve(ec);
+			}
+
+			bool overload_failed = false;
+			string op = oper_names [(int) oper];
+			MethodGroupExpr union = null;
+			left_expr = MemberLookup (ec, l, op, MemberTypes.Method, AllBindingFlags, loc);
+			if (r != l) {
+				right_expr = MemberLookup (
+						ec, r, op, MemberTypes.Method, AllBindingFlags, loc);
+				union = Invocation.MakeUnionSet (left_expr, right_expr, loc);
+			} else 
+				union = (MethodGroupExpr) left_expr;
+
+			if (union != null) {
+				Arguments = new ArrayList ();
+				Arguments.Add (new Argument (left, Argument.AType.Expression));
+				Arguments.Add (new Argument (right, Argument.AType.Expression));
+
+				method = Invocation.OverloadResolve (ec, union, Arguments, Location.Null);
+				if (method != null) {
+					MethodInfo mi = (MethodInfo) method;
+
+					type = mi.ReturnType;
+					return this;
+				} else {
+					overload_failed = true;
+				}
+			}
+
+			if (overload_failed) {
+				Error_OperatorCannotBeApplied ();
+				return null;
+			}
+
+			if (IsRelationalOperator (oper)) {
+				type = TypeManager.bool_type;
+				if (l == TypeManager.bool_type && r == TypeManager.bool_type) {
+					// Reverse the operator - to make it consistent with vbc
+					if (oper == Operator.LessThan) 
+						oper = Operator.GreaterThan;
+					else if (oper == Operator.GreaterThan)
+						oper = Operator.LessThan;
+					else if (oper == Operator.LessThanOrEqual)
+						oper = Operator.GreaterThanOrEqual;
+					else if (oper == Operator.GreaterThanOrEqual)
+						oper = Operator.LessThanOrEqual;
+				}
+			}
+
+			if (IsLogicalOperator (oper))
+				type = TypeManager.bool_type;
+			if (IsBitwiseOperator (oper)) {
+				if (l == r) {
+					if (l == TypeManager.byte_type ||
+					    l == TypeManager.short_type ||
+					    l == TypeManager.bool_type ||
+					    l == TypeManager.int32_type ||
+					    l == TypeManager.int64_type) 
+						type = l;
+					else {
+						Error_OperatorCannotBeApplied();
+						return null;
+					}
+				} else {
+					Error_OperatorCannotBeApplied();
+					return null;
+				}
+			}
+
+			if (oper == Operator.LeftShift || oper == Operator.RightShift) {
+				return CheckShiftArguments (ec);
+			}
+
+			return this;
+		}
+		
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (oper == Operator.Concat) {
+				Expression e = new StringConcat (loc, left, right);
+				return e.Resolve (ec);
+			}
+			left = left.Resolve (ec);
+			right = right.Resolve (ec);
+
+			if (left == null || right == null)
+				return null;
+
+			if (left.Type == null)
+				throw new Exception (
+					"Resolve returned non null, but did not set the type! (" +
+					left + ") at Line: " + loc.Row);
+			if (right.Type == null)
+				throw new Exception (
+					"Resolve returned non null, but did not set the type! (" +
+					right + ") at Line: "+ loc.Row);
+
+			eclass = ExprClass.Value;
+			
+			// To support  'Or' argument of AttributeTargets in AttributeUsage
+
+			if (left is EnumConstant && oper != Operator.BitwiseOr) {
+				left = ((EnumConstant) left).WidenToCompilerConstant();
+			}
+
+			if (right is EnumConstant && oper != Operator.BitwiseOr) {
+				right = ((EnumConstant) right).WidenToCompilerConstant();
+			}
+
+			if (left is Constant && right is Constant){
+				Expression e = ConstantFold.BinaryFold (
+					ec, oper, (Constant) left, (Constant) right, loc);
+				if (e != null)
+					return e;
+			}
+
+			Expression etmp = ResolveOperator (ec);
+			Type l = left.Type;
+			
+			// if the operands are of type byte/short, convert the result back to short/byte
+			if (l == TypeManager.bool_type || l == TypeManager.short_type || l == TypeManager.byte_type) {
+				if (l == TypeManager.bool_type)
+					l = TypeManager.short_type;
+				if (IsArithmaticOperator (oper) && oper != Operator.Division) {
+					Expression conv_exp = ConvertImplicit (ec, etmp, l, loc);
+					if (conv_exp != null)
+						return conv_exp;
+				} 
+				if (IsShiftOperator (oper)) {
+					// No overflow checks are needed
+					if (l == TypeManager.byte_type)
+						return new OpcodeCast (etmp, l, OpCodes.Conv_U1);
+					else 
+						return new OpcodeCast (etmp, l, OpCodes.Conv_I2);
+				}
+			}
+
+			return etmp;
+		}
+
+		/// <remarks>
+		///   EmitBranchable is called from Statement.EmitBoolExpression in the
+		///   context of a conditional bool expression.  This function will return
+		///   false if it is was possible to use EmitBranchable, or true if it was.
+		///
+		///   The expression's code is generated, and we will generate a branch to 'target'
+		///   if the resulting expression value is equal to isTrue
+		/// </remarks>
+		public bool EmitBranchable (EmitContext ec, Label target, bool onTrue)
+		{
+			if (method != null)
+				return false;
+
+			ILGenerator ig = ec.ig;
+
+			//
+			// This is more complicated than it looks, but its just to avoid
+			// duplicated tests: basically, we allow ==, !=, >, <, >= and <=
+			// but on top of that we want for == and != to use a special path
+			// if we are comparing against null
+			//
+			if (oper == Operator.Equality || oper == Operator.Inequality || oper == Operator.Is){
+				bool my_on_true = oper == Operator.Inequality ? onTrue : !onTrue;
+				
+				if (left is NullLiteral){
+					right.Emit (ec);
+					if (my_on_true)
+						ig.Emit (OpCodes.Brtrue, target);
+					else
+						ig.Emit (OpCodes.Brfalse, target);
+					return true;
+				} else if (right is NullLiteral){
+					left.Emit (ec);
+					if (my_on_true)
+						ig.Emit (OpCodes.Brtrue, target);
+					else
+						ig.Emit (OpCodes.Brfalse, target);
+					return true;
+				} 
+			} else if (!(oper == Operator.LessThan ||
+				      oper == Operator.GreaterThan ||
+				      oper == Operator.LessThanOrEqual ||
+				      oper == Operator.GreaterThanOrEqual ||
+				      oper == Operator.Is))
+				return false;
+			
+
+			
+			left.Emit (ec);
+			right.Emit (ec);
+
+			bool isUnsigned = is_unsigned (left.Type);
+
+			switch (oper){
+			case Operator.Equality:
+				if (onTrue)
+					ig.Emit (OpCodes.Beq, target);
+				else
+					ig.Emit (OpCodes.Bne_Un, target);
+				break;
+
+			case Operator.Inequality:
+				if (onTrue)
+					ig.Emit (OpCodes.Bne_Un, target);
+				else
+					ig.Emit (OpCodes.Beq, target);
+				break;
+
+			case Operator.LessThan:
+				if (onTrue)
+					if (isUnsigned)
+						ig.Emit (OpCodes.Blt_Un, target);
+					else
+						ig.Emit (OpCodes.Blt, target);
+				else
+					if (isUnsigned)
+						ig.Emit (OpCodes.Bge_Un, target);
+					else
+						ig.Emit (OpCodes.Bge, target);
+				break;
+
+			case Operator.GreaterThan:
+				if (onTrue)
+					if (isUnsigned)
+						ig.Emit (OpCodes.Bgt_Un, target);
+					else
+						ig.Emit (OpCodes.Bgt, target);
+				else
+					if (isUnsigned)
+						ig.Emit (OpCodes.Ble_Un, target);
+					else
+						ig.Emit (OpCodes.Ble, target);
+				break;
+
+			case Operator.LessThanOrEqual:
+				if (onTrue)
+					if (isUnsigned)
+						ig.Emit (OpCodes.Ble_Un, target);
+					else
+						ig.Emit (OpCodes.Ble, target);
+				else
+					if (isUnsigned)
+						ig.Emit (OpCodes.Bgt_Un, target);
+					else
+						ig.Emit (OpCodes.Bgt, target);
+				break;
+
+
+			case Operator.GreaterThanOrEqual:
+				if (onTrue)
+					if (isUnsigned)
+						ig.Emit (OpCodes.Bge_Un, target);
+					else
+						ig.Emit (OpCodes.Bge, target);
+				else
+					if (isUnsigned)
+						ig.Emit (OpCodes.Blt_Un, target);
+					else
+						ig.Emit (OpCodes.Blt, target);
+				break;
+
+			case Operator.Is:
+				if (onTrue)
+					ig.Emit (OpCodes.Beq, target); //Check this
+				else
+					ig.Emit (OpCodes.Bne_Un_S, target);
+				break;
+
+			default:
+				return false;
+			}
+			
+			return true;
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			Type l = left.Type;
+			Type r = right.Type;
+			//Type r = right.Type;
+			OpCode opcode;
+
+			if (method != null) {
+
+				// Note that operators are static anyway
+				
+				if (Arguments != null) 
+					Invocation.EmitArguments (ec, method, Arguments);
+				
+				if (method is MethodInfo)
+					ig.Emit (OpCodes.Call, (MethodInfo) method);
+				else
+					ig.Emit (OpCodes.Call, (ConstructorInfo) method);
+
+				if (DelegateOperation)
+					ig.Emit (OpCodes.Castclass, type);
+					
+				return;
+			}
+
+			//
+			// Handle short-circuit operators differently
+			// than the rest
+			//
+			if (IsLogicalOperator (oper)) {
+				Label load_zero = ig.DefineLabel ();
+				Label load_one = ig.DefineLabel ();
+				Label end = ig.DefineLabel ();
+				
+				left.Emit (ec);
+				if (l != TypeManager.bool_type) {
+					if (l == TypeManager.int64_type) {
+						ec.ig.Emit (OpCodes.Ldc_I8, 0L);
+						ec.ig.Emit (OpCodes.Cgt_Un);
+					} else if (l == TypeManager.float_type) {
+						ec.ig.Emit (OpCodes.Ldc_R4, 0.0F);
+						ec.ig.Emit (OpCodes.Ceq);
+						ec.ig.Emit (OpCodes.Ldc_I4_0);
+						ec.ig.Emit (OpCodes.Ceq);
+					} else if (l == TypeManager.double_type) {
+						ec.ig.Emit (OpCodes.Ldc_R8, 0.0);
+						ec.ig.Emit (OpCodes.Ceq);
+						ec.ig.Emit (OpCodes.Ldc_I4_0);
+						ec.ig.Emit (OpCodes.Ceq);
+					} else  {
+						ec.ig.Emit (OpCodes.Ldc_I4_0);
+						ec.ig.Emit (OpCodes.Cgt_Un);
+					}
+				}
+				if (oper == Operator.LogicalAnd) 
+					ig.Emit (OpCodes.Brfalse, load_zero);
+				else 
+					ig.Emit (OpCodes.Brtrue, load_one);
+				
+				right.Emit (ec);
+				if (r != TypeManager.bool_type) {
+					if (r == TypeManager.int64_type) {
+						ec.ig.Emit (OpCodes.Ldc_I8, 0L);
+						ec.ig.Emit (OpCodes.Cgt_Un);
+					} else if (r == TypeManager.float_type) {
+						ec.ig.Emit (OpCodes.Ldc_R4, 0.0F);
+						ec.ig.Emit (OpCodes.Ceq);
+						ec.ig.Emit (OpCodes.Ldc_I4_0);
+						ec.ig.Emit (OpCodes.Ceq);
+					} else if (r == TypeManager.double_type) {
+						ec.ig.Emit (OpCodes.Ldc_R8, 0.0);
+						ec.ig.Emit (OpCodes.Ceq);
+						ec.ig.Emit (OpCodes.Ldc_I4_0);
+						ec.ig.Emit (OpCodes.Ceq);
+					} else  {
+						ec.ig.Emit (OpCodes.Ldc_I4_0);
+						ec.ig.Emit (OpCodes.Cgt_Un);
+					}
+				}
+				ig.Emit (OpCodes.Brtrue, load_one);
+				ig.MarkLabel (load_zero);
+				ig.Emit (OpCodes.Ldc_I4_0);
+				ig.Emit (OpCodes.Br, end);
+				ig.MarkLabel (load_one);
+				ig.Emit (OpCodes.Ldc_I4_1);
+				ig.MarkLabel (end);
+				return;
+			}
+			
+			left.Emit (ec);
+			right.Emit (ec);
+
+			switch (oper){
+			case Operator.Multiply:
+				if (ec.CheckState){
+					if (l == TypeManager.int32_type || l == TypeManager.int64_type)
+						opcode = OpCodes.Mul_Ovf;
+					else if (l==TypeManager.uint32_type || l==TypeManager.uint64_type)
+						opcode = OpCodes.Mul_Ovf_Un;
+					else
+						opcode = OpCodes.Mul;
+				} else
+					opcode = OpCodes.Mul;
+
+				break;
+
+			case Operator.Division:
+			case Operator.IntDivision:
+				if (l == TypeManager.uint32_type || l == TypeManager.uint64_type)
+					opcode = OpCodes.Div_Un;
+				else
+					opcode = OpCodes.Div;
+				break;
+
+			case Operator.Modulus:
+				if (l == TypeManager.uint32_type || l == TypeManager.uint64_type)
+					opcode = OpCodes.Rem_Un;
+				else
+					opcode = OpCodes.Rem;
+				break;
+
+			case Operator.Addition:
+				if (ec.CheckState){
+					if (l == TypeManager.int32_type || l == TypeManager.int64_type)
+						opcode = OpCodes.Add_Ovf;
+					else if (l==TypeManager.uint32_type || l==TypeManager.uint64_type)
+						opcode = OpCodes.Add_Ovf_Un;
+					else
+						opcode = OpCodes.Add;
+				} else
+					opcode = OpCodes.Add;
+				break;
+
+			case Operator.Subtraction:
+				if (ec.CheckState){
+					if (l == TypeManager.int32_type || l == TypeManager.int64_type)
+						opcode = OpCodes.Sub_Ovf;
+					else if (l==TypeManager.uint32_type || l==TypeManager.uint64_type)
+						opcode = OpCodes.Sub_Ovf_Un;
+					else
+						opcode = OpCodes.Sub;
+				} else
+					opcode = OpCodes.Sub;
+				break;
+
+			case Operator.RightShift:
+				if (l == TypeManager.uint32_type || l == TypeManager.uint64_type)
+					opcode = OpCodes.Shr_Un;
+				else
+					opcode = OpCodes.Shr;
+				break;
+				
+			case Operator.LeftShift:
+				opcode = OpCodes.Shl;
+				break;
+
+			case Operator.Equality:
+			case Operator.Is:
+				opcode = OpCodes.Ceq;
+				break;
+
+			case Operator.Inequality:
+				ec.ig.Emit (OpCodes.Ceq);
+				ec.ig.Emit (OpCodes.Ldc_I4_0);
+				
+				opcode = OpCodes.Ceq;
+				break;
+
+			case Operator.LessThan:
+				opcode = OpCodes.Clt;
+				break;
+
+			case Operator.GreaterThan:
+				opcode = OpCodes.Cgt;
+				break;
+
+			case Operator.LessThanOrEqual:
+				ec.ig.Emit (OpCodes.Cgt);
+				ec.ig.Emit (OpCodes.Ldc_I4_0);
+				
+				opcode = OpCodes.Ceq;
+				break;
+
+			case Operator.GreaterThanOrEqual:
+				ec.ig.Emit (OpCodes.Clt);
+				ec.ig.Emit (OpCodes.Ldc_I4_1);
+				
+				opcode = OpCodes.Sub;
+				break;
+
+			case Operator.BitwiseOr:
+				opcode = OpCodes.Or;
+				break;
+
+			case Operator.BitwiseAnd:
+				opcode = OpCodes.And;
+				break;
+
+			case Operator.ExclusiveOr:
+				opcode = OpCodes.Xor;
+				break;
+
+			default:
+				throw new Exception ("This should not happen: Operator = "
+						     + oper.ToString ());
+			}
+
+			ig.Emit (opcode);
+		}
+
+		public bool IsBuiltinOperator {
+			get {
+				return method == null;
+			}
+		}
+	}
+
+	public class PointerArithmetic : Expression {
+		Expression left, right;
+		bool is_add;
+
+		//
+		// We assume that 'l' is always a pointer
+		//
+		public PointerArithmetic (bool is_addition, Expression l, Expression r, Type t,
+					  Location loc)
+		{
+			type = t;
+			eclass = ExprClass.Variable;
+			this.loc = loc;
+			left = l;
+			right = r;
+			is_add = is_addition;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			//
+			// We are born fully resolved
+			//
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			Type op_type = left.Type;
+			ILGenerator ig = ec.ig;
+			int size = GetTypeSize (op_type.GetElementType ());
+			
+			if (right.Type.IsPointer){
+				//
+				// handle (pointer - pointer)
+				//
+				left.Emit (ec);
+				right.Emit (ec);
+				ig.Emit (OpCodes.Sub);
+
+				if (size != 1){
+					if (size == 0)
+						ig.Emit (OpCodes.Sizeof, op_type);
+					else 
+						IntLiteral.EmitInt (ig, size);
+					ig.Emit (OpCodes.Div);
+				}
+				ig.Emit (OpCodes.Conv_I8);
+			} else {
+				//
+				// handle + and - on (pointer op int)
+				//
+				left.Emit (ec);
+				ig.Emit (OpCodes.Conv_I);
+				right.Emit (ec);
+				if (size != 1){
+					if (size == 0)
+						ig.Emit (OpCodes.Sizeof, op_type);
+					else 
+						IntLiteral.EmitInt (ig, size);
+					ig.Emit (OpCodes.Mul);
+				}
+				if (is_add)
+					ig.Emit (OpCodes.Add);
+				else
+					ig.Emit (OpCodes.Sub);
+			}
+		}
+	}
+	
+	/// <summary>
+	///   Implements the ternary conditional operator (?:)
+	/// </summary>
+	public class Conditional : Expression {
+		Expression expr, trueExpr, falseExpr;
+		
+		public Conditional (Expression expr, Expression trueExpr, Expression falseExpr, Location l)
+		{
+			this.expr = expr;
+			this.trueExpr = trueExpr;
+			this.falseExpr = falseExpr;
+			this.loc = l;
+		}
+
+		public Expression Expr {
+			get {
+				return expr;
+			}
+		}
+
+		public Expression TrueExpr {
+			get {
+				return trueExpr;
+			}
+		}
+
+		public Expression FalseExpr {
+			get {
+				return falseExpr;
+			}
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			expr = expr.Resolve (ec);
+
+			if (expr == null)
+				return null;
+			
+			if (expr.Type != TypeManager.bool_type)
+				expr = Expression.ConvertImplicitRequired (
+					ec, expr, TypeManager.bool_type, loc);
+			
+			trueExpr = trueExpr.Resolve (ec);
+			falseExpr = falseExpr.Resolve (ec);
+
+			if (trueExpr == null || falseExpr == null)
+				return null;
+
+			eclass = ExprClass.Value;
+			if (trueExpr.Type == falseExpr.Type)
+				type = trueExpr.Type;
+			else {
+				Expression conv;
+				Type true_type = trueExpr.Type;
+				Type false_type = falseExpr.Type;
+
+				if (trueExpr is NullLiteral){
+					type = false_type;
+					return this;
+				} else if (falseExpr is NullLiteral){
+					type = true_type;
+					return this;
+				}
+				
+				//
+				// First, if an implicit conversion exists from trueExpr
+				// to falseExpr, then the result type is of type falseExpr.Type
+				//
+				conv = ConvertImplicit (ec, trueExpr, false_type, loc);
+				if (conv != null){
+					//
+					// Check if both can convert implicitl to each other's type
+					//
+					if (ConvertImplicit (ec, falseExpr, true_type, loc) != null){
+						Error (172,
+						       "Can not compute type of conditional expression " +
+						       "as '" + TypeManager.MonoBASIC_Name (trueExpr.Type) +
+						       "' and '" + TypeManager.MonoBASIC_Name (falseExpr.Type) +
+						       "' convert implicitly to each other");
+						return null;
+					}
+					type = false_type;
+					trueExpr = conv;
+				} else if ((conv = ConvertImplicit(ec, falseExpr, true_type,loc))!= null){
+					type = true_type;
+					falseExpr = conv;
+				} else {
+					Error (173, "The type of the conditional expression can " +
+					       "not be computed because there is no implicit conversion" +
+					       " from '" + TypeManager.MonoBASIC_Name (trueExpr.Type) + "'" +
+					       " and '" + TypeManager.MonoBASIC_Name (falseExpr.Type) + "'");
+					return null;
+				}
+			}
+
+			if (expr is BoolConstant){
+				BoolConstant bc = (BoolConstant) expr;
+
+				if (bc.Value)
+					return trueExpr;
+				else
+					return falseExpr;
+			}
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			Label false_target = ig.DefineLabel ();
+			Label end_target = ig.DefineLabel ();
+
+			Statement.EmitBoolExpression (ec, expr, false_target, false);
+			trueExpr.Emit (ec);
+			ig.Emit (OpCodes.Br, end_target);
+			ig.MarkLabel (false_target);
+			falseExpr.Emit (ec);
+			ig.MarkLabel (end_target);
+		}
+
+	}
+
+	/// <summary>
+	///   Local variables
+	/// </summary>
+	public class LocalVariableReference : Expression, IAssignMethod, IMemoryLocation, IVariable {
+		public readonly string Name;
+		public readonly Block Block;
+		VariableInfo variable_info;
+		bool is_readonly;
+		
+		public LocalVariableReference (Block block, string name, Location l)
+		{
+			Block = block;
+			Name = name;
+			loc = l;
+			eclass = ExprClass.Variable;
+		}
+
+		// Setting 'is_readonly' to false will allow you to create a writable
+		// reference to a read-only variable.  This is used by foreach and using.
+		public LocalVariableReference (Block block, string name, Location l,
+					       VariableInfo variable_info, bool is_readonly)
+			: this (block, name, l)
+		{
+			this.variable_info = variable_info;
+			this.is_readonly = is_readonly;
+		}
+
+		public VariableInfo VariableInfo {
+			get {
+				if (variable_info == null) {
+					variable_info = Block.GetVariableInfo (Name);
+					is_readonly = variable_info.ReadOnly;
+				}
+				return variable_info;
+			}
+		}
+
+		public bool IsAssigned (EmitContext ec, Location loc)
+		{
+			return VariableInfo.IsAssigned (ec, loc);
+		}
+
+		public bool IsFieldAssigned (EmitContext ec, string name, Location loc)
+		{
+			return VariableInfo.IsFieldAssigned (ec, name, loc);
+		}
+
+		public void SetAssigned (EmitContext ec)
+		{
+			VariableInfo.SetAssigned (ec);
+		}
+
+		public void SetFieldAssigned (EmitContext ec, string name)
+		{
+			VariableInfo.SetFieldAssigned (ec, name);
+		}
+
+		public bool IsReadOnly {
+			get {
+				if (variable_info == null) {
+					variable_info = Block.GetVariableInfo (Name);
+					is_readonly = variable_info.ReadOnly;
+				}
+				return is_readonly;
+			}
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			VariableInfo vi = VariableInfo;
+
+			if (Block.IsConstant (Name)) {
+				Expression e = Block.GetConstantExpression (Name);
+
+				vi.Used = true;
+				return e;
+			}
+
+			if (ec.DoFlowAnalysis && !IsAssigned (ec, loc))
+				return null;
+
+			type = vi.VariableType;
+			return this;
+		}
+
+		override public Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			VariableInfo vi = VariableInfo;
+
+			if (ec.DoFlowAnalysis) {
+				ec.SetVariableAssigned (vi);
+			}
+
+			Expression e = DoResolve (ec);
+
+			if (e == null)
+				return null;
+
+			if (is_readonly){
+				Error (1604, "cannot assign to '" + Name + "' because it is readonly");
+				return null;
+			}
+			
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			VariableInfo vi = VariableInfo;
+			ILGenerator ig = ec.ig;
+
+			if (vi.Alias != null) {
+				ArrayList fields = ec.TypeContainer.Fields;
+				FieldBase fb = null;
+				for (int i = 0; i < fields.Count; i++) {
+					if (((Field) fields[i]).Name == vi.Alias) {
+						fb = (Field) fields[i];
+						break;
+					}
+				}
+				if ((fb.ModFlags & Modifiers.STATIC) != 0)
+					ig.Emit (OpCodes.Ldsfld, fb.FieldBuilder);
+				else {
+					ig.Emit (OpCodes.Ldarg_0);		
+					ig.Emit (OpCodes.Ldfld, fb.FieldBuilder);
+				}
+			} else
+				ig.Emit (OpCodes.Ldloc, vi.LocalBuilder);
+
+			vi.Used = true;
+		}
+		
+		public void EmitAssign (EmitContext ec, Expression source)
+		{
+			ILGenerator ig = ec.ig;
+			VariableInfo vi = VariableInfo;
+
+			vi.Assigned = true;
+
+			if (vi.Alias != null) {
+				ArrayList fields = ec.TypeContainer.Fields;
+				FieldBase fb = null;
+				for (int i = 0; i < fields.Count; i++) {
+					if (((Field) fields[i]).Name == vi.Alias) {
+						fb = (Field) fields[i];
+						break;
+					}
+				}
+				
+				if ((fb.ModFlags & Modifiers.STATIC) != 0) {
+					source.Emit (ec);
+					ig.Emit (OpCodes.Stsfld, fb.FieldBuilder);
+				}
+				else {
+					ig.Emit (OpCodes.Ldarg_0);
+					source.Emit (ec);
+					ig.Emit (OpCodes.Stfld, fb.FieldBuilder);
+				}
+			}
+			else {
+				source.Emit (ec);
+				ig.Emit (OpCodes.Stloc, vi.LocalBuilder);
+			}
+		}
+		
+		public void EmitAssign (EmitContext ec, Expression source, FieldBase fb)
+		{
+			//This is used in specific cases with non Static fields with
+			//part of source assign emmited before this.
+			ILGenerator ig = ec.ig;
+			VariableInfo vi = VariableInfo;
+			
+			vi.Assigned = true;
+			source.Emit (ec);
+			if ((fb.ModFlags & Modifiers.STATIC) != 0) 
+				ig.Emit (OpCodes.Stsfld, fb.FieldBuilder);
+			else
+				ig.Emit (OpCodes.Stfld, fb.FieldBuilder);
+		}
+		
+		public void AddressOf (EmitContext ec, AddressOp mode)
+		{
+			VariableInfo vi = VariableInfo;
+
+			if (vi.Alias != null) {
+				ArrayList fields = ec.TypeContainer.Fields;
+				FieldBase fb = null;
+				for (int i = 0; i < fields.Count; i++) {
+					if (((Field) fields[i]).Name == vi.Alias) {
+						fb = (Field) fields[i];
+						break;
+					}
+				}
+				if ((fb.ModFlags & Modifiers.STATIC) != 0)
+					ec.ig.Emit (OpCodes.Ldsflda, fb.FieldBuilder);
+				else {
+					ec.ig.Emit (OpCodes.Ldarg_0);
+					ec.ig.Emit (OpCodes.Ldflda, fb.FieldBuilder);
+				}
+			} else
+				ec.ig.Emit (OpCodes.Ldloca, vi.LocalBuilder);
+		}
+	}
+
+	/// <summary>
+	///   This represents a reference to a parameter in the intermediate
+	///   representation.
+	/// </summary>
+	public class ParameterReference : Expression, IAssignMethod, IMemoryLocation, IVariable {
+		Parameters pars;
+		String name;
+		int idx;
+		public Parameter.Modifier mod;
+		public bool is_ref, is_out;
+		
+		public ParameterReference (Parameters pars, int idx, string name, Location loc)
+		{
+			this.pars = pars;
+			this.idx  = idx;
+			this.name = name;
+			this.loc = loc;
+			eclass = ExprClass.Variable;
+		}
+
+		public bool IsAssigned (EmitContext ec, Location loc)
+		{
+			if (!is_out || !ec.DoFlowAnalysis)
+				return true;
+
+			if (!ec.CurrentBranching.IsParameterAssigned (idx)) {
+				Report.Error (165, loc,
+					      "Use of unassigned local variable '" + name + "'");
+				return false;
+			}
+
+			return true;
+		}
+
+		public bool IsFieldAssigned (EmitContext ec, string field_name, Location loc)
+		{
+			if (!is_out || !ec.DoFlowAnalysis)
+				return true;
+
+			if (ec.CurrentBranching.IsParameterAssigned (idx))
+				return true;
+
+			if (!ec.CurrentBranching.IsParameterAssigned (idx, field_name)) {
+				Report.Error (170, loc,
+					      "Use of possibly unassigned field '" + field_name + "'");
+				return false;
+			}
+
+			return true;
+		}
+
+		public void SetAssigned (EmitContext ec)
+		{
+			if (is_out && ec.DoFlowAnalysis)
+				ec.CurrentBranching.SetParameterAssigned (idx);
+		}
+
+		public void SetFieldAssigned (EmitContext ec, string field_name)
+		{
+			if (is_out && ec.DoFlowAnalysis)
+				ec.CurrentBranching.SetParameterAssigned (idx, field_name);
+		}
+
+		//
+		// Notice that for ref/out parameters, the type exposed is not the
+		// same type exposed externally.
+		//
+		// for "ref int a":
+		//   externally we expose "int&"
+		//   here we expose       "int".
+		//
+		// We record this in "is_ref".  This means that the type system can treat
+		// the type as it is expected, but when we generate the code, we generate
+		// the alternate kind of code.
+		//
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = pars.GetParameterInfo (ec.DeclSpace, idx, out mod);
+			is_ref = (mod & Parameter.Modifier.ISBYREF) != 0;
+			// is_out = (mod & Parameter.Modifier.OUT) != 0;
+			eclass = ExprClass.Variable;
+
+			/*  if (is_out && ec.DoFlowAnalysis && !IsAssigned (ec, loc))
+				return null;
+			*/
+			return this;
+		}
+
+		override public Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			type = pars.GetParameterInfo (ec.DeclSpace, idx, out mod);
+			is_ref = (mod & Parameter.Modifier.ISBYREF) != 0;
+			// is_out = (mod & Parameter.Modifier.OUT) != 0;
+			eclass = ExprClass.Variable;
+			/*
+			if (is_out && ec.DoFlowAnalysis)
+				ec.SetParameterAssigned (idx);
+			*/
+			return this;
+		}
+
+		static void EmitLdArg (ILGenerator ig, int x)
+		{
+			if (x <= 255){
+				switch (x){
+				case 0: ig.Emit (OpCodes.Ldarg_0); break;
+				case 1: ig.Emit (OpCodes.Ldarg_1); break;
+				case 2: ig.Emit (OpCodes.Ldarg_2); break;
+				case 3: ig.Emit (OpCodes.Ldarg_3); break;
+				default: ig.Emit (OpCodes.Ldarg_S, (byte) x); break;
+				}
+			} else
+				ig.Emit (OpCodes.Ldarg, x);
+		}
+		
+		//
+		// This method is used by parameters that are references, that are
+		// being passed as references:  we only want to pass the pointer (that
+		// is already stored in the parameter, not the address of the pointer,
+		// and not the value of the variable).
+		//
+		public void EmitLoad (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			int arg_idx = idx;
+
+			if (!ec.IsStatic)
+				arg_idx++;
+
+			EmitLdArg (ig, arg_idx);
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			int arg_idx = idx;
+
+			if (!ec.IsStatic)
+				arg_idx++;
+
+			EmitLdArg (ig, arg_idx);
+
+			if (!is_ref)
+				return;
+
+			//
+			// If we are a reference, we loaded on the stack a pointer
+			// Now lets load the real value
+			//
+			LoadFromPtr (ig, type);
+		}
+
+		public void EmitAssign (EmitContext ec, Expression source)
+		{
+			ILGenerator ig = ec.ig;
+			int arg_idx = idx;
+
+			if (!ec.IsStatic)
+				arg_idx++;
+
+			if (is_ref)
+				EmitLdArg (ig, arg_idx);
+			
+			source.Emit (ec);
+
+			if (is_ref)
+				StoreFromPtr (ig, type);
+			else {
+				if (arg_idx <= 255)
+					ig.Emit (OpCodes.Starg_S, (byte) arg_idx);
+				else
+					ig.Emit (OpCodes.Starg, arg_idx);
+			}
+		}
+
+		public void AddressOf (EmitContext ec, AddressOp mode)
+		{
+			int arg_idx = idx;
+
+			if (!ec.IsStatic)
+				arg_idx++;
+
+			if (is_ref){
+				if (arg_idx <= 255)
+					ec.ig.Emit (OpCodes.Ldarg_S, (byte) arg_idx);
+				else
+					ec.ig.Emit (OpCodes.Ldarg, arg_idx);
+			} else {
+				if (arg_idx <= 255)
+					ec.ig.Emit (OpCodes.Ldarga_S, (byte) arg_idx);
+				else
+					ec.ig.Emit (OpCodes.Ldarga, arg_idx);
+			}
+		}
+	}
+	
+	
+	/// <summary>
+	///   Invocation of methods or delegates.
+	/// </summary>
+	public class Invocation : ExpressionStatement {
+		public ArrayList Arguments;
+
+		public Expression expr;
+		MethodBase method = null;
+		bool is_base;
+		bool is_latebinding;
+		bool is_left_hand; // Needed for late bound calls
+		bool is_retval_required; // Needed for late bound calls
+		static Hashtable method_parameter_cache;
+		//static MemberFilter CompareName;
+
+		static ArrayList tempvars; // For ByRef - different parameter and argument type
+		static bool is_byref_conversion = false; //For ByRef when it is converted 
+		static string errorMsg = "";
+
+		static Invocation ()
+		{
+			method_parameter_cache = new PtrHashtable ();
+		}
+			
+		//
+		// arguments is an ArrayList, but we do not want to typecast,
+		// as it might be null.
+		//
+		// FIXME: only allow expr to be a method invocation or a
+		// delegate invocation (7.5.5)
+		//
+		public Invocation (Expression expr, ArrayList arguments, Location l)
+		{
+			this.expr = expr;
+			if (this.expr is MemberAccess)
+				((MemberAccess) this.expr).IsInvocation = true;
+			if (this.expr is SimpleName)
+				((SimpleName) this.expr).IsInvocation = true;
+			this.is_retval_required = false;
+			this.is_left_hand = false;
+			Arguments = arguments;
+			loc = l;
+			//CompareName = new MemberFilter (compare_name_filter);
+		}
+
+		public Expression Expr {
+			get {
+				return expr;
+			}
+		}
+
+		public bool IsLeftHand {
+			get {
+				return is_left_hand;
+			}
+			set {
+				is_left_hand = value;
+			}
+		}
+
+		public bool IsRetvalRequired {
+			get {
+				return is_retval_required;
+			}
+			set {
+				is_retval_required = value;
+			}
+		}
+
+		public bool IsLateBinding {
+			get {
+				return is_latebinding;
+			}
+			set {
+				is_latebinding = value;
+			}
+		}
+
+		/// <summary>
+		///   Returns the Parameters (a ParameterData interface) for the
+		///   Method 'mb'
+		/// </summary>
+		public static ParameterData GetParameterData (MethodBase mb)
+		{
+			object pd = method_parameter_cache [mb];
+			object ip;
+			
+			if (pd != null)
+				return (ParameterData) pd;
+
+			
+			ip = TypeManager.LookupParametersByBuilder (mb);
+			if (ip != null){
+				method_parameter_cache [mb] = ip;
+
+				return (ParameterData) ip;
+			} else {
+				ParameterInfo [] pi = mb.GetParameters ();
+
+				ReflectionParameters rp = new ReflectionParameters (pi);
+				method_parameter_cache [mb] = rp;
+
+				return (ParameterData) rp;
+			}
+		}
+
+		enum Applicability { Same, Better, Worse };
+
+		/// <summary>
+		///  Determines "Better function"
+		/// </summary>
+		/// <remarks>
+		///    and returns an integer indicating :
+		///    0 if candidate ain't better
+		///    1 if candidate is better than the current best match
+		/// </remarks>
+		static Applicability BetterFunction (EmitContext ec, ArrayList args,
+					    MethodBase candidate, MethodBase best,
+					    bool expanded_form, Location loc)
+		{
+			ParameterData candidate_pd = GetParameterData (candidate);
+			ParameterData best_pd;
+			int argument_count;
+
+			if (args == null)
+				argument_count = 0;
+			else
+				argument_count = args.Count;
+
+			int cand_count = candidate_pd.Count;
+
+			if (cand_count == 0 && argument_count == 0)
+				return Applicability.Same;
+
+			if (candidate_pd.ParameterModifier (cand_count - 1) != Parameter.Modifier.PARAMS)
+				if (cand_count != argument_count)
+					return Applicability.Worse;
+			
+			best_pd = GetParameterData (best);
+
+			Applicability res = Applicability.Same;
+
+			for (int j = 0; j < argument_count; ++j) {
+				
+				//Argument a = (Argument) args [j];
+
+				Type ct = candidate_pd.ParameterType (j);
+				Type bt = best_pd.ParameterType (j);
+
+				if (candidate_pd.ParameterModifier (j) == Parameter.Modifier.PARAMS)
+					if (expanded_form)
+						ct = ct.GetElementType ();
+
+				if (best_pd.ParameterModifier (j) == Parameter.Modifier.PARAMS)
+					if (expanded_form)
+						bt = bt.GetElementType ();
+				
+				if (ct != bt) {
+					if (!WideningConversionExists (ct, bt))
+						return Applicability.Worse;
+					res = Applicability.Better;
+				}
+			}
+
+			if (res == Applicability.Same)
+				if (candidate_pd.Count < best_pd.Count)
+					res = Applicability.Better;
+				else if (candidate_pd.Count > best_pd.Count)
+					res = Applicability.Worse;
+
+			return res;
+		}
+
+		public static string FullMethodDesc (MethodBase mb)
+		{
+			string ret_type = "";
+
+			if (mb is MethodInfo)
+				ret_type = TypeManager.MonoBASIC_Name (((MethodInfo) mb).ReturnType) + " ";
+			
+			StringBuilder sb = new StringBuilder (ret_type + mb.Name);
+			ParameterData pd = GetParameterData (mb);
+
+			int count = pd.Count;
+			sb.Append (" (");
+			
+			for (int i = count; i > 0; ) {
+				i--;
+
+				sb.Append (pd.ParameterDesc (count - i - 1));
+				if (i != 0)
+					sb.Append (", ");
+			}
+			
+			sb.Append (")");
+			return sb.ToString ();
+		}
+
+		public static MethodGroupExpr MakeUnionSet (Expression mg1, Expression mg2, Location loc)
+		{
+			MemberInfo [] miset;
+			MethodGroupExpr union;
+
+			if (mg1 == null){
+				if (mg2 == null)
+					return null;
+				return (MethodGroupExpr) mg2;
+			} else {
+				if (mg2 == null)
+					return (MethodGroupExpr) mg1;
+			}
+			
+			MethodGroupExpr left_set = null, right_set = null;
+			int length1 = 0, length2 = 0;
+			
+			left_set = (MethodGroupExpr) mg1;
+			length1 = left_set.Methods.Length;
+			
+			right_set = (MethodGroupExpr) mg2;
+			length2 = right_set.Methods.Length;
+			
+			ArrayList common = new ArrayList ();
+
+			foreach (MethodBase l in left_set.Methods){
+				foreach (MethodBase r in right_set.Methods){
+					if (l != r)
+						continue;
+					common.Add (r);
+					break;
+				}
+			}
+			
+			miset = new MemberInfo [length1 + length2 - common.Count];
+			left_set.Methods.CopyTo (miset, 0);
+			
+			int k = length1;
+
+			foreach (MemberInfo mi in right_set.Methods){
+				if (!common.Contains (mi))
+					miset [k++] = mi;
+			}
+			
+			union = new MethodGroupExpr (miset, loc);
+			
+			return union;
+		}
+
+
+		protected enum ConversionType { None, Widening, Narrowing };
+
+		static ConversionType CheckParameterAgainstArgument (EmitContext ec, ParameterData pd, int i, Argument a, Type ptype)
+		{
+			if (a.ArgType == Argument.AType.NoArg)  {
+				return ConversionType.Widening;
+			}
+
+			Parameter.Modifier a_mod = a.GetParameterModifier () &
+				~(Parameter.Modifier.REF);
+			Parameter.Modifier p_mod = pd.ParameterModifier (i) &
+				~(Parameter.Modifier.REF | Parameter.Modifier.OPTIONAL);
+
+			if (a_mod == p_mod ||
+				(a_mod == Parameter.Modifier.NONE && p_mod == Parameter.Modifier.PARAMS)) {
+				// if (a_mod == Parameter.Modifier.NONE) {
+					if (p_mod == Parameter.Modifier.PARAMS) {
+						if (!(a.Expr is NullLiteral))
+							if (ptype.IsArray && !a.Expr.Type.IsArray)
+								return ConversionType.None;
+					}
+					if (! WideningConversionExists (a.Expr, ptype) ) {
+
+						if (! NarrowingConversionExists (ec, a.Expr, ptype) )
+							return ConversionType.None;
+						else
+							return ConversionType.Narrowing;
+					} else
+						return ConversionType.Widening;
+				 // }
+				
+/*
+				if ((a_mod & Parameter.Modifier.ISBYREF) != 0) {
+					Type pt = pd.ParameterType (i);
+					
+					if (!pt.IsByRef)
+						pt = TypeManager.LookupType (pt.FullName + "&");
+
+					if (pt != a.Type)
+						return ConversionType.None;
+				}
+				return ConversionType.Widening;
+*/
+			} else
+				return ConversionType.None;					
+		}
+
+		static bool HasArrayParameter (ParameterData pd)
+		{
+			int c = pd.Count;
+			return c > 0 && (pd.ParameterModifier (c - 1) & Parameter.Modifier.PARAMS) != 0;
+		}
+
+		static int CountStandardParams (ParameterData pd) 
+		{
+			int count = pd.Count;
+			for (int i = 0; i < count; i++) {
+				Parameter.Modifier pm = pd.ParameterModifier (i);
+				if ((pm & (Parameter.Modifier.OPTIONAL | Parameter.Modifier.PARAMS)) != 0)
+					return i;
+			}
+			return count;
+		}
+
+		static ConversionType IsApplicable (EmitContext ec, ArrayList arguments, MethodBase candidate,
+						    out bool expanded)
+		{
+			bool objectArgsPresent;
+			return IsApplicable (ec, arguments, candidate, out expanded, out objectArgsPresent);
+		}
+
+		/// <summary>
+		///  Determines if the candidate method is applicable (section 14.4.2.1)
+		///  to the given set of arguments
+		/// </summary>
+		static ConversionType IsApplicable (EmitContext ec, ArrayList arguments, MethodBase candidate,
+						    out bool expanded, out bool objectArgsPresent)
+		{
+			int arg_count;
+			Type param_type;
+
+			expanded = objectArgsPresent = false;
+			int num_narr_conv = 0;		// Count the narrowing conversion not involving object
+							// arguments
+			
+			if (arguments == null)
+				arg_count = 0;
+			else
+				arg_count = arguments.Count;
+
+			ParameterData pd = GetParameterData (candidate);
+			int ps_count = CountStandardParams (pd);			
+			int pd_count = pd.Count;
+
+			// Validate argument count
+			if (ps_count == pd_count) {
+				if (arg_count != pd_count)
+					return ConversionType.None;
+			}
+			else {
+				if (arg_count < ps_count)
+					return ConversionType.None;
+				if (!HasArrayParameter (pd) && arg_count > pd_count)
+					return ConversionType.None;
+			}       
+
+			ConversionType result = ConversionType.Widening;
+			if (arg_count > 0) {
+				result = ConversionType.None;
+				int array_param_index = -1;
+				for (int i = 0; i < arg_count; ++i) {
+					Argument a = (Argument) arguments [i];
+					param_type = pd.ParameterType (i);
+					Parameter.Modifier mod = pd.ParameterModifier (i);
+					if (array_param_index < 0 && (mod & Parameter.Modifier.PARAMS) != 0)
+						array_param_index = i;
+
+					bool IsDelegate = TypeManager.IsDelegateType (param_type);
+
+					if (IsDelegate)	{	
+						if (a.ArgType == Argument.AType.AddressOf) {
+							a = new Argument ((Expression) a.Expr, Argument.AType.Expression);
+							ArrayList args = new ArrayList();
+							args.Add (a);
+							string param_name = pd.ParameterDesc(i).Replace('+', '.');
+							Expression pname = MonoBASIC.Parser.DecomposeQI (param_name, Location.Null);
+
+							New temp_new = new New ((Expression)pname, args, Location.Null);
+							Expression del_temp = temp_new.DoResolve(ec);
+
+							if (del_temp == null)
+								return ConversionType.None;
+
+							a = new Argument (del_temp, Argument.AType.Expression);
+							if (!a.Resolve(ec, Location.Null))
+								return ConversionType.None;
+						}
+					}
+					else {
+						if (a.ArgType == Argument.AType.AddressOf)
+							return ConversionType.None;
+					}
+
+					if (a.ArgType != Argument.AType.NoArg && (mod & Parameter.Modifier.REF) != 0) {
+						a = new Argument (a.Expr, Argument.AType.Ref);
+						if (!a.Resolve(ec,Location.Null))
+							return ConversionType.None;
+					}
+
+					ConversionType match = ConversionType.None;
+					if (i == array_param_index) 
+						match = CheckParameterAgainstArgument (ec, pd, i, a, param_type);
+					if (match == ConversionType.None && array_param_index >= 0 && i >= array_param_index) {
+						expanded = true;
+						param_type = param_type.GetElementType ();
+					}
+					if (match == ConversionType.None)
+						match = CheckParameterAgainstArgument (ec, pd, i, a, param_type);
+					if (match == ConversionType.None)
+						return ConversionType.None;
+
+					if (match == ConversionType.Narrowing) {
+						result = match;
+						if (a.Expr.Type == TypeManager.object_type)
+							objectArgsPresent = true;
+						else {
+							objectArgsPresent = false;
+							num_narr_conv ++;
+						}
+					} else if (result == ConversionType.None)
+						result = match;
+				}
+			}
+
+			if (num_narr_conv > 0)	// There were narrowing conversions other than those for object arguments
+				objectArgsPresent = false;
+
+			return result;
+		}
+
+		internal static ArrayList ReorderArguments (MethodBase mb,
+							    ArrayList Arguments,
+							    CaseInsensitiveHashtable namedArgs,
+							    ref string ErrMsg,
+							    Location loc)
+		{
+			ArrayList orderedArgs = new ArrayList ();
+			ParameterData pd = GetParameterData (mb);
+			bool error = false;
+			for (int index = 0; index < pd.Count; index ++) {
+				string paramName = pd.ParameterName (index);
+				if (namedArgs.Contains (paramName)) {
+					if ((pd.ParameterModifier (index) & Parameter.Modifier.PARAMS) == Parameter.Modifier.PARAMS) {
+						error = true;
+						ErrMsg += "\n\t'" + FullMethodDesc (mb) + "': Named argument cannot match a ParamArray parameter";
+						continue;
+					}
+					int argIndex = (int) namedArgs [paramName];
+					orderedArgs.Add (Arguments [argIndex]);
+				} else {
+					Parameter.Modifier p_mod = pd.ParameterModifier (index) & Parameter.Modifier.OPTIONAL;
+					if (p_mod == Parameter.Modifier.OPTIONAL)
+						orderedArgs.Add (new Argument (pd.ParameterName (index), new EmptyExpression (), Argument.AType.NoArg));
+					 else {
+						error = true;
+						ErrMsg += "\n\t'" + FullMethodDesc (mb) + "': Argument not specified for parameter '" + paramName + "'";
+					}
+				}
+			}
+
+			if (Arguments.Count > orderedArgs.Count) {
+				for (int argIndex = 0; argIndex < Arguments.Count; argIndex ++) {
+					string argName = ((Argument) Arguments [argIndex]).ParamName;
+					bool found = false;
+					for (int paramIndex = 0; paramIndex < pd.Count; paramIndex ++) {
+						string paramName = pd.ParameterName (paramIndex);
+						if (String.Compare (argName, paramName, true) == 0) {
+							found = true;
+							break;
+						}
+					}
+					if (!found) {
+						error = true;
+						ErrMsg += "\n\t'" + FullMethodDesc (mb) + "': '" + argName + "' is not a parameter";
+					}
+				}
+			}
+			if (error)
+				return null;
+			return orderedArgs;
+		}
+		
+/*
+		static bool compare_name_filter (MemberInfo m, object filterCriteria)
+		{
+			return (m.Name == ((string) filterCriteria));
+		}
+*/
+
+		public static MethodBase OverloadResolve (EmitContext ec, MethodGroupExpr me,
+							  ref ArrayList Arguments, Location loc)
+		{
+			bool isLateBindingRequired;
+			return OverloadResolve (ec, me, ref Arguments, loc, out isLateBindingRequired);	
+		}
+
+		// We need an overload for OverloadResolve because Invocation.DoResolve
+		// must pass Arguments by reference, since a later call to IsApplicable
+		// can change the argument list if optional parameters are defined
+		// in the method declaration
+		public static MethodBase OverloadResolve (EmitContext ec, MethodGroupExpr me,
+							  ArrayList Arguments, Location loc)
+		{
+			ArrayList a = Arguments;
+			return OverloadResolve (ec, me, ref a, loc);	
+		}
+
+/*
+		static string ToString(MethodBase mbase)
+		{
+			if (mbase == null)
+				return "NULL";
+
+			if (mbase is MethodBuilder)
+			{
+				MethodBuilder mb = (MethodBuilder) mbase;
+				String res = mb.ReturnType + " (";
+				ParameterInfo [] parms = mb.GetParameters();
+				for (int i = 0; i < parms.Length; i++) {
+					if (i != 0)
+						res += " ";
+					res += parms[i].ParameterType;
+				}
+				res += ")";
+				return res;
+			}
+
+			return mbase.ToString();
+		}
+*/
+		
+		/// <summary>
+		///   Find the Applicable Function Members (7.4.2.1)
+		///
+		///   me: Method Group expression with the members to select.
+		///       it might contain constructors or methods (or anything
+		///       that maps to a method).
+		///
+		///   Arguments: ArrayList containing resolved Argument objects.
+		///
+		///   loc: The location if we want an error to be reported, or a Null
+		///        location for "probing" purposes.
+		///
+		///   isLateBindingRequired : Flag to indicate that this method call is
+		///                           is a candidate for late binding. Set to true if
+		///                           there is atleast one object argument and we get
+		///                           * Two or more candidates that require widening conv
+		///                           * Two or more candidates require narrowing conversions
+		///                             (for object arguments **only**)
+		///   Returns: The MethodBase (either a ConstructorInfo or a MethodInfo)
+		///            that is the best match of me on Arguments.
+		///
+		/// </summary>
+		public static MethodBase OverloadResolve (EmitContext ec, MethodGroupExpr me,
+							  ref ArrayList Arguments, Location loc,
+							  out bool isLateBindingRequired)
+		{
+			MethodBase method = null;
+			int argument_count;
+			ArrayList candidates = new ArrayList ();
+			ArrayList lateBindingCandidates = new ArrayList ();
+			Hashtable expanded_candidates = new Hashtable();
+			int narrow_count = 0;
+			bool narrowing_candidate = false;
+			errorMsg = "";
+			isLateBindingRequired = false;
+			CaseInsensitiveHashtable namedArgs = new CaseInsensitiveHashtable ();
+
+			if (Arguments == null)
+				argument_count = 0;
+			else
+				argument_count = Arguments.Count;
+
+			if (!CheckNamedArguments (Arguments, loc))
+				return null;
+
+			if (!GetNamedArgPos (Arguments, ref namedArgs, loc))
+				return null;
+
+			ArrayList newarglist = Arguments;
+			foreach (MethodBase candidate in me.Methods){
+				bool candidate_expanded, object_args_present;
+				newarglist = Arguments;
+				if (argument_count > 0 && namedArgs.Count != 0) {
+					newarglist = ReorderArguments (candidate, Arguments, namedArgs, ref errorMsg, loc);
+					if (newarglist == null)
+						continue;
+				}
+
+				ConversionType m = IsApplicable (ec, newarglist, candidate, out candidate_expanded, out object_args_present);
+				if (candidate_expanded)
+					expanded_candidates [candidate] = candidate;
+				if (m == ConversionType.None)
+					continue;
+				else if (m == ConversionType.Narrowing) {
+					if (object_args_present)   // if the narrowing conversion was due 
+								   // to the argument being an object
+						lateBindingCandidates.Add (candidate);
+					if (method == null) {
+						method = candidate;
+						narrowing_candidate = true;
+					} 
+					narrow_count++;
+				} else if (m == ConversionType.Widening) {
+					if (method == null || narrowing_candidate) {
+						method = candidate;
+						narrowing_candidate = false;
+					} else {
+						Applicability res = BetterFunction (ec, Arguments, candidate, method, true, loc);
+						if (res == Applicability.Same)
+							continue; // should check it overrides?
+						if (res == Applicability.Better)
+							method = candidate;
+					}
+					candidates.Add (candidate);
+				}
+			}
+
+			if (candidates.Count == 0) {
+				if (lateBindingCandidates.Count > 1) {
+					isLateBindingRequired = true;
+					return null;
+				}
+
+				if (narrow_count > 1) {
+					if (lateBindingCandidates.Count == 1)
+						method = (MethodBase) lateBindingCandidates [0];
+					else 
+						method = null;
+				} else if (narrow_count == 1)
+					candidates = null;
+			} else if (candidates.Count == 1) {
+				method = (MethodBase)candidates [0];
+				candidates = null;
+			} else
+				narrow_count  = 0;
+
+			if (method == null) {
+				//
+				// Okay so we have failed to find anything so we
+				// return by providing info about the closest match
+				//
+				for (int i = 0; i < me.Methods.Length; ++i) {
+
+					MethodBase c = (MethodBase) me.Methods [i];
+					ParameterData pd = GetParameterData (c);
+
+					if (pd.Count != argument_count)
+						continue;
+
+					bool dummy;
+					if (narrow_count != 0) {
+						if (IsApplicable (ec, Arguments, c, out dummy) == ConversionType.None)
+							continue;
+						Report.Error (1502, loc,
+							"Overloaded match for method '" +
+							FullMethodDesc (c) +
+							"' requires narrowing conversionss");
+					}
+
+					VerifyArgumentsCompat (ec, Arguments, argument_count, c, false,
+							       null, loc);
+				}
+				
+				return null;
+			}
+
+			//
+			// Now check that there are no ambiguities i.e the selected method
+			// should be better than all the others
+			//
+
+			if (candidates != null) {
+				foreach (MethodBase candidate in candidates){
+					if (candidate == method)
+						continue;
+
+
+					if (BetterFunction (ec, Arguments, candidate, method,
+								false, loc) == Applicability.Better) {
+						Report.Error (
+							121, loc,
+							"Ambiguous call of '" + me.Name + "' when selecting function due to implicit casts");
+						return null;
+					}
+				}
+			}
+
+			//
+			// And now check if the arguments are all compatible, perform conversions
+			// if necessary etc. and return if everything is all right
+			//
+			if (method == null)
+				return null;
+
+			bool chose_params_expanded = expanded_candidates.Contains (method);
+
+			newarglist = Arguments;
+			if (argument_count > 0 && namedArgs.Count != 0) {
+				string err = "";
+				newarglist = ReorderArguments (method, Arguments, namedArgs, ref err, loc);
+				if (newarglist == null)
+					return null;
+			}
+			Arguments = ConstructArgumentList(ec, newarglist, namedArgs, method);
+			if (VerifyArgumentsCompat (ec, Arguments, argument_count, method,
+						   chose_params_expanded, null, loc))
+			{
+				return method;
+			}
+			else
+				return null;
+		}
+
+		internal static bool CheckNamedArguments (ArrayList Arguments, Location loc) 
+		{
+			if (Arguments == null || Arguments.Count == 0)
+				return true;
+			
+			bool namedArgFound = false;
+			for (int index = 0; index < Arguments.Count; index ++) {
+				Argument a = (Argument) Arguments [index];
+				if (a.ParamName == null || a.ParamName == "") {
+					if (namedArgFound) {
+						Report.Error (30241, loc,
+							"Named argument expected");
+						return false;
+					}
+				} else
+					namedArgFound = true;
+			}
+
+			return true;
+		}
+
+		internal static bool GetNamedArgPos (ArrayList Arguments, ref CaseInsensitiveHashtable namedArgs, Location loc) 
+		{
+			namedArgs.Clear ();
+			if (Arguments == null || Arguments.Count == 0)
+				return true;
+			for (int index = 0; index < Arguments.Count; index ++) {
+				Argument a = (Argument) Arguments [index];
+				if (a.ParamName == null || a.ParamName == "")
+					// none of the args are named
+					return true;
+				if (namedArgs.Contains (a.ParamName)) {
+					Report.Error (30274, loc, "Parameter '" + a.ParamName +"'already has a matching argument");
+					return false;
+				}
+				namedArgs.Add (a.ParamName, index);
+			}
+			return true;
+		}
+
+		public static ArrayList ConstructArgumentList (EmitContext ec, ArrayList Arguments, CaseInsensitiveHashtable namedArgs, MethodBase method)
+		{
+			ArrayList newarglist = new ArrayList();
+			int arg_count = Arguments == null ? 0 : Arguments.Count;
+
+			ParameterData pd = GetParameterData (method);
+			bool argNamesGiven = (namedArgs.Count > 0);
+			for (int i = 0; i < arg_count; i++) {
+				Argument a = (Argument) Arguments [i];
+				Type param_type = pd.ParameterType (i);
+
+				bool IsDelegate = TypeManager.IsDelegateType (param_type);
+				if (a.ArgType == Argument.AType.NoArg) {
+					Expression pdvalue = pd.DefaultValue (i);
+					pdvalue.Resolve (ec);
+					if (pdvalue != NullLiteral.Null)
+						pdvalue = ConvertImplicit (ec, pdvalue, param_type, Location.Null);;
+					if (argNamesGiven)
+						a = new Argument (pd.ParameterName (i), pdvalue, Argument.AType.Expression);
+					else
+						a = new Argument (pdvalue, Argument.AType.Expression);
+					a.Resolve (ec, Location.Null);
+				}
+
+				if (IsDelegate)	{	
+					if (a.ArgType == Argument.AType.AddressOf) {
+						a = new Argument ((Expression) a.Expr, Argument.AType.Expression);
+						ArrayList args = new ArrayList();
+						args.Add (a);
+						string param_name = pd.ParameterDesc(i).Replace('+', '.');
+						Expression pname = MonoBASIC.Parser.DecomposeQI (param_name, Location.Null);
+
+						New temp_new = new New ((Expression)pname, args, Location.Null);
+						Expression del_temp = temp_new.DoResolve(ec);
+						a = new Argument (del_temp, Argument.AType.Expression);
+						a.Resolve(ec, Location.Null);
+					}
+				}
+				if ((pd.ParameterModifier (i) & Parameter.Modifier.REF) != 0) {
+					a.ArgType = Argument.AType.Ref;
+					a.Resolve(ec, Location.Null);
+				}	
+
+				newarglist.Add (a);
+			}
+
+			if (HasArrayParameter (pd) && arg_count == pd.Count - 1)
+				return newarglist;
+
+			for (int i = arg_count; i < pd.Count; i++) {
+				Type param_type = pd.ParameterType (i);
+				Expression e = pd.DefaultValue (i);
+				e.Resolve (ec);
+				if (e != NullLiteral.Null)
+					e = ConvertImplicit (ec, e, param_type, Location.Null);
+				Argument a = null;
+				if (argNamesGiven)
+					a = new Argument (e, Argument.AType.Expression);
+				else
+					a = new Argument (pd.ParameterName (i), e, Argument.AType.Expression);
+				if ((pd.ParameterModifier (i) & Parameter.Modifier.REF) != 0)
+					a.ArgType = Argument.AType.Ref;
+				a.Resolve (ec, Location.Null);
+				newarglist.Add (a);
+			}
+
+			return newarglist;
+		}
+
+		public static bool VerifyArgumentsCompat (EmitContext ec, ArrayList Arguments,
+			int argument_count,
+			MethodBase method, 
+			bool chose_params_expanded,
+			Type delegate_type,
+			Location loc)
+		{
+			return (VerifyArgumentsCompat (ec, Arguments, argument_count,
+				method, chose_params_expanded, delegate_type, loc, null));
+		}
+										  
+		public static bool VerifyArgumentsCompat (EmitContext ec, 
+							  ArrayList Arguments,
+							  int argument_count,
+							  MethodBase method, 
+							  bool chose_params_expanded,
+							  Type delegate_type,
+							  Location loc,
+							  string InvokingProperty)
+		{
+			ParameterData pd = GetParameterData (method);
+			int pd_count = pd.Count;
+
+			for (int j = 0; j < argument_count; j++) {
+				Argument a = (Argument) Arguments [j];
+				Expression a_expr = a.Expr;
+				Type parameter_type = pd.ParameterType(j);
+					
+				if (parameter_type == null)
+				{
+					Error_WrongNumArguments(loc, (InvokingProperty == null)?((delegate_type == null)?FullMethodDesc (method):delegate_type.ToString ()):InvokingProperty, argument_count);
+					return false;	
+				}
+				if (pd.ParameterModifier (j) == Parameter.Modifier.PARAMS &&
+				chose_params_expanded)
+					parameter_type = TypeManager.TypeToCoreType (parameter_type.GetElementType ());
+				// By pass conversion for foll. case and handle it in EmitArguments()
+
+				if (a.ArgType != Argument.AType.Ref && a.Type != parameter_type){
+					Expression conv;
+					
+					conv = ConvertImplicit (ec, a_expr, parameter_type, loc);
+
+					if (conv == null) {
+						if (!Location.IsNull (loc)) {
+							if (delegate_type == null) 
+								if (InvokingProperty == null)
+									Report.Error (1502, loc,
+										"The best overloaded match for method '" +
+										FullMethodDesc (method) +
+										"' has some invalid arguments");
+								else
+									Report.Error (1502, loc,
+										"Property '" +
+										InvokingProperty +
+										"' has some invalid arguments");
+							else
+								Report.Error (1594, loc,
+									      "Delegate '" + delegate_type.ToString () +
+									      "' has some invalid arguments.");
+							Report.Error (1503, loc,
+							 "Argument " + (j+1) +
+							 ": Cannot convert from '" + Argument.FullDesc (a) 
+							 + "' to '" + pd.ParameterDesc (j) + "'");
+						}
+						
+						return false;
+					}
+					
+					//
+					// Update the argument with the implicit conversion
+					//
+					if (a_expr != conv)
+						a.Expr = conv;
+				}
+
+				Parameter.Modifier a_mod = a.GetParameterModifier () &
+					~(Parameter.Modifier.REF);
+				Parameter.Modifier p_mod = pd.ParameterModifier (j) &
+					~(Parameter.Modifier.REF | Parameter.Modifier.OPTIONAL);
+
+				if (a_mod != p_mod &&
+				    pd.ParameterModifier (pd_count - 1) != Parameter.Modifier.PARAMS) {
+					if (!Location.IsNull (loc)) {
+						Report.Error (1502, loc,
+						       "The best overloaded match for method '" + FullMethodDesc (method)+
+						       "' has some invalid arguments");
+						Report.Error (1503, loc,
+						       "Argument " + (j+1) +
+						       ": Cannot convert from '" + Argument.FullDesc (a) 
+						       + "' to '" + pd.ParameterDesc (j) + "'");
+					}
+					
+					return false;
+				}
+			}
+
+			return true;
+		}
+		
+		public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			this.is_left_hand = true;
+			Expression expr_to_return = DoResolve (ec);
+			if (expr_to_return is PropertyGroupExpr) {
+				PropertyGroupExpr pe = expr_to_return as PropertyGroupExpr;
+				pe = (PropertyGroupExpr) pe.ResolveLValue (ec, right_side);
+				if (pe == null)
+					return null;
+				if (pe.IndexerAccessRequired) {
+					if (pe.Type.IsArray) {
+						// If we are here, expr must be an ArrayAccess
+						ArrayList idxs = new ArrayList();
+						foreach (Argument a in Arguments)
+						{
+							idxs.Add (a.Expr);
+						}
+						ElementAccess ea = new ElementAccess (expr_to_return, idxs, expr.Location);
+						ArrayAccess aa = new ArrayAccess (ea, expr_to_return.Location);
+						expr_to_return = aa.DoResolve(ec);
+						expr_to_return.eclass = ExprClass.Variable;
+					} else {
+						//
+						// check whether this is a indexer
+						//
+						ArrayList idxs = new ArrayList();
+						foreach (Argument a in Arguments) {
+							idxs.Add (a.Expr);
+						}
+						ElementAccess ea = new ElementAccess (expr_to_return, idxs, expr.Location);
+						IndexerAccess ia = new IndexerAccess (ea, expr_to_return.Location);
+						if (is_left_hand)
+							expr_to_return = ia.DoResolveLValue (ec, right_side);
+						else
+							expr_to_return = ia.DoResolve(ec);
+					}
+					return expr_to_return;
+				}
+			}
+
+			if (expr_to_return is IndexerAccess && is_left_hand) {
+				IndexerAccess ia = expr_to_return as IndexerAccess;
+				expr_to_return = ia.DoResolveLValue (ec, right_side);
+			}
+
+			return expr_to_return;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (method != null)	// already resolved
+				return this;
+			//
+			// First, resolve the expression that is used to
+			// trigger the invocation
+			//
+			Expression expr_to_return = null;
+			Expression temp = null;
+
+			if (expr is BaseAccess)
+				is_base = true;
+
+			ResolveFlags flags;
+			if ((ec.ReturnType != null) && (expr.ToString() == ec.BlockName)) {
+				ec.InvokingOwnOverload = true;
+				flags = ResolveFlags.MethodGroup;
+				temp = expr.Resolve (ec, flags);
+				ec.InvokingOwnOverload = false;
+			}
+			else				
+			{
+				ec.InvokingOwnOverload = false;
+				flags = ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup;
+				temp = expr.Resolve (ec, flags);
+			}
+
+			if (temp == null) {
+				if (is_left_hand)
+					return null;
+			
+				if (expr is MemberAccess) {
+					MemberAccess m = expr as MemberAccess;
+					if (m.Expr.Type == TypeManager.object_type) {
+						StatementSequence etmp = new StatementSequence (ec.CurrentBlock, 
+										loc, expr, Arguments, 
+										is_retval_required, is_left_hand);
+						if (!etmp.ResolveArguments (ec))
+							return null;
+						etmp.GenerateLateBindingStatements();
+						this.is_latebinding = true;
+						return etmp.Resolve (ec);
+					}
+				}
+				return null;
+			}
+	
+			expr = temp;
+
+			if (expr is Invocation) {
+				// FIXME Calls which return an Array are not resolved (here or in the grammar)
+				expr = expr.Resolve(ec);
+			}
+
+			if (!(expr is MethodGroupExpr || expr is PropertyGroupExpr)) 
+			{
+				Type expr_type = expr.Type;
+
+				if (expr_type != null)
+				{
+					bool IsDelegate = TypeManager.IsDelegateType (expr_type);
+					if (IsDelegate)
+						return (new DelegateInvocation (
+							this.expr, Arguments, loc)).Resolve (ec);
+				}
+			}
+
+			//
+			// Next, evaluate all the expressions in the argument list
+			//
+			if (Arguments != null)
+			{
+				foreach (Argument a in Arguments)
+				{
+					if ((a.ArgType == Argument.AType.NoArg) && (!(expr is MethodGroupExpr)))
+						Report.Error (999, "This item cannot have empty arguments");
+
+					if (!a.Resolve (ec, loc))
+						return null;				
+				}
+			}
+			
+			if (expr is MethodGroupExpr) 
+			{
+				MethodGroupExpr mg = (MethodGroupExpr) expr;
+				bool isLateBindingRequired = false;
+				method = OverloadResolve (ec, mg, ref Arguments, loc, out isLateBindingRequired);
+				if (method == null)
+				{
+					if (isLateBindingRequired) {
+						Expression type_expr = new TypeOf (Parser.DecomposeQI (mg.DeclaringType.Name, loc), loc);
+						StatementSequence etmp = new StatementSequence (ec.CurrentBlock, 
+									loc, null, mg.Name, type_expr, 
+									Arguments, is_retval_required, is_left_hand);
+						if (! etmp.ResolveArguments (ec))
+							return null;
+						etmp.GenerateLateBindingStatements ();
+						return etmp.Resolve (ec);
+					}
+					Error (30455,
+						"Could not find any applicable function to invoke for this argument list" + errorMsg);
+					return null;
+				}
+
+				if ((method as MethodInfo) != null) 
+				{
+					MethodInfo mi = method as MethodInfo;
+					type = TypeManager.TypeToCoreType (mi.ReturnType);
+					if (!mi.IsStatic && !mg.IsExplicitImpl && (mg.InstanceExpression == null))
+						SimpleName.Error_ObjectRefRequired (ec, loc, mi.Name);
+				}
+
+				if ((method as ConstructorInfo) != null) 
+				{
+					ConstructorInfo ci = method as ConstructorInfo;
+					type = TypeManager.void_type;
+					if (!ci.IsStatic && !mg.IsExplicitImpl && (mg.InstanceExpression == null))
+						SimpleName.Error_ObjectRefRequired (ec, loc, ci.Name);
+				}
+
+				if (type.IsPointer)
+				{
+					if (!ec.InUnsafe)
+					{
+						UnsafeError (loc);
+						return null;
+					}
+				}
+				eclass = ExprClass.Value;
+				expr_to_return = this;
+				return expr_to_return;
+			}
+
+			if (expr is PropertyGroupExpr) 
+			{
+				PropertyGroupExpr pe = ((PropertyGroupExpr) expr);
+				if (pe.Arguments != null)
+					goto skip_already_resolved_property;
+				if (Arguments != null)
+					pe.Arguments = (ArrayList) Arguments.Clone ();
+				if (is_left_hand)
+					return pe;
+				string name = pe.Name;
+				pe = (PropertyGroupExpr) pe.Resolve (ec);
+				if (pe == null) {
+					Error (30057, "Property '" + name + "' cannot be invoked with given arguments");
+					return null;
+				}
+
+				if (!pe.IndexerAccessRequired)
+					return pe;
+				expr = pe;
+			}
+
+			skip_already_resolved_property:
+			if (expr.Type.IsArray) {
+				// If we are here, expr must be an ArrayAccess
+				ArrayList idxs = new ArrayList();
+				foreach (Argument a in Arguments)
+				{
+					idxs.Add (a.Expr);
+				}
+				ElementAccess ea = new ElementAccess (expr, idxs, expr.Location);
+				ArrayAccess aa = new ArrayAccess (ea, expr.Location);
+				expr_to_return = aa.DoResolve(ec);
+				expr_to_return.eclass = ExprClass.Variable;
+			} else {
+				//
+				// check whether this is a indexer
+				//
+				ArrayList idxs = new ArrayList();
+				foreach (Argument a in Arguments) {
+					idxs.Add (a.Expr);
+				}
+				ElementAccess ea = new ElementAccess (expr, idxs, expr.Location);
+				IndexerAccess ia = new IndexerAccess (ea, expr.Location);
+				if (!is_left_hand)
+					expr_to_return = ia.DoResolve(ec);
+				else
+					expr_to_return = ia.DoResolve(ec);
+				//
+				// Since all the above are failed we need to do
+				// late binding
+				//
+				if (expr_to_return == null) {
+
+					// We can't resolve now, but we
+					// have to try to access the array with a call
+					// to LateIndexGet/Set in the runtime
+					if (! is_left_hand) {
+						StatementSequence etmp = new StatementSequence (ec.CurrentBlock, 
+									loc, ia, Arguments, 
+									true, false);
+						if (!etmp.ResolveArguments (ec))
+							return null;
+						etmp.GenerateLateBindingStatements();
+						return etmp.Resolve (ec);
+					}
+					return null;
+				}
+			}
+
+			return expr_to_return;
+		}
+
+        	static void Error_WrongNumArguments (Location loc, String name, int arg_count)
+        	{
+            		Report.Error (1501, loc, "No overload for method `" + name + "' takes `" +
+                                      arg_count + "' arguments");
+        	}
+
+		// <summary>
+		//   Emits the list of arguments as an array
+		// </summary>
+		static void EmitParams (EmitContext ec, int idx, ArrayList arguments)
+		{
+			ILGenerator ig = ec.ig;
+			int count = arguments.Count - idx;
+			Argument a = (Argument) arguments [idx];
+			Type t = a.Expr.Type;
+			string array_type = t.FullName + "[]";
+			LocalBuilder array;
+
+			array = ig.DeclareLocal (TypeManager.LookupType (array_type));
+			IntConstant.EmitInt (ig, count);
+			ig.Emit (OpCodes.Newarr, TypeManager.TypeToCoreType (t));
+			ig.Emit (OpCodes.Stloc, array);
+
+			int top = arguments.Count;
+			for (int j = idx; j < top; j++){
+				a = (Argument) arguments [j];
+				
+				ig.Emit (OpCodes.Ldloc, array);
+				IntConstant.EmitInt (ig, j - idx);
+				a.Emit (ec);
+				
+				ArrayAccess.EmitStoreOpcode (ig, t);
+			}
+			ig.Emit (OpCodes.Ldloc, array);
+		}
+		
+		/// <summary>
+		///   Emits a list of resolved Arguments that are in the arguments
+		///   ArrayList.
+		/// </summary>
+		public static void EmitArguments (EmitContext ec, MethodBase mb, ArrayList arguments)
+		{
+			ParameterData pd = GetParameterData (mb);
+			//
+			// If we are calling a params method with no arguments, special case it
+			//
+			if (arguments == null){
+				if (pd.Count > 0 &&
+				    pd.ParameterModifier (0) == Parameter.Modifier.PARAMS){
+					ILGenerator ig = ec.ig;
+
+					IntConstant.EmitInt (ig, 0);
+					ig.Emit (OpCodes.Newarr, pd.ParameterType (0).GetElementType ());
+				}
+				return;
+			}
+
+			int top = arguments.Count;
+
+			for (int i = 0; i < top; i++){
+				Argument a = (Argument) arguments [i];
+				Type parameter_type = pd.ParameterType(i);
+				Type argtype = a.Type;
+				Type arg_expr_type = a.Expr.Type;
+
+				if (pd.ParameterModifier (i) == Parameter.Modifier.PARAMS){
+					//
+					// Special case if we are passing the same data as the
+					// params argument, do not put it in an array.
+					//
+					if (pd.ParameterType (i) == a.Type)
+						a.Emit (ec);
+					else
+						EmitParams (ec, i, arguments);
+					return;
+				}
+				if ((a.ArgType == Argument.AType.Ref ) &&
+					(parameter_type != arg_expr_type ||
+					 ! (a.Expr is IMemoryLocation))) {
+					
+					 LocalTemporary localtmp = new LocalTemporary (ec, parameter_type ); 
+
+					if((arg_expr_type != parameter_type) && (a.ArgType == Argument.AType.Ref)) {					 
+						Expression e = ConvertImplicit (ec, a.Expr, parameter_type, Location.Null);
+						is_byref_conversion = true;
+                                        	e.Emit (ec);
+					} else 
+						a.Expr.Emit (ec);
+					
+
+
+					if (tempvars == null)
+						tempvars = new ArrayList ();
+					if (a.Expr is IMemoryLocation && is_byref_conversion ) {
+						Expression conv;
+						if(argtype.IsByRef)
+							argtype = argtype.GetElementType();
+						conv = ConvertImplicit (ec, localtmp, argtype, Location.Null);
+						tempvars.Add (new Assign (a.Expr, conv, Location.Null));
+
+					} else if (a.Expr is PropertyGroupExpr) {
+						// FIXME: We shouldnt be doing Resolve from inside 'Emit'. 
+						// Have to find a way to push this up to 'Resolve'
+						Expression conv;
+						if(argtype.IsByRef)
+							argtype = argtype.GetElementType();
+						conv = ConvertImplicit (ec, localtmp, argtype, Location.Null);
+						Assign assgn = new Assign (a.Expr, conv, Location.Null);
+						Expression e = assgn.Resolve (ec);
+						tempvars.Add (e);
+					}
+                                       	localtmp.Store (ec);
+                                    	a = new Argument (localtmp, a.ArgType);
+				}
+                                a.Emit (ec);
+                        }
+
+
+
+			if (pd.Count > top &&
+			    pd.ParameterModifier (top) == Parameter.Modifier.PARAMS){
+				ILGenerator ig = ec.ig;
+
+				IntConstant.EmitInt (ig, 0);
+				ig.Emit (OpCodes.Newarr, pd.ParameterType (top).GetElementType ());
+			}
+		}
+
+		/// <remarks>
+		///   is_base tells whether we want to force the use of the 'call'
+		///   opcode instead of using callvirt.  Call is required to call
+		///   a specific method, while callvirt will always use the most
+		///   recent method in the vtable.
+		///
+		///   is_static tells whether this is an invocation on a static method
+		///
+		///   instance_expr is an expression that represents the instance
+		///   it must be non-null if is_static is false.
+		///
+		///   method is the method to invoke.
+		///
+		///   Arguments is the list of arguments to pass to the method or constructor.
+		/// </remarks>
+		public static void EmitCall (EmitContext ec, bool is_base,
+					     bool is_static, Expression instance_expr,
+					     MethodBase method, ArrayList Arguments, Location loc)
+		{
+			EmitCall (ec, is_base, is_static, instance_expr, method, Arguments, null, loc);
+		}
+		
+		public static void EmitCall (EmitContext ec, bool is_base,
+			bool is_static, Expression instance_expr,
+			MethodBase method, ArrayList Arguments, ArrayList prop_args, Location loc)
+		{
+			ILGenerator ig = ec.ig;
+			bool struct_call = false;
+			bool is_myclass = false;
+
+			if (instance_expr is This && ((This) instance_expr).AccessType == This.TypeOfAccess.MyClass) 
+				is_myclass = true;
+
+			Type decl_type = method.DeclaringType;
+
+			if (!RootContext.StdLib) 
+			{
+				// Replace any calls to the system's System.Array type with calls to
+				// the newly created one.
+				if (method == TypeManager.system_int_array_get_length)
+					method = TypeManager.int_array_get_length;
+				else if (method == TypeManager.system_int_array_get_rank)
+					method = TypeManager.int_array_get_rank;
+				else if (method == TypeManager.system_object_array_clone)
+					method = TypeManager.object_array_clone;
+				else if (method == TypeManager.system_int_array_get_length_int)
+					method = TypeManager.int_array_get_length_int;
+				else if (method == TypeManager.system_int_array_get_lower_bound_int)
+					method = TypeManager.int_array_get_lower_bound_int;
+				else if (method == TypeManager.system_int_array_get_upper_bound_int)
+					method = TypeManager.int_array_get_upper_bound_int;
+				else if (method == TypeManager.system_void_array_copyto_array_int)
+					method = TypeManager.void_array_copyto_array_int;
+			}
+
+			//
+			// This checks the 'ConditionalAttribute' on the method, and the
+			// ObsoleteAttribute
+			//
+			TypeManager.MethodFlags flags = TypeManager.GetMethodFlags (method, loc);
+			if ((flags & TypeManager.MethodFlags.IsObsoleteError) != 0)
+				return;
+			if ((flags & TypeManager.MethodFlags.ShouldIgnore) != 0)
+				return;
+			
+			if (!is_static)
+			{
+				if (decl_type.IsValueType)
+					struct_call = true;
+				//
+				// If this is ourselves, push "this"
+				//
+				if (instance_expr == null)
+				{
+					ig.Emit (OpCodes.Ldarg_0);
+				} 
+				else 
+				{
+					//
+					// Push the instance expression
+					//
+					if (instance_expr.Type.IsValueType)
+					{
+						//
+						// Special case: calls to a function declared in a 
+						// reference-type with a value-type argument need
+						// to have their value boxed.  
+
+						struct_call = true;
+						if (decl_type.IsValueType)
+						{
+							//
+							// If the expression implements IMemoryLocation, then
+							// we can optimize and use AddressOf on the
+							// return.
+							//
+							// If not we have to use some temporary storage for
+							// it.
+							if (instance_expr is IMemoryLocation)
+							{
+								((IMemoryLocation)instance_expr).
+									AddressOf (ec, AddressOp.LoadStore);
+							}
+							else 
+							{
+								Type t = instance_expr.Type;
+								
+								instance_expr.Emit (ec);
+								LocalBuilder temp = ig.DeclareLocal (t);
+								ig.Emit (OpCodes.Stloc, temp);
+								ig.Emit (OpCodes.Ldloca, temp);
+							}
+						} 
+						else 
+						{
+							instance_expr.Emit (ec);
+							ig.Emit (OpCodes.Box, instance_expr.Type);
+						} 
+					} 
+					else
+						instance_expr.Emit (ec);
+				}
+			}
+			
+			if (prop_args != null && prop_args.Count > 0)
+			{
+				if (Arguments == null) 
+					Arguments = new ArrayList();
+
+				for (int i = prop_args.Count-1; i >=0 ; i--) 
+				{
+					Arguments.Insert (0,prop_args[i]);
+				}
+
+			}
+
+			EmitArguments (ec, method, Arguments);
+
+			if (is_static || struct_call || is_base || is_myclass)
+			{
+				if (method is MethodInfo) 
+				{
+					ig.Emit (OpCodes.Call, (MethodInfo) method);
+				} 
+				else
+					ig.Emit (OpCodes.Call, (ConstructorInfo) method);
+			} 
+			else 
+			{
+				if (method is MethodInfo)
+					ig.Emit (OpCodes.Callvirt, (MethodInfo) method);
+				else
+					ig.Emit (OpCodes.Callvirt, (ConstructorInfo) method);
+			}
+		}
+		
+/*
+		static void EmitPropertyArgs (EmitContext ec, ArrayList prop_args)
+		{
+			int top = prop_args.Count;
+
+			for (int i = 0; i < top; i++)
+			{
+				Argument a = (Argument) prop_args [i];
+				a.Emit (ec);
+			}
+		}
+*/
+
+		public override void Emit (EmitContext ec)
+		{
+			MethodGroupExpr mg = (MethodGroupExpr) this.expr;
+ 
+			EmitCall (
+				ec, is_base, method.IsStatic, mg.InstanceExpression, method, Arguments, loc);
+		}
+		
+		public override void EmitStatement (EmitContext ec)
+		{
+			Emit (ec);
+
+			// 
+			// Pop the return value if there is one
+			//
+			if (method is MethodInfo){
+				Type ret = ((MethodInfo)method).ReturnType;
+				if ((TypeManager.TypeToCoreType (ret) != TypeManager.void_type) && !this.is_latebinding) {
+					ec.ig.Emit (OpCodes.Pop);
+
+					if (tempvars != null) {
+						foreach (Expression s in tempvars) {
+							if (s is ExpressionStatement)
+								((ExpressionStatement) s).EmitStatement (ec);
+							else
+								s.Emit (ec);
+						}
+						tempvars.Clear ();
+					}
+				}
+				
+			}
+		}
+	}
+
+	//
+	// This class is used to "disable" the code generation for the
+	// temporary variable when initializing value types.
+	//
+	class EmptyAddressOf : EmptyExpression, IMemoryLocation {
+		public void AddressOf (EmitContext ec, AddressOp Mode)
+		{
+			// nothing
+		}
+	}
+	
+	/// <summary>
+	///    Implements the new expression 
+	/// </summary>
+	public class New : ExpressionStatement {
+		public readonly ArrayList Arguments;
+		public readonly Expression RequestedType;
+
+		MethodBase method = null;
+
+		//
+		// If set, the new expression is for a value_target, and
+		// we will not leave anything on the stack.
+		//
+		Expression value_target;
+		bool value_target_set = false;
+		public bool isDelegate = false;
+		
+		public New (Expression requested_type, ArrayList arguments, Location l)
+		{
+			RequestedType = requested_type;
+			Arguments = arguments;
+			loc = l;
+		}
+
+		public Expression ValueTypeVariable {
+			get {
+				return value_target;
+			}
+
+			set {
+				value_target = value;
+				value_target_set = true;
+			}
+		}
+
+		//
+		// This function is used to disable the following code sequence for
+		// value type initialization:
+		//
+		// AddressOf (temporary)
+		// Construct/Init
+		// LoadTemporary
+		//
+		// Instead the provide will have provided us with the address on the
+		// stack to store the results.
+		//
+		static Expression MyEmptyExpression;
+		
+		public void DisableTemporaryValueType ()
+		{
+			if (MyEmptyExpression == null)
+				MyEmptyExpression = new EmptyAddressOf ();
+
+			//
+			// To enable this, look into:
+			// test-34 and test-89 and self bootstrapping.
+			//
+			// For instance, we can avoid a copy by using 'newobj'
+			// instead of Call + Push-temp on value types.
+//			value_target = MyEmptyExpression;
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (this.isDelegate) {
+				// if its a delegate resolve the type of RequestedType first
+				Expression dtype = RequestedType.Resolve(ec);
+				string ts = (dtype.Type.ToString()).Replace ('+','.');
+				dtype = Mono.MonoBASIC.Parser.DecomposeQI (ts, Location.Null);
+
+				type = ec.DeclSpace.ResolveType (dtype, false, loc);
+			}
+			else
+				type = ec.DeclSpace.ResolveType (RequestedType, false, loc);
+			
+			if (type == null)
+				return null;
+			
+			bool IsDelegate = TypeManager.IsDelegateType (type);
+			
+			if (IsDelegate)
+				return (new NewDelegate (type, Arguments, loc)).Resolve (ec);
+
+			if (type.IsInterface || type.IsAbstract){
+				Error (
+					30376, "It is not possible to create instances of Interfaces " +
+					"or classes marked as MustInherit");
+				return null;
+			}
+
+			bool is_struct = false;
+			is_struct = type.IsValueType;
+			eclass = ExprClass.Value;
+
+			//
+			// SRE returns a match for .ctor () on structs (the object constructor), 
+			// so we have to manually ignore it.
+			//
+			if (is_struct && Arguments == null)
+				return this;
+			
+			Expression ml;
+			ml = MemberLookupFinal (ec, type, ".ctor",
+						MemberTypes.Constructor,
+						AllBindingFlags | BindingFlags.Public, loc);
+
+			if (ml == null)
+				return null;
+			
+			if (! (ml is MethodGroupExpr)){
+				if (!is_struct){
+					ml.Error118 ("method group");
+					return null;
+				}
+			}
+
+			if (ml != null) {
+				if (Arguments != null){
+					foreach (Argument a in Arguments){
+						if (!a.Resolve (ec, loc))
+							return null;
+					}
+				}
+
+				method = Invocation.OverloadResolve (ec, (MethodGroupExpr) ml,
+								     Arguments, loc);
+				
+			}
+
+			if (method == null) { 
+                                if (!is_struct || Arguments.Count > 0) {
+        				Error (1501,
+	        			       "New invocation: Can not find a constructor for " +
+		        		       "this argument list");
+			        	return null;
+                                }
+			}
+			return this;
+		}
+
+		//
+		// This DoEmit can be invoked in two contexts:
+		//    * As a mechanism that will leave a value on the stack (new object)
+		//    * As one that wont (init struct)
+		//
+		// You can control whether a value is required on the stack by passing
+		// need_value_on_stack.  The code *might* leave a value on the stack
+		// so it must be popped manually
+		//
+		// If we are dealing with a ValueType, we have a few
+		// situations to deal with:
+		//
+		//    * The target is a ValueType, and we have been provided
+		//      the instance (this is easy, we are being assigned).
+		//
+		//    * The target of New is being passed as an argument,
+		//      to a boxing operation or a function that takes a
+		//      ValueType.
+		//
+		//      In this case, we need to create a temporary variable
+		//      that is the argument of New.
+		//
+		// Returns whether a value is left on the stack
+		//
+		bool DoEmit (EmitContext ec, bool need_value_on_stack)
+		{
+			bool is_value_type = type.IsValueType;
+			ILGenerator ig = ec.ig;
+
+			if (is_value_type){
+				IMemoryLocation ml;
+
+				// Allow DoEmit() to be called multiple times.
+				// We need to create a new LocalTemporary each time since
+				// you can't share LocalBuilders among ILGeneators.
+				if (!value_target_set)
+					value_target = new LocalTemporary (ec, type);
+					
+				ml = (IMemoryLocation) value_target;
+				ml.AddressOf (ec, AddressOp.Store);
+			}
+
+			if (method != null)
+				Invocation.EmitArguments (ec, method, Arguments);
+
+			if (is_value_type){
+				if (method == null)
+					ig.Emit (OpCodes.Initobj, type);
+				else 
+					ig.Emit (OpCodes.Call, (ConstructorInfo) method);
+                                if (need_value_on_stack){
+                                        value_target.Emit (ec);
+                                        return true;
+                                }
+                                return false;
+			} else {
+				ig.Emit (OpCodes.Newobj, (ConstructorInfo) method);
+				return true;
+			}
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			DoEmit (ec, true);
+		}
+		
+		public override void EmitStatement (EmitContext ec)
+		{
+			if (DoEmit (ec, false))
+				ec.ig.Emit (OpCodes.Pop);
+		}
+	}
+
+	/// <summary>
+	///   14.5.10.2: Represents an array creation expression.
+	/// </summary>
+	///
+	/// <remarks>
+	///   There are two possible scenarios here: one is an array creation
+	///   expression that specifies the dimensions and optionally the
+	///   initialization data and the other which does not need dimensions
+	///   specified but where initialization data is mandatory.
+	/// </remarks>
+	public class ArrayCreation : ExpressionStatement {
+		Expression requested_base_type;
+		ArrayList initializers;
+
+		//
+		// The list of Argument types.
+		// This is used to construct the 'newarray' or constructor signature
+		//
+		ArrayList arguments;
+
+		//
+		// Method used to create the array object.
+		//
+		MethodBase new_method = null;
+		
+		Type array_element_type;
+		Type underlying_type;
+		bool is_one_dimensional = false;
+		bool is_builtin_type = false;
+		bool expect_initializers = false;
+		int num_arguments = 0;
+		int dimensions = 0;
+		string rank;
+
+		ArrayList array_data;
+
+		Hashtable bounds;
+
+		//
+		// The number of array initializers that we can handle
+		// via the InitializeArray method - through EmitStaticInitializers
+		//
+		int num_automatic_initializers;
+		
+		public ArrayCreation (Expression requested_base_type, ArrayList exprs, string rank, ArrayList initializers, Location l)
+		{
+			this.requested_base_type = requested_base_type;
+			this.initializers = initializers;
+			this.rank = rank;
+			loc = l;
+
+			arguments = new ArrayList ();
+
+			foreach (Expression e in exprs) {
+				arguments.Add (new Argument (e, Argument.AType.Expression));
+				num_arguments++;
+			}
+		}
+
+		public ArrayCreation (Expression requested_base_type, string rank, ArrayList initializers, Location l)
+		{
+			this.requested_base_type = requested_base_type;
+			this.initializers = initializers;
+			this.rank = rank;
+			loc = l;
+
+			//this.rank = rank.Substring (0, rank.LastIndexOf ("["));
+			//
+			//string tmp = rank.Substring (rank.LastIndexOf ("["));
+			//
+			//dimensions = tmp.Length - 1;
+			expect_initializers = true;
+		}
+
+		public Expression FormArrayType (Expression base_type, int idx_count, string rank)
+		{
+			StringBuilder sb = new StringBuilder (rank);
+			
+			sb.Append ("[");
+			for (int i = 1; i < idx_count; i++)
+				sb.Append (",");
+			
+			sb.Append ("]");
+
+			return new ComposedCast (base_type, sb.ToString (), loc);
+		}
+
+		void Error_IncorrectArrayInitializer ()
+		{
+			Error (30567, "Incorrectly structured array initializer");
+		}
+		
+		public bool CheckIndices (EmitContext ec, ArrayList probe, int idx, bool specified_dims)
+		{
+			if (specified_dims) { 
+				Argument a = (Argument) arguments [idx];
+				
+				if (!a.Resolve (ec, loc))
+					return false;
+				
+				if (!(a.Expr is Constant)) {
+					Error (150, "A constant value is expected");
+					return false;
+				}
+				
+				int value = (int) ((Constant) a.Expr).GetValue ();
+				
+				if (value != probe.Count) {
+					Error_IncorrectArrayInitializer ();
+					return false;
+				}
+				
+				bounds [idx] = value;
+			}
+
+			int child_bounds = -1;
+			foreach (object o in probe) {
+				if (o is ArrayList) {
+					int current_bounds = ((ArrayList) o).Count;
+					
+					if (child_bounds == -1) 
+						child_bounds = current_bounds;
+
+					else if (child_bounds != current_bounds){
+						Error_IncorrectArrayInitializer ();
+						return false;
+					}
+					bool ret = CheckIndices (ec, (ArrayList) o, idx + 1, specified_dims);
+					if (!ret)
+						return false;
+				} else {
+					if (child_bounds != -1){
+						Error_IncorrectArrayInitializer ();
+						return false;
+					}
+					
+					Expression tmp = (Expression) o;
+					tmp = tmp.Resolve (ec);
+					if (tmp == null)
+						continue;
+
+					// Console.WriteLine ("I got: " + tmp);
+					// Handle initialization from vars, fields etc.
+
+					Expression conv = ConvertImplicitRequired (
+						ec, tmp, underlying_type, loc);
+					
+					if (conv == null) 
+						return false;
+
+					if (conv is StringConstant)
+						array_data.Add (conv);
+					else if (conv is Constant) {
+						array_data.Add (conv);
+						num_automatic_initializers++;
+					} else
+						array_data.Add (conv);
+				}
+			}
+
+			return true;
+		}
+		
+		public void UpdateIndices (EmitContext ec)
+		{
+			int i = 0;
+			for (ArrayList probe = initializers; probe != null;) {
+				if (probe.Count > 0 && probe [0] is ArrayList) {
+					Expression e = new IntConstant (probe.Count);
+					arguments.Add (new Argument (e, Argument.AType.Expression));
+
+					bounds [i++] =  probe.Count;
+					
+					probe = (ArrayList) probe [0];
+					
+				} else {
+					Expression e = new IntConstant (probe.Count);
+					arguments.Add (new Argument (e, Argument.AType.Expression));
+
+					bounds [i++] = probe.Count;
+					probe = null;
+				}
+			}
+
+		}
+		
+		public bool ValidateInitializers (EmitContext ec, Type array_type)
+		{
+			if (initializers == null) {
+				if (expect_initializers)
+					return false;
+				else
+					return true;
+			}
+			
+			if (underlying_type == null)
+				return false;
+			
+			//
+			// We use this to store all the date values in the order in which we
+			// will need to store them in the byte blob later
+			//
+			array_data = new ArrayList ();
+			bounds = new Hashtable ();
+			
+			bool ret;
+
+			if (arguments != null) {
+				ret = CheckIndices (ec, initializers, 0, true);
+				return ret;
+			} else {
+				arguments = new ArrayList ();
+
+				ret = CheckIndices (ec, initializers, 0, false);
+				
+				if (!ret)
+					return false;
+				
+				UpdateIndices (ec);
+				
+				if (arguments.Count != dimensions) {
+					Error_IncorrectArrayInitializer ();
+					return false;
+				}
+
+				return ret;
+			}
+		}
+
+/*
+		void Error_NegativeArrayIndex ()
+		{
+			Error (284, "Can not create array with a negative size");
+		}
+		
+		//
+		// Converts 'source' to an int, uint, long or ulong.
+		//
+		Expression ExpressionToArrayArgument (EmitContext ec, Expression source)
+		{
+			Expression target;
+			
+			bool old_checked = ec.CheckState;
+			ec.CheckState = true;
+			
+			target = ConvertImplicit (ec, source, TypeManager.int32_type, loc);
+			if (target == null){
+				target = ConvertImplicit (ec, source, TypeManager.uint32_type, loc);
+				if (target == null){
+					target = ConvertImplicit (ec, source, TypeManager.int64_type, loc);
+					if (target == null){
+						target = ConvertImplicit (ec, source, TypeManager.uint64_type, loc);
+						if (target == null)
+							Expression.Error_CannotConvertImplicit (loc, source.Type, TypeManager.int32_type);
+					}
+				}
+			} 
+			ec.CheckState = old_checked;
+
+			//
+			// Only positive constants are allowed at compile time
+			//
+			if (target is Constant){
+				if (target is IntConstant){
+					if (((IntConstant) target).Value < 0){
+						Error_NegativeArrayIndex ();
+						return null;
+					}
+				}
+
+				if (target is LongConstant){
+					if (((LongConstant) target).Value < 0){
+						Error_NegativeArrayIndex ();
+						return null;
+					}
+				}
+				
+			}
+
+			return target;
+		}
+*/
+
+		//
+		// Creates the type of the array
+		//
+		bool LookupType (EmitContext ec)
+		{
+			StringBuilder array_qualifier = new StringBuilder (rank);
+
+			//
+			// 'In the first form allocates an array instace of the type that results
+			// from deleting each of the individual expression from the expression list'
+			//
+			if (num_arguments > 0) {
+				array_qualifier.Append ("[");
+				for (int i = num_arguments-1; i > 0; i--)
+					array_qualifier.Append (",");
+				array_qualifier.Append ("]");				
+			}
+
+			//
+			// Lookup the type
+			//
+			Expression array_type_expr;
+			array_type_expr = new ComposedCast (requested_base_type, array_qualifier.ToString (), loc);
+			type = ec.DeclSpace.ResolveType (array_type_expr, false, loc);
+
+			if (type == null)
+				return false;
+
+			underlying_type = type;
+			if (underlying_type.IsArray)
+				underlying_type = TypeManager.TypeToCoreType (underlying_type.GetElementType ());
+			dimensions = type.GetArrayRank ();
+
+			return true;
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			int arg_count;
+
+			if (!LookupType (ec))
+				return null;
+			
+			//
+			// First step is to validate the initializers and fill
+			// in any missing bits
+			//
+			if (!ValidateInitializers (ec, type))
+				return null;
+
+			if (arguments == null)
+				arg_count = 0;
+			else {
+				arg_count = arguments.Count;
+				foreach (Argument a in arguments){
+					if (!a.Resolve (ec, loc))
+						return null;
+
+					Expression real_arg = ExpressionToArrayArgument (ec, a.Expr, loc);
+					if (real_arg == null)
+						return null;
+
+					a.Expr = real_arg;
+				}
+			}
+			
+			array_element_type = TypeManager.TypeToCoreType (type.GetElementType ());
+
+			if (arg_count == 1) {
+				is_one_dimensional = true;
+				eclass = ExprClass.Value;
+				return this;
+			}
+
+			is_builtin_type = TypeManager.IsBuiltinType (type);
+
+			if (is_builtin_type) {
+				Expression ml;
+				
+				ml = MemberLookup (ec, type, ".ctor", MemberTypes.Constructor,
+						   AllBindingFlags, loc);
+				
+				if (!(ml is MethodGroupExpr)) {
+					ml.Error118 ("method group");
+					return null;
+				}
+				
+				if (ml == null) {
+					Error (-6, "New invocation: Can not find a constructor for " +
+						      "this argument list");
+					return null;
+				}
+				
+				new_method = Invocation.OverloadResolve (ec, (MethodGroupExpr) ml, arguments, loc);
+
+				if (new_method == null) {
+					Error (-6, "New invocation: Can not find a constructor for " +
+						      "this argument list");
+					return null;
+				}
+				
+				eclass = ExprClass.Value;
+				return this;
+			} else {
+				ModuleBuilder mb = CodeGen.ModuleBuilder;
+				ArrayList args = new ArrayList ();
+				
+				if (arguments != null) {
+					for (int i = 0; i < arg_count; i++)
+						args.Add (TypeManager.int32_type);
+				}
+				
+				Type [] arg_types = null;
+
+				if (args.Count > 0)
+					arg_types = new Type [args.Count];
+				
+				args.CopyTo (arg_types, 0);
+				
+				new_method = mb.GetArrayMethod (type, ".ctor", CallingConventions.HasThis, null,
+							    arg_types);
+
+				if (new_method == null) {
+					Error (-6, "New invocation: Can not find a constructor for " +
+						      "this argument list");
+					return null;
+				}
+				
+				eclass = ExprClass.Value;
+				return this;
+			}
+		}
+
+		public static byte [] MakeByteBlob (ArrayList array_data, Type underlying_type, Location loc)
+		{
+			int factor;
+			byte [] data;
+			byte [] element;
+			int count = array_data.Count;
+
+			if (underlying_type.IsEnum)
+				underlying_type = TypeManager.EnumToUnderlying (underlying_type);
+			
+			factor = GetTypeSize (underlying_type);
+			if (factor == 0)
+				throw new Exception ("unrecognized type in MakeByteBlob: " + underlying_type);
+
+			data = new byte [(count * factor + 4) & ~3];
+			int idx = 0;
+			
+			for (int i = 0; i < count; ++i) {
+				object v = array_data [i];
+
+				if (v is EnumConstant)
+					v = ((EnumConstant) v).Child;
+				
+				if (v is Constant && !(v is StringConstant))
+					v = ((Constant) v).GetValue ();
+				else {
+					idx += factor;
+					continue;
+				}
+				
+				if (underlying_type == TypeManager.int64_type){
+					if (!(v is Expression)){
+						long val = (long) v;
+						
+						for (int j = 0; j < factor; ++j) {
+							data [idx + j] = (byte) (val & 0xFF);
+							val = (val >> 8);
+						}
+					}
+				} else if (underlying_type == TypeManager.uint64_type){
+					if (!(v is Expression)){
+						ulong val = (ulong) v;
+
+						for (int j = 0; j < factor; ++j) {
+							data [idx + j] = (byte) (val & 0xFF);
+							val = (val >> 8);
+						}
+					}
+				} else if (underlying_type == TypeManager.float_type) {
+					if (!(v is Expression)){
+						element = BitConverter.GetBytes ((float) v);
+							
+						for (int j = 0; j < factor; ++j)
+							data [idx + j] = element [j];
+					}
+				} else if (underlying_type == TypeManager.double_type) {
+					if (!(v is Expression)){
+						element = BitConverter.GetBytes ((double) v);
+
+						for (int j = 0; j < factor; ++j)
+							data [idx + j] = element [j];
+					}
+				} else if (underlying_type == TypeManager.char_type){
+					if (!(v is Expression)){
+						int val = (int) ((char) v);
+						
+						data [idx] = (byte) (val & 0xff);
+						data [idx+1] = (byte) (val >> 8);
+					}
+				} else if (underlying_type == TypeManager.short_type){
+					if (!(v is Expression)){
+						int val = (int) ((short) v);
+					
+						data [idx] = (byte) (val & 0xff);
+						data [idx+1] = (byte) (val >> 8);
+					}
+				} else if (underlying_type == TypeManager.ushort_type){
+					if (!(v is Expression)){
+						int val = (int) ((ushort) v);
+					
+						data [idx] = (byte) (val & 0xff);
+						data [idx+1] = (byte) (val >> 8);
+					}
+				} else if (underlying_type == TypeManager.int32_type) {
+					if (!(v is Expression)){
+						int val = (int) v;
+					
+						data [idx]   = (byte) (val & 0xff);
+						data [idx+1] = (byte) ((val >> 8) & 0xff);
+						data [idx+2] = (byte) ((val >> 16) & 0xff);
+						data [idx+3] = (byte) (val >> 24);
+					}
+				} else if (underlying_type == TypeManager.uint32_type) {
+					if (!(v is Expression)){
+						uint val = (uint) v;
+					
+						data [idx]   = (byte) (val & 0xff);
+						data [idx+1] = (byte) ((val >> 8) & 0xff);
+						data [idx+2] = (byte) ((val >> 16) & 0xff);
+						data [idx+3] = (byte) (val >> 24);
+					}
+				} else if (underlying_type == TypeManager.sbyte_type) {
+					if (!(v is Expression)){
+						sbyte val = (sbyte) v;
+						data [idx] = (byte) val;
+					}
+				} else if (underlying_type == TypeManager.byte_type) {
+					if (!(v is Expression)){
+						byte val = (byte) v;
+						data [idx] = (byte) val;
+					}
+				} else if (underlying_type == TypeManager.bool_type) {
+					if (!(v is Expression)){
+						bool val = (bool) v;
+						data [idx] = (byte) (val ? 1 : 0);
+					}
+				} else if (underlying_type == TypeManager.decimal_type){
+					if (!(v is Expression)){
+						int [] bits = Decimal.GetBits ((decimal) v);
+						int p = idx;
+						
+						for (int j = 0; j < 4; j++){
+							data [p++] = (byte) (bits [j] & 0xff);
+							data [p++] = (byte) ((bits [j] >> 8) & 0xff);
+							data [p++] = (byte) ((bits [j] >> 16) & 0xff);
+							data [p++] = (byte) (bits [j] >> 24);
+						}
+					}
+				} else
+					throw new Exception ("Unrecognized type in MakeByteBlob: " + underlying_type);
+
+                                idx += factor;
+			}
+
+			return data;
+		}
+
+		//
+		// Emits the initializers for the array
+		//
+		void EmitStaticInitializers (EmitContext ec, bool is_expression)
+		{
+			//
+			// First, the static data
+			//
+			FieldBuilder fb;
+			ILGenerator ig = ec.ig;
+			
+			byte [] data = MakeByteBlob (array_data, underlying_type, loc);
+
+			fb = RootContext.MakeStaticData (data);
+
+			if (is_expression)
+				ig.Emit (OpCodes.Dup);
+			ig.Emit (OpCodes.Ldtoken, fb);
+			ig.Emit (OpCodes.Call,
+				 TypeManager.void_initializearray_array_fieldhandle);
+		}
+		
+		//
+		// Emits pieces of the array that can not be computed at compile
+		// time (variables and string locations).
+		//
+		// This always expect the top value on the stack to be the array
+		//
+		void EmitDynamicInitializers (EmitContext ec, bool is_expression)
+		{
+			ILGenerator ig = ec.ig;
+			int dims = bounds.Count;
+			int [] current_pos = new int [dims];
+			int top = array_data.Count;
+			LocalBuilder temp = ig.DeclareLocal (type);
+
+			ig.Emit (OpCodes.Stloc, temp);
+
+			MethodInfo set = null;
+
+			if (dims != 1){
+				Type [] args;
+				ModuleBuilder mb = null;
+				mb = CodeGen.ModuleBuilder;
+				args = new Type [dims + 1];
+
+				int j;
+				for (j = 0; j < dims; j++)
+					args [j] = TypeManager.int32_type;
+
+				args [j] = array_element_type;
+				
+				set = mb.GetArrayMethod (
+					type, "Set",
+					CallingConventions.HasThis | CallingConventions.Standard,
+					TypeManager.void_type, args);
+			}
+			
+			for (int i = 0; i < top; i++){
+
+				Expression e = null;
+
+				if (array_data [i] is Expression)
+					e = (Expression) array_data [i];
+
+				if (e != null) {
+					//
+					// Basically we do this for string literals and
+					// other non-literal expressions
+					//
+					if (e is StringConstant || !(e is Constant) ||
+					    num_automatic_initializers <= 2) {
+						Type etype = e.Type;
+						
+						ig.Emit (OpCodes.Ldloc, temp);
+
+						for (int idx = 0; idx < dims; idx++) 
+							IntConstant.EmitInt (ig, current_pos [idx]);
+
+						//
+						// If we are dealing with a struct, get the
+						// address of it, so we can store it.
+						//
+						if ((dims == 1) &&
+						    etype.IsSubclassOf (TypeManager.value_type) &&
+						    (!TypeManager.IsBuiltinType (etype) ||
+						     etype == TypeManager.decimal_type)) {
+							if (e is New){
+								New n = (New) e;
+
+								//
+								// Let new know that we are providing
+								// the address where to store the results
+								//
+								n.DisableTemporaryValueType ();
+							}
+									     
+							ig.Emit (OpCodes.Ldelema, etype);
+						}
+
+						e.Emit (ec);
+						
+						if (dims == 1)
+							ArrayAccess.EmitStoreOpcode (ig, array_element_type);
+						else 
+							ig.Emit (OpCodes.Call, set);
+					}
+				}
+				
+				//
+				// Advance counter
+				//
+				for (int j = dims - 1; j >= 0; j--){
+					current_pos [j]++;
+					if (current_pos [j] < (int) bounds [j])
+						break;
+					current_pos [j] = 0;
+				}
+			}
+
+			if (is_expression)
+				ig.Emit (OpCodes.Ldloc, temp);
+		}
+
+		void EmitArrayArguments (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			
+			foreach (Argument a in arguments) {
+				Type atype = a.Type;
+				a.Emit (ec);
+
+				if (atype == TypeManager.uint64_type)
+					ig.Emit (OpCodes.Conv_Ovf_U4);
+				else if (atype == TypeManager.int64_type)
+					ig.Emit (OpCodes.Conv_Ovf_I4);
+			}
+		}
+		
+		void DoEmit (EmitContext ec, bool is_statement)
+		{
+			ILGenerator ig = ec.ig;
+			
+			EmitArrayArguments (ec);
+			if (is_one_dimensional)
+				ig.Emit (OpCodes.Newarr, array_element_type);
+			else {
+				if (is_builtin_type) 
+					ig.Emit (OpCodes.Newobj, (ConstructorInfo) new_method);
+				else 
+					ig.Emit (OpCodes.Newobj, (MethodInfo) new_method);
+			}
+			
+			if (initializers != null){
+				//
+				// FIXME: Set this variable correctly.
+				// 
+				bool dynamic_initializers = true;
+
+				if (underlying_type != TypeManager.string_type &&
+				    underlying_type != TypeManager.object_type) {
+					if (num_automatic_initializers > 2)
+						EmitStaticInitializers (ec, dynamic_initializers || !is_statement);
+				}
+				
+				if (dynamic_initializers)
+					EmitDynamicInitializers (ec, !is_statement);
+			}
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			DoEmit (ec, false);
+		}
+
+		public override void EmitStatement (EmitContext ec)
+		{
+			DoEmit (ec, true);
+		}
+		
+	}
+	
+	/// <summary>
+	///   Represents the 'this' construct
+	/// </summary>
+	public class This : Expression, IAssignMethod, IMemoryLocation, IVariable {
+
+		public enum TypeOfAccess : byte {
+			Me, MyClass
+		}
+
+		Block block;
+		VariableInfo vi;
+		TypeOfAccess access_type;
+		
+		public This (TypeOfAccess access_type, Block block, Location loc)
+		{
+			this.loc = loc;
+			this.block = block;
+			this.access_type = access_type;
+		}
+
+		public This (Block block, Location loc)
+		{
+			this.loc = loc;
+			this.block = block;
+			this.access_type = TypeOfAccess.Me;
+		}
+
+		public This (Location loc)
+		{
+			this.loc = loc;
+			this.access_type = TypeOfAccess.Me;
+		}
+
+		public TypeOfAccess AccessType { 
+			get { return access_type; }
+		}
+
+		public bool IsAssigned (EmitContext ec, Location loc)
+		{
+			if (vi == null)
+				return true;
+
+			return vi.IsAssigned (ec, loc);
+		}
+
+		public bool IsFieldAssigned (EmitContext ec, string field_name, Location loc)
+		{
+			if (vi == null)
+				return true;
+
+			return vi.IsFieldAssigned (ec, field_name, loc);
+		}
+
+		public void SetAssigned (EmitContext ec)
+		{
+			if (vi != null)
+				vi.SetAssigned (ec);
+		}
+
+		public void SetFieldAssigned (EmitContext ec, string field_name)
+		{	
+			if (vi != null)
+				vi.SetFieldAssigned (ec, field_name);
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			eclass = ExprClass.Variable;
+			type = ec.ContainerType;
+
+			if (ec.IsStatic){
+				Error (26, "Keyword this not valid in static code");
+				return null;
+			}
+
+			if (block != null)
+				vi = block.ThisVariable;
+
+			return this;
+		}
+
+		override public Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			DoResolve (ec);
+
+			VariableInfo vi = ec.CurrentBlock.ThisVariable;
+			if (vi != null)
+				vi.SetAssigned (ec);
+			
+			if (ec.TypeContainer is Class){
+				Error (1604, "Cannot assign to 'this'");
+				return null;
+			}
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			
+			ig.Emit (OpCodes.Ldarg_0);
+			if (ec.TypeContainer is Struct)
+				ig.Emit (OpCodes.Ldobj, type);
+		}
+
+		public void EmitAssign (EmitContext ec, Expression source)
+		{
+			ILGenerator ig = ec.ig;
+			
+			if (ec.TypeContainer is Struct){
+				ig.Emit (OpCodes.Ldarg_0);
+				source.Emit (ec);
+				ig.Emit (OpCodes.Stobj, type);
+			} else {
+				source.Emit (ec);
+				ig.Emit (OpCodes.Starg, 0);
+			}
+		}
+
+		public void AddressOf (EmitContext ec, AddressOp mode)
+		{
+			ec.ig.Emit (OpCodes.Ldarg_0);
+
+			// FIMXE
+			// FIGURE OUT WHY LDARG_S does not work
+			//
+			// consider: struct X { int val; int P { set { val = value; }}}
+			//
+			// Yes, this looks very bad. Look at 'NOTAS' for
+			// an explanation.
+			// ec.ig.Emit (OpCodes.Ldarga_S, (byte) 0);
+		}
+	}
+
+	/// <summary>
+	///   Implements the typeof operator
+	/// </summary>
+	public class TypeOf : Expression {
+		public readonly Expression QueriedType;
+		Type typearg;
+		
+		public TypeOf (Expression queried_type, Location l)
+		{
+			QueriedType = queried_type;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			typearg = ec.DeclSpace.ResolveType (QueriedType, false, loc);
+
+			if (typearg == null)
+				return null;
+
+			type = TypeManager.type_type;
+			eclass = ExprClass.Type;
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ec.ig.Emit (OpCodes.Ldtoken, typearg);
+			ec.ig.Emit (OpCodes.Call, TypeManager.system_type_get_type_from_handle);
+		}
+
+		public Type TypeArg { 
+			get { return typearg; }
+		}
+	}
+
+	/// <summary>
+	///   Implements the sizeof expression
+	/// </summary>
+	public class SizeOf : Expression {
+		public readonly Expression QueriedType;
+		Type type_queried;
+		
+		public SizeOf (Expression queried_type, Location l)
+		{
+			this.QueriedType = queried_type;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (!ec.InUnsafe) {
+				Error (233, "Sizeof may only be used in an unsafe context " +
+				       "(consider using System.Runtime.InteropServices.Marshal.SizeOf");
+				return null;
+			}
+				
+			type_queried = ec.DeclSpace.ResolveType (QueriedType, false, loc);
+			if (type_queried == null)
+				return null;
+
+			if (!TypeManager.IsUnmanagedType (type_queried)){
+				Report.Error (208, "Cannot take the size of an unmanaged type (" + TypeManager.MonoBASIC_Name (type_queried) + ")");
+				return null;
+			}
+			
+			type = TypeManager.int32_type;
+			eclass = ExprClass.Value;
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			int size = GetTypeSize (type_queried);
+
+			if (size == 0)
+				ec.ig.Emit (OpCodes.Sizeof, type_queried);
+			else
+				IntConstant.EmitInt (ec.ig, size);
+		}
+	}
+
+	/// <summary>
+	///   Implements the member access expression
+	/// </summary>
+	public class MemberAccess : Expression, ITypeExpression {
+		public readonly string Identifier;
+		Expression expr;
+		Expression member_lookup;
+		bool is_invocation = false;
+		bool is_left_hand;
+		bool is_addressof = false;
+		
+		public MemberAccess (Expression expr, string id, Location l)
+		{
+			this.expr = expr;
+			Identifier = id;
+			loc = l;
+		}
+
+		public MemberAccess (Expression expr, string id, Location l, bool isInvocation)
+		{
+			this.expr = expr;
+			Identifier = id;
+			loc = l;
+			is_invocation = isInvocation;
+		}
+
+		public bool IsInvocation {
+			get {
+				return is_invocation;
+			}
+			set {
+				is_invocation = value;
+			}
+		}
+
+		public bool IsAddressOf {
+			set {
+				is_addressof = value;
+			}
+		}
+
+		public bool IsLeftHand {
+			get {
+				return is_left_hand;
+			}
+			set {
+				is_left_hand = value;
+			}
+		}
+
+		public Expression Expr {
+			get {
+				return expr;
+			}
+		}
+
+		static void error176 (Location loc, string name)
+		{
+			Report.Error (176, loc, "Static member '" +
+				      name + "' cannot be accessed " +
+				      "with an instance reference, qualify with a " +
+				      "type name instead");
+		}
+
+		static bool IdenticalNameAndTypeName (EmitContext ec, Expression left_original, Location loc)
+		{
+			if (left_original == null)
+				return false;
+
+			if (!(left_original is SimpleName))
+				return false;
+
+			SimpleName sn = (SimpleName) left_original;
+
+			Type t = RootContext.LookupType (ec.DeclSpace, sn.Name, true, loc);
+			if (t != null)
+				return true;
+
+			return false;
+		}
+		
+		public static Expression ResolveMemberAccess (EmitContext ec, Expression member_lookup,
+							      Expression left, Location loc,
+							      Expression left_original)
+		{
+			 bool left_is_type, left_is_explicit;
+			
+
+			// If 'left' is null, then we're called from SimpleNameResolve and this is
+			// a member in the currently defining class.
+			if (left == null) {
+				left_is_type = ec.IsStatic || ec.IsFieldInitializer;
+				left_is_explicit = false;
+
+				// Implicitly default to 'this' unless we're static.
+				if (!ec.IsStatic && !ec.IsFieldInitializer && !ec.InEnumContext)
+					left = ec.This;
+			} else {
+				left_is_type = left is TypeExpr;
+				left_is_explicit = true;
+			}
+
+			if (member_lookup is FieldExpr){
+				FieldExpr fe = (FieldExpr) member_lookup;
+				FieldInfo fi = fe.FieldInfo;
+				Type decl_type = fi.DeclaringType;
+				
+				if (fi is FieldBuilder) {
+					Const c = TypeManager.LookupConstant ((FieldBuilder) fi);
+					if (c != null) {
+                                        object o;
+                                        if (!c.LookupConstantValue (out o, ec))
+                                                return null;
+					
+						object real_value = ((Constant) c.Expr).GetValue ();
+                                         Expression exp = Constantify (real_value, fi.FieldType);
+
+                                        return exp;
+                                	}
+				}
+				
+				  // IsInitOnly is because of MS compatibility, I don't know why but they emit decimal constant as InitOnly
+                        
+			if (fi.IsInitOnly && !(fi is FieldBuilder) && fi.FieldType == TypeManager.decimal_type) {
+                                object[] attrs = fi.GetCustomAttributes (TypeManager.decimal_constant_attribute_type, false);
+                                if (attrs.Length == 1)
+                                        return new DecimalConstant (((System.Runtime.CompilerServices.DecimalConstantAttribute) attrs [0]).Value);
+                        }
+
+
+
+				if (fi.IsLiteral) {
+					Type t = fi.FieldType;
+					
+					object o;
+
+					if (fi is FieldBuilder)
+						o = TypeManager.GetValue ((FieldBuilder) fi);
+					else
+						o = fi.GetValue (fi);
+					
+					if (decl_type.IsSubclassOf (TypeManager.enum_type)) {
+						if (left_is_explicit && !left_is_type &&
+						    !IdenticalNameAndTypeName (ec, left_original, loc)) {
+							error176 (loc, fe.FieldInfo.Name);
+							return null;
+						}					
+						
+						Expression enum_member = MemberLookup (
+							ec, decl_type, "value__", MemberTypes.Field,
+							AllBindingFlags, loc); 
+
+						Enum en = TypeManager.LookupEnum (decl_type);
+
+						Constant c;
+						if (en != null)
+							c = Constantify (o, en.UnderlyingType);
+						else
+							c = Constantify (o, enum_member.Type);
+
+						return new EnumConstant (c, decl_type);
+					}
+					
+					Expression exp = Constantify (o, t);
+
+					if (left_is_explicit && !left_is_type) {
+						error176 (loc, fe.FieldInfo.Name);
+						return null;
+					}
+					
+					return exp;
+				}
+
+				if (fi.FieldType.IsPointer && !ec.InUnsafe){
+					UnsafeError (loc);
+					return null;
+				}
+			}
+
+			
+			if (member_lookup is IMemberExpr) {
+				IMemberExpr me = (IMemberExpr) member_lookup;
+
+				if (left_is_type) {
+					if (me is PropertyGroupExpr) {
+						PropertyGroupExpr mg = me as PropertyGroupExpr;
+						if ((mg != null) && left_is_explicit && left.Type.IsInterface)
+							mg.IsExplicitImpl = left_is_explicit;
+	
+						if (!me.IsStatic){
+							if (IdenticalNameAndTypeName (ec, left_original, loc))
+								return member_lookup;
+	
+							SimpleName.Error_ObjectRefRequired (ec, loc, me.Name);
+							return null;
+						}
+					} else {
+						MethodGroupExpr mg = me as MethodGroupExpr;
+						if ((mg != null) && left_is_explicit && left.Type.IsInterface)
+							mg.IsExplicitImpl = left_is_explicit;
+	
+						if (!me.IsStatic){
+							if (IdenticalNameAndTypeName (ec, left_original, loc))
+								return member_lookup;
+	
+						//	SimpleName.Error_ObjectRefRequired (ec, loc, me.Name);
+							return null;
+						}
+					}
+
+				} else {
+					if (!me.IsInstance){
+						if (IdenticalNameAndTypeName (ec, left_original, loc))
+							return member_lookup;
+
+						/*if (left_is_explicit) {
+							error176 (loc, me.Name);
+							return null;
+						}*/
+					}
+
+					//
+					// Since we can not check for instance objects in SimpleName,
+					// becaue of the rule that allows types and variables to share
+					// the name (as long as they can be de-ambiguated later, see 
+					// IdenticalNameAndTypeName), we have to check whether left 
+					// is an instance variable in a static context
+					//
+					// However, if the left-hand value is explicitly given, then
+					// it is already our instance expression, so we aren't in
+					// static context.
+					//
+
+					if (ec.IsStatic && !left_is_explicit && left is IMemberExpr){
+						IMemberExpr mexp = (IMemberExpr) left;
+
+						if (!mexp.IsStatic){
+							SimpleName.Error_ObjectRefRequired (ec, loc, mexp.Name);
+							return null;
+						}
+					}
+
+					me.InstanceExpression = left;
+				}
+
+				return member_lookup;
+			}
+
+			if (member_lookup is TypeExpr){
+				member_lookup.Resolve (ec, ResolveFlags.Type);
+				return member_lookup;
+			}
+			
+			Console.WriteLine ("Left is: " + left);
+			Report.Error (-100, loc, "Support for [" + member_lookup + "] is not present yet");
+			Environment.Exit (0);
+			return null;
+		}
+		
+		public Expression DoResolve (EmitContext ec, Expression right_side, ResolveFlags flags)
+		{
+			if (type != null)
+				throw new Exception ();
+			//
+			// Resolve the expression with flow analysis turned off, we'll do the definite
+			// assignment checks later.  This is because we don't know yet what the expression
+			// will resolve to - it may resolve to a FieldExpr and in this case we must do the
+			// definite assignment check on the actual field and not on the whole struct.
+			//
+
+			Expression original = expr;
+			expr = expr.Resolve (ec, flags | ResolveFlags.DisableFlowAnalysis);
+			
+			if (expr == null)
+				return null;
+
+			if (expr is SimpleName){
+				SimpleName child_expr = (SimpleName) expr;
+
+				Expression new_expr = new SimpleName (child_expr.Name + "." + Identifier, loc);
+				((SimpleName) new_expr).IsInvocation = is_invocation;
+
+				if ((flags & ResolveFlags.MaskExprClass) == ResolveFlags.Type)
+					return new_expr.Resolve (ec, flags);
+				else
+					return new_expr.Resolve (ec, flags | ResolveFlags.MethodGroup | ResolveFlags.VariableOrValue);
+			}
+					
+			int errors = Report.Errors;
+			
+			Type expr_type = expr.Type;
+
+			if (expr is TypeExpr){
+				//FIXME: add access level check
+				//if (!ec.DeclSpace.CheckAccessLevel (expr_type)) {
+				//		Error (30390, "'" + TypeManager.MonoBASIC_Name (expr_type) + "' " +
+				//		       "is inaccessible because of its protection level");
+				//	return null;
+				//}
+
+				if (expr_type == TypeManager.enum_type || expr_type.IsSubclassOf (TypeManager.enum_type)){
+					Enum en = TypeManager.LookupEnum (expr_type);
+
+					if (en != null) {
+						object value = en.LookupEnumValue (Identifier);
+						
+						if (value != null){
+							Constant c = Constantify (value, en.UnderlyingType);
+							return new EnumConstant (c, expr_type);
+						} else {
+							Report.Error (30456, loc,
+								Identifier + " is not found in member list of enum " + en.Name);
+						}
+					}
+				}
+			}
+			
+			if (expr_type.IsPointer){
+				Error (30311, "The '.' operator can not be applied to pointer operands (" +
+				       TypeManager.MonoBASIC_Name (expr_type) + ")");
+				return null;
+			}
+
+			member_lookup = MemberLookup (ec, expr_type, Identifier, loc);
+			if (member_lookup == null)
+			{
+				// Error has already been reported.
+				if (errors < Report.Errors)
+					return null;
+				
+				//
+				// Try looking the member up from the same type, if we find
+				// it, we know that the error was due to limited visibility
+				//
+				object lookup = TypeManager.MemberLookup (
+					expr_type, expr_type, AllMemberTypes, AllBindingFlags |
+					BindingFlags.NonPublic, Identifier);
+					
+				if (lookup == null) {
+					if (expr_type != TypeManager.object_type)
+						Error (30456, "'" + expr_type + "' does not contain a definition for '" + Identifier + "'");
+					// If this came as a part of Invocation, 
+					// Since argumets are not known, return null, 
+					// let Invocation's Resolve take care
+					if (is_invocation)
+						return null;
+
+					else if (! is_left_hand) {
+						StatementSequence etmp = new StatementSequence (ec.CurrentBlock, 
+										loc, this, null, 
+										true, is_left_hand);
+						etmp.GenerateLateBindingStatements();
+						return etmp.Resolve (ec);
+					} 
+
+					// if the expression is a left hand side of an assignment,
+					// return null, as we dont know the RHS
+					// Let assign take care of Late Binding
+					return null;
+				}
+				else
+				{
+					if ((expr_type != ec.ContainerType) &&
+						 ec.ContainerType.IsSubclassOf (expr_type))
+					{
+
+						// Although a derived class can access protected members of
+						// its base class it cannot do so through an instance of the
+						// base class (CS1540).  If the expr_type is a parent of the
+						// ec.ContainerType and the lookup succeeds with the latter one,
+						// then we are in this situation.
+
+						lookup = TypeManager.MemberLookup(
+									ec.ContainerType, ec.ContainerType, AllMemberTypes, 
+									AllBindingFlags, Identifier);
+
+						if (lookup != null)
+							Error (1540, "Cannot access protected member '" +
+						       expr_type + "." + Identifier + "' " +
+						       "via a qualifier of type '" + TypeManager.MonoBASIC_Name (expr_type) + "'; the " +
+						       "qualifier must be of type '" + TypeManager.MonoBASIC_Name (ec.ContainerType) + "' " +
+						       "(or derived from it)");
+						else
+							Error (30390, "'" + expr_type + "." + Identifier + "' " +
+						       "is inaccessible because of its protection level");
+					} else
+						Error (30390, "'" + expr_type + "." + Identifier + "' " +
+					       "is inaccessible because of its protection level");
+				}  
+				return null;
+			}
+
+			if ((expr is TypeExpr) && (expr_type.IsSubclassOf (TypeManager.enum_type)))	{
+				Enum en = TypeManager.LookupEnum (expr_type);
+				
+				if (en != null) {
+					object value = en.LookupEnumValue (Identifier);
+					expr_type = TypeManager.int32_type;
+					if (value != null) {
+						Constant c = Constantify (value, en.UnderlyingType);
+						return new EnumConstant (c, en.UnderlyingType);
+					} else {
+						Report.Error (30456, loc,
+							Identifier + " is not found in member list of enum " + en.Name);
+					}
+				}
+			}
+
+			if (member_lookup is TypeExpr){
+				member_lookup.Resolve (ec, ResolveFlags.Type);
+
+				return member_lookup;
+			} else if ((flags & ResolveFlags.MaskExprClass) == ResolveFlags.Type)
+				return null;
+			
+			member_lookup = ResolveMemberAccess (ec, member_lookup, expr, loc, original);
+			if (member_lookup == null)
+				return null;
+
+			if ((member_lookup is MethodGroupExpr) && ! is_invocation && !is_addressof) {
+				Expression inv = new Invocation (this, new ArrayList (), loc);
+				return inv.Resolve (ec);
+			}
+
+			if (member_lookup is PropertyGroupExpr && is_invocation) // As we dont know the arguments yet
+				return member_lookup;
+
+			// The following DoResolve/DoResolveLValue will do the definite assignment
+			// check.
+			if (right_side != null)
+				member_lookup = member_lookup.DoResolveLValue (ec, right_side);
+			else
+				member_lookup = member_lookup.DoResolve (ec);
+
+
+			return member_lookup;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			return DoResolve (ec, null, ResolveFlags.VariableOrValue |
+					  ResolveFlags.SimpleName | ResolveFlags.Type);
+		}
+
+		public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			return DoResolve (ec, right_side, ResolveFlags.VariableOrValue |
+					  ResolveFlags.SimpleName | ResolveFlags.Type);
+		}
+
+		public Expression DoResolveType (EmitContext ec)
+		{
+			return DoResolve (ec, null, ResolveFlags.Type);
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			throw new Exception ("Should not happen");
+		}
+
+		public override string ToString ()
+		{
+			return expr + "." + Identifier;
+		}
+	}
+
+	
+	
+	/// <summary>
+	///   Implements checked expressions
+	/// </summary>
+	public class CheckedExpr : Expression {
+
+		public Expression Expr;
+
+		public CheckedExpr (Expression e, Location l)
+		{
+			Expr = e;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			bool last_const_check = ec.ConstantCheckState;
+
+			ec.ConstantCheckState = true;
+			Expr = Expr.Resolve (ec);
+			ec.ConstantCheckState = last_const_check;
+			
+			if (Expr == null)
+				return null;
+
+			if (Expr is Constant)
+				return Expr;
+			
+			eclass = Expr.eclass;
+			type = Expr.Type;
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			bool last_check = ec.CheckState;
+			bool last_const_check = ec.ConstantCheckState;
+			
+			ec.CheckState = true;
+			ec.ConstantCheckState = true;
+			Expr.Emit (ec);
+			ec.CheckState = last_check;
+			ec.ConstantCheckState = last_const_check;
+		}
+		
+	}
+
+	/// <summary>
+	///   Implements the unchecked expression
+	/// </summary>
+	public class UnCheckedExpr : Expression {
+
+		public Expression Expr;
+
+		public UnCheckedExpr (Expression e, Location l)
+		{
+			Expr = e;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			bool last_const_check = ec.ConstantCheckState;
+
+			ec.ConstantCheckState = false;
+			Expr = Expr.Resolve (ec);
+			ec.ConstantCheckState = last_const_check;
+
+			if (Expr == null)
+				return null;
+
+			if (Expr is Constant)
+				return Expr;
+			
+			eclass = Expr.eclass;
+			type = Expr.Type;
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			bool last_check = ec.CheckState;
+			bool last_const_check = ec.ConstantCheckState;
+			
+			ec.CheckState = false;
+			ec.ConstantCheckState = false;
+			Expr.Emit (ec);
+			ec.CheckState = last_check;
+			ec.ConstantCheckState = last_const_check;
+		}
+		
+	}
+
+	/// <summary>
+	///   An Element Access expression.
+	///
+	///   During semantic analysis these are transformed into 
+	///   IndexerAccess or ArrayAccess 
+	/// </summary>
+	public class ElementAccess : Expression {
+		public ArrayList  Arguments;
+		public Expression Expr;
+		
+		public ElementAccess (Expression e, ArrayList e_list, Location l)
+		{
+			Expr = e;
+
+			loc  = l;
+			
+			if (e_list == null)
+				return;
+			
+			Arguments = new ArrayList ();
+			foreach (Expression tmp in e_list)
+				Arguments.Add (new Argument (tmp, Argument.AType.Expression));
+			
+		}
+
+		bool CommonResolve (EmitContext ec)
+		{
+			Expr = Expr.Resolve (ec);
+
+			if (Expr == null) 
+				return false;
+
+			if (Arguments == null)
+				return false;
+
+			foreach (Argument a in Arguments){
+				if (!a.Resolve (ec, loc))
+					return false;
+			}
+
+			return true;
+		}
+
+		Expression MakePointerAccess ()
+		{
+			Type t = Expr.Type;
+
+			if (t == TypeManager.void_ptr_type){
+				Error (
+					242,
+					"The array index operation is not valid for void pointers");
+				return null;
+			}
+			if (Arguments.Count != 1){
+				Error (
+					196,
+					"A pointer must be indexed by a single value");
+				return null;
+			}
+			Expression p = new PointerArithmetic (true, Expr, ((Argument)Arguments [0]).Expr,
+							      t, loc);
+			return new Indirection (p, loc);
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (!CommonResolve (ec))
+				return null;
+
+			//
+			// We perform some simple tests, and then to "split" the emit and store
+			// code we create an instance of a different class, and return that.
+			//
+			// I am experimenting with this pattern.
+			//
+			Type t = Expr.Type;
+
+			if (t.IsArray)
+				return (new ArrayAccess (this, loc)).Resolve (ec);
+			else if (t.IsPointer)
+				return MakePointerAccess ();
+			else
+				return (new IndexerAccess (this, loc)).Resolve (ec);
+		}
+
+		public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			if (!CommonResolve (ec))
+				return null;
+
+			Type t = Expr.Type;
+			if (t.IsArray)
+				return (new ArrayAccess (this, loc)).ResolveLValue (ec, right_side);
+			else if (t.IsPointer)
+				return MakePointerAccess ();
+			else
+				return (new IndexerAccess (this, loc)).ResolveLValue (ec, right_side);
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			throw new Exception ("Should never be reached");
+		}
+	}
+
+	/// <summary>
+	///   Implements array access 
+	/// </summary>
+	public class ArrayAccess : Expression, IAssignMethod, IMemoryLocation {
+		//
+		// Points to our "data" repository
+		//
+		ElementAccess ea;
+
+		LocalTemporary [] cached_locations;
+
+		public ArrayAccess (ElementAccess ea_data, Location l)
+		{
+			ea = ea_data;
+			eclass = ExprClass.Variable;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			//ExprClass eclass = ea.Expr.eclass;
+
+#if false
+			// As long as the type is valid
+			if (!(eclass == ExprClass.Variable || eclass == ExprClass.PropertyAccess ||
+			      eclass == ExprClass.Value)) {
+				ea.Expr.Error118 ("variable or value");
+				return null;
+			}
+#endif
+
+			Type t = ea.Expr.Type;
+/*
+			if (t == typeof (System.Object))
+			{
+				// We can't resolve now, but we
+				// have to try to access the array with a call
+				// to LateIndexGet in the runtime
+
+				Expression lig_call_expr = Mono.MonoBASIC.Parser.DecomposeQI("Microsoft.VisualBasic.CompilerServices.LateBinding.LateIndexGet", Location.Null);
+				Expression obj_type = Mono.MonoBASIC.Parser.DecomposeQI("System.Object", Location.Null);
+				ArrayList adims = new ArrayList();
+
+				ArrayList ainit = new ArrayList();
+				foreach (Argument a in ea.Arguments)
+					ainit.Add ((Expression) a.Expr);
+
+				adims.Add ((Expression) new IntLiteral (ea.Arguments.Count));
+
+				Expression oace = new ArrayCreation (obj_type, adims, "", ainit, Location.Null);
+
+				ArrayList args = new ArrayList();
+				args.Add (new Argument(ea.Expr, Argument.AType.Expression));
+				args.Add (new Argument(oace, Argument.AType.Expression));
+				args.Add (new Argument(NullLiteral.Null, Argument.AType.Expression));
+
+				Expression lig_call = new Invocation (lig_call_expr, args, Location.Null);
+				lig_call = lig_call.Resolve(ec);
+				return lig_call;
+			}
+*/
+			if (t.GetArrayRank () != ea.Arguments.Count){
+				ea.Error (22,
+					  "Incorrect number of indexes for array " +
+					  " expected: " + t.GetArrayRank () + " got: " +
+					  ea.Arguments.Count);
+				return null;
+			}
+			type = TypeManager.TypeToCoreType (t.GetElementType ());
+			if (type.IsPointer && !ec.InUnsafe){
+				UnsafeError (ea.Location);
+				return null;
+			}
+
+			foreach (Argument a in ea.Arguments){
+				Type argtype = a.Type;
+
+				if (argtype == TypeManager.int32_type ||
+				    argtype == TypeManager.uint32_type ||
+				    argtype == TypeManager.int64_type ||
+				    argtype == TypeManager.uint64_type)
+					continue;
+
+				//
+				// Mhm.  This is strage, because the Argument.Type is not the same as
+				// Argument.Expr.Type: the value changes depending on the ref/out setting.
+				//
+				// Wonder if I will run into trouble for this.
+				//
+				a.Expr = ExpressionToArrayArgument (ec, a.Expr, ea.Location);
+				if (a.Expr == null)
+					return null;
+			}
+			
+			eclass = ExprClass.Variable;
+
+			return this;
+		}
+
+		/// <summary>
+		///    Emits the right opcode to load an object of Type 't'
+		///    from an array of T
+		/// </summary>
+		static public void EmitLoadOpcode (ILGenerator ig, Type type)
+		{
+			if (type == TypeManager.byte_type || type == TypeManager.bool_type)
+				ig.Emit (OpCodes.Ldelem_U1);
+			else if (type == TypeManager.sbyte_type)
+				ig.Emit (OpCodes.Ldelem_I1);
+			else if (type == TypeManager.short_type)
+				ig.Emit (OpCodes.Ldelem_I2);
+			else if (type == TypeManager.ushort_type || type == TypeManager.char_type)
+				ig.Emit (OpCodes.Ldelem_U2);
+			else if (type == TypeManager.int32_type)
+				ig.Emit (OpCodes.Ldelem_I4);
+			else if (type == TypeManager.uint32_type)
+				ig.Emit (OpCodes.Ldelem_U4);
+			else if (type == TypeManager.uint64_type)
+				ig.Emit (OpCodes.Ldelem_I8);
+			else if (type == TypeManager.int64_type)
+				ig.Emit (OpCodes.Ldelem_I8);
+			else if (type == TypeManager.float_type)
+				ig.Emit (OpCodes.Ldelem_R4);
+			else if (type == TypeManager.double_type)
+				ig.Emit (OpCodes.Ldelem_R8);
+			else if (type == TypeManager.intptr_type)
+				ig.Emit (OpCodes.Ldelem_I);
+			else if (type.IsValueType){
+				ig.Emit (OpCodes.Ldelema, type);
+				ig.Emit (OpCodes.Ldobj, type);
+			} else 
+				ig.Emit (OpCodes.Ldelem_Ref);
+		}
+
+		/// <summary>
+		///    Emits the right opcode to store an object of Type 't'
+		///    from an array of T.  
+		/// </summary>
+		static public void EmitStoreOpcode (ILGenerator ig, Type t)
+		{
+			t = TypeManager.TypeToCoreType (t);
+			if (TypeManager.IsEnumType (t) && t != TypeManager.enum_type)
+				t = TypeManager.EnumToUnderlying (t);
+			if (t == TypeManager.byte_type || t == TypeManager.sbyte_type ||
+			    t == TypeManager.bool_type)
+				ig.Emit (OpCodes.Stelem_I1);
+			else if (t == TypeManager.short_type || t == TypeManager.ushort_type || t == TypeManager.char_type)
+				ig.Emit (OpCodes.Stelem_I2);
+			else if (t == TypeManager.int32_type || t == TypeManager.uint32_type)
+				ig.Emit (OpCodes.Stelem_I4);
+			else if (t == TypeManager.int64_type || t == TypeManager.uint64_type)
+				ig.Emit (OpCodes.Stelem_I8);
+			else if (t == TypeManager.float_type)
+				ig.Emit (OpCodes.Stelem_R4);
+			else if (t == TypeManager.double_type)
+				ig.Emit (OpCodes.Stelem_R8);
+			else if (t == TypeManager.intptr_type)
+				ig.Emit (OpCodes.Stelem_I);
+			else if (t.IsValueType){
+				ig.Emit (OpCodes.Stobj, t);
+			} else
+				ig.Emit (OpCodes.Stelem_Ref);
+		}
+
+		MethodInfo FetchGetMethod ()
+		{
+			ModuleBuilder mb = CodeGen.ModuleBuilder;
+			int arg_count = ea.Arguments.Count;
+			Type [] args = new Type [arg_count];
+			MethodInfo get;
+			
+			for (int i = 0; i < arg_count; i++){
+				//args [i++] = a.Type;
+				args [i] = TypeManager.int32_type;
+			}
+			
+			get = mb.GetArrayMethod (
+				ea.Expr.Type, "Get",
+				CallingConventions.HasThis |
+				CallingConventions.Standard,
+				type, args);
+			return get;
+		}
+				
+
+		MethodInfo FetchAddressMethod ()
+		{
+			ModuleBuilder mb = CodeGen.ModuleBuilder;
+			int arg_count = ea.Arguments.Count;
+			Type [] args = new Type [arg_count];
+			MethodInfo address;
+			string ptr_type_name;
+			Type ret_type;
+			
+			ptr_type_name = type.FullName + "&";
+			ret_type = Type.GetType (ptr_type_name);
+			
+			//
+			// It is a type defined by the source code we are compiling
+			//
+			if (ret_type == null){
+				ret_type = mb.GetType (ptr_type_name);
+			}
+
+			for (int i = 0; i < arg_count; i++){
+				//args [i++] = a.Type;
+				args [i] = TypeManager.int32_type;
+			}
+			
+			address = mb.GetArrayMethod (
+				ea.Expr.Type, "Address",
+				CallingConventions.HasThis |
+				CallingConventions.Standard,
+				ret_type, args);
+
+			return address;
+		}
+
+		//
+		// Load the array arguments into the stack.
+		//
+		// If we have been requested to cache the values (cached_locations array
+		// initialized), then load the arguments the first time and store them
+		// in locals.  otherwise load from local variables.
+		//
+		void LoadArrayAndArguments (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			
+			if (cached_locations == null){
+				ea.Expr.Emit (ec);
+				foreach (Argument a in ea.Arguments){
+					Type argtype = a.Expr.Type;
+					
+					a.Expr.Emit (ec);
+					
+					if (argtype == TypeManager.int64_type)
+						ig.Emit (OpCodes.Conv_Ovf_I);
+					else if (argtype == TypeManager.uint64_type)
+						ig.Emit (OpCodes.Conv_Ovf_I_Un);
+				}
+				return;
+			}
+
+			if (cached_locations [0] == null){
+				cached_locations [0] = new LocalTemporary (ec, ea.Expr.Type);
+				ea.Expr.Emit (ec);
+				ig.Emit (OpCodes.Dup);
+				cached_locations [0].Store (ec);
+				
+				int j = 1;
+				
+				foreach (Argument a in ea.Arguments){
+					Type argtype = a.Expr.Type;
+					
+					cached_locations [j] = new LocalTemporary (ec, TypeManager.intptr_type /* a.Expr.Type */);
+					a.Expr.Emit (ec);
+					if (argtype == TypeManager.int64_type)
+						ig.Emit (OpCodes.Conv_Ovf_I);
+					else if (argtype == TypeManager.uint64_type)
+						ig.Emit (OpCodes.Conv_Ovf_I_Un);
+
+					ig.Emit (OpCodes.Dup);
+					cached_locations [j].Store (ec);
+					j++;
+				}
+				return;
+			}
+
+			foreach (LocalTemporary lt in cached_locations)
+				lt.Emit (ec);
+		}
+
+		public new void CacheTemporaries (EmitContext ec)
+		{
+			cached_locations = new LocalTemporary [ea.Arguments.Count + 1];
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			int rank = ea.Expr.Type.GetArrayRank ();
+			ILGenerator ig = ec.ig;
+
+			LoadArrayAndArguments (ec);
+			
+			if (rank == 1)
+				EmitLoadOpcode (ig, type);
+			else {
+				MethodInfo method;
+				
+				method = FetchGetMethod ();
+				ig.Emit (OpCodes.Call, method);
+			}
+		}
+
+		public void EmitAssign (EmitContext ec, Expression source)
+		{
+			int rank = ea.Expr.Type.GetArrayRank ();
+			ILGenerator ig = ec.ig;
+			Type t = source.Type;
+
+			LoadArrayAndArguments (ec);
+
+			//
+			// The stobj opcode used by value types will need
+			// an address on the stack, not really an array/array
+			// pair
+			//
+			if (rank == 1){
+				if (t == TypeManager.enum_type || t == TypeManager.decimal_type ||
+				    (t.IsSubclassOf (TypeManager.value_type) && !TypeManager.IsEnumType (t) && !TypeManager.IsBuiltinType (t)))
+					ig.Emit (OpCodes.Ldelema, t);
+			}
+			
+			source.Emit (ec);
+
+			if (rank == 1)
+				EmitStoreOpcode (ig, t);
+			else {
+				ModuleBuilder mb = CodeGen.ModuleBuilder;
+				int arg_count = ea.Arguments.Count;
+				Type [] args = new Type [arg_count + 1];
+				MethodInfo set;
+				
+				for (int i = 0; i < arg_count; i++){
+					//args [i++] = a.Type;
+					args [i] = TypeManager.int32_type;
+				}
+
+				args [arg_count] = type;
+				
+				set = mb.GetArrayMethod (
+					ea.Expr.Type, "Set",
+					CallingConventions.HasThis |
+					CallingConventions.Standard,
+					TypeManager.void_type, args);
+				
+				ig.Emit (OpCodes.Call, set);
+			}
+		}
+
+		public void AddressOf (EmitContext ec, AddressOp mode)
+		{
+			int rank = ea.Expr.Type.GetArrayRank ();
+			ILGenerator ig = ec.ig;
+
+			LoadArrayAndArguments (ec);
+
+			if (rank == 1){
+				ig.Emit (OpCodes.Ldelema, type);
+			} else {
+				MethodInfo address = FetchAddressMethod ();
+				ig.Emit (OpCodes.Call, address);
+			}
+		}
+	}
+
+	
+	class Indexers {
+		public ArrayList getters, setters;
+		static Hashtable map;
+
+		static Indexers ()
+		{
+			map = new Hashtable ();
+		}
+
+		Indexers (MemberInfo [] mi)
+		{
+			foreach (PropertyInfo property in mi){
+				MethodInfo get, set;
+				
+				get = property.GetGetMethod (true);
+				if (get != null){
+					if (getters == null)
+						getters = new ArrayList ();
+
+					getters.Add (get);
+				}
+				
+				set = property.GetSetMethod (true);
+				if (set != null){
+					if (setters == null)
+						setters = new ArrayList ();
+					setters.Add (set);
+				}
+			}
+		}
+
+		static private Indexers GetIndexersForTypeOrInterface (Type caller_type, Type lookup_type)
+		{
+			Indexers ix = (Indexers) map [lookup_type];
+			
+			if (ix != null)
+				return ix;
+
+			Type innerType;
+			string p_name = TypeManager.IndexerPropertyName (lookup_type, out innerType);
+			
+			if ( p_name == null )
+				return null;
+
+			MemberInfo [] mi = TypeManager.MemberLookup (
+				caller_type, innerType, MemberTypes.Property,
+				BindingFlags.Public | BindingFlags.Instance, p_name);
+
+			if (mi == null || mi.Length == 0)
+				return null;
+
+			ix = new Indexers (mi);
+			//map [lookup_type] = ix;
+			map [innerType] = ix;
+
+			return ix;
+		}
+		
+		static public Indexers GetIndexersForType (Type caller_type, Type lookup_type, Location loc) 
+		{
+			Indexers ix = (Indexers) map [lookup_type];
+			
+			if (ix != null)
+				return ix;
+
+			ix = GetIndexersForTypeOrInterface (caller_type, lookup_type);
+			if (ix != null)
+				return ix;
+
+			Type [] ifaces = TypeManager.GetInterfaces (lookup_type);
+			if (ifaces != null) {
+				foreach (Type itype in ifaces) {
+					ix = GetIndexersForTypeOrInterface (caller_type, itype);
+					if (ix != null)
+						return ix;
+				}
+			}
+			return null;
+		}
+	}
+
+	/// <summary>
+	///   Expressions that represent an indexer call.
+	/// </summary>
+	public class IndexerAccess : Expression, IAssignMethod {
+		//
+		// Points to our "data" repository
+		//
+		MethodInfo get, set;
+		Indexers ilist;
+		ArrayList set_arguments;
+		//bool is_base_indexer;
+
+		protected Type indexer_type;
+		protected Type current_type;
+		protected Expression instance_expr;
+		protected ArrayList arguments;
+		
+		public IndexerAccess (ElementAccess ea, Location loc)
+			: this (ea.Expr, false, loc)
+		{
+			this.arguments = ea.Arguments;
+		}
+
+		protected IndexerAccess (Expression instance_expr, bool is_base_indexer,
+					 Location loc)
+		{
+			this.instance_expr = instance_expr;
+			//this.is_base_indexer = is_base_indexer;
+			this.eclass = ExprClass.Value;
+			this.loc = loc;
+		}
+
+		public Expression Instance {
+			get {
+				return instance_expr;
+			}
+		}
+
+		public ArrayList Arguments {
+			get {
+				return arguments;
+			}
+		}
+
+		protected virtual bool CommonResolve (EmitContext ec)
+		{
+			indexer_type = instance_expr.Type;
+			current_type = ec.ContainerType;
+
+			return true;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (!CommonResolve (ec))
+				return null;
+
+			//
+			// Step 1: Query for all 'Item' *properties*.  Notice
+			// that the actual methods are pointed from here.
+			//
+			// This is a group of properties, piles of them.  
+
+			if (ilist == null) {
+				ilist = Indexers.GetIndexersForType (
+					current_type, indexer_type, loc);
+
+				if (ilist == null && indexer_type != TypeManager.object_type) {
+					Report.Error (30367, loc,
+					      	"Type '" + TypeManager.MonoBASIC_Name (indexer_type) +
+					      	"' does not have any indexers defined");
+					return null;
+					//Report.Error (21, loc,
+					//      	"Type '" + TypeManager.MonoBASIC_Name (indexer_type) +
+					//      	"' does not have any indexers defined");
+					//return null;
+				}
+			}
+
+			//
+			// Step 2: find the proper match
+			//
+			if (ilist != null && ilist.getters != null && ilist.getters.Count > 0)
+				get = (MethodInfo) Invocation.OverloadResolve (
+					ec, new MethodGroupExpr (ilist.getters, loc), arguments, loc);
+
+			if (get == null){
+				if (instance_expr.Type != TypeManager.object_type)
+					Error (30524, "indexer can not be used in this context, because " +
+				   		"it lacks a 'get' accessor");
+				return null;
+			}
+
+			type = get.ReturnType;
+			if (type.IsPointer && !ec.InUnsafe){
+				UnsafeError (loc);
+				return null;
+			}
+			
+			eclass = ExprClass.IndexerAccess;
+			return this;
+		}
+
+		public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
+		{
+			if (!CommonResolve (ec))
+				return null;
+
+			Type right_type = right_side.Type;
+
+			if (ilist == null) {
+				ilist = Indexers.GetIndexersForType (
+					current_type, indexer_type, loc);
+				if (ilist == null && indexer_type != TypeManager.object_type) {
+					Report.Error (21, loc,
+					      	"Type '" + TypeManager.MonoBASIC_Name (indexer_type) +
+					      	"' does not have any indexers defined");
+					return null;
+				}
+			}
+
+			if (ilist != null && ilist.setters != null && ilist.setters.Count > 0){
+				set_arguments = (ArrayList) arguments.Clone ();
+				set_arguments.Add (new Argument (right_side, Argument.AType.Expression));
+
+				set = (MethodInfo) Invocation.OverloadResolve (
+					ec, new MethodGroupExpr (ilist.setters, loc), set_arguments, loc);
+			}
+			
+			if (set == null){
+				Error (30526, "indexer X.this [" + TypeManager.MonoBASIC_Name (right_type) +
+				       "] lacks a 'set' accessor");
+				return null;
+			}
+
+			type = TypeManager.void_type;
+			eclass = ExprClass.IndexerAccess;
+			return this;
+		}
+		
+		public override void Emit (EmitContext ec)
+		{
+			Invocation.EmitCall (ec, false, false, instance_expr, get, arguments, loc);
+		}
+
+		//
+		// source is ignored, because we already have a copy of it from the
+		// LValue resolution and we have already constructed a pre-cached
+		// version of the arguments (ea.set_arguments);
+		//
+		public void EmitAssign (EmitContext ec, Expression source)
+		{
+			Invocation.EmitCall (ec, false, false, instance_expr, set, set_arguments, loc);
+		}
+	}
+
+	/// <summary>
+	///   The base operator for method names
+	/// </summary>
+	public class BaseAccess : Expression {
+		public string member;
+		
+		public BaseAccess (string member, Location l)
+		{
+			this.member = member;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			Expression member_lookup;
+			Type current_type = ec.ContainerType;
+			Type base_type = current_type.BaseType;
+			Expression e;
+
+			if (ec.IsStatic){
+				Error (1511, "Keyword MyBase is not allowed in static method");
+				return null;
+			}
+			
+			if (member == "New")
+				member = ".ctor";
+			
+			member_lookup = MemberLookup (ec, current_type, base_type, member,
+						      AllMemberTypes, AllBindingFlags, loc);
+
+			if (member_lookup == null) {
+				Error (30456,
+					      TypeManager.MonoBASIC_Name (base_type) + " does not " +
+					      "contain a definition for '" + member + "'");
+				return null;
+			}
+
+			Expression left;
+			
+			if (ec.IsStatic)
+				left = new TypeExpr (base_type, loc);
+			else
+				left = ec.This;
+			
+			e = MemberAccess.ResolveMemberAccess (ec, member_lookup, left, loc, null);
+
+			if (e is PropertyExpr) {
+				PropertyExpr pe = (PropertyExpr) e;
+
+				pe.IsBase = true;
+			}
+
+			return e;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			throw new Exception ("Should never be called"); 
+		}
+	}
+
+	/// <summary>
+	///   The base indexer operator
+	/// </summary>
+	public class BaseIndexerAccess : IndexerAccess {
+		public BaseIndexerAccess (ArrayList args, Location loc)
+			: base (null, true, loc)
+		{
+			arguments = new ArrayList ();
+			foreach (Expression tmp in args)
+				arguments.Add (new Argument (tmp, Argument.AType.Expression));
+		}
+
+		protected override bool CommonResolve (EmitContext ec)
+		{
+			instance_expr = ec.This;
+
+			current_type = ec.ContainerType.BaseType;
+			indexer_type = current_type;
+
+			foreach (Argument a in arguments){
+				if (!a.Resolve (ec, loc))
+					return false;
+			}
+
+			return true;
+		}
+	}
+	
+	/// <summary>
+	///   This class exists solely to pass the Type around and to be a dummy
+	///   that can be passed to the conversion functions (this is used by
+	///   foreach implementation to typecast the object return value from
+	///   get_Current into the proper type.  All code has been generated and
+	///   we only care about the side effect conversions to be performed
+	///
+	///   This is also now used as a placeholder where a no-action expression
+	///   is needed (the 'New' class).
+	/// </summary>
+	public class EmptyExpression : Expression {
+		public EmptyExpression ()
+		{
+			type = TypeManager.object_type;
+			eclass = ExprClass.Value;
+			loc = Location.Null;
+		}
+
+		public EmptyExpression (Type t)
+		{
+			type = t;
+			eclass = ExprClass.Value;
+			loc = Location.Null;
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			// nothing, as we only exist to not do anything.
+		}
+
+		//
+		// This is just because we might want to reuse this bad boy
+		// instead of creating gazillions of EmptyExpressions.
+		// (CanConvertImplicit uses it)
+		//
+		public void SetType (Type t)
+		{
+			type = t;
+		}
+	}
+
+	public class UserCast : Expression {
+		MethodBase method;
+		Expression source;
+		
+		public UserCast (MethodInfo method, Expression source, Location l)
+		{
+			this.method = method;
+			this.source = source;
+			type = method.ReturnType;
+			eclass = ExprClass.Value;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			//
+			// We are born fully resolved
+			//
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+
+			source.Emit (ec);
+			
+			if (method is MethodInfo)
+				ig.Emit (OpCodes.Call, (MethodInfo) method);
+			else
+				ig.Emit (OpCodes.Call, (ConstructorInfo) method);
+
+		}
+	}
+
+	// <summary>
+	//   This class is used to "construct" the type during a typecast
+	//   operation.  Since the Type.GetType class in .NET can parse
+	//   the type specification, we just use this to construct the type
+	//   one bit at a time.
+	// </summary>
+	public class ComposedCast : Expression, ITypeExpression {
+		Expression left;
+		string dim;
+		
+		public ComposedCast (Expression left, string dim, Location l)
+		{
+			this.left = left;
+			this.dim = dim;
+			loc = l;
+		}
+
+		public Expression DoResolveType (EmitContext ec)
+		{
+			Type ltype = ec.DeclSpace.ResolveType (left, false, loc);
+			if (ltype == null)
+				return null;
+
+			//
+			// ltype.Fullname is already fully qualified, so we can skip
+			// a lot of probes, and go directly to TypeManager.LookupType
+			//
+			string cname = ltype.FullName + dim;
+			type = TypeManager.LookupTypeDirect (cname);
+			if (type == null){
+				//
+				// For arrays of enumerations we are having a problem
+				// with the direct lookup.  Need to investigate.
+				//
+				// For now, fall back to the full lookup in that case.
+				//
+				type = RootContext.LookupType (
+					ec.DeclSpace, cname, false, loc);
+
+				if (type == null)
+					return null;
+			}
+
+			if (!ec.ResolvingTypeTree){
+				//
+				// If the above flag is set, this is being invoked from the ResolveType function.
+				// Upper layers take care of the type validity in this context.
+				//
+			if (!ec.InUnsafe && type.IsPointer){
+				UnsafeError (loc);
+				return null;
+			}
+			}
+			
+			eclass = ExprClass.Type;
+			return this;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			return DoResolveType (ec);
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			throw new Exception ("This should never be called");
+		}
+
+		public override string ToString ()
+		{
+			return left + dim;
+		}
+	}
+
+	//
+	// This class is used to represent the address of an array, used
+	// only by the Fixed statement, this is like the C "&a [0]" construct.
+	//
+	public class ArrayPtr : Expression {
+		Expression array;
+		
+		public ArrayPtr (Expression array, Location l)
+		{
+			Type array_type = array.Type.GetElementType ();
+
+			this.array = array;
+			
+			string array_ptr_type_name = array_type.FullName + "*";
+			
+			type = Type.GetType (array_ptr_type_name);
+			if (type == null){
+				ModuleBuilder mb = CodeGen.ModuleBuilder;
+				
+				type = mb.GetType (array_ptr_type_name);
+			}
+
+			eclass = ExprClass.Value;
+			loc = l;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			
+			array.Emit (ec);
+			IntLiteral.EmitInt (ig, 0);
+			ig.Emit (OpCodes.Ldelema, array.Type.GetElementType ());
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			//
+			// We are born fully resolved
+			//
+			return this;
+		}
+	}
+
+	//
+	// Used by the fixed statement
+	//
+	public class StringPtr : Expression {
+		LocalBuilder b;
+		
+		public StringPtr (LocalBuilder b, Location l)
+		{
+			this.b = b;
+			eclass = ExprClass.Value;
+			type = TypeManager.char_ptr_type;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			// This should never be invoked, we are born in fully
+			// initialized state.
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+
+			ig.Emit (OpCodes.Ldloc, b);
+			ig.Emit (OpCodes.Conv_I);
+			ig.Emit (OpCodes.Call, TypeManager.int_get_offset_to_string_data);
+			ig.Emit (OpCodes.Add);
+		}
+	}
+	
+	//
+	// Implements the 'stackalloc' keyword
+	//
+	public class StackAlloc : Expression {
+		Type otype;
+		Expression t;
+		Expression count;
+		
+		public StackAlloc (Expression type, Expression count, Location l)
+		{
+			t = type;
+			this.count = count;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			count = count.Resolve (ec);
+			if (count == null)
+				return null;
+			
+			if (count.Type != TypeManager.int32_type){
+				count = ConvertImplicitRequired (ec, count, TypeManager.int32_type, loc);
+				if (count == null)
+					return null;
+			}
+
+			if (ec.InCatch || ec.InFinally){
+				Error (255,
+					      "stackalloc can not be used in a catch or finally block");
+				return null;
+			}
+
+			otype = ec.DeclSpace.ResolveType (t, false, loc);
+
+			if (otype == null)
+				return null;
+
+			if (!TypeManager.VerifyUnManaged (otype, loc))
+				return null;
+
+			string ptr_name = otype.FullName + "*";
+			type = Type.GetType (ptr_name);
+			if (type == null){
+				ModuleBuilder mb = CodeGen.ModuleBuilder;
+				
+				type = mb.GetType (ptr_name);
+			}
+			eclass = ExprClass.Value;
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			int size = GetTypeSize (otype);
+			ILGenerator ig = ec.ig;
+				
+			if (size == 0)
+				ig.Emit (OpCodes.Sizeof, otype);
+			else
+				IntConstant.EmitInt (ig, size);
+			count.Emit (ec);
+			ig.Emit (OpCodes.Mul);
+			ig.Emit (OpCodes.Localloc);
+		}
+	}
+	public class Preserve : ExpressionStatement {
+		ArrayList args = null;
+		MethodInfo mi = null;
+		Expression target = null;
+		ExpressionStatement source = null;
+
+
+		public Preserve (Expression RedimTarget, ExpressionStatement acExpr, Location l)
+		{
+			Type type = typeof(Microsoft.VisualBasic.CompilerServices.Utils);
+			mi = type.GetMethod("CopyArray");
+
+			target = RedimTarget;
+			source = acExpr;
+
+			eclass = ExprClass.Value;
+			loc = l;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			//
+			// We are born fully resolved
+			//
+			type = mi.ReturnType;
+
+			source.Resolve (ec);
+
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			args = new ArrayList (2);
+
+			args.Add (new Argument (target, Argument.AType.Expression));
+			args.Add (new Argument (source, Argument.AType.Expression));
+
+			Invocation.EmitArguments (ec, mi, args);
+
+			ec.ig.Emit (OpCodes.Call, mi);
+			return;
+		}
+
+		public override void EmitStatement (EmitContext ec)
+		{
+			Emit (ec);
+		}
+
+	}
+}
diff --git a/dead/mbas/genericparser.cs b/dead/mbas/genericparser.cs
new file mode 100644
index 00000000..77361ce8
--- /dev/null
+++ b/dead/mbas/genericparser.cs
@@ -0,0 +1,326 @@
+//
+// GenericParser.cs: The Base Parser for the Mono compilers
+//
+// Author: A Rafael D Teixeira (rafaelteixeirabr@hotmail.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// Copyright (C) 2001 Ximian, Inc.
+//
+
+namespace Mono.Languages
+{
+	using System;
+	using System.Reflection;
+	using System.Collections;
+	using System.IO;
+	using System.Text;
+	using Mono.MonoBASIC;
+
+	/// <summary>
+	/// Base class to support multiple Jay generated parsers
+	/// </summary>
+	public abstract class GenericParser
+	{
+		// ---------------------------------------------------
+		// Class state
+
+		// Count of errors found while parsing
+		static protected int global_errors;
+
+		// Maps extensions to specific parsers
+		static private Hashtable mapOfParsers;
+
+		// Maps extensions to specific parsers
+		static private GenericParser defaultParser = null;
+
+		// Indicates if parsing should be verbose
+		static public int yacc_verbose_flag = 0;
+
+		// Context to use
+		static public ArrayList defines;
+
+		// ---------------------------------------------------
+		// Instance state
+
+		// Name of the file we are parsing
+		protected string name;
+
+		// Input stream to parse from.
+		protected System.IO.TextReader input;
+
+		// Current namespace definition
+		protected Namespace     current_namespace;
+
+		// Current typecontainer definition
+		protected TypeContainer current_container;
+		
+		// ---------------------------------------------------
+		// What the descendants MUST reimplement
+
+		/// <summary>
+		/// Parses the current "input"
+		/// </summary>
+		protected abstract int parse();
+
+		/// <summary>
+		/// Lists the extensions this parser can handle
+		/// </summary>
+		public abstract string[] extensions();
+		/* {
+			string [] list = { ".cs" };
+			return list;
+		} */
+
+		// ---------------------------------------------------
+		// What the descendants DONT HAVE to reimplement
+
+		/// <summary>
+		/// Initializes this parser from a file and parses it
+		/// </summary>
+		/// <param name="fileName">Name of the file to be parsed</param>
+		public int ParseFile(string fileName)
+		{
+			// file exceptions must be caught by caller
+
+			global_errors = 0;
+			name = fileName;
+			// TODO: Encoding switching as needed
+			//   We are here forcing StreamReader to assume current system codepage,
+			//   because normally it defaults to UTF-8
+			input = new StreamReader(fileName, System.Text.Encoding.Default); 
+			//rc = context;
+			return parse();
+		}
+
+		/// <summary>
+		/// Initializes this parser from a file and parses it
+		/// </summary>
+		/// <param name="fileName">Name of the file to be parsed</param>
+		/// <param name="encoding">Specific encoding to use in parsing</param>
+		public int ParseFile(string fileName, Encoding encoding)
+		{
+			// file exceptions must be caught by caller
+
+			global_errors = 0;
+			name = fileName;
+			// TODO: Encoding switching as needed
+			//   We are here forcing StreamReader to assume an specific encoding
+			input = new StreamReader(fileName, encoding); 
+			//rc = context;
+			return parse();
+		}
+
+		/// <summary>
+		/// Initializes this parser from a string and parses it
+		/// </summary>
+		/// <param name="source">String to be parsed</param>
+		/// <param name="sourceName">Name of the source to be parsed (just for error reporting)</param>
+		public int ParseString(string source, string sourceName)
+		{
+			global_errors = 0;
+			name = sourceName;
+			input = new StringReader(source);
+			//rc = context;
+			return parse();
+		}
+
+		// ---------------------------------------------------
+		// Class methods
+
+		static private void MapParsers()
+		{
+			mapOfParsers = new Hashtable();
+
+			Assembly thisAssembly = Assembly.GetExecutingAssembly();
+			foreach(Type type in thisAssembly.GetTypes())
+			{
+				if (type.BaseType != null)
+					if (type.BaseType.FullName == "Mono.Languages.GenericParser")
+					{
+						GenericParser parser = (GenericParser)Activator.CreateInstance(type);
+						foreach(string fileExtension in parser.extensions())
+						{												
+							string theFileExtension = fileExtension.ToLower();
+							if (mapOfParsers.Contains(theFileExtension))
+								Console.WriteLine("[TRACE] " + type.FullName + " can't try to parse '" + theFileExtension + "' files too");
+							else
+								mapOfParsers.Add(theFileExtension, parser);
+						}
+						object[] attribs = type.GetCustomAttributes(typeof(DefaultParserAttribute), false);
+						if (attribs != null && attribs.Length > 0)
+						{
+							if (defaultParser == null)
+								defaultParser = parser;
+							else
+								Console.WriteLine("[TRACE] " + type.FullName + " can't be another default parser");								
+						}
+					}
+			}
+		}
+
+		/// <summary>
+		/// Find the descendant parser that knows how to parse the specified file
+		/// based on the file extension, or the default parser otherwise, if available
+		/// </summary>
+		/// <param name="fileName">Name of the file to be parsed</param>
+		public static GenericParser GetSpecificParserFor(string fileName)
+		{
+			int i;
+			GenericParser chosenParser = null;
+			
+			if (mapOfParsers == null)
+				MapParsers();
+			
+			if ((i = fileName.LastIndexOf(".")) > 0)
+			{
+				string fileExtension = fileName.Substring(i).ToLower();
+				chosenParser = (GenericParser)mapOfParsers[fileExtension];
+			}
+			
+			if (chosenParser != null)			
+				return chosenParser;
+				
+			return defaultParser;
+		}
+
+
+		[Obsolete]		
+		public static int Tokenize(string fileName)
+		{
+			return 1;
+		}
+
+
+		/// <summary>
+		/// Find the descendant parser that knows how to parse the specified file
+		/// based on the files extension, and parses it using the chosen parser
+		/// </summary>
+		/// <param name="fileName">Name of the file to be parsed</param>
+		[Obsolete]
+		public static int Parse(string fileName)
+		{
+			return Parse(fileName, null);
+		}
+		
+		/// <summary>
+		/// Find the descendant parser that knows how to parse the specified file
+		/// based on the files extension, and parses it using the chosen parser
+		/// </summary>
+		/// <param name="fileName">Name of the file to be parsed</param>
+		/// <param name="encoding">Encoding of the file to be parsed</param>
+		public static int Parse(string fileName, Encoding encoding)
+		{
+			int errors;
+			GenericParser parser = GetSpecificParserFor(fileName);
+						
+			if (parser == null)
+			{
+				Console.WriteLine("Do not know how to compile " + fileName);
+				return 1;
+			}
+			
+			if (encoding == null)
+				encoding = Encoding.Default;
+				
+			try 
+			{
+				errors = parser.ParseFile(fileName, encoding);
+			} 
+			catch (FileNotFoundException)
+			{
+				Report.Error(2001, "Source file \'" + fileName + "\' could not be found!!!");
+				return 1;
+			}
+			catch (DirectoryNotFoundException)
+			{
+				Report.Error(2001, "Source file \'" + fileName + "\' could not be found!!!");
+				return 1;
+			}			
+			catch (Exception ex)
+			{
+				Console.WriteLine (ex);
+				Console.WriteLine ("Compilation aborted");
+				return 1;
+			}
+			
+			return errors;
+		}
+
+		// <summary>
+		//   Given the @class_name name, it creates a fully qualified name
+		//   based on the containing declaration space
+		// </summary>
+		protected string MakeName(string class_name)
+		{
+			string ns = current_namespace.Name;
+			string container_name = current_container.Name;
+
+			if (container_name == "")
+			{
+				if (ns != "")
+					return ns + "." + class_name;
+				else
+					return class_name;
+			} 
+			else
+				return container_name + "." + class_name;
+		}
+
+		// <summary>
+		//   Used to report back to the user the result of a declaration
+		//   in the current declaration space
+		// </summary>
+		protected void CheckDef (AdditionResult result, string name, Location l)
+		{
+			if (result == AdditionResult.Success)
+				return;
+
+			switch (result)
+			{
+				case AdditionResult.NameExists:
+					Report.Error (102, l, "The container '" + current_container.Name + 
+						"' already contains a definition for '"+
+						name + "'");
+					break;
+
+
+					//
+					// This is handled only for static Constructors, because
+					// in reality we handle these by the semantic analysis later
+					//
+				case AdditionResult.MethodExists:
+					Report.Error (
+						111, l, "Class `"+current_container.Name+
+						"' already defines a member called '" + 
+						name + "' with the same parameter types (more than one default constructor)");
+					break;
+
+				case AdditionResult.NotAConstructor:
+					Report.Error (1520, l, "Class, struct, or interface method must have a return type");
+					break;
+			}
+		}
+
+		// <summary>
+		//   Used to report back to the user the result of a declaration
+		//   in the current declaration space
+		// </summary>
+		protected void CheckDef (bool result, string name, Location l)
+		{
+			if (result)
+				return;
+			CheckDef (AdditionResult.NameExists, name, l);
+		}
+
+
+		// ---------------------------------------------------
+		// Constructors
+
+		public GenericParser()
+		{
+			// DO NOTHING
+		}
+
+	}
+}
diff --git a/dead/mbas/interface.cs b/dead/mbas/interface.cs
new file mode 100644
index 00000000..61204498
--- /dev/null
+++ b/dead/mbas/interface.cs
@@ -0,0 +1,181 @@
+//
+// interface.cs: Interface handler
+//
+// Author: Miguel de Icaza (miguel@gnu.org)
+//		   Anirban Bhattacharjee (banirban@novell.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001 Ximian, Inc (http://www.ximian.com)
+//
+
+#define CACHE
+
+/*This file will go off shortly
+ * after copying the interface class 
+ * in class.cs file
+ */
+
+using System.Collections;
+using System;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///   Interfaces
+	/// </summary>
+
+
+	/// <summary>
+	///   Interfaces
+	/// </summary>
+	public class Interface : Mono.MonoBASIC.Class /*TypeContainer , IMemberContainer */
+	{
+		/// <summary>
+		///   Modifiers allowed in a class declaration
+		/// </summary>
+		public new const int AllowedModifiers =
+			Modifiers.NEW       |
+			Modifiers.PUBLIC    |
+			Modifiers.PROTECTED |
+			Modifiers.INTERNAL  |
+			Modifiers.PRIVATE;
+
+		public Interface (TypeContainer parent, string name, int mod,
+							Attributes attrs, Location l)
+			: base (parent, name, 0, attrs, l)
+		{
+			int accmods;
+
+			if (parent.Parent == null)
+				accmods = Modifiers.INTERNAL;
+			else
+				accmods = Modifiers.PUBLIC;
+
+			this.ModFlags = Modifiers.Check (AllowedModifiers, mod, accmods, l);
+			this.ModFlags |= Modifiers.ABSTRACT;
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Interface;
+			}
+		}
+
+		public override TypeAttributes TypeAttr 
+		{
+			get 
+			{
+				return base.TypeAttr |
+					TypeAttributes.AutoLayout |
+					TypeAttributes.Abstract |
+					TypeAttributes.Interface;
+			}
+		}
+	}
+
+/*
+	public class InterfaceMemberBase {
+		public readonly string Name;
+		public readonly bool IsNew;
+		public Attributes OptAttributes;
+		
+		public InterfaceMemberBase (string name, bool is_new, Attributes attrs)
+		{
+			Name = name;
+			IsNew = is_new;
+			OptAttributes = attrs;
+		}
+	}
+	
+	public class InterfaceProperty : InterfaceMemberBase {
+		public readonly bool HasSet;
+		public readonly bool HasGet;
+		public readonly Location Location;
+		public Expression Type;
+		
+		public InterfaceProperty (Expression type, string name,
+					  bool is_new, bool has_get, bool has_set,
+					  Attributes attrs, Location loc)
+			: base (name, is_new, attrs)
+		{
+			Type = type;
+			HasGet = has_get;
+			HasSet = has_set;
+			Location = loc;
+		}
+	}
+*/
+/*	public class InterfaceEvent : InterfaceMemberBase {
+		public readonly Location Location;
+		public Expression Type;
+		
+		public InterfaceEvent (Expression type, string name, bool is_new, Attributes attrs,
+				       Location loc)
+			: base (name, is_new, attrs)
+		{
+			Type = type;
+			Location = loc;
+		}
+	}
+/*	
+	public class InterfaceMethod : InterfaceMemberBase {
+		public readonly Expression ReturnType;
+		public readonly Parameters Parameters;
+		public readonly Location Location;
+		
+		public InterfaceMethod (Expression return_type, string name, bool is_new, Parameters args,
+					Attributes attrs, Location l)
+			: base (name, is_new, attrs)
+		{
+			this.ReturnType = return_type;
+			this.Parameters = args;
+			Location = l;
+		}
+
+		/// <summary>
+		///   Returns the signature for this interface method
+		/// </summary>
+		public string GetSignature (DeclSpace ds)
+		{
+			Type ret = ds.ResolveType (ReturnType, false, Location);
+			string args = Parameters.GetSignature (ds);
+
+			if ((ret == null) || (args == null))
+				return null;
+			
+			return (IsNew ? "new-" : "") + ret.FullName + "(" + args + ")";
+		}
+
+		public Type [] ParameterTypes (DeclSpace ds)
+		{
+			return Parameters.GetParameterInfo (ds);
+		}
+	}
+
+	public class InterfaceIndexer : InterfaceMemberBase {
+		public readonly bool HasGet, HasSet;
+		public readonly Parameters Parameters;
+		public readonly Location Location;
+		public Expression Type;
+		
+		public InterfaceIndexer (Expression type, Parameters args, bool do_get, bool do_set,
+					 bool is_new, Attributes attrs, Location loc)
+			: base ("", is_new, attrs)
+		{
+			Type = type;
+			Parameters = args;
+			HasGet = do_get;
+			HasSet = do_set;
+			Location = loc;
+		}
+
+		public Type [] ParameterTypes (DeclSpace ds)
+		{
+			return Parameters.GetParameterInfo (ds);
+		}
+	}*/
+}
diff --git a/dead/mbas/literal.cs b/dead/mbas/literal.cs
new file mode 100644
index 00000000..04941beb
--- /dev/null
+++ b/dead/mbas/literal.cs
@@ -0,0 +1,223 @@
+//
+// literal.cs: Literal representation for the IL tree.
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//
+// (C) 2001 Ximian, Inc.
+//
+//
+// Notice that during parsing we create objects of type Literal, but the
+// types are not loaded (thats why the Resolve method has to assign the
+// type at that point).
+//
+// Literals differ from the constants in that we know we encountered them
+// as a literal in the source code (and some extra rules apply there) and
+// they have to be resolved (since during parsing we have not loaded the
+// types yet) while constants are created only after types have been loaded
+// and are fully resolved when born.
+//
+
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Mono.MonoBASIC {
+	
+	 //
+        // The NullType just exists to compare type equality, and for
+        // expressions that might have the `null type'
+        //
+        public class NullType {
+        }
+
+        //
+        // The null Literal constant
+        //
+
+	public class NullLiteral : Constant {
+		public static readonly NullLiteral Null;
+		
+		static NullLiteral ()
+		{
+			Null = new NullLiteral ();
+		}
+			
+		public NullLiteral ()
+		{
+			if (Null != null)
+				throw new Exception ("More than one null has been created!");
+			eclass = ExprClass.Value;
+		}
+		
+		override public string AsString ()
+		{
+			return "null";
+		}
+
+		public override object GetValue ()
+		{
+			return null;
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.object_type;
+			return this;
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			ec.ig.Emit (OpCodes.Ldnull);
+		}
+	}
+
+	public class BoolLiteral : BoolConstant {
+		public BoolLiteral (bool val) : base (val)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.bool_type;
+			return this;
+		}
+	}
+
+	public class CharLiteral : CharConstant {
+		public CharLiteral (char c) : base (c)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.char_type;
+			return this;
+		}
+	}
+
+	public class IntLiteral : IntConstant {
+		public IntLiteral (int l) : base (l)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.int32_type;
+			return this;
+		}
+	}
+
+	public class ShortLiteral : ShortConstant {
+		public ShortLiteral (short l) : base (l)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.short_type;
+			return this;
+		}
+	}
+
+	public class UIntLiteral : UIntConstant {
+		public UIntLiteral (uint l) : base (l)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.uint32_type;
+			return this;
+		}
+	}
+	
+	public class LongLiteral : LongConstant {
+		public LongLiteral (long l) : base (l)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.int64_type;
+
+			return this;
+		}
+	}
+
+	public class ULongLiteral : ULongConstant {
+		public ULongLiteral (ulong l) : base (l)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.uint64_type;
+			return this;
+		}
+	}
+	
+	public class FloatLiteral : FloatConstant {
+		
+		public FloatLiteral (float f) : base (f)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.float_type;
+			return this;
+		}
+	}
+
+	public class DoubleLiteral : DoubleConstant {
+		public DoubleLiteral (double d) : base (d)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.double_type;
+
+			return this;
+		}
+	}
+
+	public class DecimalLiteral : DecimalConstant {
+		public DecimalLiteral (decimal d) : base (d)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.decimal_type;
+			return this;
+		}
+	}
+
+	public class StringLiteral : StringConstant {
+		public StringLiteral (string s) : base (s)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.string_type;
+
+			return this;
+		}
+	}
+	
+	public class DateLiteral : DateConstant {
+		public DateLiteral (DateTime s) : base (s)
+		{
+		}
+
+		public override Expression DoResolve (EmitContext ec)
+		{
+			type = TypeManager.date_type;
+
+			return this;
+		}
+	}
+}
diff --git a/dead/mbas/location.cs b/dead/mbas/location.cs
new file mode 100644
index 00000000..c930229c
--- /dev/null
+++ b/dead/mbas/location.cs
@@ -0,0 +1,167 @@
+//
+// location.cs: Keeps track of the location of source code entity
+//
+// Author:
+//   Miguel de Icaza
+//
+// (C) 2001 Ximian, Inc.
+//
+
+using System;
+using System.IO;
+using System.Collections;
+using System.Diagnostics.SymbolStore;
+
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///   Keeps track of the location in the program
+	/// </summary>
+	///
+	/// <remarks>
+	///   This uses a compact representation and a couple of auxiliary
+	///   structures to keep track of tokens to (line, col, file) mappings.
+	///
+	public struct Location {
+		const int NUM_ROW_BITS = 16;
+		const int NUM_COL_BITS =  8;
+		const int NUM_FILE_BITS = (32-NUM_ROW_BITS-NUM_COL_BITS);
+		
+		const int NUM_FILE_SHIFTS = 0;
+		const int NUM_ROW_SHIFTS = NUM_FILE_BITS;
+		const int NUM_COL_SHIFTS =  NUM_ROW_BITS+NUM_FILE_BITS;
+
+		const int FILE_MASK = (1<<NUM_FILE_BITS)-1;
+		const int ROW_MASK = ((1<<NUM_ROW_BITS)-1)<<NUM_FILE_BITS;
+		const int COL_MASK = ((1<<NUM_COL_BITS)-1)<<(NUM_ROW_BITS+NUM_FILE_BITS);
+		
+		public int token; // ordered triplet: (Row, Col, File Index)
+
+		static ArrayList source_list;
+		static Hashtable source_files;
+		static int source_count;
+		static int current_source;
+		static Hashtable sym_docs;
+
+		public readonly static Location Null;
+		
+		static Location ()
+		{
+			source_files = new Hashtable ();
+			source_list = new ArrayList ();
+			current_source = 0;
+			sym_docs = new Hashtable ();
+			Null.token = 0;
+		}
+
+		static public void SetCurrentSource(string name)
+		{
+			int index;
+			
+			if (!source_files.Contains (name)) {
+				index = ++source_count;
+				source_files.Add (name, index);
+				source_list.Add (name);
+			}
+			else {
+				index = (int)source_files[name];
+			}
+
+			current_source = index;
+		}
+		
+		public Location (int row, int col)
+		{
+			if (row < 0 || col <  0)
+				token = 0;
+			else {
+				if (col > 255)
+					col = 255;
+				token = (current_source<<NUM_FILE_SHIFTS) + (row<<NUM_ROW_SHIFTS) + (col<<NUM_COL_SHIFTS);
+			}
+		}
+
+		public override string ToString ()
+		{
+			return Name + ": (" + Row + ")";
+		}
+		
+		static public bool IsNull (Location l)
+		{
+			return l.token == 0;
+		}
+
+		public string Name {
+			get {
+				if(token == 0)
+					return "Internal";
+
+				int index = (token & FILE_MASK)>>NUM_FILE_SHIFTS;
+				string file = (string) source_list [index - 1];
+				return file;
+			}
+		}
+
+		public int Row {
+			get {
+				if (token == 0)
+					return 1;
+
+				return (token & ROW_MASK)>>NUM_ROW_SHIFTS;
+			}
+		}
+
+		public int Col {
+			get {
+				if (token == 0)
+					return 1;
+				
+				return (token & COL_MASK)>>NUM_COL_SHIFTS;
+			}
+		}
+
+		// The ISymbolDocumentWriter interface is used by the symbol writer to
+		// describe a single source file - for each source file there's exactly
+		// one corresponding ISymbolDocumentWriter instance.
+		//
+		// This class has an internal hash table mapping source document names
+		// to such ISymbolDocumentWriter instances - so there's exactly one
+		// instance per document.
+		//
+		// This property returns the ISymbolDocumentWriter instance which belongs
+		// to the location's source file.
+		//
+		// If we don't have a symbol writer, this property is always null.
+		public ISymbolDocumentWriter SymbolDocument {
+			get {
+				ISymbolWriter sw = CodeGen.SymbolWriter;
+				ISymbolDocumentWriter doc;
+
+				if (token < 0)
+					return null;
+
+				// If we don't have a symbol writer, return null.
+				if (sw == null)
+					return null;
+
+				string path = Path.GetFullPath (Name);
+
+				if (sym_docs.Contains (path))
+					// If we already created an ISymbolDocumentWriter
+					// instance for this document, return it.
+					doc = (ISymbolDocumentWriter) sym_docs [path];
+				else {
+					// Create a new ISymbolDocumentWriter instance and
+					// store it in the hash table.
+					doc = sw.DefineDocument (path, SymLanguageType.Basic,
+								 SymLanguageVendor.Microsoft,
+								 SymDocumentType.Text);
+
+					sym_docs.Add (path, doc);
+				}
+
+				return doc;
+			}
+		}
+	}
+}
diff --git a/dead/mbas/mb-parser.jay b/dead/mbas/mb-parser.jay
new file mode 100644
index 00000000..c99d9143
--- /dev/null
+++ b/dead/mbas/mb-parser.jay
@@ -0,0 +1,6377 @@
+%{
+//
+// Mono.MonoBASIC.Parser.cs (from .jay): The Parser for the MonoBASIC compiler
+//
+// Authors: A Rafael D Teixeira (rafaelteixeirabr@hotmail.com)
+//	    Anirban Bhattacharjee (banirban@novell.com)
+//          Jambunathan K (kjambunathan@novell.com)
+//          Manjula GHM (mmanjula@novell.com)
+//          Sudharsan V (vsudharsan@novell.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// Copyright (C) 2001, 2002, 2003, 2004 A Rafael D Teixeira
+// Copyright (C) 2003, 2004 Novell
+//
+//
+namespace Mono.MonoBASIC
+{
+	using System.Text;
+	using System;
+	using System.Reflection;
+	using System.Collections;
+	using Mono.Languages;
+	using Mono.MonoBASIC;
+
+	public class MBASException : ApplicationException
+	{
+		public int code;
+		public Location loc;
+
+		public MBASException(int code, Location loc, string text) : base(text)
+		{
+			this.code = code;
+			this.loc = loc;
+		}
+	}
+
+	/// <summary>
+	///    The MonoBASIC Parser
+	/// </summary>
+	[DefaultParser]
+	public class Parser : GenericParser
+	{
+	
+
+
+		/// <summary>
+		///   Current block is used to add statements as we find
+		///   them.  
+		/// </summary>
+		Block      current_block;
+		
+		/// <summary>
+		///   Tmp block is used to store block endings in if/select's
+		/// </summary>
+		Block      tmp_block;		
+
+		/// <summary>
+		///   Tmp block is used to store tmp copies of expressions
+		/// </summary>
+		Expression      tmp_expr;	
+		
+		/// <summary>
+		///   Tmp catch is used to store catch clauses in try..catch..finally
+		/// </summary>
+		ArrayList      tmp_catch_clauses;			
+		
+		/// <summary>
+		///   Current interface is used by the various declaration
+		///   productions in the interface declaration to "add"
+		///   the interfaces as we find them.
+		/// </summary>
+		Interface  current_interface;
+
+		/// <summary>
+		///   This is used by the unary_expression code to resolve
+		///   a name against a parameter.  
+		/// </summary>
+		Parameters current_local_parameters;
+		
+		/// <summary>
+		///   This are used when parsing parameters in property
+		///   declarations.
+		/// </summary>		
+		Parameters set_parameters;
+		Parameters get_parameters;
+		
+		/// <summary>
+		///   This is used by the sub_header parser to store modifiers
+		///   to be passed to sub/constructor  
+		/// </summary>
+		int current_modifiers;		
+			
+		/// <summary>
+		///   This is used by the sub_header parser to store attributes
+		///   to be passed to sub/constructor  
+		/// </summary>
+		Attributes current_attributes;				
+
+		/// <summary>
+		///   Using during property parsing to describe the implicit
+		///   value parameter that is passed to the "set" accessor
+		///   method
+		/// </summary>
+		string get_implicit_value_parameter_name;
+		
+		// <summary>
+		//   Using during property parsing to describe the implicit
+		//   value parameter that is passed to the "set" and "get"accesor
+		//   methods (properties and indexers).
+		// </summary>
+		Expression get_implicit_value_parameter_type;
+		
+		/// <summary>
+		///   Using during property parsing to describe the implicit
+		///   value parameter that is passed to the "set" accessor
+		///   method
+		/// </summary>
+		string set_implicit_value_parameter_name;
+		
+		// <summary>
+		//   Using during property parsing to describe the implicit
+		//   value parameter that is passed to the "set" and "get"accesor
+		//   methods (properties and indexers).
+		// </summary>
+		Expression set_implicit_value_parameter_type;		
+		
+		// An out-of-band stack.
+		//
+		Stack oob_stack;
+	
+		ArrayList current_rank_specifiers;
+
+		//To handle the End of a block 
+               // We use grammer, priority, strings, and an integer called Parenta
+               //
+               // FIX ME: Need to implement some better method than this and in
+               // some cases parser will come out without proceeding further
+               // if it comes acorss error.
+
+		// Used to store
+		//	1) The value for corresponding blocks with which it will be accessed...
+		// In case of any more addition to end of blocks... add it at the end	
+		
+		public enum Start_block {
+				NOTHING,
+				FOR,
+				DO,
+				IF,
+				SUB,
+				MODULE,
+				NAMESPACE,
+				CLASS,
+				FUNCTION,
+				STRUCTURE,
+				ENUM,
+				INTERFACE,
+				PROPERTY,
+				WITH,
+				SYNCLOCK,
+				TRY,
+				WHILE,
+				SELECT,
+				SET,
+				GET
+		}
+
+		// Used to store
+		//	1) Start of block
+		// 	2) End of Block
+		// In case of any more addition to end of blocks... add it at the end	
+
+		public string[,] end_blocks = {
+			 { "empty"     , "empty"             },
+			 { "For"       , "Next"           },
+			 { "Do"        , "Loop"           },
+			 { "If"        , "End If"         },
+			 { "Sub"       , "End Sub"        },
+			 { "Module"    , "End Module"     },
+			 { "NameSpace" , "End NameSpace"  },
+			 { "Class"     , "End Class"      },
+			 { "Function"  , "End Function"   },
+			 { "Structure" , "End Structure"  },
+			 { "Enum"      , "End Enum"       },
+			 { "Interface" , "End Interface"  },
+			 { "Property"  , "End Property"   },
+			 { "With"      , "End With"       },
+			 { "SyncLock"  , "End SyncLock"   },
+			 { "Try"       , "End Try"        },
+			 { "While"     , "End While"      },
+			 { "Select"    , "End Select"     },
+			 { "Set"       , "End Set"        },
+			 { "Get"       , "End Get"        }
+			};
+			
+		
+		// Used to store
+		//	1) Error number for End of block missing 
+		// 	2) Extra End of Block  
+		// 	3) Priority for the end 0f blocks
+		// In case of any more addition to end of blocks... add it at the end	
+
+		public int[,] error_end_blocks = {
+			 { 29999 , 29999 , 0 },
+			 { 30084 , 30092 , 1 },
+			 { 30083 , 30091 , 1 },
+			 { 30081 , 30087 , 1 },
+			 { 30289 , 30429 , 3 },
+			 { 30625 , 30622 , 5 },
+			 { 30626 , 30623 , 6 },
+			 { 30481 , 30460 , 4 },
+			 { 30027 , 30430 , 3 },
+			 { 30624 , 30621 , 4 },
+			 { 30185 , 30184 , 1 },
+			 { 30253 , 30252 , 3 },
+			 { 30025 , 30431 , 3 },
+			 { 30085 , 30093 , 1 },
+			 { 30675 , 30674 , 1 },
+			 { 30384 , 30383 , 1 },
+			 { 30082 , 30090 , 1 },
+			 { 30095 , 30088 , 1 },
+			 { 30633 , 30632 , 2 },
+			 { 30631 , 30630 , 2 }
+ 			};
+
+		Stack end_of_block;
+		Stack temp_block;
+		Stack loc_end_of_block;
+		Stack loc_temp_block;
+
+		Location try_top;
+
+		DoOptions do_type;
+		//
+		// Switch stack.
+		//
+		Stack switch_stack;
+		
+		// Expression stack for nested ifs
+		Stack expr_stack; 
+		
+		Stack tmp_blocks;
+	    	Stack statement_stack;
+
+		// A stack for With expressions.
+		//
+		Stack with_stack;
+		
+		//	
+		// Hash table for const preprocessing directive
+		//
+		public static CaseInsensitiveHashtable constPreDir = new CaseInsensitiveHashtable();
+		public static CaseInsensitiveHashtable with_hash = new CaseInsensitiveHashtable();
+		
+		static public bool InitialOptionExplicit = false;
+		static public bool InitialOptionStrict = false;
+		static public bool InitialOptionCompareBinary = true;
+		static public ArrayList ImportsList = null;
+
+		static public bool OptionExplicit;
+		static public bool OptionStrict;
+		static public bool OptionCompareBinary;
+
+		static public bool UseExtendedSyntax; // for ".mbs" files
+
+		bool implicit_modifiers;
+		
+		public override string[] extensions()
+		{
+			string [] list = { ".vb", ".mbs" };
+			return list;
+		}
+
+		bool in_external_source = false;
+		int in_marked_region = 0;
+
+		TokenizerController tokenizerController;
+		IfElseStateMachine ifElseStateMachine;
+
+		
+		public class IfElseStateMachine {
+			
+			public enum State {
+			START,
+			IF_SEEN,
+			ELSEIF_SEEN,
+			ELSE_SEEN,
+			ENDIF_SEEN,
+			MAX
+			}
+		
+			public enum Token {
+			START,
+			IF,
+			ELSEIF,
+			ELSE,
+			ENDIF,
+			EOF,
+			MAX
+			}
+
+			State state;
+			Stack stateStack;
+
+			public static Hashtable errStrings = new Hashtable();
+
+			int err=0;
+			static int[,] errTable = new int[(int)State.MAX, (int)Token.MAX];
+		
+			static IfElseStateMachine()
+			{
+				// FIXME: Fix both the error nos and the error strings. 
+				// Currently the error numbers and the error strings are 
+				// just placeholders for getting the state-machine going.
+
+				errStrings.Add(0, "");
+				errStrings.Add(30012, "#If must end with a matching #End If");
+				errStrings.Add(30013, "#ElseIf, #Else or #End If must be preceded by a matching #If");
+				errStrings.Add(30014, "#ElseIf must be preceded by a matching #If or #ElseIf");
+				errStrings.Add(30028, "#Else must be preceded by a matching #If or #ElseIf");
+				errStrings.Add(32030, "#ElseIf cannot follow #Else as part of #If block");
+
+				errTable[(int)State.START, (int)Token.IF] = 0;
+				errTable[(int)State.START, (int)Token.ELSEIF] = 30014;
+				errTable[(int)State.START, (int)Token.ELSE] = 30028;
+				errTable[(int)State.START, (int)Token.ENDIF] = 30013;
+				errTable[(int)State.START, (int)Token.EOF] = 0;
+
+				errTable[(int)State.IF_SEEN, (int)Token.IF] = 0;
+				errTable[(int)State.IF_SEEN, (int)Token.ELSEIF] = 0;
+				errTable[(int)State.IF_SEEN, (int)Token.ELSE] = 0;
+				errTable[(int)State.IF_SEEN, (int)Token.ENDIF] = 0;
+				errTable[(int)State.IF_SEEN, (int)Token.EOF] = 30012;
+
+				errTable[(int)State.ELSEIF_SEEN, (int)Token.IF] = 0;
+				errTable[(int)State.ELSEIF_SEEN, (int)Token.ELSEIF] = 0;
+				errTable[(int)State.ELSEIF_SEEN, (int)Token.ELSE] = 0;
+				errTable[(int)State.ELSEIF_SEEN, (int)Token.ENDIF] = 0;
+				errTable[(int)State.ELSEIF_SEEN, (int)Token.EOF] = 30012;
+
+				errTable[(int)State.ELSE_SEEN, (int)Token.IF] = 0;
+				errTable[(int)State.ELSE_SEEN, (int)Token.ELSEIF] = 32030;
+				errTable[(int)State.ELSE_SEEN, (int)Token.ELSE] = 32030;
+				errTable[(int)State.ELSE_SEEN, (int)Token.ENDIF] = 0;
+				errTable[(int)State.ELSE_SEEN, (int)Token.EOF] = 30012;
+
+				errTable[(int)State.ENDIF_SEEN, (int)Token.IF] = 0;
+				errTable[(int)State.ENDIF_SEEN, (int)Token.ELSEIF] = 30014;
+				errTable[(int)State.ENDIF_SEEN, (int)Token.ELSE] = 30028;
+				errTable[(int)State.ENDIF_SEEN, (int)Token.ENDIF] = 30013;
+				errTable[(int)State.ENDIF_SEEN, (int)Token.EOF] = 0;
+			}
+
+			public IfElseStateMachine()
+			{
+				state = State.START;
+
+				stateStack = new Stack();
+				stateStack.Push(state);
+			}
+
+			// The parameter here need not be qualified with IfElseStateMachine
+			// But it hits a bug in mcs. So temporarily scoping it so that builds
+			// are not broken.
+
+			public void HandleToken(IfElseStateMachine.Token tok)
+			{	
+				err = (int) errTable[(int)state, (int)tok];
+
+				if(err != 0)
+					throw new ApplicationException("Unexpected pre-processor directive #"+tok); 
+				
+				if(tok == Token.IF) {
+					stateStack.Push(state);
+					state = (State) tok;
+				}
+				else if(tok == Token.ENDIF) {
+					state = (State)stateStack.Pop();
+				}
+				else
+					state = (State)tok;
+			}
+
+			public int Error {
+				get {
+					return err;
+				}
+			}
+
+			public string ErrString {
+				get {
+					return (string) errStrings[err];
+				}
+			}
+		}
+
+		
+		public class TokenizerController {
+			
+			struct State
+			{
+				public bool CanAcceptTokens;
+				public bool CanSelectBlock;
+			}
+
+			State currentState;
+			Stack stateStack;
+			Tokenizer lexer;
+
+			public TokenizerController(Tokenizer lexer)
+			{
+				this.lexer = lexer;
+				stateStack = new Stack();
+
+				currentState.CanAcceptTokens = true;
+				currentState.CanSelectBlock = true;
+
+				stateStack.Push(currentState);
+			}
+
+			State parentState {
+				get {
+					return (State)stateStack.Peek();
+				}
+			}
+
+			public bool IsAcceptingTokens {
+				get {
+					return currentState.CanAcceptTokens;
+				}
+			}
+
+			public void PositionCursorAtNextPreProcessorDirective()
+			{
+				lexer.PositionCursorAtNextPreProcessorDirective();
+			}
+
+			public void PositionTokenizerCursor(IfElseStateMachine.Token tok, BoolLiteral expr)
+			{
+				if(tok == IfElseStateMachine.Token.ENDIF) {
+					currentState = (State)stateStack.Pop();
+
+					if(currentState.CanAcceptTokens)
+						return;
+					else {
+						PositionCursorAtNextPreProcessorDirective();
+						return;
+					}
+				}
+				
+				if(tok == IfElseStateMachine.Token.IF) {
+					stateStack.Push(currentState);
+					
+					currentState.CanAcceptTokens = parentState.CanAcceptTokens;
+					currentState.CanSelectBlock = true;
+				}
+			
+				if(parentState.CanAcceptTokens && 
+				    currentState.CanSelectBlock && (bool)(expr.GetValue()) ) {
+				    
+				    currentState.CanAcceptTokens = true;
+				    currentState.CanSelectBlock = false; 
+				    return;
+				}
+				else {
+					currentState.CanAcceptTokens = false;
+					PositionCursorAtNextPreProcessorDirective();
+					return;
+				}
+			}
+		}
+
+		bool allow_global_attribs = true;
+
+		bool expecting_global_attribs = false;
+		bool expecting_local_attribs = false;
+
+		bool local_attrib_section_added = false;
+%}
+
+%token EOF
+%token NONE   /* This token is never returned by our lexer */
+%token ERROR  // This is used not by the parser, but by the tokenizer.
+	      // do not remove.
+
+/*
+ *These are the MonoBASIC keywords
+ */
+%token ADDHANDLER
+%token ADDRESSOF
+%token ALIAS
+%token AND
+%token ANDALSO
+%token ANSI
+%token AS
+%token ASSEMBLY
+%token AUTO
+%token BINARY
+%token BOOLEAN	
+%token BYREF
+%token BYTE
+%token BYVAL	
+%token CALL
+%token CASE	
+%token CATCH	
+%token CBOOL
+%token CBYTE
+%token CCHAR	
+%token CDATE
+%token CDEC
+%token CDBL
+%token CHAR	
+%token CINT
+%token CLASS
+%token CLNG
+%token COBJ
+%token COMPARE	
+%token CONST	
+%token CSHORT	
+%token CSNG
+%token CSTR
+%token CTYPE
+%token DATE
+%token DECIMAL	
+%token DECLARE
+%token DEFAULT	
+%token DELEGATE	
+%token DIM
+%token DIRECTCAST
+%token DO	
+%token DOUBLE	
+%token EACH	
+%token ELSE
+%token ELSEIF
+%token END
+%token END_EOL
+%token ENDIF
+%token ENUM	
+%token EOL
+%token ERASE
+%token ERROR
+%token EVENT
+%token EXIT	
+%token EXPLICIT	
+%token FALSE	
+%token FINALLY	
+%token FOR	
+%token FRIEND
+%token FUNCTION
+%token GET
+%token GETTYPE
+%token GOSUB
+%token GOTO	
+%token HANDLES
+%token IF	
+%token IMPLEMENTS
+%token IMPORTS	
+%token IN	
+%token INHERITS
+%token INTEGER	
+%token INTERFACE
+%token IS
+%token LET
+%token LIB	
+%token LIKE	
+%token LONG	
+%token LOOP
+%token ME
+%token MOD
+%token MODULE
+%token MUSTINHERIT	
+%token MUSTOVERRIDE
+%token MYBASE
+%token MYCLASS
+%token NAMESPACE
+%token NEW
+%token NEXT	
+%token NOT
+%token NOTHING
+%token NOTINHERITABLE
+%token NOTOVERRIDABLE
+%token OBJECT	
+%token OFF
+%token ON
+%token OPTION	
+%token OPTIONAL	
+%token OR
+%token ORELSE
+%token OVERLOADS
+%token OVERRIDABLE	
+%token OVERRIDES	
+%token PARAM_ARRAY
+%token PRESERVE
+%token PRIVATE	
+%token PROPERTY
+%token PROTECTED
+%token PUBLIC
+%token RAISEEVENT
+%token READONLY	
+%token REDIM
+%token REM
+%token REMOVEHANDLER
+%token RESUME	
+%token RETURN
+%token SELECT
+%token SET
+%token SHADOWS
+%token SHARED
+%token SHORT	
+%token SINGLE
+%token SIZEOF	
+%token STATIC	
+%token STEP
+%token STOP
+%token STRICT	
+%token STRING
+%token STRUCTURE
+%token SUB
+%token SYNCLOCK
+%token TEXT
+%token THEN
+%token THROW
+%token TO
+%token TRUE	
+%token TRY	
+%token TYPEOF	
+%token UNICODE
+%token UNTIL
+%token VARIANT	
+%token WEND
+%token WHEN	
+%token WHILE	
+%token WITH
+%token WITHEVENTS
+%token WRITEONLY
+%token XOR
+%token YIELD // MonoBASIC extension
+
+%token HASH
+
+/* MonoBASIC single character operators/punctuation. */
+
+%token OPEN_BRACKET  "["
+%token CLOSE_BRACKET "]"
+%token OPEN_PARENS   "("
+%token OPEN_BRACE    "{"
+%token CLOSE_BRACE   "}"
+%token CLOSE_PARENS  ")"
+%token DOT           "."
+%token COMMA         ","
+%token COLON         ":"
+
+%token PLUS           "+"
+%token MINUS          "-"
+%token ASSIGN         "="
+%token OP_LT          "<"
+%token OP_GT          ">"
+%token STAR           "*"
+%token DIV            "/"
+%token OP_EXP         "^"
+%token INTERR         "?"
+%token OP_IDIV        "\\" //FIXME: This should be "\"
+%token OP_CONCAT      "&"
+%token EXCLAMATION    "!"
+
+%token PERCENT        "%"
+%token LONGTYPECHAR   "&"
+%token AT_SIGN		  "@"
+%token SINGLETYPECHAR "!"
+%token NUMBER_SIGN    "#"
+%token DOLAR_SIGN     "$"
+
+%token ATTR_ASSIGN	  ":="
+
+/* MonoBASIC multi-character operators. */
+%token OP_LE                  "<="
+%token OP_GE                  ">="
+%token OP_NE                  "<>"
+%token OP_XOR                 "xor"
+//%token OP_MODULUS             //"mod"
+
+/* VB.NET 2003 new bit-shift operators */
+%token OP_SHIFT_LEFT		  "<<"
+%token OP_SHIFT_RIGHT         ">>"
+
+/* Numbers */
+%token LITERAL_INTEGER           "int literal"
+%token LITERAL_SINGLE            "float literal"
+%token LITERAL_DOUBLE            "double literal"
+%token LITERAL_DECIMAL           "decimal literal"
+%token LITERAL_CHARACTER         "character literal"
+%token LITERAL_STRING            "string literal"
+%token LITERAL_DATE              "datetime literal"
+
+%token IDENTIFIER
+%token LABELNAME
+
+/* Add precedence rules to solve dangling else s/r conflict */
+%nonassoc LOWPREC
+%nonassoc IF
+%nonassoc ELSE
+%right ASSIGN
+%left OP_OR
+%left OP_AND
+%left BITWISE_OR
+%left BITWISE_AND
+%left OP_SHIFT_LEFT OP_SHIFT_RIGHT
+%left PLUS MINUS
+%left STAR DIV PERCENT
+%right BITWISE_NOT CARRET UMINUS
+%nonassoc OP_INC OP_DEC
+%left OPEN_PARENS
+%left OPEN_BRACKET OPEN_BRACE
+%left DOT
+%right NOT
+%nonassoc HIGHPREC
+
+%start compilation_unit
+%%
+
+end_of_stmt
+	: logical_end_of_line
+	| COLON
+	;	
+
+logical_end_of_line
+	:
+	  EOL 
+	| logical_end_of_line pp_directive 
+	;
+
+compilation_unit
+	: logical_end_of_line _mark_
+	  opt_option_directives
+	  opt_imports_directives 
+	  declarations 
+	  EOF
+	  {
+		$$=$4;
+	  }
+	| logical_end_of_line _mark_ 
+	  opt_option_directives
+	  opt_imports_directives 
+	  opt_attributes
+	  EOF
+	  {
+		/* ????? */ ;
+	  }
+	;
+	  
+opt_option_directives
+	: /* empty */
+	| option_directives
+	;
+	
+option_directives
+	: option_directive
+	| option_directives option_directive
+	;
+	
+option_directive
+	: option_explicit_directive
+	| option_strict_directive
+	| option_compare_directive
+	| OPTION _mark_ logical_end_of_line
+		{
+		 Report.Error(30206 ,(Location)$2, "Option must be followed by 'Compare' or 'Explicit' or 'Strict'");
+		}
+	| OPTION _mark_ IDENTIFIER logical_end_of_line
+		{
+		 Report.Error(30206 ,(Location)$2, "Option must be followed by 'Compare' or 'Explicit' or 'Strict'");
+		}
+	;
+	
+on_off
+	: /* empty */
+	  {
+		  $$ = (object)true;
+	  }
+	| ON
+	  {
+		  $$ = (object)true;
+	  }
+	| OFF
+	  {
+		  $$ = (object)false;
+	  }
+	;
+	  
+text_or_binary
+	: BINARY
+	  {
+		  $$ = (object)true;
+	  }
+	| TEXT
+	  {
+		  $$ = (object)false;
+	  }
+	;
+	  
+option_explicit_directive
+	: OPTION EXPLICIT _mark_ on_off logical_end_of_line
+	  {
+		if (!UseExtendedSyntax)
+			OptionExplicit = (bool)$4;
+		else
+			Report.Warning (
+				9999, (Location)$3, 
+				"In MonoBASIC extended syntax explicit declaration is always required. So OPTION EXPLICIT is deprecated");
+	  }
+	;
+	  
+			
+option_strict_directive
+	: OPTION STRICT _mark_ on_off logical_end_of_line
+	  {
+		if (!UseExtendedSyntax)
+			OptionStrict = (bool)$4;
+		else
+			Report.Warning (
+				9999, (Location)$3, 
+				"In MonoBASIC extended syntax strict assignability is always required. So OPTION STRICT is deprecated");
+	  }
+	;
+	  
+option_compare_directive
+	: OPTION COMPARE text_or_binary logical_end_of_line
+	  {
+		OptionCompareBinary = (bool)$3;
+	  }
+	;
+
+opt_declarations
+	: /* empty */
+	| declarations
+	;		
+
+declarations
+	: declaration
+	| declarations declaration
+	;
+	
+declaration
+	: declaration_qualifiers
+	  {
+	  	// FIXME: Need to check declaration qualifiers for multi-file compilation
+	  	// FIXME: Qualifiers cannot be applied to namespaces
+	  	allow_global_attribs = false;
+	  }
+	  namespace_declaration
+	|declaration_qualifiers _mark_ 
+	  {
+		  // FIXME: Need to check declaration qualifiers for multi-file compilation
+		  allow_global_attribs = false;
+	  }
+	  type_spec_declaration
+	  {
+		string name = "";
+		int mod_flags;
+
+		if ($4 is Class || $4 is Struct || $4 is Module ){
+			TypeContainer c = (TypeContainer) $4;
+			mod_flags = c.ModFlags;
+			name = c.Name;
+		} else
+			break;
+
+		if ((mod_flags & (Modifiers.PRIVATE)) != 0){
+			Report.Error (
+				31089, (Location)$2, 
+				"Namespace elements cannot be explicitly " +
+			        "declared private in '" + name + "'");
+			}
+		else if ((mod_flags & (Modifiers.PROTECTED)) != 0){
+			Report.Error (
+				31047, (Location)$2, 
+				"Namespace elements cannot be explicitly " +
+			        "declared protected in '" + name + "'");
+		}
+	  }
+	;
+
+identifier
+	: IDENTIFIER
+	| BINARY
+	| TEXT
+	| COMPARE
+	| EXPLICIT
+	| OFF
+	;
+
+type_character
+	: PERCENT 			{ $$ = typeof (int); }
+	| LONGTYPECHAR 			{ $$ = typeof (long); }
+	| AT_SIGN		 	{ $$ = typeof (decimal); }
+	| SINGLETYPECHAR 		{ $$ = typeof (float); }
+	| NUMBER_SIGN 			{ $$ = typeof (double); }
+	| DOLAR_SIGN 			{ $$ = typeof (string); }
+	;	
+	
+opt_type_character
+	: /* empty */			{ $$ = null; }
+	| type_character		{ $$ = $1; }
+	;
+	
+
+qualified_identifier
+	: identifier 
+	| qualified_identifier DOT identifier // FIXME: It should be qualified_identifier DOT identifier-or-keyword
+	  {
+	    $$ = (($1).ToString ()) + "." + ($3.ToString ()); 
+	  }
+	;
+	
+opt_imports_directives
+	: /* empty */
+	| imports_directives
+	;
+
+imports_directives
+	: imports_directive 
+	| imports_directives imports_directive 
+	;
+
+imports_directive
+	: IMPORTS imports_terms logical_end_of_line
+	;
+
+imports_terms
+	: imports_term
+	| imports_terms COMMA imports_term
+	;
+	
+imports_term
+	: namespace_or_type_name 
+	  {
+		RootContext.SourceBeingCompiled.Imports ((string) $1, lexer.Location);
+	  }
+	| identifier _mark_ ASSIGN namespace_or_type_name 
+	  {
+		RootContext.SourceBeingCompiled.ImportsWithAlias ((string) $1, (string) $4, (Location)$2);
+	  }
+	| identifier _mark_ ASSIGN
+	  {
+		Report.Error(30203, (Location)$2, "Alias Statement no complete: Expression Expected");
+   	  }
+	| _mark_ /* empty */ 
+	  {
+		Report.Error(30203, (Location)$1, "No namespace imported: Expression Expected");
+   	  }
+	;
+
+opt_params
+        : /* empty */   { $$ = Parameters.EmptyReadOnlyParameters; }
+        | OPEN_PARENS CLOSE_PARENS      { $$ = Parameters.EmptyReadOnlyParameters; }
+        | OPEN_PARENS _mark_ opt_formal_parameter_list CLOSE_PARENS     { $$ = $3; }
+        | OPEN_PARENS _mark_  
+          {
+                Report.Error(30203,(Location)$2, "Identifier Expected");
+                $$ = Parameters.EmptyReadOnlyParameters;
+          }
+        | OPEN_PARENS _mark_ opt_formal_parameter_list error
+          {
+                Report.Error(30198,(Location)$2, "'(' is not having a matching ')'");
+                $$ = $3;
+          }
+        | error _mark_ opt_formal_parameter_list CLOSE_PARENS
+          {
+                Report.Error(30205,(Location)$2, "')' is not having a matching '('");
+                $$ = $3;
+          }
+        ;
+
+opt_attributes
+ 	: /* empty */
+ 	| attribute_sections 	
+	  { 
+	  	$$ = $1; 
+		local_attrib_section_added = false;
+	  }
+ 	;
+
+attribute_sections
+	:  attribute_section	
+	  { 
+	  	$$ = $1;
+		if ($1 == null) {
+			expecting_local_attribs = false;
+			expecting_global_attribs = false;
+			break;
+		}
+		
+		if (expecting_local_attribs) {
+			local_attrib_section_added = true;
+			allow_global_attribs = false;
+
+			$$ = new Attributes ((ArrayList) $1);
+		}	
+
+		if (expecting_global_attribs) {
+			$$ = null;
+			CodeGen.AddGlobalAttributes ((ArrayList) $1);
+		}
+
+		expecting_local_attribs = false;
+		expecting_global_attribs = false;
+	  }
+	| attribute_sections  
+	   {
+	   	$$ = lexer.Location;
+	   }
+	   attribute_section	
+	  {
+	  	$$ = $1;
+	  	if ($3 != null) {
+			ArrayList attrs = (ArrayList) $3;
+
+			if (expecting_local_attribs) {
+				if (local_attrib_section_added) {
+					expecting_local_attribs = false;
+					expecting_global_attribs = false;
+					Report.Error (30205, (Location) $2, "Multiple attribute sections may not be used; Coalesce multiple attribute sections in to a single attribute section");
+					break;
+				}
+
+				if ($1 == null)
+					$$ = new Attributes (attrs);
+				else 
+					((Attributes) $1).Add (attrs);
+
+				local_attrib_section_added = true;
+				allow_global_attribs = false;
+			}
+
+			if (expecting_global_attribs) {
+				$$ = null;
+				CodeGen.AddGlobalAttributes ((ArrayList) $3);
+			}
+  		}	
+
+		expecting_local_attribs = false;
+		expecting_global_attribs = false;
+	  }
+	;
+
+attribute_section
+	: OP_LT _mark_ attribute_list OP_GT opt_end_of_stmt
+ 	  {
+ 	  	$$ = null;
+		if ($3 != null) {
+			if (expecting_global_attribs && !(bool) $5) {
+				Report.Error (30205, (Location)$2, "End of statement expected");
+				break;
+			}
+			
+			if (expecting_local_attribs)  {
+				if ((bool) $5) {
+					Report.Error (32035, (Location)$2, "Use a line continuation after the attribute specifier to apply it to the following statement.");
+					break;
+				}
+			}
+
+			$$ = $3;
+		}
+ 	  }
+ 	; 
+
+opt_end_of_stmt
+	: /* empty */ { $$ = false; }
+	| end_of_stmt	{ $$ = true; }
+	;
+
+attribute_list
+ 	: attribute 
+ 	  {
+ 	  	ArrayList attrs = null;
+ 	  	if ($1 != null) {
+	 		attrs = new ArrayList ();
+ 			attrs.Add ($1);
+  		}
+ 		$$ = attrs;
+ 	  }	
+ 	| attribute_list COMMA attribute
+ 	  {
+ 	  	ArrayList attrs = null;
+		
+ 	  	if ($3 != null) {
+	 		attrs = ($1 == null) ? new ArrayList () : (ArrayList) $1;
+ 			attrs.Add ($3);
+  		}
+
+ 		$$ = attrs;
+ 	  }	
+ 	;
+
+attribute 
+ 	:  namespace_or_type_name
+ 	   {
+ 		$$ = lexer.Location;
+ 	   }
+ 	   opt_attribute_arguments
+ 	   {
+ 	   	$$ = null;
+		
+ 	   	if (expecting_global_attribs)
+			Report.Error (32015, (Location) $2, "Expecting Assembly or Module attribute specifiers");
+		else {
+			expecting_local_attribs = true;
+	 		$$ = new Attribute ((string) $1, (ArrayList) $3, (Location) $2);
+		}
+ 	   }
+	  | attribute_target_specifier 
+	    {
+	    	$$ = lexer.Location;
+	    }
+	    COLON 
+	    namespace_or_type_name
+	   {
+		  $$ = lexer.Location;
+	   }
+	   opt_attribute_arguments
+	   {
+	   	$$ = null;
+
+	   	string attribute_target = (string) $1;
+	   	if (attribute_target != "assembly" && attribute_target != "module") {
+			Report.Error (29999, lexer.Location, "`" + (string)$1 + "' is an invalid attribute modifier");
+			break;
+   		}
+   		if (!allow_global_attribs) {
+			Report.Error (30637, (Location) $2, "Global attribute statements must precede any declarations in a file");
+			break;
+		}
+
+		if (expecting_local_attribs) {
+			Report.Error (30183, (Location) $2, "Global attributes cannot be combined with local attributes");
+			break;
+		}			
+
+		expecting_global_attribs = true;
+		$$ = new Attribute (attribute_target, (string) $4, (ArrayList) $6, (Location) $5);
+	    }	
+ 	;
+
+attribute_target_specifier
+	:  ASSEMBLY	{ $$ = "assembly"; }
+	| MODULE	{ $$ = "module"; }
+	| namespace_or_type_name
+	;
+	
+			
+opt_attribute_arguments
+	: /* empty */ 	{ $$ = null; }
+	| OPEN_PARENS opt_attribute_arguments_list CLOSE_PARENS
+	  {
+		$$ = $2;
+	  }	
+	;
+
+opt_attribute_arguments_list
+	: /* empty */
+	| attribute_arguments_list
+	;		
+	
+attribute_arguments_list
+	: positional_argument_list
+	  {
+		ArrayList args = new ArrayList ();
+		args.Add ($1);
+	
+		$$ = args;
+	  }
+        | positional_argument_list COMMA named_argument_list
+	  {
+		ArrayList args = new ArrayList ();
+		args.Add ($1);
+		args.Add ($3);
+
+		$$ = args;
+	  }
+        | named_argument_list
+	  {
+		ArrayList args = new ArrayList ();
+		args.Add (null);
+		args.Add ($1);
+		
+		$$ = args;
+	  }
+        ;
+
+positional_argument_list
+	: constant_expression
+	  {
+		ArrayList args = new ArrayList ();
+		args.Add (new Argument ((Expression) $1, Argument.AType.Expression));
+
+		$$ = args;
+	  }
+        | positional_argument_list COMMA constant_expression
+	 {
+		ArrayList args = (ArrayList) $1;
+		args.Add (new Argument ((Expression) $3, Argument.AType.Expression));
+
+		$$ = args;
+	 }
+        ;
+
+named_argument_list
+	: named_argument
+	  {
+		ArrayList args = new ArrayList ();
+		args.Add ($1);
+
+		$$ = args;
+	  }
+        | named_argument_list COMMA named_argument
+	  {	  
+		ArrayList args = (ArrayList) $1;
+		args.Add ($3);
+
+		$$ = args;
+	  }
+        ;
+
+named_argument
+	: identifier ATTR_ASSIGN constant_expression //FIXME: It should be identifier_or_keyword ATTR_ASSIGN constant_expression
+	  {
+		$$ = new DictionaryEntry (
+			(string) $1, 
+			new Argument ((Expression) $3, Argument.AType.Expression));
+	  }
+	;
+				
+namespace_declaration
+	: NAMESPACE _mark_ qualified_identifier logical_end_of_line
+	  {
+		push_into_stack((int)Start_block.NAMESPACE, (Location)$2);
+		current_namespace = RootContext.Tree.RecordNamespace(current_namespace, name, (string)$3);
+		
+	  } 
+	  opt_declarations
+	  opt_end_block
+	  {
+		pop_out_of_stack((int)$7, lexer.Location);	
+	  }
+	  logical_end_of_line
+	  { 
+		current_namespace = current_namespace.Parent;
+	  }
+	;
+
+declaration_qualifiers
+	: opt_attributes 
+	  opt_modifiers 
+	  { 
+		current_attributes = (Attributes) $1; 
+	  	current_modifiers = (int) $2; 
+	  }	  
+	;
+
+type_spec_declaration
+	: class_declaration
+	| module_declaration
+	| interface_declaration
+	| delegate_declaration
+	| struct_declaration
+	| enum_declaration
+	;
+
+class_declaration
+	: CLASS identifier _mark_ end_of_stmt opt_inherits opt_implements
+	  {
+		// Module members are static by default, but Class *can't* be declared static
+		// so we must fix it, if mbas was the one actually responsible for this
+		// instead of triggering an error.
+		push_into_stack((int)Start_block.CLASS, (Location)$3);
+		
+		if (implicit_modifiers && ((current_modifiers & Modifiers.STATIC) != 0))
+			current_modifiers = (current_modifiers & ~Modifiers.STATIC);
+	  
+		Class new_class;
+		string name;
+		
+		name = MakeName ((string) $2);
+		new_class = new Class (current_container, name, current_modifiers, 
+				       (Attributes) current_attributes, (Location)$3);
+
+		current_container = new_class;
+		current_container.Namespace = current_namespace;
+		RootContext.Tree.RecordDecl (name, new_class);
+	  }
+	  opt_class_member_declarations
+	  opt_end_block
+	  {
+		pop_out_of_stack((int)$9, lexer.Location);
+	  }
+	  logical_end_of_line
+	  {
+		Class new_class = (Class) current_container;
+		
+		ArrayList bases = (ArrayList) $5;
+
+		ArrayList ifaces = (ArrayList) $6;
+		if (ifaces != null){
+			if (bases != null)	
+				bases.AddRange(ifaces);
+			else
+				bases = ifaces;
+		}
+		new_class.Bases = bases;
+	
+		current_container = current_container.Parent;
+		CheckDef (current_container.AddClass (new_class), new_class.Name, new_class.Location);
+
+		$$ = new_class;
+	  }
+	;
+
+opt_inherits
+	: /* empty */				{ $$ = null; }
+	| INHERITS type_list end_of_stmt 	{ $$ = $2; }
+	;
+
+opt_implements
+	: /* empty */				{ $$ = null; }
+	| IMPLEMENTS type_list end_of_stmt	 	{ $$ = $2; }
+	;
+
+opt_modifiers
+	: /* empty */		{ $$ = (int) 0; current_modifiers = 0; }
+	| modifiers 		{ $$ = $1; current_modifiers = (int) $1; }
+	;
+	
+modifiers
+	: modifier
+	| modifiers modifier
+	  { 
+		int m1 = (int) $1;
+		int m2 = (int) $2;
+
+		if ((m1 & m2) != 0) {
+			Location l = lexer.Location;
+			Report.Error (1004, l, "Duplicate modifier: `" + Modifiers.Name (m2) + "'");
+		}
+		$$ = (int) (m1 | m2);
+	  }
+        ;
+
+modifier
+	: PUBLIC			{ $$ = Modifiers.PUBLIC; }
+	| PROTECTED			{ $$ = Modifiers.PROTECTED; }
+	| PRIVATE			{ $$ = Modifiers.PRIVATE; }
+	| SHARED			{ $$ = Modifiers.STATIC; }
+	| FRIEND			{ $$ = Modifiers.INTERNAL; }
+	| NOTINHERITABLE		{ $$ = Modifiers.SEALED; } 
+	| OVERRIDABLE			{ $$ = Modifiers.VIRTUAL; }
+	| NOTOVERRIDABLE		{ $$ = Modifiers.NONVIRTUAL; }
+	| OVERRIDES 			{ $$ = Modifiers.OVERRIDE; }
+	| OVERLOADS			{ $$ = Modifiers.NEW; }
+	| SHADOWS			{ $$ = Modifiers.SHADOWS; }
+	| MUSTINHERIT			{ $$ = Modifiers.ABSTRACT; }
+	| READONLY 			{ $$ = Modifiers.READONLY; }
+	| DEFAULT 			{ $$ = Modifiers.DEFAULT; }
+	| WRITEONLY			{ $$ = Modifiers.WRITEONLY; }
+	;
+
+module_declaration
+	: MODULE _mark_ identifier logical_end_of_line
+	  { 
+		push_into_stack((int)Start_block.MODULE, (Location)$2);	
+		Module new_module;
+		string name;
+		name = MakeName((string) $3);
+		new_module = new Module(current_container, 
+					name, 
+					current_modifiers, // already checks then
+					(Attributes) current_attributes,
+					(Location)$2);
+		current_container = new_module;
+		current_container.Namespace = current_namespace;
+		RootContext.Tree.RecordDecl(name, new_module);
+	  }
+	  opt_module_member_declarations
+	  opt_end_block
+	  {
+		pop_out_of_stack((int)$7, lexer.Location);	
+	  }
+	  logical_end_of_line
+	  {
+		Module new_module = (Module)current_container;
+
+		current_container = current_container.Parent;
+		CheckDef (current_container.AddClass(new_module), new_module.Name, new_module.Location);
+		
+		TypeManager.AddStandardModule(new_module);
+
+		$$ = new_module;
+	  }
+	;
+
+opt_module_member_declarations
+	: /* empty */
+	| module_member_declarations
+	;
+
+module_member_declarations
+	: module_member_declaration
+	| module_member_declarations module_member_declaration
+	;
+
+module_member_declaration
+	:  opt_attributes
+	   opt_modifiers
+	   { 
+	   	current_attributes = (Attributes) $1;
+	   	current_modifiers = ((int)$2) | Modifiers.STATIC; 
+		bool explicit_static = (((int) $2 & Modifiers.STATIC) > 0);
+		implicit_modifiers = (!explicit_static);
+	   }
+	   module_member_declarator
+	   {
+	   	implicit_modifiers = false;
+	   	$$ = $3;
+	   }
+	;
+
+module_member_declarator
+	:  constructor_declaration
+	|  method_declaration
+	   { 
+	   	Method method = (Method) $1;
+	   	CheckDef (current_container.AddMethod (method), method.Name, method.Location);
+	   }	
+	|  field_declaration
+	|  withevents_declaration	/* This is a field but must be treated specially, see below */
+	|  constant_declaration
+	|  property_declaration			
+	|  event_declaration	
+	|  type_spec_declaration			
+	;
+	
+constant_declaration
+	: CONST constant_declarators end_of_stmt
+	{
+		// Module members are static by default, but constants *can't* be declared static
+		// so we must fix it, if mbas was the one actually responsible for this
+		// instead of triggering an error.
+		if (implicit_modifiers && ((current_modifiers & Modifiers.STATIC) != 0))
+			current_modifiers = (current_modifiers & ~Modifiers.STATIC);
+		
+		int mod = (int) current_modifiers;
+		
+		// Structure members are Public by default			
+		if ((current_container is Struct) && (mod == 0))
+			mod = Modifiers.PUBLIC;			
+
+		ArrayList consts = (ArrayList) $2;
+		if(consts.Count > 0) 
+		{
+			VariableDeclaration.FixupTypes ((ArrayList) $2);
+			VariableDeclaration.FixupArrayTypes ((ArrayList) $2);
+
+			foreach (VariableDeclaration var in (ArrayList) $2){
+				Location l = var.Location;
+				Const vconstant = new Const ((Expression)var.type, (String)var.identifier, 
+							(Expression)var.expression_or_array_initializer, 
+							mod, (Attributes) null, l);
+
+				CheckDef (current_container.AddConstant (vconstant), vconstant.Name, l);
+			}
+		}
+	}
+	;
+	   
+opt_class_member_declarations
+	: /* empty */
+	| class_member_declarations
+	;
+
+class_member_declarations
+	: class_member_declaration
+	| class_member_declarations class_member_declaration
+	;
+
+class_member_declaration
+	:  opt_attributes
+	   opt_modifiers
+	   { 
+	   	current_attributes = (Attributes) $1;
+	   	current_modifiers = (int) $2;
+	   }
+	   class_member_declarator
+	   {
+	   	$$ = $3;
+	   }
+	;
+
+class_member_declarator
+	:  constructor_declaration
+	|  method_declaration
+	   { 
+	   	Method method = (Method) $1;
+	   	CheckDef (current_container.AddMethod (method), method.Name, method.Location);
+	   }	
+	|  field_declaration
+	|  constant_declaration
+	|  property_declaration			
+	|  event_declaration	
+	|  withevents_declaration	/* This is a field but must be treated specially, see below */
+	|  type_spec_declaration
+	;
+	
+	
+method_declaration
+	: sub_declaration
+	| func_declaration 
+	| must_override_declaration
+	;
+	
+must_override_declaration
+	: must_override_sub_declaration
+	| must_override_func_declaration	
+	;
+	
+must_override_sub_declaration
+	: MUSTOVERRIDE SUB identifier opt_params opt_implement_clause _mark_ logical_end_of_line
+	  {	
+	  	if (current_container is Module)
+	  		Report.Error (30433, (Location)$6, "Methods in a Module cannot be declared 'MustOverride'.");
+	  		
+	  	if (current_container is Struct)
+	  		Report.Error (435, (Location)$6, "Methods in a Structure cannot be declared 'MustOverride'.");
+	  	
+	  	current_modifiers |= Modifiers.ABSTRACT;
+	  			  	
+	  	Method method = new Method (TypeManager.system_void_expr, (int) current_modifiers, (string) $3,
+					    (Parameters) $4, null, (ArrayList) $5, (Location)$6);
+					    
+		if (!(current_container is Class))
+			Report.Error (9999, (Location)$6, "THIS SHOULD NEVER HAPPEN!");		
+			
+		$$ = method; 			    
+	  }
+	;
+
+	
+must_override_func_declaration
+	: MUSTOVERRIDE FUNCTION identifier opt_type_character opt_params _mark_ opt_type_with_ranks opt_implement_clause logical_end_of_line
+	  {	
+		Expression ftype = ($7 == null) ? (($4 == null) ? TypeManager.	
+			system_object_expr : (Expression) TypeManager.TypeToCoreTypeExpr ((Type) $4) ) : (Expression) $7;
+
+	  	if (current_container is Module)
+	  		Report.Error (30433, (Location)$6,"Methods in a Module cannot be declared 'MustOverride'.");
+	  		
+	  	if (current_container is Struct)
+	  		Report.Error (435, (Location)$6,"Methods in a Structure cannot be declared 'MustOverride'.");
+	  			
+		current_modifiers |= Modifiers.ABSTRACT;
+			  			  	
+	  	Method method = new Method ((Expression) ftype, (int) current_modifiers, 
+						(string) $3,(Parameters) $5, null, (ArrayList) $8, 
+						(Location)$6);
+					    
+		if (!(current_container is Class))
+			Report.Error (9999, (Location)$6,"THIS SHOULD NEVER HAPPEN!");
+			
+		$$ = method; 					
+	  }	
+	;
+	
+sub_declaration
+	: SUB identifier _mark_ opt_params opt_evt_handler opt_implement_clause logical_end_of_line
+	  { 
+		push_into_stack((int)Start_block.SUB, (Location)$3);
+	  	current_local_parameters = (Parameters) $4;
+		start_method_block((string) $2); 
+
+		// Structure members are Public by default			
+		if ((current_container is Struct) && (current_modifiers == 0))
+			current_modifiers = Modifiers.PUBLIC;		
+
+	  }
+	  opt_statement_list 
+	  opt_end_block 
+	  {
+		pop_out_of_stack((int)$10, lexer.Location);
+	  }
+	  logical_end_of_line
+	  {
+		Method method = new Method (TypeManager.system_void_expr, (int) current_modifiers, (string) $2,
+					    (Parameters) current_local_parameters, (Attributes) current_attributes, 
+					    (ArrayList) $6, (Location)$3);
+	
+		method.Block = (Block) end_block();
+		
+		if ( ((MethodBlock) method.Block).onerror != null ) {
+			method.Block = ((MethodBlock) method.Block).onerror;
+		}
+		$$ = method;
+
+		if ($5 != null) { 
+		  // we have event handlers to take care of 
+
+		  ArrayList list = (ArrayList) $5; 
+		  Location loc = (Location)$3;
+		  
+		  foreach (Expression handles_exp in list) {
+			  if (handles_exp is MemberAccess) {
+				string evt_def = ((MemberAccess)handles_exp).ToString();
+				int pos = evt_def.LastIndexOf (".");
+				string evt_target = evt_def.Substring (0, pos);
+				bool found = false;
+			
+				if (current_container.Properties != null) {
+					foreach (Property p in current_container.Properties) {
+						if (p.Name == evt_target) {
+							
+
+							Statement addhnd = (Statement) new AddHandler (handles_exp, 
+												DecomposeQI((string) $2, loc), 
+												loc);
+
+							current_container.AddEventHandler (addhnd);
+							found = true;
+							break;
+						}
+					}		
+				}
+				
+				if (!found){
+					Report.Error(30506, (Location)$3,
+							evt_target + " is not declared with WithEvents");
+				}
+			  } else if (handles_exp is BaseAccess) {
+					Statement addhnd = (Statement) new AddHandler (handles_exp, 
+												DecomposeQI((string) $2, loc), 
+												loc);	
+												
+					current_container.AddEventHandler (addhnd);
+			  }
+		  }  
+		}	
+	  }	  
+	;
+
+func_declaration
+	: FUNCTION identifier opt_type_character
+	  opt_params _mark_ opt_type_with_ranks opt_implement_clause logical_end_of_line
+	  { 
+		push_into_stack((int)Start_block.FUNCTION, (Location)$5);
+	  	current_local_parameters = (Parameters) $4;
+		start_method_block((string) $2); 
+				
+		Expression ftype = ($6 == null) ? (($3 == null) ? TypeManager.system_object_expr : (Expression) TypeManager.TypeToCoreTypeExpr ((Type) $3) ) : (Expression) $6;
+
+		// Structure members are Public by default			
+		if ((current_container is Struct) && (current_modifiers == 0))
+			current_modifiers = Modifiers.PUBLIC;			  	
+		// Add local var declaration
+		// for return value
+		ArrayList retval = new ArrayList ();
+		retval.Add (new VariableDeclaration ((string) $2, (Expression) ftype, (Location)$5));
+		Block implicit_block = declare_local_variables ((Expression) ftype, retval, (Location)$5);
+		implicit_block.GetVariableInfo((string) $2).Used = true;
+	  }	  
+	  opt_statement_list
+	  opt_end_block 
+	  {
+		pop_out_of_stack((int)$11, lexer.Location);
+	  }
+	  logical_end_of_line
+	  {
+		Expression ftype = ($6 == null) ? (($3 == null) ? TypeManager.system_object_expr : (Expression) TypeManager.TypeToCoreTypeExpr ((Type) $3) ) : (Expression) $6;
+
+		Method method = new Method ((Expression) ftype, (int) current_modifiers, (string) $2,
+					    (Parameters) current_local_parameters, (Attributes) current_attributes,/* (Attributes) currx ent_attributes,  */
+					    (ArrayList) $7, (Location)$5);
+		method.Block = end_block();
+		$$ = method;
+	  }	  
+	;		
+
+struct_declaration
+	: STRUCTURE _mark_ identifier end_of_stmt
+	  opt_implement_clause
+	  {
+		push_into_stack((int)Start_block.STRUCTURE, (Location)$2);
+		Struct new_struct;
+		string full_struct_name = MakeName ((string) $3);
+		
+		// Module members are static by default, but structures *can't* be declared static
+		// so we must fix it, if mbas was the one actually responsible for this
+		// instead of triggering an error.
+		if (implicit_modifiers && ((current_modifiers & Modifiers.STATIC) != 0))
+			current_modifiers = (current_modifiers & ~Modifiers.STATIC);
+			
+		new_struct = new Struct (current_container, full_struct_name, 
+					 (int) current_modifiers,
+					 (Attributes) current_attributes, (Location)$2);
+		current_container = new_struct;
+		current_container.Namespace = current_namespace;
+		RootContext.Tree.RecordDecl (full_struct_name, new_struct);
+	  }
+	  opt_struct_member_declarations
+	  {
+		Struct new_struct = (Struct) current_container;
+
+		if ($5 != null)
+			new_struct.Bases = (ArrayList) $5;
+
+		current_container = current_container.Parent;
+		CheckDef (current_container.AddStruct (new_struct), new_struct.Name, new_struct.Location);
+		$$ = new_struct;
+	  }
+	  opt_end_block 
+	  {
+		pop_out_of_stack((int)$9, lexer.Location);
+	  }
+	  logical_end_of_line
+	;
+	
+opt_struct_member_declarations
+	: /* empty */
+	| struct_member_declarations
+	;
+
+struct_member_declarations
+	: struct_member_declaration
+	| struct_member_declarations struct_member_declaration
+	;
+
+struct_member_declaration
+	: opt_modifiers
+	  struct_member_declarator
+	;
+	
+struct_member_declarator	
+	: field_declaration
+	| constant_declaration
+	| constructor_declaration
+	| method_declaration
+	  { 
+	   	Method method = (Method) $1;
+	   	CheckDef (current_container.AddMethod (method), method.Name, method.Location);
+	  }	
+	| property_declaration
+	| event_declaration
+	| type_spec_declaration
+
+	/*
+	 * This is only included so we can flag error 575:
+	 * destructors only allowed on class types
+	 */
+	//| destructor_declaration
+	;
+	
+event_declaration
+	: EVENT identifier _mark_ AS type opt_implement_clause logical_end_of_line
+	  {
+	  	VariableDeclaration var = new VariableDeclaration ((string) $2, (Expression) $5, (Location)$3);
+
+		Event e = new Event ((Expression) $5, var.identifier, 
+				     null, current_modifiers, 
+				     current_attributes, (ArrayList) $6,
+				     (Location)$3);
+
+		CheckDef (current_container.AddEvent (e), e.Name, e.Location);
+	  }
+	| EVENT identifier _mark_ opt_params opt_implement_clause logical_end_of_line
+	  {
+		string delName = null;
+
+		if ($5 == null) {
+			delName = (string) $2;
+			delName = delName + "EventHandler";
+			int modifiers = (implicit_modifiers) ? (current_modifiers & ~ (Modifiers.STATIC) ): current_modifiers;
+			Mono.MonoBASIC.Delegate del = new Mono.MonoBASIC.Delegate 
+							(current_container, TypeManager.system_void_expr, 
+							(int) modifiers, MakeName(delName), (Parameters) $4, 
+							(Attributes) current_attributes, (Location)$3);
+						     	  
+			del.Namespace = current_namespace;
+			CheckDef (current_container.AddDelegate (del), del.Name, (Location)$3);
+		} else {
+			ArrayList impls = (ArrayList) $5;
+			if (impls.Count > 1) {
+				string expstr = "Event '" + ((Expression) impls[1]).ToString () +
+					"' can not be implemented with Event '" +
+					(string) $2 + "', since it's delegate type does not match " +
+					"with the delegate type of '" + ((Expression) impls[0]).ToString () + "'";
+				Report.Error (31407, (Location)$3, expstr);
+			}			
+			Expression impl = (Expression) impls[0];  
+			delName = impl.ToString();
+			delName = delName.Substring (delName.LastIndexOf(".") + 1);
+			delName = delName + "EventHandler";
+		}
+		
+		Event e = new Event (DecomposeQI (delName, (Location)$3),
+					 (string) $2, 
+				     null, current_modifiers, 
+				     current_attributes, (ArrayList) $5, 
+				     (Location)$3);
+
+		CheckDef (current_container.AddEvent (e), e.Name, e.Location);
+	  }
+	;
+	
+enum_declaration
+	: ENUM _mark_ identifier opt_type_spec logical_end_of_line
+	  opt_enum_member_declarations 
+	  { 
+		push_into_stack((int)Start_block.ENUM, (Location)$2);
+		Location enum_location = (Location)$2;
+		string full_name = MakeName ((string) $3);
+		Expression enum_type = ($4 == null) ? TypeManager.system_int32_expr : (Expression) $4;
+		ArrayList enum_members = (ArrayList) $6;
+		
+		if (enum_members.Count == 0)
+			Report.Error (30280, enum_location,
+				"Enum can not have empty member list");
+		
+		// Module members are static by default, but enums *can't* be declared static
+		// so we must fix it if mbas was the one actually responsible for this
+		// instead of triggering an error.
+		if (implicit_modifiers && ((current_modifiers & Modifiers.STATIC) != 0))
+			current_modifiers = (current_modifiers & ~Modifiers.STATIC);
+			
+		Mono.MonoBASIC.Enum e = new Mono.MonoBASIC.Enum (current_container, enum_type, 
+					(int) current_modifiers, full_name, 
+				   	(Attributes) current_attributes, enum_location);
+		
+		foreach (VariableDeclaration ev in enum_members) {
+			Location loc = (Location) ev.Location;
+
+			CheckDef (e.AddEnumMember (ev.identifier, 
+						   (Expression) ev.expression_or_array_initializer,
+						   loc, ev.OptAttributes), ev.identifier, loc);
+		}
+
+		e.Namespace = current_namespace;
+
+		CheckDef (current_container.AddEnum (e), full_name, enum_location);
+		RootContext.Tree.RecordDecl (full_name, e);
+
+	  }
+	  opt_end_block 
+	  {
+		pop_out_of_stack((int)$8,lexer.Location);
+	  }
+  	  logical_end_of_line
+	;
+
+opt_enum_member_declarations
+	: /* empty */			{ $$ = new ArrayList (); }
+	| enum_member_declarations  	{ $$ = $1; }
+	;
+
+enum_member_declarations
+	: enum_member_declaration 
+	  {
+		ArrayList l = new ArrayList ();
+
+		l.Add ($1);
+		$$ = l;
+	  }
+	| enum_member_declarations  enum_member_declaration
+	  {
+		ArrayList l = (ArrayList) $1;
+
+		l.Add ($2);
+
+		$$ = l;
+	  }
+	;
+
+enum_member_declaration
+	: opt_attributes identifier _mark_ logical_end_of_line
+	  {
+		$$ = new VariableDeclaration ((string) $2, null, (Location)$3, (Attributes) $1);
+	  }
+	| opt_attributes identifier
+	  {
+		  $$ = lexer.Location;
+	  }
+          ASSIGN expression logical_end_of_line
+	  { 
+		$$ = new VariableDeclaration ((string) $2, (Expression)$5, (Location)$3, (Attributes) $1);
+	  }
+	;
+		
+interface_declaration
+	: INTERFACE _mark_ identifier logical_end_of_line
+	  {
+		push_into_stack((int)Start_block.INTERFACE, (Location)$2);
+		Interface new_interface;
+		string full_interface_name = MakeName ((string) $3);
+
+		int modifiers = (implicit_modifiers) ?  (current_modifiers & ~ (Modifiers.STATIC) ) : current_modifiers;
+		new_interface = new Interface (current_container, full_interface_name, modifiers,
+					       (Attributes) current_attributes, (Location)$2);
+		current_interface = new_interface;
+		new_interface.Namespace = current_namespace;
+		RootContext.Tree.RecordDecl (full_interface_name, new_interface);
+	  }
+	  opt_interface_base
+	  interface_body
+ 	  { 
+		Interface new_interface = (Interface) current_interface;
+
+		if ($6 != null)
+			new_interface.Bases = (ArrayList) $6;
+
+		current_interface = null;
+
+		CheckDef (current_container.AddInterface (new_interface),new_interface.Name, new_interface.Location);
+	  }
+	  opt_end_block 
+	  {
+		pop_out_of_stack((int)$9, lexer.Location);
+	 }
+	  logical_end_of_line
+	;
+
+opt_interface_base
+	: /* empty */			  { $$ = null; }
+	| interface_bases
+	;
+
+interface_bases
+	: interface_base
+	| interface_bases interface_base
+	  {
+		ArrayList bases = (ArrayList) $1;
+		bases.AddRange ((ArrayList) $2);
+		$$ = bases;
+	  }
+	;
+
+interface_base
+	: INHERITS type_list logical_end_of_line  { $$ = $2; }
+	;
+
+interface_body
+	: opt_interface_member_declarations
+	| opt_interface_declaration
+	;
+
+opt_interface_declaration
+	: INTERFACE _mark_ identifier logical_end_of_line
+	  {
+		push_into_stack((int)Start_block.INTERFACE, (Location)$2);
+		Interface new_interface;
+		string full_interface_name = MakeName ((string) $3);
+
+		int modifiers = (implicit_modifiers) ?  (current_modifiers & ~ (Modifiers.STATIC) ) : current_modifiers;
+		new_interface = new Interface (current_interface, full_interface_name, modifiers,
+					       (Attributes) current_attributes, (Location)$2);
+
+		CheckDef (current_interface.AddInterface (new_interface),new_interface.Name, new_interface.Location);
+		
+		current_interface = new_interface;
+
+		new_interface.Namespace = current_namespace;
+		RootContext.Tree.RecordDecl (full_interface_name, new_interface);
+	  }
+	  opt_interface_base
+	  interface_body
+ 	  { 
+		Interface new_interface = (Interface) current_interface;
+
+		if ($6 != null)
+			new_interface.Bases = (ArrayList) $6;
+	  }
+	  opt_end_block 
+	  {
+		current_interface = (Interface)current_interface.Parent;
+
+		pop_out_of_stack((int)$9, lexer.Location);
+	 }
+	  logical_end_of_line
+	;
+
+
+
+
+opt_interface_member_declarations
+	: /* empty */
+	| interface_member_declarations
+	;
+
+interface_member_declarations
+	: interface_member_declaration
+	| interface_member_declarations interface_member_declaration
+	;
+
+interface_member_declaration
+	: opt_attributes
+	  opt_modifiers
+	  {
+	   	current_attributes = (Attributes) $1;
+	   	current_modifiers = ((int)$2) | Modifiers.ABSTRACT; 
+	  }
+	  interface_member_declarator
+	  {
+	   	$$ = $3;
+	  }
+	;
+	
+interface_member_declarator
+	: interface_method_declaration		
+	  { 
+		Method m = (Method) $1;
+		CheckDef (current_interface.AddMethod (m), m.Name, m.Location);
+	  }
+	| interface_property_declaration	
+	| interface_event_declaration 
+	;
+
+interface_method_declaration
+	: SUB identifier opt_params _mark_ logical_end_of_line
+	  {
+	  	Method method = new Method (TypeManager.system_void_expr, (int) current_modifiers, (string) $2,
+					    (Parameters) $3, current_attributes, null, (Location)$4);
+		
+		$$ = method;
+	  }
+	| FUNCTION identifier opt_type_character opt_params _mark_ opt_type_with_ranks logical_end_of_line
+	  {
+		Expression ftype = ($6 == null) ? (($3 == null) ? TypeManager.	
+			system_object_expr : (Expression) TypeManager.TypeToCoreTypeExpr ((Type) $3) ) : (Expression) $6;
+		
+	  	Method method = new Method ((Expression) ftype, (int) current_modifiers, 
+						(string) $2,(Parameters) $4, current_attributes, null, 
+						(Location)$5);
+		
+		$$ = method;
+	  }
+	;
+
+interface_property_declaration
+	: PROPERTY identifier _mark_ opt_type_character opt_property_parameters opt_type_with_ranks logical_end_of_line
+	  {
+		Expression ftype = ($6 == null) ? (($4 == null) ? 
+				TypeManager.system_object_expr : (Expression) TypeManager.TypeToCoreTypeExpr ((Type) $4) ) : (Expression) $6;
+
+		if ( OptionStrict && ($4 == null) && ($6 == null) ) {
+				Report.Error (30210,
+                                                (Location) $3,
+                                                "Option Strict On requires all function and property "+
+                                                "declarations to have an 'As' clause or a type character.");
+		}			
+
+		current_local_parameters = (Parameters) $5;
+		if (current_local_parameters != Parameters.EmptyReadOnlyParameters) { 
+			get_parameters = current_local_parameters.Copy ((Location)$3);
+			set_parameters = current_local_parameters.Copy ((Location)$3);
+			
+			Parameter implicit_value_parameter = new Parameter (
+					ftype, "Value", Parameter.Modifier.NONE, null);
+			
+			set_parameters.AppendParameter (implicit_value_parameter);
+		}
+		else
+		{
+			get_parameters = Parameters.EmptyReadOnlyParameters;
+			set_parameters = new Parameters (null, null ,(Location)$3); 
+			
+			Parameter implicit_value_parameter = new Parameter (
+					ftype, "Value", Parameter.Modifier.NONE, null);
+			
+			set_parameters.AppendParameter (implicit_value_parameter);
+		}
+		lexer.PropertyParsing = true;
+		
+		Accessor get_block = new Accessor (null, null);	
+
+		Accessor set_block = null;
+
+		if ((current_modifiers & Modifiers.READONLY) == 0)
+			set_block = new Accessor (null, null);	
+		
+		int modifiers = (implicit_modifiers) ? (current_modifiers & ~ (Modifiers.STATIC) ): current_modifiers;
+		Property prop = new Property ((Expression) ftype, (string) $2, modifiers,
+					 get_block, set_block, current_attributes, (Location)$3,
+					 null, get_parameters, set_parameters, null);
+    
+		CheckDef (current_interface.AddProperty (prop), prop.Name, (Location)$3);
+		
+		get_implicit_value_parameter_type = null;
+		set_implicit_value_parameter_type = null;
+		get_parameters = null;
+		set_parameters = null;
+		current_local_parameters = null;			
+	  }
+	;
+	
+interface_event_declaration
+	: EVENT identifier AS _mark_ type logical_end_of_line
+	  {
+	  	VariableDeclaration var = new VariableDeclaration ((string) $2, (Expression) $5, (Location)$4);
+
+		Event e = new Event ((Expression) $5, var.identifier, 
+				     null, current_modifiers, 
+				     current_attributes, (Location)$4);
+
+		CheckDef (current_interface.AddEvent (e), e.Name, e.Location);
+
+	  }
+	| EVENT identifier opt_params _mark_ logical_end_of_line
+	  {
+		string delName = (string) $2;
+		delName = delName + "EventHandler";
+		int delModifiers = (current_modifiers & ~Modifiers.ABSTRACT);
+	    Mono.MonoBASIC.Delegate del = new Mono.MonoBASIC.Delegate 
+						(current_container, TypeManager.system_void_expr, 
+					     (int) delModifiers, MakeName(delName), (Parameters) $3, 
+					     (Attributes) current_attributes, (Location)$4);
+					     	  
+		del.Namespace = current_namespace;
+		CheckDef (current_interface.AddDelegate (del), del.Name, (Location)$4);
+	  
+		Event e = new Event (DecomposeQI (delName, (Location)$4),
+					 (string) $2, 
+				     null, current_modifiers, 
+				     current_attributes, (Location)$4);
+
+		CheckDef (current_interface.AddEvent (e), e.Name, e.Location);
+	  }
+	;
+
+property_declaration
+	: abstract_propery_declaration
+	| non_abstract_propery_declaration 
+	;
+	
+abstract_propery_declaration
+	: MUSTOVERRIDE PROPERTY identifier opt_type_character opt_property_parameters _mark_ opt_type_with_ranks logical_end_of_line
+	  {	
+		Expression ftype = ($7 == null) ? (($4 == null) ? 
+				TypeManager.system_object_expr : (Expression) TypeManager.TypeToCoreTypeExpr ((Type) $4) ) : (Expression) $7;
+
+	  	if (current_container is Module)
+	  		Report.Error (30503, (Location) $6 , "Properties in a Module cannot be declared 'MustOverride'.");
+	  		
+	  	if (current_container is Struct)
+	  		Report.Error (435, (Location) $6 ,"Methods in a Structure cannot be declared 'MustOverride'.");
+	  			
+		if ( OptionStrict && ($4 == null) && ($7 == null) ) {
+				Report.Error (30210,
+                                                (Location) $6,
+                                                "Option Strict On requires all function and property "+
+                                                "declarations to have an 'As' clause or a type character.");
+		}			
+
+		current_modifiers |= Modifiers.ABSTRACT;
+		
+		current_local_parameters = (Parameters) $5;
+		if (current_local_parameters != Parameters.EmptyReadOnlyParameters) { 
+			get_parameters = current_local_parameters.Copy (lexer.Location);
+			set_parameters = current_local_parameters.Copy (lexer.Location);
+			
+			Parameter implicit_value_parameter = new Parameter (
+					ftype, "Value", Parameter.Modifier.NONE, null);
+			
+			set_parameters.AppendParameter (implicit_value_parameter);
+		}
+		else
+		{
+			get_parameters = Parameters.EmptyReadOnlyParameters;
+			set_parameters = new Parameters (null, null ,lexer.Location); 
+			
+			Parameter implicit_value_parameter = new Parameter (
+					ftype, "Value", Parameter.Modifier.NONE, null);
+			
+			set_parameters.AppendParameter (implicit_value_parameter);
+		}
+		lexer.PropertyParsing = true;
+		
+		Accessor get_block = new Accessor (null, null);	
+		Accessor set_block = new Accessor (null, null);	
+				
+		Property prop = new Property ((Expression) ftype, (string) $3, current_modifiers, 
+					 get_block, set_block, current_attributes, lexer.Location,
+					 null, get_parameters, set_parameters, null);
+    
+		if (!(current_container is Class))
+			Report.Error (9999, (Location) $6, "THIS SHOULD NEVER HAPPEN!");
+			
+		CheckDef (current_container.AddProperty (prop), prop.Name, lexer.Location);
+		
+		get_implicit_value_parameter_type = null;
+		set_implicit_value_parameter_type = null;
+		get_parameters = null;
+		set_parameters = null;
+		current_local_parameters = null;				
+	  }	
+	;
+	
+	
+ non_abstract_propery_declaration
+	  : PROPERTY identifier 
+	    opt_type_character  
+	    opt_property_parameters 
+	    _mark_
+	    opt_type_with_ranks
+	    opt_implement_clause 
+	  {
+		push_into_stack((int)Start_block.PROPERTY, (Location)$5);
+		if ((current_modifiers & Modifiers.DEFAULT) > 0) {
+			if (current_container.DefaultPropName != null 
+				  && current_container.DefaultPropName != (string) $2)
+				Report.Error (30359, 
+						(Location) $5,
+						"Type '" + current_container.Name +
+						"' cannot have more than one 'Default Property' ");
+						
+			current_container.DefaultPropName = (string) $2;
+		}		
+		
+		if ( OptionStrict && ($3 == null) && ($6 == null) ) {
+				Report.Error (30210,
+                                                (Location) $5,
+                                                "Option Strict On requires all function and property "+
+                                                "declarations to have an 'As' clause or a type character.");
+		}			
+
+	  
+		get_implicit_value_parameter_type  = 
+			($6 == null) ? (($3 == null) ? 
+				TypeManager.system_object_expr : (Expression) TypeManager.TypeToCoreTypeExpr ((Type) $3) ): (Expression) $6;
+		get_implicit_value_parameter_name = (string) $2;
+		
+		current_local_parameters = (Parameters) $4;
+		if (current_local_parameters != Parameters.EmptyReadOnlyParameters) { 
+			get_parameters = current_local_parameters.Copy ((Location)$5);
+			set_parameters = current_local_parameters.Copy ((Location)$5);
+		}
+		else
+		{
+			get_parameters = Parameters.EmptyReadOnlyParameters;
+			set_parameters = new Parameters (null, null ,(Location)$5);		
+		}
+		lexer.PropertyParsing = true;
+
+		$$ = (Location)$5;
+	  }
+	  logical_end_of_line
+	  accessor_declarations 
+	  opt_end_block 
+	  {
+		pop_out_of_stack((int)$11,lexer.Location);
+	 }
+          logical_end_of_line
+	  {
+		lexer.PropertyParsing = false;
+
+		Property prop;
+		Pair pair = (Pair) $10;
+		
+		Accessor get_block = null;
+		Accessor set_block = null;
+		
+		if (pair.First != null){
+			get_block = (Accessor) pair.First;
+		}
+		
+		if (pair.Second != null) {
+			set_block = (Accessor) pair.Second;
+		}
+		
+		Location loc = (Location) $5 ;
+		
+		// Structure members are Public by default			
+		if ((current_container is Struct) && (current_modifiers == 0))
+			current_modifiers = Modifiers.PUBLIC;				
+			
+		prop = new Property ((Expression) get_implicit_value_parameter_type, 
+					 (string) $2, current_modifiers, get_block, set_block,
+				     current_attributes, loc, set_implicit_value_parameter_name, 
+				     get_parameters, set_parameters, (ArrayList) $7);
+		
+		CheckDef (current_container.AddProperty (prop), prop.Name, loc);
+		get_implicit_value_parameter_type = null;
+		set_implicit_value_parameter_type = null;
+		get_parameters = null;
+		set_parameters = null;
+		current_local_parameters = null;
+	  }
+	;
+
+opt_property_parameters
+	: /* empty */
+	  {
+	  	$$ = Parameters.EmptyReadOnlyParameters;
+	  }
+	| OPEN_PARENS opt_formal_parameter_list CLOSE_PARENS
+	  {
+	  	$$ = $2;
+	  }
+	;
+	
+opt_implement_clause
+	: /* empty */
+	  {
+	  	$$ = null;
+	  }
+	| IMPLEMENTS implement_clause_list
+	  {
+		$$ = $2;
+	  }
+	;
+	
+implement_clause_list
+	: qualified_identifier
+	  {
+	   ArrayList impl_list = new ArrayList ();
+	   impl_list.Add (DecomposeQI ((string)$1, lexer.Location));
+	  	$$ = impl_list;
+	  }	
+	| implement_clause_list COMMA qualified_identifier
+	  {
+		ArrayList impl_list = (ArrayList) $1;
+		impl_list.Add (DecomposeQI ((string)$3, lexer.Location));
+	  	$$ = impl_list;
+	  }	
+	  
+	;
+	
+accessor_declarations
+	: get_accessor_declaration opt_set_accessor_declaration
+	  { 
+		$$ = new Pair ($1, $2);
+	  }
+	| set_accessor_declaration opt_get_accessor_declaration
+	  {
+		$$ = new Pair ($2, $1);
+	  }
+	;
+
+opt_get_accessor_declaration
+	: /* empty */			{ $$ = null; }
+	| get_accessor_declaration
+	;
+
+opt_set_accessor_declaration
+	: /* empty */			{ $$ = null; }
+	| set_accessor_declaration
+	;
+
+get_accessor_declaration
+	: opt_attributes GET _mark_ logical_end_of_line
+	  {
+		push_into_stack((int)Start_block.GET, (Location)$3);
+		if ((current_modifiers & Modifiers.WRITEONLY) != 0)
+	  		Report.Error (30023, (Location)$3, "'WriteOnly' properties cannot have a 'Get' accessor");
+	  
+		current_local_parameters = get_parameters;
+		
+		lexer.PropertyParsing = false;
+		
+		start_block();	
+		// Add local var declaration
+		// for return value
+		ArrayList retval = new ArrayList ();
+		retval.Add (new VariableDeclaration (get_implicit_value_parameter_name, get_implicit_value_parameter_type, (Location)$3));
+		declare_local_variables (get_implicit_value_parameter_type, retval, lexer.Location);	
+	  }
+	  opt_statement_list
+          opt_end_block
+          {
+		pop_out_of_stack((int)$7,lexer.Location);
+          }
+	  logical_end_of_line
+	  {
+		$$ = new Accessor ((Block) end_block(), (Attributes) $1);
+		current_local_parameters = null;
+		lexer.PropertyParsing = true;
+	  }
+	;
+
+set_accessor_declaration
+	: opt_attributes SET opt_set_parameter _mark_ logical_end_of_line
+	  {
+		push_into_stack((int)Start_block.SET, (Location)$4);
+	        if ((current_modifiers & Modifiers.READONLY) != 0)
+	  		Report.Error (30022,
+				      (Location)$4,
+			              "'ReadOnly' properties cannot have a 'Set' accessor");
+	  		
+		Parameter implicit_value_parameter = new Parameter (
+			set_implicit_value_parameter_type, 
+			set_implicit_value_parameter_name, 
+			Parameter.Modifier.NONE, null);
+
+		current_local_parameters = set_parameters;
+		current_local_parameters.AppendParameter (implicit_value_parameter);
+		
+		start_block();
+		lexer.PropertyParsing = false;
+	  }
+	  opt_statement_list
+          opt_end_block
+          {
+		pop_out_of_stack((int)$8,lexer.Location);
+          }
+
+          logical_end_of_line
+	  {
+		$$ = new Accessor ((Block) end_block(), (Attributes) $1);
+		current_local_parameters = null;
+		lexer.PropertyParsing = true;
+	  }
+	;
+		
+opt_set_parameter
+	: /* empty */
+	{
+		set_implicit_value_parameter_type = (Expression) get_implicit_value_parameter_type; // TypeManager.system_object_expr;
+		set_implicit_value_parameter_name = "Value";
+	}	
+	|OPEN_PARENS CLOSE_PARENS
+	{
+		set_implicit_value_parameter_type = (Expression) get_implicit_value_parameter_type;
+		set_implicit_value_parameter_name = "Value";
+	}	
+	| OPEN_PARENS opt_parameter_modifier opt_identifier opt_type_with_ranks CLOSE_PARENS
+	{
+		Parameter.Modifier pm = (Parameter.Modifier)$2;
+		if ((pm | Parameter.Modifier.VAL) != 0)
+			Report.Error (31065, 
+				lexer.Location, 
+				"Set cannot have a paremeter modifier other than 'ByVal'");
+				
+		set_implicit_value_parameter_type = (Expression) $4;
+		
+		if (set_implicit_value_parameter_type.ToString () != get_implicit_value_parameter_type.ToString ())
+			Report.Error (31064, 
+				lexer.Location, 
+				"Set value parameter type can not be different from property type");
+				
+		if ($2 != null)
+			set_implicit_value_parameter_name = (string) $3;
+		else
+			set_implicit_value_parameter_name = "Value";
+	}
+	;
+			
+field_declaration
+	: opt_dim_stmt 
+	  variable_declarators end_of_stmt
+	  {   		  
+		int mod = (int) current_modifiers;
+
+		VariableDeclaration.FixupTypes ((ArrayList) $2);
+		VariableDeclaration.FixupArrayTypes ((ArrayList) $2);
+		
+		if (current_container is Module)
+			mod = mod | Modifiers.STATIC;
+			
+		// Structure members are Public by default			
+		if ((current_container is Struct) && (mod == 0))
+			mod = Modifiers.PUBLIC;			
+		
+		if ((mod & Modifiers.Accessibility) == 0)
+			mod |= Modifiers.PRIVATE;
+					
+		foreach (VariableDeclaration var in (ArrayList) $2){
+			Location l = var.Location;
+			Field field = new Field (var.type, mod, var.identifier, 
+						 var.expression_or_array_initializer, 
+						 (Attributes) null, l);
+
+			CheckDef (current_container.AddField (field), field.Name, l);
+		}
+	  }
+	;
+	
+withevents_declaration
+	: opt_dim_stmt WITHEVENTS variable_declarators logical_end_of_line
+	  {
+		// Module members are static by default, but delegates *can't* be declared static
+		// so we must fix it, if mbas was the one actually responsible for this
+		// instead of triggering an error.
+		if (implicit_modifiers && ((current_modifiers & Modifiers.STATIC) != 0))
+			current_modifiers = (current_modifiers & ~Modifiers.STATIC);
+	  
+	  	/* WithEvents Fields must be resolved into properties
+	  	   with a bit of magic behind the scenes */
+	  	  
+	  	VariableDeclaration.FixupTypes ((ArrayList) $3);
+	  	
+		foreach (VariableDeclaration var in (ArrayList) $3) {
+			// 1 - We create a private field
+			Location l = var.Location;
+			Property prop;
+			if ((current_modifiers & Modifiers.STATIC) > 0) 
+				Report.Error (30234, l, "'Static' is not valid on a WithEvents declaration.");
+			
+			Field field = new Field (var.type, Modifiers.PRIVATE, "_" + var.identifier, 
+						 var.expression_or_array_initializer, 
+						 (Attributes) null, l);
+						 
+			CheckDef (current_container.AddField (field), field.Name, l);	
+			
+			// 2 - Public property
+				
+			prop = BuildSimpleProperty (var.type, (string) var.identifier, 
+						field, (int) current_modifiers, 
+					     	(Attributes) current_attributes, l);
+			
+			CheckDef (current_container.AddProperty (prop), prop.Name, l);
+		}		
+	  }
+	;
+	
+opt_dim_stmt 
+	: /* empty */
+	| DIM
+	; 
+		
+delegate_declaration
+	: DELEGATE SUB _mark_  
+	  identifier OPEN_PARENS 
+	  opt_formal_parameter_list
+	  CLOSE_PARENS 
+	  logical_end_of_line
+	  {
+		Location l = (Location)$3;
+		// Module members are static by default, but delegates *can't* be declared static
+		// so we must fix it, if mbas was the one actually responsible for this
+		// instead of triggering an error.
+		if (implicit_modifiers && ((current_modifiers & Modifiers.STATIC) != 0))
+			current_modifiers = (current_modifiers & ~Modifiers.STATIC);
+					
+		Mono.MonoBASIC.Delegate del = new Mono.MonoBASIC.Delegate (current_container, 
+						 TypeManager.system_void_expr, 
+					     (int) current_modifiers, 
+		                 MakeName ((string) $4), (Parameters) $6, 
+					     (Attributes) current_attributes, l);
+					     	  
+		del.Namespace = current_namespace;
+		CheckDef (current_container.AddDelegate (del), del.Name, l);
+	  }	
+	| DELEGATE FUNCTION _mark_ 	  
+	  identifier OPEN_PARENS 
+	  opt_formal_parameter_list
+	  CLOSE_PARENS opt_type_with_ranks logical_end_of_line
+	  {
+		Location l = (Location)$3;
+		
+		// Module members are static by default, but delegates *can't* be declared static
+		// so we must fix it, if mbas was the one actually responsible for this
+		// instead of triggering an error.
+		if (implicit_modifiers && ((current_modifiers & Modifiers.STATIC) != 0))
+			current_modifiers = (current_modifiers & ~Modifiers.STATIC);
+			
+		Expression ftype = ($8 == null) ? TypeManager.system_object_expr : (Expression) $8;
+			
+		Mono.MonoBASIC.Delegate del = new Mono.MonoBASIC.Delegate (
+			current_container,
+			ftype, (int) current_modifiers, MakeName ((string) $4), 
+			(Parameters) $6, (Attributes) current_attributes, l);
+
+		del.Namespace = current_namespace;
+		CheckDef (current_container.AddDelegate (del), del.Name, l);
+	  }
+	;
+	
+opt_evt_handler
+	: /* empty */		{ 	$$ = null; }
+	  | HANDLES evt_handler_list		{ 	$$ = $2; }
+    ;
+
+evt_handler_list
+	: evt_handler
+	 {
+		ArrayList list = new ArrayList ();
+		list.Add ($1);
+	        $$ = list;
+	 }
+	| evt_handler_list COMMA evt_handler
+	 {
+		((ArrayList) $1).Add ($3);
+		$$ = $1;
+	 }
+	;
+
+
+evt_handler
+	: qualified_identifier _mark_ 
+	  {
+		$$ = (Expression) DecomposeQI ((string)$1, (Location)$2);	
+	  }
+	| base_access
+	  {
+		$$ = $1;
+	  }
+	| ME DOT qualified_identifier _mark_
+	  {
+		$$ = (Expression) DecomposeQI ((string)$3, (Location)$4);	
+	  }
+	/*| MYBASE DOT qualified_identifier
+	  {
+	  	// FIXME: this is blatantly wrong and crash-prone
+		$$ = (Expression) DecomposeQI ("MyBase." + (string)$4, lexer.Location);
+	  }*/
+	;
+
+constructor_declaration
+	: SUB _mark_ NEW opt_params logical_end_of_line
+	  {
+		push_into_stack((int)Start_block.SUB, (Location)$2);
+	  	current_local_parameters = (Parameters) $4;
+	  	start_block();
+		$$ = new Constructor ((string) "New", (Parameters) $4, (ConstructorInitializer) null, (Location)$2);
+		$1 = $$;
+	  }
+	  opt_statement_list
+	  { 
+		Constructor c = (Constructor) $1;
+		c.Block = (Block) end_block();
+
+//To support "Sub New()" add default modifier "public"
+
+		if(current_modifiers ==0)
+			current_modifiers = Modifiers.PUBLIC;
+		c.ModFlags = (int) current_modifiers;
+		c.OptAttributes = current_attributes;
+		
+		c.Initializer = CheckConstructorInitializer (ref c.Block.statements);
+
+		CheckDef (current_container.AddConstructor(c), c.Name, c.Location);
+		current_local_parameters = null;
+	  }
+	  opt_end_block 
+	  {
+		pop_out_of_stack((int)$9, lexer.Location);
+	 }
+          logical_end_of_line
+	;
+	
+opt_formal_parameter_list
+	: /* empty */			
+	  { 
+		$$ = Parameters.EmptyReadOnlyParameters; 
+	  }
+	| formal_parameter_list	
+	  { 
+	  	$$ = $1;	
+	    	//Parameter p = ((Parameters) $1).FixedParameters[0];
+	  }
+	;
+	
+formal_parameter_list
+	: parameters		
+	  { 
+		ArrayList pars_list = (ArrayList) $1;
+		Parameter [] pars = null; 
+		Parameter array_parameter = null;
+		int non_array_count = pars_list.Count;
+		if (pars_list.Count > 0 && (((Parameter) pars_list [pars_list.Count - 1]).ModFlags & Parameter.Modifier.PARAMS) != 0) {
+			array_parameter = (Parameter) pars_list [pars_list.Count - 1];
+			non_array_count = pars_list.Count - 1;
+		}
+		foreach (Parameter par in pars_list)
+			if (par != array_parameter && (par.ModFlags & Parameter.Modifier.PARAMS) != 0) {
+		  		Report.Error (30192, lexer.Location, "ParamArray parameters must be last");
+			  	non_array_count = 0; 
+				array_parameter = null;
+				break;
+			}
+		if (non_array_count > 0) {
+			pars = new Parameter [non_array_count];
+			pars_list.CopyTo (0, pars, 0, non_array_count);
+		}
+	  	$$ = new Parameters (pars, array_parameter, lexer.Location); 
+	  } 
+	;
+
+parameters
+	: parameter	
+	  {
+		ArrayList pars = new ArrayList ();
+
+		pars.Add ($1);
+		$$ = pars;
+	  }
+	| parameters COMMA parameter
+	  {
+		ArrayList pars = (ArrayList) $1;
+
+		pars.Add ($3);
+		$$ = $1;
+	  }
+	;
+
+parameter
+	: opt_attributes
+	  opt_parameter_modifier
+	  identifier _mark_ opt_type_character opt_rank_specifiers opt_type_with_ranks opt_variable_initializer
+	  {
+	  	Parameter.Modifier pm = (Parameter.Modifier)$2;
+	  	bool opt_parm = ((pm & Parameter.Modifier.OPTIONAL) != 0);
+	  	Expression ptype;
+	  	
+	  	if (opt_parm && ($8 == null))
+	  		Report.Error (30812, (Location)$4, "Optional parameters must have a default value");
+
+	  	if (!opt_parm && ($8 != null))
+	  		Report.Error (32024, (Location)$4, "Non-Optional parameters should not have a default value");
+
+	  	if ((pm & Parameter.Modifier.PARAMS) != 0) {
+		  	if ((pm & ~Parameter.Modifier.PARAMS) != 0)
+	  			Report.Error (30667, (Location)$4, "ParamArray parameters must be ByVal");
+		}
+	  	
+  		if ((pm & Parameter.Modifier.REF) !=0)
+  			pm |= Parameter.Modifier.ISBYREF;
+		
+		TypeExpr tc_expr = TypeManager.TypeToCoreTypeExpr ((Type) $5);
+	  	if (tc_expr != null && $7 != null && tc_expr != $7)
+			Report.Error (30302, (Location)$4, "Type character conflicts with declared type."); // TODO: Correct error number and message text
+
+		ptype = (Expression)(($7 == null) ? ((tc_expr == null) ? TypeManager.system_object_expr : tc_expr) : $7);
+		if ($6 != null)	{
+	  		string t = ptype.ToString ();
+	  		if (t.IndexOf('[') >= 0)
+				Report.Error (31087, (Location)$4, "Array types specified in too many places");
+			else	
+	  			ptype = DecomposeQI (t + VariableDeclaration.BuildRanks ((ArrayList) $6, true, (Location)$4), (Location)$4);
+	  	}
+		if ((pm & Parameter.Modifier.PARAMS) != 0 && ptype.ToString ().IndexOf('[') < 0)
+	  		Report.Error (30050, (Location)$4, "ParamArray parameters must be an array type");
+		$$ = new Parameter (ptype, (string) $3, pm,
+					(Attributes) $1, (Expression) $8, opt_parm);
+	  }
+	;
+	
+opt_parameter_modifier
+	: /* empty */		{ $$ = Parameter.Modifier.VAL; 	}
+	| parameter_modifiers	{ $$ = $1;			}
+	;
+
+parameter_modifiers
+	: parameter_modifiers parameter_modifier 	{ $$ = (Parameter.Modifier)$1 | (Parameter.Modifier)$2;	}
+	| parameter_modifier				{ $$ = $1;	}
+	;
+	
+parameter_modifier
+	: BYREF			{ $$ = Parameter.Modifier.REF | Parameter.Modifier.ISBYREF; }
+	| BYVAL			{ $$ = Parameter.Modifier.VAL; }
+	| OPTIONAL		{ $$ = Parameter.Modifier.OPTIONAL; } 
+	| PARAM_ARRAY		{ $$ = Parameter.Modifier.PARAMS; } 
+	;	
+
+opt_statement_list
+	: /* empty */
+	| statement_list end_of_stmt
+	;
+
+statement_list
+	: statement 
+	| statement_list end_of_stmt  
+	  statement
+	;
+
+statement
+	:STOP 
+	  | declaration_statement
+	    {
+		if ($1 != null && (Block) $1 != current_block){
+			current_block.AddStatement ((Statement) $1);
+			current_block = (Block) $1;
+		  }
+	    }
+	  | embedded_statement
+	    {
+		  if ($1 != null)
+		  	current_block.AddStatement ((Statement) $1);
+	    } 
+	  | labeled_statement 
+	  | ADDHANDLER prefixed_unary_expression COMMA ADDRESSOF evt_handler
+	    {
+	   		AddHandler ((Expression) $2, (Expression) $5);
+	    }
+	  | REMOVEHANDLER prefixed_unary_expression COMMA ADDRESSOF evt_handler
+		{
+	   	  RemoveHandler ((Expression) $2, (Expression) $5);
+	    }
+	  | RAISEEVENT identifier opt_raise_event_args  //OPEN_PARENS opt_argument_list CLOSE_PARENS
+	    {
+	      RaiseEvent ((string) $2, (ArrayList) $3);
+	    }
+	  /* | array_handling_statement */
+	  /* | empty_statement */
+	  | with_statement 
+	    {
+	      current_block.AddStatement ((Statement) $1);
+	    }	  
+	  ;	
+	  
+opt_end_stmt
+	: END_EOL {$$ = new End (lexer.Location);}
+	;
+
+	
+opt_raise_event_args 
+	: /* empty */	{ $$ = null; }
+	| OPEN_PARENS opt_argument_list CLOSE_PARENS
+	  {
+		$$ = $2;
+	  }
+	;
+
+label_name
+	: LABELNAME
+	| LITERAL_INTEGER
+	{
+		$$ = $1.ToString();
+	}
+	;
+
+labeled_statement
+	: label_name COLON
+	  {
+		LabeledStatement labeled = new LabeledStatement ((string) $1, lexer.Location);
+
+		if (!current_block.AddLabel ((string) $1, labeled,lexer.Location)){
+			Location l = lexer.Location;
+			Report.Error (140, l, "The label '" + ((string) $1) + "' is a duplicate");
+		}	
+		current_block.AddStatement (labeled);
+	  }
+	| label_name COLON
+	  {
+		LabeledStatement labeled = new LabeledStatement ((string) $1, lexer.Location);
+
+		if (!current_block.AddLabel ((string) $1, labeled,lexer.Location)){
+			Location l = lexer.Location;
+			Report.Error (140, l, "The label '" + ((string) $1) + "' is a duplicate");
+		}	
+		current_block.AddStatement (labeled);
+	  }
+	  statement
+	;
+
+embedded_statement
+	: expression_statement
+	| selection_statement
+	| iteration_statement
+	| try_statement
+	| on_error_statement
+	| synclock_statement
+	| jump_statement
+	| array_handling_statement 
+	| error_statement
+	;
+/*        
+empty_statement
+	: end_of_stmt
+	  {
+		  $$ = new EmptyStatement ();
+	  }
+	;        
+*/
+
+error_statement
+	: ERROR _mark_ expression {
+	
+		Expression primary_expression = DecomposeQI ("Microsoft.VisualBasic.CompilerServices.ProjectData.CreateProjectError", (Location) $2 );
+		
+		Argument error_number = new Argument ((Expression) $3, Argument.AType.Expression);
+		ArrayList args = new ArrayList();
+		args.Add(error_number);
+		
+		Invocation CreateProjectErrorInvoke =  new Invocation (primary_expression, args, (Location)$2);
+		$$ = new Throw (CreateProjectErrorInvoke ,(Location)$2);
+	}
+;
+
+with_statement
+	 // : WITH _mark_ expression end_of_stmt /* was : WITH qualified_identifier end_of_stmt */
+	 : WITH _mark_ qualified_identifier end_of_stmt /* was : WITH qualified_identifier end_of_stmt */
+	  {
+	  	Expression e = DecomposeQI ((string) $3, (Location)$2);
+		push_into_stack((int)Start_block.WITH, (Location)$2);
+		with_stack.Push(e);
+                string temp = Convert.ToString(e);
+		with_hash.Add(temp,e);
+
+		start_block();
+	  }
+	  opt_statement_list
+	  opt_end_block 
+	  {
+		pop_out_of_stack((int)$7,lexer.Location);
+	  	Block b = end_block();
+		with_stack.Pop();
+		with_hash.Clear();
+		$$ = b;
+	  }
+	;
+	
+	
+array_handling_statement
+	: redim_statement
+	| erase_statement
+	;
+	
+redim_statement
+	: REDIM _mark_ opt_preserve redim_clauses
+	  {
+	  	ArrayList list = (ArrayList) $4;
+		ReDim r = new ReDim (list, (bool) $3, (Location)$2);
+		$$ = r;
+	  }
+	;
+	
+opt_preserve
+	: /* empty */ 	{ $$ = false; }
+	| PRESERVE	{ $$ = true;  }
+	;
+	
+redim_clauses
+	: redim_clause
+	  {
+		ArrayList clauses = new ArrayList ();
+
+		clauses.Add ($1);
+		$$ = clauses;
+	  }
+	| redim_clauses COMMA redim_clause
+	  {
+		ArrayList clauses = (ArrayList) ($1);
+		clauses.Add ($3);
+
+		$$ = clauses;
+	  }
+	;
+
+redim_clause
+	: invocation_expression opt_type_spec
+	  {
+	  	Invocation i = (Invocation) $1;
+		RedimClause rc = new RedimClause (i.expr, i.Arguments, (Expression) $2);
+		$$ = rc;
+	  }
+	;
+
+erase_statement
+	: ERASE erase_clauses
+	{
+	  	ArrayList list = (ArrayList) $2;
+		foreach(Expression e in list)
+		{
+	  		Erase r = new Erase (e, lexer.Location);
+	  		$$ = r;
+		}
+	}
+	;
+
+erase_clauses
+	: erase_clause
+	  {
+		ArrayList clauses = new ArrayList ();
+
+		clauses.Add ($1);
+		$$ = clauses;
+	  }
+	| erase_clauses COMMA erase_clause
+	  {
+		ArrayList clauses = (ArrayList) ($1);
+		clauses.Add ($2);
+
+		$$ = clauses;
+	  }
+	;
+
+erase_clause
+	: primary_expression
+	;	
+		        
+jump_statement
+	: /*break_statement
+	| continue_statement
+	| */return_statement
+	| goto_statement	
+	| throw_statement	
+	| exit_statement
+	| yield_statement
+	| opt_end_stmt
+	;
+	        
+goto_statement
+	: GOTO label_name  
+	  {
+		Block block = current_block;
+	  
+		while( current_block.Parent != null )
+			current_block = current_block.Parent;
+
+		$$ = new Goto (current_block, (string) $2, lexer.Location);
+
+		current_block = block;
+		current_block.SetEndLocation(lexer.Location);
+	  }
+	;
+	
+throw_statement
+	: THROW _mark_ opt_expression
+	  {
+		$$ = new Throw ((Expression) $3, (Location)$2);
+	  }
+	;	
+		        
+exit_statement
+	: EXIT exit_type
+	  {
+	  	$$ = new Exit ((ExitType)$2, lexer.Location);	        
+	  }
+	;
+	
+exit_type
+	: DO 		{ $$ = ExitType.DO;		}
+	| FOR 		{ $$ = ExitType.FOR; 	}
+	| WHILE 	{ $$ = ExitType.WHILE;		}
+	| SELECT 	{ $$ = ExitType.SELECT;		}
+	| SUB 		{ $$ = ExitType.SUB;		}
+	| FUNCTION 	{ $$ = ExitType.FUNCTION;	}
+	| PROPERTY 	{ $$ = ExitType.PROPERTY;	}
+	| TRY		{ $$ = ExitType.TRY;		}
+	;
+return_statement
+	: RETURN opt_expression 
+	  {	  
+		$$ = new Return ((Expression) $2, lexer.Location);
+	  }
+	;
+	        
+iteration_statement
+	: while_statement
+	| do_statement
+	| for_statement
+	| foreach_statement
+	;
+
+foreach_statement
+	: FOR EACH identifier _mark_ opt_type_spec IN 
+	  expression end_of_stmt
+	  {
+		Location l = (Location)$4;		
+		push_into_stack((int)Start_block.FOR, l);
+		LocalVariableReference v = null;
+		VariableInfo vi;
+
+		if ($5 != null)	
+		{
+			start_block();
+			VariableDeclaration decl = new VariableDeclaration ((string) $3, 
+					(Expression) $5, null, (Location)$4, null);
+			
+			vi = current_block.AddVariable (
+				(Expression) $5, decl.identifier, current_local_parameters, decl.Location);
+
+			Expression expr;
+			if (decl.expression_or_array_initializer is Expression)
+				expr = (Expression) decl.expression_or_array_initializer;
+			else if (decl.expression_or_array_initializer == null) 
+				expr = null;
+			else 
+			{
+				ArrayList init = (ArrayList) decl.expression_or_array_initializer;
+				expr = new ArrayCreation ((Expression) $5, "", init, decl.Location);
+			}
+		
+			v = new LocalVariableReference (current_block, decl.identifier, l);
+
+			if (expr != null) 
+			{
+				Assign a = new Assign (v, expr, decl.Location);
+				current_block.AddStatement (new StatementExpression (a, (Location)$4));
+			}
+		}
+		else
+		{
+			vi = current_block.GetVariableInfo ((string) $3);
+
+			if (vi != null) {
+				// Get a reference to this variable.
+				v = new LocalVariableReference (current_block, (string) $3, l, vi, false);
+			}
+			else
+			{
+				ArrayList VarDeclarations = new ArrayList ();
+       				VarDeclarations.Add (new VariableDeclaration ("$FOREACH$" + (string) $3, null, l, (string) $3));
+                                ArrayList decl = new ArrayList ();
+                                decl.AddRange (VarDeclarations);
+
+                                DictionaryEntry de = new DictionaryEntry (DecomposeQI("_local_vars_", l), decl);
+
+                                Block b = declare_local_variables ((Expression) de.Key, (ArrayList) de.Value, l);
+				
+				if(current_block.Used)
+				{
+					current_block.AddStatement ((Statement) b);
+					current_block = b;
+				}
+
+				//Mark these variables as Used
+                                vi = current_block.GetVariableInfo ("$FOREACH$" + (string) $3);
+                                //vi.Type = DecomposeQI ((String)$3, l);
+                                vi.Used = true;
+                                v = new LocalVariableReference (current_block,"$FOREACH$" + (string) $3, l, vi, false);
+
+			}
+		}
+		
+		oob_stack.Push (v);
+		start_block();	
+	  } 	  
+	  opt_statement_list
+	  opt_end_block
+          {
+		pop_out_of_stack((int)$11,lexer.Location);
+          }
+	   _mark_ opt_identifier
+	  {
+			string s = $3.ToString();
+			string s1 = "";
+			if ($14 != null)
+				s1 = $14.ToString();		
+			if (s1 != "" && s != s1)
+				{		
+					Report.Error(30070, (Location)$13, "Next Control Variable '"+s1+"' does not match with For Loop control variable '"+s+"'");    
+				}
+		LocalVariableReference v = (LocalVariableReference) oob_stack.Pop ();
+		Block foreach_block = end_block();
+		Foreach f = null;
+		if (v != null)
+			f = new Foreach (null, v, (Expression) $7, foreach_block, (Location)$4);
+		
+		if ($5 != null)
+		{
+			current_block.AddStatement (f);
+			$$ = end_block ();
+		}
+		else
+			$$ = f;
+	
+		if (foreach_block.HasLabeledStatement && !foreach_block.HasGotoStatement)
+		Report.Error(30757, foreach_block.Parent.Parent.EndLocation, "'Goto "+foreach_block.LabelName+"' is not valid because '"+foreach_block.LabelName+"' is inside a 'For' or 'ForEach' statement that does not contain this statement.");
+	  }	  
+	;
+
+yield_statement 
+	: YIELD expression _mark_ 
+	  {
+		if (!UseExtendedSyntax)
+		{
+			ReportError9998();
+			$$ = null;
+		}
+/*		else
+			if (iterator_container == null){
+				Report.Error (204, (Location)$3, "yield statement can only be used within a method, operator or property");
+				$$ = null;
+			} else {
+				iterator_container.SetYields ();
+				$$ = new Yield ((Expression) $2, (Location)$3);
+			} */
+	  }
+	| YIELD STOP _mark_ 
+	  {
+		if (!UseExtendedSyntax)
+		{
+			ReportError9998();
+			$$ = null;
+		}
+/*		else
+			if (iterator_container == null){
+				Report.Error (204, (Location)$3, "yield statement can only be used within a method, operator or property");
+				$$ = null;
+			} else {
+				iterator_container.SetYields ();
+				$$ = new YieldBreak ((Location)$3);
+			} */
+	  }
+	;
+
+synclock_statement
+	: SYNCLOCK _mark_ expression end_of_stmt
+	  {   
+		push_into_stack((int)Start_block.SYNCLOCK, (Location)$2);
+		start_block();  
+	  }
+	  opt_statement_list 
+	  opt_end_block 
+	  {
+		pop_out_of_stack((int)$7,lexer.Location);
+		$$ = new Lock ((Expression) $3, (Statement) (Block) end_block(), (Location)$2);
+	  }
+	;
+
+try_statement
+	: try_catch
+	| try_catch_finally
+	;
+				
+try_header
+	: TRY _mark_ end_of_stmt
+	  {   
+		push_into_stack((int)Start_block.TRY, (Location)$2);
+		try_top=(Location)$2;
+		start_block();  
+	  }
+	  opt_statement_list 
+	  opt_catch_clauses
+	  {
+	  	tmp_catch_clauses = (ArrayList) $6;
+	  }
+	;
+	
+
+/*FIXME: Try block without a end try is throwing error at a wrong place*/				
+try_catch
+	: try_header 	
+	  _mark_ opt_end_block 
+	  {
+		pop_out_of_stack((int)$3,lexer.Location);
+		Catch g = null;
+		ArrayList s = new ArrayList ();
+
+		foreach (Catch cc in (ArrayList) tmp_catch_clauses) {
+			if (cc.IsGeneral)
+				g = cc;
+			else
+				s.Add (cc);
+		}
+
+		// Now s contains the list of specific catch clauses
+		// and g contains the general one.
+		Block b = end_block();
+
+		$$ = new Try ((Block) b, s, g, null, try_top);
+	  }	  
+	;	
+	  
+try_catch_finally
+	: try_header 
+	  { 
+		tmp_block = end_block(); 
+	  }	
+	  FINALLY end_of_stmt
+  	  { 
+		start_block(); 
+	  }	  
+	  opt_statement_list 
+	  _mark_ opt_end_block 
+	  {
+		pop_out_of_stack((int)$8,lexer.Location);
+		Catch g = null;
+		ArrayList s = new ArrayList ();
+		ArrayList catch_list = (ArrayList) tmp_catch_clauses;
+
+		if (catch_list != null){
+			foreach (Catch cc in catch_list) {
+				if (cc.IsGeneral)
+					g = cc;
+				else
+					s.Add (cc);
+			}
+		}
+
+		$$ = new Try ((Block) tmp_block, s, g, (Block) end_block(), try_top);
+	
+	  }	
+	  ;	  	
+
+opt_catch_clauses
+	: /* empty */  {  $$ = null;  }
+        | catch_clauses
+	;
+
+catch_clauses
+	: catch_clause 
+	  {
+		ArrayList l = new ArrayList ();
+
+		l.Add ($1);
+		$$ = l;
+	  }
+	| catch_clauses catch_clause
+	  {
+		ArrayList l = (ArrayList) $1;
+
+		l.Add ($2);
+		$$ = l;
+	  }
+	;
+
+opt_identifier
+	: /* empty */	{  $$ = null;  }
+	| identifier
+	;
+
+opt_when
+	: /* empty */	{  $$ = null;  }
+	| WHEN boolean_expression 
+		{
+			$$ = $2; 
+		}
+	;
+	
+catch_clause 
+	: CATCH opt_catch_args opt_when _mark_ end_of_stmt
+	{
+		Expression type = null;
+		string id = null;
+		
+		if ($2 != null) {
+			DictionaryEntry cc = (DictionaryEntry) $2;
+			type = (Expression) cc.Key;
+			id   = (string) cc.Value;
+			
+			if (id != null){
+				ArrayList one = new ArrayList ();
+				Location loc = (Location)$4;
+
+				one.Add (new VariableDeclaration (id, type, loc));
+
+				$1 = current_block;
+				current_block = new Block (current_block);
+				Block b = declare_local_variables (type, one, loc);
+				current_block = b;
+			}
+		}
+	} 
+	opt_statement_list {
+		Expression type = null;
+		string id = null;
+		Block b_catch = current_block;
+		
+		if ($2 != null){
+			DictionaryEntry cc = (DictionaryEntry) $2;
+			type = (Expression) cc.Key;
+			id   = (string) cc.Value;
+			
+			if ($1 != null) {
+				//
+				// FIXME: I can change this for an assignment.
+				//
+				while (current_block != (Block) $1)
+					current_block = current_block.Parent;
+			}
+		}
+		$$ = new Catch (type, id , (Block) b_catch, (Expression) $3, (Location)$4);
+	}
+    ;
+
+opt_catch_args
+	: /* empty */ {  $$ = null; }
+        | catch_args
+	;	  
+
+catch_args 
+        : identifier AS _mark_ type
+        {
+		 $$ = new DictionaryEntry ($4, $1); 
+	}
+	| error _mark_ AS type
+	{
+		Report.Error(30203, (Location)$2, "Identifier Expected");
+		$$ = null;
+	}
+	| identifier AS _mark_ error 
+	{
+		Report.Error(30182, (Location)$3, "Type Expected");
+		$$ = null;
+	}
+        ;
+
+on_error_statement
+	: ON ERROR GOTO MINUS _mark_ LITERAL_INTEGER //ON ERROR GOTO -1
+	  {// This should disables the exception in the current procedure.
+		
+		Location l = (Location) $5;
+	
+		if ( $6.ToString() == "1" )
+		{
+			Block method_block = current_block;
+			
+			while ( !(method_block is MethodBlock) && (method_block.Parent != null) )
+                       		method_block = method_block.Parent;
+
+			// call Microsoft.VisualBasic.CompilerServices.ProjectData.ClearProjectError()
+			// This call will be created in all kinds of on error goto ( 0, -1, label )
+			Expression clearerrors = DecomposeQI ("Microsoft.VisualBasic.CompilerServices.ProjectData.ClearProjectError", l);
+			StatementExpression stex = new StatementExpression (
+							(ExpressionStatement) new Invocation (clearerrors, null, l),
+							l);
+			current_block.AddStatement ((Statement) stex );
+			
+			String var2 = "$ONERROR$2";//Loc_1 -Int-
+			
+			// This Assignment must be emited only if the method have a statement like ON ERROR GOTO label.
+			// $ONERROR$2 = 0  (this Variable is created in a on error goto label stmt)
+			// This variable will be used in a filter block to disable de exception, if the method have a statement like ON ERROR GOTO label.
+
+			Expression var = DecomposeQI (var2, l);
+			Expression value = new IntLiteral (0);
+				
+			StatementExpression assign = new StatementExpression( ((ExpressionStatement) new Assign (var, value, l)), l);
+
+			if( ((MethodBlock) method_block).onerror  != null ) //There is an On_Error Statement created.
+				current_block.AddStatement ( (Statement) assign );
+			else // Mark this assignment as pending, if exists an ON ERROR GOTO LABEL statement after this.
+			{
+				if ( ((MethodBlock) method_block).Pending_Assigns == null )
+					((MethodBlock) method_block).Pending_Assigns = new ArrayList();
+
+				Pending_Assign pa = new Pending_Assign(current_block, (Statement) assign, current_block.statements.Count );
+				((MethodBlock) method_block).Pending_Assigns.Add(pa) ;
+			}	
+		}
+		else
+		{
+			Report.Error (30203, l, "Identifier expected.");
+		}
+
+		$$ = null;
+	  }
+	| ON ERROR GOTO _mark_ label_name
+	  {
+		Location l = (Location) $4;
+		Block old_current = current_block;
+		Block method_block = current_block;
+			
+		while ( !(method_block is MethodBlock) && (method_block.Parent != null) )
+                       	method_block = method_block.Parent;
+
+		// call Microsoft.VisualBasic.CompilerServices.ProjectData.ClearProjectError()
+		// This call will be created in all kinds of on error goto ( 0, -1, label )
+		Expression clearerrors = DecomposeQI ("Microsoft.VisualBasic.CompilerServices.ProjectData.ClearProjectError", l);
+		StatementExpression stex = new StatementExpression (
+						(ExpressionStatement) new Invocation (clearerrors, null, l),
+						l);
+		current_block.AddStatement ((Statement) stex );
+
+		if ( $5.ToString() == "0") // ON ERROR GOTO 0
+		{// This should disables error handling in the current procedure.
+			
+			String var1 = "$ONERROR$1";//Loc_0 -Int- Number of Label.
+	                
+			// This Assignment must be emited only if the method have a statement like ON ERROR GOTO label.
+			// $ONERROR$1 = 0  (this Variable is created in a on error goto label stmt)
+			// This variable will be used in a filter block to disable error handling, if the method have a statement like ON ERROR GOTO label.
+
+			Expression var = DecomposeQI (var1, l);
+			Expression value = new IntLiteral (0);
+				
+			StatementExpression assign = new StatementExpression( ((ExpressionStatement) new Assign (var, value, l)), l);
+
+			if( ((MethodBlock) method_block).onerror  != null ) //There is an On_Error Statement created.
+				current_block.AddStatement ( (Statement) assign );
+			else // Mark this assignment as pending, if exists an ON ERROR GOTO LABEL statement after this.
+			{
+				if ( ((MethodBlock) method_block).Pending_Assigns == null )
+					((MethodBlock) method_block).Pending_Assigns = new ArrayList();
+
+				Pending_Assign pa = new Pending_Assign(current_block, (Statement) assign, current_block.statements.Count );
+				((MethodBlock) method_block).Pending_Assigns.Add(pa) ;
+			}	
+		}
+		else // ON ERROR GOTO LABEL
+		{// This should Enables the error-handling routine that starts at the line specified in the required line argument.
+	
+			String var1 = "$ONERROR$1";//Loc_0 -Int-Number of Label.
+			String var2 = "$ONERROR$2";//Loc_1 -Int-
+			String var3 = "$ONERROR$3";//Loc_2 -System.Exception- Exception Object.
+	                
+			VariableInfo vi = current_block.GetVariableInfo (var1);
+			
+			if( vi == null )
+			{ // First On Error Statement
+			  // 1) Declare local variables to handle goto.
+			  // 1.1) Dim $ONERROR$01  (Variable Generated because on error stmt)
+			  // 1.2) Dim $ONERROR$02  (Variable Generated because on error stmt)
+			  // 1.3) Dim $ONERROR$03  (Variable Generated because on error stmt)
+			  // 2) Declare a Parent Block of Method_Block to handle the method_block stmts within a try stmt.
+			  // 3) Declere OnError stmt and mark its block as Parent of method_block.
+			  // 4) Assign the pending assignments if they exist.
+			
+				Block block = new Block( method_block.Parent, null,
+                        	   lexer.Location, Location.Null);
+
+				//Cleaning the variables created in a top block(these variables already were created in method_block)
+				block.Variables.Clear();
+
+				// Dim $ONERROR$01 As Integer (Variable Genearted because on error stmt)
+				// Dim $ONERROR$02 As Integer (Variable Genearted because on error stmt)
+				// Dim $ONERROR$03 As System.Exception (Variable Genearted because on error stmt)
+				ArrayList VarDeclarations = new ArrayList ();
+				VarDeclarations.Add (new VariableDeclaration (var1, TypeManager.system_int32_expr, null, l, null));
+				VarDeclarations.Add (new VariableDeclaration (var2, TypeManager.system_int32_expr, null, l, null));
+				VarDeclarations.Add (new VariableDeclaration (var3, DecomposeQI("System.Exception", l), null, l, null));
+				ArrayList decl = new ArrayList ();
+				decl.AddRange (VarDeclarations);
+			
+				DictionaryEntry de = new DictionaryEntry (DecomposeQI("_local_vars_", l), decl);
+				current_block = block;
+				declare_local_variables ((Expression) de.Key, (ArrayList) de.Value, l);
+
+				//Mark these variables as Used
+				vi = current_block.GetVariableInfo (var1);
+				vi.Used = true;
+				vi = current_block.GetVariableInfo (var2);
+				vi.Used = true;
+				vi = current_block.GetVariableInfo (var3);
+				vi.Used = true;
+
+				current_block = old_current;
+				
+				Statement stmt = new On_Error( method_block, l );
+				block.AddStatement(stmt);
+				block.AddChild(method_block);
+				// This will make on_error block as Parent of method_block
+				// This is needed because an implicit insertion of a try outside of method_block statements.
+				((MethodBlock) method_block).onerror = block;
+				method_block.Parent = block;
+
+				//This adds the pendinding assignments of any on error goto 0 or -1 before the first ON ERROR GOTO LABEL statement.
+				if ( ((MethodBlock) method_block).Pending_Assigns != null )
+				{
+					foreach ( Pending_Assign pa in  ((MethodBlock) method_block).Pending_Assigns )
+						pa.AddAssign();
+					((MethodBlock) method_block).Pending_Assigns.Clear();
+				}
+			}
+		
+			int targetnumber = 0;
+
+			foreach ( Statement s in ((MethodBlock) method_block).onerror.statements )
+			{
+				if ( s is On_Error )
+				{
+					targetnumber = ((On_Error) s).AddTarget( (string) $5 );
+					break;	
+				}
+			}
+
+			// $ONERROR$1 = targetnumber + 1 (this Variable already was created in a on error stmt)
+			// This variable will be used in a switch to indicate de used label
+			// and to indicate the exit in a comparison with false.
+
+			Expression var = DecomposeQI (var1, l);
+			Expression value = new IntLiteral (targetnumber + 1);
+				
+			StatementExpression assign = new StatementExpression( ((ExpressionStatement) new Assign (var, value, l)), l);
+			current_block.AddStatement ( (Statement) assign );
+			
+		}
+		$$ = null;
+	  } 
+	| ON ERROR _mark_ RESUME NEXT
+	  { //Control goes to the statement immediately following the statement 
+	    //where the error occurred and execution continues from that point.
+		
+	  }
+	;
+       
+do_statement
+	: DO _mark_ opt_do_construct end_of_stmt
+	  {
+		push_into_stack((int)Start_block.DO, (Location)$2);
+		start_block();
+	  }	
+	  opt_statement_list
+	  opt_end_block
+          {
+		pop_out_of_stack((int)$7,lexer.Location);
+	  }
+	  _mark_ opt_do_construct
+	  {
+	  	Expression t_before = (Expression) $3;
+		Expression t_after = (Expression) $10;
+		Expression t;
+
+		if  ((t_before != null) && (t_after != null))
+			Report.Error (30238, (Location)$9, "'Loop' cannot have a condition if matching 'Do' has one.");
+
+		if ((t_before == null) && (t_after == null))
+			t = new BoolLiteral (true);
+		else
+			t = (t_before != null) ? t_before : t_after;
+			
+		DoOptions test_type = (t_before != null) ? DoOptions.TEST_BEFORE : DoOptions.TEST_AFTER;
+		
+		if (((do_type == DoOptions.WHILE) && (test_type == DoOptions.TEST_BEFORE)) ||
+		    ((do_type == DoOptions.UNTIL) && (test_type == DoOptions.TEST_AFTER)))
+			 t = new Unary (Unary.Operator.LogicalNot, (Expression) t, (Location)$2);
+			 
+		$$ = new Do ((Statement) end_block(), (Expression) t, test_type, (Location)$2);
+	  }
+	  ;
+
+opt_do_construct
+	: /* empty */ { $$ = null; }
+	| while_or_until boolean_expression
+	  {
+		do_type = (DoOptions)$1;
+		$$ = (Expression) $2;
+	  }
+	;
+
+while_or_until
+	: WHILE { $$ = DoOptions.WHILE; }
+	| UNTIL { $$ = DoOptions.UNTIL; }
+	;
+
+while_statement
+	: WHILE
+	{
+		push_into_stack((int)Start_block.WHILE, lexer.Location);
+		start_block();
+		oob_stack.Push (lexer.Location);
+	}
+	boolean_expression end_of_stmt
+	opt_statement_list
+	opt_end_block
+          {
+		Location l = (Location) oob_stack.Pop ();
+		pop_out_of_stack((int)$6,lexer.Location);
+		Block b = end_block();
+		Expression e = (Expression) $3;
+		$$ = new While ((Expression) e, (Statement) b, l);
+	}
+	;
+	
+for_statement
+	: FOR _mark_ identifier opt_type_spec ASSIGN expression TO expression opt_step end_of_stmt
+	  {
+		
+		push_into_stack((int)Start_block.FOR, (Location)$2);
+		if ($4 != null)
+		{
+			start_block();
+			ArrayList VarDeclaration = new ArrayList ();
+			VarDeclaration.Add (new VariableDeclaration ((string) $3, 
+				(Expression) $4, null, (Location)$2, null));
+
+			DictionaryEntry de = new DictionaryEntry (DecomposeQI("_local_vars_", (Location)$2), VarDeclaration);
+			Block b = declare_local_variables ((Expression) de.Key, (ArrayList) de.Value, (Location)$2);
+			current_block = b;
+		}
+		start_block();
+	  }
+	  opt_statement_list 
+   	  opt_end_block
+          {
+		pop_out_of_stack((int)$13,lexer.Location);
+  	  }
+          _mark_ opt_identifier 
+	  {
+		string s = $3.ToString();
+		string s1 = "";
+		if ($16 != null)
+			s1 = $16.ToString();		
+		if (s1 != "" && s != s1) {		
+			Report.Error(30070, (Location)$15, "Next Control Variable '"+s1+"' does not match with For Loop control variable '"+s+"'");    
+		}
+
+		Block inner_statement = end_block();
+		if (!inner_statement.HasGotoStatement && inner_statement.HasLabeledStatement)
+			Report.Error(30757, inner_statement.Parent.EndLocation, "'Goto "+inner_statement.LabelName+"' is not valid because '"+inner_statement.LabelName+"' is inside a 'For' or 'ForEach' statement that does not contain this statement.");
+		Location l = (Location)$2;
+		Expression for_var = (Expression) DecomposeQI ((string)$3, l);
+			
+		For f = new For (for_var, (Expression) $6, (Expression) $8, (Expression) $9, inner_statement, l);
+		if ($4 != null)
+		{
+			current_block.AddStatement (f);
+			$$ = end_block();
+		}
+		else
+			$$ = f;
+	}
+	;
+
+opt_step
+	: /* empty */ 		{ $$ = new IntLiteral ((Int32) 1); }
+	| STEP expression 	{ $$ = $2; }
+	;
+
+selection_statement
+	: if_statement
+	| select_statement
+	;
+
+if_statement
+	: if_statement_open opt_then end_of_stmt opt_statement_list 
+	   {
+		push_into_stack((int)Start_block.IF, (Location)$1);
+	   }	
+	   if_statement_rest
+	   {
+		$$ = $6;
+	   }
+	| if_statement_open THEN pre_embedded_statement opt_else_pre_embedded_statement
+	  {
+		if ($4 == null)
+		{
+			Location l = (Location) oob_stack.Pop ();
+			tmp_expr = (Expression)expr_stack.Pop(); 
+			$$ = new If ((Expression) tmp_expr, end_block(), l);
+		}
+		else
+		{
+			Location l = (Location) oob_stack.Pop ();
+			tmp_expr = (Expression)expr_stack.Pop(); 
+			tmp_block = (Block) tmp_blocks.Pop ();
+			$$ = new If ((Expression) tmp_expr, (Statement) tmp_block, end_block(), l);
+		}
+	  }
+	| if_statement_open THEN else_pre_embedded_statement
+	  {
+			Location l = (Location) oob_stack.Pop ();
+			tmp_expr = (Expression)expr_stack.Pop(); 
+			tmp_block = (Block) tmp_blocks.Pop ();
+			$$ = new If ((Expression) tmp_expr, (Statement) tmp_block, end_block(), l);
+	  }
+	;
+
+pre_embedded_statement
+	: embedded_statement 
+	  {
+		if ($1 != null)
+			current_block.AddStatement ((Statement) $1);
+	  } 
+	;	
+
+opt_else_pre_embedded_statement
+	: /* empty */
+	| else_pre_embedded_statement
+	;
+	
+else_pre_embedded_statement	
+	: ELSE
+	  {
+		Block bl = end_block(); 
+        tmp_blocks.Push(bl); 
+        
+	  	start_block();
+	  }
+	| ELSE embedded_statement 
+	  {
+		Block bl = end_block(); 
+        tmp_blocks.Push(bl); 
+        
+	  	start_block();
+		if ($2 != null)
+			current_block.AddStatement ((Statement) $2);
+	  } 
+	;	
+
+/*FIXME:if without end if not working. Error line shown is nor correct*/
+if_statement_open
+	: IF _mark_
+	  {
+	   	oob_stack.Push (lexer.Location);
+	  }
+		boolean_expression 
+	  {
+	   	start_block();
+	   	tmp_expr = (Expression) $4;
+	   	expr_stack.Push(tmp_expr);
+		$$ = (Location)$2;
+	  }
+	 ;
+
+opt_then
+	: /* empty */
+	| THEN
+	;
+	
+if_statement_rest
+	: 
+	  opt_end_block 
+	  { 
+		Location l = (Location) oob_stack.Pop ();
+		pop_out_of_stack((int)$1,lexer.Location);
+       		Expression expr = (Expression)expr_stack.Pop(); 
+		$$ = new If ((Expression) expr, (Statement) end_block(), l);
+	  }	  
+	| 
+	  ELSE end_of_stmt 
+	  { 
+	  	Block bl = end_block(); 
+	        tmp_blocks.Push(bl); 
+	  	start_block();
+	  }
+	  opt_statement_list
+	  opt_end_block	
+	  {
+		Location l = (Location) oob_stack.Pop ();
+		pop_out_of_stack((int)$5,lexer.Location);
+                tmp_expr = (Expression)expr_stack.Pop(); 
+                tmp_block = (Block) tmp_blocks.Pop(); 
+		$$ = new If ((Expression) tmp_expr, (Statement) tmp_block, (Statement) end_block(), l);
+	  }	
+	|	
+	  opt_elseif boolean_expression opt_then 
+	  { 
+    	        tmp_expr = (Expression) $2;                                                  
+                expr_stack.Push(tmp_expr);                                                 
+	  	tmp_block = end_block();
+                tmp_blocks.Push(tmp_block);
+	  	start_block();
+	  }
+	  end_of_stmt opt_statement_list	
+	  else_if_statement_rest
+	  {
+		Statement stmt = (Statement) statement_stack.Pop();
+                Block bl = (Block) tmp_blocks.Pop();  
+	   	Expression expr =  (Expression)expr_stack.Pop();  
+		Location l = (Location) oob_stack.Pop ();
+                $$ = (Statement) new If ((Expression) expr, (Statement) bl , stmt , l); 
+	  }
+	;
+	
+	
+else_if_statement_rest
+	:
+	  ELSE end_of_stmt 
+	  { 
+	  	Block bl = end_block();
+                tmp_blocks.Push(bl);
+	  	start_block();
+	  }
+	  opt_statement_list
+	  opt_end_block	
+	  {
+		Location l = (Location) oob_stack.Pop ();
+		pop_out_of_stack((int)$5,lexer.Location);
+		oob_stack.Push (l);
+	   	Expression expr = (Expression)expr_stack.Pop(); 
+	   	Block bl = (Block)tmp_blocks.Pop(); 
+                Statement stmt = (Statement) new If ((Expression) expr,  (Statement) bl , (Statement)  end_block(), l);
+                statement_stack.Push(stmt);
+	  }	
+ 	| 
+	  opt_elseif boolean_expression opt_then 
+	  { 
+                expr_stack.Push((Expression) $2);                                                 
+	  	Block bl = end_block();
+                tmp_blocks.Push(bl);
+	  	start_block();
+	  }
+	  end_of_stmt opt_statement_list	
+	  else_if_statement_rest
+	  {
+		Location l = (Location) oob_stack.Pop ();
+		oob_stack.Push (l);
+		Statement tmp_stmt = (Statement)statement_stack.Pop();
+                Block bl = (Block) tmp_blocks.Pop();  
+	   	Expression expr =  (Expression)expr_stack.Pop();  
+		Statement stmt = (Statement) new If ((Expression) expr, (Statement) bl, tmp_stmt , l);
+                statement_stack.Push(stmt);
+	  }	     
+        |
+	  opt_end_block
+	  {
+		Location l = (Location) oob_stack.Pop ();
+		pop_out_of_stack((int)$1,lexer.Location);
+		oob_stack.Push (l);
+	   	Expression expr = (Expression)expr_stack.Pop(); 
+                Statement stmt = (Statement) new If ((Expression) expr, (Statement)  end_block(), l);
+                statement_stack.Push(stmt);
+	  }
+	;
+
+/*FIXME:Select without an expression is showing a parser error instead of a expression missing error*/	
+select_statement
+	: SELECT 
+	  _mark_ opt_case expression end_of_stmt
+	  { 
+		push_into_stack((int)Start_block.SELECT, (Location)$2);
+		oob_stack.Push (lexer.Location);
+		switch_stack.Push (current_block);
+	  }	
+	  opt_case_sections
+	  opt_end_block
+          {
+		pop_out_of_stack((int)$8,lexer.Location);
+		current_block = (Block) switch_stack.Pop ();
+		$$ = new Switch ((Expression) $4, (ArrayList) $7, (Location) oob_stack.Pop ());
+	  }	  
+	;
+
+opt_case_sections
+	: /* empty */ 	{ $$ = null; }
+	| case_sections { $$ = $1; }
+	;
+	
+case_sections
+	: case_sections case_section
+	  {
+		ArrayList sections = (ArrayList) $1;
+
+		sections.Add ($2);
+		$$ = sections;
+	  }
+	| case_section
+	  {
+		ArrayList sections = new ArrayList ();
+
+		sections.Add ($1);
+		$$ = sections;
+	  }
+	;
+
+ends 
+	: end_of_stmt
+	| ends end_of_stmt
+	;
+	
+
+case_section
+	: CASE case_clauses ends
+	  { 
+	  	start_block();
+	  }
+	  opt_statement_list
+	  {
+	  	//Block topmost = current_block;
+		Block topmost = end_block();
+		
+		while (topmost.Implicit)
+			topmost = topmost.Parent;
+			
+		// FIXME: This is a horrible hack which MUST go			
+		topmost.statements.Add (new Break (lexer.Location));
+	  	$$ = new SwitchSection ((ArrayList) $2, topmost);
+	  }
+	| CASE ELSE ends
+	    /* FIXME: we should somehow flag an error 
+	       (BC30321 'Case' cannot follow a 'Case Else' 
+	       in the same 'Select' statement.) 
+	       if Case Else is not the last of the Case clauses
+	    */
+	  { 
+	  	start_block();
+	  }	
+	  opt_statement_list
+	  { 
+	  	//Block topmost = current_block;
+		Block topmost = end_block();
+
+		while (topmost.Implicit)
+			topmost = topmost.Parent;
+			
+		// FIXME: This is a horrible hack which MUST go			
+		topmost.statements.Add (new Break (lexer.Location));
+		
+		ArrayList a = new ArrayList();
+		a.Add (new SwitchLabel (null, SwitchLabel.LabelType.Else, Binary.Operator.TOP, lexer.Location));			
+	  	$$ = new SwitchSection ((ArrayList) a, topmost);	  	
+	  }
+	;	  
+	
+case_clauses
+	: case_clause
+	  {
+		ArrayList labels = new ArrayList ();
+		labels.Add ($1);
+		$$ = labels;
+	  }	
+	| case_clauses COMMA case_clause
+	  {
+		ArrayList labels = (ArrayList) ($1);
+		labels.Add ($3);
+
+		$$ = labels;
+	  }	
+	;
+	
+case_clause
+	: opt_is comparison_operator expression
+	  {
+	  	$$ = new SwitchLabel ((Expression) $3, SwitchLabel.LabelType.Operator, (Binary.Operator) $2, lexer.Location);
+	  }
+	| expression
+	  {
+	  	$$ = new SwitchLabel ((Expression) $1, SwitchLabel.LabelType.Label, Binary.Operator.TOP, lexer.Location);
+	  }
+	| expression TO expression
+        {
+	  	$$ = new SwitchLabel ((Expression) $1, (Expression) $3, SwitchLabel.LabelType.Range,
+					 Binary.Operator.TOP, lexer.Location);
+        }
+
+	;
+	
+opt_is 
+	: /* empty */
+	| IS
+	;
+
+comparison_operator
+	: OP_LT 
+	  {
+		$$ = Binary.Operator.LessThan;
+	  }
+	| OP_GT
+	  {
+		$$ = Binary.Operator.GreaterThan;
+	  }
+	| OP_GE
+	  {
+		$$ = Binary.Operator.GreaterThanOrEqual;
+	  }
+	| OP_LE
+	  {
+		$$ = Binary.Operator.LessThanOrEqual;
+	  }
+	| OP_NE
+	  {
+		$$ = Binary.Operator.Inequality;
+	  }
+	| ASSIGN
+	  {
+		$$ = Binary.Operator.Equality;
+	  }
+	;
+
+opt_case
+	: /* empty */
+	| CASE
+	;
+
+expression_statement
+	: statement_expression 
+	  {
+		 $$ = $1; 
+	  }
+	;
+
+
+statement_expression
+	: invocation_expression		{ $$ = new StatementExpression ((ExpressionStatement) $1, lexer.Location);  }
+	| object_creation_expression	{ $$ = new StatementExpression ((ExpressionStatement) $1, lexer.Location);  }
+	| qualified_identifier		{ 
+						Expression e = Parser.DecomposeQI ((string)$1, lexer.Location);
+						e = new Invocation (e, new ArrayList (), lexer.Location);
+						$$ = new StatementExpression ((ExpressionStatement) e, lexer.Location);  
+					}
+	| assignment_expression		
+	{
+		if($1 != null) 
+			$$ = new StatementExpression ((ExpressionStatement) $1, lexer.Location);  
+		else
+			$$ = null;
+	}
+	;
+
+object_creation_expression
+	: NEW type OPEN_PARENS _mark_ opt_argument_list CLOSE_PARENS
+	  {
+		$$ = new New ((Expression) $2, (ArrayList) $5, (Location)$4);
+	  }
+	| NEW type _mark_
+	  {
+		$$ = new New ((Expression) $2, new ArrayList(), (Location)$3);
+	  }
+	;
+	
+array_creation_expression
+	: object_creation_expression opt_rank_specifiers _mark_ array_initializer 
+	  {
+	  	New n = (New) $1;
+	  	ArrayList dims = new ArrayList();
+	  	
+	  	if (n.Arguments != null) {
+		  	foreach (Argument a in n.Arguments) {
+		  		dims.Add (a.Expr);
+		  	}
+		}
+			
+	  	Expression atype = n.RequestedType;
+
+		if ($2 != null)
+			atype = DecomposeQI (atype.ToString () + VariableDeclaration.BuildRanks ((ArrayList)$2, true, (Location)$3), (Location)$3);
+
+		ArrayList init = (ArrayList) $4;
+		if (init.Count == 0)
+			init = null;
+  	
+	  	if (VariableDeclaration.IndexesSpecifiedInRank(dims)) {
+	  		VariableDeclaration.VBFixIndexList (ref dims);
+	  		$$ = new ArrayCreation (atype, dims, "", init, (Location)$3); 
+	  	}
+	  	else
+	  	{
+	  		string rank = VariableDeclaration.BuildRank (dims);
+	  		$$ = new ArrayCreation (atype, rank, (ArrayList) $4, (Location)$3); 
+	  	}
+	  	//Console.WriteLine ("Creating a new array of type " + (atype.ToString()) + " with rank '" + dims + "'");
+	  }
+	;	
+
+new_expression
+	: object_creation_expression
+	| array_creation_expression
+	;
+
+declaration_statement
+	: _mark_ local_variable_declaration 
+	  {
+		if ($2 != null){
+			DictionaryEntry de = (DictionaryEntry) $2;
+			$$ = declare_local_variables ((Expression) de.Key, (ArrayList) de.Value, (Location)$1);
+		}
+	  }
+	| local_constant_declaration 
+	  {
+		if ($1!= null){
+			DictionaryEntry de = (DictionaryEntry) $1;
+
+			$$ = declare_local_constant ((Expression) de.Key, (ArrayList) de.Value);
+		}
+	  }
+	| STATIC _mark_ opt_dim_stmt variable_declarators
+          {
+	  	//Static variables may not be declared in structures.
+                if (($4 != null) && !(current_container is Struct)) {
+			Block block = current_block ;
+			
+			DictionaryEntry de = new DictionaryEntry (DecomposeQI("_local_vars_", (Location)$2), $4);
+			
+			int mod = (int) current_modifiers;
+	
+			VariableDeclaration.FixupTypes ((ArrayList) de.Value);
+			VariableDeclaration.FixupArrayTypes ((ArrayList) de.Value);
+	
+			if (current_container is Module)
+				mod = mod | Modifiers.STATIC;
+	
+			if ((mod & Modifiers.Accessibility) == 0)
+				mod |= Modifiers.PRIVATE;
+	
+			foreach (VariableDeclaration var in (ArrayList) de.Value){
+				Location l = var.Location;
+				Field field = new Field (var.type, mod, var.identifier,
+							var.expression_or_array_initializer,
+							null, l);
+				
+			   while ( !(block is MethodBlock) && (block.Parent != null) )
+			      block = block.Parent;
+					
+			   field.Name = @"$STATIC$" + ((MethodBlock) block).MethodName + @"$" + ((Location) $2).Row + @"$" + field.Name;
+			   CheckDef (current_container.AddField (field), field.Name, l);
+			   var.Alias = field.Name;
+
+			   //To do initialization only once.
+			   if( var.expression_or_array_initializer != null ) { //Like: Static a as Integer = 10
+		
+			      //Declare StaticLocalInitFlag Field.
+			      Expression init = DecomposeQI ("Microsoft.VisualBasic.CompilerServices.StaticLocalInitFlag", l);
+			      init = (Expression) new New (init, null, l);
+			
+			      Field field_init = new Field ( ((New)init).RequestedType  , mod, var.identifier, init, null, l);
+			      field_init.Name = field.Name+@"$Init";
+			      CheckDef (current_container.AddField (field_init), field_init.Name, l);
+
+			      //Declare If statement, to verify if the static variable was initialized.
+			      //If( ((Microsoft.VisualBasic.CompilerServices.StaticLocalInitFlag) localStaticvar).State != 1)
+			      Expression left = DecomposeQI (field_init.Name + ".State", l);
+			      Expression right = (Expression) new IntLiteral (1);
+			      Expression boolean_expression = new Binary (Binary.Operator.Inequality, left, right, l);
+			      boolean_expression = SetValueRequiredFlag (boolean_expression);
+			      start_block();
+			        
+			         //Then
+			         left = DecomposeQI (field_init.Name, l);
+			         ArrayList list = new ArrayList ();
+			         list.Add ( new Argument (left, Argument.AType.Expression) );
+				
+			         left = DecomposeQI ("System.Threading.Monitor.Enter", l);
+			         StatementExpression stex = new StatementExpression (
+								(ExpressionStatement)new Invocation (left, list, l),
+								l);
+			         current_block.AddStatement ((Statement) stex );
+
+
+			         //Try
+				 start_block();
+
+  				    //IF ( localStaticvar$Init.State == 0 )
+				    left = DecomposeQI (field_init.Name + ".State", l);
+		                    right = (Expression) new IntLiteral (0);
+				    Expression boolean_expression2 = new Binary (Binary.Operator.Equality, left, right, l);
+				    boolean_expression2 = SetValueRequiredFlag (boolean_expression2);
+				    start_block();
+
+				       //  localStaticvar$Init.State = 1
+				       left = DecomposeQI (field_init.Name + ".State", l);
+			               right = (Expression) new IntLiteral (2);
+				       ExpressionStatement assign = (ExpressionStatement) new Assign (left, right, l);
+				       stex = new StatementExpression (assign, l);
+				       current_block.AddStatement ((Statement) stex );
+											
+				       // localStaticvar = initvalue
+				       left = DecomposeQI (field.Name, l);
+				       assign = (ExpressionStatement) new Assign (left, (Expression) var.expression_or_array_initializer , l);
+				       stex = new StatementExpression (assign, l);
+				       current_block.AddStatement ((Statement) stex );
+			
+				       var.expression_or_array_initializer = null;
+
+				    //Else
+				    tmp_block = end_block();
+				    start_block();
+  					
+				       //IF ( localStaticvar$Init.State == 2 )
+				       left = DecomposeQI (field_init.Name + ".State", l);
+		                           right = (Expression) new IntLiteral (2);
+				   	   Expression boolean_expression3 = new Binary (Binary.Operator.Equality, left, right, l);
+					   boolean_expression3 = SetValueRequiredFlag (boolean_expression3);
+					   start_block();
+					   
+					   //THROW New Microsoft.VisualBasic.CompilerServices.IncompleteInitialization()
+			                   left = DecomposeQI ("Microsoft.VisualBasic.CompilerServices.IncompleteInitialization", l);
+			                   left = (Expression) new New (left, null, l);
+					   Statement stmt = (Statement) new Throw (left, l);
+					    current_block.AddStatement (stmt);
+
+					//End If
+					stmt = (Statement) new If (boolean_expression3, (Statement) end_block(), l);
+					current_block.AddStatement (stmt);
+					
+				    //End If
+				    stmt = (Statement) new If (boolean_expression2, (Statement) tmp_block, (Statement) end_block(), l);
+			            current_block.AddStatement (stmt);
+
+			 	 //End Try
+				 tmp_block = end_block();
+
+				 //Finally
+				 start_block();
+				 // ((Microsoft.VisualBasic.CompilerServices.StaticLocalInitFlag) localStaticvar).State = 1
+				 left = DecomposeQI (field_init.Name + ".State", l);
+		                 right = (Expression) new IntLiteral (1);
+				 assign = (ExpressionStatement) new Assign (left, right, l);
+				 stex = new StatementExpression (assign, l);
+				 current_block.AddStatement ((Statement) stex );
+
+				    // System.Threading.Monitor.Exit( field$Init )
+				    left = DecomposeQI (field_init.Name, l);
+				    list.Clear();
+				    list.Add ( new Argument (left, Argument.AType.Expression) );
+				    left = DecomposeQI ("System.Threading.Monitor.Exit", l);
+				    stex = new StatementExpression (
+						(ExpressionStatement)new Invocation (left, list, l),
+						l);
+				    current_block.AddStatement ((Statement) stex );
+
+				 //End Finally
+				 stmt =  (Statement) new Try ((Block) tmp_block, new ArrayList(), null, (Block) end_block(), l);
+				 current_block.AddStatement (stmt);
+			
+			      //End If
+			      stmt = (Statement) new If (boolean_expression, (Statement) end_block(), l);
+			      current_block.AddStatement (stmt);
+			   }
+			}
+		
+			$$ = declare_local_variables ((Expression) de.Key, (ArrayList) de.Value, (Location) $2);
+		}
+		else {
+			if (current_container is Struct)
+				Report.Error ( 31400, (Location)$2,"Local variables within structures methods can't be declared 'Static'.");
+			$$ = null;
+		}	
+          }
+	;	 
+	
+local_variable_declaration
+	: DIM _mark_ variable_declarators 
+	  {
+		$$ = new DictionaryEntry (DecomposeQI("_local_vars_", (Location)$2), $3);		
+	  }
+ 	;
+
+	
+local_constant_declaration
+	: CONST constant_declarators
+	  {
+		if ($2 != null)
+			$$ = new DictionaryEntry (DecomposeQI("_local_consts_", lexer.Location), $2);
+		else
+			$$ = null;
+	  }
+	;	 
+	
+constant_declarators
+	: constant_declarator 
+	  {
+		ArrayList decl = new ArrayList ();
+		if ($1 != null) 
+			decl.Add ($1);
+			
+		$$ = decl;
+	  }
+	| constant_declarators COMMA constant_declarator
+	  {
+	  	ArrayList decls = (ArrayList) $1;
+		if ($3 != null)
+			decls.Add ($3);
+
+		$$ = $1;
+	  }
+	;
+
+constant_declarator
+	: _mark_ variable_name opt_type_decl opt_variable_initializer
+	  {
+		VarName vname = (VarName) $2;
+		string varname = (string) vname.Name;
+		current_rank_specifiers = (ArrayList) vname.Rank;
+		object varinit = $4;
+
+		if (varinit == null)
+			Report.Error (
+				30438, (Location)$1, "Constant should have a value"
+				);
+
+		if (vname.Type != null && $3 != null)
+			Report.Error (
+				30302, (Location)$1, 
+				"Type character cannot be used with explicit type declaration" );
+
+		Expression vartype = ($3 == null) ? ((vname.Type == null) ? TypeManager.system_object_expr : (Expression) vname.Type ) : (Expression) $3;
+
+		if (current_rank_specifiers != null) 
+		{
+			Report.Error (30424, (Location)$1, "Constant doesn't support array");
+			$$ = null;
+	  	}
+	  	else
+	  	  	$$ = new VariableDeclaration (varname, vartype, varinit, (Location)$1, null);
+	  }
+	;		
+
+variable_declarators
+	: variable_declarator 
+	  {
+		ArrayList decl = new ArrayList ();
+		decl.AddRange ((ArrayList) $1);
+		$$ = decl;
+	  }
+	| variable_declarators COMMA variable_declarator
+	  {
+		ArrayList decls = (ArrayList) $1;
+		decls.AddRange ((ArrayList) $3);
+		$$ = $1;
+	  }
+	;
+
+variable_declarator
+	: _mark_ variable_names opt_type_decl opt_variable_initializer
+	  {
+	    ArrayList names = (ArrayList) $2;
+		object varinit = $4;
+		ArrayList VarDeclarations = new ArrayList();
+	  	Expression vartype;
+	  	ArrayList a_dims = null;
+
+		if ((names.Count > 1) && (varinit != null)) 
+			Report.Error (
+				30671, (Location)$1, 
+				"Multiple variables with single type can not have " +
+				"a explicit initialization" );
+
+				
+		foreach (VarName vname in names)
+		{
+			string varname = (string) vname.Name;
+			current_rank_specifiers = (ArrayList) vname.Rank;
+			a_dims = null;
+			varinit = $4;
+
+			if (VariableDeclaration.IsArrayDecl (this) && $3.ToString().IndexOf('[') >= 0)
+                                Report.Error (
+                                      31087, (Location)$1,
+                                       "Array modifiers can not specified on both a variable and its type" );
+
+	  		if(vname.Type != null && $3 != null)
+				Report.Error (
+					30302, (Location)$1, 
+					"Type character cannot be used with explicit type declaration" );
+
+	  		// Some checking is required for particularly weird declarations
+	  		// like Dim a As Integer(,)
+	  		if ($3 is Pair) {
+	  			vartype = (Expression) ((Pair) $3).First;
+				
+	  			/*if ($4 != null && $4 is ArrayList)
+	  				Report.Error (205, "End of statement expected.");*/
+		  			
+				ArrayList args = (ArrayList) ((Pair) $3).Second;
+				if (current_rank_specifiers != null)
+					Report.Error (31087, (Location)$1,
+						 "Array types specified in too many places");	
+				
+				if (VariableDeclaration.IndexesSpecifiedInRank (args))	  	  
+					Report.Error (30638, (Location)$1,"Array bounds cannot appear in type specifiers.");	
+				
+				current_rank_specifiers = new ArrayList ();
+				current_rank_specifiers.Add (args);				
+	  		}
+	  		else
+				vartype = ($3 == null) ? ((vname.Type == null) ? TypeManager.system_object_expr : (Expression) vname.Type ) : (Expression) $3;
+
+			// if the variable is an array with explicit bound
+			// and having explicit initialization throw exception
+			if (current_rank_specifiers != null && varinit != null) 
+			{
+				bool broken = false;
+				foreach (ArrayList exprs in current_rank_specifiers)
+				{
+					foreach (Expression expr in exprs)
+					{
+						if (!((Expression)expr is EmptyExpression ))
+						{
+							Report.Error (
+								30672, (Location)$1, 
+								"Array declared with explicit bound " +
+								" can not have explicit initialization");
+							broken = true;
+							break;
+						}
+					}
+					if (broken)
+						break;
+				}
+	  		}
+			
+	  		/*
+	  		Check for a declaration like Dim a(2) or Dim a(2,3)
+	  		If this is the case, we must generate an ArrayCreationExpression
+	  		and, in case, add the initializer after the array has been created.
+	  		*/
+	  		if (VariableDeclaration.IsArrayDecl (this)) {	
+				if (VariableDeclaration.IndexesSpecified(current_rank_specifiers)) {   
+					a_dims = (ArrayList) current_rank_specifiers;
+					VariableDeclaration.VBFixIndexLists (ref a_dims);
+					varinit = VariableDeclaration.BuildArrayCreator(vartype, a_dims, (ArrayList) varinit, (Location)$1);
+				}
+				vartype = DecomposeQI (vartype.ToString() + VariableDeclaration.BuildRanks (current_rank_specifiers, false, (Location)$1), (Location)$1);
+			}
+
+			if (vartype is New) {
+				if (varinit != null) {
+					Report.Error (30205, (Location)$1, "End of statement expected");
+					$$ = null;
+				}
+				else
+				{
+					varinit = vartype;
+					vartype = ((New)vartype).RequestedType;
+				}
+			}
+	  		VarDeclarations.Add (new VariableDeclaration (varname, vartype, varinit, (Location)$1, null));
+	    }// end of for
+	    $$ = VarDeclarations;
+	  } 
+	;
+
+variable_names
+	: variable_name
+	  {
+		ArrayList list = new ArrayList ();
+		list.Add ($1);
+		$$ = list;
+	  }
+	| variable_names COMMA variable_name
+	  {
+		ArrayList list = (ArrayList) $1;
+		list.Add ($3);
+		$$ = list;
+	  }
+	;
+	
+variable_name
+	: identifier opt_type_character opt_array_name_modifier
+	  {
+		$$ = new VarName ($1, TypeManager.TypeToCoreTypeExpr ((Type) $2), $3);
+	  }
+	;
+
+opt_type_spec
+	: /* empty */	
+	  { 
+	  	$$ = null; 		
+	  }
+	| AS type	
+	  {
+		if ($2 != null) 
+	  		$$ = (Expression) $2;
+		else
+		{
+			Report.Error(30182, lexer.Location, "Identifier Expected");
+                	$$ = null;
+        	}
+	  }
+	;
+		
+opt_type_with_ranks
+	: opt_type_spec	
+	| AS type _mark_ rank_specifiers
+	  {
+		if ($2 == null)
+		{
+			Report.Error(30182,  (Location)$3, "Identifier Expected");
+                	$$ = null;
+		}
+		else
+			$$ = DecomposeQI ($2.ToString() + VariableDeclaration.BuildRanks ((ArrayList)$4, true, (Location)$3), (Location)$3);
+	  }
+	;
+	
+opt_type_decl
+	: opt_type_with_ranks
+	  {
+	  	$$ = $1;
+	  }
+	| AS NEW type
+	  {
+	  	New n = new New ((Expression)$3, null, lexer.Location);
+	  	$$ = (Expression) n;
+	  }
+	| AS NEW type OPEN_PARENS opt_argument_list CLOSE_PARENS 
+	  {
+	  	New n = new New ((Expression)$3, (ArrayList) $5, lexer.Location);
+	  	$$ = (Expression) n;
+	  }
+	/*| AS NEW type OPEN_PARENS ADDRESSOF expression CLOSE_PARENS 
+	  {
+	    ArrayList args = new ArrayList();
+		Argument arg = new Argument ((Expression) $6, Argument.AType.Expression);
+		args.Add (arg);
+		
+	  	New n = new New ((Expression)$3, (ArrayList) args, lexer.Location);
+	  	$$ = (Expression) n;
+	  }*/
+ 	;
+		
+opt_array_name_modifier
+	: /* empty */ 				{ $$ = null; }
+	| array_type_modifier			{ $$ = $1;   }
+	;
+	
+array_type_modifier
+	: rank_specifiers		{ $$ = $1; }
+	;
+	
+opt_variable_initializer
+	: /* empty */ 			{ $$ = null; }
+	| ASSIGN variable_initializer  	{ $$ = $2; }
+	;
+		
+variable_initializer
+	: expression
+	  {
+		Expression etmp = (Expression) $1;
+		etmp = SetValueRequiredFlag (etmp);
+		$$ = etmp;
+	  }
+	| array_initializer
+	  {
+		$$ = $1;
+	  }
+	
+	;	
+	
+array_initializer
+	: OPEN_BRACE CLOSE_BRACE
+	  {
+		ArrayList list = new ArrayList ();
+		$$ = list;
+	  }
+	| OPEN_BRACE variable_initializer_list CLOSE_BRACE
+	  {
+		$$ = (ArrayList) $2;
+	  }
+	;
+
+variable_initializer_list
+	: variable_initializer
+	  {
+		ArrayList list = new ArrayList ();
+		list.Add ($1);
+		$$ = list;
+	  }
+	| variable_initializer_list COMMA variable_initializer
+	  {
+		ArrayList list = (ArrayList) $1;
+		list.Add ($3);
+		$$ = list;
+	  }
+	;
+
+opt_rank_specifiers
+	: /* empty */
+	  {
+		  // $$ = "";
+		  $$ = null;
+	  }
+	| rank_specifiers
+	  {
+			$$ = $1;
+	  }
+	;      
+	
+rank_specifiers
+	: rank_specifier
+	  {
+		  ArrayList rs = new ArrayList();
+		  rs.Add ($1);
+		  $$ = rs;
+	  }
+	| rank_specifiers rank_specifier
+	  {
+		  ArrayList rs = (ArrayList) $1;
+		  rs.Add ($2);
+		  $$ = rs;
+	  }     	
+        ;	  	
+	
+rank_specifier
+	: OPEN_PARENS opt_dim_specifiers CLOSE_PARENS
+	  {
+		$$ = $2;
+	  }
+	;
+		
+opt_dim_specifiers
+	: /* empty */
+	  {
+	  	ArrayList ds = new ArrayList();
+	  	ds.Add (new EmptyExpression());
+	  	$$ = ds;
+	  }	
+	| expression
+	  {
+	  	ArrayList ds = new ArrayList();
+	  	ds.Add ((Expression) $1);
+	  	$$ = ds;
+	  }	
+	| opt_dim_specifiers COMMA expression
+	  {
+		ArrayList ds = (ArrayList) $1;
+	  	ds.Add ((Expression) $3);
+	  	$$ = ds;		
+	  }	
+	| opt_dim_specifiers COMMA 
+	  {
+		ArrayList ds = (ArrayList) $1;
+	  	ds.Add (new EmptyExpression());
+	  	$$ = ds;		
+	  }	
+	;
+	
+primary_expression
+	: literal 
+	| literal type_character
+	  {
+		$$ = $1;
+		
+		Constant literal = (Constant) $1;
+		Type literal_type = literal.GetValue ().GetType ();
+		Type typechar = (Type) $2;
+
+		if (literal_type == typechar)
+			//no conversion required
+			break;
+
+		if (literal_type == typeof (bool)) {
+			Report.Error (30687, lexer.Location, "Keyword cannot have a type character.");
+			break;
+		}
+
+		if (literal_type == typeof (DateTime) || literal_type == typeof (char) || literal_type == typeof (string) || typechar == typeof (string) ) {
+			Report.Error (30037, lexer.Location, "Character is not valid");
+			break;
+		}
+			
+		if (literal_type == typeof (int) || literal_type == typeof (short) || literal_type == typeof (long)) {
+			//integer literal
+			$$ = ConvertLiteral (literal, typechar);
+		} else
+		if (literal_type == typeof (float) || literal_type == typeof (double) || literal_type == typeof (decimal)) {
+			//real literal
+			if (typechar == typeof (int))
+				Report.Error (30037, lexer.Location, "Character is not valid.");
+			else
+			if (typechar == typeof (long))
+				Report.Error (30201, lexer.Location, "Expression expected.");
+			else
+				//Valid type char
+				$$ = ConvertLiteral (literal, typechar);
+		}/* FIXME: throw error here? */ 
+	  }
+	| parenthesized_expression
+	| this_access
+	| base_access
+	| qualified_identifier opt_type_character _mark_
+	  {
+		Expression left = DecomposeQI ((string) $1, (Location) $3);
+		if ($2 != null)
+			$$ = new DecoratedIdentifier (left, (Type) $2);
+		else
+			$$ = left;
+	  }
+	| get_type_expression
+	| member_access
+	| invocation_expression
+	//| element_access
+	| new_expression
+	| cast_expression
+	| error _mark_ 
+	     { Report.Error(30201,(Location)$2,"Expression expected"); $$ = (Expression)null;}
+	;
+
+literal
+	: boolean_literal
+	| integer_literal
+	| real_literal
+	| LITERAL_DATE			{ $$ = new DateLiteral ((DateTime)lexer.Value); }
+	| LITERAL_CHARACTER     { $$ = new CharLiteral ((char) lexer.Value); }
+	| LITERAL_STRING        { $$ = new StringLiteral ((string) lexer.Value); }
+	| NOTHING				{ $$ = NullLiteral.Null; }
+	;
+
+real_literal
+	: LITERAL_SINGLE        { $$ = new FloatLiteral ((float) lexer.Value); }
+	| LITERAL_DOUBLE        { $$ = new DoubleLiteral ((double) lexer.Value); }
+	| LITERAL_DECIMAL       { $$ = new DecimalLiteral ((decimal) lexer.Value); }
+	;
+
+integer_literal
+	: LITERAL_INTEGER       {
+		object v = lexer.Value;
+
+		if (v is int)
+			$$ = new IntLiteral ((Int32)v); 
+		else if (v is short)
+			$$ = new ShortLiteral ((Int16)v);
+		else if (v is long)
+			$$ = new LongLiteral ((Int64)v);
+		else
+			Console.WriteLine ("Unexpected result from scanner");
+			
+	  }
+	;
+
+boolean_literal
+	: TRUE			{ $$ = new BoolLiteral (true); }
+	| FALSE			{ $$ = new BoolLiteral (false); }
+	;
+
+parenthesized_expression
+	: OPEN_PARENS expression CLOSE_PARENS
+	  { $$ = $2; }
+	;
+
+member_access
+	: primary_expression DOT _mark_ identifier
+	  {
+	  	if ($1 != null) {
+	  		string id_name = (string)$4;
+	  		if (id_name.ToUpper() == "NEW")
+	  			id_name = ".ctor";
+			$$ = new MemberAccess ((Expression) $1, id_name, (Location)$3);
+		}
+		else
+		{
+			if (with_stack.Count > 0) {
+				Expression e = (Expression) with_stack.Peek();
+				$$ = new MemberAccess (e, (string) $4, (Location)$3);
+			}
+			else
+			{
+				// OOps
+			}
+		}
+	  }
+/*	| primary_expression DOT _mark_ NEW
+	  {
+		$$ = new MemberAccess ((Expression) $1, (string) ".ctor", (Location)$3);
+	  }	  */
+	| predefined_type DOT _mark_ identifier
+	  {
+	  	if ($1 != null)
+			$$ = new MemberAccess ((Expression) $1, (string) $4, (Location)$3);
+		else
+		{
+			if (with_stack.Count > 0) {
+				Expression e = (Expression) with_stack.Peek();
+				$$ = new MemberAccess (e, (string) $4, (Location)$3);
+			}
+			else
+			{
+				// OOps
+			}
+		}
+	  }
+	;
+	
+predefined_type
+	: builtin_types
+	;
+
+invocation_expression
+// To support Mid$()
+	: primary_expression opt_dolar_sign OPEN_PARENS opt_argument_list _mark_ CLOSE_PARENS
+	  {
+		if ($1 == null) {
+			Location l = (Location)$5;
+			Report.Error (1, l, "THIS IS CRAZY");
+		}
+		$$ = new Invocation ((Expression) $1, (ArrayList) $4, (Location)$5);
+		// Console.WriteLine ("Invocation: {0} with {1} arguments", $1, ($4 != null) ? ((ArrayList) $4).Count : 0);
+	  }
+	| CALL primary_expression OPEN_PARENS opt_argument_list _mark_ CLOSE_PARENS
+	  {
+		if ($2 == null) {
+			Location l = (Location)$5;
+			Report.Error (1, l, "THIS IS CRAZY");
+		}
+		$$ = new Invocation ((Expression) $2, (ArrayList) $3, (Location)$5);
+//		Console.WriteLine ("Invocation: {0} with {1} arguments", $2, ($3 != null) ? ((ArrayList) $3).Count : 0);
+	  }
+	| primary_expression EXCLAMATION _mark_ identifier // FIXME : This should be identifier-or-keyword
+	  {
+		if ($1 == null) {
+			Location l = (Location)$3;
+			Report.Error (1, l, "THIS IS CRAZY");
+		}
+		
+		ArrayList args = new ArrayList ();
+		Expression etmp = new StringLiteral ((string)$4);
+		
+		args.Add (new Argument (etmp, Argument.AType.Expression));
+		$$ = new Invocation ((Expression) $1, args, (Location)$3);
+	  }
+	;
+
+opt_dolar_sign
+	: DOLAR_SIGN
+	| /*empty*/
+	;	
+
+base_access
+	: MYBASE DOT IDENTIFIER
+	  {
+		string id_name = (string) $3;
+		if (id_name.ToUpper() == "NEW")
+			id_name = "New";
+		$$ = new BaseAccess (id_name, lexer.Location);
+	  }
+/*	| MYBASE DOT NEW
+	  {
+		$$ = new BaseAccess ("New", lexer.Location);
+	  }*/
+	;	
+
+opt_argument_list
+	: argument_list
+	  { 
+		/*
+		   The 'argument' rule returns an 'empty' argument
+		   of type NoArg (used for default arguments in invocations)
+		   if no arguments are actually passed.
+
+		   If there is only one argument and it is o type NoArg,
+		   we return a null (empty) list
+		*/
+		ArrayList args = (ArrayList) $1;
+		if (args.Count == 1 &&
+		    ((Argument)args[0]).ArgType == Argument.AType.NoArg)
+			$$ = null;
+		else
+			$$ = $1;
+	  }
+	;
+
+argument_list
+	: argument
+	  {
+		ArrayList list = new ArrayList ();
+		list.Add ($1);
+		$$ = list;
+	  }
+	| argument_list COMMA argument
+	  {
+		ArrayList list = (ArrayList) $1;
+		list.Add ($3);
+		$$ = list;
+	  }
+	;
+
+argument
+	: expression
+	  {
+		$$ = new Argument ((Expression) $1, Argument.AType.Expression);
+	  }
+	| BYREF variable_reference
+	  {
+		$$ = new Argument ((Expression) $2, Argument.AType.Ref);
+	  }
+	| /* empty */
+	  {
+	  	$$ = new Argument (new EmptyExpression (), Argument.AType.NoArg);
+	  }
+	| ADDRESSOF expression
+	  {
+		$$ = new Argument ((Expression) $2, Argument.AType.AddressOf);
+	  }
+	| identifier ATTR_ASSIGN expression 
+	  {
+		$$ = new Argument ((string) $1, (Expression) $3, Argument.AType.Expression);
+	  }
+	;
+
+variable_reference
+	: expression {/* note ("section 5.4"); */  $$ = $1;  }
+	;
+
+		
+expression
+	: conditional_xor_expression { $$ = $1; } 
+	/*| assignment_expression*/
+	;
+
+opt_expression
+	: /* empty */
+	| expression
+	;
+		
+this_access
+	: ME
+	  {
+		$$ = new This (current_block, lexer.Location);
+	  }
+	| MYCLASS
+	  {
+		$$ = new This (This.TypeOfAccess.MyClass, current_block, lexer.Location);
+	  }
+	;
+
+cast_expression
+        : DIRECTCAST OPEN_PARENS expression COMMA type CLOSE_PARENS
+	  {
+	  	// TODO
+	  } 
+	| CTYPE OPEN_PARENS expression COMMA type CLOSE_PARENS
+	  {
+		  $$ = new Cast ((Expression) $5, (Expression) $3, lexer.Location);
+	  } 	
+        | cast_operator OPEN_PARENS expression CLOSE_PARENS
+	  {
+		  $$ = new Cast ((Expression) $1, (Expression) $3, lexer.Location);
+	  }  	
+	;
+	
+cast_operator
+	: CBOOL		{ $$ = TypeManager.system_boolean_expr; 	}
+	| CBYTE		{ $$ = TypeManager.system_byte_expr;	 	}
+	| CCHAR		{ $$ = TypeManager.system_char_expr; 		}
+	| CDATE		{ $$ = TypeManager.system_date_expr;	 	}
+	| CDBL		{ $$ = TypeManager.system_double_expr; 		}
+	| CDEC		{ $$ = TypeManager.system_decimal_expr; 	}
+	| CINT		{ $$ = TypeManager.system_int32_expr; 		}
+	| CLNG		{ $$ = TypeManager.system_int64_expr; 		}
+	| COBJ		{ $$ = TypeManager.system_object_expr; 		}
+	| CSHORT	{ $$ = TypeManager.system_int16_expr; 		}
+	| CSNG		{ $$ = TypeManager.system_single_expr; 		}
+	| CSTR		{ $$ = TypeManager.system_string_expr; 		}
+	;
+
+get_type_expression
+	: GETTYPE OPEN_PARENS _mark_ type CLOSE_PARENS
+	  {
+		$$ = new TypeOf ((Expression) $4, (Location)$3);
+  	  }
+	;
+	
+exponentiation_expression
+	: prefixed_unary_expression
+	| exponentiation_expression OP_EXP _mark_ prefixed_unary_expression
+	  {
+		$$ = new Binary (Binary.Operator.Exponentiation,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }			  	
+	;
+	
+prefixed_unary_expression
+	: primary_expression
+	| PLUS _mark_ prefixed_unary_expression
+	  {
+	  	//FIXME: Is this rule correctly defined ?
+	  	$$ = new Unary (Unary.Operator.UnaryPlus, (Expression) $3, (Location)$2);
+	  }
+	| MINUS _mark_ prefixed_unary_expression
+	  {
+	  	//FIXME: Is this rule correctly defined ?
+		$$ = new Unary (Unary.Operator.UnaryNegation, (Expression) $3, (Location)$2);
+	  }
+	;
+
+multiplicative_expression
+	: exponentiation_expression
+	| multiplicative_expression STAR _mark_ prefixed_unary_expression
+	  {
+		$$ = new Binary (Binary.Operator.Multiply,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| multiplicative_expression DIV _mark_ prefixed_unary_expression
+	  {
+		$$ = new Binary (Binary.Operator.Division,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	;
+
+integer_division_expression
+	: multiplicative_expression
+	| integer_division_expression OP_IDIV _mark_ multiplicative_expression
+          {
+	  	//FIXME: Is this right ?
+		$$ = new Binary (Binary.Operator.IntDivision,
+			   (Expression) $1, (Expression) $4, (Location)$3);
+          }
+	;
+
+mod_expression
+	: integer_division_expression
+	| mod_expression MOD _mark_ integer_division_expression
+	  {
+	      $$ = new Binary (Binary.Operator.Modulus,
+			       (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	;
+	
+additive_expression
+	: mod_expression
+	| additive_expression PLUS _mark_ mod_expression
+	  {
+		$$ = new Binary (Binary.Operator.Addition,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| additive_expression MINUS _mark_ mod_expression
+	  {
+		$$ = new Binary (Binary.Operator.Subtraction,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	;
+
+concat_expression
+	: additive_expression
+	| concat_expression OP_CONCAT _mark_ additive_expression
+          {
+	      // FIXME: This should only work for String expressions
+	      // We probably need to use something from the runtime
+	      $$ = new StringConcat((Location)$3,
+			       (Expression) $1, (Expression) $4);
+	  }	
+	;
+
+
+shift_expression
+	: concat_expression
+	| shift_expression OP_SHIFT_LEFT _mark_ concat_expression
+	  {
+	  	$$ = new Binary(Binary.Operator.LeftShift, (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| shift_expression OP_SHIFT_RIGHT _mark_ concat_expression
+	  {
+	  	$$ = new Binary(Binary.Operator.RightShift, (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	;
+
+relational_expression
+	: shift_expression
+	| relational_expression LIKE _mark_ shift_expression
+	  {
+		$$ = new Binary (Binary.Operator.Like,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| relational_expression ASSIGN _mark_ shift_expression
+	  {
+		$$ = new Binary (Binary.Operator.Equality,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| relational_expression OP_NE _mark_ shift_expression
+	  {
+		$$ = new Binary (Binary.Operator.Inequality, 
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }	  
+	| relational_expression OP_LT _mark_ shift_expression
+	  {
+		$$ = new Binary (Binary.Operator.LessThan,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| relational_expression OP_GT _mark_ shift_expression
+	  {
+		$$ = new Binary (Binary.Operator.GreaterThan,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| relational_expression OP_LE _mark_ shift_expression
+	  {
+		$$ = new Binary (Binary.Operator.LessThanOrEqual,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| relational_expression OP_GE _mark_ shift_expression
+	  {
+		$$ = new Binary (Binary.Operator.GreaterThanOrEqual,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| relational_expression IS _mark_ shift_expression
+	  {
+		$$ = new Binary (Binary.Operator.Is,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| TYPEOF shift_expression _mark_ IS type
+	  {
+		//FIXME: Is this rule correctly defined ?
+		$$ = new Is ((Expression) $2, (Expression) $5, (Location)$3);
+	  }
+	;
+
+negation_expression
+	: relational_expression
+	| NOT _mark_ negation_expression 
+	  {
+	  	//FIXME: Is this rule correctly defined ?
+		$$ = new Unary (Unary.Operator.LogicalNot, (Expression) $3, (Location)$2);
+	  }
+	;
+	
+conditional_and_expression
+	: negation_expression
+	| conditional_and_expression AND _mark_ negation_expression
+	  {
+		$$ = new Binary (Binary.Operator.BitwiseAnd,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| conditional_and_expression ANDALSO _mark_ negation_expression
+	  {	// FIXME: this is likely to be broken
+		$$ = new Binary (Binary.Operator.LogicalAnd,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	;
+
+conditional_or_expression
+	: conditional_and_expression
+	| conditional_or_expression OR _mark_ conditional_and_expression
+	  {
+		$$ = new Binary (Binary.Operator.BitwiseOr,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	| conditional_or_expression ORELSE _mark_ conditional_and_expression
+	  {	// FIXME: this is likely to be broken
+		$$ = new Binary (Binary.Operator.LogicalOr,
+			         (Expression) $1, (Expression) $4, (Location)$3);
+	  }
+	;
+
+conditional_xor_expression
+	: conditional_or_expression
+	| conditional_xor_expression XOR _mark_ conditional_or_expression
+	{
+   	      $$ = new Binary (Binary.Operator.ExclusiveOr,
+			       (Expression) $1, (Expression) $4, (Location)$3);
+	}
+	;
+
+assignment_expression
+	: prefixed_unary_expression ASSIGN _mark_ expression
+	  { 
+		// $$ = new Assign ((Expression) $1, (Expression) $4, (Location)$3);
+		
+                bool bval = false;
+
+		// Avoid re-assignment of object inside with block
+		// TODO : Similarly do for other assignments
+
+		if (with_stack.Count > 0) {
+			Expression estack = (Expression) $1;
+
+                        string tempstring = Convert.ToString(estack);
+
+		 	if(with_hash.Contains(tempstring)) 
+                               	bval = true;
+                       if (!bval) 
+                               $$ = new Assign ((Expression) $1, (Expression) $4, (Location)$3);
+                       else
+				$$ = null;
+                }
+                else 
+                        $$ = new Assign ((Expression) $1, (Expression) $4, (Location)$3);
+          }
+
+
+	| prefixed_unary_expression OP_EXP ASSIGN _mark_ expression
+	  {
+		Location l = (Location)$4;
+		$$ = new CompoundAssign (
+			Binary.Operator.Exponentiation, (Expression) $1, (Expression) $5, l);
+	  }
+	| prefixed_unary_expression STAR ASSIGN _mark_ expression
+	  {
+		Location l = (Location)$4;
+		$$ = new CompoundAssign (
+			Binary.Operator.Multiply, (Expression) $1, (Expression) $5, l);
+	  }
+	| prefixed_unary_expression DIV ASSIGN _mark_ expression
+	  {
+		Location l = (Location)$4;
+		$$ = new CompoundAssign (
+			Binary.Operator.Division, (Expression) $1, (Expression) $5, l);
+	  }
+	| prefixed_unary_expression PLUS ASSIGN _mark_ expression
+	  {
+		Location l = (Location)$4;
+		$$ = new CompoundAssign (
+			Binary.Operator.Addition, (Expression) $1, (Expression) $5, l);
+	  }
+	| prefixed_unary_expression MINUS ASSIGN _mark_ expression
+	  {
+		Location l = (Location)$4;
+		$$ = new CompoundAssign (
+			Binary.Operator.Subtraction, (Expression) $1, (Expression) $5, l);
+	  }
+	| prefixed_unary_expression OP_SHIFT_LEFT ASSIGN _mark_ expression
+	  {
+		Location l = (Location)$4;
+		$$ = new CompoundAssign (
+			Binary.Operator.LeftShift, (Expression) $1, (Expression) $5, l);
+	  }
+	| prefixed_unary_expression OP_SHIFT_RIGHT ASSIGN _mark_ expression
+	  {
+		Location l = (Location)$4;
+		$$ = new CompoundAssign (
+			Binary.Operator.RightShift, (Expression) $1, (Expression) $5, l);
+	  }
+	| prefixed_unary_expression OP_CONCAT ASSIGN _mark_ expression
+	  {
+		Location l = (Location)$4;
+
+		// FIXME should be strings only
+		$$ = new CompoundAssign (
+			Binary.Operator.Concat, (Expression) $1, (Expression) $5, l);
+	  }
+	| prefixed_unary_expression ASSIGN ADDRESSOF _mark_ expression
+	  { 
+	    ArrayList args = new ArrayList();
+		Expression expr = (Expression) $5;
+		expr = SetAddressOf (expr);
+		Argument arg = new Argument (expr, Argument.AType.Expression);
+		args.Add (arg);
+		
+		New n = new New ((Expression) $1, (ArrayList) args, (Location)$4);
+		n.isDelegate = true;
+		$$ = new Assign ((Expression) $1, (Expression) n, (Location)$4);
+	  }
+	;
+
+constant_expression
+	: expression
+	;
+
+boolean_expression
+	: expression 
+	 {
+		Expression expr = (Expression) $1;
+		expr = SetValueRequiredFlag (expr);
+		$$ = expr;
+	 }
+	;
+
+type
+	: namespace_or_type_name 
+	  {  	
+		$$ = DecomposeQI ((string) $1, lexer.Location); 
+	  }
+	| builtin_types 
+	//| array_type 
+	;
+
+type_list
+	: type
+	  {
+		ArrayList types = new ArrayList ();
+
+		types.Add ($1);
+		$$ = types;
+	  }
+	| type_list COMMA type
+	  {
+		ArrayList types = (ArrayList) $1;
+
+		types.Add ($3);
+		$$ = types;
+	  }
+	;
+
+namespace_or_type_name
+	: qualified_identifier
+	;
+
+builtin_types
+	: OBJECT	{ $$ = TypeManager.system_object_expr; }
+	| primitive_type
+	;
+
+primitive_type
+	: numeric_type
+	| BOOLEAN	{ $$ = TypeManager.system_boolean_expr; }
+	| DATE		{ $$ = TypeManager.system_date_expr; }
+	| CHAR		{ $$ = TypeManager.system_char_expr; }
+	| STRING	{ $$ = TypeManager.system_string_expr; }
+	;
+	
+
+numeric_type
+	: integral_type
+	| floating_point_type
+	| DECIMAL	{ $$ = TypeManager.system_decimal_expr; }
+	;
+
+integral_type
+	:
+	| BYTE		{ $$ = TypeManager.system_byte_expr; }
+	| SHORT		{ $$ = TypeManager.system_int16_expr; }
+	| INTEGER	{ $$ = TypeManager.system_int32_expr; }
+	| LONG		{ $$ = TypeManager.system_int64_expr; }
+	;
+	
+floating_point_type
+	: SINGLE	{ $$ = TypeManager.system_single_expr; }
+	| DOUBLE	{ $$ = TypeManager.system_double_expr; }
+	;
+
+directive_expression 
+	: constant_expression _mark_  //FIXME: Fix for binary expression
+	 {
+		Expression exp = (Expression) $1;
+		if (exp is SimpleName) {
+			string key = ((SimpleName)exp).Name;	
+			if(constPreDir.Contains(key)) {
+				$$ = new BoolLiteral ((bool)constPreDir [key]);
+			}
+		}
+		else {
+			object o = ((Constant) exp).GetValue ();
+			bool temp = Convert.ToBoolean(o);
+			$$ = new BoolLiteral ((bool)temp);
+			// Report.Error (30580, (Location)$2, "value of Const used is not set");
+		    }
+	 }
+	;	
+		
+pp_directive
+	: HASH IDENTIFIER OPEN_PARENS LITERAL_STRING COMMA LITERAL_INTEGER CLOSE_PARENS _mark_ EOL
+	  { 
+	  	if(tokenizerController.IsAcceptingTokens)
+	  	{
+	  		if(in_external_source) 
+				Report.Error (30580, (Location)$8, "#ExternalSource directives may not be nested");
+			else {
+	  			in_external_source = true;
+			
+				lexer.EffectiveSource = (string) $4;
+				lexer.EffectiveLine = (int) $6;
+			}
+	  	}
+	  }
+	| HASH IDENTIFIER LITERAL_STRING _mark_ EOL
+	  {
+	  	if(tokenizerController.IsAcceptingTokens) 
+	  	{
+		  	if(!($2 as string).ToLower().Equals("region"))
+				Report.Error (30205, (Location)$4, "Invalid Pre-processor directive");
+			else
+			{
+				++in_marked_region;
+			}
+	  	}
+	  }
+	| HASH END IDENTIFIER _mark_ EOL
+	  {
+	  	if(tokenizerController.IsAcceptingTokens)
+	  	{
+	  		if( ($3 as string).ToLower().Equals("externalsource")) {
+				if(!in_external_source)
+					Report.Error (30578, (Location)$4, "'#End ExternalSource' must be preceded by a matching '#ExternalSource'");
+				else {
+					in_external_source = false;
+					lexer.EffectiveSource = lexer.Source;
+					lexer.EffectiveLine = lexer.Line;
+				}
+	  		}
+			else if(($3 as string).ToLower().Equals("region")) {
+				if(in_marked_region > 0)
+					--in_marked_region;
+				else
+					Report.Error (30205, (Location)$4, "'#End Region' must be preceded  by a matching '#Region'");
+			}
+			else {
+				Report.Error (29999, (Location)$4, "Unrecognized Pre-Processor statement");
+			}	
+	  	}
+	  }
+	| HASH CONST IDENTIFIER ASSIGN constant_expression _mark_ EOL
+	  {
+	  	{
+			Expression express = (Expression) $5;
+			if (express is Binary) {
+				// FIXME
+                		// TODO
+			}	
+			object o = ((Constant) express).GetValue ();
+			bool temp = Convert.ToBoolean(o);
+
+			string key = Convert.ToString($3);
+
+			if (constPreDir.Contains(key))
+				constPreDir[key] = temp;
+			else
+				constPreDir.Add($3,temp);
+	  	}
+	  }
+	| HASH IF _mark_   
+	  {
+	      	IfElseStateMachine.Token tok = IfElseStateMachine.Token.IF;
+
+		try {
+			ifElseStateMachine.HandleToken(tok);
+		}
+		catch(ApplicationException) {
+			throw new MBASException(ifElseStateMachine.Error, (Location)$3, ifElseStateMachine.ErrString);
+		}
+	  }
+  	  directive_expression opt_then  EOL 
+	  {
+		//FIXME: Fix for constant expression
+
+	  	HandleConditionalDirective(IfElseStateMachine.Token.IF, (BoolLiteral)$5);
+	  }
+	| HASH opt_elseif _mark_ 
+	  {
+		      IfElseStateMachine.Token tok = IfElseStateMachine.Token.ELSEIF;
+		      try {
+			      ifElseStateMachine.HandleToken(tok);
+		      }
+		      catch(ApplicationException) {
+			      throw new MBASException(ifElseStateMachine.Error, (Location)$3, ifElseStateMachine.ErrString);
+		      }
+  	  }
+	  directive_expression opt_then  EOL 
+	  {
+		  //FIXME: Fix for constant expression
+ 
+		  HandleConditionalDirective(IfElseStateMachine.Token.ELSEIF, (BoolLiteral)$5);
+	  }
+	| HASH ELSE _mark_ 
+  	  {
+		    IfElseStateMachine.Token tok = IfElseStateMachine.Token.ELSE;
+		    try {
+			    ifElseStateMachine.HandleToken(tok);
+		    }
+		    catch(ApplicationException) {
+			    throw new MBASException(ifElseStateMachine.Error, (Location)$3, ifElseStateMachine.ErrString);
+		    }
+	  }
+	  EOL 
+	  { 
+	  	HandleConditionalDirective(IfElseStateMachine.Token.ELSE, new BoolLiteral(true));
+	  }
+	| HASH END IF _mark_ 
+	  {
+		/*FIXME: IF without ENDIF not working properly. Error line is not diplayed properly*/
+		
+		  IfElseStateMachine.Token tok = IfElseStateMachine.Token.ENDIF;
+		  try {
+			  ifElseStateMachine.HandleToken(tok);
+		  }
+		  catch(ApplicationException) {
+			  throw new MBASException(ifElseStateMachine.Error, (Location)$4, ifElseStateMachine.ErrString);
+		  }
+	  }
+	  EOL 
+	  { 
+		HandleConditionalDirective(IfElseStateMachine.Token.ENDIF, new BoolLiteral(false));
+	  }
+	| HASH error _mark_ EOL	  
+	{
+		if(tokenizerController.IsAcceptingTokens)
+			Report.Error(29999, (Location)$3, "Unrecognized Pre-Processor statement");
+		else
+			Report.Warning (29999, (Location)$3,"Unrecognized Pre-Processor statement");
+	}
+	  
+	;		
+
+// Utility rule to save location information
+_mark_
+        : /* empty */
+        { $$ = lexer.Location; if (yyToken == Token.EOL) { $$ = new Location (lexer.Location.Row - 1, lexer.Location.Col); } }
+	;
+
+// Changed to accept "Else If" also along with "ElseIf" 
+opt_elseif
+        : ELSEIF
+        | ELSE IF
+	;
+
+// Changed so as to check if every block is closed or not... 
+opt_end_block
+	: opt_block_types 
+	  {
+		$$ = 2 + (int)$1 ;
+	  }
+	| NEXT
+	  {$$ = 1;}
+	| LOOP
+	  {$$ = 2;}
+	| EOF
+	  {$$ = Token.EOF;}	
+	;
+
+opt_block_types
+	: END IF
+	  {$$ = 1;}
+	| END SUB
+	  {$$ = 2;}
+	| END MODULE
+	  {$$ = 3;}
+	| END NAMESPACE
+	  {$$ = 4;}
+	| END CLASS
+	  {$$ = 5;}
+	| END FUNCTION 
+	  {$$ = 6;}
+	| END STRUCTURE 
+	  {$$ = 7;}
+	| END ENUM
+	  {$$ = 8;}
+	| END INTERFACE 
+	  {$$ = 9;}
+	| END PROPERTY 
+	  {$$ = 10;}
+	| END WITH 
+	  {$$ = 11;}
+	| END SYNCLOCK
+	  {$$ = 12;}
+	| END TRY 
+	  {$$ = 13;}
+	| END WHILE 
+	  {$$ = 14;}
+	| END SELECT 
+	  {$$ = 15;}
+	| END SET 
+	  {$$ = 16;}
+	| END GET 
+	  {$$ = 17;}
+	/*In case of any new end block please add it here.. after END_GET as single token... and please continue the numbering from 17...*/
+	;
+
+%%
+
+
+Tokenizer lexer;
+
+public Tokenizer Lexer {
+	get {
+		return lexer;
+	}
+}		   
+
+public static Expression DecomposeQI (string name, Location loc)
+{
+	Expression o;
+
+	if (name.IndexOf ('.') == -1) {
+		return new SimpleName (name, loc);
+	} else {
+		int pos = name.LastIndexOf (".");
+		string left = name.Substring (0, pos);
+		string right = name.Substring (pos + 1);
+
+		o = DecomposeQI (left, loc);
+
+		return new MemberAccess (o, right, loc);
+	}
+}
+
+Block declare_local_variables (Expression dummy_type, ArrayList variable_declarators, Location loc)
+{
+	Block implicit_block;
+	ArrayList inits = null;
+
+	//
+	// We use the `Used' property to check whether statements
+	// have been added to the current block.  If so, we need
+	// to create another block to contain the new declaration
+	// otherwise, as an optimization, we use the same block to
+	// add the declaration.
+	//
+	// FIXME: A further optimization is to check if the statements
+	// that were added were added as part of the initialization
+	// below.  In which case, no other statements have been executed
+	// and we might be able to reduce the number of blocks for
+	// situations like this:
+	//
+	// int j = 1;  int k = j + 1;
+	//
+	
+	VariableDeclaration.FixupTypes (variable_declarators);
+	
+	if (current_block.Used) {
+		implicit_block = new Block (current_block, true, loc, Location.Null);
+		implicit_block.AddChildVariableNames (current_block);
+	} else
+		implicit_block = current_block;
+
+	foreach (VariableDeclaration decl in variable_declarators){
+		Expression type = decl.type;
+		if (decl.Alias != null) {
+			if (implicit_block.AddVariable (type, decl.identifier, current_local_parameters, loc, decl.Alias) != null) {
+				if (decl.expression_or_array_initializer != null){
+					if (inits == null)
+						inits = new ArrayList ();
+					inits.Add (decl);
+				}
+			}
+		}
+		else {
+			if (implicit_block.AddVariable (type, decl.identifier, current_local_parameters, loc) != null) {
+				if (decl.expression_or_array_initializer != null){
+					if (inits == null)
+						inits = new ArrayList ();
+					inits.Add (decl);
+				}
+			}
+		}
+	}
+
+	if (inits == null)
+		return implicit_block;
+
+	foreach (VariableDeclaration decl in inits){
+		Assign assign;
+		Expression expr;
+		Expression type = decl.type;
+		
+		if ((decl.expression_or_array_initializer is Expression) || 
+		    (decl.expression_or_array_initializer is New)) {
+			expr = (Expression) decl.expression_or_array_initializer;
+		} else {
+			ArrayList init = (ArrayList) decl.expression_or_array_initializer;
+			
+			expr = new ArrayCreation (type, "", init, decl.Location);
+		}
+
+		LocalVariableReference var;
+		var = new LocalVariableReference (implicit_block, decl.identifier, loc);
+
+		assign = new Assign (var, expr, decl.Location);
+
+		implicit_block.AddStatement (new StatementExpression (assign, lexer.Location));
+	}
+	
+	return implicit_block;
+}
+
+Block declare_local_constant (Expression dummy_type, ArrayList variable_declarators)
+{
+	Block implicit_block;
+	VariableDeclaration.FixupTypes (variable_declarators);
+
+	if (current_block.Used)
+		implicit_block = new Block (current_block, true);
+	else
+		implicit_block = current_block;
+
+	foreach (VariableDeclaration decl in variable_declarators){
+		Expression type = decl.type;
+		implicit_block.AddConstant (type, decl.identifier, (Expression) decl.expression_or_array_initializer,
+					  current_local_parameters, decl.Location);
+	}
+	
+	return implicit_block;
+}
+
+struct VarName {
+                public object Name;
+                public object Type;
+		public object Rank;
+                                                                                
+                public VarName (object n, object t, object r)
+                {
+                        Name = n;
+                        Type = t;
+			Rank = r;
+                }
+        }
+
+
+// <summary>
+//   A class used to pass around variable declarations and constants
+// </summary>
+public class VariableDeclaration {
+	public string identifier;
+	public string Alias;
+	public bool Static;
+	public object expression_or_array_initializer;
+	public Location Location;
+	public Attributes OptAttributes;
+	public Expression type;
+	public ArrayList dims;
+		
+	public VariableDeclaration (string id, object eoai, Location l, Attributes opt_attrs, string Alias) :	this 
+					(id, TypeManager.system_object_expr, eoai, l, opt_attrs, Alias)
+	{
+	}	
+
+	public VariableDeclaration (string id, object eoai, Location l, Attributes opt_attrs) :	this 
+					(id, TypeManager.system_object_expr, eoai, l, opt_attrs)
+	{
+	}	
+
+	public VariableDeclaration (string id, object eoai, Location l) : this (id, eoai, l, (Attributes) null)
+	{
+	}
+	
+	public VariableDeclaration (string id, object eoai, Location l, string Alias) : this (id, eoai, l, (Attributes) null, Alias)
+	{
+	}
+
+	public VariableDeclaration (string id, Expression t, object eoai, Location l, Attributes opt_attrs, string Alias)
+	{
+		this.identifier = id;
+		this.expression_or_array_initializer = eoai;
+		this.Location = l;
+		this.OptAttributes = opt_attrs;
+		this.type = t;
+		this.dims = null;
+		this.Alias = Alias;
+	}	
+	
+	public VariableDeclaration (string id, Expression t, object eoai, Location l, Attributes opt_attrs)
+		: this (id, t, eoai, l, opt_attrs,  null)	
+	{
+	}
+	
+	public VariableDeclaration (string id, Expression t, Location l) : this (id, t, null, l, (Attributes) null)
+	{
+	}	
+	
+	public VariableDeclaration (string id, Expression t, Location l, string Alias) : this (id, t, null, l, (Attributes) null, Alias)
+	{
+	}	
+			
+	public static ArrayCreation BuildArrayCreator (Expression vartype, ArrayList a_dims, ArrayList varinit, Location l)
+	{	
+		// FIXME : This is broken: only the first rank is parsed
+		return new ArrayCreation (vartype, (ArrayList) a_dims[0], "", varinit, l);
+	}
+	
+	public static void FixupTypes (ArrayList vars)
+	{
+		int varcount = 	vars.Count;
+		VariableDeclaration last_var = (VariableDeclaration) vars[varcount - 1];
+			
+		if (last_var.type == null)
+			last_var.type = TypeManager.system_object_expr;
+			
+		Expression cur_type = last_var.type;
+		int n = varcount - 1;
+		
+		while (n >= 0) {
+			VariableDeclaration var = (VariableDeclaration) vars[n--];
+			if (var.type == null)
+				var.type = cur_type;
+			else
+				cur_type = var.type;
+		}
+	}
+	
+	public static bool IndexesSpecifiedInRank (ArrayList IndexList)
+	{
+		bool res = false;
+		
+		if (IndexList != null) {
+			foreach (Expression e in IndexList)
+				if (!(e is EmptyExpression)) {
+					res = true;
+					break;
+				}	
+		}
+		return (res);
+	}	
+	
+	
+	public static bool IndexesSpecified (ArrayList ranks)
+	{
+		bool res = false;
+		
+		if (ranks != null) {
+			foreach (ArrayList IndexList in ranks) {
+				if (IndexesSpecifiedInRank (IndexList)) {
+					res = true;
+					break;
+				}	
+			}	
+		}
+		return (res);
+	}
+	
+	public static string StripDims (string varname, ref string d)
+	{
+		string res = varname;
+		string dres = "";
+		
+		if (varname.IndexOf("[") >= 0) {
+			dres = varname.Substring(varname.IndexOf("["), (varname.LastIndexOf("]") - varname.IndexOf("["))+1);
+			res = varname.Substring(0, varname.IndexOf("["));
+		}
+		d = dres;
+		return (res);
+	}	
+	
+	public static string StripDims (string varname)
+	{
+		string dres = "";
+		
+		return (StripDims(varname, ref dres));
+	}	
+	
+	public static string StripIndexesFromDims (string dims)
+	{
+		StringBuilder sb = new StringBuilder();
+
+		foreach (char c in dims) 
+			if (c == ',' || c == ']' || c == '[')
+				sb.Append (c);
+				
+		return sb.ToString();				
+	}
+	
+	public static string BuildRank (ArrayList rank)
+	{
+		bool allEmpty;
+		return BuildRank(rank, out allEmpty);
+	}
+            
+	public static string BuildRank (ArrayList rank, out bool allEmpty)
+	{
+		string res = "";
+
+		res += "[";
+		allEmpty = true;
+		bool first = true;
+		foreach (object e in rank) {
+			if (!(e is EmptyExpression))
+				allEmpty = false;
+			if (!first)
+				res += ",";
+			first = false;
+		}
+			
+		res += "]";
+		return res;
+	}
+		
+	public static string BuildRanks (ArrayList rank_specifiers, bool mustBeEmpty, Location loc)
+	{
+		string res = "";
+
+		bool allEmpty = true;
+		foreach (ArrayList rank in rank_specifiers) {
+			bool tmp;
+			res = BuildRank (rank, out tmp) + res;
+			if (!tmp)
+				allEmpty = false;
+		}
+		if (!allEmpty && mustBeEmpty)
+			Report.Error (30638, loc, "Array bounds cannot appear in type specifiers.");	
+
+		return res;
+	}	
+	
+	public static void VBFixIndexList (ref ArrayList IndexList)
+	{
+		if (IndexList != null) {
+			for (int x = 0; x < IndexList.Count; x++) {
+				Expression e = (Expression) IndexList[x];
+				if (!(e is EmptyExpression)) {
+					IndexList[x] = new Binary (Binary.Operator.Addition, e, new IntLiteral(1), Location.Null);
+				}
+			}
+		}
+	}		
+	
+	public static bool IsArrayDecl (Parser t)
+	{
+		// return (varname.IndexOf("[") >= 0);
+		return (t.current_rank_specifiers != null);
+	}			
+	
+	public static void VBFixIndexLists (ref ArrayList ranks)
+	{	
+		if (ranks != null) {
+			for (int x = 0; x < ranks.Count; x++) {
+				ArrayList IndexList = (ArrayList) ranks[x];
+				VBFixIndexList (ref IndexList);
+			}	
+		}	
+	}
+		
+	public static void FixupArrayTypes (ArrayList vars)
+	{
+		string dims;
+		
+		foreach (VariableDeclaration var in vars) {
+		  	if (var.identifier.EndsWith(",")) {
+		  		dims = "[" + var.identifier.Substring(var.identifier.IndexOf (","), 
+		  						var.identifier.LastIndexOf(",")) + "]";
+				var.identifier = var.identifier.Substring (0, var.identifier.IndexOf (","));
+				var.type = new ComposedCast (var.type, (string) dims, var.Location);
+		  	}
+		}
+	}				
+}
+
+
+public Property BuildSimpleProperty (Expression p_type, string name, 
+					Field p_fld, int mod_flags,
+			 		Attributes attrs, Location loc) 
+{
+	Property p;
+	Block get_block, set_block;
+	Accessor acc_set, acc_get;
+	StatementExpression a_set;
+	Statement a_get;
+	Parameter [] args;
+	
+	// Build SET Block
+	Parameter implicit_value_parameter = new Parameter (p_type, "value", Parameter.Modifier.NONE, null);	
+	args  = new Parameter [1];
+	args [0] = implicit_value_parameter;
+		
+	Parameters set_params = new Parameters (args, null, loc);
+	a_set = new StatementExpression ((ExpressionStatement) new Assign ((Expression) DecomposeQI(p_fld.Name, loc), 
+			    (Expression) new SimpleName("value", loc), loc), loc);
+			    
+	set_block = new Block (current_block, set_params, loc, Location.Null);
+	set_block.AddStatement ((Statement) a_set);					    
+	acc_set = new Accessor (set_block, attrs);
+	
+	// Build GET Block
+	a_get = (Statement) new Return ((Expression) DecomposeQI(p_fld.Name, loc), loc);
+	get_block = new Block (current_block, null, loc, Location.Null);
+	get_block.AddStatement ((Statement) a_get);					    
+	acc_get = new Accessor (get_block, attrs);
+		
+	p = new Property (p_type, name, mod_flags, (Accessor) acc_get, (Accessor) acc_set, attrs, loc);
+	
+	return (p);
+}
+	
+void start_block () 
+{
+	current_block = new Block (current_block, current_local_parameters,
+			   lexer.Location, Location.Null);
+} 
+
+void start_method_block (string Name) 
+{
+	current_block = new MethodBlock (current_block, current_local_parameters,
+			   lexer.Location, Location.Null, Name);
+} 
+
+Block end_block ()
+{ 
+	Block res;
+	
+	while (current_block.Implicit)
+		current_block = current_block.Parent;
+
+	res = current_block;
+
+	current_block.SetEndLocation (lexer.Location);
+	current_block = current_block.Parent;
+	
+	return (res);
+}
+
+void push_into_stack(int BlockStart, Location l)
+{
+	end_of_block.Push(BlockStart);	
+	loc_end_of_block.Push(l);
+}
+
+void pop_out_of_stack(int BlockEnd, Location l)
+{
+	if(BlockEnd != Token.EOF) {
+		int current = (int)end_of_block.Pop();
+ 		Location current_loc = (Location)loc_end_of_block.Pop();
+		if(BlockEnd != current) {
+			// Block end is missing
+			// eg: For 'Sub' BlockEnd should be 'End Sub'	
+			
+			if(error_end_blocks[BlockEnd,2] > error_end_blocks[current,2]) {
+				while(error_end_blocks[BlockEnd,2] > error_end_blocks[current,2])
+				{
+					if(error_end_blocks[BlockEnd,2] > error_end_blocks[current,2])
+						Report.Error(error_end_blocks[current,0],current_loc,"'"+end_blocks[current,0]+"' is not having matching '"+end_blocks[current,1]+"'");
+					current = (int)end_of_block.Pop();
+ 					current_loc = (Location)loc_end_of_block.Pop();
+				}
+			}
+			
+			// Extra end is present, but works for lesser priority 
+			// (for priority see opt_end_block opt_block_types return values 
+			// eg: 'EndIf' without 'If' inside 'Sub'
+			// Also certain other errors like 'Sub' having a 'End Module' etc 
+			// can be handled here
+
+			if(error_end_blocks[BlockEnd,2] < error_end_blocks[current,2]) {
+				Report.Error(error_end_blocks[BlockEnd,1],l,"'"+end_blocks[BlockEnd,1]+"' is not having  a corresponding '"+end_blocks[BlockEnd,0]+"'");
+				end_of_block.Push(current);	
+				loc_end_of_block.Push(current_loc);
+			}	
+			// Extra end is present but with equal priorty
+
+			if((error_end_blocks[BlockEnd,2] == error_end_blocks[current,2]) && BlockEnd != current) {
+				while((error_end_blocks[BlockEnd,2] == error_end_blocks[current,2]) && BlockEnd != current) {
+					temp_block.Push(current);
+					loc_temp_block.Push(current_loc);
+					current = (int)end_of_block.Pop();
+ 					current_loc = (Location)loc_end_of_block.Pop();
+				}
+			
+				if(BlockEnd == current) {
+				        while(temp_block.Count !=0)
+				        {
+				                int lapse = (int) temp_block.Pop();
+			                        Location lapse_location = (Location)loc_temp_block.Pop();
+						Report.Error(error_end_blocks[lapse,0],lapse_location,"'"+end_blocks[lapse,0]+"' is not having matching '"+end_blocks[lapse,1]+"'");
+			                }
+				}
+				
+				else {
+					Report.Error(error_end_blocks[BlockEnd,1],l,"'"+end_blocks[BlockEnd,1]+"' is not having  a corresponding '"+end_blocks[BlockEnd,0]+"'");
+					end_of_block.Push(current);	
+					loc_end_of_block.Push(current_loc);
+				        while(temp_block.Count !=0) {
+				                int lapse = (int) temp_block.Pop();
+			                        Location lapse_location = (Location)loc_temp_block.Pop();
+						end_of_block.Push(lapse);	
+						loc_end_of_block.Push(lapse_location);
+				        }
+				}
+			}
+		}
+	}	
+	else {
+	        while(end_of_block.Count !=0) {
+	                int lapse = (int) end_of_block.Pop();
+                        Location lapse_location = (Location)loc_end_of_block.Pop();
+			Report.Error(error_end_blocks[lapse,0],lapse_location,"'"+end_blocks[lapse,0]+"' is not having matching '"+end_blocks[lapse,1]+"'");
+                }
+	}		
+}
+
+private void AddHandler (Expression evt_definition, Expression handler_exp)
+{
+	AddHandler (current_block, evt_definition, handler_exp);
+}
+
+/*
+void CheckAttributeTarget (string a)
+{
+	switch (a) {
+
+	case "assembly" : case "field" : case "method" : case "param" : case "property" : case "type" :
+		return;
+		
+	default :
+		Location l = lexer.Location;
+		Report.Error (658, l, "`" + a + "' is an invalid attribute target");
+		break;
+	}
+}
+*/
+
+private void AddHandler (Block b, Expression evt_id, Expression handles_exp)
+{
+	Location loc = lexer.Location;
+	
+	Statement addhnd = (Statement) new AddHandler (evt_id, 
+													handles_exp, 
+													loc);													
+	b.AddStatement (addhnd);
+}
+
+private void RaiseEvent (string evt_name, ArrayList args)
+{
+	Location loc = lexer.Location;
+	Expression qi = DecomposeQI (evt_name, loc);
+	
+	Invocation evt_call = new Invocation (qi, args, lexer.Location);
+   	Statement s = (Statement)(new StatementExpression ((ExpressionStatement) evt_call, loc)); 
+
+	Binary bin = new Binary (Binary.Operator.Is, qi, (Expression) NullLiteral.Null, loc);
+	If if_s = new If (bin, new EmptyStatement (), s, loc);
+
+   	current_block.AddStatement (if_s);	
+}
+
+private void RemoveHandler (Block b, Expression evt_definition, Expression handler_exp)
+{
+	Location loc = lexer.Location;
+	
+	Statement rmhnd = (Statement) new RemoveHandler (evt_definition, 
+													handler_exp, 
+													loc);
+	b.AddStatement (rmhnd);
+}
+
+private Constant ConvertLiteral (Constant literal, Type target_type)
+{
+	if (literal.GetValue ().GetType () == target_type)
+		//no conversion required
+		return literal;
+
+	if (target_type == typeof (float))
+		return new FloatLiteral ((float) literal.ConvertToFloat ().Value);
+	else
+	if (target_type == typeof (decimal))
+		return new DecimalLiteral ((decimal) literal.ConvertToDecimal ().Value);
+	else
+	if (target_type == typeof (double))
+		return new DoubleLiteral ((double) literal.ConvertToDouble ().Value);
+	else
+	if (target_type == typeof (long))
+		return new LongLiteral ((Int64) literal.ConvertToLong ().Value);
+	else
+	if (target_type == typeof (int))
+		return new IntLiteral ((Int32) literal.ConvertToInt ().Value);
+
+	/* FIXME: throw error? */
+	return null;
+}
+
+// <summary>
+//  This method is used to get at the complete string representation of
+//  a fully-qualified type name, hiding inside a MemberAccess ;-)
+//  This is necessary because local_variable_type admits primary_expression
+//  as the type of the variable. So we do some extra checking
+// </summary>
+string GetQualifiedIdentifier (Expression expr)
+{
+	if (expr is SimpleName)
+		return ((SimpleName)expr).Name;
+	else if (expr is MemberAccess)
+		return GetQualifiedIdentifier (((MemberAccess)expr).Expr) + "." + ((MemberAccess) expr).Identifier;
+	else 
+		throw new Exception ("Expr has to be either SimpleName or MemberAccess! (" + expr + ")");
+	
+}
+
+private void RemoveHandler (Expression evt_definition, Expression handler_exp)
+{
+	RemoveHandler (current_block, evt_definition, handler_exp);
+}
+
+private ConstructorInitializer CheckConstructorInitializer (ref ArrayList s)
+{
+	ConstructorInitializer ci = null;
+	
+	if (s.Count > 0) {
+		if (s[0] is StatementExpression && ((StatementExpression) s[0]).expr is Invocation) {
+			Invocation i = (Invocation) ((StatementExpression) s[0]).expr;
+			
+			if (i.expr is BaseAccess) {
+				BaseAccess ba = (BaseAccess) i.expr;
+				if (ba.member == "New" || ba.member == ".ctor") {
+					ci = new ConstructorBaseInitializer (i.Arguments, current_local_parameters, lexer.Location);
+					s.RemoveAt(0);
+				}
+			}
+			if (i.expr.ToString() == "Mono.MonoBASIC.This..ctor") {
+				ci = new ConstructorThisInitializer (i.Arguments, current_local_parameters, lexer.Location); 
+				s.RemoveAt(0);
+			}
+		}
+	}
+	return ci;
+}
+
+/*
+void Error_ExpectingTypeName (Location l, Expression expr)
+{
+	if (expr is Invocation){
+		Report.Error (1002, l, "; expected");
+	} else {
+		Report.Error (-1, l, "Invalid Type definition");
+	}
+}
+*/
+
+public static Expression SetLeftHandFlag (Expression expr) {
+	if (expr is Invocation) {
+		Invocation e = (Invocation) expr;
+		e.IsLeftHand = true;
+		return e;
+	} else if (expr is MemberAccess) {
+		MemberAccess e = (MemberAccess) expr;
+		e.IsLeftHand = true;
+		return e;
+	}
+
+	return expr;
+}
+
+public static Expression SetValueRequiredFlag (Expression expr) {
+	if (expr is Invocation) {
+		Invocation e = (Invocation) expr;
+		e.IsRetvalRequired = true;
+		expr = e;
+		return expr;
+	}
+	if (expr is Binary) {
+		Binary binary = (Binary) expr;
+		binary.Left  = SetValueRequiredFlag (binary.Left);
+		binary.Right  = SetValueRequiredFlag (binary.Right);
+		return binary;	
+	}
+	if (expr is Unary) {
+		Unary unary = (Unary) expr;
+		unary.Expr = SetValueRequiredFlag (unary.Expr);
+		return unary;
+	}
+	return expr;
+}
+
+public static Expression SetAddressOf (Expression expr) {
+	if (expr is SimpleName) {
+		SimpleName sname = expr as SimpleName;
+		sname.IsAddressOf = true;
+		return sname;
+	}
+	if (expr is MemberAccess) {
+		MemberAccess ma = expr as MemberAccess;
+		ma.IsAddressOf = true;
+		return ma;
+	}
+	return expr;
+}
+
+/*
+static bool AlwaysAccept (MemberInfo m, object filterCriteria) {
+	return true;
+}
+*/
+
+private void ReportError9998()
+{
+	Report.Error (29998, lexer.Location, "This construct is only available in MonoBASIC extended syntax.");
+}
+
+protected override int parse ()
+{
+	RootContext.InitializeImports(ImportsList);
+	current_namespace = new Namespace (null, RootContext.RootNamespace);
+	current_container = RootContext.Tree.Types;
+	current_container.Namespace = current_namespace;
+	oob_stack = new Stack ();
+	switch_stack = new Stack ();
+	expr_stack = new Stack ();	
+	tmp_blocks = new Stack(); 
+	with_stack = new Stack();
+	statement_stack = new Stack(); 	
+	end_of_block = new Stack ();
+	loc_end_of_block = new Stack ();
+	temp_block = new Stack();
+	loc_temp_block = new Stack();
+
+	allow_global_attribs = true;
+	expecting_global_attribs = false;
+	expecting_local_attribs = false;
+	local_attrib_section_added = false;
+
+	UseExtendedSyntax = name.EndsWith(".mbs");
+	OptionExplicit = InitialOptionExplicit || UseExtendedSyntax;
+	OptionStrict = InitialOptionStrict || UseExtendedSyntax;
+	OptionCompareBinary = InitialOptionCompareBinary;
+
+	lexer = new Tokenizer (input, name, defines);
+	
+	ifElseStateMachine = new IfElseStateMachine();
+	tokenizerController = new TokenizerController(lexer);
+	
+	try {
+		if (yacc_verbose_flag > 0)
+			yyparse (lexer, new yydebug.yyDebugSimple ());
+		else {
+			yyparse (lexer);
+			cleanup();
+		}
+	} 
+	catch(MBASException e) {
+		Report.Error(e.code, e.loc, e.Message);
+	}
+	catch (Exception e) {
+		if (Report.Stacktrace)
+			Console.WriteLine(e);
+		Report.Error (29999, lexer.Location, "Parsing error");
+	}
+
+	RootContext.VerifyImports();
+
+	return Report.Errors;
+}
+
+void cleanup()
+{
+	try {
+		ifElseStateMachine.HandleToken(IfElseStateMachine.Token.EOF);
+	}
+	catch(ApplicationException) {
+		throw new MBASException(ifElseStateMachine.Error, lexer.Location, ifElseStateMachine.ErrString);
+	}
+
+	if(in_external_source) 
+		Report.Error (30579, lexer.Location, "'#ExternalSource' directives must end with matching '#End ExternalSource'");
+
+	if(in_marked_region > 0)
+		Report.Error (30205, lexer.Location, "'#Region' directive must be followed by a matching '#End Region'");
+}
+
+void HandleConditionalDirective(IfElseStateMachine.Token tok, BoolLiteral expr)
+{
+	try {
+		tokenizerController.PositionTokenizerCursor(tok, expr);
+	}
+	catch(ApplicationException) {
+		tok = IfElseStateMachine.Token.EOF;
+		try {
+			ifElseStateMachine.HandleToken(tok);
+		}
+		catch(ApplicationException) {
+			throw new MBASException(ifElseStateMachine.Error, lexer.Location, ifElseStateMachine.ErrString);
+		}
+	}
+}
+/* end end end */
+}
+
+
+
+
diff --git a/dead/mbas/mb-tokenizer.cs b/dead/mbas/mb-tokenizer.cs
new file mode 100644
index 00000000..f1f2c267
--- /dev/null
+++ b/dead/mbas/mb-tokenizer.cs
@@ -0,0 +1,1136 @@
+//
+// Mono.MonoBASIC.Tokenizer.cs: The Tokenizer for the MonoBASIC compiler
+//
+// Author: A Rafael D Teixeira (rafaelteixeirabr@hotmail.com)
+//	 : Manjula GHM (mmanjula@novell.com)  
+// Based on cs-tokenizer.cs by Miguel de Icaza (miguel@gnu.org)
+//
+// Licensed under the terms of the GNU GPL
+//
+// Copyright (C) 2001 A Rafael D Teixeira
+//
+
+namespace Mono.MonoBASIC
+{
+	using System;
+	using System.Text;
+	using System.Collections;
+	using System.IO;
+	using System.Globalization;
+	using Mono.Languages;
+	using Mono.MonoBASIC;
+	
+	/// <summary>
+	///    Tokenizer for MonoBASIC source code. 
+	/// </summary>
+	
+	public class Tokenizer : yyParser.yyInput
+	{
+		TextReader reader;
+		string file_name;
+		string ref_name;
+		int ref_line = 0;
+		int line = 0;
+		int col = 1;
+		public int current_token = Token.ERROR;
+		public int last_token = Token.ERROR;
+		bool handle_get_set = false;
+		bool cant_have_a_type_character = false;
+
+		public int ExpandedTabsSize = 4; 
+
+		public string location {
+			get {
+				string det;
+
+				if (current_token == Token.ERROR)
+					det = "detail: " + error_details;
+				else
+					det = "";
+				
+				return "Line:     "+line+" Col: "+col + "\n" +
+				       "VirtLine: "+ref_line +
+				       " Token: "+current_token + " " + det;
+			}
+		}
+
+		public bool properties {
+			get {
+				return handle_get_set;
+			}
+
+			set {
+				handle_get_set = value;
+			}
+                }
+		
+		//
+		// Class variables
+		// 
+		static Hashtable keywords;
+		static NumberStyles styles;
+		static NumberFormatInfo csharp_format_info;
+		
+		//
+		// Values for the associated token returned
+		//
+		StringBuilder number;
+		int putback_char = -1;
+		Object val;
+		long lon = 0;
+		
+		//
+		// Details about the error encoutered by the tokenizer
+		//
+		string error_details;
+		
+		public string error {
+			get {
+				return error_details;
+			}
+		}
+
+		
+		public string Source {
+			get {
+				return file_name;
+			}
+
+			set {
+				file_name = value;
+				ref_name = value;
+				Location.SetCurrentSource(file_name);
+			}
+		}
+
+		public string EffectiveSource {
+			get {
+				return ref_name;
+			}
+			set {
+				ref_name = value;
+				Location.SetCurrentSource(ref_name);
+			}
+		}
+
+		public int Line {
+			get {
+				return line;
+			}
+		}
+
+		public int EffectiveLine {
+			get {
+				return ref_line;
+			}
+			set {
+				ref_line = value;
+			}
+		}
+
+		public int Col {
+			get {
+				return col;
+			}
+		}
+		
+		static void initTokens ()
+		{
+			keywords = new Hashtable ();
+
+			keywords.Add ("addhandler", Token.ADDHANDLER);
+			keywords.Add ("addressof", Token.ADDRESSOF);
+			keywords.Add ("alias", Token.ALIAS);
+			keywords.Add ("and", Token.AND);
+			keywords.Add ("andalso", Token.ANDALSO);
+			keywords.Add ("ansi", Token.ANSI);
+			keywords.Add ("as", Token.AS);
+			keywords.Add ("assembly", Token.ASSEMBLY);
+			keywords.Add ("auto", Token.AUTO);
+			keywords.Add ("binary", Token.BINARY); // Not a VB.NET Keyword 
+			keywords.Add ("boolean", Token.BOOLEAN);
+			keywords.Add ("byref", Token.BYREF);
+			keywords.Add ("byte", Token.BYTE);
+			keywords.Add ("byval", Token.BYVAL);
+			keywords.Add ("call", Token.CALL);
+			keywords.Add ("case", Token.CASE);
+			keywords.Add ("catch", Token.CATCH);
+			keywords.Add ("cbool", Token.CBOOL);
+			keywords.Add ("cbyte", Token.CBYTE);
+			keywords.Add ("cchar", Token.CCHAR);
+			keywords.Add ("cdate", Token.CDATE);
+			keywords.Add ("cdec", Token.CDEC);
+			keywords.Add ("cdbl", Token.CDBL);
+			keywords.Add ("char", Token.CHAR);
+			keywords.Add ("cint", Token.CINT);
+			keywords.Add ("class", Token.CLASS);
+			keywords.Add ("clng", Token.CLNG);
+			keywords.Add ("cobj", Token.COBJ);
+			keywords.Add ("compare", Token.COMPARE); // Not a VB.NET Keyword
+			keywords.Add ("const", Token.CONST);
+			keywords.Add ("cshort", Token.CSHORT);
+			keywords.Add ("csng", Token.CSNG);
+			keywords.Add ("cstr", Token.CSTR);
+			keywords.Add ("ctype", Token.CTYPE);
+			keywords.Add ("date", Token.DATE);
+			keywords.Add ("decimal", Token.DECIMAL);
+			keywords.Add ("declare", Token.DECLARE);
+			keywords.Add ("default", Token.DEFAULT);
+			keywords.Add ("delegate", Token.DELEGATE);
+			keywords.Add ("dim", Token.DIM);
+			keywords.Add ("directcast", Token.DIRECTCAST);			
+			keywords.Add ("do", Token.DO);
+			keywords.Add ("double", Token.DOUBLE);
+			keywords.Add ("each", Token.EACH);
+			keywords.Add ("else", Token.ELSE);
+			keywords.Add ("elseif", Token.ELSEIF);
+			keywords.Add ("end", Token.END);
+			keywords.Add ("endif", Token.ENDIF); // An unused VB.NET keyword
+			keywords.Add ("enum", Token.ENUM);
+			keywords.Add ("erase", Token.ERASE);
+			keywords.Add ("error", Token.ERROR);
+			keywords.Add ("event", Token.EVENT);
+			keywords.Add ("exit", Token.EXIT);
+			keywords.Add ("explicit", Token.EXPLICIT); // Not a VB.NET keyword 
+			keywords.Add ("false", Token.FALSE);
+			keywords.Add ("finally", Token.FINALLY);
+			keywords.Add ("for", Token.FOR);
+			keywords.Add ("friend", Token.FRIEND);
+			keywords.Add ("function", Token.FUNCTION);
+			keywords.Add ("get", Token.GET);
+			keywords.Add ("gettype", Token.GETTYPE);
+			keywords.Add ("gosub", Token.GOSUB); // An unused VB.NET keyword 
+			keywords.Add ("goto", Token.GOTO);
+			keywords.Add ("handles", Token.HANDLES);
+			keywords.Add ("if", Token.IF);
+			keywords.Add ("implements", Token.IMPLEMENTS);
+			keywords.Add ("imports", Token.IMPORTS);
+			keywords.Add ("in", Token.IN);
+			keywords.Add ("inherits", Token.INHERITS);
+			keywords.Add ("integer", Token.INTEGER);
+			keywords.Add ("interface", Token.INTERFACE);
+			keywords.Add ("is", Token.IS);
+			keywords.Add ("let ", Token.LET ); // An unused VB.NET keyword
+			keywords.Add ("lib ", Token.LIB );
+			keywords.Add ("like", Token.LIKE );
+			keywords.Add ("long", Token.LONG);
+			keywords.Add ("loop", Token.LOOP);
+			keywords.Add ("me", Token.ME);
+			keywords.Add ("mod", Token.MOD);
+			keywords.Add ("module", Token.MODULE);
+			keywords.Add ("mustinherit", Token.MUSTINHERIT);
+			keywords.Add ("mustoverride", Token.MUSTOVERRIDE);
+			keywords.Add ("mybase", Token.MYBASE);
+			keywords.Add ("myclass", Token.MYCLASS);
+			keywords.Add ("namespace", Token.NAMESPACE);
+			keywords.Add ("new", Token.NEW);
+			keywords.Add ("next", Token.NEXT);
+			keywords.Add ("not", Token.NOT);
+			keywords.Add ("nothing", Token.NOTHING);
+			keywords.Add ("notinheritable", Token.NOTINHERITABLE);
+			keywords.Add ("notoverridable", Token.NOTOVERRIDABLE);
+			keywords.Add ("object", Token.OBJECT);
+			keywords.Add ("off", Token.OFF); // Not a VB.NET Keyword 
+			keywords.Add ("on", Token.ON);
+			keywords.Add ("option", Token.OPTION);
+			keywords.Add ("optional", Token.OPTIONAL);
+			keywords.Add ("or", Token.OR);
+			keywords.Add ("orelse", Token.ORELSE);
+			keywords.Add ("overloads", Token.OVERLOADS);
+			keywords.Add ("overridable", Token.OVERRIDABLE);
+			keywords.Add ("overrides", Token.OVERRIDES);
+			keywords.Add ("paramarray", Token.PARAM_ARRAY);
+			keywords.Add ("preserve", Token.PRESERVE);
+			keywords.Add ("private", Token.PRIVATE);
+			keywords.Add ("property", Token.PROPERTY);
+			keywords.Add ("protected", Token.PROTECTED);
+			keywords.Add ("public", Token.PUBLIC);
+			keywords.Add ("raiseevent", Token.RAISEEVENT);
+			keywords.Add ("readonly", Token.READONLY);
+			keywords.Add ("redim", Token.REDIM);
+			keywords.Add ("rem", Token.REM);
+			keywords.Add ("removehandler", Token.REMOVEHANDLER);
+			keywords.Add ("resume", Token.RESUME);
+			keywords.Add ("return", Token.RETURN);
+			keywords.Add ("select", Token.SELECT);
+			keywords.Add ("set", Token.SET);
+			keywords.Add ("shadows", Token.SHADOWS);
+			keywords.Add ("shared", Token.SHARED);
+			keywords.Add ("short", Token.SHORT);
+			keywords.Add ("single", Token.SINGLE);
+			keywords.Add ("sizeof", Token.SIZEOF); // Not a VB.NET Keyword 
+			keywords.Add ("static", Token.STATIC);
+			keywords.Add ("step", Token.STEP);
+			keywords.Add ("stop", Token.STOP);
+			keywords.Add ("strict", Token.STRICT); // Not a VB.NET Keyword 
+			keywords.Add ("string", Token.STRING);
+			keywords.Add ("structure", Token.STRUCTURE);
+			keywords.Add ("sub", Token.SUB);
+			keywords.Add ("synclock", Token.SYNCLOCK);
+			keywords.Add ("text", Token.TEXT); // Not a VB.NET Keyword
+			keywords.Add ("then", Token.THEN);
+			keywords.Add ("throw", Token.THROW);
+			keywords.Add ("to", Token.TO);
+			keywords.Add ("true", Token.TRUE);
+			keywords.Add ("try", Token.TRY);
+			keywords.Add ("typeof", Token.TYPEOF);
+			keywords.Add ("unicode", Token.UNICODE);
+			keywords.Add ("until", Token.UNTIL);
+			keywords.Add ("variant", Token.VARIANT); // An unused VB.NET keyword
+			keywords.Add ("wend", Token.WEND); // An unused VB.NET keyword
+			keywords.Add ("when", Token.WHEN);
+			keywords.Add ("while", Token.WHILE);
+			keywords.Add ("with", Token.WITH);
+			keywords.Add ("withevents", Token.WITHEVENTS);
+			keywords.Add ("writeonly", Token.WRITEONLY);
+			keywords.Add ("xor", Token.XOR);
+
+			if (Parser.UseExtendedSyntax){
+				keywords.Add ("yield", Token.YIELD);
+			}
+
+		}
+
+		static Tokenizer ()
+		{
+			initTokens ();
+			csharp_format_info = new NumberFormatInfo ();
+			csharp_format_info.CurrencyDecimalSeparator = ".";
+			styles = NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint;
+		}
+
+		public Tokenizer (System.IO.TextReader input, string fname, ArrayList defines)
+		{
+			this.Source = fname;
+
+			reader = input;
+
+			// putback an EOL at the beginning of a stream. This is a convenience that 
+			// allows pre-processor directives to be added to the beginning of a vb file.
+			putback('\n');
+		}
+
+		bool is_keyword (string name)
+		{
+			bool res;
+			name = name.ToLower();
+
+			res = keywords.Contains(name);
+			if ((name == "GET" || name == "SET") && handle_get_set == false)
+				return false;
+			return res;
+		}
+
+		int getKeyword (string name)
+		{
+			return (int) (keywords [name.ToLower()]);
+		}
+		
+		public Location Location {
+			get {
+				return new Location (ref_line, col);
+			}
+		}
+		
+		public bool PropertyParsing {
+			get {
+				return handle_get_set;
+			}
+
+			set {
+				handle_get_set = value;
+			}
+                }
+                		
+		bool is_identifier_start_character (char c)
+		{
+			return Char.IsLetter (c) || c == '_' ;
+		}
+
+		bool is_identifier_part_character (char c)
+		{
+			return (Char.IsLetter (c) || Char.IsDigit (c) || c == '_');
+		}
+
+		int is_punct (char c, ref bool doread)
+		{
+			int d;
+			int t;
+
+			doread = false;
+			
+			error_details = c.ToString();
+			
+			d = peekChar ();
+			
+			switch (c){
+			case '[':
+				return Token.OPEN_BRACKET;
+			case ']':
+				return Token.CLOSE_BRACKET;
+			case '{':
+				return Token.OPEN_BRACE;
+			case '}':
+				return Token.CLOSE_BRACE;				
+			case '(':
+				return Token.OPEN_PARENS;
+			case ')':
+				return Token.CLOSE_PARENS;
+			case ',':
+				return Token.COMMA;
+			case '?':
+				return Token.INTERR;
+			case '!':
+				if (is_identifier_start_character((char)d) || cant_have_a_type_character)
+					return Token.EXCLAMATION;
+				return Token.SINGLETYPECHAR;
+			case '$':
+				if (cant_have_a_type_character)
+					return Token.ERROR;
+				return Token.DOLAR_SIGN;
+			case '@':
+				if (cant_have_a_type_character)
+					return Token.ERROR;
+				return Token.AT_SIGN;
+			case '%':
+				if (cant_have_a_type_character)
+					return Token.ERROR;
+				return Token.PERCENT;
+			case '#':
+				if(tokens_seen)
+				{
+					if (cant_have_a_type_character) 
+						return ExtractDateTimeLiteral();
+					else
+						return Token.NUMBER_SIGN;
+				}
+				else 
+				{
+					tokens_seen = true;
+					return Token.HASH;
+				} 
+			case '&':
+				if (!cant_have_a_type_character)
+					return Token.LONGTYPECHAR;
+				t = handle_integer_literal_in_other_bases(d);
+				if (t == Token.NONE) {
+					t = Token.OP_CONCAT;
+				}
+				return t;			
+			}
+
+			if (c == '+'){
+				if (d == '+')
+					t = Token.OP_INC;
+				else 
+					return Token.PLUS;
+				doread = true;
+				return t;
+			}
+			if (c == '-'){
+				return Token.MINUS;
+			}
+
+			if (c == '='){
+				return Token.ASSIGN;
+			}
+
+			if (c == '*'){
+				return Token.STAR;
+			}
+
+			if (c == '/'){
+				return Token.DIV;
+			}
+
+			if (c == '\\'){
+				return Token.OP_IDIV;
+			}
+
+			if (c == '^'){
+				return Token.OP_EXP;
+			}
+
+			if (c == '<'){
+				if (d == '>')
+				{
+					doread = true;
+					return Token.OP_NE;
+				}
+				if (d == '='){
+					doread = true;
+					return Token.OP_LE;
+				}
+				if (d == '<')
+				{
+					doread = true;
+					return Token.OP_SHIFT_LEFT;
+				}
+				return Token.OP_LT;
+			}
+
+			if (c == '>'){
+				if (d == '='){
+					doread = true;
+					return Token.OP_GE;
+				}
+				if (d == '>')
+				{
+					doread = true;
+					return Token.OP_SHIFT_RIGHT;
+				}
+				return Token.OP_GT;
+			}
+			
+			if (c == ':'){
+				if (d == '='){
+					doread = true;
+					return Token.ATTR_ASSIGN;
+				}
+				return Token.COLON;
+			}			
+			
+			return Token.ERROR;
+		}
+
+		bool decimal_digits (int c)
+		{
+			int d;
+			bool seen_digits = false;
+			
+			if (c != -1)
+				number.Append ((char) c);
+			while ((d = peekChar ()) != -1){
+				if (Char.IsDigit ((char)d)){
+					number.Append ((char) d);
+					getChar ();
+					seen_digits = true;
+				} else
+					break;
+			}
+			return seen_digits;
+		}
+
+		
+		int real_type_suffix (int c)
+		{
+			int t;
+			
+			switch (c){
+			case 'F': case 'f':
+				t =  Token.LITERAL_SINGLE;
+				break;
+			case 'R': case 'r':
+				t = Token.LITERAL_DOUBLE;
+				break;
+			case 'D': case 'd':
+				 t= Token.LITERAL_DECIMAL;
+				break;
+			default:
+				return Token.NONE;
+			}
+			getChar ();
+			return t;
+		}
+
+		int integer_type_suffix (int c)
+		{
+			int t;
+			
+			try {
+			
+				switch (c){
+				case 'S': case 's':
+					t =  Token.LITERAL_INTEGER; // SHORT ?
+			
+				// hexadecimal literals - like &H8000S is "-32768" 
+				// and not an overflow exception 
+				// Check for other literals ???
+
+					if(lon == 32768) {
+                                                val = (short) lon;
+					}
+					else 
+						val = ((IConvertible)val).ToInt16(null);
+					break;
+				case 'I': case 'i':
+					t = Token.LITERAL_INTEGER;
+					val = ((IConvertible)val).ToInt32(null);
+					break;
+				case 'L': case 'l':
+					 t= Token.LITERAL_INTEGER; // LONG ?
+					 val = ((IConvertible)val).ToInt64(null);
+					break;
+				default:
+					if ((long)val <= System.Int32.MaxValue &&
+						(long)val >= System.Int32.MinValue) {
+						val = ((IConvertible)val).ToInt32(null);
+						return Token.LITERAL_INTEGER;
+					} else {
+						val = ((IConvertible)val).ToInt64(null);
+						return Token.LITERAL_INTEGER; // LONG ?
+					}
+				}
+				getChar ();
+				return t;
+			} catch (Exception e) {
+				val = e.ToString();
+				return Token.ERROR;
+			}
+		}
+		
+		int adjust_real (int t)
+		{
+			string s = number.ToString ();
+
+			switch (t){
+			case Token.LITERAL_DECIMAL:
+				val = new System.Decimal ();
+				val = System.Decimal.Parse (
+					s, styles, csharp_format_info);
+				break;
+			case Token.LITERAL_DOUBLE:
+				val = new System.Double ();
+				val = System.Double.Parse (
+					s, styles, csharp_format_info);
+				break;
+			case Token.LITERAL_SINGLE:
+				val = new System.Double ();
+				val = (float) System.Double.Parse (
+					s, styles, csharp_format_info);
+				break;
+
+			case Token.NONE:
+				val = new System.Double ();
+				val = System.Double.Parse (
+					s, styles, csharp_format_info);
+				t = Token.LITERAL_DOUBLE;
+				break;
+			}
+			return t;
+		}
+
+		long hex_digits ()
+		{
+			StringBuilder hexNumber = new StringBuilder ();
+			
+			int d;
+
+			while ((d = peekChar ()) != -1){
+				char e = Char.ToUpper ((char) d);
+				
+				if (Char.IsDigit (e) || (e >= 'A' && e <= 'F')){
+					hexNumber.Append (e);
+					getChar ();
+				} else
+					break;
+			}
+			lon = System.Int64.Parse (hexNumber.ToString(), NumberStyles.HexNumber);
+			return lon;
+		}
+
+		long octal_digits ()
+		{
+			long valueToReturn = 0;
+			
+			int d;
+
+			while ((d = peekChar ()) != -1){
+				char e = (char)d;			
+				if (Char.IsDigit (e) && (e < '8')){
+					valueToReturn *= 8;
+					valueToReturn += (d - (int)'0');
+					getChar ();
+				} else
+					break;
+			}
+			
+			return valueToReturn;
+		}
+
+		int handle_integer_literal_in_other_bases(int peek)
+		{
+			if (peek == 'h' || peek == 'H'){
+				getChar ();
+				val = hex_digits ();
+				return integer_type_suffix (peekChar ());
+			}
+			
+			if (peek == 'o' || peek == 'O'){
+				getChar ();
+				val = octal_digits ();
+				return integer_type_suffix (peekChar ());
+			}
+			
+			return Token.NONE;
+		}
+		
+		//
+		// Invoked if we know we have .digits or digits
+		//
+		int is_number (int c)
+		{
+			bool is_real = false;
+			number = new StringBuilder ();
+			int type;
+			bool non_prefixdecimal = false; //To capture decimals like .50
+
+			number.Length = 0;
+
+			if (Char.IsDigit ((char)c)){
+				decimal_digits (c);
+				c = peekChar ();	
+				non_prefixdecimal = true;
+			}
+
+			//
+			// We need to handle the case of
+			// "1.1" vs "1.ToString()" (LITERAL_SINGLE vs NUMBER DOT IDENTIFIER)
+			//
+			if (c == '.'){
+				if (non_prefixdecimal == false)
+					 putback ('.');
+				if (decimal_digits (getChar())){
+					is_real = true;
+					c = peekChar ();
+				} else {
+					putback ('.');
+					number.Length -= 1;
+					val = System.Int64.Parse(number.ToString());
+					return integer_type_suffix('.');
+				}
+			}
+			
+			if (c == 'e' || c == 'E'){
+				is_real = true;
+				number.Append ("e");
+				getChar ();
+				
+				c = peekChar ();
+				if (c == '+'){
+					number.Append ((char) c);
+					getChar ();
+					c = peekChar ();
+				} else if (c == '-'){
+					number.Append ((char) c);
+					getChar ();
+					c = peekChar ();
+				}
+				decimal_digits (-1);
+				c = peekChar ();
+			}
+
+			type = real_type_suffix (c);
+			if (type == Token.NONE && !is_real){
+				val = System.Int64.Parse(number.ToString());
+				return integer_type_suffix(c);
+			}
+			
+			return adjust_real (type);
+		}
+			
+		int getChar ()
+		{
+			if (putback_char != -1){
+				int x = putback_char;
+				putback_char = -1;
+
+				return x;
+			}
+			return reader.Read ();
+		}
+
+		int peekChar ()
+		{
+			if (putback_char != -1)
+				return putback_char;
+			return reader.Peek ();
+		}
+		
+
+		void putback (int c)
+		{
+			if (putback_char != -1)
+				throw new Exception ("This should not happen putback on putback");
+			putback_char = c;
+		}
+
+		public bool advance ()
+		{
+			return current_token != Token.EOF ;
+		}
+
+		public Object Value {
+			get {
+				return val;
+			}
+		}
+
+		public Object value ()
+		{
+			return val;
+		}
+
+		private bool IsEOL(int currentChar)
+		{
+			bool retVal;
+			
+			if (currentChar ==  0x0D) {
+				if (peekChar() ==  0x0A) // if it is a CR-LF pair consume LF also
+					getChar();
+
+				retVal = true;
+			}
+			else {
+				retVal = (currentChar ==  -1 || currentChar ==  0x0A || currentChar ==  0x2028 || currentChar ==  0x2029);
+			}
+
+			if(retVal) {
+				nextLine();
+			}
+
+			return retVal;
+		}
+
+		private int DropComments()		
+		{
+			//int d;
+			while (!IsEOL(/*d =*/ getChar ()))
+				col++;
+
+			return Token.EOL;
+		}	
+	 	
+		public bool putbacktoken = false;
+		public bool flag = false;		
+		int next_token;
+			
+		public int token ()
+		{
+			int before_last_token = last_token;
+			last_token = current_token;
+			do
+			{
+				current_token = xtoken ();
+				if(current_token == Token.END) {
+					next_token = xtoken();
+					putbacktoken = true;
+					if (next_token == Token.EOL) 
+						return Token.END_EOL;
+					 else 
+						return Token.END;
+				}	
+				if (current_token == Token.COLON) {
+					next_token = xtoken();
+					putbacktoken = true;
+					if (next_token == Token.EOL) {
+						if (last_token != Token.LABELNAME && last_token != Token.LITERAL_INTEGER) {
+							current_token = Token.EOL;
+							putbacktoken = false;
+						}
+						else if (before_last_token == Token.GOTO) {
+							current_token = Token.EOL;
+							putbacktoken = false;
+						}
+					}
+				}
+				if (current_token == 0) 
+					return Token.EOF;
+				if (current_token == Token.REM)
+					current_token = DropComments();
+			} while (last_token == Token.EOL && current_token == Token.EOL);
+
+			return current_token;
+		}
+
+		private string GetIdentifier()
+		{
+			int c = getChar();
+			if (is_identifier_start_character ((char) c))
+				return GetIdentifier(c);
+			else
+				return null;
+		}
+
+		private bool IsLabel ()
+		{
+			char c = (char) peekChar();
+			//putback (c);
+			return (c == ':');
+		}
+
+		private string GetIdentifier(int c)
+		{
+			StringBuilder id = new StringBuilder ();
+
+			id.Append ((char) c);
+				
+			while ((c = peekChar ()) != -1) 
+			{
+				if (is_identifier_part_character ((char) c))
+				{
+					id.Append ((char)getChar ());
+					col++;
+				} 
+				else 
+					break;
+			}
+			
+			cant_have_a_type_character = false;
+			
+			return id.ToString();
+		}
+
+		private bool is_doublequote(int currentChar)
+		{
+			return (currentChar == '"' || 
+					currentChar == 0x201C || // unicode left double-quote character
+					currentChar == 0x201D);  // unicode right double-quote character
+		}
+		
+		private bool is_whitespace(int c)
+		{
+			return (c == ' ' || c == '\t' || c == '\v' || c == '\r' || c == 0xa0);
+		}
+		
+		private bool tokens_seen = false;
+		
+		private void nextLine()
+		{
+			cant_have_a_type_character = true;
+			line++;
+			ref_line++;
+			col = 0;
+			tokens_seen = false;
+		}
+
+		public int xtoken ()
+		{
+			int t;
+			bool doread = false;
+			int c;
+
+			if (putbacktoken == true) {
+				putbacktoken = false;
+				return next_token;
+			}
+	
+			val = null;
+			for (;(c = getChar ()) != -1; col++) {
+			
+				// Handle line continuation character
+				if (c == '_') 
+				{
+					int d = peekChar();
+					if (!is_identifier_part_character((char)d)) {
+						while ((c = getChar ()) != -1 && !IsEOL(c)) {}
+						c = getChar ();
+						tokens_seen = true;
+					}
+				}
+					
+				
+				// white space
+				if (is_whitespace(c)) {
+					// expand tabs for location
+					if (c == '\t')
+						col = (((col + ExpandedTabsSize) / ExpandedTabsSize) * ExpandedTabsSize) - 1;
+					cant_have_a_type_character = true;
+					continue;
+				}
+				
+				// Handle line comments.
+				if (c == '\'')
+					return Token.REM;					
+				
+				// Handle EOL.
+				if (IsEOL(c))
+				{
+					if (current_token == Token.EOL) // if last token was also EOL keep skipping
+						continue;
+					return Token.EOL;
+				}
+				
+				// Handle escaped identifiers
+				if (c == '[')
+				{
+					bool is_first_token_in_line = !tokens_seen;
+					if ((val = GetIdentifier()) == null)
+						break;
+					if ((c = getChar()) != ']')
+						break;
+					tokens_seen = true;
+					if (IsLabel() && is_first_token_in_line)
+						return Token.LABELNAME;
+
+					if (last_token == Token.GOTO)
+						return Token.LABELNAME;
+					return Token.IDENTIFIER;
+				}
+
+				// Handle unescaped identifiers
+				if (is_identifier_start_character ((char) c))
+				{
+					string id;
+					bool is_first_token_in_line = !tokens_seen;
+					if ((id = GetIdentifier(c)) == null)
+						break;
+					val = id;
+					tokens_seen = true;
+					if (is_keyword(id) && (current_token != Token.DOT))
+						return getKeyword(id);
+
+					if (IsLabel() && is_first_token_in_line)
+						return Token.LABELNAME;
+
+					if (last_token == Token.GOTO)
+						return Token.LABELNAME;
+					return Token.IDENTIFIER;
+				}
+
+				// Treat string literals
+				if (is_doublequote(c)) {
+					cant_have_a_type_character = true;
+					return ExtractStringOrCharLiteral(c);
+				}
+			
+				// handle numeric literals
+
+				if (Char.IsDigit ((char) c))
+                                {
+                                        cant_have_a_type_character = false;
+                                        tokens_seen = true;
+                                        return is_number (c);
+                                }
+
+				if (c == '.')
+				{
+					cant_have_a_type_character = true;
+					tokens_seen = true;
+					if (Char.IsDigit ((char) peekChar ()))
+						return is_number (c);
+					return Token.DOT;
+				}
+				if ((t = is_punct ((char)c, ref doread)) != Token.ERROR) {
+					cant_have_a_type_character = true;
+
+					if (t == Token.NONE)
+						continue;
+						
+					if (doread){
+						getChar ();
+						col++;
+					}
+					tokens_seen = true;
+					return t;
+				}
+				
+				error_details = ((char)c).ToString ();
+				return Token.ERROR;
+			}
+
+			if (current_token != Token.EOL) // if last token wasn't EOL send it before EOF
+				return Token.EOL;
+			
+			return Token.EOF;
+		}
+
+		private int ExtractDateTimeLiteral()
+		{
+			int c;
+			
+			StringBuilder sb = new StringBuilder();
+			for (;(c = getChar ()) != -1; col++)
+			{
+				if (c == '#') {
+					val = ParseDateLiteral(sb);
+					return Token.LITERAL_DATE;
+				}
+				if (IsEOL(c)) {
+					break;
+				} 
+				if (c == '-')
+					c = '/';
+				sb.Append((char)c);
+			}
+			return Token.ERROR;
+		}
+		
+		private int ExtractStringOrCharLiteral(int c)
+		{
+			StringBuilder s = new StringBuilder ();
+
+			tokens_seen = true;
+
+			while ((c = getChar ()) != -1){
+				if (is_doublequote(c)){
+					if (is_doublequote(peekChar()))
+						getChar();
+					else {
+						//handle Char Literals
+						if (peekChar() == 'C' || peekChar() == 'c') {
+							getChar();
+							if (s.Length == 1) {
+								val = s[0];
+								return Token.LITERAL_CHARACTER;
+							} else {
+								val = "Incorrect length for a character literal";
+								return Token.ERROR;
+							}							
+						} else {
+							val = s.ToString ();
+							return Token.LITERAL_STRING;
+						}
+					}
+				}
+
+				if (IsEOL(c)) {
+					return Token.ERROR;
+				}
+			
+				s.Append ((char) c);
+			}
+					
+			return Token.ERROR;
+		}
+
+		static IFormatProvider enUSculture = new CultureInfo("en-US", true);
+
+		private DateTime ParseDateLiteral(StringBuilder value)
+		{
+			try
+			{
+	  			return DateTime.Parse(value.ToString(),
+            	           		  	  enUSculture,
+        	                   	  	  DateTimeStyles.NoCurrentDateDefault | DateTimeStyles.AllowWhiteSpaces);
+ 			}
+	 		catch (FormatException ex)
+ 			{
+				//TODO: What is the correct error number and message?
+				Report.Error (1, Location, string.Format("Invalid date literal '{0}'", value.ToString()) 
+					+ Environment.NewLine + ex.ToString());
+ 			}
+	 		catch (Exception)
+ 			{
+				Report.Error (1, Location, "Error parsing date literal");	//TODO: What is the correct error number and message?
+ 			}
+			return new DateTime();
+		}
+ 
+		public void PositionCursorAtNextPreProcessorDirective()
+		{
+			int t;
+			
+			for(t = token(); t != Token.HASH && t != Token.EOF ; t = token()); 
+
+			if(t == Token.EOF)
+				throw new ApplicationException("Unexpected EOF while looking for a pre-processor directive");
+			
+			if(t == Token.HASH) {
+				tokens_seen = false;
+				putback('#');
+			}
+		}
+
+	}
+}
diff --git a/dead/mbas/mbas.cmbx b/dead/mbas/mbas.cmbx
new file mode 100644
index 00000000..ef477437
--- /dev/null
+++ b/dead/mbas/mbas.cmbx
@@ -0,0 +1,16 @@
+<Combine name="mbas" fileversion="2.0">
+  <Configurations active="Debug">
+    <Configuration name="Release" ctype="CombineConfiguration">
+      <Entry build="False" name="mbas" />
+    </Configuration>
+    <Configuration name="Debug" ctype="CombineConfiguration">
+      <Entry build="False" name="mbas" />
+    </Configuration>
+  </Configurations>
+  <StartMode startupentry="mbas" single="True">
+    <Execute type="None" entry="mbas" />
+  </StartMode>
+  <Entries>
+    <Entry filename="./mbas.mdp" />
+  </Entries>
+</Combine>
\ No newline at end of file
diff --git a/dead/mbas/mbas.csproj b/dead/mbas/mbas.csproj
new file mode 100644
index 00000000..94c25c27
--- /dev/null
+++ b/dead/mbas/mbas.csproj
@@ -0,0 +1,291 @@
+<VisualStudioProject>
+    <CSHARP
+        ProjectType = "Local"
+        ProductVersion = "7.10.3077"
+        SchemaVersion = "2.0"
+        ProjectGuid = "{D9868C8B-B8C9-43E0-8702-F33AD49F1CC3}"
+    >
+        <Build>
+            <Settings
+                ApplicationIcon = "mbas.ico"
+                AssemblyKeyContainerName = ""
+                AssemblyName = "mbas"
+                AssemblyOriginatorKeyFile = ""
+                DefaultClientScript = "JScript"
+                DefaultHTMLPageLayout = "Grid"
+                DefaultTargetSchema = "IE50"
+                DelaySign = "false"
+                OutputType = "Exe"
+                PreBuildEvent = ""
+                PostBuildEvent = ""
+                RootNamespace = "Mono.Languages"
+                RunPostBuildEvent = "OnBuildSuccess"
+                StartupObject = ""
+            >
+                <Config
+                    Name = "Debug"
+                    AllowUnsafeBlocks = "false"
+                    BaseAddress = "285212672"
+                    CheckForOverflowUnderflow = "false"
+                    ConfigurationOverrideFile = ""
+                    DefineConstants = "DEBUG;TRACE"
+                    DocumentationFile = ""
+                    DebugSymbols = "true"
+                    FileAlignment = "4096"
+                    IncrementalBuild = "true"
+                    NoStdLib = "false"
+                    NoWarn = ""
+                    Optimize = "false"
+                    OutputPath = "E:\mbas-out\"
+                    RegisterForComInterop = "false"
+                    RemoveIntegerChecks = "false"
+                    TreatWarningsAsErrors = "false"
+                    WarningLevel = "4"
+                />
+                <Config
+                    Name = "Release"
+                    AllowUnsafeBlocks = "false"
+                    BaseAddress = "285212672"
+                    CheckForOverflowUnderflow = "false"
+                    ConfigurationOverrideFile = ""
+                    DefineConstants = "TRACE"
+                    DocumentationFile = ""
+                    DebugSymbols = "false"
+                    FileAlignment = "4096"
+                    IncrementalBuild = "false"
+                    NoStdLib = "false"
+                    NoWarn = ""
+                    Optimize = "true"
+                    OutputPath = "bin\Release\"
+                    RegisterForComInterop = "false"
+                    RemoveIntegerChecks = "false"
+                    TreatWarningsAsErrors = "false"
+                    WarningLevel = "4"
+                />
+            </Settings>
+            <References>
+                <Reference
+                    Name = "System"
+                    AssemblyName = "System"
+                    HintPath = "..\..\..\..\WINNT\Microsoft.NET\Framework\v1.0.3705\System.dll"
+                />
+                <Reference
+                    Name = "System.Data"
+                    AssemblyName = "System.Data"
+                    HintPath = "..\..\..\..\WINNT\Microsoft.NET\Framework\v1.0.3705\System.Data.dll"
+                />
+                <Reference
+                    Name = "System.XML"
+                    AssemblyName = "System.Xml"
+                    HintPath = "..\..\..\..\WINNT\Microsoft.NET\Framework\v1.0.3705\System.XML.dll"
+                />
+                <Reference
+                    Name = "Mono.GetOptions"
+                    Project = "{88BF59CF-3127-46E8-A61D-613E333FFAC7}"
+                    Package = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}"
+                />
+                <Reference
+                    Name = "Microsoft.VisualBasic"
+                    Project = "{8A34E0CD-E436-4969-8103-0B66F5FC82EA}"
+                    Package = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}"
+                />
+            </References>
+        </Build>
+        <Files>
+            <Include>
+                <File
+                    RelPath = "argument.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "AssemblyInfo.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "assign.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "attribute.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "cfold.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "ChangeLog"
+                    BuildAction = "None"
+                />
+                <File
+                    RelPath = "class.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "codegen.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "const.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "constant.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "decl.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "defaultparserattribute.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "delegate.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "driver.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "ecore.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "enum.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "expression.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "genericparser.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "interface.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "literal.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "location.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "mbas.ico"
+                    BuildAction = "Content"
+                />
+                <File
+                    RelPath = "mb-parser.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "mb-parser.jay"
+                    BuildAction = "None"
+                />
+                <File
+                    RelPath = "mb-tokenizer.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "modifiers.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "module.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "namespace.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "parameter.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "pending.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "report.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "rootcontext.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "sourcebeingcompiled.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "statement.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "statementCollection.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "support.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "tree.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "typemanager.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "testmbas\filelist"
+                    BuildAction = "Content"
+                />
+            </Include>
+        </Files>
+    </CSHARP>
+</VisualStudioProject>
+
diff --git a/dead/mbas/mbas.exe.sources b/dead/mbas/mbas.exe.sources
new file mode 100644
index 00000000..29d6b2e2
--- /dev/null
+++ b/dead/mbas/mbas.exe.sources
@@ -0,0 +1,37 @@
+argument.cs
+AssemblyInfo.cs
+assign.cs
+attribute.cs
+block.cs
+cfold.cs
+class.cs
+codegen.cs
+CompilerOptions.cs
+constant.cs
+const.cs
+decl.cs
+defaultparserattribute.cs
+delegate.cs
+driver.cs
+ecore.cs
+enum.cs
+expression.cs
+genericparser.cs
+interface.cs
+literal.cs
+location.cs
+mb-tokenizer.cs
+modifiers.cs
+module.cs
+namespace.cs
+parameter.cs
+pending.cs
+report.cs
+rootcontext.cs
+sourcebeingcompiled.cs
+statementCollection.cs
+statement.cs
+support.cs
+tree.cs
+typemanager.cs
+../build/common/Consts.cs
diff --git a/dead/mbas/mbas.ico b/dead/mbas/mbas.ico
new file mode 100644
index 00000000..e134617d
Binary files /dev/null and b/dead/mbas/mbas.ico differ
diff --git a/dead/mbas/mbas.prjx b/dead/mbas/mbas.prjx
new file mode 100644
index 00000000..a8032772
--- /dev/null
+++ b/dead/mbas/mbas.prjx
@@ -0,0 +1,62 @@
+<Project name="mbas" description="MonoBASIC: Mono's VisualBasic.Net compiler" newfilesearch="None" enableviewstate="True" version="1.1" projecttype="C#">
+  <Contents>
+    <File name="./argument.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./AssemblyInfo.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./assign.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./attribute.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./cfold.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./class.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./codegen.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./constant.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./const.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./decl.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./defaultparserattribute.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./delegate.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./driver.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./ecore.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./enum.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./expression.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./genericparser.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./interface.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./literal.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./location.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./mb-parser.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./mb-parser.jay" subtype="Code" buildaction="Nothing" dependson="" data="" />
+    <File name="./mb-tokenizer.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./modifiers.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./module.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./namespace.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./parameter.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./pending.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./report.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./rootcontext.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./sourcebeingcompiled.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./statementCollection.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./statement.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./support.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./tree.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./typemanager.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./ChangeLog" subtype="Code" buildaction="Nothing" dependson="" data="" />
+  </Contents>
+  <References>
+    <Reference type="Gac" refto="/usr/lib/Mono.GetOptions.dll" localcopy="True" />
+  </References>
+  <DeploymentInformation target="" script="" strategy="File" />
+  <Configuration runwithwarnings="False" name="Debug">
+    <CodeGeneration runtime="MsNet" compiler="Csc" warninglevel="4" includedebuginformation="True" optimize="True" unsafecodeallowed="False" generateoverflowchecks="True" mainclass="" target="Exe" definesymbols="DEBUG" generatexmldocumentation="False" win32Icon="./mbas.ico" />
+    <Execution commandlineparameters="" consolepause="True" />
+    <Output directory="./" assembly="mbas" executeScript="" executeBeforeBuild="" executeAfterBuild="" />
+  </Configuration>
+  <Configurations active="Debug">
+    <Configuration runwithwarnings="False" name="Debug">
+      <CodeGeneration runtime="MsNet" compiler="Csc" warninglevel="4" includedebuginformation="True" optimize="True" unsafecodeallowed="False" generateoverflowchecks="True" mainclass="" target="Exe" definesymbols="DEBUG" generatexmldocumentation="False" win32Icon="./mbas.ico" />
+      <Execution commandlineparameters="" consolepause="True" />
+      <Output directory="./" assembly="mbas" executeScript="" executeBeforeBuild="" executeAfterBuild="" />
+    </Configuration>
+    <Configuration runwithwarnings="False" name="Release">
+      <CodeGeneration runtime="MsNet" compiler="Csc" warninglevel="4" includedebuginformation="True" optimize="True" unsafecodeallowed="False" generateoverflowchecks="True" mainclass="" target="Exe" definesymbols="" generatexmldocumentation="False" win32Icon="./mbas.ico" />
+      <Execution commandlineparameters="" consolepause="True" />
+      <Output directory="./" assembly="mbas" executeScript="" executeBeforeBuild="" executeAfterBuild="" />
+    </Configuration>
+  </Configurations>
+</Project>
\ No newline at end of file
diff --git a/dead/mbas/mbas.sln b/dead/mbas/mbas.sln
new file mode 100644
index 00000000..1e859c5e
--- /dev/null
+++ b/dead/mbas/mbas.sln
@@ -0,0 +1,37 @@
+Microsoft Visual Studio Solution File, Format Version 8.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "mbas", "mbas.csproj", "{D9868C8B-B8C9-43E0-8702-F33AD49F1CC3}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.GetOptions", "..\class\Mono.GetOptions\Mono.GetOptions.csproj", "{88BF59CF-3127-46E8-A61D-613E333FFAC7}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.VisualBasic", "..\class\Microsoft.VisualBasic\Microsoft.VisualBasic.csproj", "{8A34E0CD-E436-4969-8103-0B66F5FC82EA}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfiguration) = preSolution
+		Debug = Debug
+		Release = Release
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
+		{D9868C8B-B8C9-43E0-8702-F33AD49F1CC3}.Debug.ActiveCfg = Debug|.NET
+		{D9868C8B-B8C9-43E0-8702-F33AD49F1CC3}.Debug.Build.0 = Debug|.NET
+		{D9868C8B-B8C9-43E0-8702-F33AD49F1CC3}.Release.ActiveCfg = Release|.NET
+		{D9868C8B-B8C9-43E0-8702-F33AD49F1CC3}.Release.Build.0 = Release|.NET
+		{88BF59CF-3127-46E8-A61D-613E333FFAC7}.Debug.ActiveCfg = Debug|.NET
+		{88BF59CF-3127-46E8-A61D-613E333FFAC7}.Debug.Build.0 = Debug|.NET
+		{88BF59CF-3127-46E8-A61D-613E333FFAC7}.Release.ActiveCfg = Release|.NET
+		{88BF59CF-3127-46E8-A61D-613E333FFAC7}.Release.Build.0 = Release|.NET
+		{8A34E0CD-E436-4969-8103-0B66F5FC82EA}.Debug.ActiveCfg = Debug|.NET
+		{8A34E0CD-E436-4969-8103-0B66F5FC82EA}.Debug.Build.0 = Debug|.NET
+		{8A34E0CD-E436-4969-8103-0B66F5FC82EA}.Release.ActiveCfg = Release|.NET
+		{8A34E0CD-E436-4969-8103-0B66F5FC82EA}.Release.Build.0 = Release|.NET
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+EndGlobal
diff --git a/dead/mbas/modifiers.cs b/dead/mbas/modifiers.cs
new file mode 100644
index 00000000..f49b88b2
--- /dev/null
+++ b/dead/mbas/modifiers.cs
@@ -0,0 +1,252 @@
+//
+// modifiers.cs: Modifier handling.
+// 
+using System;
+using System.Reflection;
+
+namespace Mono.MonoBASIC {
+	public class Modifiers {
+
+		//
+		// The ordering of the following 4 constants
+		// has been carefully done.
+		//
+		public const int PROTECTED = 0x00001;
+		public const int PUBLIC    = 0x00002;
+		public const int PRIVATE   = 0x00004;
+		public const int INTERNAL  = 0x00008;
+		public const int NEW       = 0x00010;
+		public const int ABSTRACT  = 0x00020;
+		public const int SEALED    = 0x00040;
+		public const int STATIC    = 0x00080;
+		public const int READONLY  = 0x00100;
+		public const int VIRTUAL   = 0x00200;
+		public const int OVERRIDE  = 0x00400;
+		public const int EXTERN    = 0x00800;
+		public const int VOLATILE  = 0x01000;
+		public const int UNSAFE    = 0x02000;
+		public const int WRITEONLY = 0x04000;
+		// Todo : Shadows needs implementation		
+		public const int SHADOWS   = 0x08000;
+		public const int DEFAULT   = 0x10000;
+		public const int NONVIRTUAL= 0x20000;
+		private const int TOP      = 0x20000;
+		
+
+		public const int Accessibility =
+			PUBLIC | PROTECTED | INTERNAL | PRIVATE;
+		
+		static public string Name (int i)
+		{
+			string s = "";
+			
+			switch (i) {
+			case Modifiers.NEW:
+				s = "overloads"; break;
+			case Modifiers.PUBLIC:
+				s = "public"; break;
+			case Modifiers.PROTECTED:
+				s = "protected"; break;
+			case Modifiers.INTERNAL:
+				s = "friend"; break;
+			case Modifiers.PRIVATE:
+				s = "private"; break;
+			case Modifiers.ABSTRACT:
+				s = "mustinherit"; break;
+			case Modifiers.SEALED:
+				s = "notinheritable"; break;
+			case Modifiers.STATIC:
+				s = "shared"; break;
+			case Modifiers.READONLY:
+				s = "readonly"; break;
+			case Modifiers.VIRTUAL:
+				s = "overridable"; break;
+			case Modifiers.OVERRIDE:
+				s = "overrides"; break;
+			case Modifiers.EXTERN:
+				s = "extern"; break;
+			case Modifiers.VOLATILE:
+				s = "volatile"; break;
+			case Modifiers.SHADOWS:
+				s = "shadows"; break;
+			case Modifiers.NONVIRTUAL:
+				s = "notoveridable"; break;
+			}
+
+			return s;
+		}
+
+		public static TypeAttributes TypeAttr (int mod_flags, bool is_toplevel)
+		{
+			TypeAttributes t = 0;
+
+			if (is_toplevel){
+				if ((mod_flags & PUBLIC) != 0)
+					t |= TypeAttributes.Public;
+				if ((mod_flags & PRIVATE) != 0)
+					t |= TypeAttributes.NotPublic;
+			} else {
+				if ((mod_flags & PUBLIC) != 0)
+					t |= TypeAttributes.NestedPublic;
+				if ((mod_flags & PRIVATE) != 0)
+					t |= TypeAttributes.NestedPrivate;
+				if ((mod_flags & PROTECTED) != 0 && (mod_flags & INTERNAL) != 0)
+					t |= TypeAttributes.NestedFamORAssem;
+				if ((mod_flags & PROTECTED) != 0)
+					t |= TypeAttributes.NestedFamily;
+				if ((mod_flags & INTERNAL) != 0)
+					t |= TypeAttributes.NestedAssembly;
+			}
+			
+			if ((mod_flags & SEALED) != 0)
+				t |= TypeAttributes.Sealed;
+			if ((mod_flags & ABSTRACT) != 0)
+				t |= TypeAttributes.Abstract;
+
+			return t;
+		}
+		
+		public static TypeAttributes TypeAttr (int mod_flags, TypeContainer caller)
+		{
+			TypeAttributes t = TypeAttr (mod_flags, caller.IsTopLevel);
+
+			// If we do not have static constructors, static methods
+			// can be invoked without initializing the type.
+			if (!caller.HaveStaticConstructor)
+				t |= TypeAttributes.BeforeFieldInit;
+				
+			return t;
+		}
+
+		public static FieldAttributes FieldAttr (int mod_flags)
+		{
+			FieldAttributes fa = 0;
+
+			if ((mod_flags & PUBLIC) != 0)
+				fa |= FieldAttributes.Public;
+			if ((mod_flags & PRIVATE) != 0)
+				fa |= FieldAttributes.Private;
+			if ((mod_flags & PROTECTED) != 0){
+				if ((mod_flags & INTERNAL) != 0)
+					fa |= FieldAttributes.FamORAssem;
+				else 
+					fa |= FieldAttributes.Family;
+			} else {
+				if ((mod_flags & INTERNAL) != 0)
+					fa |= FieldAttributes.Assembly;
+			}
+			
+			if ((mod_flags & STATIC) != 0)
+				fa |= FieldAttributes.Static;
+			if ((mod_flags & READONLY) != 0)
+				fa |= FieldAttributes.InitOnly;
+			return fa;
+		}
+
+		public static MethodAttributes MethodAttr (int mod_flags)
+		{
+			MethodAttributes ma = 0;
+			if ((mod_flags & PUBLIC) != 0)
+				ma |= MethodAttributes.Public;
+			if ((mod_flags & PRIVATE) != 0)
+				ma |= MethodAttributes.Private;
+			if ((mod_flags & PROTECTED) != 0){
+				if ((mod_flags & INTERNAL) != 0)
+					ma |= MethodAttributes.FamORAssem;
+				else 
+					ma |= MethodAttributes.Family;
+			} else {
+				if ((mod_flags & INTERNAL) != 0)
+					ma |= MethodAttributes.Assembly;
+			}
+
+			if ((mod_flags & STATIC) != 0)
+				ma |= MethodAttributes.Static;
+			if ((mod_flags & ABSTRACT) != 0){
+				ma |= MethodAttributes.Abstract | MethodAttributes.Virtual |
+					MethodAttributes.HideBySig;
+			}
+			if ((mod_flags & NONVIRTUAL) != 0)
+				ma |= MethodAttributes.Final;
+
+			if ((mod_flags & VIRTUAL) != 0)
+				ma |= MethodAttributes.Virtual;
+
+			if ((mod_flags & OVERRIDE) != 0)
+				ma |= MethodAttributes.Virtual | MethodAttributes.HideBySig;
+			else {
+				if ((ma & MethodAttributes.Virtual) != 0)
+					ma |= MethodAttributes.NewSlot;
+			}
+			
+			if ((mod_flags & NEW) != 0)
+				ma |= MethodAttributes.HideBySig;
+
+			//if ((mod_flags & SHADOWS) != 0)
+				// needs to be fixed
+
+			return ma;
+		}
+
+		// <summary>
+		//   Checks the object @mod modifiers to be in @allowed.
+		//   Returns the new mask.  Side effect: reports any
+		//   incorrect attributes. 
+		// </summary>
+		public static int Check (int allowed, int mod, int def_access, Location l)
+		{
+			int invalid_flags  = (~allowed) & mod;
+			int i;
+
+			if (invalid_flags == 0){
+				int a = mod;
+
+				if ((mod & Modifiers.UNSAFE) != 0){
+					if (!RootContext.Unsafe){
+						Report.Error (227, l,
+							      "Unsafe code requires the --unsafe command " +
+							      "line option to be specified");
+					}
+				}
+				
+				//
+				// If no accessibility bits provided
+				// then provide the defaults.
+				//
+				if ((mod & Accessibility) == 0){
+					mod |= def_access;
+					return mod;
+				}
+
+				//
+				// Make sure that no conflicting accessibility
+				// bits have been set.  Protected+Internal is
+				// allowed, that is why they are placed on bits
+				// 1 and 4 (so the shift 3 basically merges them)
+				//
+				a &= 15;
+				a |= (a >> 3);
+				a = ((a & 2) >> 1) + (a & 5);
+				a = ((a & 4) >> 2) + (a & 3);
+				if (a > 1)
+					Report.Error (30176, l, "More than one protection modifier specified");
+				
+				return mod;
+			}
+
+			for (i = 1; i < TOP; i <<= 1){
+				if ((i & invalid_flags) == 0)
+					continue;
+
+				Error_InvalidModifier (l, Name (i));
+			}
+
+			return allowed & mod;
+		}
+
+		public static void Error_InvalidModifier (Location l, string name)
+		{
+			Report.Error (31089, l, "the modifier " + name + " is not valid for this item");
+		}
+	}
+}
diff --git a/dead/mbas/module.cs b/dead/mbas/module.cs
new file mode 100644
index 00000000..7e59be90
--- /dev/null
+++ b/dead/mbas/module.cs
@@ -0,0 +1,73 @@
+//
+// module.cs: Module handler
+//
+// Author: Rafael Teixeira (rafaelteixeirabr@hotmail.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2002 Rafael Teixeira
+//
+using System;
+using System.Collections;
+using System.Diagnostics.SymbolStore;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using Mono.MonoBASIC ;
+
+namespace Mono.MonoBASIC
+{
+	public class Utils
+	{
+		public static void AddSpecializedAttribute(ref Attributes attrs, string attributeName, ArrayList args, Location loc)
+		{
+			Mono.MonoBASIC.Attribute specialAttr = new Mono.MonoBASIC.Attribute(attributeName, args, loc);
+			ArrayList al = new ArrayList();
+			al.Add(specialAttr);
+			if (attrs == null)
+				attrs = new Attributes(al);
+			else
+				attrs.Add(al);
+		}
+	}
+	
+	/// <summary>
+	/// Summary description for module.
+	/// </summary>
+	public class Module : Mono.MonoBASIC.Class 
+	{
+		// <summary>
+		//   Modifiers allowed in a class declaration
+		// </summary>
+		public new const int AllowedModifiers =
+			Modifiers.PUBLIC |
+			Modifiers.INTERNAL
+			;
+
+		public Module(TypeContainer parent, string name, int mod, Attributes attrs, Location l)
+			: base (parent, name, 0, attrs, l)
+		{
+			if (parent.Parent != null)
+				Report.Error (30617, l,
+					"'Module' statements can occur only at file or namespace level");
+
+			// overwrite ModFlags
+			this.ModFlags = Modifiers.Check (AllowedModifiers, mod, Modifiers.INTERNAL, l);
+
+			// add specialized attribute
+			Utils.AddSpecializedAttribute(ref attrs, "Microsoft.VisualBasic.CompilerServices.StandardModuleAttribute", null, l);
+		}
+
+		//
+		// FIXME: How do we deal with the user specifying a different
+		// layout?
+		//
+		public override TypeAttributes TypeAttr 
+		{
+			get 
+			{
+				return base.TypeAttr | TypeAttributes.AutoLayout | TypeAttributes.Class | TypeAttributes.Sealed;
+			}
+		}
+	}
+}
diff --git a/dead/mbas/namespace.cs b/dead/mbas/namespace.cs
new file mode 100644
index 00000000..6cb6b3c5
--- /dev/null
+++ b/dead/mbas/namespace.cs
@@ -0,0 +1,69 @@
+//
+// namespace.cs: Tracks namespaces
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//
+// (C) 2001 Ximian, Inc.
+//
+using System;
+using System.Collections;
+using Mono.Languages;
+
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///   Keeps track of the namespaces defined in the C# code.
+	/// </summary>
+	public class Namespace {
+		static ArrayList all_namespaces = new ArrayList ();
+		
+		Namespace parent;
+		string name;
+				
+		/// <summary>
+		///   Constructor Takes the current namespace and the
+		///   name.  This is bootstrapped with parent == null
+		///   and name = ""
+		/// </summary>
+		public Namespace (Namespace parent, string name)
+		{
+			this.name = name;
+			this.parent = parent;
+
+			all_namespaces.Add (this);
+		}
+
+		/// <summary>
+		///   The qualified name of the current namespace
+		/// </summary>
+		public string Name {
+			get {
+				string pname = parent != null ? parent.Name : "";
+				
+				if (pname == "")
+					return name;
+				else
+					return parent.Name + "." + name;
+			}
+		}
+
+		/// <summary>
+		///   The parent of this namespace, used by the parser to "Pop"
+		///   the current namespace declaration
+		/// </summary>
+		public Namespace Parent {
+			get {
+				return parent;
+			}
+		}
+		
+		/// <summary>
+		///   Show the qualified name of the namespace contained here
+		/// </summary>
+		public override string ToString() {
+			return Name;
+		}
+		
+	}
+}
diff --git a/dead/mbas/parameter.cs b/dead/mbas/parameter.cs
new file mode 100644
index 00000000..5350497e
--- /dev/null
+++ b/dead/mbas/parameter.cs
@@ -0,0 +1,634 @@
+//
+// parameter.cs: Parameter definition.
+//
+// Author: Miguel de Icaza (miguel@gnu.org)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001 Ximian, Inc (http://www.ximian.com)
+//
+//
+//
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Collections;
+
+namespace Mono.MonoBASIC {
+
+
+	/// <summary>
+	///   Represents a single method parameter
+	/// </summary>
+	public class Parameter : Attributable {
+		ParameterBuilder builder;
+		
+		[Flags]
+		public enum Modifier : byte {
+			NONE    = 0,
+			VAL 	= 0,
+			REF     = 1,
+//			OUT     = 2,
+			PARAMS  = 4,
+			// This is a flag which says that it's either REF or OUT.
+			ISBYREF = 8,
+			OPTIONAL = 16
+		}
+
+		public readonly Expression TypeName;
+		public readonly Modifier ModFlags;
+		public readonly string Name;
+		public Type parameter_type;
+		public Expression ParameterInitializer;
+		public readonly bool IsOptional;
+
+		public Parameter (Expression type, string name, Modifier mod, Attributes attrs)
+			: base (attrs)
+		{
+			Name = name;
+			ModFlags = mod;
+			TypeName = type;
+			ParameterInitializer = null;
+			IsOptional = false;
+		}
+
+		public Parameter (Expression type, string name, Modifier mod, Attributes attrs, Expression pi)
+			: base (attrs)
+		{
+			Name = name;
+			ModFlags = mod;
+			TypeName = type;
+			ParameterInitializer = pi;
+			IsOptional = false;
+		}
+
+		public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+		{
+			if (a.Type == TypeManager.marshal_as_attr_type) {
+				UnmanagedMarshal marshal = UnmanagedMarshal.DefineUnmanagedMarshal (a.UnmanagedType);
+				builder.SetMarshal (marshal);
+			} else 
+				builder.SetCustomAttribute (cb);
+		}
+
+		public Parameter (Expression type, string name, Modifier mod, Attributes attrs, Expression pi, bool opt)
+			: base (attrs)
+		{
+			Name = name;
+			ModFlags = mod;
+			TypeName = type;
+			ParameterInitializer = pi;
+			IsOptional = opt;
+		}
+
+		public override AttributeTargets AttributeTargets {
+			get {
+				return AttributeTargets.Parameter;
+			}
+		}
+		
+		// <summary>
+		//   Resolve is used in method definitions
+		// </summary>
+		public bool Resolve (DeclSpace ds, Location l)
+		{
+			parameter_type = ds.ResolveType (TypeName, false, l);
+
+			if (parameter_type == TypeManager.void_type){
+				Report.Error (1536, l, "`void' parameter is not permitted");
+				return false;
+			}
+			
+			return parameter_type != null;
+		}
+
+		public Type ExternalType (DeclSpace ds, Location l)
+		{
+			if ((ModFlags & Parameter.Modifier.ISBYREF) != 0){
+				string n = parameter_type.FullName + "&";
+
+				Type t = RootContext.LookupType (ds, n, false, l);
+
+				return t;
+			}
+			
+			return parameter_type;
+		}
+
+		public Type ParameterType {
+			get {
+				return parameter_type;
+			}
+		}
+		
+		public ParameterAttributes Attributes {
+			get {
+				int flags = ((int) ModFlags) & ~((int) Parameter.Modifier.ISBYREF | (int) Parameter.Modifier.REF);
+				switch ((Modifier) flags) {
+				case Modifier.NONE:
+					return ParameterAttributes.None;
+				case Modifier.REF:
+					return ParameterAttributes.None;
+/*
+				case Modifier.OUT:
+					return ParameterAttributes.Out;
+*/
+				case Modifier.OPTIONAL:
+					return ParameterAttributes.Optional;
+				case Modifier.PARAMS:
+					return 0;
+				}
+				
+				return ParameterAttributes.None;
+			}
+		}
+		
+		/// <summary>
+		///   Returns the signature for this parameter evaluating it on the
+		///   @tc context
+		/// </summary>
+		public string GetSignature (DeclSpace ds, Location loc)
+		{
+			if (parameter_type == null){
+				if (!Resolve (ds, loc))
+					return null;
+			}
+
+			return ExternalType (ds, loc).FullName;
+		}
+
+		public bool DefineParameter (EmitContext ec, MethodBuilder mb, ConstructorBuilder cb, int index, Location loc)
+		{
+			if (mb == null)
+				builder = cb.DefineParameter (index, Attributes, Name);
+			else 
+				builder = mb.DefineParameter (index, Attributes, Name);
+
+			if (ParameterInitializer != null) {
+				if (ParameterInitializer is MemberAccess) {
+					MemberAccess ma = ParameterInitializer as MemberAccess;
+
+					ParameterInitializer = ma.Resolve(ec);
+				} else 
+					ParameterInitializer = ParameterInitializer.Resolve (ec);
+
+				if (ParameterInitializer == null) {
+					Report.Error(-1, "Internal error - Non supported argument type in optional parameter");
+					return false;
+				}
+
+				if (parameter_type != ParameterInitializer.Type) {
+					Expression conv = Expression.ConvertImplicit (ec, ParameterInitializer, parameter_type, loc);
+					if (conv == null) {
+						Report.Error (30439, loc, "Constant expression '" + ParameterInitializer + "' not representable in type '" + parameter_type + "'");
+						return false;
+					}
+					ParameterInitializer = conv;
+				}
+
+				if (!(ParameterInitializer is Constant)) {
+					Report.Error (30059, loc, "Constant expression is required");
+					return false;
+				}
+
+				builder.SetConstant (((Constant) ParameterInitializer).GetValue());
+
+			}
+
+			if (OptAttributes != null)
+				OptAttributes.Emit (ec, this);
+			return true;
+		}
+	}
+
+	/// <summary>
+	///   Represents the methods parameters
+	/// </summary>
+	public class Parameters {
+		public Parameter [] FixedParameters;
+		public readonly Parameter ArrayParameter;
+		string signature;
+		Type [] types;
+		Location loc;
+		
+		static Parameters empty_parameters;
+		
+		public Parameters (Parameter [] fixed_parameters, Parameter array_parameter, Location l)
+		{
+			FixedParameters = fixed_parameters;
+			ArrayParameter  = array_parameter;
+			loc = l;
+		}
+	
+		/// <summary>
+		///   This is used to reuse a set of empty parameters, because they
+		///   are common
+		/// </summary>
+		public static Parameters EmptyReadOnlyParameters {
+			get {
+				if (empty_parameters == null)
+					empty_parameters = new Parameters (null, null, Location.Null);
+			
+				return empty_parameters;
+			}
+		}
+		
+		public bool HasOptional()
+		{
+			bool res = false;
+
+			foreach (Parameter p in FixedParameters) 
+			{
+				if (p.IsOptional) 
+				{
+					res = true;
+					break;
+				}
+			}
+			return (res);
+		}
+		
+		/// <summary>
+		///   Returns the number of standard (i.e. non-optional) parameters
+		/// </summary>		
+		public int CountStandardParams()
+		{
+			int res = 0;
+			if (FixedParameters == null)
+				return 0;
+
+			foreach (Parameter p in FixedParameters) {
+				if (!p.IsOptional)
+					res++;
+			}
+			return (res);
+		}
+		
+		/// <summary>
+		///   Returns the number of optional parameters
+		/// </summary>		
+		public int CountOptionalParams()
+		{
+			int res = 0;
+			if (FixedParameters == null)
+				return 0;
+							
+			foreach (Parameter p in FixedParameters) {
+				if (p.IsOptional)
+					res++;
+			}
+			return (res);
+		}		
+
+		public Expression GetDefaultValue (int i)
+		{
+			Parameter p = FixedParameters[i];
+			if (p.IsOptional)
+				return p.ParameterInitializer;
+			else
+				return null;
+		}
+
+		public void AppendParameter (Parameter p)
+		{
+			if (FixedParameters != null) 
+			{
+				Parameter [] pa = new Parameter [FixedParameters.Length+1];
+				FixedParameters.CopyTo (pa, 0);
+				pa[FixedParameters.Length] = p;
+				FixedParameters = pa;		
+			}
+			else
+			{
+				FixedParameters = new Parameter [1];
+				FixedParameters[0] = p;
+			}
+		}
+
+		public void PrependParameter (Parameter p)
+		{
+			Parameter [] pa = new Parameter [FixedParameters.Length+1];
+			FixedParameters.CopyTo (pa, 1);
+			pa[0] = p;
+			FixedParameters = pa;		
+		}
+		
+		public Parameters Copy (Location l)
+		{
+			Parameters p = new Parameters (null, null, l);
+			p.FixedParameters = new Parameter[this.FixedParameters.Length];
+			this.FixedParameters.CopyTo (p.FixedParameters, 0);
+			
+			return (p);
+			
+		}
+		
+		public bool Empty {
+			get {
+				return (FixedParameters == null) && (ArrayParameter == null);
+			}
+		}
+		
+		public void ComputeSignature (DeclSpace ds)
+		{
+			signature = "";
+			if (FixedParameters != null){
+				for (int i = 0; i < FixedParameters.Length; i++){
+					Parameter par = FixedParameters [i];
+					
+					signature += par.GetSignature (ds, loc);
+				}
+			}
+			//
+			// Note: as per the spec, the `params' arguments (ArrayParameter)
+			// are not used in the signature computation for a method
+			//
+		}
+
+		static void Error_DuplicateParameterName (string name)
+		{
+			Report.Error (
+				100, "The parameter name `" + name + "' is a duplicate");
+		}
+		
+		public bool VerifyArgs ()
+		{
+			int count;
+			int i, j;
+
+			if (FixedParameters == null)
+				return true;
+			
+			count = FixedParameters.Length;
+			string array_par_name = ArrayParameter != null ? ArrayParameter.Name : null;
+			for (i = 0; i < count; i++){
+				string base_name = FixedParameters [i].Name;
+				
+				for (j = i + 1; j < count; j++){
+					if (base_name.ToLower () != FixedParameters [j].Name.ToLower ())
+						continue;
+					Error_DuplicateParameterName (base_name);
+					return false;
+				}
+
+				if ((array_par_name != null) && (base_name.ToLower () == array_par_name.ToLower ())) {
+					Error_DuplicateParameterName (base_name);
+					return false;
+				}
+			}
+			return true;
+		}
+		
+		/// <summary>
+		///    Returns the signature of the Parameters evaluated in
+		///    the @tc environment
+		/// </summary>
+		public string GetSignature (DeclSpace ds)
+		{
+			if (signature == null){
+				VerifyArgs ();
+				ComputeSignature (ds);
+			}
+			
+			return signature;
+		}
+		
+		/// <summary>
+		///    Returns the paramenter information based on the name
+		/// </summary>
+		public Parameter GetParameterByName (string name, out int idx)
+		{
+			idx = 0;
+			int i = 0;
+
+			if (FixedParameters != null){
+				foreach (Parameter par in FixedParameters){
+					if (par.Name.ToLower() == name.ToLower()) {
+						idx = i;
+						return par;
+					}
+					i++;
+				}
+			}
+
+			if (ArrayParameter != null){
+				if (name.ToLower () == ArrayParameter.Name.ToLower ()) {
+					idx = i;
+					return ArrayParameter;
+				}
+			}
+			
+			return null;
+		}
+
+		bool ComputeParameterTypes (DeclSpace ds)
+		{
+			int extra = (ArrayParameter != null) ? 1 : 0;
+			int i = 0;
+			int pc;
+
+			if (FixedParameters == null)
+				pc = extra;
+			else
+				pc = extra + FixedParameters.Length;
+
+			types = new Type [pc];
+			
+			if (!VerifyArgs ()){
+				FixedParameters = null;
+				return false;
+			}
+
+			bool failed = false;
+			if (FixedParameters != null){
+				foreach (Parameter p in FixedParameters){
+					Type t = null;
+					
+					if (p.Resolve (ds, loc))
+						t = p.ExternalType (ds, loc);
+					else
+						failed = true;
+					
+					types [i] = t;
+					i++;
+				}
+			}
+			
+			if (extra > 0){
+				if (ArrayParameter.Resolve (ds, loc))
+					types [i] = ArrayParameter.ExternalType (ds, loc);
+				else 
+					failed = true;
+			}
+
+			if (failed){
+				types = null;
+				return false;
+			}
+
+			return true;
+		}
+
+		//
+		// This variant is used by Delegates, because they need to
+		// resolve/define names, instead of the plain LookupType
+		//
+		public bool ComputeAndDefineParameterTypes (DeclSpace ds)
+		{
+			int extra = (ArrayParameter != null) ? 1 : 0;
+			int i = 0;
+			int pc;
+
+			if (FixedParameters == null)
+				pc = extra;
+			else
+				pc = extra + FixedParameters.Length;
+			
+			types = new Type [pc];
+			
+			if (!VerifyArgs ()){
+				FixedParameters = null;
+				return false;
+			}
+
+			bool ok_flag = true;
+			
+			if (FixedParameters != null){
+				foreach (Parameter p in FixedParameters){
+					Type t = null;
+					
+					if (p.Resolve (ds, loc))
+						t = p.ExternalType (ds, loc);
+					else
+						ok_flag = false;
+					
+					types [i] = t;
+					i++;
+				}
+			}
+			
+			if (extra > 0){
+				if (ArrayParameter.Resolve (ds, loc))
+					types [i] = ArrayParameter.ExternalType (ds, loc);
+				else
+					ok_flag = false;
+			}
+
+			//
+			// invalidate the cached types
+			//
+			if (!ok_flag){
+				types = null;
+			}
+			
+			return ok_flag;
+		}
+		
+		/// <summary>
+		///   Returns the argument types as an array
+		/// </summary>
+		static Type [] no_types = new Type [0];
+		
+		public Type [] GetParameterInfo (DeclSpace ds)
+		{
+			if (types != null)
+				return types;
+			
+			if (FixedParameters == null && ArrayParameter == null)
+				return no_types;
+
+			if (ComputeParameterTypes (ds) == false){
+				types = null;
+				return null;
+			}
+
+			return types;
+		}
+
+		/// <summary>
+		///   Returns the type of a given parameter, and stores in the `is_out'
+		///   boolean whether this is an out or ref parameter.
+		///
+		///   Note that the returned type will not contain any dereference in this
+		///   case (ie, you get "int" for a ref int instead of "int&"
+		/// </summary>
+		public Type GetParameterInfo (DeclSpace ds, int idx, out Parameter.Modifier mod)
+		{
+			mod = Parameter.Modifier.NONE;
+			
+			if (!VerifyArgs ()){
+				FixedParameters = null;
+				return null;
+			}
+
+			if (FixedParameters == null && ArrayParameter == null)
+				return null;
+			
+			if (types == null)
+				if (ComputeParameterTypes (ds) == false)
+					return null;
+
+			//
+			// If this is a request for the variable lenght arg.
+			//
+			int array_idx = (FixedParameters != null ? FixedParameters.Length : 0);
+			if (idx == array_idx)
+				return types [idx];
+
+			//
+			// Otherwise, it is a fixed parameter
+			//
+			Parameter p = FixedParameters [idx];
+			mod = p.ModFlags;
+
+			if ((mod & (Parameter.Modifier.REF )) != 0)
+				mod |= Parameter.Modifier.ISBYREF;
+
+			return p.ParameterType;
+		}
+
+		public CallingConventions GetCallingConvention ()
+		{
+			// For now this is the only correc thing to do
+			return CallingConventions.Standard;
+		}
+		
+		public void LabelParameters (EmitContext ec, MethodBase builder, Location loc)
+		{
+			//
+			// Define each type attribute (in/out/ref) and
+			// the argument names.
+			//
+			Parameter [] p = FixedParameters;
+			int i = 0;
+			
+			MethodBuilder mb = null;
+			ConstructorBuilder cb = null;
+
+			if (builder is MethodBuilder)
+				mb = (MethodBuilder) builder;
+			else
+				cb = (ConstructorBuilder) builder;
+			
+			if (p != null){
+				for (i = 0; i < p.Length; i++) {
+					p [i].DefineParameter (ec, mb, cb, i + 1, loc);
+				}
+			}
+
+			if (ArrayParameter != null) {
+				ParameterBuilder pb;
+				Parameter array_param = ArrayParameter;
+				
+				if (mb == null)
+					pb = cb.DefineParameter (i + 1, array_param.Attributes,	array_param.Name);
+				else
+					pb = mb.DefineParameter (i + 1, array_param.Attributes, array_param.Name);
+					
+				CustomAttributeBuilder a = new CustomAttributeBuilder (TypeManager.cons_param_array_attribute, new object [0]);
+				pb.SetCustomAttribute (a);
+			}
+		}
+		
+	}
+}
diff --git a/dead/mbas/pending.cs b/dead/mbas/pending.cs
new file mode 100644
index 00000000..111b8d15
--- /dev/null
+++ b/dead/mbas/pending.cs
@@ -0,0 +1,562 @@
+//
+// pending.cs: Pending method implementation
+//
+// Author:
+//   Miguel de Icaza (miguel@gnu.org)
+//   Anirban Bhattacharjee (banirban@novell.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001, 2002 Ximian, Inc (http://www.ximian.com)
+//
+//
+
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Mono.MonoBASIC {
+
+	struct TypeAndMethods {
+		public Type          type;
+		public MethodInfo [] methods;
+		
+		// Far from ideal, but we want to avoid creating a copy
+		// of methods above.
+		public Type [][]     args;
+		
+		//
+		// This flag on the method says `We found a match, but
+		// because it was private, we could not use the match
+		//
+		public bool []       found;
+
+		// If a method is defined here, then we always need to
+		// create a proxy for it.  This is used when implementing
+		// an interface's indexer with a different DefaultPropName.
+		public MethodInfo [] need_proxy;
+	}
+
+	public class PendingImplementation {
+		/// <summary>
+		///   The container for this PendingImplementation
+		/// </summary>
+		TypeContainer container;
+		
+		/// <summary>
+		///   This filter is used by FindMembers, and it is used to
+		///   extract only virtual/abstract fields
+		/// </summary>
+		static MemberFilter virtual_method_filter;
+
+		/// <summary>
+		///   This is the array of TypeAndMethods that describes the pending implementations
+		///   (both interfaces and abstract methods in parent class)
+		/// </summary>
+		TypeAndMethods [] pending_implementations;
+
+		static bool IsVirtualFilter (MemberInfo m, object filterCriteria)
+		{
+			if (!(m is MethodInfo))
+				return false;
+
+			return ((MethodInfo) m).IsVirtual;
+		}
+
+		/// <summary>
+		///   Inits the virtual_method_filter
+		/// </summary>
+		static PendingImplementation ()
+		{
+			virtual_method_filter = new MemberFilter (IsVirtualFilter);
+		}
+
+		// <remarks>
+		//   Returns a list of the abstract methods that are exposed by all of our
+		//   parents that we must implement.  Notice that this `flattens' the
+		//   method search space, and takes into account overrides.  
+		// </remarks>
+		static ArrayList GetAbstractMethods (Type t)
+		{
+			ArrayList list = null;
+			bool searching = true;
+			Type current_type = t;
+			
+			do {
+				MemberList mi;
+				
+				mi = TypeContainer.FindMembers (
+					current_type, MemberTypes.Method,
+					BindingFlags.Public | BindingFlags.Instance |
+					BindingFlags.DeclaredOnly,
+					virtual_method_filter, null);
+
+				if (current_type == TypeManager.object_type)
+					searching = false;
+				else {
+					current_type = current_type.BaseType;
+					if (!current_type.IsAbstract)
+						searching = false;
+				}
+
+				if (mi.Count == 0)
+					continue;
+
+				if (mi.Count == 1 && !(mi [0] is MethodBase))
+					searching = false;
+				else 
+					list = TypeManager.CopyNewMethods (list, mi);
+			} while (searching);
+
+			if (list == null)
+				return null;
+			
+			for (int i = 0; i < list.Count; i++){
+				while (list.Count > i && !((MethodInfo) list [i]).IsAbstract)
+					list.RemoveAt (i);
+			}
+
+			if (list.Count == 0)
+				return null;
+
+			return list;
+		}
+
+		PendingImplementation (TypeContainer container, Type [] ifaces, ArrayList abstract_methods, int total)
+		{
+			TypeBuilder type_builder = container.TypeBuilder;
+			
+			this.container = container;
+			pending_implementations = new TypeAndMethods [total];
+
+			int i = 0;
+			if (ifaces != null){
+				foreach (Type t in ifaces){
+					MethodInfo [] mi;
+					/*if (t is TypeBuilder){
+						Interface iface;
+
+						iface = TypeManager.LookupInterface (t);
+						
+						mi = iface.GetMethods (container);
+					} else*/
+					mi = t.GetMethods ();
+
+					int count = mi.Length;
+					pending_implementations [i].type = t;
+					pending_implementations [i].methods = mi;
+					pending_implementations [i].args = new Type [count][];
+					pending_implementations [i].found = new bool [count];
+					pending_implementations [i].need_proxy = new MethodInfo [count];
+
+					int j = 0;
+					foreach (MethodInfo m in mi){
+						Type [] types = TypeManager.GetArgumentTypes (m);
+
+						pending_implementations [i].args [j] = types;
+						j++;
+					}
+					i++;
+				}
+			}
+
+			if (abstract_methods != null){
+				int count = abstract_methods.Count;
+				pending_implementations [i].methods = new MethodInfo [count];
+				pending_implementations [i].need_proxy = new MethodInfo [count];
+				
+				abstract_methods.CopyTo (pending_implementations [i].methods, 0);
+				pending_implementations [i].found = new bool [count];
+				pending_implementations [i].args = new Type [count][];
+				pending_implementations [i].type = type_builder.BaseType;
+				
+				int j = 0;
+				foreach (MemberInfo m in abstract_methods){
+					MethodInfo mi = (MethodInfo) m;
+
+					Type [] types = TypeManager.GetArgumentTypes (mi);
+					
+					pending_implementations [i].args [j] = types;
+					j++;
+				}
+			}
+		}
+		
+		//
+		// Factory method: if there are pending implementation methods, we return a PendingImplementation
+		// object, otherwise we return null.
+		//
+		// Register method implementations are either abstract methods
+		// flagged as such on the base class or interface methods
+		//
+		static public PendingImplementation GetPendingImplementations (TypeContainer container)
+		{
+			TypeBuilder type_builder = container.TypeBuilder;
+			Type [] ifaces;
+			Type b = type_builder.BaseType;
+			int icount = 0;
+
+			//
+			// Notice that TypeBuilders will only return the interfaces that the Type
+			// is supposed to implement, not all the interfaces that the type implements.
+			//
+			// Completely broken.  Anyways, we take advantage of this, so we only register
+			// the implementations that we need, as they are those that are listed by the
+			// TypeBuilder.
+			//
+			ifaces = type_builder.GetInterfaces ();
+
+#if DEBUG
+			{
+				Type x = type_builder;
+
+				while (x != null){
+					Type [] iff = x.GetInterfaces ();
+					Console.WriteLine ("Type: " + x.Name);
+					
+					foreach (Type tt in iff){
+						Console.WriteLine ("  Iface: " + tt.Name);
+					}
+					x = x.BaseType;
+				}
+			}
+#endif
+
+            		
+			ifaces = TypeManager.ExpandInterfaces (ifaces);
+			icount = ifaces.Length;
+			//
+			// If we are implementing an abstract class, and we are not
+			// ourselves abstract, and there are abstract methods (C# allows
+			// abstract classes that have no abstract methods), then allocate
+			// one slot.
+			//
+			// We also pre-compute the methods.
+			//
+			bool implementing_abstract = ((b != null) && b.IsAbstract && !type_builder.IsAbstract);
+			ArrayList abstract_methods = null;
+
+			if (implementing_abstract){
+				abstract_methods = GetAbstractMethods (b);
+				
+				if (abstract_methods == null)
+					implementing_abstract = false;
+			}
+			
+			int total = icount +  (implementing_abstract ? 1 : 0);
+			if (total == 0)
+				return null;
+
+			return new PendingImplementation (container, ifaces, abstract_methods, total);
+		}
+
+		public enum Operation {
+			//
+			// If you change this, review the whole InterfaceMethod routine as there
+			// are a couple of assumptions on these three states
+			//
+			Lookup, ClearOne, ClearAll
+		}
+
+		/// <summary>
+		///   Whether the specified method is an interface method implementation
+		/// </summary>
+		public MethodInfo IsAbstractMethod (Type t, string name, Type ret_type, Type [] args)
+		{
+			return InterfaceMethod (t, name, ret_type, args, Operation.Lookup, null);
+		}
+
+		public MethodInfo IsAbstractIndexer (Type t, Type ret_type, Type [] args)
+		{
+			return InterfaceMethod (t, null, ret_type, args, Operation.Lookup, null);
+		}
+
+		public void ImplementMethod (Type t, string name, Type ret_type, Type [] args, bool clear_one) 
+		{
+			InterfaceMethod (t, name, ret_type, args,
+					 clear_one ? Operation.ClearOne : Operation.ClearAll, null);
+		}
+
+		public void ImplementIndexer (Type t, MethodInfo mi, Type ret_type, Type [] args, bool clear_one) 
+		{
+			InterfaceMethod (t, mi.Name, ret_type, args,
+					 clear_one ? Operation.ClearOne : Operation.ClearAll, mi);
+		}
+		
+		/// <remarks>
+		///   If a method in Type `t' (or null to look in all interfaces
+		///   and the base abstract class) with name `Name', return type `ret_type' and
+		///   arguments `args' implements an interface, this method will
+		///   return the MethodInfo that this method implements.
+		///
+		///   If `name' is null, we operate solely on the method's signature.  This is for
+		///   instance used when implementing indexers.
+		///
+		///   The `Operation op' controls whether to lookup, clear the pending bit, or clear
+		///   all the methods with the given signature.
+		///
+		///   The `MethodInfo need_proxy' is used when we're implementing an interface's
+		///   indexer in a class.  If the new indexer's DefaultPropName does not match the one
+		///   that was used in the interface, then we always need to create a proxy for it.
+		///
+		/// </remarks>
+		public MethodInfo InterfaceMethod (Type t, string name, Type ret_type, Type [] args,
+						   Operation op, MethodInfo need_proxy)
+		{
+			int arg_len = args.Length;
+
+			if (pending_implementations == null)
+				return null;
+
+			foreach (TypeAndMethods tm in pending_implementations){
+				if (!(t == null || tm.type == t))
+					continue;
+
+				int i = 0;
+				foreach (MethodInfo m in tm.methods){
+					if (m == null){
+						i++;
+						continue;
+					}
+
+					// `need_proxy' is not null when we're implementing an
+					// interface indexer and this is Clear(One/All) operation.
+					// If `name' is null, then we do a match solely based on the
+					// signature and not on the name (this is done in the Lookup
+					// for an interface indexer).
+					if ((name != null) && (need_proxy == null) && (name != m.Name)){
+						i++;
+						continue;
+					}
+
+					if (ret_type != m.ReturnType){
+						if (!((ret_type == null && m.ReturnType == TypeManager.void_type) ||
+						      (m.ReturnType == null && ret_type == TypeManager.void_type)))
+						{
+							i++;
+							continue;
+						}
+					}
+
+					//
+					// Check if we have the same parameters
+					//
+					if (tm.args [i].Length != arg_len){
+						i++;
+						continue;
+					}
+
+					int j, top = args.Length;
+					bool fail = false;
+					
+					for (j = 0; j < top; j++){
+						if (tm.args [i][j] != args[j]){
+							fail = true;
+							break;
+						}
+					}
+					if (fail){
+						i++;
+						continue;
+					}
+
+					if (op != Operation.Lookup){
+						// If `t != null', then this is an explicitly interface
+						// implementation and we can always clear the method.
+						// `need_proxy' is not null if we're implementing an
+						// interface indexer.  In this case, we need to create
+						// a proxy if the implementation's DefaultPropName doesn't
+						// match the DefaultPropName in the interface.
+						if ((t == null) && (need_proxy != null) && (name != m.Name))
+							tm.need_proxy [i] = need_proxy;
+						else
+							tm.methods [i] = null;
+					}
+					tm.found [i] = true;
+
+					//
+					// Lookups and ClearOne return
+					//
+					if (op != Operation.ClearAll)
+						return m;
+				}
+
+				// If a specific type was requested, we can stop now.
+				if (tm.type == t)
+					return null;
+			}
+			return null;
+		}
+
+		/// <summary>
+		///   C# allows this kind of scenarios:
+		///   interface I { void M (); }
+		///   class X { public void M (); }
+		///   class Y : X, I { }
+		///
+		///   For that case, we create an explicit implementation function
+		///   I.M in Y.
+		/// </summary>
+		void DefineProxy (Type iface, MethodInfo parent_method, MethodInfo iface_method,
+				  Type [] args)
+		{
+			MethodBuilder proxy;
+
+			string proxy_name = iface.Name + "." + iface_method.Name;
+
+			proxy = container.TypeBuilder.DefineMethod (
+				proxy_name,
+				MethodAttributes.HideBySig |
+				MethodAttributes.NewSlot |
+				MethodAttributes.Virtual,
+				CallingConventions.Standard | CallingConventions.HasThis,
+				parent_method.ReturnType, args);
+
+			int top = args.Length;
+			ILGenerator ig = proxy.GetILGenerator ();
+
+			ig.Emit (OpCodes.Ldarg_0);
+			for (int i = 0; i < top; i++){
+				switch (i){
+				case 0:
+					ig.Emit (OpCodes.Ldarg_1); break;
+				case 1:
+					ig.Emit (OpCodes.Ldarg_2); break;
+				case 2:
+					ig.Emit (OpCodes.Ldarg_3); break;
+				default:
+					ig.Emit (OpCodes.Ldarg, i - 1); break;
+				}
+			}
+			ig.Emit (OpCodes.Call, parent_method);
+			ig.Emit (OpCodes.Ret);
+
+			container.TypeBuilder.DefineMethodOverride (proxy, iface_method);
+		}
+		
+		static bool IsPropertyGetMethod (string m)
+		{
+			return (m.Substring (0, 4) == "get_");	
+		}
+
+		static bool IsPropertySetMethod (string m)
+		{
+			return (m.Substring (0, 4) == "set_");	
+		}
+
+		MethodInfo FindExplicitImplementation (string iface_name, string method_name)
+		{
+			if (container.Properties != null) {
+				foreach (Property p in container.Properties) 
+				{
+					if (p.Implements != null) {					
+						if (IsPropertyGetMethod (method_name) && (container.Namespace.Name +  "." + p.Implements.ToString() == iface_name + "." + method_name.Substring(4))) 
+								return p.PropertyBuilder.GetGetMethod(true);
+
+						if (IsPropertySetMethod (method_name) && (container.Namespace.Name +  "." + p.Implements.ToString() == iface_name + "." + method_name.Substring(4))) 
+								return p.PropertyBuilder.GetSetMethod(true);
+					}
+				}
+			}
+
+			if (container.Methods != null) 
+			{
+				foreach (Method m in container.Methods) 
+				{
+					if (m.Implements != null) 
+					{					
+						if (container.Namespace.Name +  "." + m.Implements.ToString() == iface_name + "." + method_name)
+							return (MethodInfo) m.MethodBuilder;
+					}
+				}
+			}
+			return null;
+		}
+
+		/// <summary>
+		///   This function tells whether one of our parent classes implements
+		///   the given method (which turns out, it is valid to have an interface
+		///   implementation in a parent
+		/// </summary>
+		bool ParentImplements (Type iface_type, MethodInfo mi)
+		{
+			MethodSignature ms;
+			MethodInfo mr;
+			
+			Type [] args = TypeManager.GetArgumentTypes (mi);
+
+			ms = new MethodSignature (mi.Name, mi.ReturnType, args);
+			MemberList list = TypeContainer.FindMembers (
+				container.TypeBuilder.BaseType, MemberTypes.Method | MemberTypes.Property,
+				BindingFlags.Public | BindingFlags.Instance,
+				MethodSignature.method_signature_filter, ms);
+
+			if (list.Count == 0) 
+			{
+				mr = FindExplicitImplementation (iface_type.ToString(), mi.Name);
+				if (mr == null)
+					return false;
+			}
+			else
+				mr = (MethodInfo) list[0];
+
+			DefineProxy (iface_type, mr, mi, args);
+			return true;						
+		}
+
+		/// <summary>
+		///   Verifies that any pending abstract methods or interface methods
+		///   were implemented.
+		/// </summary>
+		public bool VerifyPendingMethods ()
+		{
+			int top = pending_implementations.Length;
+			bool errors = false;
+			int i;
+			
+			for (i = 0; i < top; i++){
+				Type type = pending_implementations [i].type;
+				int j = 0;
+				
+				foreach (MethodInfo mi in pending_implementations [i].methods){
+					if (mi == null)
+						continue;
+
+					if (type.IsInterface){
+						MethodInfo need_proxy =
+							pending_implementations [i].need_proxy [j];
+
+						if (need_proxy != null) {
+							Type [] args = TypeManager.GetArgumentTypes (mi);
+							DefineProxy (type, need_proxy, mi, args);
+							continue;
+						}
+
+						if (ParentImplements (type, mi))
+							continue;
+
+						string extra = "";
+						
+						if (pending_implementations [i].found [j])
+							extra = ".  (method might be private or static)";
+						Report.Error (
+							536, container.Location,
+							"`" + container.Name + "' does not implement " +
+							"interface member `" +
+							type.FullName + "." + mi.Name + "'" + extra);
+					} else {
+						Report.Error (
+							30610, container.Location,
+							"`" + container.Name + "' does not implement " +
+							"inherited 'MustOverride' member `" +
+							type.FullName + "." + mi.Name + "'");
+					}
+					errors = true;
+					j++;
+				}
+			}
+			return errors;
+		}
+	} /* end of class */
+}
diff --git a/dead/mbas/report.cs b/dead/mbas/report.cs
new file mode 100644
index 00000000..64d4863c
--- /dev/null
+++ b/dead/mbas/report.cs
@@ -0,0 +1,373 @@
+//
+// report.cs: report errors and warnings.
+//
+// Author: Miguel de Icaza (miguel@ximian.com)
+//
+// (C) 2001 Ximian, Inc. (http://www.ximian.com)
+//
+
+//
+// FIXME: currently our class library does not support custom number format strings
+//
+using System;
+using System.Text;
+using System.Collections;
+using System.Diagnostics;
+
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///   This class is used to report errors and warnings t te user.
+	/// </summary>
+	public class Report {
+		/// <summary>  
+		///   Errors encountered so far
+		/// </summary>
+		static public int Errors;
+
+		/// <summary>  
+		///   Warnings encountered so far
+		/// </summary>
+		static public int Warnings;
+
+		/// <summary>  
+		///   Whether errors should be throw an exception
+		/// </summary>
+		static public bool Fatal;
+		
+		/// <summary>  
+		///   Whether warnings should be considered errors
+		/// </summary>
+		static public bool WarningsAreErrors;
+
+		/// <summary>  
+		///   Whether to dump a stack trace on errors. 
+		/// </summary>
+		static public bool Stacktrace;
+		
+		//
+		// If the 'expected' error code is reported then the
+                // compilation succeeds.
+		//
+		// Used for the test suite to excercise the error codes
+		//
+		static int expected_error = 0;
+
+		//
+		// Keeps track of the warnings that we are ignoring
+		//
+		static Hashtable warning_ignore_table;
+		
+		static public int ProcessResults(bool quiet)
+		{
+			if (!quiet)
+			{
+				if (Report.ExpectedError != 0)
+					Console.WriteLine("Failed to report expected Error " + Report.ExpectedError);
+					
+				if (Errors == 0) 
+				{
+					if (Warnings == 0) 
+						Console.WriteLine("Compilation succeeded");
+					else
+						Console.WriteLine("Compilation succeeded: {0} warning(s)", Warnings);
+				}
+				else
+					Console.WriteLine("Compilation failed: {0} Error(s), {1} warnings",	Errors, Warnings);
+			}
+			return (Errors == 0)?0:1;
+		}
+		
+		static void Check (int code)
+		{
+			if (code == expected_error)
+			{
+				if (Fatal)
+					throw new Exception ();
+				
+				Environment.Exit (0);
+			}
+		}
+		
+		static private void RealError (string msg)
+		{
+			Errors++;
+			Console.WriteLine (msg);
+
+			if (Stacktrace)
+				Console.WriteLine (new StackTrace ().ToString ());
+			if (Fatal)
+				throw new Exception (msg);
+		}
+
+		static public void Error (int code, Location l, string text)
+		{
+			string msg = String.Format (
+				"{0}({1},{2}) error BC{3:0000}: {4}", l.Name, l.Row, l.Col, code, text);
+			
+			RealError (msg);
+			Check (code);
+		}
+
+		static public void Warning (int code, Location l, string text)
+		{
+			if (warning_ignore_table != null){
+				if (warning_ignore_table.Contains (code))
+					return;
+			}
+			
+			if (WarningsAreErrors)
+				Error (code, l, text);
+			else {
+				if (Location.IsNull (l))
+					Console.WriteLine(String.Format("{0} warning BC{1:0000}: {2}",
+						l.Name, code, text));
+				else
+					Console.WriteLine(String.Format("{0}({1},{2}) warning BC{3:0000}: {4}",
+						l.Name, l.Row, l.Col, code, text));
+				Warnings++;
+				Check (code);
+
+				if (Stacktrace)
+					Console.WriteLine (new StackTrace ().ToString ());
+			}
+		}
+		
+		static public void Warning (int code, string text)
+		{
+			Warning (code, Location.Null, text);
+		}
+
+		static public void Warning (int code, int level, string text)
+		{
+			if (RootContext.WarningLevel >= level)
+				Warning (code, Location.Null, text);
+		}
+
+		static public void Warning (int code, int level, Location l, string text)
+		{
+			if (RootContext.WarningLevel >= level)
+				Warning (code, l, text);
+		}
+
+		static public void Error (int code, string text)
+		{
+			string msg = String.Format ("error BC{0:0000}: {1}", code, text);
+			
+			RealError (msg);
+			Check (code);
+		}
+
+		static public void Message (Message m)
+		{
+			if (m is ErrorMessage)
+				Error (m.code, m.text);
+			else
+				Warning (m.code, m.text);
+		}
+
+		static public void SetIgnoreWarning (int code)
+		{
+			if (warning_ignore_table == null)
+				warning_ignore_table = new Hashtable ();
+
+			warning_ignore_table [code] = true;
+		}
+		
+                static public int ExpectedError {
+                        set {
+                                expected_error = value;
+                        }
+                        get {
+                                return expected_error;
+                        }
+                }
+
+		public static int DebugFlags = 0;
+
+		[Conditional ("MCS_DEBUG")]
+		static public void Debug (string message, params object[] args)
+		{
+			Debug (4, message, args);
+		}
+			
+		[Conditional ("MCS_DEBUG")]
+		static public void Debug (int category, string message, params object[] args)
+		{
+			if ((category & DebugFlags) == 0)
+				return;
+
+			StringBuilder sb = new StringBuilder (message);
+
+			if ((args != null) && (args.Length > 0)) {
+				sb.Append (": ");
+
+				bool first = true;
+				foreach (object arg in args) {
+					if (first)
+						first = false;
+					else
+						sb.Append (",");
+					if (arg == null)
+						sb.Append ("null");
+					else if (arg is ICollection)
+						sb.Append (PrintCollection ((ICollection) arg));
+					else
+						sb.Append (arg);
+				}
+			}
+
+			Console.WriteLine (sb.ToString ());
+		}
+
+		static public string PrintCollection (ICollection collection)
+		{
+			StringBuilder sb = new StringBuilder ();
+
+			sb.Append (collection.GetType ());
+			sb.Append ("(");
+
+			bool first = true;
+			foreach (object o in collection) {
+				if (first)
+					first = false;
+				else
+					sb.Append (",");
+				sb.Append (o);
+			}
+
+			sb.Append (")");
+			return sb.ToString ();
+		}
+	}
+
+	public class Message {
+		public int code;
+		public string text;
+		
+		public Message (int code, string text)
+		{
+			this.code = code;
+			this.text = text;
+		}
+	}
+
+	public class WarningMessage : Message {
+		public WarningMessage (int code, string text) : base (code, text)
+		{
+		}
+	}
+
+	public class ErrorMessage : Message {
+		public ErrorMessage (int code, string text) : base (code, text)
+		{
+		}
+
+		//
+		// For compatibility reasons with old code.
+		//
+		public static void report_error (string error)
+		{
+			Console.Write ("ERROR: ");
+			Console.WriteLine (error);
+		}
+	}
+
+	public enum TimerType {
+		FindMembers	= 0,
+		TcFindMembers	= 1,
+		MemberLookup	= 2,
+		CachedLookup	= 3,
+		CacheInit	= 4,
+		MiscTimer	= 5,
+		CountTimers	= 6
+	}
+
+	public enum CounterType {
+		FindMembers	= 0,
+		MemberCache	= 1,
+		MiscCounter	= 2,
+		CountCounters	= 3
+	}
+
+	public class Timer
+	{
+		static DateTime[] timer_start;
+		static TimeSpan[] timers;
+		static long[] timer_counters;
+		static long[] counters;
+
+		static Timer ()
+		{
+			timer_start = new DateTime [(int) TimerType.CountTimers];
+			timers = new TimeSpan [(int) TimerType.CountTimers];
+			timer_counters = new long [(int) TimerType.CountTimers];
+			counters = new long [(int) CounterType.CountCounters];
+
+			for (int i = 0; i < (int) TimerType.CountTimers; i++) {
+				timer_start [i] = DateTime.Now;
+				timers [i] = TimeSpan.Zero;
+			}
+		}
+
+		[Conditional("TIMER")]
+		static public void IncrementCounter (CounterType which)
+		{
+			++counters [(int) which];
+		}
+
+		[Conditional("TIMER")]
+		static public void StartTimer (TimerType which)
+		{
+			timer_start [(int) which] = DateTime.Now;
+		}
+
+		[Conditional("TIMER")]
+		static public void StopTimer (TimerType which)
+		{
+			timers [(int) which] += DateTime.Now - timer_start [(int) which];
+			++timer_counters [(int) which];
+		}
+
+		[Conditional("TIMER")]
+		static public void ShowTimers ()
+		{
+			ShowTimer (TimerType.FindMembers, "- FindMembers timer");
+			ShowTimer (TimerType.TcFindMembers, "- TypeContainer.FindMembers timer");
+			ShowTimer (TimerType.MemberLookup, "- MemberLookup timer");
+			ShowTimer (TimerType.CachedLookup, "- CachedLookup timer");
+			ShowTimer (TimerType.CacheInit, "- Cache init");
+			ShowTimer (TimerType.MiscTimer, "- Misc timer");
+
+			ShowCounter (CounterType.FindMembers, "- Find members");
+			ShowCounter (CounterType.MemberCache, "- Member cache");
+			ShowCounter (CounterType.MiscCounter, "- Misc counter");
+		}
+
+		static public void ShowCounter (CounterType which, string msg)
+		{
+			Console.WriteLine ("{0} {1}", counters [(int) which], msg);
+		}
+
+		static public void ShowTimer (TimerType which, string msg)
+		{
+			Console.WriteLine (
+				"[{0:00}:{1:000}] {2} (used {3} times)",
+				(int) timers [(int) which].TotalSeconds,
+				timers [(int) which].Milliseconds, msg,
+				timer_counters [(int) which]);
+		}
+	}
+
+	public class InternalErrorException : Exception {
+		public InternalErrorException ()
+			: base ("Internal error")
+		{
+		}
+
+		public InternalErrorException (string message)
+			: base (message)
+		{
+		}
+	}
+}
diff --git a/dead/mbas/rootcontext.cs b/dead/mbas/rootcontext.cs
new file mode 100644
index 00000000..086973b5
--- /dev/null
+++ b/dead/mbas/rootcontext.cs
@@ -0,0 +1,826 @@
+//
+// rootcontext.cs: keeps track of our tree representation, and assemblies loaded.
+//
+// Author: Miguel de Icaza (miguel@ximian.com)
+//         Ravi Pratap     (ravi@ximian.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001 Ximian, Inc (http://www.ximian.com)
+
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Diagnostics;
+
+namespace Mono.MonoBASIC {
+
+	public class RootContext {
+
+		//
+		// Contains the parsed tree
+		//
+		static Tree tree;
+
+		//
+		// Tracks Imported namespaces
+		//
+		static SourceBeingCompiled sourceBeingCompiled = new SourceBeingCompiled();
+
+		//
+		// This hashtable contains all of the #definitions across the source code
+		// it is used by the ConditionalAttribute handler.
+		//
+		public static Hashtable AllDefines = new Hashtable ();
+		
+		//
+		// Whether we are being linked against the standard libraries.
+		// This is only used to tell whether `System.Object' should
+		// have a parent or not.
+		//
+		public static bool StdLib = true;
+
+		//
+		// This keeps track of the order in which classes were defined
+		// so that we can poulate them in that order.
+		//
+		// Order is important, because we need to be able to tell by
+		// examining the parent's list of methods which ones are virtual
+		// or abstract as well as the parent names (to implement new, 
+		// override).
+		//
+		static ArrayList type_container_resolve_order;
+		static ArrayList interface_resolve_order;
+		static ArrayList attribute_types;
+
+		//
+		// Holds a reference to the Private Implementation Details
+		// class.
+		//
+		static TypeBuilder impl_details_class;
+
+		public static int WarningLevel = 2;
+		
+		//
+		// Constructor
+		//
+		static RootContext ()
+		{
+			tree = new Tree ();
+			interface_resolve_order = new ArrayList ();
+			type_container_resolve_order = new ArrayList ();
+		}
+
+		static public Tree Tree {
+			get {
+				return tree;
+			}
+		}
+
+		static public string MainClass;
+		
+		public static void RegisterOrder (Interface iface)
+		{
+			interface_resolve_order.Add (iface);
+		}
+		
+		public static void RegisterOrder (TypeContainer tc)
+		{
+			type_container_resolve_order.Add (tc);
+		}
+
+		public static void RegisterAttribute (TypeContainer tc)
+		{
+			if (attribute_types == null)
+				attribute_types = new ArrayList ();
+			
+			attribute_types.Add (tc);
+		}
+		
+		public static void InitializeImports(ArrayList ImportsList)
+		{
+			sourceBeingCompiled.InitializeImports (ImportsList);
+		}
+
+		public static SourceBeingCompiled SourceBeingCompiled
+		{
+			get { return sourceBeingCompiled; }
+		}
+
+		public static void VerifyImports()
+		{
+			sourceBeingCompiled.VerifyImports();
+		}
+
+		// 
+		// The default compiler checked state
+		//
+		static public bool Checked = false;
+
+		//
+		// Whether to allow Unsafe code
+		//
+		static public bool Unsafe = false;
+		
+		// Root namespace name (implicit namespace)
+		static public string RootNamespace = "";
+		
+		static string MakeFQN (string nsn, string name)
+		{
+			string prefix = (nsn == "" ? "" : nsn + ".");
+
+			return prefix + name;
+		}
+		       
+		// <remarks>
+		//   This function is used to resolve the hierarchy tree.
+		//   It processes interfaces, structs and classes in that order.
+		//
+		//   It creates the TypeBuilder's as it processes the user defined
+		//   types.  
+		// </remarks>
+		static public void ResolveTree ()
+		{
+			//
+			// Process the attribute types separately and before anything else
+			//
+			if (attribute_types != null)
+				foreach (TypeContainer tc in attribute_types)
+					tc.DefineType ();
+			
+			//
+			// Interfaces are processed next, as classes and
+			// structs might inherit from an object or implement
+			// a set of interfaces, we need to be able to tell
+			// them appart by just using the TypeManager.
+			//
+			TypeContainer root = Tree.Types;
+
+			ArrayList ifaces = root.Interfaces;
+			if (ifaces != null){
+				foreach (Interface i in ifaces) 
+					i.DefineType ();
+			}
+
+			
+			foreach (TypeContainer tc in root.Types) 
+				tc.DefineType ();
+
+			if (root.Delegates != null)
+				foreach (Delegate d in root.Delegates) 
+					d.DefineType ();
+
+			if (root.Enums != null)
+				foreach (Enum e in root.Enums)
+					e.DefineType ();
+			
+		}
+
+		static void Error_TypeConflict (string name, Location loc)
+		{
+			Report.Error (
+				520, loc, "`" + name + "' conflicts with a predefined type");
+		}
+
+		static void Error_TypeConflict (string name)
+		{
+			Report.Error (
+				520, "`" + name + "' conflicts with a predefined type");
+		}
+
+		//
+		// Resolves a single class during the corlib bootstrap process
+		//
+		static TypeBuilder BootstrapCorlib_ResolveClass (TypeContainer root, string name)
+		{
+			object o = root.GetDefinition (name);
+			if (o == null){
+				Report.Error (518, "The predefined type `" + name + "' is not defined");
+				return null;
+			}
+
+			if (!(o is Class)){
+				if (o is DeclSpace){
+					DeclSpace d = (DeclSpace) o;
+
+					Error_TypeConflict (name, d.Location);
+				} else
+					Error_TypeConflict (name);
+
+				return null;
+			}
+
+			return ((DeclSpace) o).DefineType ();
+		}
+
+		//
+		// Resolves a struct during the corlib bootstrap process
+		//
+		static void BootstrapCorlib_ResolveStruct (TypeContainer root, string name)
+		{
+			object o = root.GetDefinition (name);
+			if (o == null){
+				Report.Error (518, "The predefined type `" + name + "' is not defined");
+				return;
+			}
+
+			if (!(o is Struct)){
+				if (o is DeclSpace){
+					DeclSpace d = (DeclSpace) o;
+
+					Error_TypeConflict (name, d.Location);
+				} else
+					Error_TypeConflict (name);
+
+				return;
+			}
+
+			((DeclSpace) o).DefineType ();
+		}
+
+		//
+		// Resolves a struct during the corlib bootstrap process
+		//
+		static void BootstrapCorlib_ResolveInterface (TypeContainer root, string name)
+		{
+			object o = root.GetDefinition (name);
+			if (o == null){
+				Report.Error (518, "The predefined type `" + name + "' is not defined");
+				return;
+			}
+
+			if (!(o is Interface)){
+				if (o is DeclSpace){
+					DeclSpace d = (DeclSpace) o;
+
+					Error_TypeConflict (name, d.Location);
+				} else
+					Error_TypeConflict (name);
+
+				return;
+			}
+
+			((DeclSpace) o).DefineType ();
+		}
+
+		//
+		// Resolves a delegate during the corlib bootstrap process
+		//
+		static void BootstrapCorlib_ResolveDelegate (TypeContainer root, string name)
+		{
+			object o = root.GetDefinition (name);
+			if (o == null){
+				Report.Error (518, "The predefined type `" + name + "' is not defined");
+				Environment.Exit (0);
+			}
+
+			if (!(o is Delegate)){
+				Error_TypeConflict (name);
+				return;
+			}
+
+			((DeclSpace) o).DefineType ();
+		}
+		
+
+		/// <summary>
+		///    Resolves the core types in the compiler when compiling with --nostdlib
+		/// </summary>
+		static public void ResolveCore ()
+		{
+			TypeContainer root = Tree.Types;
+
+			TypeManager.object_type = BootstrapCorlib_ResolveClass (root, "System.Object");
+			TypeManager.value_type = BootstrapCorlib_ResolveClass (root, "System.ValueType");
+			TypeManager.attribute_type = BootstrapCorlib_ResolveClass (root, "System.Attribute");
+			
+			string [] interfaces_first_stage = {
+				"System.IComparable", "System.ICloneable",
+				"System.IConvertible",
+				
+				"System.Collections.IEnumerable",
+				"System.Collections.ICollection",
+				"System.Collections.IEnumerator",
+				"System.Collections.IList", 
+				"System.IAsyncResult",
+				"System.IDisposable",
+				
+				"System.Runtime.Serialization.ISerializable",
+
+				"System.Reflection.IReflect",
+				"System.Reflection.ICustomAttributeProvider"
+			};
+
+			foreach (string iname in interfaces_first_stage)
+				BootstrapCorlib_ResolveInterface (root, iname);
+
+			//
+			// These are the base value types
+			//
+			string [] structs_first_stage = {
+				"System.Byte",    "System.SByte",
+				"System.Int16",   "System.UInt16",
+				"System.Int32",   "System.UInt32",
+				"System.Int64",   "System.UInt64",
+			};
+
+			foreach (string cname in structs_first_stage)
+				BootstrapCorlib_ResolveStruct (root, cname);
+
+			//
+			// Now, we can load the enumerations, after this point,
+			// we can use enums.
+			//
+			TypeManager.InitEnumUnderlyingTypes ();
+
+			string [] structs_second_stage = {
+				"System.Single",  "System.Double",
+				"System.Char",    "System.Boolean",
+				"System.Decimal", "System.Void",
+				"System.RuntimeFieldHandle",
+				"System.RuntimeTypeHandle",
+				"System.IntPtr"
+			};
+			
+			foreach (string cname in structs_second_stage)
+				BootstrapCorlib_ResolveStruct (root, cname);
+			
+			//
+			// These are classes that depends on the core interfaces
+			//
+			string [] classes_second_stage = {
+				"System.Reflection.MemberInfo",
+				"System.Type",
+				"System.Exception",
+
+				//
+				// These are not really important in the order, but they
+				// are used by the compiler later on (typemanager/CoreLookupType-d)
+				//
+				"System.Runtime.CompilerServices.RuntimeHelpers",
+				"System.Reflection.DefaultMemberAttribute",
+				"System.Threading.Monitor",
+				
+				"System.AttributeUsageAttribute",
+				"System.Runtime.InteropServices.DllImportAttribute",
+				"System.Runtime.CompilerServices.MethodImplAttribute",
+				"System.Runtime.InteropServices.MarshalAsAttribute",
+				"System.Diagnostics.ConditionalAttribute",
+				"System.ObsoleteAttribute",
+				"System.ParamArrayAttribute",
+				"System.Security.UnverifiableCodeAttribute",
+				"System.Runtime.CompilerServices.IndexerNameAttribute",
+			};
+
+			// We must store them here before calling BootstrapCorlib_ResolveDelegate.
+			TypeManager.string_type = BootstrapCorlib_ResolveClass (root, "System.String");
+			TypeManager.enum_type = BootstrapCorlib_ResolveClass (root, "System.Enum");
+			TypeManager.array_type = BootstrapCorlib_ResolveClass (root, "System.Array");
+			TypeManager.multicast_delegate_type = BootstrapCorlib_ResolveClass (root, "System.MulticastDelegate");
+			TypeManager.delegate_type = BootstrapCorlib_ResolveClass (root, "System.Delegate");
+			
+			foreach (string cname in classes_second_stage)
+				BootstrapCorlib_ResolveClass (root, cname);
+
+			BootstrapCorlib_ResolveDelegate (root, "System.AsyncCallback");
+		}
+			
+		// <summary>
+		//   Closes all open types
+		// </summary>
+		//
+		// <remarks>
+		//   We usually use TypeBuilder types.  When we are done
+		//   creating the type (which will happen after we have added
+		//   methods, fields, etc) we need to "Define" them before we
+		//   can save the Assembly
+		// </remarks>
+		static public void CloseTypes ()
+		{
+			TypeContainer root = Tree.Types;
+			
+			//ArrayList ifaces = root.Interfaces;
+
+			if (root.Enums != null)
+				foreach (Enum en in root.Enums)
+					en.CloseType ();
+
+			if (attribute_types != null)
+				foreach (TypeContainer tc in attribute_types)
+					tc.CloseType ();
+			
+			foreach (Interface iface in interface_resolve_order)
+				iface.CloseType ();
+
+			//
+			// We do this in two passes, first we close the structs,
+			// then the classes, because it seems the code needs it this
+			// way.  If this is really what is going on, we should probably
+			// make sure that we define the structs in order as well.
+			//
+			foreach (TypeContainer tc in type_container_resolve_order){
+				if (tc is Struct && tc.Parent == tree.Types){
+					tc.CloseType ();
+				}
+			}
+
+			foreach (TypeContainer tc in type_container_resolve_order){
+				if (!(tc is Struct && tc.Parent == tree.Types))
+					tc.CloseType ();					
+			}
+			
+			if (root.Delegates != null)
+				foreach (Delegate d in root.Delegates)
+					d.CloseType ();
+
+
+			//
+			// If we have a <PrivateImplementationDetails> class, close it
+			//
+			if (impl_details_class != null){
+				impl_details_class.CreateType ();
+			}
+		}
+
+		//
+		// This idea is from Felix Arrese-Igor
+		//
+		// Returns : the implicit parent of a composite namespace string
+		//   eg. Implicit parent of A.B is A
+		//
+		static public string ImplicitParent (string ns)
+		{
+			int i = ns.LastIndexOf (".");
+			if (i < 0)
+				return null;
+			
+			return ns.Substring (0, i);
+		}
+
+		static Type NamespaceLookup (Namespace curr_ns, string name, Location loc)
+		{
+			Type t;
+			
+			//
+			// Try in the current namespace and all its implicit parents
+			//
+			for (string ns = curr_ns.Name; ns != null; ns = ImplicitParent (ns)) {
+				t = TypeManager.LookupType (MakeFQN (ns, name));
+				if (t != null)
+					return t;
+			}
+			
+			//
+			// It's possible that name already is fully qualified. So we do
+			// a simple direct lookup without adding any namespace names
+			//
+			t = TypeManager.LookupType (name); 
+			if (t != null)
+				return t;
+
+			//
+			// Try the aliases in the current namespace
+			//
+			string alias = sourceBeingCompiled.LookupAlias (name);
+
+			if (alias != null) {
+				t = TypeManager.LookupType (alias);
+				if (t != null)
+					return t;
+
+				t = TypeManager.LookupType (MakeFQN (alias, name));
+				if (t != null)
+					return t;
+			}
+			
+			for (Namespace ns = curr_ns; ns != null; ns = ns.Parent) {
+				//
+				// Look in the namespace ns
+				//
+				t = TypeManager.LookupType (MakeFQN (ns.Name, name));
+				if (t != null)
+					return t;
+				
+				//
+				// Then try with the using clauses
+				//
+
+				ICollection imports_list = sourceBeingCompiled.ImportsTable;
+
+				if (imports_list == null)
+					continue;
+
+				Type match = null;
+				foreach (SourceBeingCompiled.ImportsEntry ue in imports_list) {
+				//TODO: deal with standard modules
+					match = TypeManager.LookupType (MakeFQN (ue.Name, name));
+					if (match != null){
+						if (t != null){
+							DeclSpace.Error_AmbiguousTypeReference (loc, name, t, match);
+							return null;
+						}
+						
+						t = match;
+						ue.Used = true;
+					}
+				}
+				if (t != null)
+					return t;
+
+				//
+				// Try with aliases
+				//
+				string a = sourceBeingCompiled.LookupAlias (name);
+				if (a != null) {
+					t = TypeManager.LookupType (a);
+					if (t != null)
+						return t;
+
+					t = TypeManager.LookupType (MakeFQN (a, name));
+					if (t != null)
+						return t;
+				}
+			}
+
+			return null;
+		}
+		
+		//
+		// Public function used to locate types, this can only
+		// be used after the ResolveTree function has been invoked.
+		//
+		// Returns: Type or null if they type can not be found.
+		//
+		// Come to think of it, this should be a DeclSpace
+		//
+		static public Type LookupType (DeclSpace ds, string name, bool silent, Location loc)
+		{
+			Type t;
+
+			if (ds.Cache.Contains (name)){
+				t = (Type) ds.Cache [name];
+				if (t != null)
+					return t;
+			} else {
+				//
+				// For the case the type we are looking for is nested within this one
+				// or is in any base class
+				//
+				DeclSpace containing_ds = ds;
+				while (containing_ds != null){
+					Type current_type = containing_ds.TypeBuilder;
+					
+					while (current_type != null) {
+						//
+						// nested class
+						//
+						t = TypeManager.LookupType (current_type.FullName + "." + name);
+						if (t != null){
+							ds.Cache [name] = t;
+							return t;
+						}
+						
+						current_type = current_type.BaseType;
+					}
+					
+					containing_ds = containing_ds.Parent;
+				}
+				
+				t = NamespaceLookup (ds.Namespace, name, loc);
+				if (t != null){
+					ds.Cache [name] = t;
+					return t;
+				}
+			}
+
+			if (!silent)
+				Report.Error (30002, loc, "Cannot find type `"+name+"'");
+			
+			return null;
+		}
+
+		// <summary>
+		//   This is the silent version of LookupType, you can use this
+		//   to `probe' for a type
+		// </summary>
+		static public Type LookupType (TypeContainer tc, string name, Location loc)
+		{
+			return LookupType (tc, name, true, loc);
+		}
+
+		static public bool IsNamespace (string name)
+		{
+			Namespace ns;
+
+			if (tree.Namespaces != null){
+				ns = (Namespace) tree.Namespaces [name];
+
+				if (ns != null)
+					return true;
+			}
+
+			return false;
+		}
+
+		static void Report1530 (Location loc)
+		{
+			Report.Error (1530, loc, "Keyword new not allowed for namespace elements");
+		}
+		
+		static public void PopulateCoreType (TypeContainer root, string name)
+		{
+			DeclSpace ds = (DeclSpace) root.GetDefinition (name);
+
+			ds.DefineMembers (root);
+			ds.Define (root);
+		}
+		
+		static public void BootCorlib_PopulateCoreTypes ()
+		{
+			TypeContainer root = tree.Types;
+
+			PopulateCoreType (root, "System.Object");
+			PopulateCoreType (root, "System.ValueType");
+			PopulateCoreType (root, "System.Attribute");
+		}
+		
+		// <summary>
+		//   Populates the structs and classes with fields and methods
+		// </summary>
+		//
+		// This is invoked after all interfaces, structs and classes
+		// have been defined through `ResolveTree' 
+		static public void PopulateTypes ()
+		{
+			TypeContainer root = Tree.Types;
+
+			if (attribute_types != null)
+				foreach (TypeContainer tc in attribute_types)
+					tc.DefineMembers (root);
+			
+			if (interface_resolve_order != null){
+				foreach (Interface iface in interface_resolve_order)
+					if ((iface.ModFlags & Modifiers.NEW) == 0)
+						iface.DefineMembers (root);
+					else
+						Report1530 (iface.Location);
+			}
+
+
+			if (type_container_resolve_order != null){
+				foreach (TypeContainer tc in type_container_resolve_order) {
+					// When compiling corlib, these types have already been
+					// populated from BootCorlib_PopulateCoreTypes ().
+					if (!RootContext.StdLib &&
+					    ((tc.Name == "System.Object") ||
+					     (tc.Name == "System.Attribute") ||
+					     (tc.Name == "System.ValueType")))
+						continue;
+
+					if ((tc.ModFlags & Modifiers.NEW) == 0)
+						tc.DefineMembers (root);
+					else
+						Report1530 (tc.Location);
+				}
+			}
+
+			ArrayList delegates = root.Delegates;
+			if (delegates != null){
+				foreach (Delegate d in delegates)
+					if ((d.ModFlags & Modifiers.NEW) == 0)
+						d.DefineMembers (root);
+					else
+						Report1530 (d.Location);
+			}
+
+			ArrayList enums = root.Enums;
+			if (enums != null){
+				foreach (Enum en in enums)
+					if ((en.ModFlags & Modifiers.NEW) == 0)
+						en.DefineMembers (root);
+					else
+						Report1530 (en.Location);
+			}
+		}
+
+		static public void DefineTypes ()
+		{
+			TypeContainer root = Tree.Types;
+
+			if (attribute_types != null)
+				foreach (TypeContainer tc in attribute_types)
+					tc.Define (root);
+			
+			if (interface_resolve_order != null){
+				foreach (Interface iface in interface_resolve_order)
+					if ((iface.ModFlags & Modifiers.NEW) == 0)
+						iface.Define (root);
+			}
+
+
+			if (type_container_resolve_order != null){
+				foreach (TypeContainer tc in type_container_resolve_order) {
+					// When compiling corlib, these types have already been
+					// populated from BootCorlib_PopulateCoreTypes ().
+					if (!RootContext.StdLib &&
+					    ((tc.Name == "System.Object") ||
+					     (tc.Name == "System.Attribute") ||
+					     (tc.Name == "System.ValueType")))
+						continue;
+
+					if ((tc.ModFlags & Modifiers.NEW) == 0)
+						tc.Define (root);
+				}
+			}
+
+			ArrayList delegates = root.Delegates;
+			if (delegates != null){
+				foreach (Delegate d in delegates)
+					if ((d.ModFlags & Modifiers.NEW) == 0)
+						d.Define (root);
+			}
+
+			ArrayList enums = root.Enums;
+			if (enums != null){
+				foreach (Enum en in enums)
+					if ((en.ModFlags & Modifiers.NEW) == 0)
+						en.Define (root);
+			}
+		}
+
+		static public void EmitCode ()
+		{
+			if (attribute_types != null)
+				foreach (TypeContainer tc in attribute_types)
+					tc.Emit ();
+
+			CodeGen.EmitGlobalAttributes ();
+			
+			if (type_container_resolve_order != null) {
+				foreach (TypeContainer tc in type_container_resolve_order)
+					tc.EmitConstants ();
+				
+				foreach (TypeContainer tc in type_container_resolve_order)
+					tc.Emit ();
+			}
+			
+			if (Unsafe) {
+				if (TypeManager.unverifiable_code_ctor == null) {
+					Console.WriteLine ("Internal error ! Cannot set unverifiable code attribute.");
+					return;
+				}
+				
+				CustomAttributeBuilder cb = new CustomAttributeBuilder (TypeManager.unverifiable_code_ctor, new object [0]);
+				CodeGen.ModuleBuilder.SetCustomAttribute (cb);
+			}
+		}
+		
+		//
+		// Public Field, used to track which method is the public entry
+		// point.
+		//
+		static public MethodInfo EntryPoint;
+
+                //
+                // Track the location of the entry point.
+                //
+                static public Location EntryPointLocation;
+
+		//
+		// These are used to generate unique names on the structs and fields.
+		//
+		static int field_count;
+		
+		//
+		// Makes an initialized struct, returns the field builder that
+		// references the data.  Thanks go to Sergey Chaban for researching
+		// how to do this.  And coming up with a shorter mechanism than I
+		// was able to figure out.
+		//
+		// This works but makes an implicit public struct $ArrayType$SIZE and
+		// makes the fields point to it.  We could get more control if we did
+		// use instead:
+		//
+		// 1. DefineNestedType on the impl_details_class with our struct.
+		//
+		// 2. Define the field on the impl_details_class
+		//
+		static public FieldBuilder MakeStaticData (byte [] data)
+		{
+			FieldBuilder fb;
+			//int size = data.Length;
+			
+			if (impl_details_class == null)
+				impl_details_class = CodeGen.ModuleBuilder.DefineType (
+					"<PrivateImplementationDetails>", TypeAttributes.NotPublic, TypeManager.object_type);
+
+			fb = impl_details_class.DefineInitializedData (
+				"$$field-" + (field_count++), data,
+				FieldAttributes.Static | FieldAttributes.Assembly);
+			
+			return fb;
+		}
+
+	}
+}
diff --git a/dead/mbas/sourcebeingcompiled.cs b/dead/mbas/sourcebeingcompiled.cs
new file mode 100644
index 00000000..5e324191
--- /dev/null
+++ b/dead/mbas/sourcebeingcompiled.cs
@@ -0,0 +1,144 @@
+//
+// sourcebeingcompiled.cs: Tracks once-per-source things 
+//
+// Author:
+//   Rafael Teixeira (rafaelteixeirabr@hotmail.com)
+//
+// (C) 2004 Rafael Teixeira.
+//
+
+using System;
+using System.Collections;
+using Mono.Languages;
+
+namespace Mono.MonoBASIC {
+
+	/// <summary>
+	///   Keeps track of the once-per-source things in the VB.NET code.
+	/// </summary>
+	public class SourceBeingCompiled {
+
+		Hashtable imports_clauses;
+		Hashtable aliases;
+		
+		//
+		// This class holds the location where a using definition is
+		// done, and whether it has been used by the program or not.
+		//
+		// We use this to flag using clauses for namespaces that do not
+		// exist.
+		//
+		public class ImportsEntry {
+			public string Name;
+			public bool Used;
+			public Location Location;
+			
+			public ImportsEntry (string name, Location loc)
+			{
+				Name = name;
+				Location = loc;
+				Used = false;
+			}
+		}
+		
+		public SourceBeingCompiled () { } 
+
+		/// <summary>
+		///   Initializes the list of preimported namespaces
+		/// </summary>
+		public void InitializeImports (ArrayList ImportsList)
+		{
+			foreach(string preImportedNamespace in ImportsList)
+				this.Imports(preImportedNamespace, Location.Null);
+		}
+
+		/// <summary>
+		///   Records a new namespace for resolving name references
+		/// </summary>
+		public void Imports (string ns, Location loc)
+		{
+			if (imports_clauses == null)
+				imports_clauses = new CaseInsensitiveHashtable ();
+
+			ImportsEntry ue = new ImportsEntry (ns, loc);
+			imports_clauses [ns] = ue;
+		}
+
+		public ICollection ImportsTable {
+			get {
+				return imports_clauses.Values;
+			}
+		}
+		
+		public string[] GetNamespacesInScope(string currentNamespace)
+		{
+			ArrayList list = new ArrayList();
+			foreach(ImportsEntry ie in ImportsTable)
+				list.Add(ie.Name);
+			list.Add(currentNamespace);
+			return (string[])list.ToArray(typeof(string));
+			
+		}
+
+		public void ImportsWithAlias (string alias, string namespace_or_type, Location loc)
+		{
+			if (aliases == null)
+				aliases = new CaseInsensitiveHashtable ();
+			
+			if (aliases.Contains (alias)){
+				Report.Error (1537, loc, "The Imports clause with alias '" + alias +
+					      "' appeared previously in this namespace");
+				return;
+			}
+					
+			aliases [alias] = namespace_or_type;
+		}
+
+		public string LookupAlias (string alias)
+		{
+			string value = null;
+
+			if (aliases != null)
+				value = (string) (aliases [alias]);
+
+			return value;
+		}
+
+		/// <summary>
+		///   Used to validate that all the using clauses are correct
+		///   after we are finished parsing all the files.  
+		/// </summary>
+		public void VerifyImports ()
+		{
+			ArrayList unused = new ArrayList ();
+			
+			foreach (ImportsEntry ue in ImportsTable) {
+				if (ue.Used)
+					continue;
+				unused.Add (ue);
+			}
+
+			//
+			// If we have unused imports aliases, load all namespaces and check
+			// whether it is unused, or it was missing
+			//
+/* FIXME: why is happening a ghostly NullReferenceException inside TypeManager.GetNamespaces ()?
+
+			if (unused.Count > 0) {
+				CaseInsensitiveHashtable namespaces = TypeManager.GetNamespaces ();
+
+				foreach (ImportsEntry ue in unused) {
+					if (namespaces.Contains (ue.Name)){
+						Report.Warning (6024, ue.Location, "Unused namespace in 'Imports' declaration");
+						continue;
+					}
+
+					Report.Error (246, ue.Location, "The namespace '" + ue.Name +
+						      "' can not be found (missing assembly reference?)");
+				}
+			}
+*/
+		}
+
+	}
+}
diff --git a/dead/mbas/statement.cs b/dead/mbas/statement.cs
new file mode 100644
index 00000000..0914861a
--- /dev/null
+++ b/dead/mbas/statement.cs
@@ -0,0 +1,5869 @@
+//
+// statement.cs: Statement representation for the IL tree.
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//   Martin Baulig (martin@gnome.org)
+//	 Anirban Bhattacharjee (banirban@novell.com)
+//   Manjula GHM (mmanjula@novell.com)
+//   Satya Sudha K (ksathyasudha@novell.com)
+//
+// (C) 2001, 2002 Ximian, Inc.
+//
+
+using System;
+using System.Text;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Diagnostics;
+
+namespace Mono.MonoBASIC {
+
+	using System.Collections;
+	
+	public abstract class Statement {
+		public Location loc;
+		
+		///
+		/// Resolves the statement, true means that all sub-statements
+		/// did resolve ok.
+		//
+		public virtual bool Resolve (EmitContext ec)
+		{
+			return true;
+		}
+		
+		/// <summary>
+		///   Return value indicates whether all code paths emitted return.
+		/// </summary>
+		protected abstract bool DoEmit (EmitContext ec);
+
+		/// <summary>
+		///   Return value indicates whether all code paths emitted return.
+		/// </summary>
+		public virtual bool Emit (EmitContext ec)
+		{
+			ec.Mark (loc);
+			Report.Debug (8, "MARK", this, loc);
+			return DoEmit (ec);
+		}
+		
+		public static Expression ResolveBoolean (EmitContext ec, Expression e, Location loc)
+		{
+			e = e.Resolve (ec);
+			if (e == null)
+				return null;
+			
+			if (e.Type != TypeManager.bool_type){
+				e = Expression.ConvertImplicit (ec, e, TypeManager.bool_type, Location.Null);
+			}
+
+			if (e == null){
+				Report.Error (
+					30311, loc, "Can not convert the expression to a boolean");
+			}
+
+			ec.Mark (loc);
+
+			return e;
+		}
+		
+		/// <remarks>
+		///    Encapsulates the emission of a boolean test and jumping to a
+		///    destination.
+		///
+		///    This will emit the bool expression in 'bool_expr' and if
+		///    'target_is_for_true' is true, then the code will generate a 
+		///    brtrue to the target.   Otherwise a brfalse. 
+		/// </remarks>
+		public static void EmitBoolExpression (EmitContext ec, Expression bool_expr,
+						       Label target, bool target_is_for_true)
+		{
+			ILGenerator ig = ec.ig;
+			
+			bool invert = false;
+			if (bool_expr is Unary){
+				Unary u = (Unary) bool_expr;
+				
+				if (u.Oper == Unary.Operator.LogicalNot){
+					invert = true;
+
+					u.EmitLogicalNot (ec);
+				}
+			} else if (bool_expr is Binary){
+				Binary b = (Binary) bool_expr;
+
+				if (b.EmitBranchable (ec, target, target_is_for_true))
+					return;
+			}
+
+			if (!invert)
+				bool_expr.Emit (ec);
+
+			if (target_is_for_true){
+				if (invert)
+					ig.Emit (OpCodes.Brfalse, target);
+				else
+					ig.Emit (OpCodes.Brtrue, target);
+			} else {
+				if (invert)
+					ig.Emit (OpCodes.Brtrue, target);
+				else
+					ig.Emit (OpCodes.Brfalse, target);
+			}
+		}
+
+		public static void Warning_DeadCodeFound (Location loc)
+		{
+			Report.Warning (162, loc, "Unreachable code detected");
+		}
+	}
+
+	public class EmptyStatement : Statement {
+		public override bool Resolve (EmitContext ec)
+		{
+			return true;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			return false;
+		}
+	}
+	
+	public class If : Statement {
+		Expression expr;
+		public Statement TrueStatement;
+		public Statement FalseStatement;
+		
+		public If (Expression expr, Statement trueStatement, Location l)
+		{
+			this.expr = expr;
+			TrueStatement = trueStatement;
+			loc = l;
+		}
+
+		public If (Expression expr,
+			   Statement trueStatement,
+			   Statement falseStatement,
+			   Location l)
+		{
+			this.expr = expr;
+			TrueStatement = trueStatement;
+			FalseStatement = falseStatement;
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			Report.Debug (1, "START IF BLOCK", loc);
+
+			expr = ResolveBoolean (ec, expr, loc);
+			if (expr == null){
+				return false;
+			}
+			
+			ec.StartFlowBranching (FlowBranchingType.BLOCK, loc);
+			
+			if (!TrueStatement.Resolve (ec)) {
+				ec.KillFlowBranching ();
+				return false;
+			}
+
+			ec.CurrentBranching.CreateSibling ();
+
+			if ((FalseStatement != null) && !FalseStatement.Resolve (ec)) {
+				ec.KillFlowBranching ();
+				return false;
+			}
+					
+			ec.EndFlowBranching ();
+
+			Report.Debug (1, "END IF BLOCK", loc);
+
+			return true;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			Label false_target = ig.DefineLabel ();
+			Label end;
+			bool is_true_ret, is_false_ret;
+
+			//
+			// Dead code elimination
+			//
+			if (expr is BoolConstant){
+				bool take = ((BoolConstant) expr).Value;
+
+				if (take){
+					if (FalseStatement != null){
+						Warning_DeadCodeFound (FalseStatement.loc);
+					}
+					return TrueStatement.Emit (ec);
+				} else {
+					Warning_DeadCodeFound (TrueStatement.loc);
+					if (FalseStatement != null)
+						return FalseStatement.Emit (ec);
+				}
+			}
+			
+			EmitBoolExpression (ec, expr, false_target, false);
+
+			is_true_ret = TrueStatement.Emit (ec);
+			is_false_ret = is_true_ret;
+
+			if (FalseStatement != null){
+				bool branch_emitted = false;
+				
+				end = ig.DefineLabel ();
+				if (!is_true_ret){
+					ig.Emit (OpCodes.Br, end);
+					branch_emitted = true;
+				}
+
+				ig.MarkLabel (false_target);
+				is_false_ret = FalseStatement.Emit (ec);
+
+				if (branch_emitted)
+					ig.MarkLabel (end);
+			} else {
+				ig.MarkLabel (false_target);
+				is_false_ret = false;
+			}
+
+			return is_true_ret && is_false_ret;
+		}
+	}
+
+	public enum DoOptions {
+		WHILE,
+		UNTIL,
+		TEST_BEFORE,
+		TEST_AFTER
+	};
+
+	public class Do : Statement {
+		public Expression expr;
+		public readonly Statement  EmbeddedStatement;
+		//public DoOptions type;
+		public DoOptions test;
+		bool infinite, may_return;
+
+		
+		public Do (Statement statement, Expression boolExpr, DoOptions do_test, Location l)
+		{
+			expr = boolExpr;
+			EmbeddedStatement = statement;
+//			type = do_type;
+			test = do_test;
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			bool ok = true;
+
+			ec.StartFlowBranching (FlowBranchingType.LOOP_BLOCK, loc);
+
+			if (!EmbeddedStatement.Resolve (ec))
+				ok = false;
+
+			expr = ResolveBoolean (ec, expr, loc);
+			if (expr == null)
+				ok = false;
+			else if (expr is BoolConstant){
+				bool res = ((BoolConstant) expr).Value;
+
+				if (res)
+					infinite = true;
+			}
+
+			ec.CurrentBranching.Infinite = infinite;
+			FlowReturns returns = ec.EndFlowBranching ();
+			may_return = returns != FlowReturns.NEVER;
+
+			return ok;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			Label loop = ig.DefineLabel ();
+			Label old_begin = ec.LoopBegin;
+			Label old_end = ec.LoopEnd;
+			bool  old_inloop = ec.InLoop;
+			int old_loop_begin_try_catch_level = ec.LoopBeginTryCatchLevel;
+			
+			ec.LoopBegin = ig.DefineLabel ();
+			ec.LoopEnd = ig.DefineLabel ();
+			ec.InLoop = true;
+			ec.LoopBeginTryCatchLevel = ec.TryCatchLevel;
+
+			if (test == DoOptions.TEST_AFTER) {
+				ig.MarkLabel (loop);
+				EmbeddedStatement.Emit (ec);
+				ig.MarkLabel (ec.LoopBegin);
+
+				//
+				// Dead code elimination
+				//
+				if (expr is BoolConstant){
+					bool res = ((BoolConstant) expr).Value;
+
+					if (res)
+						ec.ig.Emit (OpCodes.Br, loop);
+				} else
+					EmitBoolExpression (ec, expr, loop, true);
+
+				ig.MarkLabel (ec.LoopEnd);
+			}
+			else
+			{
+				ig.MarkLabel (loop);
+				ig.MarkLabel (ec.LoopBegin);
+
+				//
+				// Dead code elimination
+				//
+				if (expr is BoolConstant){
+					bool res = ((BoolConstant) expr).Value;
+
+					if (res)
+						ec.ig.Emit (OpCodes.Br, ec.LoopEnd);
+				} else
+					EmitBoolExpression (ec, expr, ec.LoopEnd, true);
+
+				EmbeddedStatement.Emit (ec);
+				ec.ig.Emit (OpCodes.Br, loop);
+				ig.MarkLabel (ec.LoopEnd);
+			}
+			ec.LoopBeginTryCatchLevel = old_loop_begin_try_catch_level;
+			ec.LoopBegin = old_begin;
+			ec.LoopEnd = old_end;
+			ec.InLoop = old_inloop;
+
+			if (infinite)
+				return may_return == false;
+			else
+				return false;
+		}
+	}
+
+	public class While : Statement {
+		public Expression expr;
+		public readonly Statement Statement;
+		bool may_return, empty, infinite;
+		
+		public While (Expression boolExpr, Statement statement, Location l)
+		{
+			this.expr = boolExpr;
+			Statement = statement;
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			bool ok = true;
+
+			expr = ResolveBoolean (ec, expr, loc);
+			if (expr == null)
+				return false;
+
+			ec.StartFlowBranching (FlowBranchingType.LOOP_BLOCK, loc);
+
+			//
+			// Inform whether we are infinite or not
+			//
+			if (expr is BoolConstant){
+				BoolConstant bc = (BoolConstant) expr;
+
+				if (bc.Value == false){
+					Warning_DeadCodeFound (Statement.loc);
+					empty = true;
+				} else
+					infinite = true;
+			} else {
+				//
+				// We are not infinite, so the loop may or may not be executed.
+				//
+				ec.CurrentBranching.CreateSibling ();
+			}
+
+			if (!Statement.Resolve (ec))
+				ok = false;
+
+			if (empty)
+				ec.KillFlowBranching ();
+			else {
+				ec.CurrentBranching.Infinite = infinite;
+				FlowReturns returns = ec.EndFlowBranching ();
+				may_return = returns != FlowReturns.NEVER;
+			}
+
+			return ok;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			if (empty)
+				return false;
+
+			ILGenerator ig = ec.ig;
+			Label old_begin = ec.LoopBegin;
+			Label old_end = ec.LoopEnd;
+			bool old_inloop = ec.InLoop;
+			int old_loop_begin_try_catch_level = ec.LoopBeginTryCatchLevel;
+			bool ret;
+			
+			ec.LoopBegin = ig.DefineLabel ();
+			ec.LoopEnd = ig.DefineLabel ();
+			ec.InLoop = true;
+			ec.LoopBeginTryCatchLevel = ec.TryCatchLevel;
+
+			//
+			// Inform whether we are infinite or not
+			//
+			if (expr is BoolConstant){
+				ig.MarkLabel (ec.LoopBegin);
+				Statement.Emit (ec);
+				ig.Emit (OpCodes.Br, ec.LoopBegin);
+					
+				//
+				// Inform that we are infinite (ie, 'we return'), only
+				// if we do not 'break' inside the code.
+				//
+				ret = may_return == false;
+				ig.MarkLabel (ec.LoopEnd);
+			} else {
+				Label while_loop = ig.DefineLabel ();
+
+				ig.Emit (OpCodes.Br, ec.LoopBegin);
+				ig.MarkLabel (while_loop);
+
+				Statement.Emit (ec);
+			
+				ig.MarkLabel (ec.LoopBegin);
+
+				EmitBoolExpression (ec, expr, while_loop, true);
+				ig.MarkLabel (ec.LoopEnd);
+
+				ret = false;
+			}	
+
+			ec.LoopBegin = old_begin;
+			ec.LoopEnd = old_end;
+			ec.InLoop = old_inloop;
+			ec.LoopBeginTryCatchLevel = old_loop_begin_try_catch_level;
+
+			return ret;
+		}
+	}
+
+	public class For : Statement {
+		Expression LoopControlVar;
+		Expression Start;
+		Expression Limit;
+		Expression StepValue;
+		Statement statement, Increment;
+		bool may_return, infinite, empty;
+		private Statement InitStatement;
+		// required when loop control var is of type 'Object'
+		Expression Test, AddnTest;
+		LocalTemporary ltmp;
+		bool is_lcv_object;
+		
+		public For (Expression loopVar,
+			    Expression start,
+			    Expression limit,
+			    Expression stepVal,
+			    Statement statement,
+			    Location l)
+		{
+			LoopControlVar = loopVar;
+			Start = start;
+			Limit = limit;
+			StepValue = stepVal;
+			this.statement = statement;
+			loc = l;
+			ltmp = null;
+
+			InitStatement = new StatementExpression ((ExpressionStatement) (new Assign (LoopControlVar, Start, loc)), loc);
+			Increment = new StatementExpression (
+						(ExpressionStatement) (new CompoundAssign (Binary.Operator.Addition, 
+									LoopControlVar, StepValue, loc)), loc);
+			AddnTest = null;
+			is_lcv_object = false;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			bool ok = true;
+
+			LoopControlVar = LoopControlVar.Resolve (ec);
+			if (LoopControlVar == null)
+				return false;
+
+			Start = Start.Resolve (ec);
+			Limit = Limit.Resolve (ec);
+			StepValue = StepValue.Resolve (ec);
+			if (StepValue == null || Start == null || Limit == null)
+				return false;
+
+			double value = 0;
+			if (StepValue is Constant) {
+
+				value = GetValue (StepValue);
+				if (value > 0) // Positive Step value
+					Test = new Binary (Binary.Operator.LessThanOrEqual, LoopControlVar, Limit, loc);
+				else if (value < 0)
+					Test = new Binary (Binary.Operator.GreaterThanOrEqual, LoopControlVar, Limit, loc);
+			}
+
+			if (Start is Constant && Limit is Constant) {
+				if (value > 0)
+					AddnTest = ConstantFold.BinaryFold (ec, Binary.Operator.LessThanOrEqual,
+									    (Constant) Start, (Constant) Limit, loc);
+				else  if (value < 0)
+					AddnTest = ConstantFold.BinaryFold (ec, Binary.Operator.GreaterThanOrEqual,
+									    (Constant) Start, (Constant) Limit, loc);
+			}
+
+
+			string method_to_call = null;
+			Binary left, right;
+			left = right = null;
+
+			switch (Type.GetTypeCode (LoopControlVar.Type)) {
+			case TypeCode.Boolean :
+			case TypeCode.Char :
+			case TypeCode.DateTime :
+			case TypeCode.String :
+				Report.Error (30337,loc,"'For' loop control variable cannot be of type '" + LoopControlVar.Type + "'");
+				return false;
+			case TypeCode.Byte :
+				if (Test == null)
+					Test = new Binary (Binary.Operator.LessThanOrEqual, LoopControlVar, Limit, loc);
+				break;
+			case TypeCode.Int16 :
+				if (Test == null) {
+					left = new Binary (Binary.Operator.ExclusiveOr, 
+							   new Binary (Binary.Operator.RightShift, StepValue, new IntLiteral (15), loc),
+							   LoopControlVar, 
+							   loc);
+					right = new Binary (Binary.Operator.ExclusiveOr, 
+							    new Binary (Binary.Operator.RightShift, StepValue, new IntLiteral (15), loc),
+							    Limit, 
+							    loc);
+					Test = new Binary (Binary.Operator.LessThanOrEqual, left, right, loc);
+				}
+				break;
+			case TypeCode.Int32 :
+				if (Test == null) {
+					left = new Binary (Binary.Operator.ExclusiveOr, 
+							   new Binary (Binary.Operator.RightShift, StepValue, new IntLiteral (31), loc),
+							   LoopControlVar, 
+							   loc);
+					right = new Binary (Binary.Operator.ExclusiveOr, 
+							    new Binary (Binary.Operator.RightShift, StepValue, new IntLiteral (31), loc),
+							    Limit, 
+							    loc);
+					Test = new Binary (Binary.Operator.LessThanOrEqual, left, right, loc);
+				}
+				break;
+			case TypeCode.Int64 :
+				if (Test == null) {
+					left = new Binary (Binary.Operator.ExclusiveOr, 
+							   new Binary (Binary.Operator.RightShift, StepValue, new IntLiteral (63), loc),
+							   LoopControlVar, 
+							   loc);
+					right = new Binary (Binary.Operator.ExclusiveOr, 
+							    new Binary (Binary.Operator.RightShift, StepValue, new IntLiteral (63), loc),
+							    Limit, 
+							    loc);
+					Test = new Binary (Binary.Operator.LessThanOrEqual, left, right, loc);
+				}
+				break;
+			case TypeCode.Decimal :
+				method_to_call = "Microsoft.VisualBasic.CompilerServices.FlowControl.ForNextCheckDec";
+				break;
+			case TypeCode.Single :
+				method_to_call = "Microsoft.VisualBasic.CompilerServices.FlowControl.ForNextCheckR4";
+				break;
+			case TypeCode.Double :
+				method_to_call = "Microsoft.VisualBasic.CompilerServices.FlowControl.ForNextCheckR8";
+				break;
+			case TypeCode.Object :
+				is_lcv_object = true;
+				ArrayList initArgs = new ArrayList ();
+				initArgs.Add (new Argument (LoopControlVar, Argument.AType.Expression));
+				initArgs.Add (new Argument (Start, Argument.AType.Expression));
+				initArgs.Add (new Argument (Limit, Argument.AType.Expression));
+				initArgs.Add (new Argument (StepValue, Argument.AType.Expression));
+				ltmp = new LocalTemporary (ec, TypeManager.object_type);
+				initArgs.Add (new Argument (ltmp, Argument.AType.Ref));
+				initArgs.Add (new Argument (LoopControlVar, Argument.AType.Ref));
+				Expression sname  = Parser.DecomposeQI ("Microsoft.VisualBasic.CompilerServices.FlowControl.ForLoopInitObj", loc);
+				AddnTest = new Invocation (sname, initArgs, loc);
+				//AddnTest = new Binary (Binary.Operator.Inequality, inv, new BoolLiteral (false), loc);
+				ArrayList args = new ArrayList ();
+				args.Add (new Argument (LoopControlVar, Argument.AType.Expression));
+				args.Add (new Argument (ltmp, Argument.AType.Expression));
+				args.Add (new Argument (LoopControlVar, Argument.AType.Ref));
+				sname  = Parser.DecomposeQI ("Microsoft.VisualBasic.CompilerServices.FlowControl.ForNextCheckObj", loc);
+				Test = new Invocation (sname, args, loc);
+				//Test = new Binary (Binary.Operator.Inequality, inv, new BoolLiteral (false), loc);
+				break;
+			}
+
+			if (method_to_call != null && !method_to_call.Equals ("")) {
+				ArrayList args = null;
+				args = new ArrayList ();
+				args.Add (new Argument (LoopControlVar, Argument.AType.Expression));
+				args.Add (new Argument (Limit, Argument.AType.Expression));
+				args.Add (new Argument (StepValue, Argument.AType.Expression));
+				Expression sname = Parser.DecomposeQI (method_to_call, loc);
+				Test = new Invocation (sname, args, loc);
+				//Test = new Binary (Binary.Operator.Inequality, invocation, new BoolLiteral (false), loc);
+			}
+
+			if (InitStatement != null){
+				if (!InitStatement.Resolve (ec))
+					ok = false;
+			}
+
+			if (AddnTest != null) {
+				AddnTest = ResolveBoolean (ec, AddnTest, loc);
+				if (AddnTest == null)
+					ok = false;
+			}
+
+			if (Test != null){
+				Test = ResolveBoolean (ec, Test, loc);
+				if (Test == null)
+					ok = false;
+				else if (Test is BoolConstant){
+					BoolConstant bc = (BoolConstant) Test;
+
+					if (bc.Value == false){
+						Warning_DeadCodeFound (statement.loc);
+						empty = true;
+					} else
+						infinite = true;
+				}
+			} else
+				infinite = true;
+
+			if (Increment != null) {
+				if (!Increment.Resolve (ec))
+					ok = false;
+			}
+
+			ec.StartFlowBranching (FlowBranchingType.LOOP_BLOCK, loc);
+			if (!infinite)
+				ec.CurrentBranching.CreateSibling ();
+
+			if (!statement.Resolve (ec))
+				ok = false;
+
+			if (empty)
+				ec.KillFlowBranching ();
+			else {
+				ec.CurrentBranching.Infinite = infinite;
+				FlowReturns returns = ec.EndFlowBranching ();
+				may_return = returns != FlowReturns.NEVER;
+			}
+
+			return ok;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			if (empty)
+				return false;
+
+			ILGenerator ig = ec.ig;
+			Label old_begin = ec.LoopBegin;
+			Label old_end = ec.LoopEnd;
+			bool old_inloop = ec.InLoop;
+			int old_loop_begin_try_catch_level = ec.LoopBeginTryCatchLevel;
+			Label loop = ig.DefineLabel ();
+			Label test = ig.DefineLabel ();
+			
+			if (!is_lcv_object && InitStatement != null)
+				if (! (InitStatement is EmptyStatement))
+					InitStatement.Emit (ec);
+
+			ec.LoopBegin = ig.DefineLabel ();
+			ec.LoopEnd = ig.DefineLabel ();
+			ec.InLoop = true;
+			ec.LoopBeginTryCatchLevel = ec.TryCatchLevel;
+
+			if (AddnTest != null) {
+				if (AddnTest is BoolConstant) {
+					if (!((BoolConstant) AddnTest).Value)
+						// We can actually branch to the end of the loop,
+						// but vbc does it this way
+						ig.Emit (OpCodes.Br, test);
+				} else if (is_lcv_object)
+					EmitBoolExpression (ec, AddnTest, ec.LoopEnd, false);
+				else 
+					EmitBoolExpression (ec, AddnTest, test, false);
+			} else 
+				ig.Emit (OpCodes.Br, test);
+			ig.MarkLabel (loop);
+			statement.Emit (ec);
+
+			ig.MarkLabel (ec.LoopBegin);
+			if (!is_lcv_object && !(Increment is EmptyStatement))
+				Increment.Emit (ec);
+
+			ig.MarkLabel (test);
+			//
+			// If test is null, there is no test, and we are just
+			// an infinite loop
+			//
+			if (Test != null)
+				EmitBoolExpression (ec, Test, loop, true);
+			else
+				ig.Emit (OpCodes.Br, loop);
+			ig.MarkLabel (ec.LoopEnd);
+
+			ec.LoopBegin = old_begin;
+			ec.LoopEnd = old_end;
+			ec.InLoop = old_inloop;
+			ec.LoopBeginTryCatchLevel = old_loop_begin_try_catch_level;
+			
+			//
+ 			// Inform whether we are infinite or not
+			//
+
+			if (ltmp != null)
+				ltmp.Release (ec);
+			if (Test != null){
+				if (Test is BoolConstant){
+					BoolConstant bc = (BoolConstant) Test;
+
+					if (bc.Value)
+						return may_return == false;
+				}
+				return false;
+			} else
+				return may_return == false;
+		}
+
+		private double GetValue (Expression e) {
+			if (e is DoubleConstant)
+				return ((DoubleConstant) e).Value;
+			if (e is FloatConstant)
+				return (double)((FloatConstant) e).Value;
+			if (e is IntConstant)
+				return (double)((IntConstant) e).Value;
+			if (e is LongConstant)
+				return (double)((LongConstant) e).Value;
+			if (e is DecimalConstant)
+				return (double)((DecimalConstant) e).Value;
+			return 0;
+		}
+	}
+	
+	public class StatementExpression : Statement {
+		public Expression expr;
+		
+		public StatementExpression (ExpressionStatement expr, Location l)
+		{
+			this.expr = expr;
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			expr = (Expression) expr.Resolve (ec);
+			return expr != null;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			
+			if (expr is ExpressionStatement)
+				((ExpressionStatement) expr).EmitStatement (ec);
+			else {
+				expr.Emit (ec);
+				if (! (expr is StatementSequence))
+					ig.Emit (OpCodes.Pop);
+			}
+
+			return false;
+		}
+
+		public override string ToString ()
+		{
+			return "StatementExpression (" + expr + ")";
+		}
+	}
+
+	/// <summary>
+	///   Implements the return statement
+	/// </summary>
+	public class Return : Statement {
+		public Expression Expr;
+		
+		public Return (Expression expr, Location l)
+		{
+			expr = Parser.SetValueRequiredFlag (expr);
+			Expr = expr;
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			if (Expr != null){
+				Expr = Expr.Resolve (ec);
+				if (Expr == null)
+					return false;
+			}
+
+			FlowBranching.UsageVector vector = ec.CurrentBranching.CurrentUsageVector;
+
+			if (ec.CurrentBranching.InTryBlock ())
+				ec.CurrentBranching.AddFinallyVector (vector);
+
+			if (! ec.InTry && ! ec.InCatch) {
+				vector.Returns = FlowReturns.ALWAYS;
+				vector.Breaks = FlowReturns.ALWAYS;
+			}
+			return true;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			if (ec.InFinally){
+				Report.Error (157,loc,"Control can not leave the body of the finally block");
+				return false;
+			}
+			
+			if (ec.ReturnType == null){
+				if (Expr != null){
+					Report.Error (127, loc, "Return with a value not allowed here");
+					return true;
+				}
+			} else {
+				if (Expr == null){
+					Report.Error (126, loc, "An object of type '" +
+						      TypeManager.MonoBASIC_Name (ec.ReturnType) + "' is " +
+						      "expected for the return statement");
+					return true;
+				}
+
+				if (Expr.Type != ec.ReturnType)
+					Expr = Expression.ConvertImplicitRequired (
+						ec, Expr, ec.ReturnType, loc);
+
+				if (Expr == null)
+					return true;
+
+				Expr.Emit (ec);
+
+				if (ec.InTry || ec.InCatch)
+					ec.ig.Emit (OpCodes.Stloc, ec.TemporaryReturn ());
+			}
+
+			if (ec.InTry || ec.InCatch) {
+				if (!ec.HasReturnLabel) {
+					ec.ReturnLabel = ec.ig.DefineLabel ();
+					ec.HasReturnLabel = true;
+				}
+				ec.ig.Emit (OpCodes.Leave, ec.ReturnLabel);
+			} else
+				ec.ig.Emit (OpCodes.Ret);
+
+			return true; 
+		}
+	}
+
+	public class Goto : Statement {
+		string target;
+		Block block;
+		LabeledStatement label;
+		
+		public override bool Resolve (EmitContext ec)
+		{
+			label = block.LookupLabel (target);
+
+			if (label == null){
+				Report.Error (
+					30132, loc,
+					"No such label '" + target + "' in this scope");
+				return false;
+			}
+
+			// If this is a forward goto.
+			if (!label.IsDefined)
+				label.AddUsageVector (ec.CurrentBranching.CurrentUsageVector);
+
+			 ec.CurrentBranching.CurrentUsageVector.Breaks = FlowReturns.ALWAYS;
+			label.AddReference ();
+			return true;
+		}
+		
+		public Goto (Block parent_block, string label, Location l)
+		{
+			block = parent_block;
+			loc = l;
+			target = label;
+		}
+
+		public string Target {
+			get {
+				return target;
+			}
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			Label l = label.LabelTarget (ec);
+			 if (ec.InTry || ec.InCatch)
+                         	ec.ig.Emit (OpCodes.Leave, l);
+			else 
+				ec.ig.Emit (OpCodes.Br, l);
+			
+			return false;
+		}
+	}
+
+	public class LabeledStatement : Statement {
+		public readonly Location Location;
+		string label_name;
+		bool defined;
+		bool referenced;
+		Label label;
+
+		ArrayList vectors;
+		
+		public LabeledStatement (string label_name, Location l)
+		{
+			this.label_name = label_name;
+			this.Location = l;
+		}
+		
+		public string LabelName {
+			get {
+				return label_name;
+			}
+		}
+
+		public Label LabelTarget (EmitContext ec)
+		{
+			if (defined) 
+				return label;
+			label = ec.ig.DefineLabel ();
+
+			defined = true;
+
+			return label;
+		}
+
+		public bool IsDefined {
+			get {
+				return defined;
+			}
+		}
+
+		public bool HasBeenReferenced {
+			get {
+				return referenced;
+			}
+		}
+
+		public void AddUsageVector (FlowBranching.UsageVector vector)
+		{
+			if (vectors == null)
+				vectors = new ArrayList ();
+
+			vectors.Add (vector.Clone ());
+
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			if (vectors != null) {
+				ec.CurrentBranching.CurrentUsageVector.MergeJumpOrigins (vectors);
+			}
+			else {
+				ec.CurrentBranching.CurrentUsageVector.Breaks = FlowReturns.NEVER;
+				ec.CurrentBranching.CurrentUsageVector.Returns = FlowReturns.NEVER;
+			}
+
+			referenced = true;
+
+
+			return true;
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			LabelTarget (ec);
+			ec.ig.MarkLabel (label);
+
+			return false;
+		}
+		public void AddReference ()
+                {
+                        referenced = true;
+                }
+	}
+	
+
+	/// <summary>
+	///   'goto default' statement
+	/// </summary>
+	public class GotoDefault : Statement {
+		
+		public GotoDefault (Location l)
+		{
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			ec.CurrentBranching.CurrentUsageVector.Breaks = FlowReturns.UNREACHABLE;
+			return true;
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			if (ec.Switch == null){
+				Report.Error (153, loc, "goto default is only valid in a switch statement");
+				return false;
+			}
+
+			if (!ec.Switch.GotDefault){
+				Report.Error (30132, loc, "No default target on switch statement");
+				return false;
+			}
+			ec.ig.Emit (OpCodes.Br, ec.Switch.DefaultTarget);
+			return false;
+		}
+	}
+
+	/// <summary>
+	///   'goto case' statement
+	/// </summary>
+	public class GotoCase : Statement {
+		Expression expr;
+		Label label;
+		
+		public GotoCase (Expression e, Location l)
+		{
+			expr = e;
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			if (ec.Switch == null){
+				Report.Error (153, loc, "goto case is only valid in a switch statement");
+				return false;
+			}
+
+			expr = expr.Resolve (ec);
+			if (expr == null)
+				return false;
+
+			if (!(expr is Constant)){
+				Report.Error (30132, loc, "Target expression for goto case is not constant");
+				return false;
+			}
+
+			object val = Expression.ConvertIntLiteral (
+				(Constant) expr, ec.Switch.SwitchType, loc);
+
+			if (val == null)
+				return false;
+					
+			SwitchLabel sl = (SwitchLabel) ec.Switch.Elements [val];
+
+			if (sl == null){
+				Report.Error (
+					30132, loc,
+					"No such label 'case " + val + "': for the goto case");
+			}
+
+			label = sl.ILLabelCode;
+
+			ec.CurrentBranching.CurrentUsageVector.Breaks = FlowReturns.UNREACHABLE;
+			return true;
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			ec.ig.Emit (OpCodes.Br, label);
+			return true;
+		}
+	}
+	
+	public class Throw : Statement {
+		Expression expr;
+		
+		public Throw (Expression expr, Location l)
+		{
+			this.expr = expr;
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			if (expr != null){
+				expr = expr.Resolve (ec);
+				if (expr == null)
+					return false;
+
+				ExprClass eclass = expr.eclass;
+
+				if (!(eclass == ExprClass.Variable || eclass == ExprClass.PropertyAccess ||
+				      eclass == ExprClass.Value || eclass == ExprClass.IndexerAccess)) {
+					expr.Error118 ("value, variable, property or indexer access ");
+					return false;
+				}
+
+				Type t = expr.Type;
+				
+				if ((t != TypeManager.exception_type) &&
+				    !t.IsSubclassOf (TypeManager.exception_type) &&
+				    !(expr is NullLiteral)) {
+					Report.Error (30665, loc,
+						      "The type caught or thrown must be derived " +
+						      "from System.Exception");
+					return false;
+				}
+			}
+
+			ec.CurrentBranching.CurrentUsageVector.Returns = FlowReturns.EXCEPTION;
+			ec.CurrentBranching.CurrentUsageVector.Breaks = FlowReturns.EXCEPTION;
+			return true;
+		}
+			
+		protected override bool DoEmit (EmitContext ec)
+		{
+			if (expr == null){
+				if (ec.InCatch)
+					ec.ig.Emit (OpCodes.Rethrow);
+				else {
+					Report.Error (
+						156, loc,
+						"A throw statement with no argument is only " +
+						"allowed in a catch clause");
+				}
+				return false;
+			}
+
+			expr.Emit (ec);
+
+			ec.ig.Emit (OpCodes.Throw);
+
+			return true;
+		}
+	}
+
+	// Support 'End' Statement which terminates execution immediately
+
+	  public class End : Statement {
+
+                public End (Location l)
+                {
+                        loc = l;
+                }
+
+                public override bool Resolve (EmitContext ec)
+                {
+                        return true;
+                }
+
+                protected override bool DoEmit (EmitContext ec)
+                {
+			Expression e = null;
+                        Expression tmp = Mono.MonoBASIC.Parser.DecomposeQI (
+                                                "Microsoft.VisualBasic.CompilerServices.ProjectData.EndApp",
+                                                        Location.Null);
+
+                       e = new Invocation (tmp, null, loc);
+                       e.Resolve (ec);
+
+                	if (e == null)
+                        	return false;
+                	e.Emit (ec);
+
+                        return true;
+                }
+        }
+
+
+	public class Break : Statement {
+		
+		public Break (Location l)
+		{
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			ec.CurrentBranching.MayLeaveLoop = true;
+			ec.CurrentBranching.CurrentUsageVector.Breaks = FlowReturns.ALWAYS;
+			return true;
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+
+			if (ec.InLoop == false && ec.Switch == null){
+				Report.Error (139, loc, "No enclosing loop or switch to continue to");
+				return false;
+			}
+
+			if (ec.InTry || ec.InCatch)
+				ig.Emit (OpCodes.Leave, ec.LoopEnd);
+			else
+				ig.Emit (OpCodes.Br, ec.LoopEnd);
+
+			return false;
+		}
+	}
+	
+	public enum ExitType {
+		DO, 
+		FOR, 
+		WHILE,
+		SELECT,
+		SUB,
+		FUNCTION,
+		PROPERTY,
+		TRY			
+	};
+	
+	public class Exit : Statement {
+		public readonly ExitType type;
+		public Exit (ExitType t, Location l)
+		{
+			loc = l;
+			type = t;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			ec.CurrentBranching.MayLeaveLoop = true;
+			ec.CurrentBranching.CurrentUsageVector.Breaks = FlowReturns.ALWAYS;
+			return true;
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+
+			if (type != ExitType.SUB && type != ExitType.FUNCTION && 
+				type != ExitType.PROPERTY && type != ExitType.TRY) {
+				if (ec.InLoop == false && ec.Switch == null){
+					if (type == ExitType.FOR)
+						Report.Error (30096, loc, "No enclosing FOR loop to exit from");
+					if (type == ExitType.WHILE) 
+						Report.Error (30097, loc, "No enclosing WHILE loop to exit from");
+					if (type == ExitType.DO)
+						Report.Error (30089, loc, "No enclosing DO loop to exit from");
+					if (type == ExitType.SELECT)
+						Report.Error (30099, loc, "No enclosing SELECT to exit from");
+
+					return false;
+				}
+
+				if (ec.InTry || ec.InCatch)
+					ig.Emit (OpCodes.Leave, ec.LoopEnd);
+				else
+					ig.Emit (OpCodes.Br, ec.LoopEnd);
+			} else {			
+				if (ec.InFinally){
+					Report.Error (30393, loc, 
+						"Control can not leave the body of the finally block");
+					return false;
+				}
+			
+				if (ec.InTry || ec.InCatch) {
+					if (ec.HasExitLabel)
+						ec.ig.Emit (OpCodes.Leave, ec.ExitLabel);
+				} else {
+					if(type == ExitType.SUB) {   
+                                                ec.ig.Emit (OpCodes.Ret);
+                                        } else {
+						ec.ig.Emit (OpCodes.Ldloc_0);
+						ec.ig.Emit (OpCodes.Ret);
+				      	}
+
+				}
+
+				return true; 
+			}
+			
+			return false;
+		}
+	}	
+
+	public class Continue : Statement {
+		
+		public Continue (Location l)
+		{
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			ec.CurrentBranching.CurrentUsageVector.Breaks = FlowReturns.ALWAYS;
+			return true;
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			Label begin = ec.LoopBegin;
+			
+			if (!ec.InLoop){
+				Report.Error (139, loc, "No enclosing loop to continue to");
+				return false;
+			} 
+
+			//
+			// UGH: Non trivial.  This Br might cross a try/catch boundary
+			// How can we tell?
+			//
+			// while () {
+			//   try { ... } catch { continue; }
+			// }
+			//
+			// From:
+			// try {} catch { while () { continue; }}
+			//
+			if (ec.TryCatchLevel > ec.LoopBeginTryCatchLevel)
+				ec.ig.Emit (OpCodes.Leave, begin);
+			else if (ec.TryCatchLevel < ec.LoopBeginTryCatchLevel)
+				throw new Exception ("Should never happen");
+			else
+				ec.ig.Emit (OpCodes.Br, begin);
+			return false;
+		}
+	}
+
+	// <summary>
+	//   This is used in the control flow analysis code to specify whether the
+	//   current code block may return to its enclosing block before reaching
+	//   its end.
+	// </summary>
+	public enum FlowReturns {
+		// It can never return.
+		NEVER,
+
+		// This means that the block contains a conditional return statement
+		// somewhere.
+		SOMETIMES,
+
+		// The code always returns, ie. there's an unconditional return / break
+		// statement in it.
+		ALWAYS,
+
+		// The code always throws an exception.
+		EXCEPTION,
+
+		// The current code block is unreachable.  This happens if it's immediately
+		// following a FlowReturns.ALWAYS block.
+		UNREACHABLE
+	}
+
+	// <summary>
+	//   This is a special bit vector which can inherit from another bit vector doing a
+	//   copy-on-write strategy.  The inherited vector may have a smaller size than the
+	//   current one.
+	// </summary>
+	public class MyBitVector {
+		private int count;
+		public int Count { get { return count; } }
+		public readonly MyBitVector InheritsFrom;
+
+		bool is_dirty;
+		BitArray vector;
+
+		public MyBitVector (int Count)
+			: this (null, Count)
+		{ }
+
+		public MyBitVector (MyBitVector InheritsFrom, int Count)
+		{
+			this.InheritsFrom = InheritsFrom;
+			this.count = Count;
+		}
+
+		// <summary>
+		//   Checks whether this bit vector has been modified.  After setting this to true,
+		//   we won't use the inherited vector anymore, but our own copy of it.
+		// </summary>
+		public bool IsDirty {
+			get {
+				return is_dirty;
+			}
+
+			set {
+				if (!is_dirty)
+					initialize_vector ();
+			}
+		}
+
+		// <summary>
+		//   Get/set bit 'index' in the bit vector.
+		// </summary>
+		public bool this [int index]
+		{
+			get {
+				if (index > count)
+					throw new ArgumentOutOfRangeException ();
+
+				// We're doing a "copy-on-write" strategy here; as long
+				// as nobody writes to the array, we can use our parent's
+				// copy instead of duplicating the vector.
+
+				if (vector != null)
+					return vector [index];
+				else if (InheritsFrom != null) {
+					BitArray inherited = InheritsFrom.Vector;
+
+					if (index < inherited.Count)
+						return inherited [index];
+					else
+						return false;
+				} else
+					return false;
+			}
+
+			set {
+				if (index > count)
+					throw new ArgumentOutOfRangeException ();
+
+				// Only copy the vector if we're actually modifying it.
+
+				if (this [index] != value) {
+					initialize_vector ();
+
+					vector [index] = value;
+				}
+			}
+		}
+
+		// <summary>
+		//   If you explicitly convert the MyBitVector to a BitArray, you will get a deep
+		//   copy of the bit vector.
+		// </summary>
+		public static explicit operator BitArray (MyBitVector vector)
+		{
+			vector.initialize_vector ();
+			return vector.Vector;
+		}
+
+		// <summary>
+		//   Performs an 'or' operation on the bit vector.  The 'new_vector' may have a
+		//   different size than the current one.
+		// </summary>
+		public void Or (MyBitVector new_vector)
+		{
+			BitArray new_array = new_vector.Vector;
+
+			initialize_vector ();
+
+			int upper;
+			if (vector.Count < new_array.Count)
+				upper = vector.Count;
+			else
+				upper = new_array.Count;
+
+			for (int i = 0; i < upper; i++)
+				vector [i] = vector [i] | new_array [i];
+		}
+
+		// <summary>
+		//   Perfonrms an 'and' operation on the bit vector.  The 'new_vector' may have
+		//   a different size than the current one.
+		// </summary>
+		public void And (MyBitVector new_vector)
+		{
+			BitArray new_array = new_vector.Vector;
+
+			initialize_vector ();
+
+			int lower, upper;
+			if (vector.Count < new_array.Count)
+				lower = upper = vector.Count;
+			else {
+				lower = new_array.Count;
+				upper = vector.Count;
+			}
+
+			for (int i = 0; i < lower; i++)
+				vector [i] = vector [i] & new_array [i];
+
+			for (int i = lower; i < upper; i++)
+				vector [i] = false;
+		}
+
+		// <summary>
+		//   This does a deep copy of the bit vector.
+		// </summary>
+		public MyBitVector Clone ()
+		{
+			MyBitVector retval = new MyBitVector (Count);
+
+			retval.Vector = Vector;
+
+			return retval;
+		}
+		
+		public void ExpandBy(int howMany)
+		{
+			if (howMany < 1)
+				throw new ArgumentException("howMany");
+			initialize_vector();
+			count = vector.Count + howMany;
+			BitArray newVector = new BitArray(count, false);
+			for (int i = 0; i < vector.Count; i++)
+					newVector [i] = vector [i];
+			vector = newVector;
+		}
+
+		BitArray Vector {
+			get {
+				if (vector != null)
+					return vector;
+				else if (!is_dirty && (InheritsFrom != null))
+					return InheritsFrom.Vector;
+
+				initialize_vector ();
+
+				return vector;
+			}
+
+			set {
+				initialize_vector ();
+
+				for (int i = 0; i < System.Math.Min (vector.Count, value.Count); i++)
+					vector [i] = value [i];
+			}
+		}
+
+		void initialize_vector ()
+		{
+			if (vector != null)
+				return;
+
+			vector = new BitArray (Count, false);
+			if (InheritsFrom != null)
+				Vector = InheritsFrom.Vector;
+
+			is_dirty = true;
+		}
+
+		public override string ToString ()
+		{
+			StringBuilder sb = new StringBuilder ("MyBitVector (");
+
+			BitArray vector = Vector;
+			sb.Append (Count);
+			sb.Append (",");
+			if (!IsDirty)
+				sb.Append ("INHERITED - ");
+			for (int i = 0; i < vector.Count; i++) {
+				if (i > 0)
+					sb.Append (",");
+				sb.Append (vector [i]);
+			}
+			
+			sb.Append (")");
+			return sb.ToString ();
+		}
+	}
+
+	// <summary>
+	//   The type of a FlowBranching.
+	// </summary>
+	public enum FlowBranchingType {
+		// Normal (conditional or toplevel) block.
+		BLOCK,
+
+		// A loop block.
+		LOOP_BLOCK,
+
+		// Try/Catch block.
+		EXCEPTION,
+
+		// Switch block.
+		SWITCH,
+
+		// Switch section.
+		SWITCH_SECTION
+	}
+
+	// <summary>
+	//   A new instance of this class is created every time a new block is resolved
+	//   and if there's branching in the block's control flow.
+	// </summary>
+	public class FlowBranching {
+		// <summary>
+		//   The type of this flow branching.
+		// </summary>
+		public readonly FlowBranchingType Type;
+
+		// <summary>
+		//   The block this branching is contained in.  This may be null if it's not
+		//   a top-level block and it doesn't declare any local variables.
+		// </summary>
+		public readonly Block Block;
+
+		// <summary>
+		//   The parent of this branching or null if this is the top-block.
+		// </summary>
+		public readonly FlowBranching Parent;
+
+		// <summary>
+		//   Start-Location of this flow branching.
+		// </summary>
+		public readonly Location Location;
+
+		// <summary>
+		//   A list of UsageVectors.  A new vector is added each time control flow may
+		//   take a different path.
+		// </summary>
+		public ArrayList Siblings;
+
+		// <summary>
+		//   If this is an infinite loop.
+		// </summary>
+		public bool Infinite;
+
+		// <summary>
+		//   If we may leave the current loop.
+		// </summary>
+		public bool MayLeaveLoop;
+
+		//
+		// Private
+		//
+		InternalParameters param_info;
+		int[] param_map;
+		MyStructInfo[] struct_params;
+		int num_params;
+		ArrayList finally_vectors;
+
+		static int next_id = 0;
+		int id;
+
+		// <summary>
+		//   Performs an 'And' operation on the FlowReturns status
+		//   (for instance, a block only returns ALWAYS if all its siblings
+		//   always return).
+		// </summary>
+		public static FlowReturns AndFlowReturns (FlowReturns a, FlowReturns b)
+		{
+			if (b == FlowReturns.UNREACHABLE)
+				return a;
+
+			switch (a) {
+			case FlowReturns.NEVER:
+				if (b == FlowReturns.NEVER)
+					return FlowReturns.NEVER;
+				else
+					return FlowReturns.SOMETIMES;
+
+			case FlowReturns.SOMETIMES:
+				return FlowReturns.SOMETIMES;
+
+			case FlowReturns.ALWAYS:
+				if ((b == FlowReturns.ALWAYS) || (b == FlowReturns.EXCEPTION))
+					return FlowReturns.ALWAYS;
+				else
+					return FlowReturns.SOMETIMES;
+
+			case FlowReturns.EXCEPTION:
+				if (b == FlowReturns.EXCEPTION)
+					return FlowReturns.EXCEPTION;
+				else if (b == FlowReturns.ALWAYS)
+					return FlowReturns.ALWAYS;
+				else
+					return FlowReturns.SOMETIMES;
+			}
+
+			return b;
+		}
+
+		// <summary>
+		//   The vector contains a BitArray with information about which local variables
+		//   and parameters are already initialized at the current code position.
+		// </summary>
+		public class UsageVector {
+			// <summary>
+			//   If this is true, then the usage vector has been modified and must be
+			//   merged when we're done with this branching.
+			// </summary>
+			public bool IsDirty;
+
+			// <summary>
+			//   The number of parameters in this block.
+			// </summary>
+			public readonly int CountParameters;
+
+			// <summary>
+			//   The number of locals in this block.
+			// </summary>
+			public readonly int CountLocals;
+			
+			// <summary>
+			//   The number of locals in this block added after starting usage track.
+			// </summary>
+			public int ExtraLocals 	{ get { return locals.Count - CountLocals; } } 
+
+
+			// <summary>
+			//   If not null, then we inherit our state from this vector and do a
+			//   copy-on-write.  If null, then we're the first sibling in a top-level
+			//   block and inherit from the empty vector.
+			// </summary>
+			public readonly UsageVector InheritsFrom;
+
+			//
+			// Private.
+			//
+			MyBitVector locals, parameters;
+			FlowReturns real_returns, real_breaks;
+			bool is_finally;
+
+			static int next_id = 0;
+			int id;
+
+			//
+			// Normally, you should not use any of these constructors.
+			//
+			public UsageVector (UsageVector parent, int num_params, int num_locals)
+			{
+				this.InheritsFrom = parent;
+				this.CountParameters = num_params;
+				this.CountLocals = num_locals;
+				this.real_returns = FlowReturns.NEVER;
+				this.real_breaks = FlowReturns.NEVER;
+
+				if (parent != null) {
+					locals = new MyBitVector (parent.locals, CountLocals);
+					if (num_params > 0)
+						parameters = new MyBitVector (parent.parameters, num_params);
+					real_returns = parent.Returns;
+					real_breaks = parent.Breaks;
+				} else {
+					locals = new MyBitVector (null, CountLocals);
+					if (num_params > 0)
+						parameters = new MyBitVector (null, num_params);
+				}
+
+				id = ++next_id;
+			}
+
+			public UsageVector (UsageVector parent)
+				: this (parent, parent.CountParameters, parent.CountLocals)
+			{ }
+
+			public void AddExtraLocals(int howMany)
+			{
+				locals.ExpandBy(howMany);
+			}
+			
+			// <summary>
+			//   This does a deep copy of the usage vector.
+			// </summary>
+			public UsageVector Clone ()
+			{
+				UsageVector retval = new UsageVector (null, CountParameters, CountLocals);
+
+				retval.locals = locals.Clone ();
+				if (parameters != null)
+					retval.parameters = parameters.Clone ();
+				retval.real_returns = real_returns;
+				retval.real_breaks = real_breaks;
+
+				return retval;
+			}
+
+			// 
+			// State of parameter 'number'.
+			//
+			public bool this [int number]
+			{
+				get {
+					if (number == -1)
+						return true;
+					else if (number == 0)
+						throw new ArgumentException ();
+
+					return parameters [number - 1];
+				}
+
+				set {
+					if (number == -1)
+						return;
+					else if (number == 0)
+						throw new ArgumentException ();
+
+					parameters [number - 1] = value;
+				}
+			}
+
+			//
+			// State of the local variable 'vi'.
+			// If the local variable is a struct, use a non-zero 'field_idx'
+			// to check an individual field in it.
+			//
+			public bool this [VariableInfo vi, int field_idx]
+			{
+				get {
+					if (vi.Number == -1)
+						return true;
+					else if (vi.Number == 0)
+						throw new ArgumentException ();
+
+					return locals [vi.Number + field_idx - 1];
+				}
+
+				set {
+					if (vi.Number == -1)
+						return;
+					else if (vi.Number == 0)
+						throw new ArgumentException ();
+
+					locals [vi.Number + field_idx - 1] = value;
+				}
+			}
+
+			// <summary>
+			//   Specifies when the current block returns.
+			//   If this is FlowReturns.UNREACHABLE, then control can never reach the
+			//   end of the method (so that we don't need to emit a return statement).
+			//   The same applies for FlowReturns.EXCEPTION, but in this case the return
+			//   value will never be used.
+			// </summary>
+			public FlowReturns Returns {
+				get {
+					return real_returns;
+				}
+
+				set {
+					real_returns = value;
+				}
+			}
+
+			// <summary>
+			//   Specifies whether control may return to our containing block
+			//   before reaching the end of this block.  This happens if there
+			//   is a break/continue/goto/return in it.
+			//   This can also be used to find out whether the statement immediately
+			//   following the current block may be reached or not.
+			// </summary>
+			public FlowReturns Breaks {
+				get {
+					return real_breaks;
+				}
+
+				set {
+					real_breaks = value;
+				}
+			}
+
+			public bool AlwaysBreaks {
+				get {
+					return (Breaks == FlowReturns.ALWAYS) ||
+						(Breaks == FlowReturns.EXCEPTION) ||
+						(Breaks == FlowReturns.UNREACHABLE);
+				}
+			}
+
+			public bool MayBreak {
+				get {
+					return Breaks != FlowReturns.NEVER;
+				}
+			}
+
+			public bool AlwaysReturns {
+				get {
+					return (Returns == FlowReturns.ALWAYS) ||
+						(Returns == FlowReturns.EXCEPTION);
+				}
+			}
+
+			public bool MayReturn {
+				get {
+					return (Returns == FlowReturns.SOMETIMES) ||
+						(Returns == FlowReturns.ALWAYS);
+				}
+			}
+
+			// <summary>
+			//   Merge a child branching.
+			// </summary>
+			public FlowReturns MergeChildren (FlowBranching branching, ICollection children)
+			{
+				MyBitVector new_locals = null;
+				MyBitVector new_params = null;
+
+				FlowReturns new_returns = FlowReturns.NEVER;
+				FlowReturns new_breaks = FlowReturns.NEVER;
+				bool new_returns_set = false, new_breaks_set = false;
+
+				Report.Debug (2, "MERGING CHILDREN", branching, branching.Type,
+					      this, children.Count);
+
+				foreach (UsageVector child in children) {
+					Report.Debug (2, "  MERGING CHILD", child, child.is_finally);
+					
+					if (!child.is_finally) {
+						if (child.Breaks != FlowReturns.UNREACHABLE) {
+							// If Returns is already set, perform an
+							// 'And' operation on it, otherwise just set just.
+							if (!new_returns_set) {
+								new_returns = child.Returns;
+								new_returns_set = true;
+							} else
+								new_returns = AndFlowReturns (
+									new_returns, child.Returns);
+						}
+
+						// If Breaks is already set, perform an
+						// 'And' operation on it, otherwise just set just.
+						if (!new_breaks_set) {
+							new_breaks = child.Breaks;
+							new_breaks_set = true;
+						} else
+							new_breaks = AndFlowReturns (
+								new_breaks, child.Breaks);
+					}
+
+					// Ignore unreachable children.
+					if (child.Returns == FlowReturns.UNREACHABLE)
+						continue;
+
+					// A local variable is initialized after a flow branching if it
+					// has been initialized in all its branches which do neither
+					// always return or always throw an exception.
+					//
+					// If a branch may return, but does not always return, then we
+					// can treat it like a never-returning branch here: control will
+					// only reach the code position after the branching if we did not
+					// return here.
+					//
+					// It's important to distinguish between always and sometimes
+					// returning branches here:
+					//
+					//    1   int a;
+					//    2   if (something) {
+					//    3      return;
+					//    4      a = 5;
+					//    5   }
+					//    6   Console.WriteLine (a);
+					//
+					// The if block in lines 3-4 always returns, so we must not look
+					// at the initialization of 'a' in line 4 - thus it'll still be
+					// uninitialized in line 6.
+					//
+					// On the other hand, the following is allowed:
+					//
+					//    1   int a;
+					//    2   if (something)
+					//    3      a = 5;
+					//    4   else
+					//    5      return;
+					//    6   Console.WriteLine (a);
+					//
+					// Here, 'a' is initialized in line 3 and we must not look at
+					// line 5 since it always returns.
+					// 
+					if (child.is_finally) {
+						if (new_locals == null)
+							new_locals = locals.Clone ();
+						new_locals.Or (child.locals);
+
+						if (parameters != null) {
+							if (new_params == null)
+								new_params = parameters.Clone ();
+							new_params.Or (child.parameters);
+						}
+
+					} else {
+						if (!child.AlwaysReturns && !child.AlwaysBreaks) {
+							if (new_locals != null)
+								new_locals.And (child.locals);
+							else {
+								new_locals = locals.Clone ();
+								new_locals.Or (child.locals);
+							}
+						} else if (children.Count == 1) {
+							new_locals = locals.Clone ();
+							new_locals.Or (child.locals);
+						}
+
+						// An 'out' parameter must be assigned in all branches which do
+						// not always throw an exception.
+						if (parameters != null) {
+							if (child.Breaks != FlowReturns.EXCEPTION) {
+								if (new_params != null)
+									new_params.And (child.parameters);
+								else {
+									new_params = parameters.Clone ();
+									new_params.Or (child.parameters);
+								}
+							} else if (children.Count == 1) {
+								new_params = parameters.Clone ();
+								new_params.Or (child.parameters);
+							}
+						}
+					}
+				}
+
+				Returns = new_returns;
+				if ((branching.Type == FlowBranchingType.BLOCK) ||
+				    (branching.Type == FlowBranchingType.EXCEPTION) ||
+				    (new_breaks == FlowReturns.UNREACHABLE) ||
+				    (new_breaks == FlowReturns.EXCEPTION))
+					Breaks = new_breaks;
+				else if (branching.Type == FlowBranchingType.SWITCH_SECTION)
+					Breaks = new_returns;
+				else if (branching.Type == FlowBranchingType.SWITCH){
+					if (new_breaks == FlowReturns.ALWAYS)
+						Breaks = FlowReturns.ALWAYS;
+				}
+
+				//
+				// We've now either reached the point after the branching or we will
+				// never get there since we always return or always throw an exception.
+				//
+				// If we can reach the point after the branching, mark all locals and
+				// parameters as initialized which have been initialized in all branches
+				// we need to look at (see above).
+				//
+
+				if (((new_breaks != FlowReturns.ALWAYS) &&
+				     (new_breaks != FlowReturns.EXCEPTION) &&
+				     (new_breaks != FlowReturns.UNREACHABLE)) ||
+				    (children.Count == 1)) {
+					if (new_locals != null)
+						locals.Or (new_locals);
+
+					if (new_params != null)
+						parameters.Or (new_params);
+				}
+
+				Report.Debug (2, "MERGING CHILDREN DONE", branching.Type,
+					      new_params, new_locals, new_returns, new_breaks,
+					      branching.Infinite, branching.MayLeaveLoop, this);
+
+				if (branching.Type == FlowBranchingType.SWITCH_SECTION) {
+					if ((new_breaks != FlowReturns.ALWAYS) &&
+					    (new_breaks != FlowReturns.EXCEPTION) &&
+					    (new_breaks != FlowReturns.UNREACHABLE))
+						Report.Error (163, branching.Location,
+							      "Control cannot fall through from one " +
+							      "case label to another");
+				}
+
+				if (branching.Infinite && !branching.MayLeaveLoop) {
+					Report.Debug (1, "INFINITE", new_returns, new_breaks,
+						      Returns, Breaks, this);
+
+					// We're actually infinite.
+					if (new_returns == FlowReturns.NEVER) {
+						Breaks = FlowReturns.UNREACHABLE;
+						return FlowReturns.UNREACHABLE;
+					}
+
+					// If we're an infinite loop and do not break, the code after
+					// the loop can never be reached.  However, if we may return
+					// from the loop, then we do always return (or stay in the loop
+					// forever).
+					if ((new_returns == FlowReturns.SOMETIMES) ||
+					    (new_returns == FlowReturns.ALWAYS)) {
+						Returns = FlowReturns.ALWAYS;
+						return FlowReturns.ALWAYS;
+					}
+				}
+
+				return new_returns;
+			}
+
+			// <summary>
+			//   Tells control flow analysis that the current code position may be reached with
+			//   a forward jump from any of the origins listed in 'origin_vectors' which is a
+			//   list of UsageVectors.
+			//
+			//   This is used when resolving forward gotos - in the following example, the
+			//   variable 'a' is uninitialized in line 8 becase this line may be reached via
+			//   the goto in line 4:
+			//
+			//      1     int a;
+			//
+			//      3     if (something)
+			//      4        goto World;
+			//
+			//      6     a = 5;
+			//
+			//      7  World:
+			//      8     Console.WriteLine (a);
+			//
+			// </summary>
+			public void MergeJumpOrigins (ICollection origin_vectors)
+			{
+				Report.Debug (1, "MERGING JUMP ORIGIN", this);
+
+				real_breaks = FlowReturns.NEVER;
+				real_returns = FlowReturns.NEVER;
+
+				foreach (UsageVector vector in origin_vectors) {
+					Report.Debug (1, "  MERGING JUMP ORIGIN", vector);
+
+					locals.And (vector.locals);
+					if (parameters != null)
+						parameters.And (vector.parameters);
+					Breaks = AndFlowReturns (Breaks, vector.Breaks);
+					Returns = AndFlowReturns (Returns, vector.Returns);
+				}
+
+				Report.Debug (1, "MERGING JUMP ORIGIN DONE", this);
+			}
+
+			// <summary>
+			//   This is used at the beginning of a finally block if there were
+			//   any return statements in the try block or one of the catch blocks.
+			// </summary>
+			public void MergeFinallyOrigins (ICollection finally_vectors)
+			{
+				Report.Debug (1, "MERGING FINALLY ORIGIN", this);
+
+				real_breaks = FlowReturns.NEVER;
+
+				foreach (UsageVector vector in finally_vectors) {
+					Report.Debug (1, "  MERGING FINALLY ORIGIN", vector);
+
+					if (parameters != null)
+						parameters.And (vector.parameters);
+					Breaks = AndFlowReturns (Breaks, vector.Breaks);
+				}
+
+				is_finally = true;
+
+				Report.Debug (1, "MERGING FINALLY ORIGIN DONE", this);
+			}
+			// <summary>
+			//   Performs an 'or' operation on the locals and the parameters.
+			// </summary>
+			public void Or (UsageVector new_vector)
+			{
+				locals.Or (new_vector.locals);
+				if (parameters != null)
+					parameters.Or (new_vector.parameters);
+			}
+
+			// <summary>
+			//   Performs an 'and' operation on the locals.
+			// </summary>
+			public void AndLocals (UsageVector new_vector)
+			{
+				locals.And (new_vector.locals);
+			}
+
+			// <summary>
+			//   Returns a deep copy of the parameters.
+			// </summary>
+			public MyBitVector Parameters {
+				get {
+					if (parameters != null)
+						return parameters.Clone ();
+					else
+						return null;
+				}
+			}
+
+			// <summary>
+			//   Returns a deep copy of the locals.
+			// </summary>
+			public MyBitVector Locals {
+				get {
+					return locals.Clone ();
+				}
+			}
+
+			//
+			// Debugging stuff.
+			//
+
+			public override string ToString ()
+			{
+				StringBuilder sb = new StringBuilder ();
+
+				sb.Append ("Vector (");
+				sb.Append (id);
+				sb.Append (",");
+				sb.Append (Returns);
+				sb.Append (",");
+				sb.Append (Breaks);
+				if (parameters != null) {
+					sb.Append (" - ");
+					sb.Append (parameters);
+				}
+				sb.Append (" - ");
+				sb.Append (locals);
+				sb.Append (")");
+
+				return sb.ToString ();
+			}
+		}
+
+		FlowBranching (FlowBranchingType type, Location loc)
+		{
+			this.Siblings = new ArrayList ();
+			this.Block = null;
+			this.Location = loc;
+			this.Type = type;
+			id = ++next_id;
+		}
+
+		// <summary>
+		//   Creates a new flow branching for 'block'.
+		//   This is used from Block.Resolve to create the top-level branching of
+		//   the block.
+		// </summary>
+		public FlowBranching (Block block, InternalParameters ip, Location loc)
+			: this (FlowBranchingType.BLOCK, loc)
+		{
+			Block = block;
+			Parent = null;
+
+			int count = (ip != null) ? ip.Count : 0;
+
+			param_info = ip;
+			param_map = new int [count];
+			struct_params = new MyStructInfo [count];
+			num_params = 0;
+
+			for (int i = 0; i < count; i++) {
+				//Parameter.Modifier mod = param_info.ParameterModifier (i);
+
+			//	if ((mod & Parameter.Modifier.OUT) == 0)
+			//		continue;
+
+				param_map [i] = ++num_params;
+
+				Type param_type = param_info.ParameterType (i);
+
+				struct_params [i] = MyStructInfo.GetStructInfo (param_type);
+				if (struct_params [i] != null)
+					num_params += struct_params [i].Count;
+			}
+
+			Siblings = new ArrayList ();
+			Siblings.Add (new UsageVector (null, num_params, block.CountVariables));
+		}
+
+		// <summary>
+		//   Creates a new flow branching which is contained in 'parent'.
+		//   You should only pass non-null for the 'block' argument if this block
+		//   introduces any new variables - in this case, we need to create a new
+		//   usage vector with a different size than our parent's one.
+		// </summary>
+		public FlowBranching (FlowBranching parent, FlowBranchingType type,
+				      Block block, Location loc)
+			: this (type, loc)
+		{
+			Parent = parent;
+			Block = block;
+
+			if (parent != null) {
+				param_info = parent.param_info;
+				param_map = parent.param_map;
+				struct_params = parent.struct_params;
+				num_params = parent.num_params;
+			}
+
+			UsageVector vector;
+			if (Block != null)
+				vector = new UsageVector (parent.CurrentUsageVector, num_params,
+							  Block.CountVariables);
+			else
+				vector = new UsageVector (Parent.CurrentUsageVector);
+
+			Siblings.Add (vector);
+
+			switch (Type) {
+			case FlowBranchingType.EXCEPTION:
+				finally_vectors = new ArrayList ();
+				break;
+
+			default:
+				break;
+			}
+		}
+
+		// <summary>
+		//   Returns the branching's current usage vector.
+		// </summary>
+		public UsageVector CurrentUsageVector
+		{
+			get {
+				return (UsageVector) Siblings [Siblings.Count - 1];
+			}
+		}
+
+		// <summary>
+		//   Creates a sibling of the current usage vector.
+		// </summary>
+		public void CreateSibling ()
+		{
+			Siblings.Add (new UsageVector (Parent.CurrentUsageVector));
+
+			Report.Debug (1, "CREATED SIBLING", CurrentUsageVector);
+		}
+
+		// <summary>
+		//   Creates a sibling for a 'finally' block.
+		// </summary>
+		public void CreateSiblingForFinally ()
+		{
+			if (Type != FlowBranchingType.EXCEPTION)
+				throw new NotSupportedException ();
+
+			CreateSibling ();
+
+			CurrentUsageVector.MergeFinallyOrigins (finally_vectors);
+		}
+
+
+		// <summary>
+		//   Merge a child branching.
+		// </summary>
+		public FlowReturns MergeChild (FlowBranching child)
+		{
+			FlowReturns returns = CurrentUsageVector.MergeChildren (child, child.Siblings);
+
+			if (child.Type != FlowBranchingType.LOOP_BLOCK)
+				MayLeaveLoop |= child.MayLeaveLoop;
+			else
+				MayLeaveLoop = false;
+
+			return returns;
+ 		}
+ 
+		// <summary>
+		//   Does the toplevel merging.
+		// </summary>
+		public FlowReturns MergeTopBlock ()
+		{
+			if ((Type != FlowBranchingType.BLOCK) || (Block == null))
+				throw new NotSupportedException ();
+
+			UsageVector vector = new UsageVector (null, num_params, Block.CountVariables);
+
+			Report.Debug (1, "MERGING TOP BLOCK", Location, vector);
+
+			vector.MergeChildren (this, Siblings);
+
+			Siblings.Clear ();
+			Siblings.Add (vector);
+
+			Report.Debug (1, "MERGING TOP BLOCK DONE", Location, vector);
+
+			if (vector.Breaks != FlowReturns.EXCEPTION) {
+				return vector.AlwaysBreaks ? FlowReturns.ALWAYS : vector.Returns;
+			} else
+				return FlowReturns.EXCEPTION;
+		}
+
+		public bool InTryBlock ()
+		{
+			if (finally_vectors != null)
+				return true;
+			else if (Parent != null)
+				return Parent.InTryBlock ();
+			else
+				return false;
+		}
+
+		public void AddFinallyVector (UsageVector vector)
+		{
+			if (finally_vectors != null) {
+				finally_vectors.Add (vector.Clone ());
+				return;
+			}
+
+			if (Parent != null)
+				Parent.AddFinallyVector (vector);
+			else
+				throw new NotSupportedException ();
+		}
+
+		public bool IsVariableAssigned (VariableInfo vi)
+		{
+			if (CurrentUsageVector.AlwaysBreaks)
+				return true;
+			else
+				return CurrentUsageVector [vi, 0];
+		}
+
+		public bool IsVariableAssigned (VariableInfo vi, int field_idx)
+		{
+			if (CurrentUsageVector.AlwaysBreaks)
+				return true;
+			else
+				return CurrentUsageVector [vi, field_idx];
+		}
+
+		public void SetVariableAssigned (VariableInfo vi)
+		{
+			if (CurrentUsageVector.AlwaysBreaks)
+				return;
+
+			CurrentUsageVector [vi, 0] = true;
+		}
+
+		public void SetVariableAssigned (VariableInfo vi, int field_idx)
+		{
+			if (CurrentUsageVector.AlwaysBreaks)
+				return;
+
+			CurrentUsageVector [vi, field_idx] = true;
+		}
+
+		public bool IsParameterAssigned (int number)
+		{
+			int index = param_map [number];
+
+			if (index == 0)
+				return true;
+
+			if (CurrentUsageVector [index])
+				return true;
+
+			// Parameter is not assigned, so check whether it's a struct.
+			// If it's either not a struct or a struct which non-public
+			// fields, return false.
+			MyStructInfo struct_info = struct_params [number];
+			if ((struct_info == null) || struct_info.HasNonPublicFields)
+				return false;
+
+			// Ok, so each field must be assigned.
+			for (int i = 0; i < struct_info.Count; i++)
+				if (!CurrentUsageVector [index + i])
+					return false;
+
+			return true;
+		}
+
+		public bool IsParameterAssigned (int number, string field_name)
+		{
+			int index = param_map [number];
+
+			if (index == 0)
+				return true;
+
+			MyStructInfo info = (MyStructInfo) struct_params [number];
+			if (info == null)
+				return true;
+
+			int field_idx = info [field_name];
+
+			return CurrentUsageVector [index + field_idx];
+		}
+
+		public void SetParameterAssigned (int number)
+		{
+			if (param_map [number] == 0)
+				return;
+
+			if (!CurrentUsageVector.AlwaysBreaks)
+				CurrentUsageVector [param_map [number]] = true;
+		}
+
+		public void SetParameterAssigned (int number, string field_name)
+		{
+			int index = param_map [number];
+
+			if (index == 0)
+				return;
+
+			MyStructInfo info = (MyStructInfo) struct_params [number];
+			if (info == null)
+				return;
+
+			int field_idx = info [field_name];
+
+			if (!CurrentUsageVector.AlwaysBreaks)
+				CurrentUsageVector [index + field_idx] = true;
+		}
+
+		public bool IsReachable ()
+		{
+			bool reachable;
+
+			switch (Type) {
+			case FlowBranchingType.SWITCH_SECTION:
+				// The code following a switch block is reachable unless the switch
+				// block always returns.
+				reachable = !CurrentUsageVector.AlwaysReturns;
+				break;
+
+			case FlowBranchingType.LOOP_BLOCK:
+				// The code following a loop is reachable unless the loop always
+				// returns or it's an infinite loop without any 'break's in it.
+				reachable = !CurrentUsageVector.AlwaysReturns &&
+					(CurrentUsageVector.Breaks != FlowReturns.UNREACHABLE);
+				break;
+
+			default:
+				// The code following a block or exception is reachable unless the
+				// block either always returns or always breaks.
+				reachable = !CurrentUsageVector.AlwaysBreaks &&
+					!CurrentUsageVector.AlwaysReturns;
+				break;
+			}
+
+			Report.Debug (1, "REACHABLE", Type, CurrentUsageVector.Returns,
+				      CurrentUsageVector.Breaks, CurrentUsageVector, reachable);
+
+			return reachable;
+		}
+
+		public override string ToString ()
+		{
+			StringBuilder sb = new StringBuilder ("FlowBranching (");
+
+			sb.Append (id);
+			sb.Append (",");
+			sb.Append (Type);
+			if (Block != null) {
+				sb.Append (" - ");
+				sb.Append (Block.ID);
+				sb.Append (" - ");
+				sb.Append (Block.StartLocation);
+			}
+			sb.Append (" - ");
+			sb.Append (Siblings.Count);
+			sb.Append (" - ");
+			sb.Append (CurrentUsageVector);
+			sb.Append (")");
+			return sb.ToString ();
+		}
+	}
+
+	public class MyStructInfo {
+		public readonly Type Type;
+		public readonly FieldInfo[] Fields;
+		public readonly FieldInfo[] NonPublicFields;
+		public readonly int Count;
+		public readonly int CountNonPublic;
+		public readonly bool HasNonPublicFields;
+
+		private static Hashtable field_type_hash = new Hashtable ();
+		private Hashtable field_hash;
+
+		// Private constructor.  To save memory usage, we only need to create one instance
+		// of this class per struct type.
+		private MyStructInfo (Type type)
+		{
+			this.Type = type;
+
+			if (type is TypeBuilder) {
+				TypeContainer tc = TypeManager.LookupTypeContainer (type);
+
+				ArrayList fields = tc.Fields;
+				if (fields != null) {
+					foreach (Field field in fields) {
+						if ((field.ModFlags & Modifiers.STATIC) != 0)
+							continue;
+						if ((field.ModFlags & Modifiers.PUBLIC) != 0)
+							++Count;
+						else
+							++CountNonPublic;
+					}
+				}
+
+				Fields = new FieldInfo [Count];
+				NonPublicFields = new FieldInfo [CountNonPublic];
+
+				Count = CountNonPublic = 0;
+				if (fields != null) {
+					foreach (Field field in fields) {
+						if ((field.ModFlags & Modifiers.STATIC) != 0)
+							continue;
+						if ((field.ModFlags & Modifiers.PUBLIC) != 0)
+							Fields [Count++] = field.FieldBuilder;
+						else
+							NonPublicFields [CountNonPublic++] =
+								field.FieldBuilder;
+					}
+				}
+				
+			} else {
+				Fields = type.GetFields (BindingFlags.Instance|BindingFlags.Public);
+				Count = Fields.Length;
+
+				NonPublicFields = type.GetFields (BindingFlags.Instance|BindingFlags.NonPublic);
+				CountNonPublic = NonPublicFields.Length;
+			}
+
+			Count += NonPublicFields.Length;
+
+			int number = 0;
+			field_hash = new Hashtable ();
+			foreach (FieldInfo field in Fields)
+				field_hash.Add (field.Name, ++number);
+
+			if (NonPublicFields.Length != 0)
+				HasNonPublicFields = true;
+
+			foreach (FieldInfo field in NonPublicFields)
+				field_hash.Add (field.Name, ++number);
+		}
+
+		public int this [string name] {
+			get {
+				if (field_hash.Contains (name))
+					return (int) field_hash [name];
+				else
+					return 0;
+			}
+		}
+
+		public FieldInfo this [int index] {
+			get {
+				if (index >= Fields.Length)
+					return NonPublicFields [index - Fields.Length];
+				else
+					return Fields [index];
+			}
+		}		       
+
+		public static MyStructInfo GetStructInfo (Type type)
+		{
+			if (!TypeManager.IsValueType (type) || TypeManager.IsEnumType (type))
+				return null;
+
+			if (!(type is TypeBuilder) && TypeManager.IsBuiltinType (type))
+				return null;
+
+			MyStructInfo info = (MyStructInfo) field_type_hash [type];
+			if (info != null)
+				return info;
+
+			info = new MyStructInfo (type);
+			field_type_hash.Add (type, info);
+			return info;
+		}
+
+		public static MyStructInfo GetStructInfo (TypeContainer tc)
+		{
+			MyStructInfo info = (MyStructInfo) field_type_hash [tc.TypeBuilder];
+			if (info != null)
+				return info;
+
+			info = new MyStructInfo (tc.TypeBuilder);
+			field_type_hash.Add (tc.TypeBuilder, info);
+			return info;
+		}
+	}
+	
+	public class VariableInfo : IVariable {
+		public Expression Type;
+		public LocalBuilder LocalBuilder;
+		public Type VariableType;
+		public string Alias;
+		FieldBase FieldAlias;
+		public readonly string Name;
+		public readonly Location Location;
+		public readonly int Block;
+		
+		public int Number;
+		
+		public bool Used;
+		public bool Assigned;
+		public bool ReadOnly;
+		
+		public VariableInfo (Expression type, string name, int block, Location l, string Alias)
+			: this (type, name, block, l)
+		{
+			this.Alias = Alias;
+		}
+		
+		public VariableInfo (Expression type, string name, int block, Location l)
+		{
+			Type = type;
+			Name = name;
+			Block = block;
+			LocalBuilder = null;
+			Location = l;
+		}
+
+		public VariableInfo (TypeContainer tc, int block, Location l, string Alias)
+			: this (tc, block, l)
+		{
+			this.Alias = Alias;
+		}
+		
+		public VariableInfo (TypeContainer tc, int block, Location l)
+		{
+			VariableType = tc.TypeBuilder;
+			struct_info = MyStructInfo.GetStructInfo (tc);
+			Block = block;
+			LocalBuilder = null;
+			Location = l;
+		}
+
+		MyStructInfo struct_info;
+		public MyStructInfo StructInfo {
+			get {
+				return struct_info;
+			}
+		}
+
+		public bool IsAssigned (EmitContext ec, Location loc)
+		{/* FIXME: we shouldn't just skip this!!!
+			if (!ec.DoFlowAnalysis || ec.CurrentBranching.IsVariableAssigned (this))
+				return true;
+
+			MyStructInfo struct_info = StructInfo;
+			if ((struct_info == null) || (struct_info.HasNonPublicFields && (Name != null))) {
+				Report.Error (165, loc, "Use of unassigned local variable '" + Name + "'");
+				ec.CurrentBranching.SetVariableAssigned (this);
+				return false;
+			}
+
+			int count = struct_info.Count;
+
+			for (int i = 0; i < count; i++) {
+				if (!ec.CurrentBranching.IsVariableAssigned (this, i+1)) {
+					if (Name != null) {
+						Report.Error (165, loc,
+							      "Use of unassigned local variable '" +
+							      Name + "'");
+						ec.CurrentBranching.SetVariableAssigned (this);
+						return false;
+					}
+
+					FieldInfo field = struct_info [i];
+					Report.Error (171, loc,
+						      "Field '" + TypeManager.MonoBASIC_Name (VariableType) +
+						      "." + field.Name + "' must be fully initialized " +
+						      "before control leaves the constructor");
+					return false;
+				}
+			}
+*/
+			return true;
+		}
+
+		public bool IsFieldAssigned (EmitContext ec, string name, Location loc)
+		{
+			if (!ec.DoFlowAnalysis || ec.CurrentBranching.IsVariableAssigned (this) ||
+			    (struct_info == null))
+				return true;
+
+			int field_idx = StructInfo [name];
+			if (field_idx == 0)
+				return true;
+
+			if (!ec.CurrentBranching.IsVariableAssigned (this, field_idx)) {
+				Report.Error (170, loc,
+					      "Use of possibly unassigned field '" + name + "'");
+				ec.CurrentBranching.SetVariableAssigned (this, field_idx);
+				return false;
+			}
+
+			return true;
+		}
+
+		public void SetAssigned (EmitContext ec)
+		{
+			if (ec.DoFlowAnalysis)
+				ec.CurrentBranching.SetVariableAssigned (this);
+		}
+
+		public void SetFieldAssigned (EmitContext ec, string name)
+		{
+			if (ec.DoFlowAnalysis && (struct_info != null))
+				ec.CurrentBranching.SetVariableAssigned (this, StructInfo [name]);
+		}
+
+		public FieldBase GetFieldAlias (EmitContext ec)  {
+			if ( this.FieldAlias != null )
+				return this.FieldAlias;
+			else
+			{
+				ArrayList fields = ec.TypeContainer.Fields;
+                                for (int i = 0; i < fields.Count; i++) 
+				{
+                                	if (((Field) fields[i]).Name == this.Alias) 
+					{
+	                                	this.FieldAlias = (Field) fields[i];
+	                                	break;
+					}
+	                        }
+				return this.FieldAlias;
+		 	}
+		}
+		
+		public bool Resolve (DeclSpace decl)
+		{
+			if (struct_info != null)
+				return true;
+
+			if (VariableType == null)
+				VariableType = decl.ResolveType (Type, false, Location);
+
+			if (VariableType == null)
+				return false;
+
+			struct_info = MyStructInfo.GetStructInfo (VariableType);
+
+			return true;
+		}
+
+		public void MakePinned ()
+		{
+			TypeManager.MakePinned (LocalBuilder);
+		}
+
+		public override string ToString ()
+		{
+			return "VariableInfo (" + Number + "," + Type + "," + Location + ")";
+		}
+	}
+
+		
+	public class StatementSequence : Expression {
+		Block stmtBlock;
+		ArrayList args, originalArgs;
+		Expression expr;
+		bool isRetValRequired;
+		bool isLeftHandSide;
+		bool isIndexerAccess;
+		string memberName;
+		Expression type_expr;
+		bool is_resolved = false;
+
+		public StatementSequence (Block parent, Location loc, Expression expr) 
+			: this (parent, loc, expr, null)
+		{ }
+
+		public StatementSequence (Block parent, Location loc, Expression expr, string name, 
+					  Expression type_expr, ArrayList a, bool isRetValRequired,
+					  bool isLeftHandSide) 
+			: this (parent, loc, expr, a)
+		{
+			this.memberName = name;
+			this.type_expr = type_expr;
+			this.isRetValRequired = isRetValRequired;
+			this.isLeftHandSide = isLeftHandSide;
+		}
+
+		public StatementSequence (Block parent, Location loc, Expression expr, ArrayList a,
+					  bool isRetValRequired, bool isLeftHandSide) 
+			: this (parent, loc, expr, a)
+		{
+			this.isRetValRequired = isRetValRequired;
+			this.isLeftHandSide = isLeftHandSide;
+			if (expr is MemberAccess) {
+				this.expr = ((MemberAccess)expr).Expr;
+				this.memberName = ((MemberAccess)expr).Identifier;
+				this.isIndexerAccess = false;
+			} else if (expr is IndexerAccess) {
+				this.expr = ((IndexerAccess) expr).Instance;
+				this.memberName = "";
+				this.isIndexerAccess = true;
+			}
+		}
+
+		public StatementSequence (Block parent, Location loc, Expression expr, ArrayList a) 
+		{
+			stmtBlock = new Block (parent);
+			args = a;
+			originalArgs = new ArrayList ();
+			if (args != null) {
+				for (int index = 0; index < a.Count; index ++) {
+					Argument argument = (Argument) args [index];
+					originalArgs.Add (new Argument (argument.Expr, argument.ArgType));
+				}
+			}
+
+			this.expr = expr;
+			stmtBlock.IsLateBindingRequired = true;
+			this.loc = loc;
+			this.isRetValRequired = this.isLeftHandSide = false;
+			this.memberName = "";
+			this.type_expr = null;
+		}
+
+		public ArrayList Arguments {
+			get {
+				return args;
+			}
+			set {
+				args = value;
+			}
+		}
+
+		public bool IsLeftHandSide {
+			set {
+				isLeftHandSide = value;
+			}
+		}
+
+		public Block StmtBlock {
+			get {
+				return stmtBlock;
+			}
+		}
+		
+		public override Expression DoResolve (EmitContext ec)
+		{
+			if (is_resolved)
+				return this;
+			if (!stmtBlock.Resolve (ec))
+				return null;
+			eclass = ExprClass.Value;
+			type = TypeManager.object_type;
+			is_resolved = true;
+			return this;
+		}
+
+		public bool ResolveArguments (EmitContext ec) {
+		
+			bool argNamesFound = false;
+			if (Arguments != null)
+			{
+				for (int index = 0; index < Arguments.Count; index ++)
+				{
+					Argument a = (Argument) Arguments [index];
+					if (a.ParamName == null || a.ParamName == "") {
+						if (argNamesFound) {
+							Report.Error (30241, loc, "Named Argument expected");
+							return false;
+						}
+					} else
+						argNamesFound = true;
+					if (a.ArgType == Argument.AType.NoArg)
+						a = new Argument (Parser.DecomposeQI ("System.Reflection.Missing.Value", loc), Argument.AType.Expression);
+					if (!a.Resolve (ec, loc))
+						return false;				
+					Arguments [index] = a;
+				}
+			}
+			return true;
+		}
+			
+		public void GenerateLateBindingStatements ()
+		{
+			int argCount = 0;
+			ArrayList arrayInitializers = new ArrayList ();
+			ArrayList ArgumentNames = null;
+			if (args != null) {
+				//arrayInitializers = new ArrayList ();
+				argCount = args.Count;
+				for (int index = 0; index < args.Count; index ++) {
+					Argument a = (Argument) args [index];
+					Expression argument = a.Expr;
+					arrayInitializers.Add (argument);
+					if (a.ParamName != null && a.ParamName != "") {
+						if (ArgumentNames == null)
+							ArgumentNames = new ArrayList ();
+						ArgumentNames.Add (new StringLiteral (a.ParamName));
+					}
+				}
+			}
+
+			// __LateBindingArgs = new Object () {arg1, arg2 ...}
+			ArrayCreation new_expr = new ArrayCreation (Parser.DecomposeQI ("System.Object",  loc), "[]", arrayInitializers, loc);
+			Assign assign_stmt = null;
+
+			LocalVariableReference v1 = new LocalVariableReference (stmtBlock, Block.lateBindingArgs, loc);
+			assign_stmt = new Assign (v1, new_expr, loc);
+			stmtBlock.AddStatement (new StatementExpression ((ExpressionStatement) assign_stmt, loc));
+			// __LateBindingArgNames = new string () { argument names}
+			LocalVariableReference v2 = null;
+			if (ArgumentNames != null && ArgumentNames.Count > 0) {
+			 	new_expr = new ArrayCreation (Parser.DecomposeQI ("System.String",  loc), "[]", ArgumentNames, loc);
+				v2 = new LocalVariableReference (stmtBlock, Block.lateBindingArgNames, loc);
+				assign_stmt = new Assign (v2, new_expr, loc);
+				stmtBlock.AddStatement (new StatementExpression ((ExpressionStatement) assign_stmt, loc));
+			}
+
+			//string memName = "";
+			//bool isIndexerAccess = true;
+
+			ArrayList invocationArgs = new ArrayList ();
+			if (isIndexerAccess || memberName == "") {
+				invocationArgs.Add (new Argument (expr, Argument.AType.Expression));
+				invocationArgs.Add (new Argument (v1, Argument.AType.Expression));
+				invocationArgs.Add (new Argument (NullLiteral.Null, Argument.AType.Expression));
+				Expression tmp = null;
+				if (!isLeftHandSide)
+					tmp = Parser.DecomposeQI ("Microsoft.VisualBasic.CompilerServices.LateBinding.LateIndexGet", loc);
+				else
+					tmp = Parser.DecomposeQI ("Microsoft.VisualBasic.CompilerServices.LateBinding.LateIndexSet", loc);
+				Invocation invStmt = new Invocation (tmp, invocationArgs, Location.Null);
+				invStmt.IsLateBinding = true;
+				stmtBlock.AddStatement (new StatementExpression ((ExpressionStatement) invStmt, loc));
+				return;
+			}
+
+			if (expr != null)
+				invocationArgs.Add (new Argument (expr, Argument.AType.Expression));
+			else
+				invocationArgs.Add (new Argument (NullLiteral.Null, Argument.AType.Expression));
+			if (type_expr != null)
+				invocationArgs.Add (new Argument (type_expr, Argument.AType.Expression));
+			else
+				invocationArgs.Add (new Argument (NullLiteral.Null, Argument.AType.Expression));
+			invocationArgs.Add (new Argument (new StringLiteral (memberName), Argument.AType.Expression));
+			invocationArgs.Add (new Argument (v1, Argument.AType.Expression));
+			if (ArgumentNames != null && ArgumentNames.Count > 0)
+				invocationArgs.Add (new Argument (v2, Argument.AType.Expression));
+			else
+				invocationArgs.Add (new Argument (NullLiteral.Null, Argument.AType.Expression));
+
+			// __LateBindingCopyBack = new Boolean (no_of_args) {}
+			bool isCopyBackRequired = false;
+			if (!isLeftHandSide) {
+				for (int i = 0; i < argCount; i++) {
+					Argument origArg = (Argument) Arguments [i];
+					Expression origExpr = origArg.Expr; 
+					if (!(origExpr is Constant || origArg.ArgType == Argument.AType.NoArg)) 
+						isCopyBackRequired = true;
+				}
+			}
+
+			LocalVariableReference v3 = new LocalVariableReference (stmtBlock, Block.lateBindingCopyBack, loc);
+			if (isCopyBackRequired) {
+				ArrayList rank_specifier = new ArrayList ();
+				rank_specifier.Add (new IntLiteral (argCount));
+				arrayInitializers = new ArrayList ();
+				for (int i = 0; i < argCount; i++) {
+					Argument a = (Argument) Arguments [i];
+					Expression origExpr = a.Expr;
+					if (origExpr is Constant || a.ArgType == Argument.AType.NoArg || origExpr is New)
+						arrayInitializers.Add (new BoolLiteral (false));
+					else 
+						arrayInitializers.Add (new BoolLiteral (true));
+				}
+	
+				new_expr = new ArrayCreation (Parser.DecomposeQI ("System.Boolean",  loc), "[]", arrayInitializers, loc);
+				assign_stmt = new Assign (v3, new_expr, loc);
+				stmtBlock.AddStatement (new StatementExpression ((ExpressionStatement) assign_stmt, loc));
+				invocationArgs.Add (new Argument (v3, Argument.AType.Expression));
+			} else if (! isLeftHandSide) {
+				invocationArgs.Add (new Argument (NullLiteral.Null, Argument.AType.Expression));
+			}
+
+			Expression etmp = null;
+			if (isLeftHandSide) {
+				// LateSet
+				etmp = Parser.DecomposeQI ("Microsoft.VisualBasic.CompilerServices.LateBinding.LateSet", loc);
+			} else if (isRetValRequired) {
+				// Late Get
+				etmp = Parser.DecomposeQI ("Microsoft.VisualBasic.CompilerServices.LateBinding.LateGet", loc);
+			}  else {
+				etmp = Parser.DecomposeQI ("Microsoft.VisualBasic.CompilerServices.LateBinding.LateCall", loc);
+			}
+
+			Invocation inv_stmt = new Invocation (etmp, invocationArgs, Location.Null);
+			inv_stmt.IsLateBinding = true;
+			stmtBlock.AddStatement (new StatementExpression ((ExpressionStatement) inv_stmt, loc));
+
+			if (! isCopyBackRequired)
+				return;
+
+			for (int i = argCount - 1; i >= 0; i --) {
+				Argument arg = (Argument) originalArgs [i];
+				Expression origExpr = (Expression) arg.Expr;
+				if (arg.ArgType == Argument.AType.NoArg)
+					continue;
+				if (origExpr is Constant)
+					continue;
+				if (origExpr is New)
+					continue;
+
+				Expression intExpr = new IntLiteral (i);
+				ArrayList argsLocal = new ArrayList ();
+				argsLocal.Add (new Argument (intExpr, Argument.AType.Expression));
+				Expression indexExpr = new Invocation (new SimpleName (Block.lateBindingCopyBack, loc), argsLocal, loc);
+				Expression value = new Invocation (new SimpleName (Block.lateBindingArgs, loc), argsLocal, loc);
+				assign_stmt = new Assign (origExpr, value,  loc);
+				Expression boolExpr = new Binary (Binary.Operator.Inequality, indexExpr, new BoolLiteral (false), loc);
+				Statement ifStmt = new If (boolExpr, new StatementExpression ((ExpressionStatement) assign_stmt, loc), loc);
+				stmtBlock.AddStatement (ifStmt);
+			}
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			stmtBlock.Emit (ec);
+		}
+	}
+
+	public class SwitchLabel {
+		public enum LabelType : byte {
+			Operator, Range, Label, Else
+		}
+
+		Expression label, start, end;
+		LabelType label_type;
+		Expression label_condition, start_condition, end_condition;
+		Binary.Operator oper;
+		public Location loc;
+		public Label ILLabel;
+		public Label ILLabelCode;
+
+		//
+		// if expr == null, then it is the default case.
+		//
+		public SwitchLabel (Expression start, Expression end, LabelType ltype, Binary.Operator oper, Location l) {
+			this.start = start;
+			this.end = end;
+			this.label_type = ltype;
+			this.oper = oper;
+			this.loc = l;
+			label_condition = start_condition = end_condition = null;
+		}
+
+		public SwitchLabel (Expression expr, LabelType ltype, Binary.Operator oper, Location l)
+		{
+			label = expr;
+			start = end = null;
+			label_condition = start_condition = end_condition = null;
+			loc = l;
+			this.label_type = ltype;
+			this.oper = oper;
+		}
+
+		public Expression Label {
+			get {
+				return label;
+			}
+		}
+
+		public LabelType Type {
+			get {
+				return label_type;
+			}
+		}
+
+		public Expression ConditionStart {
+			get {
+				return start_condition;
+			}
+		}
+
+		public Expression ConditionEnd {
+			get {
+				return end_condition;
+			}
+		}
+
+		public Expression ConditionLabel {
+			get {
+				return label_condition;
+			}
+		}
+
+		//
+		// Resolves the expression, reduces it to a literal if possible
+		// and then converts it to the requested type.
+		//
+		public bool ResolveAndReduce (EmitContext ec, Expression expr)
+		{
+			ILLabel = ec.ig.DefineLabel ();
+			ILLabelCode = ec.ig.DefineLabel ();
+
+			Expression e = null;
+			switch (label_type) {
+			case LabelType.Label :
+				if (label == null)
+					return false;
+				e = label.Resolve (ec);
+				if (e != null)
+					e = Expression.ConvertImplicit (ec, e, expr.Type, loc);
+				if (e == null)
+					return false;
+				label_condition = new Binary (Binary.Operator.Equality, expr, e, loc);
+				if ((label_condition = label_condition.DoResolve (ec)) == null)
+					return false;
+				return true;
+			case LabelType.Operator :
+				e = label.Resolve (ec);
+				label_condition = new Binary (oper, expr, e, loc);
+				if ((label_condition = label_condition.DoResolve (ec)) == null)
+					return false;
+				return true;
+			case LabelType.Range :
+				if (start == null || end == null)
+					return false;
+				e = start.Resolve (ec);
+				if (e != null)
+					e = Expression.ConvertImplicit (ec, e, expr.Type, loc);
+				if (e == null)
+					return false;
+				start_condition = new Binary (Binary.Operator.GreaterThanOrEqual, expr, e, loc);
+				start_condition = start_condition.Resolve (ec);
+				e = end.Resolve (ec);
+				if (e != null)
+					e = Expression.ConvertImplicit (ec, e, expr.Type, loc);
+				if (e == null)
+					return false;
+				end_condition = new Binary (Binary.Operator.LessThanOrEqual, expr, e, loc);
+				end_condition = end_condition.Resolve (ec);
+				if (start_condition == null || end_condition == null)
+					return false;
+				return true;
+
+			case LabelType.Else :
+				break;
+			}
+			return true;
+		}
+	}
+
+	public class SwitchSection {
+		// An array of SwitchLabels.
+		public readonly ArrayList Labels;
+		public readonly Block Block;
+		
+		public SwitchSection (ArrayList labels, Block block)
+		{
+			Labels = labels;
+			Block = block;
+		}
+	}
+	
+	public class Switch : Statement {
+		public readonly ArrayList Sections;
+		public Expression Expr;
+
+		/// <summary>
+		///   Maps constants whose type type SwitchType to their  SwitchLabels.
+		/// </summary>
+		public Hashtable Elements;
+
+		/// <summary>
+		///   The governing switch type
+		/// </summary>
+		public Type SwitchType;
+
+		//
+		// Computed
+		//
+		bool got_default;
+		Label default_target;
+		Expression new_expr;
+
+		//
+		// The types allowed to be implicitly cast from
+		// on the governing type
+		//
+		//static Type [] allowed_types;
+		
+		public Switch (Expression e, ArrayList sects, Location l)
+		{
+			Expr = e;
+			Sections = sects;
+			loc = l;
+		}
+
+		public bool GotDefault {
+			get {
+				return got_default;
+			}
+		}
+
+		public Label DefaultTarget {
+			get {
+				return default_target;
+			}
+		}
+
+		//
+		// Determines the governing type for a switch.  The returned
+		// expression might be the expression from the switch, or an
+		// expression that includes any potential conversions to the
+		// integral types or to string.
+		//
+		Expression SwitchGoverningType (EmitContext ec, Type t)
+		{
+			if (t == TypeManager.byte_type ||
+			    t == TypeManager.short_type ||
+			    t == TypeManager.int32_type ||
+			    t == TypeManager.int64_type ||
+			    t == TypeManager.decimal_type ||
+			    t == TypeManager.float_type ||
+			    t == TypeManager.double_type ||
+			    t == TypeManager.date_type ||
+			    t == TypeManager.char_type ||
+			    t == TypeManager.object_type ||
+			    t == TypeManager.string_type ||
+				t == TypeManager.bool_type ||
+				t.IsSubclassOf (TypeManager.enum_type))
+				return Expr;
+/*
+			if (allowed_types == null){
+				allowed_types = new Type [] {
+					TypeManager.sbyte_type,
+					TypeManager.byte_type,
+					TypeManager.short_type,
+					TypeManager.ushort_type,
+					TypeManager.int32_type,
+					TypeManager.uint32_type,
+					TypeManager.int64_type,
+					TypeManager.uint64_type,
+					TypeManager.char_type,
+					TypeManager.bool_type,
+					TypeManager.string_type
+				};
+			}
+
+			//
+			// Try to find a *user* defined implicit conversion.
+			//
+			// If there is no implicit conversion, or if there are multiple
+			// conversions, we have to report an error
+			//
+			Expression converted = null;
+			foreach (Type tt in allowed_types){
+				Expression e;
+				
+				e = Expression.ImplicitUserConversion (ec, Expr, tt, loc);
+				if (e == null)
+					continue;
+
+				if (converted != null){
+					Report.Error (-12, loc, "More than one conversion to an integral " +
+						      " type exists for type '" +
+						      TypeManager.MonoBASIC_Name (Expr.Type)+"'");
+					return null;
+				} else
+					converted = e;
+			}
+			return converted;
+*/
+			return null;
+		}
+
+		void error152 (string n)
+		{
+			Report.Error (
+				152, "The label '" + n + ":' " +
+				"is already present on this switch statement");
+		}
+		
+		//
+		// Performs the basic sanity checks on the switch statement
+		// (looks for duplicate keys and non-constant expressions).
+		//
+		// It also returns a hashtable with the keys that we will later
+		// use to compute the switch tables
+		//
+		bool CheckSwitch (EmitContext ec)
+		{
+			//Type compare_type;
+			bool error = false;
+			Elements = new CaseInsensitiveHashtable ();
+				
+			got_default = false;
+
+/*
+			if (TypeManager.IsEnumType (SwitchType)){
+				compare_type = TypeManager.EnumToUnderlying (SwitchType);
+			} else
+				compare_type = SwitchType;
+*/
+			
+			for (int secIndex = 0; secIndex < Sections.Count; secIndex ++) {
+				SwitchSection ss = (SwitchSection) Sections [secIndex];
+				for (int labelIndex = 0; labelIndex < ss.Labels.Count; labelIndex ++) {
+					SwitchLabel sl  = (SwitchLabel) ss.Labels [labelIndex];
+					if (!sl.ResolveAndReduce (ec, Expr)){
+						error = true;
+						continue;
+					}
+
+					if (sl.Type == SwitchLabel.LabelType.Else){
+						if (got_default){
+							error152 ("default");
+							error = true;
+						}
+						got_default = true;
+						continue;
+					}
+				}
+			}
+			if (error)
+				return false;
+			
+			return true;
+		}
+
+		void EmitObjectInteger (ILGenerator ig, object k)
+		{
+			if (k is int)
+				IntConstant.EmitInt (ig, (int) k);
+			else if (k is Constant) {
+				EmitObjectInteger (ig, ((Constant) k).GetValue ());
+			} 
+			else if (k is uint)
+				IntConstant.EmitInt (ig, unchecked ((int) (uint) k));
+			else if (k is long)
+			{
+				if ((long) k >= int.MinValue && (long) k <= int.MaxValue)
+				{
+					IntConstant.EmitInt (ig, (int) (long) k);
+					ig.Emit (OpCodes.Conv_I8);
+				}
+				else
+					LongConstant.EmitLong (ig, (long) k);
+			}
+			else if (k is ulong)
+			{
+				if ((ulong) k < (1L<<32))
+				{
+					IntConstant.EmitInt (ig, (int) (long) k);
+					ig.Emit (OpCodes.Conv_U8);
+				}
+				else
+				{
+					LongConstant.EmitLong (ig, unchecked ((long) (ulong) k));
+				}
+			}
+			else if (k is char)
+				IntConstant.EmitInt (ig, (int) ((char) k));
+			else if (k is sbyte)
+				IntConstant.EmitInt (ig, (int) ((sbyte) k));
+			else if (k is byte)
+				IntConstant.EmitInt (ig, (int) ((byte) k));
+			else if (k is short)
+				IntConstant.EmitInt (ig, (int) ((short) k));
+			else if (k is ushort)
+				IntConstant.EmitInt (ig, (int) ((ushort) k));
+			else if (k is bool)
+				IntConstant.EmitInt (ig, ((bool) k) ? 1 : 0);
+			else
+				throw new Exception ("Unhandled case");
+		}
+		
+		// structure used to hold blocks of keys while calculating table switch
+		class KeyBlock : IComparable
+		{
+			public KeyBlock (long _nFirst)
+			{
+				nFirst = nLast = _nFirst;
+			}
+			public long nFirst;
+			public long nLast;
+			public ArrayList rgKeys = null;
+			public int Length
+			{
+				get { return (int) (nLast - nFirst + 1); }
+			}
+			public static long TotalLength (KeyBlock kbFirst, KeyBlock kbLast)
+			{
+				return kbLast.nLast - kbFirst.nFirst + 1;
+			}
+			public int CompareTo (object obj)
+			{
+				KeyBlock kb = (KeyBlock) obj;
+				int nLength = Length;
+				int nLengthOther = kb.Length;
+				if (nLengthOther == nLength)
+					return (int) (kb.nFirst - nFirst);
+				return nLength - nLengthOther;
+			}
+		}
+
+/*
+		/// <summary>
+		/// This method emits code for a lookup-based switch statement (non-string)
+		/// Basically it groups the cases into blocks that are at least half full,
+		/// and then spits out individual lookup opcodes for each block.
+		/// It emits the longest blocks first, and short blocks are just
+		/// handled with direct compares.
+		/// </summary>
+		/// <param name="ec"></param>
+		/// <param name="val"></param>
+		/// <returns></returns>
+		bool TableSwitchEmit (EmitContext ec, LocalBuilder val)
+		{
+			int cElements = Elements.Count;
+			object [] rgKeys = new object [cElements];
+			Elements.Keys.CopyTo (rgKeys, 0);
+			Array.Sort (rgKeys);
+
+			// initialize the block list with one element per key
+			ArrayList rgKeyBlocks = new ArrayList ();
+			foreach (object key in rgKeys)
+				rgKeyBlocks.Add (new KeyBlock (Convert.ToInt64 (key)));
+
+			KeyBlock kbCurr;
+			// iteratively merge the blocks while they are at least half full
+			// there's probably a really cool way to do this with a tree...
+			while (rgKeyBlocks.Count > 1)
+			{
+				ArrayList rgKeyBlocksNew = new ArrayList ();
+				kbCurr = (KeyBlock) rgKeyBlocks [0];
+				for (int ikb = 1; ikb < rgKeyBlocks.Count; ikb++)
+				{
+					KeyBlock kb = (KeyBlock) rgKeyBlocks [ikb];
+					if ((kbCurr.Length + kb.Length) * 2 >=  KeyBlock.TotalLength (kbCurr, kb))
+					{
+						// merge blocks
+						kbCurr.nLast = kb.nLast;
+					}
+					else
+					{
+						// start a new block
+						rgKeyBlocksNew.Add (kbCurr);
+						kbCurr = kb;
+					}
+				}
+				rgKeyBlocksNew.Add (kbCurr);
+				if (rgKeyBlocks.Count == rgKeyBlocksNew.Count)
+					break;
+				rgKeyBlocks = rgKeyBlocksNew;
+			}
+
+			// initialize the key lists
+			foreach (KeyBlock kb in rgKeyBlocks)
+				kb.rgKeys = new ArrayList ();
+
+			// fill the key lists
+			int iBlockCurr = 0;
+			if (rgKeyBlocks.Count > 0) {
+				kbCurr = (KeyBlock) rgKeyBlocks [0];
+				foreach (object key in rgKeys)
+				{
+					bool fNextBlock = (key is UInt64) ? (ulong) key > (ulong) kbCurr.nLast : Convert.ToInt64 (key) > kbCurr.nLast;
+					if (fNextBlock)
+						kbCurr = (KeyBlock) rgKeyBlocks [++iBlockCurr];
+					kbCurr.rgKeys.Add (key);
+				}
+			}
+
+			// sort the blocks so we can tackle the largest ones first
+			rgKeyBlocks.Sort ();
+
+			// okay now we can start...
+			ILGenerator ig = ec.ig;
+			Label lblEnd = ig.DefineLabel ();	// at the end ;-)
+			Label lblDefault = ig.DefineLabel ();
+
+			Type typeKeys = null;
+			if (rgKeys.Length > 0)
+				typeKeys = rgKeys [0].GetType ();	// used for conversions
+
+			for (int iBlock = rgKeyBlocks.Count - 1; iBlock >= 0; --iBlock)
+			{
+				KeyBlock kb = ((KeyBlock) rgKeyBlocks [iBlock]);
+				lblDefault = (iBlock == 0) ? DefaultTarget : ig.DefineLabel ();
+				if (kb.Length <= 2)
+				{
+					foreach (object key in kb.rgKeys)
+					{
+						ig.Emit (OpCodes.Ldloc, val);
+						EmitObjectInteger (ig, key);
+						SwitchLabel sl = (SwitchLabel) Elements [key];
+						ig.Emit (OpCodes.Beq, sl.ILLabel);
+					}
+				}
+				else
+				{
+					// TODO: if all the keys in the block are the same and there are
+					//       no gaps/defaults then just use a range-check.
+					if (SwitchType == TypeManager.int64_type ||
+						SwitchType == TypeManager.uint64_type)
+					{
+						// TODO: optimize constant/I4 cases
+
+						// check block range (could be > 2^31)
+						ig.Emit (OpCodes.Ldloc, val);
+						EmitObjectInteger (ig, Convert.ChangeType (kb.nFirst, typeKeys));
+						ig.Emit (OpCodes.Blt, lblDefault);
+						ig.Emit (OpCodes.Ldloc, val);
+						EmitObjectInteger (ig, Convert.ChangeType (kb.nFirst, typeKeys));
+						ig.Emit (OpCodes.Bgt, lblDefault);
+
+						// normalize range
+						ig.Emit (OpCodes.Ldloc, val);
+						if (kb.nFirst != 0)
+						{
+							EmitObjectInteger (ig, Convert.ChangeType (kb.nFirst, typeKeys));
+							ig.Emit (OpCodes.Sub);
+						}
+						ig.Emit (OpCodes.Conv_I4);	// assumes < 2^31 labels!
+					}
+					else
+					{
+						// normalize range
+						ig.Emit (OpCodes.Ldloc, val);
+						int nFirst = (int) kb.nFirst;
+						if (nFirst > 0)
+						{
+							IntConstant.EmitInt (ig, nFirst);
+							ig.Emit (OpCodes.Sub);
+						}
+						else if (nFirst < 0)
+						{
+							IntConstant.EmitInt (ig, -nFirst);
+							ig.Emit (OpCodes.Add);
+						}
+					}
+
+					// first, build the list of labels for the switch
+					int iKey = 0;
+					int cJumps = kb.Length;
+					Label [] rgLabels = new Label [cJumps];
+					for (int iJump = 0; iJump < cJumps; iJump++)
+					{
+						object key = kb.rgKeys [iKey];
+						if (Convert.ToInt64 (key) == kb.nFirst + iJump)
+						{
+							SwitchLabel sl = (SwitchLabel) Elements [key];
+							rgLabels [iJump] = sl.ILLabel;
+							iKey++;
+						}
+						else
+							rgLabels [iJump] = lblDefault;
+					}
+					// emit the switch opcode
+					ig.Emit (OpCodes.Switch, rgLabels);
+				}
+
+				// mark the default for this block
+				if (iBlock != 0)
+					ig.MarkLabel (lblDefault);
+			}
+
+			// TODO: find the default case and emit it here,
+			//       to prevent having to do the following jump.
+			//       make sure to mark other labels in the default section
+
+			// the last default just goes to the end
+			ig.Emit (OpCodes.Br, lblDefault);
+
+			// now emit the code for the sections
+			bool fFoundDefault = false;
+			bool fAllReturn = true;
+			foreach (SwitchSection ss in Sections)
+			{
+				foreach (SwitchLabel sl in ss.Labels)
+				{
+					ig.MarkLabel (sl.ILLabel);
+					ig.MarkLabel (sl.ILLabelCode);
+					if (sl.Label == null)
+					{
+						ig.MarkLabel (lblDefault);
+						fFoundDefault = true;
+					}
+				}
+				bool returns = ss.Block.Emit (ec);
+				fAllReturn &= returns;
+				//ig.Emit (OpCodes.Br, lblEnd);
+			}
+			
+			if (!fFoundDefault) {
+				ig.MarkLabel (lblDefault);
+				fAllReturn = false;
+			}
+			ig.MarkLabel (lblEnd);
+
+			return fAllReturn;
+		}
+		//
+		// This simple emit switch works, but does not take advantage of the
+		// 'switch' opcode. 
+		// TODO: remove non-string logic from here
+		// TODO: binary search strings?
+		//
+		bool SimpleSwitchEmit (EmitContext ec, LocalBuilder val)
+		{
+			ILGenerator ig = ec.ig;
+			Label end_of_switch = ig.DefineLabel ();
+			Label next_test = ig.DefineLabel ();
+			Label null_target = ig.DefineLabel ();
+			bool default_found = false;
+			bool first_test = true;
+			bool pending_goto_end = false;
+			bool all_return = true;
+			bool is_string = false;
+			bool null_found;
+			
+			//
+			// Special processing for strings: we cant compare
+			// against null.
+			//
+			if (SwitchType == TypeManager.string_type){
+				ig.Emit (OpCodes.Ldloc, val);
+				is_string = true;
+				
+				if (Elements.Contains (NullLiteral.Null)){
+					ig.Emit (OpCodes.Brfalse, null_target);
+				} else
+					ig.Emit (OpCodes.Brfalse, default_target);
+
+				ig.Emit (OpCodes.Ldloc, val);
+				ig.Emit (OpCodes.Call, TypeManager.string_isinterneted_string);
+				ig.Emit (OpCodes.Stloc, val);
+			}
+			
+			foreach (SwitchSection ss in Sections){
+				Label sec_begin = ig.DefineLabel ();
+
+				if (pending_goto_end)
+					ig.Emit (OpCodes.Br, end_of_switch);
+
+				int label_count = ss.Labels.Count;
+				null_found = false;
+				foreach (SwitchLabel sl in ss.Labels){
+					ig.MarkLabel (sl.ILLabel);
+					
+					if (!first_test){
+						ig.MarkLabel (next_test);
+						next_test = ig.DefineLabel ();
+					}
+					//
+					// If we are the default target
+					//
+					if (sl.Label == null){
+						ig.MarkLabel (default_target);
+						default_found = true;
+					} else {
+						object lit = sl.Converted;
+
+						if (lit is NullLiteral){
+							null_found = true;
+							if (label_count == 1)
+								ig.Emit (OpCodes.Br, next_test);
+							continue;
+									      
+						}
+						if (is_string){
+							StringConstant str = (StringConstant) lit;
+
+							ig.Emit (OpCodes.Ldloc, val);
+							ig.Emit (OpCodes.Ldstr, str.Value);
+							if (label_count == 1)
+								ig.Emit (OpCodes.Bne_Un, next_test);
+							else
+								ig.Emit (OpCodes.Beq, sec_begin);
+						} else {
+							ig.Emit (OpCodes.Ldloc, val);
+							EmitObjectInteger (ig, lit);
+							ig.Emit (OpCodes.Ceq);
+							if (label_count == 1)
+								ig.Emit (OpCodes.Brfalse, next_test);
+							else
+								ig.Emit (OpCodes.Brtrue, sec_begin);
+						}
+					}
+				}
+				if (label_count != 1)
+					ig.Emit (OpCodes.Br, next_test);
+				
+				if (null_found)
+					ig.MarkLabel (null_target);
+				ig.MarkLabel (sec_begin);
+				foreach (SwitchLabel sl in ss.Labels)
+					ig.MarkLabel (sl.ILLabelCode);
+
+				bool returns = ss.Block.Emit (ec);
+				if (returns)
+					pending_goto_end = false;
+				else {
+					all_return = false;
+					pending_goto_end = true;
+				}
+				first_test = false;
+			}
+			if (!default_found){
+				ig.MarkLabel (default_target);
+				all_return = false;
+			}
+			ig.MarkLabel (next_test);
+			ig.MarkLabel (end_of_switch);
+			
+			return all_return;
+		}
+*/
+
+		public override bool Resolve (EmitContext ec)
+		{
+			Expr = Expr.Resolve (ec);
+			if (Expr == null)
+				return false;
+
+			new_expr = SwitchGoverningType (ec, Expr.Type);
+			if (new_expr == null){
+				Report.Error (30338, loc, "'Select' expression cannot be of type '" + Expr.Type +"'");
+				return false;
+			}
+
+			// Validate switch.
+			SwitchType = new_expr.Type;
+
+			if (!CheckSwitch (ec))
+				return false;
+
+			Switch old_switch = ec.Switch;
+			ec.Switch = this;
+			ec.Switch.SwitchType = SwitchType;
+
+			ec.StartFlowBranching (FlowBranchingType.SWITCH, loc);
+
+			bool first = true;
+			foreach (SwitchSection ss in Sections){
+				if (!first)
+					ec.CurrentBranching.CreateSibling ();
+				else
+					first = false;
+
+				if (ss.Block.Resolve (ec) != true)
+					return false;
+			}
+
+
+			if (!got_default)
+				ec.CurrentBranching.CreateSibling ();
+
+			ec.EndFlowBranching ();
+			ec.Switch = old_switch;
+
+			return true;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			//
+			// Setup the codegen context
+			//
+			Label old_end = ec.LoopEnd;
+			Switch old_switch = ec.Switch;
+			
+			ec.LoopEnd = ig.DefineLabel ();
+			ec.Switch = this;
+
+			for (int secIndex = 0; secIndex < Sections.Count; secIndex ++) {
+				SwitchSection section = (SwitchSection) Sections [secIndex];
+				Label sLabel = ig.DefineLabel ();
+				Label lLabel = ig.DefineLabel ();
+				ArrayList Labels = section.Labels;
+				for (int labelIndex = 0; labelIndex < Labels.Count; labelIndex ++) {
+					SwitchLabel sl = (SwitchLabel) Labels [labelIndex];
+					switch (sl.Type) {
+					case SwitchLabel.LabelType.Range :
+						if (labelIndex + 1 == Labels.Count) {
+							EmitBoolExpression (ec, sl.ConditionStart, sLabel, false);
+							EmitBoolExpression (ec, sl.ConditionEnd, sLabel, false);
+							ig.Emit (OpCodes.Br, lLabel);
+						} else {
+							Label newLabel = ig.DefineLabel ();
+							EmitBoolExpression (ec, sl.ConditionStart, newLabel, false);
+							EmitBoolExpression (ec, sl.ConditionEnd, newLabel, false);
+							ig.Emit (OpCodes.Br, lLabel);
+							ig.MarkLabel (newLabel);
+						}
+						break;
+					case SwitchLabel.LabelType.Else :
+						// Nothing to be done here
+						break;
+					case SwitchLabel.LabelType.Operator :
+						EmitBoolExpression (ec, sl.ConditionLabel, lLabel, true);
+						if (labelIndex + 1 == Labels.Count)
+							ig.Emit (OpCodes.Br, sLabel);
+						break;
+					case SwitchLabel.LabelType.Label :
+						EmitBoolExpression (ec, sl.ConditionLabel, lLabel, true);
+						if (labelIndex + 1 == Labels.Count)
+							ig.Emit (OpCodes.Br, sLabel);
+						break;
+					}
+
+				}
+				ig.MarkLabel (lLabel);
+				section.Block.Emit (ec);
+				ig.MarkLabel (sLabel);
+			}
+
+			// Restore context state. 
+			ig.MarkLabel (ec.LoopEnd);
+
+			//
+			// Restore the previous context
+			//
+			ec.LoopEnd = old_end;
+			ec.Switch = old_switch;
+			return true;
+		}
+	}
+
+	public class Lock : Statement {
+		Expression expr;
+		Statement Statement;
+			
+		public Lock (Expression expr, Statement stmt, Location l)
+		{
+			this.expr = expr;
+			Statement = stmt;
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			expr = expr.Resolve (ec);
+			return Statement.Resolve (ec) && expr != null;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			Type type = expr.Type;
+			bool val;
+			
+			if (type.IsValueType){
+				Report.Error (30582, loc, "lock statement requires the expression to be " +
+					      " a reference type (type is: '" +
+					      TypeManager.MonoBASIC_Name (type) + "'");
+				return false;
+			}
+
+			ILGenerator ig = ec.ig;
+			LocalBuilder temp = ig.DeclareLocal (type);
+				
+			expr.Emit (ec);
+			ig.Emit (OpCodes.Dup);
+			ig.Emit (OpCodes.Stloc, temp);
+			ig.Emit (OpCodes.Call, TypeManager.void_monitor_enter_object);
+
+			// try
+			ig.BeginExceptionBlock ();
+			bool old_in_try = ec.InTry;
+			ec.InTry = true;
+			Label finish = ig.DefineLabel ();
+			val = Statement.Emit (ec);
+			ec.InTry = old_in_try;
+			// ig.Emit (OpCodes.Leave, finish);
+
+			ig.MarkLabel (finish);
+			
+			// finally
+			ig.BeginFinallyBlock ();
+			ig.Emit (OpCodes.Ldloc, temp);
+			ig.Emit (OpCodes.Call, TypeManager.void_monitor_exit_object);
+			ig.EndExceptionBlock ();
+			
+			return val;
+		}
+	}
+
+	public class Unchecked : Statement {
+		public readonly Block Block;
+		
+		public Unchecked (Block b)
+		{
+			Block = b;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			return Block.Resolve (ec);
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			bool previous_state = ec.CheckState;
+			bool previous_state_const = ec.ConstantCheckState;
+			bool val;
+			
+			ec.CheckState = false;
+			ec.ConstantCheckState = false;
+			val = Block.Emit (ec);
+			ec.CheckState = previous_state;
+			ec.ConstantCheckState = previous_state_const;
+
+			return val;
+		}
+	}
+
+	public class Checked : Statement {
+		public readonly Block Block;
+		
+		public Checked (Block b)
+		{
+			Block = b;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			bool previous_state = ec.CheckState;
+			bool previous_state_const = ec.ConstantCheckState;
+			
+			ec.CheckState = true;
+			ec.ConstantCheckState = true;
+			bool ret = Block.Resolve (ec);
+			ec.CheckState = previous_state;
+			ec.ConstantCheckState = previous_state_const;
+
+			return ret;
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			bool previous_state = ec.CheckState;
+			bool previous_state_const = ec.ConstantCheckState;
+			bool val;
+			
+			ec.CheckState = true;
+			ec.ConstantCheckState = true;
+			val = Block.Emit (ec);
+			ec.CheckState = previous_state;
+			ec.ConstantCheckState = previous_state_const;
+
+			return val;
+		}
+	}
+
+	public class Unsafe : Statement {
+		public readonly Block Block;
+
+		public Unsafe (Block b)
+		{
+			Block = b;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			bool previous_state = ec.InUnsafe;
+			bool val;
+			
+			ec.InUnsafe = true;
+			val = Block.Resolve (ec);
+			ec.InUnsafe = previous_state;
+
+			return val;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			bool previous_state = ec.InUnsafe;
+			bool val;
+			
+			ec.InUnsafe = true;
+			val = Block.Emit (ec);
+			ec.InUnsafe = previous_state;
+
+			return val;
+		}
+	}
+
+	// 
+	// Fixed statement
+	//
+	public class Fixed : Statement {
+		Expression type;
+		ArrayList declarators;
+		Statement statement;
+		Type expr_type;
+		FixedData[] data;
+
+		struct FixedData {
+			public bool is_object;
+			public VariableInfo vi;
+			public Expression expr;
+			public Expression converted;
+		}			
+
+		public Fixed (Expression type, ArrayList decls, Statement stmt, Location l)
+		{
+			this.type = type;
+			declarators = decls;
+			statement = stmt;
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			expr_type = ec.DeclSpace.ResolveType (type, false, loc);
+			if (expr_type == null)
+				return false;
+
+			data = new FixedData [declarators.Count];
+
+			int i = 0;
+			foreach (Pair p in declarators){
+				VariableInfo vi = (VariableInfo) p.First;
+				Expression e = (Expression) p.Second;
+
+				vi.Number = -1;
+
+				//
+				// The rules for the possible declarators are pretty wise,
+				// but the production on the grammar is more concise.
+				//
+				// So we have to enforce these rules here.
+				//
+				// We do not resolve before doing the case 1 test,
+				// because the grammar is explicit in that the token &
+				// is present, so we need to test for this particular case.
+				//
+
+				//
+				// Case 1: & object.
+				//
+				if (e is Unary && ((Unary) e).Oper == Unary.Operator.AddressOf){
+					Expression child = ((Unary) e).Expr;
+
+					vi.MakePinned ();
+					if (child is ParameterReference || child is LocalVariableReference){
+						Report.Error (
+							213, loc, 
+							"No need to use fixed statement for parameters or " +
+							"local variable declarations (address is already " +
+							"fixed)");
+						return false;
+					}
+					
+					e = e.Resolve (ec);
+					if (e == null)
+						return false;
+
+					child = ((Unary) e).Expr;
+					
+					if (!TypeManager.VerifyUnManaged (child.Type, loc))
+						return false;
+
+					data [i].is_object = true;
+					data [i].expr = e;
+					data [i].converted = null;
+					data [i].vi = vi;
+					i++;
+
+					continue;
+				}
+
+				e = e.Resolve (ec);
+				if (e == null)
+					return false;
+
+				//
+				// Case 2: Array
+				//
+				if (e.Type.IsArray){
+					Type array_type = e.Type.GetElementType ();
+					
+					vi.MakePinned ();
+					//
+					// Provided that array_type is unmanaged,
+					//
+					if (!TypeManager.VerifyUnManaged (array_type, loc))
+						return false;
+
+					//
+					// and T* is implicitly convertible to the
+					// pointer type given in the fixed statement.
+					//
+					ArrayPtr array_ptr = new ArrayPtr (e, loc);
+					
+					Expression converted = Expression.ConvertImplicitRequired (
+						ec, array_ptr, vi.VariableType, loc);
+					if (converted == null)
+						return false;
+
+					data [i].is_object = false;
+					data [i].expr = e;
+					data [i].converted = converted;
+					data [i].vi = vi;
+					i++;
+
+					continue;
+				}
+
+				//
+				// Case 3: string
+				//
+				if (e.Type == TypeManager.string_type){
+					data [i].is_object = false;
+					data [i].expr = e;
+					data [i].converted = null;
+					data [i].vi = vi;
+					i++;
+				}
+			}
+
+			return statement.Resolve (ec);
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+
+			bool is_ret = false;
+
+			for (int i = 0; i < data.Length; i++) {
+				VariableInfo vi = data [i].vi;
+
+				//
+				// Case 1: & object.
+				//
+				if (data [i].is_object) {
+					//
+					// Store pointer in pinned location
+					//
+					data [i].expr.Emit (ec);
+					ig.Emit (OpCodes.Stloc, vi.LocalBuilder);
+
+					is_ret = statement.Emit (ec);
+
+					// Clear the pinned variable.
+					ig.Emit (OpCodes.Ldc_I4_0);
+					ig.Emit (OpCodes.Conv_U);
+					ig.Emit (OpCodes.Stloc, vi.LocalBuilder);
+
+					continue;
+				}
+
+				//
+				// Case 2: Array
+				//
+				if (data [i].expr.Type.IsArray){
+					//
+					// Store pointer in pinned location
+					//
+					data [i].converted.Emit (ec);
+					
+					ig.Emit (OpCodes.Stloc, vi.LocalBuilder);
+
+					is_ret = statement.Emit (ec);
+					
+					// Clear the pinned variable.
+					ig.Emit (OpCodes.Ldc_I4_0);
+					ig.Emit (OpCodes.Conv_U);
+					ig.Emit (OpCodes.Stloc, vi.LocalBuilder);
+
+					continue;
+				}
+
+				//
+				// Case 3: string
+				//
+				if (data [i].expr.Type == TypeManager.string_type){
+					LocalBuilder pinned_string = ig.DeclareLocal (TypeManager.string_type);
+					TypeManager.MakePinned (pinned_string);
+					
+					data [i].expr.Emit (ec);
+					ig.Emit (OpCodes.Stloc, pinned_string);
+
+					Expression sptr = new StringPtr (pinned_string, loc);
+					Expression converted = Expression.ConvertImplicitRequired (
+						ec, sptr, vi.VariableType, loc);
+					
+					if (converted == null)
+						continue;
+
+					converted.Emit (ec);
+					ig.Emit (OpCodes.Stloc, vi.LocalBuilder);
+					
+					is_ret = statement.Emit (ec);
+
+					// Clear the pinned variable
+					ig.Emit (OpCodes.Ldnull);
+					ig.Emit (OpCodes.Stloc, pinned_string);
+				}
+			}
+
+			return is_ret;
+		}
+	}
+	
+	public class Catch {
+		public readonly string Name;
+		public readonly Block  Block;
+		public Expression Clause;
+		public readonly Location Location;
+
+		Expression type_expr;
+		//Expression clus_expr;
+		Type type;
+		
+		public Catch (Expression type, string name, Block block, Expression clause, Location l)
+		{
+			type_expr = type;
+			Name = name;
+			Block = block;
+			Clause = clause;
+			Location = l;
+		}
+
+		public Type CatchType {
+			get {
+				return type;
+			}
+		}
+
+		public bool IsGeneral {
+			get {
+				return type_expr == null;
+			}
+		}
+
+		public bool Resolve (EmitContext ec)
+		{
+			if (type_expr != null) {
+				type = ec.DeclSpace.ResolveType (type_expr, false, Location);
+				if (type == null)
+					return false;
+
+				if (type != TypeManager.exception_type && !type.IsSubclassOf (TypeManager.exception_type)){
+					Report.Error (30665, Location,
+						      "The type caught or thrown must be derived " +
+						      "from System.Exception");
+					return false;
+				}
+			} else
+				type = null;
+
+			if (Clause != null)	{
+				Clause = Statement.ResolveBoolean (ec, Clause, Location);
+				if (Clause == null) {
+					return false;
+				}
+			}
+
+			if (!Block.Resolve (ec))
+				return false;
+
+			return true;
+		}
+	}
+
+	public class Try : Statement {
+		public readonly Block Fini, Block;
+		public readonly ArrayList Specific;
+		public readonly Catch General;
+		
+		//
+		// specific, general and fini might all be null.
+		//
+		public Try (Block block, ArrayList specific, Catch general, Block fini, Location l)
+		{
+			if (specific == null && general == null){
+				Console.WriteLine ("CIR.Try: Either specific or general have to be non-null");
+			}
+			
+			this.Block = block;
+			this.Specific = specific;
+			this.General = general;
+			this.Fini = fini;
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			bool ok = true;
+			
+			ec.StartFlowBranching (FlowBranchingType.EXCEPTION, Block.StartLocation);
+
+			Report.Debug (1, "START OF TRY BLOCK", Block.StartLocation);
+
+			bool old_in_try = ec.InTry;
+			ec.InTry = true;
+
+			if (!Block.Resolve (ec))
+				ok = false;
+
+			ec.InTry = old_in_try;
+
+			FlowBranching.UsageVector vector = ec.CurrentBranching.CurrentUsageVector;
+
+			Report.Debug (1, "START OF CATCH BLOCKS", vector);
+
+			foreach (Catch c in Specific){
+				ec.CurrentBranching.CreateSibling ();
+				Report.Debug (1, "STARTED SIBLING FOR CATCH", ec.CurrentBranching);
+
+				if (c.Name != null) {
+					VariableInfo vi = c.Block.GetVariableInfo (c.Name);
+					if (vi == null)
+						throw new Exception ();
+
+					vi.Number = -1;
+				}
+
+				bool old_in_catch = ec.InCatch;
+				ec.InCatch = true;
+
+				if (!c.Resolve (ec))
+					ok = false;
+
+				ec.InCatch = old_in_catch;
+
+				FlowBranching.UsageVector current = ec.CurrentBranching.CurrentUsageVector;
+
+				if (!current.AlwaysReturns && !current.AlwaysBreaks)
+					vector.AndLocals (current);
+			}
+
+			Report.Debug (1, "END OF CATCH BLOCKS", ec.CurrentBranching);
+
+			if (General != null){
+				ec.CurrentBranching.CreateSibling ();
+				Report.Debug (1, "STARTED SIBLING FOR GENERAL", ec.CurrentBranching);
+
+				bool old_in_catch = ec.InCatch;
+				ec.InCatch = true;
+
+				if (!General.Resolve (ec))
+					ok = false;
+
+				ec.InCatch = old_in_catch;
+
+				FlowBranching.UsageVector current = ec.CurrentBranching.CurrentUsageVector;
+
+				if (!current.AlwaysReturns && !current.AlwaysBreaks)
+					vector.AndLocals (current);
+			}
+
+			Report.Debug (1, "END OF GENERAL CATCH BLOCKS", ec.CurrentBranching);
+
+			if (Fini != null) {
+				ec.CurrentBranching.CreateSiblingForFinally ();
+				Report.Debug (1, "STARTED SIBLING FOR FINALLY", ec.CurrentBranching, vector);
+
+				bool old_in_finally = ec.InFinally;
+				ec.InFinally = true;
+
+				if (!Fini.Resolve (ec))
+					ok = false;
+
+				ec.InFinally = old_in_finally;
+			}
+
+			FlowReturns returns = ec.EndFlowBranching ();
+
+			FlowBranching.UsageVector f_vector = ec.CurrentBranching.CurrentUsageVector;
+
+			Report.Debug (1, "END OF FINALLY", ec.CurrentBranching, returns, vector, f_vector);
+			ec.CurrentBranching.CurrentUsageVector.Or (vector);
+
+			Report.Debug (1, "END OF TRY", ec.CurrentBranching);
+
+			return ok;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			bool returns;
+
+			ec.TryCatchLevel++;
+			Label finish = ig.BeginExceptionBlock ();
+			ec.HasExitLabel = true;
+			ec.ExitLabel = finish;
+
+			bool old_in_try = ec.InTry;
+			ec.InTry = true;
+			returns = Block.Emit (ec);
+			ec.InTry = old_in_try;
+
+			//
+			// System.Reflection.Emit provides this automatically:
+			// ig.Emit (OpCodes.Leave, finish);
+
+			bool old_in_catch = ec.InCatch;
+			ec.InCatch = true;
+			//DeclSpace ds = ec.DeclSpace;
+
+			foreach (Catch c in Specific){
+				VariableInfo vi;
+				
+				ig.BeginCatchBlock (c.CatchType);
+
+				if (c.Name != null){
+					vi = c.Block.GetVariableInfo (c.Name);
+					if (vi == null)
+						throw new Exception ("Variable does not exist in this block");
+
+					ig.Emit (OpCodes.Stloc, vi.LocalBuilder);
+				} else
+					ig.Emit (OpCodes.Pop);
+
+				//
+				// if when clause is there
+				//
+				if (c.Clause != null) {
+					if (c.Clause is BoolConstant) {
+						bool take = ((BoolConstant) c.Clause).Value;
+
+						if (take) 
+							if (!c.Block.Emit (ec))
+								returns = false;
+					} else {
+						EmitBoolExpression (ec, c.Clause, finish, false);
+						if (!c.Block.Emit (ec))
+							returns = false;
+					}
+				} else 
+					if (!c.Block.Emit (ec))
+						returns = false;
+			}
+
+			if (General != null){
+				ig.BeginCatchBlock (TypeManager.object_type);
+				ig.Emit (OpCodes.Pop);
+
+				if (General.Clause != null) {
+					if (General.Clause is BoolConstant) {
+						bool take = ((BoolConstant) General.Clause).Value;
+						if (take) 
+							if (!General.Block.Emit (ec))
+								returns = false;
+					} else {
+						EmitBoolExpression (ec, General.Clause, finish, false);
+						if (!General.Block.Emit (ec))
+							returns = false;
+					}
+				} else 
+					if (!General.Block.Emit (ec))
+						returns = false;
+			}
+
+			ec.InCatch = old_in_catch;
+
+			if (Fini != null){
+				ig.BeginFinallyBlock ();
+				bool old_in_finally = ec.InFinally;
+				ec.InFinally = true;
+				Fini.Emit (ec);
+				ec.InFinally = old_in_finally;
+			}
+			
+			ig.EndExceptionBlock ();
+			ec.TryCatchLevel--;
+
+			if (!returns || ec.InTry || ec.InCatch)
+				return returns;
+
+			return true;
+		}
+	}
+	
+	public  class Pending_Assign {
+		Statement assign;
+		Block block_to_be_inserted;
+		int statement_index;
+		
+		public Pending_Assign (Block block, Statement assign, int index)
+		{
+			this.assign = assign;
+			this.block_to_be_inserted = block;
+			this.statement_index = index;
+		}
+
+		public  void AddAssign()
+		{
+			block_to_be_inserted.statements.Insert( statement_index, assign );
+		}	
+	}
+	
+	public class On_Error : Statement {
+		public readonly Block method_block;
+		ArrayList targets;
+		LabeledStatement[] labeledstatements;
+		
+		public On_Error (Block method_block, Location l)
+		{	
+			//Goto
+			this.method_block = method_block;
+			base.loc = l;
+			targets = new ArrayList();
+		}
+
+		public int AddTarget ( string target )
+		{				
+			int i = targets.IndexOf( target ) ;
+			
+			if ( i == -1 ) 
+				return targets.Add ( target );
+			else
+				return i;
+		}
+
+		public ArrayList Targets {
+			get {
+				return targets;
+			}
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			this.labeledstatements = new LabeledStatement[targets.Count];
+			
+			bool ok = true;
+			
+			ec.StartFlowBranching (FlowBranchingType.EXCEPTION, method_block.StartLocation);
+
+			Report.Debug (1, "START OF TRY BLOCK", method_block.StartLocation);
+
+			bool old_in_try = ec.InTry;
+			ec.InTry = true;
+
+			if (!method_block.Resolve (ec))
+				ok = false;
+
+			ec.InTry = old_in_try;
+
+			FlowBranching.UsageVector vector = ec.CurrentBranching.CurrentUsageVector;
+
+			ec.EndFlowBranching ();
+
+			ec.CurrentBranching.CurrentUsageVector.Or (vector);
+
+			Report.Debug (1, "END OF TRY", ec.CurrentBranching);
+
+			//This statement has more than one label in cases of more than one 'on error goto' specification.
+			for ( int i = 0 ; i < targets.Count ; i++ )
+			{
+				labeledstatements[i] = method_block.Parent.LookupLabel ((string) targets[i]);
+
+				// If this is a forward goto.
+				if (!labeledstatements[i].IsDefined)
+					labeledstatements[i].AddUsageVector (ec.CurrentBranching.CurrentUsageVector);
+
+				labeledstatements[i].AddReference ();
+			}
+			ec.CurrentBranching.CurrentUsageVector.Breaks = FlowReturns.ALWAYS;
+			
+			return ok;
+		}
+		protected override bool DoEmit (EmitContext ec)
+		{	
+			ILGenerator ig = ec.ig;
+				
+			//Try
+
+			bool returns;
+
+			ec.TryCatchLevel++;
+			
+			Label finish = ig.BeginExceptionBlock ();
+				ec.HasExitLabel = true;
+				ec.ExitLabel = finish;
+				
+				bool old_in_try = ec.InTry;
+				ec.InTry = true;
+				returns = method_block.Emit (ec);
+				ec.InTry = old_in_try;
+				bool old_in_catch = ec.InCatch;
+				ec.InCatch = true;
+
+			Label error = ig.DefineLabel();
+			Label endfilter = ig.DefineLabel();
+			Label verification = ig.DefineLabel();
+			
+			ig.BeginExceptFilterBlock();
+				ig.Emit (OpCodes.Isinst, Type.GetType("System.Exception") );
+				ig.Emit (OpCodes.Brtrue_S, verification );
+
+				ig.Emit (OpCodes.Br_S, error);
+			
+				ig.MarkLabel ( verification );	
+				ig.Emit (OpCodes.Ldloc_0);
+				ig.Emit (OpCodes.Brfalse_S, error);
+				
+				ig.Emit (OpCodes.Ldloc_1);
+				ig.Emit (OpCodes.Brtrue_S, error);
+
+				ig.Emit (OpCodes.Ldc_I4_1);
+				ig.Emit (OpCodes.Br_S, endfilter);
+				
+				ig.MarkLabel (error);	
+				ig.Emit (OpCodes.Ldc_I4_0);
+
+				ig.MarkLabel ( endfilter );	
+			
+			
+			Label endcatch = ig.DefineLabel();		
+			Label verification2 = ig.DefineLabel();
+			
+			ig.BeginCatchBlock (null);
+				ig.Emit (OpCodes.Castclass, Type.GetType("System.Exception"));
+				ig.Emit (OpCodes.Dup);
+
+				Type t = typeof(Microsoft.VisualBasic.CompilerServices.ProjectData);
+				MethodInfo mi = t.GetMethod("SetProjectError", new Type[] { typeof(System.Exception) } );
+				ig.Emit (OpCodes.Call, mi);
+				ig.Emit (OpCodes.Stloc_3);
+				ig.Emit (OpCodes.Ldloc_1);
+				ig.Emit (OpCodes.Brfalse_S, verification2 );
+				ig.Emit (OpCodes.Leave_S, finish );
+				ig.MarkLabel ( verification2 );
+				ig.Emit (OpCodes.Ldc_I4_M1);
+				ig.Emit (OpCodes.Stloc_1);
+				ig.Emit (OpCodes.Ldloc_0);
+
+				Label[] lbswitch = new Label[targets.Count + 1];
+				for ( int i = 0; i <= targets.Count; i++ )
+					lbswitch[i] = ig.DefineLabel();
+				
+				ig.Emit (OpCodes.Switch, lbswitch);	
+				ig.MarkLabel ( lbswitch[0] ) ;
+				ig.Emit (OpCodes.Leave_S, endcatch);	
+								
+				Label[] labels = new Label[targets.Count];
+				for ( int i = 0; i < targets.Count; i++ )
+				{
+					labels[i] = labeledstatements[i].LabelTarget(ec);
+
+					ig.MarkLabel ( lbswitch[i+1] ) ;
+					ig.Emit ( OpCodes.Leave, labels[i] );
+				}
+
+				ig.MarkLabel ( endcatch );
+				ig.Emit ( OpCodes.Rethrow );	
+
+			ec.InCatch = old_in_catch;
+
+			ig.EndExceptionBlock ();
+			ec.TryCatchLevel--;
+
+			Label end = ig.DefineLabel();
+			//ig.MarkLabel ( finish ) ;
+			ig.Emit (OpCodes.Ldloc_1);
+			ig.Emit (OpCodes.Brfalse_S, end );
+				
+			mi = t.GetMethod("ClearProjectError");
+			ig.Emit (OpCodes.Call, mi);
+
+			ig.MarkLabel(end) ;
+			
+			if (!returns)
+				return returns;
+
+			// Unfortunately, System.Reflection.Emit automatically emits a leave
+			// to the end of the finally block.  This is a problem if 'returns'
+			// is true since we may jump to a point after the end of the method.
+			// As a workaround, emit an explicit ret here.
+
+			if (ec.ReturnType != null)
+				ec.ig.Emit (OpCodes.Ldloc, ec.TemporaryReturn ());
+			ec.ig.Emit (OpCodes.Ret);
+
+			return true;
+		}
+		
+	}
+
+	public class Using : Statement {
+		object expression_or_block;
+		Statement Statement;
+		ArrayList var_list;
+		Expression expr;
+		Type expr_type;
+		Expression conv;
+		Expression [] converted_vars;
+		ExpressionStatement [] assign;
+		
+		public Using (object expression_or_block, Statement stmt, Location l)
+		{
+			this.expression_or_block = expression_or_block;
+			Statement = stmt;
+			loc = l;
+		}
+
+		//
+		// Resolves for the case of using using a local variable declaration.
+		//
+		bool ResolveLocalVariableDecls (EmitContext ec)
+		{
+			bool need_conv = false;
+			expr_type = ec.DeclSpace.ResolveType (expr, false, loc);
+			int i = 0;
+
+			if (expr_type == null)
+				return false;
+
+			//
+			// The type must be an IDisposable or an implicit conversion
+			// must exist.
+			//
+			converted_vars = new Expression [var_list.Count];
+			assign = new ExpressionStatement [var_list.Count];
+			if (!TypeManager.ImplementsInterface (expr_type, TypeManager.idisposable_type)){
+				foreach (DictionaryEntry e in var_list){
+					Expression var = (Expression) e.Key;
+
+					var = var.ResolveLValue (ec, new EmptyExpression ());
+					if (var == null)
+						return false;
+					
+					converted_vars [i] = Expression.ConvertImplicitRequired (
+						ec, var, TypeManager.idisposable_type, loc);
+
+					if (converted_vars [i] == null)
+						return false;
+					i++;
+				}
+				need_conv = true;
+			}
+
+			i = 0;
+			foreach (DictionaryEntry e in var_list){
+				LocalVariableReference var = (LocalVariableReference) e.Key;
+				Expression new_expr = (Expression) e.Value;
+				Expression a;
+
+				a = new Assign (var, new_expr, loc);
+				a = a.Resolve (ec);
+				if (a == null)
+					return false;
+
+				if (!need_conv)
+					converted_vars [i] = var;
+				assign [i] = (ExpressionStatement) a;
+				i++;
+			}
+
+			return true;
+		}
+
+		bool ResolveExpression (EmitContext ec)
+		{
+			if (!TypeManager.ImplementsInterface (expr_type, TypeManager.idisposable_type)){
+				conv = Expression.ConvertImplicitRequired (
+					ec, expr, TypeManager.idisposable_type, loc);
+
+				if (conv == null)
+					return false;
+			}
+
+			return true;
+		}
+		
+		//
+		// Emits the code for the case of using using a local variable declaration.
+		//
+		bool EmitLocalVariableDecls (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			int i = 0;
+
+			bool old_in_try = ec.InTry;
+			ec.InTry = true;
+			for (i = 0; i < assign.Length; i++) {
+				assign [i].EmitStatement (ec);
+				
+				ig.BeginExceptionBlock ();
+			}
+			Statement.Emit (ec);
+			ec.InTry = old_in_try;
+
+			bool old_in_finally = ec.InFinally;
+			ec.InFinally = true;
+			var_list.Reverse ();
+			foreach (DictionaryEntry e in var_list){
+				LocalVariableReference var = (LocalVariableReference) e.Key;
+				Label skip = ig.DefineLabel ();
+				i--;
+				
+				ig.BeginFinallyBlock ();
+				
+				var.Emit (ec);
+				ig.Emit (OpCodes.Brfalse, skip);
+				converted_vars [i].Emit (ec);
+				ig.Emit (OpCodes.Callvirt, TypeManager.void_dispose_void);
+				ig.MarkLabel (skip);
+				ig.EndExceptionBlock ();
+			}
+			ec.InFinally = old_in_finally;
+
+			return false;
+		}
+
+		bool EmitExpression (EmitContext ec)
+		{
+			//
+			// Make a copy of the expression and operate on that.
+			//
+			ILGenerator ig = ec.ig;
+			LocalBuilder local_copy = ig.DeclareLocal (expr_type);
+			if (conv != null)
+				conv.Emit (ec);
+			else
+				expr.Emit (ec);
+			ig.Emit (OpCodes.Stloc, local_copy);
+
+			bool old_in_try = ec.InTry;
+			ec.InTry = true;
+			ig.BeginExceptionBlock ();
+			Statement.Emit (ec);
+			ec.InTry = old_in_try;
+			
+			Label skip = ig.DefineLabel ();
+			bool old_in_finally = ec.InFinally;
+			ig.BeginFinallyBlock ();
+			ig.Emit (OpCodes.Ldloc, local_copy);
+			ig.Emit (OpCodes.Brfalse, skip);
+			ig.Emit (OpCodes.Ldloc, local_copy);
+			ig.Emit (OpCodes.Callvirt, TypeManager.void_dispose_void);
+			ig.MarkLabel (skip);
+			ec.InFinally = old_in_finally;
+			ig.EndExceptionBlock ();
+
+			return false;
+		}
+		
+		public override bool Resolve (EmitContext ec)
+		{
+			if (expression_or_block is DictionaryEntry){
+				expr = (Expression) ((DictionaryEntry) expression_or_block).Key;
+				var_list = (ArrayList)((DictionaryEntry)expression_or_block).Value;
+
+				if (!ResolveLocalVariableDecls (ec))
+					return false;
+
+			} else if (expression_or_block is Expression){
+				expr = (Expression) expression_or_block;
+
+				expr = expr.Resolve (ec);
+				if (expr == null)
+					return false;
+
+				expr_type = expr.Type;
+
+				if (!ResolveExpression (ec))
+					return false;
+			}			
+
+			return Statement.Resolve (ec);
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			if (expression_or_block is DictionaryEntry)
+				return EmitLocalVariableDecls (ec);
+			else if (expression_or_block is Expression)
+				return EmitExpression (ec);
+
+			return false;
+		}
+	}
+
+	/// <summary>
+	///   Implementation of the for each statement
+	/// </summary>
+	public class Foreach : Statement {
+		Expression type;
+		LocalVariableReference variable;
+		Expression expr;
+		Statement statement;
+		ForeachHelperMethods hm;
+		Expression empty, conv;
+		Type array_type, element_type;
+		Type var_type;
+		
+		public Foreach (Expression type, LocalVariableReference var, Expression expr,
+				Statement stmt, Location l)
+		{
+			if (type != null) {
+				this.type = type;
+			}
+			else
+			{
+				VariableInfo vi = var.VariableInfo;
+				this.type = vi.Type;
+			}
+			this.variable = var;
+			this.expr = expr;
+			statement = stmt;
+			loc = l;
+		}
+		
+		public override bool Resolve (EmitContext ec)
+		{       
+			expr = expr.Resolve (ec);
+			if (expr == null)
+				return false;
+
+			if ( variable.VariableInfo.Alias != null )
+			{
+				FieldBase fb = variable.VariableInfo.GetFieldAlias(ec);
+
+				if ( fb == null )
+				{
+					Report.Error (451, loc,"Name '" + variable.VariableInfo.Name  + "' is not declared.");
+					return false;
+				}
+				else
+				type = fb.Type;
+			}
+						
+			var_type = ec.DeclSpace.ResolveType (type, false, loc);
+			if (var_type == null)
+				return false;
+			
+			//
+			// We need an instance variable.  Not sure this is the best
+			// way of doing this.
+			//
+			// FIXME: When we implement propertyaccess, will those turn
+			// out to return values in ExprClass?  I think they should.
+			//
+			if (!(expr.eclass == ExprClass.Variable || expr.eclass == ExprClass.Value ||
+			      expr.eclass == ExprClass.PropertyAccess || expr.eclass == ExprClass.IndexerAccess)){
+				error1579 (expr.Type);
+				return false;
+			}
+
+			if (expr.Type.IsArray) {
+				array_type = expr.Type;
+				element_type = array_type.GetElementType ();
+
+				empty = new EmptyExpression (element_type);
+			} else {
+				hm = ProbeCollectionType (ec, expr.Type);
+				if (hm == null){
+					error1579 (expr.Type);
+					return false;
+				}
+
+				array_type = expr.Type;
+				element_type = hm.element_type;
+
+				empty = new EmptyExpression (hm.element_type);
+			}
+
+			ec.StartFlowBranching (FlowBranchingType.LOOP_BLOCK, loc);
+			ec.CurrentBranching.CreateSibling ();
+
+ 			//
+			//
+			// FIXME: maybe we can apply the same trick we do in the
+			// array handling to avoid creating empty and conv in some cases.
+			//
+			// Although it is not as important in this case, as the type
+			// will not likely be object (what the enumerator will return).
+			//
+			conv = Expression.ConvertExplicit (ec, empty, var_type, false, loc);
+			if (conv == null)
+				return false;
+
+			if (variable.ResolveLValue (ec, empty) == null)
+				return false;
+			
+			if (!statement.Resolve (ec))
+				return false;
+
+			//FlowReturns returns = ec.EndFlowBranching ();
+			ec.EndFlowBranching ();
+			return true;
+		}
+		
+		//
+		// Retrieves a 'public bool MoveNext ()' method from the Type 't'
+		//
+		static MethodInfo FetchMethodMoveNext (Type t)
+		{
+			MemberList move_next_list;
+			
+			move_next_list = TypeContainer.FindMembers (
+				t, MemberTypes.Method,
+				BindingFlags.Public | BindingFlags.Instance,
+				Type.FilterName, "MoveNext");
+			if (move_next_list.Count == 0)
+				return null;
+
+			foreach (MemberInfo m in move_next_list){
+				MethodInfo mi = (MethodInfo) m;
+				Type [] args;
+				
+				args = TypeManager.GetArgumentTypes (mi);
+				if (args != null && args.Length == 0){
+					if (mi.ReturnType == TypeManager.bool_type)
+						return mi;
+				}
+			}
+			return null;
+		}
+		
+		//
+		// Retrieves a 'public T get_Current ()' method from the Type 't'
+		//
+		static MethodInfo FetchMethodGetCurrent (Type t)
+		{
+			MemberList move_next_list;
+			
+			move_next_list = TypeContainer.FindMembers (
+				t, MemberTypes.Method,
+				BindingFlags.Public | BindingFlags.Instance,
+				Type.FilterName, "get_Current");
+			if (move_next_list.Count == 0)
+				return null;
+
+			foreach (MemberInfo m in move_next_list){
+				MethodInfo mi = (MethodInfo) m;
+				Type [] args;
+
+				args = TypeManager.GetArgumentTypes (mi);
+				if (args != null && args.Length == 0)
+					return mi;
+			}
+			return null;
+		}
+
+		// 
+		// This struct records the helper methods used by the Foreach construct
+		//
+		class ForeachHelperMethods {
+			public EmitContext ec;
+			public MethodInfo get_enumerator;
+			public MethodInfo move_next;
+			public MethodInfo get_current;
+			public Type element_type;
+			public Type enumerator_type;
+			public bool is_disposable;
+
+			public ForeachHelperMethods (EmitContext ec)
+			{
+				this.ec = ec;
+				this.element_type = TypeManager.object_type;
+				this.enumerator_type = TypeManager.ienumerator_type;
+				this.is_disposable = true;
+			}
+		}
+		
+		static bool GetEnumeratorFilter (MemberInfo m, object criteria)
+		{
+			if (m == null)
+				return false;
+			
+			if (!(m is MethodInfo))
+				return false;
+			
+			if (m.Name != "GetEnumerator")
+				return false;
+
+			MethodInfo mi = (MethodInfo) m;
+			Type [] args = TypeManager.GetArgumentTypes (mi);
+			if (args != null){
+				if (args.Length != 0)
+					return false;
+			}
+			ForeachHelperMethods hm = (ForeachHelperMethods) criteria;
+			EmitContext ec = hm.ec;
+
+			//
+			// Check whether GetEnumerator is accessible to us
+			//
+			MethodAttributes prot = mi.Attributes & MethodAttributes.MemberAccessMask;
+
+			Type declaring = mi.DeclaringType;
+			if (prot == MethodAttributes.Private){
+				if (declaring != ec.ContainerType)
+					return false;
+			} else if (prot == MethodAttributes.FamANDAssem){
+				// If from a different assembly, false
+				if (!(mi is MethodBuilder))
+					return false;
+				//
+				// Are we being invoked from the same class, or from a derived method?
+				//
+				if (ec.ContainerType != declaring){
+					if (!ec.ContainerType.IsSubclassOf (declaring))
+						return false;
+				}
+			} else if (prot == MethodAttributes.FamORAssem){
+				if (!(mi is MethodBuilder ||
+				      ec.ContainerType == declaring ||
+				      ec.ContainerType.IsSubclassOf (declaring)))
+					return false;
+			} if (prot == MethodAttributes.Family){
+				if (!(ec.ContainerType == declaring ||
+				      ec.ContainerType.IsSubclassOf (declaring)))
+					return false;
+			}
+
+			//
+			// Ok, we can access it, now make sure that we can do something
+			// with this 'GetEnumerator'
+			//
+
+			if (mi.ReturnType == TypeManager.ienumerator_type ||
+			    TypeManager.ienumerator_type.IsAssignableFrom (mi.ReturnType) ||
+			    (!RootContext.StdLib && TypeManager.ImplementsInterface (mi.ReturnType, TypeManager.ienumerator_type))) {
+				hm.move_next = TypeManager.bool_movenext_void;
+				hm.get_current = TypeManager.object_getcurrent_void;
+				return true;
+			}
+
+			//
+			// Ok, so they dont return an IEnumerable, we will have to
+			// find if they support the GetEnumerator pattern.
+			//
+			Type return_type = mi.ReturnType;
+
+			hm.move_next = FetchMethodMoveNext (return_type);
+			if (hm.move_next == null)
+				return false;
+			hm.get_current = FetchMethodGetCurrent (return_type);
+			if (hm.get_current == null)
+				return false;
+
+			hm.element_type = hm.get_current.ReturnType;
+			hm.enumerator_type = return_type;
+			hm.is_disposable = TypeManager.ImplementsInterface (
+				hm.enumerator_type, TypeManager.idisposable_type);
+
+			return true;
+		}
+		
+		/// <summary>
+		///   This filter is used to find the GetEnumerator method
+		///   on which IEnumerator operates
+		/// </summary>
+		static MemberFilter FilterEnumerator;
+		
+		static Foreach ()
+		{
+			FilterEnumerator = new MemberFilter (GetEnumeratorFilter);
+		}
+
+                void error1579 (Type t)
+                {
+                        Report.Error (1579, loc,
+                                      "foreach statement cannot operate on variables of type '" +
+                                      t.FullName + "' because that class does not provide a " +
+                                      " GetEnumerator method or it is inaccessible");
+                }
+
+		static bool TryType (Type t, ForeachHelperMethods hm)
+		{
+			MemberList mi;
+			
+			mi = TypeContainer.FindMembers (t, MemberTypes.Method,
+							BindingFlags.Public | BindingFlags.NonPublic |
+							BindingFlags.Instance,
+							FilterEnumerator, hm);
+
+			if (mi.Count == 0)
+				return false;
+
+			hm.get_enumerator = (MethodInfo) mi [0];
+			return true;	
+		}
+		
+		//
+		// Looks for a usable GetEnumerator in the Type, and if found returns
+		// the three methods that participate: GetEnumerator, MoveNext and get_Current
+		//
+		ForeachHelperMethods ProbeCollectionType (EmitContext ec, Type t)
+		{
+			ForeachHelperMethods hm = new ForeachHelperMethods (ec);
+
+			if (TryType (t, hm))
+				return hm;
+
+			//
+			// Now try to find the method in the interfaces
+			//
+			while (t != null){
+				Type [] ifaces = t.GetInterfaces ();
+
+				foreach (Type i in ifaces){
+					if (TryType (i, hm))
+						return hm;
+				}
+				
+				//
+				// Since TypeBuilder.GetInterfaces only returns the interface
+				// types for this type, we have to keep looping, but once
+				// we hit a non-TypeBuilder (ie, a Type), then we know we are
+				// done, because it returns all the types
+				//
+				if ((t is TypeBuilder))
+					t = t.BaseType;
+				else
+					break;
+			} 
+
+			return null;
+		}
+
+		//
+		// FIXME: possible optimization.
+		// We might be able to avoid creating 'empty' if the type is the sam
+		//
+		bool EmitCollectionForeach (EmitContext ec)
+		{
+			ILGenerator ig = ec.ig;
+			LocalBuilder enumerator, disposable;
+
+			enumerator = ig.DeclareLocal (hm.enumerator_type);
+			if (hm.is_disposable)
+				disposable = ig.DeclareLocal (TypeManager.idisposable_type);
+			else
+				disposable = null;
+			
+			//
+			// Instantiate the enumerator
+			//
+			if (expr.Type.IsValueType){
+				if (expr is IMemoryLocation){
+					IMemoryLocation ml = (IMemoryLocation) expr;
+
+					ml.AddressOf (ec, AddressOp.Load);
+				} else
+					throw new Exception ("Expr " + expr + " of type " + expr.Type +
+							     " does not implement IMemoryLocation");
+				ig.Emit (OpCodes.Call, hm.get_enumerator);
+			} else {
+				expr.Emit (ec);
+				ig.Emit (OpCodes.Callvirt, hm.get_enumerator);
+			}
+			ig.Emit (OpCodes.Stloc, enumerator);
+
+			//
+			// Protect the code in a try/finalize block, so that
+			// if the beast implement IDisposable, we get rid of it
+			//
+			bool old_in_try = ec.InTry;
+
+			if (hm.is_disposable) {
+				ig.BeginExceptionBlock ();
+				ec.InTry = true;
+			}
+			
+			Label end_try = ig.DefineLabel ();
+			
+			ig.MarkLabel (ec.LoopBegin);
+			ig.Emit (OpCodes.Ldloc, enumerator);
+			ig.Emit (OpCodes.Callvirt, hm.move_next);
+			ig.Emit (OpCodes.Brfalse, end_try);
+			
+			
+			FieldBase fb = null;
+			if ( variable.VariableInfo.Alias != null )
+			{
+				fb = variable.VariableInfo.GetFieldAlias(ec);
+				
+				if( (fb.ModFlags & Modifiers.STATIC) == 0 )
+					ig.Emit (OpCodes.Ldarg_0);
+			}	
+					
+			ig.Emit (OpCodes.Ldloc, enumerator);
+			ig.Emit (OpCodes.Callvirt, hm.get_current);
+			
+			if ( fb == null)
+				variable.EmitAssign (ec, conv);
+			else
+				variable.EmitAssign (ec, conv, fb);
+			
+			statement.Emit (ec);
+			ig.Emit (OpCodes.Br, ec.LoopBegin);
+			ig.MarkLabel (end_try);
+			ec.InTry = old_in_try;
+			
+			// The runtime provides this for us.
+			// ig.Emit (OpCodes.Leave, end);
+
+			//
+			// Now the finally block
+			//
+			if (hm.is_disposable) {
+				Label end_finally = ig.DefineLabel ();
+				bool old_in_finally = ec.InFinally;
+				ec.InFinally = true;
+				ig.BeginFinallyBlock ();
+			
+				ig.Emit (OpCodes.Ldloc, enumerator);
+				ig.Emit (OpCodes.Isinst, TypeManager.idisposable_type);
+				ig.Emit (OpCodes.Stloc, disposable);
+				ig.Emit (OpCodes.Ldloc, disposable);
+				ig.Emit (OpCodes.Brfalse, end_finally);
+				ig.Emit (OpCodes.Ldloc, disposable);
+				ig.Emit (OpCodes.Callvirt, TypeManager.void_dispose_void);
+				ig.MarkLabel (end_finally);
+				ec.InFinally = old_in_finally;
+
+				// The runtime generates this anyways.
+				// ig.Emit (OpCodes.Endfinally);
+
+				ig.EndExceptionBlock ();
+			}
+
+			ig.MarkLabel (ec.LoopEnd);
+			return false;
+		}
+
+		//
+		// FIXME: possible optimization.
+		// We might be able to avoid creating 'empty' if the type is the sam
+		//
+		bool EmitArrayForeach (EmitContext ec)
+		{
+			int rank = array_type.GetArrayRank ();
+			ILGenerator ig = ec.ig;
+
+			LocalBuilder copy = ig.DeclareLocal (array_type);
+			
+			//
+			// Make our copy of the array
+			//
+			expr.Emit (ec);
+			ig.Emit (OpCodes.Stloc, copy);
+			
+			if (rank == 1){
+				LocalBuilder counter = ig.DeclareLocal (TypeManager.int32_type);
+
+				Label loop, test;
+				
+				ig.Emit (OpCodes.Ldc_I4_0);
+				ig.Emit (OpCodes.Stloc, counter);
+				test = ig.DefineLabel ();
+				ig.Emit (OpCodes.Br, test);
+
+				loop = ig.DefineLabel ();
+				ig.MarkLabel (loop);
+
+				FieldBase fb = null;
+				if ( variable.VariableInfo.Alias != null )
+				{
+					fb = variable.VariableInfo.GetFieldAlias(ec);
+
+					if( (fb.ModFlags & Modifiers.STATIC) == 0 )
+						ig.Emit (OpCodes.Ldarg_0);
+				}	
+					
+				ig.Emit (OpCodes.Ldloc, copy);
+				ig.Emit (OpCodes.Ldloc, counter);
+				ArrayAccess.EmitLoadOpcode (ig, var_type);
+
+				if ( fb == null)
+					variable.EmitAssign (ec, conv);
+				else
+					variable.EmitAssign (ec, conv, fb);
+
+				statement.Emit (ec);
+
+				ig.MarkLabel (ec.LoopBegin);
+				ig.Emit (OpCodes.Ldloc, counter);
+				ig.Emit (OpCodes.Ldc_I4_1);
+				ig.Emit (OpCodes.Add);
+				ig.Emit (OpCodes.Stloc, counter);
+
+				ig.MarkLabel (test);
+				ig.Emit (OpCodes.Ldloc, counter);
+				ig.Emit (OpCodes.Ldloc, copy);
+				ig.Emit (OpCodes.Ldlen);
+				ig.Emit (OpCodes.Conv_I4);
+				ig.Emit (OpCodes.Blt, loop);
+			} else {
+				LocalBuilder [] dim_len   = new LocalBuilder [rank];
+				LocalBuilder [] dim_count = new LocalBuilder [rank];
+				Label [] loop = new Label [rank];
+				Label [] test = new Label [rank];
+				int dim;
+				
+				for (dim = 0; dim < rank; dim++){
+					dim_len [dim] = ig.DeclareLocal (TypeManager.int32_type);
+					dim_count [dim] = ig.DeclareLocal (TypeManager.int32_type);
+					test [dim] = ig.DefineLabel ();
+					loop [dim] = ig.DefineLabel ();
+				}
+					
+				for (dim = 0; dim < rank; dim++){
+					ig.Emit (OpCodes.Ldloc, copy);
+					IntLiteral.EmitInt (ig, dim);
+					ig.Emit (OpCodes.Callvirt, TypeManager.int_getlength_int);
+					ig.Emit (OpCodes.Stloc, dim_len [dim]);
+				}
+
+				for (dim = 0; dim < rank; dim++){
+					ig.Emit (OpCodes.Ldc_I4_0);
+					ig.Emit (OpCodes.Stloc, dim_count [dim]);
+					ig.Emit (OpCodes.Br, test [dim]);
+					ig.MarkLabel (loop [dim]);
+				}
+
+				ig.Emit (OpCodes.Ldloc, copy);
+				for (dim = 0; dim < rank; dim++)
+					ig.Emit (OpCodes.Ldloc, dim_count [dim]);
+
+				//
+				// FIXME: Maybe we can cache the computation of 'get'?
+				//
+				Type [] args = new Type [rank];
+				MethodInfo get;
+
+				for (int i = 0; i < rank; i++)
+					args [i] = TypeManager.int32_type;
+
+				ModuleBuilder mb = CodeGen.ModuleBuilder;
+				get = mb.GetArrayMethod (
+					array_type, "Get",
+					CallingConventions.HasThis| CallingConventions.Standard,
+					var_type, args);
+				ig.Emit (OpCodes.Call, get);
+				variable.EmitAssign (ec, conv);
+				statement.Emit (ec);
+				ig.MarkLabel (ec.LoopBegin);
+				for (dim = rank - 1; dim >= 0; dim--){
+					ig.Emit (OpCodes.Ldloc, dim_count [dim]);
+					ig.Emit (OpCodes.Ldc_I4_1);
+					ig.Emit (OpCodes.Add);
+					ig.Emit (OpCodes.Stloc, dim_count [dim]);
+
+					ig.MarkLabel (test [dim]);
+					ig.Emit (OpCodes.Ldloc, dim_count [dim]);
+					ig.Emit (OpCodes.Ldloc, dim_len [dim]);
+					ig.Emit (OpCodes.Blt, loop [dim]);
+				}
+			}
+			ig.MarkLabel (ec.LoopEnd);
+			
+			return false;
+		}
+		
+		protected override bool DoEmit (EmitContext ec)
+		{
+			bool ret_val;
+			
+			ILGenerator ig = ec.ig;
+			
+			Label old_begin = ec.LoopBegin, old_end = ec.LoopEnd;
+			bool old_inloop = ec.InLoop;
+			int old_loop_begin_try_catch_level = ec.LoopBeginTryCatchLevel;
+			ec.LoopBegin = ig.DefineLabel ();
+			ec.LoopEnd = ig.DefineLabel ();
+			ec.InLoop = true;
+			ec.LoopBeginTryCatchLevel = ec.TryCatchLevel;
+			
+			if (hm != null)
+				ret_val = EmitCollectionForeach (ec);
+			else
+				ret_val = EmitArrayForeach (ec);
+			
+			ec.LoopBegin = old_begin;
+			ec.LoopEnd = old_end;
+			ec.InLoop = old_inloop;
+			ec.LoopBeginTryCatchLevel = old_loop_begin_try_catch_level;
+
+			return ret_val;
+		}
+	}
+	
+	/// <summary>
+	///   AddHandler statement
+	/// </summary>
+	public class AddHandler : Statement {
+		Expression EvtId;
+		Expression EvtHandler;
+
+		//
+		// keeps track whether EvtId is already resolved
+		//
+		bool resolved;
+
+		public AddHandler (Expression evt_id, Expression evt_handler, Location l)
+		{
+			EvtId = evt_id;
+			EvtHandler = Parser.SetAddressOf (evt_handler);
+			loc = l;
+			resolved = false;
+			//Console.WriteLine ("Adding handler '" + evt_handler + "' for Event '" + evt_id +"'");
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			//
+			// if EvetId is of EventExpr type that means
+			// this is already resolved 
+			//
+			if (EvtId is EventExpr)	{
+				resolved = true;
+				return true;
+			}
+
+			EvtId = EvtId.Resolve(ec);
+			EvtHandler = EvtHandler.Resolve(ec,ResolveFlags.MethodGroup);
+			if (EvtId == null || (!(EvtId is EventExpr))) {
+				Report.Error (30676, "Need an event designator.");
+				return false;
+			}
+
+			if (EvtHandler == null) 
+			{
+				Report.Error (999, "'AddHandler' statement needs an event handler.");
+				return false;
+			}
+
+			return true;
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			//
+			// Already resolved and emitted don't do anything
+			//
+			if (resolved)
+				return true;
+
+			Expression e, d;
+			ArrayList args = new ArrayList();
+			Argument arg = new Argument (EvtHandler, Argument.AType.Expression);
+			args.Add (arg);
+			
+			
+
+			// The even type was already resolved to a delegate, so
+			// we must un-resolve its name to generate a type expression
+			string ts = (EvtId.Type.ToString()).Replace ('+','.');
+			Expression dtype = Mono.MonoBASIC.Parser.DecomposeQI (ts, Location.Null);
+
+			// which we can use to declare a new event handler
+			// of the same type
+			d = new New (dtype, args, Location.Null);
+			d = d.Resolve(ec);
+			e = new CompoundAssign(Binary.Operator.Addition, EvtId, d, Location.Null);
+
+			// we resolve it all and emit the code
+			e = e.Resolve(ec);
+			if (e != null) 
+			{
+				e.Emit(ec);
+				return true;
+			}
+
+			return false;
+		}
+	}
+
+	/// <summary>
+	///   RemoveHandler statement
+	/// </summary>
+	public class RemoveHandler : Statement 
+	{
+		Expression EvtId;
+		Expression EvtHandler;
+
+		public RemoveHandler (Expression evt_id, Expression evt_handler, Location l)
+		{
+			EvtId = evt_id;
+			EvtHandler = Parser.SetAddressOf (evt_handler);
+			loc = l;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			EvtId = EvtId.Resolve(ec);
+			EvtHandler = EvtHandler.Resolve(ec,ResolveFlags.MethodGroup);
+			if (EvtId == null || (!(EvtId is EventExpr))) 
+			{
+				Report.Error (30676, "Need an event designator.");
+				return false;
+			}
+
+			if (EvtHandler == null) 
+			{
+				Report.Error (999, "'AddHandler' statement needs an event handler.");
+				return false;
+			}
+			return true;
+		}
+
+		protected override bool DoEmit (EmitContext ec)
+		{
+			Expression e, d;
+			ArrayList args = new ArrayList();
+			Argument arg = new Argument (EvtHandler, Argument.AType.Expression);
+			args.Add (arg);
+			
+			// The even type was already resolved to a delegate, so
+			// we must un-resolve its name to generate a type expression
+			string ts = (EvtId.Type.ToString()).Replace ('+','.');
+			Expression dtype = Mono.MonoBASIC.Parser.DecomposeQI (ts, Location.Null);
+
+			// which we can use to declare a new event handler
+			// of the same type
+			d = new New (dtype, args, Location.Null);
+			d = d.Resolve(ec);
+			// detach the event
+			e = new CompoundAssign(Binary.Operator.Subtraction, EvtId, d, Location.Null);
+
+			// we resolve it all and emit the code
+			e = e.Resolve(ec);
+			if (e != null) 
+			{
+				e.Emit(ec);
+				return true;
+			}
+
+			return false;
+		}
+	}
+
+	public class RedimClause {
+		private Expression RedimTarget;
+		private ArrayList NewIndexes;
+		private Expression AsType;
+		
+		private LocalTemporary localTmp = null;
+		private Expression origRedimTarget = null;
+		private StatementExpression ReDimExpr;
+
+		public RedimClause (Expression e, ArrayList args, Expression e_as)
+		{
+			if (e is SimpleName)
+				((SimpleName) e).IsInvocation = false;
+			if (e is MemberAccess)
+				((MemberAccess) e).IsInvocation = false;
+		
+			RedimTarget = e;
+			NewIndexes = args;
+			AsType = e_as;
+		}
+
+		public bool Resolve (EmitContext ec, bool Preserve, Location loc)
+		{
+			RedimTarget = RedimTarget.Resolve (ec);
+
+			if (AsType != null) {
+				Report.Error (30811, loc, "'ReDim' statements can no longer be used to declare array variables");
+				return false;
+			}
+			
+			if (!RedimTarget.Type.IsArray) {
+				Report.Error (49, loc, "'ReDim' statement requires an array");
+				return false;
+			}
+
+			ArrayList args = new ArrayList();
+			foreach (Argument a in NewIndexes) {
+				if (a.Resolve(ec, loc))
+					args.Add (a.Expr);
+			}
+
+			for (int x = 0; x < args.Count; x++) {
+				args[x] = new Binary (Binary.Operator.Addition,
+							(Expression) args[x], new IntLiteral (1), Location.Null);	
+			}
+
+			NewIndexes = args;
+			if (RedimTarget.Type.GetArrayRank() != NewIndexes.Count) {
+				Report.Error (30415, loc, "'ReDim' cannot change the number of dimensions of an array.");
+				return false;
+			}
+			
+			Type BaseType = RedimTarget.Type.GetElementType();
+			Expression BaseTypeExpr = MonoBASIC.Parser.DecomposeQI(BaseType.FullName.ToString(), Location.Null);
+			ArrayCreation acExpr = new ArrayCreation (BaseTypeExpr, NewIndexes, "", null, Location.Null); 	
+			if (Preserve)
+			{
+				ExpressionStatement PreserveExpr = null;
+				if (RedimTarget is PropertyGroupExpr) {
+					localTmp = new LocalTemporary (ec, RedimTarget.Type);
+					PropertyGroupExpr pe = RedimTarget as PropertyGroupExpr;
+					origRedimTarget = new PropertyGroupExpr (pe.Properties, pe.Arguments, pe.InstanceExpression, loc);
+					if ((origRedimTarget = origRedimTarget.Resolve (ec)) == null)  {
+						Report.Error (-1, loc, "'ReDim' vs PropertyGroup");
+						return false;
+					}
+					PreserveExpr = (ExpressionStatement) new Preserve(localTmp, acExpr, loc);
+				} else
+					PreserveExpr = (ExpressionStatement) new Preserve(RedimTarget, acExpr, loc);
+				ReDimExpr = (StatementExpression) new StatementExpression ((ExpressionStatement) new Assign (RedimTarget, PreserveExpr, loc), loc);
+			}
+			else
+				ReDimExpr = (StatementExpression) new StatementExpression ((ExpressionStatement) new Assign (RedimTarget, acExpr, loc), loc);
+			ReDimExpr.Resolve(ec);	
+			return true;		
+		}
+
+		public void DoEmit (EmitContext ec)
+		{
+			if (ReDimExpr == null)
+				return;
+				
+			if (localTmp != null && origRedimTarget != null) {
+				origRedimTarget.Emit (ec);
+				localTmp.Store (ec);
+			}
+			ReDimExpr.Emit(ec);
+		}		
+
+	}
+
+	public class ReDim : Statement {
+		ArrayList RedimTargets;
+		bool Preserve;
+
+		public ReDim (ArrayList targets, bool opt_preserve, Location l)
+		{
+			loc = l;
+			RedimTargets = targets;
+			Preserve = opt_preserve;
+		}
+
+		public override bool Resolve (EmitContext ec)
+		{
+			bool result = true;
+			foreach (RedimClause rc in RedimTargets)
+				result = rc.Resolve(ec, Preserve, loc) && result;
+			return result;
+		}
+				
+		protected override bool DoEmit (EmitContext ec)
+		{
+			foreach (RedimClause rc in RedimTargets)
+				rc.DoEmit(ec);
+			return false;
+		}		
+		
+	}
+	
+	public class Erase : Statement {
+		Expression EraseTarget;
+		
+		private StatementExpression EraseExpr;
+		
+		public Erase (Expression expr, Location l)
+		{
+			loc = l;
+			EraseTarget = expr;
+		}
+		
+		public override bool Resolve (EmitContext ec)
+		{
+			EraseTarget = EraseTarget.Resolve (ec);
+			if (!EraseTarget.Type.IsArray) 
+				Report.Error (49, "'Erase' statement requires an array");
+
+			EraseExpr = (StatementExpression) new StatementExpression ((ExpressionStatement) new Assign (EraseTarget, NullLiteral.Null, loc), loc);
+			EraseExpr.Resolve(ec);
+			
+			return true;
+		}
+				
+		protected override bool DoEmit (EmitContext ec)
+		{
+			EraseExpr.Emit(ec);
+			return false;
+		}		
+		
+	}
+	
+	
+}
diff --git a/dead/mbas/statementCollection.cs b/dead/mbas/statementCollection.cs
new file mode 100644
index 00000000..352cb132
--- /dev/null
+++ b/dead/mbas/statementCollection.cs
@@ -0,0 +1,166 @@
+//
+// System.CodeDOM CodeStatementCollection Class implementation
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//
+// (C) 2001 Ximian, Inc.
+//
+
+namespace Mono.MonoBASIC {
+
+	using System.Collections;
+	using System;
+	
+	public class StatementCollection : IList, ICollection, IEnumerable {
+
+		ArrayList statements;
+		
+		//
+		// Constructors
+		//
+		public StatementCollection ()
+		{
+			statements = new ArrayList ();
+		}
+
+		//
+		// Properties
+		//
+		public int Count {
+			get {
+				return statements.Count;
+			}
+		}
+
+		//
+		// Methods
+		//
+		public void Add (Statement value)
+		{
+			statements.Add (value);
+		}
+
+		public void AddRange (Statement [] values)
+		{
+			foreach (Statement ca in values) 
+				statements.Add (ca);
+
+		}
+
+		public void Clear ()
+		{
+			statements.Clear ();
+		}
+
+		private class Enumerator : IEnumerator {
+			private StatementCollection collection;
+			private int currentIndex = -1;
+
+			internal Enumerator (StatementCollection collection)
+			{
+				this.collection = collection;
+			}
+
+			public object Current {
+				get {
+					if (currentIndex == collection.Count)
+						throw new InvalidOperationException ();
+					return collection [currentIndex];
+				}
+			}
+
+			public bool MoveNext ()
+			{
+				if (currentIndex > collection.Count)
+					throw new InvalidOperationException ();
+				return ++currentIndex < collection.Count;
+			}
+
+			public void Reset ()
+			{
+				currentIndex = -1;
+			}
+		}
+		
+		public IEnumerator GetEnumerator ()
+		{
+			return new StatementCollection.Enumerator (this);
+		}
+
+		//
+		// IList method implementations
+		//
+		public int Add (object value)
+		{
+			return statements.Add (value);
+		}
+
+		public bool Contains (Object value)
+		{
+			return statements.Contains (value);
+		}
+
+		public int IndexOf (Object value)
+		{
+			return statements.IndexOf (value);
+		}
+
+		public void Insert (int index, Object value)
+		{
+			statements [index] = value;
+		}
+
+		public object this[int index] {
+			get {
+				return statements [index];
+			}
+
+			set {
+				statements [index] = value;
+			}
+		}
+
+		public void Remove (object value)
+		{
+			statements.Remove (value);
+		}
+
+		public void RemoveAt (int index)
+		{
+			statements.RemoveAt (index);
+		}
+
+		//
+		// ICollection method implementations
+		//
+		public void CopyTo (Array array, int index)
+		{
+			statements.CopyTo (array, index);
+		}
+
+		public object SyncRoot {
+			get {
+				return statements.SyncRoot;
+			}
+		}
+
+		public bool IsReadOnly {
+			get {
+				return false;
+			}
+		}
+
+		public bool IsSynchronized {
+			get {
+				return statements.IsSynchronized;
+			}
+		}
+
+		public bool IsFixedSize {
+			get {
+				return false;
+			}
+		}
+	}
+}
diff --git a/dead/mbas/support.cs b/dead/mbas/support.cs
new file mode 100644
index 00000000..4356a466
--- /dev/null
+++ b/dead/mbas/support.cs
@@ -0,0 +1,344 @@
+//
+// support.cs: Support routines to work around the fact that System.Reflection.Emit
+// can not introspect types that are being constructed
+//
+// Author:
+//   Miguel de Icaza (miguel@ximian.com)
+//
+// (C) 2001 Ximian, Inc (http://www.ximian.com)
+//
+
+using System;
+using System.Text;
+using System.Reflection;
+using System.Collections;
+using System.Reflection.Emit;
+using System.Globalization;
+
+namespace Mono.MonoBASIC {
+
+	public interface ParameterData {
+		Type ParameterType (int pos);
+		int  Count { get; }
+		string ParameterName (int pos);
+		string ParameterDesc (int pos);
+		Expression DefaultValue (int pos);
+		Parameter.Modifier ParameterModifier (int pos);
+	}
+
+	public class ReflectionParameters : ParameterData {
+		ParameterInfo [] pi;
+		bool last_arg_is_params = false;
+		
+		public ReflectionParameters (ParameterInfo [] pi)
+		{
+			object [] attrs;
+			
+			this.pi = pi;
+
+			int count = pi.Length-1;
+
+			if (count >= 0) {
+				attrs = pi [count].GetCustomAttributes (TypeManager.param_array_type, true);
+
+				if (attrs == null)
+					return;
+				
+				if (attrs.Length == 0)
+					return;
+
+				last_arg_is_params = true;
+			}
+		}
+		       
+		public Type ParameterType (int pos)
+		{
+			if (last_arg_is_params && pos >= pi.Length - 1)
+				return pi [pi.Length - 1].ParameterType;
+			else
+				if (pos >= pi.Length)
+					return null;
+				else {
+					Type pt = pi [pos].ParameterType;
+                              		if (pt.IsByRef)
+						pt = pt.GetElementType();
+					return pt;
+				}
+		}
+
+		public Expression DefaultValue (int pos)
+		{
+			if (pi [pos].DefaultValue == null)
+				return NullLiteral.Null;
+			Type type = pi [pos].DefaultValue.GetType();
+
+			//
+			// TODO : Enum is not handled here since ParameterInfo
+			// is not returning correct Data type for Enum
+			//
+			switch (Type.GetTypeCode(type)){
+				case TypeCode.Byte:
+					return new ByteConstant ((byte) pi [pos].DefaultValue);
+				case TypeCode.Char:
+					return new CharConstant ((char) pi [pos].DefaultValue);
+				case TypeCode.String:
+					return new StringConstant ((string) pi [pos].DefaultValue);
+				case TypeCode.Int16:
+					return new ShortConstant ((short) pi [pos].DefaultValue);
+				case TypeCode.UInt16:
+					return new UShortConstant ((ushort) pi [pos].DefaultValue);
+				case TypeCode.Int32:
+					return new IntConstant ((int) pi [pos].DefaultValue);
+				case TypeCode.UInt32:
+					return new UIntConstant ((uint) pi [pos].DefaultValue);
+				case TypeCode.Int64:
+					return new LongConstant ((long) pi [pos].DefaultValue);
+				case TypeCode.UInt64:
+					return new ULongConstant ((ulong) pi [pos].DefaultValue);
+				case TypeCode.Boolean:
+					return new BoolConstant ((bool) pi [pos].DefaultValue);
+				case TypeCode.DateTime:
+					return new DateConstant ((DateTime) pi [pos].DefaultValue);
+				case TypeCode.Decimal:
+					return new DecimalConstant ((decimal) pi [pos].DefaultValue);
+				case TypeCode.Double:
+					return new DoubleConstant ((double) pi [pos].DefaultValue);
+				case TypeCode.SByte:
+					return new SByteConstant ((sbyte) pi [pos].DefaultValue);
+				default:
+					Report.Error(-1, 
+					"Internal Error : cannot handle the data type" +
+					"received from ParameterInfo class");
+					return null;
+			}
+#if false
+			if (last_arg_is_params && pos >= pi.Length - 1)
+				return pi [pi.Length - 1].ParameterType;
+			else
+				if (pos >= pi.Length)
+					return null;
+				else {
+					Type pt = pi [pos].ParameterType;
+                              		if (pt.IsByRef)
+						pt = pt.GetElementType();
+					return pt;
+				}
+#endif
+		}
+
+		public string ParameterName (int pos)
+		{
+			if (last_arg_is_params && pos >= pi.Length - 1)
+				return pi [pi.Length - 1].Name;
+			else 
+				return pi [pos].Name;
+		}
+
+		public string ParameterDesc (int pos)
+		{
+			StringBuilder sb = new StringBuilder ();
+
+			if (pi [pos].IsOut)
+				sb.Append ("out ");
+
+			if (pi [pos].IsIn)
+				sb.Append ("in ");
+
+			if (pos >= pi.Length - 1 && last_arg_is_params)
+				sb.Append ("params ");
+			
+			sb.Append (TypeManager.MonoBASIC_Name (ParameterType (pos)));
+
+			return sb.ToString ();
+			
+		}
+
+		public Parameter.Modifier ParameterModifier (int pos)
+		{
+			int len = pi.Length;
+			Parameter.Modifier pm = Parameter.Modifier.NONE;
+
+			if (pos >= len - 1)
+				if (last_arg_is_params) {
+					pm |= Parameter.Modifier.PARAMS;
+					pos = len - 1;
+				}
+			
+			Type t = pi [pos].ParameterType;
+			if (t.IsByRef)
+				pm |= Parameter.Modifier.ISBYREF | Parameter.Modifier.REF;
+
+			if (pi [pos].IsOptional)
+				pm |= Parameter.Modifier.OPTIONAL;
+			
+			return pm;
+		}
+
+		public int Count {
+			get {
+				return pi.Length;
+			}
+		}
+		
+	}
+
+	public class InternalParameters : ParameterData {
+		Type [] param_types;
+
+		public readonly Parameters Parameters;
+		
+		public InternalParameters (Type [] param_types, Parameters parameters)
+		{
+			this.param_types = param_types;
+			this.Parameters = parameters;
+		}
+
+		public InternalParameters (DeclSpace ds, Parameters parameters)
+			: this (parameters.GetParameterInfo (ds), parameters)
+		{
+		}
+
+		public int Count {
+			get {
+				if (param_types == null)
+					return 0;
+
+				return param_types.Length;
+			}
+		}
+
+		public Type ParameterType (int pos)
+		{
+			if (param_types == null)
+				return null;
+
+			Parameter [] fixed_pars = Parameters.FixedParameters;
+			if (fixed_pars != null && pos < fixed_pars.Length)
+				return Parameters.FixedParameters [pos].ParameterType;
+			else 
+				return Parameters.ArrayParameter.ParameterType;
+		}
+
+		public Expression DefaultValue (int pos)
+		{
+			Parameter [] fixed_pars = Parameters.FixedParameters;
+			if (fixed_pars != null && pos < fixed_pars.Length)
+				return Parameters.FixedParameters [pos].ParameterInitializer;
+			return null;
+		}
+
+		public string ParameterName (int pos)
+		{
+			Parameter p;
+
+			if (pos >= Parameters.FixedParameters.Length)
+				p = Parameters.ArrayParameter;
+			else
+				p = Parameters.FixedParameters [pos];
+
+			return p.Name;
+		}
+
+		public string ParameterDesc (int pos)
+		{
+			string tmp = String.Empty;
+			Parameter p;
+
+			if (Parameters.FixedParameters == null || pos >= Parameters.FixedParameters.Length)
+				p = Parameters.ArrayParameter;
+			else
+				p = Parameters.FixedParameters [pos];
+			
+			if (p.ModFlags == Parameter.Modifier.REF)
+				tmp = "ref ";
+			else if (p.ModFlags == Parameter.Modifier.PARAMS)
+				tmp = "params ";
+
+			Type t = ParameterType (pos);
+
+			return tmp + TypeManager.MonoBASIC_Name (t);
+		}
+
+		public Parameter.Modifier ParameterModifier (int pos)
+		{
+			Parameter.Modifier mod;
+
+			if (Parameters.FixedParameters == null) {
+				if (Parameters.ArrayParameter != null) 
+					mod = Parameters.ArrayParameter.ModFlags;
+				else
+					mod = Parameter.Modifier.NONE;
+			} else if (pos >= Parameters.FixedParameters.Length)
+				mod = Parameters.ArrayParameter.ModFlags;
+			else
+				mod = Parameters.FixedParameters [pos].ModFlags;
+
+			if ((mod & (Parameter.Modifier.REF )) != 0)
+				mod |= Parameter.Modifier.ISBYREF;
+
+			return mod;
+		}
+		
+	}
+
+	class PtrHashtable : Hashtable {
+		class PtrComparer : IComparer {
+			public int Compare (object x, object y)
+			{
+				if (x == y)
+					return 0;
+				else
+					return 1;
+			}
+		}
+		
+		public PtrHashtable ()
+		{
+			comparer = new PtrComparer ();
+			hcp = new CaseInsensitiveHashCodeProvider();
+		}
+	}
+	
+
+	public class CaseInsensitiveHashtable : Hashtable {
+		public CaseInsensitiveHashtable() : base()
+		{
+			comparer = new CaseInsensitiveComparer();
+			hcp = new CaseInsensitiveHashCodeProvider();
+		}
+	}
+
+	//
+	// Compares member infos based on their name and
+	// also allows one argument to be a string
+	//
+	class MemberInfoCompare : IComparer {
+
+		public int Compare (object a, object b)
+		{
+			if (a == null || b == null){
+				Console.WriteLine ("Invalid information passed");
+				throw new Exception ();
+			}
+			
+			if (a is string)
+				return String.Compare ((string) a, ((MemberInfo)b).Name);
+
+			if (b is string)
+				return String.Compare (((MemberInfo)a).Name, (string) b);
+
+			return String.Compare (((MemberInfo)a).Name, ((MemberInfo)b).Name);
+		}
+	}
+
+	struct Pair {
+		public object First;
+		public object Second;
+		
+		public Pair (object f, object s)
+		{
+			First = f;
+			Second = s;
+		}
+	}
+}
diff --git a/dead/mbas/tree.cs b/dead/mbas/tree.cs
new file mode 100644
index 00000000..4f424cd8
--- /dev/null
+++ b/dead/mbas/tree.cs
@@ -0,0 +1,109 @@
+//
+// tree.cs: keeps a tree representation of the generated code
+//
+// Author: Miguel de Icaza (miguel@gnu.org)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001 Ximian, Inc (http://www.ximian.com)
+//
+//
+
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+
+namespace Mono.MonoBASIC
+{
+
+	public interface ITreeDump {
+		int  Dump (Tree tree, StreamWriter output);
+		void ParseOptions (string options);
+	}
+
+	// <summary>
+	//   
+	//   We store here all the toplevel types that we have parsed,
+	//   this is the root of all information we have parsed.
+	// 
+	// </summary>
+	
+	public class Tree {
+		TypeContainer root_types;
+
+		// <summary>
+		//  Keeps track of namespaces defined in the source code
+		// </summary>
+		Hashtable namespaces;
+
+		// <summary>
+		//   Keeps track of all the types definied (classes, structs, ifaces, enums)
+		// </summary>
+		Hashtable decls;
+		
+		public Tree ()
+		{
+			root_types = new TypeContainer (null, "", null, new Location (-1, 0));
+
+			decls = new Hashtable ();
+			namespaces = new Hashtable ();
+		}
+
+		public void RecordDecl (string name, DeclSpace ds)
+		{
+			if (decls.Contains (name)){
+				Report.Error (
+					30179, ds.Location,
+					"There is already a definition for `" + name + "'");
+				DeclSpace other = (DeclSpace) decls [name];
+				Report.Error (0,
+					other.Location, "(Location of symbol related to previous error)");
+				return;
+			}
+			decls.Add (name, ds);
+		}
+		
+		public Namespace RecordNamespace (Namespace parent, string file, string name)
+		{
+			Namespace ns = new Namespace (parent, name);
+
+			if (namespaces.Contains (file)){
+				Hashtable ns_ns = (Hashtable) namespaces [file];
+
+				if (ns_ns.Contains (ns.Name))
+					return (Namespace) ns_ns [ns.Name];
+				ns_ns.Add (ns.Name, ns);
+			} else {
+				Hashtable new_table = new Hashtable ();
+				namespaces [file] = new_table;
+
+				new_table.Add (ns.Name, ns);
+			}
+
+			return ns;
+		}
+
+		//
+		// FIXME: Why are we using Types?
+		//
+                public TypeContainer Types {
+                        get {
+                                return root_types;
+                        }
+                }
+
+		public Hashtable Decls {
+			get {
+				return decls;
+			}
+		}
+
+		public Hashtable Namespaces {
+			get {
+				return namespaces;
+			}
+		}
+	}
+}
diff --git a/dead/mbas/typemanager.cs b/dead/mbas/typemanager.cs
new file mode 100644
index 00000000..00083be4
--- /dev/null
+++ b/dead/mbas/typemanager.cs
@@ -0,0 +1,2687 @@
+//
+// typemanager.cs: C# type manager
+//
+// Author: Miguel de Icaza (miguel@gnu.org)
+//         Ravi Pratap     (ravi@ximian.com)
+//         Manjula GHM     (mmanjula@novell.com)
+//
+// Licensed under the terms of the GNU GPL
+//
+// (C) 2001 Ximian, Inc (http://www.ximian.com)
+//
+//
+using System;
+using System.Globalization;
+using System.Collections;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Text.RegularExpressions;
+using System.Runtime.CompilerServices;
+using System.Diagnostics;
+
+namespace Mono.MonoBASIC {
+
+public class TypeManager {
+	//
+	// A list of core types that the compiler requires or uses
+	//
+	static public Type object_type;
+	static public Type value_type;
+	static public Type string_type;
+	static public Type int32_type;
+	static public Type uint32_type;
+	static public Type int64_type;
+	static public Type uint64_type;
+	static public Type float_type;
+	static public Type double_type;
+	static public Type char_type;
+	static public Type char_ptr_type;
+	static public Type short_type;
+	static public Type decimal_type;
+	static public Type date_type;
+	static public Type bool_type;
+	static public Type sbyte_type;
+	static public Type byte_type;
+	static public Type ushort_type;
+	static public Type enum_type;
+	static public Type delegate_type;
+	static public Type multicast_delegate_type;
+	static public Type void_type;
+	static public Type null_type;
+	static public Type enumeration_type;
+	static public Type array_type;
+	static public Type runtime_handle_type;
+	static public Type icloneable_type;
+	static public Type type_type;
+	static public Type ienumerator_type;
+	static public Type idisposable_type;
+	static public Type default_member_type;
+	static public Type iasyncresult_type;
+	static public Type asynccallback_type;
+	static public Type intptr_type;
+	static public Type monitor_type;
+	static public Type runtime_field_handle_type;
+	static public Type attribute_type;
+	static public Type attribute_usage_type;
+	static public Type decimal_constant_attribute_type;
+	static public Type dllimport_type;
+	static public Type unverifiable_code_type;
+	static public Type methodimpl_attr_type;
+	static public Type marshal_as_attr_type;
+	static public Type param_array_type;
+	static public Type void_ptr_type;
+	static public Type indexer_name_type;
+	static public Type exception_type;
+	static public object obsolete_attribute_type;
+	static public object conditional_attribute_type;
+
+	//
+	// An empty array of types
+	//
+	static public Type [] NoTypes;
+
+
+	// 
+	// Expressions representing the internal types.  Used during declaration
+	// definition.
+	//
+	static public TypeExpr system_object_expr, system_string_expr; 
+	static public TypeExpr system_boolean_expr, system_decimal_expr;
+	static public TypeExpr system_single_expr, system_double_expr;
+	static public TypeExpr system_sbyte_expr, system_byte_expr;
+	static public TypeExpr system_int16_expr, system_uint16_expr;
+	static public TypeExpr system_int32_expr, system_uint32_expr;
+	static public TypeExpr system_int64_expr, system_uint64_expr;
+	static public TypeExpr system_char_expr, system_void_expr;
+	static public TypeExpr system_date_expr;
+	static public TypeExpr system_asynccallback_expr;
+	static public TypeExpr system_iasyncresult_expr;
+
+	//
+	// This is only used when compiling corlib
+	//
+	static public Type system_int32_type;
+	static public Type system_array_type;
+	static public Type system_type_type;
+	static public Type system_assemblybuilder_type;
+	static public MethodInfo system_int_array_get_length;
+	static public MethodInfo system_int_array_get_rank;
+	static public MethodInfo system_object_array_clone;
+	static public MethodInfo system_int_array_get_length_int;
+	static public MethodInfo system_int_array_get_lower_bound_int;
+	static public MethodInfo system_int_array_get_upper_bound_int;
+	static public MethodInfo system_void_array_copyto_array_int;
+	static public MethodInfo system_void_set_corlib_type_builders;
+
+	
+	//
+	// Internal, not really used outside
+	//
+	static Type runtime_helpers_type;
+	
+	//
+	// These methods are called by code generated by the compiler
+	//
+	static public MethodInfo string_concat_string_string;
+	static public MethodInfo string_concat_object_object;
+	static public MethodInfo string_isinterneted_string;
+	static public MethodInfo system_type_get_type_from_handle;
+	static public MethodInfo object_getcurrent_void;
+	static public MethodInfo bool_movenext_void;
+	static public MethodInfo void_dispose_void;
+	static public MethodInfo void_monitor_enter_object;
+	static public MethodInfo void_monitor_exit_object;
+	static public MethodInfo void_initializearray_array_fieldhandle;
+	static public MethodInfo int_getlength_int;
+	static public MethodInfo delegate_combine_delegate_delegate;
+	static public MethodInfo delegate_remove_delegate_delegate;
+	static public MethodInfo int_get_offset_to_string_data;
+	static public MethodInfo int_array_get_length;
+	static public MethodInfo int_array_get_rank;
+	static public MethodInfo object_array_clone;
+	static public MethodInfo int_array_get_length_int;
+	static public MethodInfo int_array_get_lower_bound_int;
+	static public MethodInfo int_array_get_upper_bound_int;
+	static public MethodInfo void_array_copyto_array_int;
+	
+	//
+	// The attribute constructors.
+	//
+	static public ConstructorInfo cons_param_array_attribute;
+	static public ConstructorInfo void_decimal_ctor_five_args;
+	static public ConstructorInfo void_decimal_ctor_int_arg;
+	static public ConstructorInfo void_datetime_ctor_ticks_arg;
+	static public ConstructorInfo unverifiable_code_ctor;
+	static public ConstructorInfo default_member_ctor;
+	static public ConstructorInfo decimal_constant_attribute_ctor;
+	
+	// <remarks>
+	//   Holds the Array of Assemblies that have been loaded
+	//   (either because it is the default or the user used the
+	//   -r command line option)
+	// </remarks>
+	static Assembly [] assemblies;
+
+	// <remarks>
+	//  Keeps a list of module builders. We used this to do lookups
+	//  on the modulebuilder using GetType -- needed for arrays
+	// </remarks>
+	
+	// This is changed from list of ModuleBuilders 
+	// to list of Modules for getting addmodule 
+	// compiler option working
+	// Anirban - 13.07.2004
+
+	static System.Reflection.Module [] modules;
+
+	// <remarks>
+	//   This is the type_cache from the assemblies to avoid
+	//   hitting System.Reflection on every lookup.
+	// </summary>
+	static CaseInsensitiveHashtable types;
+
+	// <remarks>
+	//  This is used to hotld the corresponding TypeContainer objects
+	//  since we need this in FindMembers
+	// </remarks>
+	static CaseInsensitiveHashtable typecontainers;
+
+	// <remarks>
+	//   Keeps track of those types that are defined by the
+	//   user's program
+	// </remarks>
+	static ArrayList user_types;
+
+	static PtrHashtable builder_to_declspace;
+
+	// <remarks>
+	//   Tracks the interfaces implemented by typebuilders.  We only
+	//   enter those who do implement or or more interfaces
+	// </remarks>
+	static PtrHashtable builder_to_ifaces;
+
+	// <remarks>
+	//   Maps MethodBase.RuntimeTypeHandle to a Type array that contains
+	//   the arguments to the method
+	// </remarks>
+	static Hashtable method_arguments;
+
+	// <remarks>
+	//   Maps PropertyBuilder to a Type array that contains
+	//   the arguments to the indexer
+	// </remarks>
+	static Hashtable indexer_arguments;
+
+	// <remarks>
+	//   Maybe 'method_arguments' should be replaced and only
+	//   method_internal_params should be kept?
+	// <remarks>
+	static Hashtable method_internal_params;
+
+	// <remarks>
+	//  Keeps track of methods
+	// </remarks>
+
+	static Hashtable builder_to_method;
+
+	struct Signature {
+		public string name;
+		public Type [] args;
+	}
+
+	/// <summary>
+	///   A filter for Findmembers that uses the Signature object to
+	///   extract objects
+	/// </summary>
+	static bool SignatureFilter (MemberInfo mi, object criteria)
+	{
+		Signature sig = (Signature) criteria;
+
+		if (!(mi is MethodBase))
+			return false;
+		
+		if (mi.Name != sig.name)
+			return false;
+
+		int count = sig.args.Length;
+		
+		if (mi is MethodBuilder || mi is ConstructorBuilder){
+			Type [] candidate_args = GetArgumentTypes ((MethodBase) mi);
+
+			if (candidate_args.Length != count)
+				return false;
+			
+			for (int i = 0; i < count; i++)
+				if (candidate_args [i] != sig.args [i])
+					return false;
+			
+			return true;
+		} else {
+			ParameterInfo [] pars = ((MethodBase) mi).GetParameters ();
+
+			if (pars.Length != count)
+				return false;
+
+			for (int i = 0; i < count; i++)
+				if (pars [i].ParameterType != sig.args [i])
+					return false;
+			return true;
+		}
+	}
+
+	// A delegate that points to the filter above.
+	static MemberFilter signature_filter;
+
+	//
+	// These are expressions that represent some of the internal data types, used
+	// elsewhere
+	//
+	static void InitExpressionTypes ()
+	{
+		system_object_expr  = new TypeLookupExpression ("System.Object");
+		system_string_expr  = new TypeLookupExpression ("System.String");
+		system_boolean_expr = new TypeLookupExpression ("System.Boolean");
+		system_decimal_expr = new TypeLookupExpression ("System.Decimal");
+		system_single_expr  = new TypeLookupExpression ("System.Single");
+		system_double_expr  = new TypeLookupExpression ("System.Double");
+		system_sbyte_expr   = new TypeLookupExpression ("System.SByte");
+		system_byte_expr    = new TypeLookupExpression ("System.Byte");
+		system_int16_expr   = new TypeLookupExpression ("System.Int16");
+		system_uint16_expr  = new TypeLookupExpression ("System.UInt16");
+		system_int32_expr   = new TypeLookupExpression ("System.Int32");
+		system_uint32_expr  = new TypeLookupExpression ("System.UInt32");
+		system_int64_expr   = new TypeLookupExpression ("System.Int64");
+		system_uint64_expr  = new TypeLookupExpression ("System.UInt64");
+		system_char_expr    = new TypeLookupExpression ("System.Char");
+		system_void_expr    = new TypeLookupExpression ("System.Void");
+		system_date_expr    = new TypeLookupExpression ("System.DateTime");
+		system_asynccallback_expr = new TypeLookupExpression ("System.AsyncCallback");
+		system_iasyncresult_expr = new TypeLookupExpression ("System.IAsyncResult");
+	}
+	
+	static TypeManager ()
+	{
+		assemblies = new Assembly [0];
+		modules = null;
+		user_types = new ArrayList ();
+		
+		types = new CaseInsensitiveHashtable ();
+		negative_hits = new CaseInsensitiveHashtable ();
+		typecontainers = new CaseInsensitiveHashtable ();
+		
+		builder_to_declspace = new PtrHashtable ();
+		builder_to_method = new PtrHashtable ();
+		method_arguments = new PtrHashtable ();
+		method_internal_params = new PtrHashtable ();
+		indexer_arguments = new PtrHashtable ();
+		builder_to_ifaces = new PtrHashtable ();
+		
+		NoTypes = new Type [0];
+
+		signature_filter = new MemberFilter (SignatureFilter);
+		InitExpressionTypes ();
+	}
+
+	public static void AddUserType (string name, TypeBuilder t, Type [] ifaces)
+	{
+		try {
+			types.Add (name, t);
+		} catch {
+			Type prev = (Type) types [name];
+			TypeContainer tc = builder_to_declspace [prev] as TypeContainer;
+
+			if (tc != null){
+				//
+				// This probably never happens, as we catch this before
+				//
+				Report.Error (-17, "The type '" + name + "' has already been defined.");
+				return;
+			}
+
+			tc = builder_to_declspace [t] as TypeContainer;
+			
+			Report.Warning (
+				1595, "The type '" + name + "' is defined in an existing assembly;"+
+				" Using the new definition from: " + tc.Location);
+			Report.Warning (1595, "Previously defined in: " + prev.Assembly.FullName);
+			
+			types.Remove (name);
+			types.Add (name, t);
+		}
+		user_types.Add (t);
+			
+		if (ifaces != null)
+			builder_to_ifaces [t] = ifaces;
+	}
+
+	//
+	// This entry point is used by types that we define under the covers
+	// 
+	public static void RegisterBuilder (TypeBuilder tb, Type [] ifaces)
+	{
+		if (ifaces != null)
+			builder_to_ifaces [tb] = ifaces;
+	}
+	
+	public static void AddUserType (string name, TypeBuilder t, TypeContainer tc, Type [] ifaces)
+	{
+		builder_to_declspace.Add (t, tc);
+		typecontainers.Add (name, tc);
+		AddUserType (name, t, ifaces);
+	}
+
+	public static void AddDelegateType (string name, TypeBuilder t, Delegate del)
+	{
+		types.Add (name, t);
+		builder_to_declspace.Add (t, del);
+	}
+	
+	public static void AddEnumType (string name, TypeBuilder t, Enum en)
+	{
+		types.Add (name, t);
+		builder_to_declspace.Add (t, en);
+	}
+
+	public static void AddUserInterface (string name, TypeBuilder t, Interface i, Type [] ifaces)
+	{
+		AddUserType (name, t, ifaces);
+		builder_to_declspace.Add (t, i);
+	}
+
+	public static void AddMethod (MethodBuilder builder, MethodData method)
+	{
+		builder_to_method.Add (builder, method);
+	}
+
+	/// <summary>
+	///   Returns the TypeContainer whose Type is 't' or null if there is no
+	///   TypeContainer for 't' (ie, the Type comes from a library)
+	/// </summary>
+	public static TypeContainer LookupTypeContainer (Type t)
+	{
+		return builder_to_declspace [t] as TypeContainer;
+	}
+
+	public static IMemberContainer LookupMemberContainer (Type t)
+	{
+		if (t is TypeBuilder) {
+			IMemberContainer container = builder_to_declspace [t] as IMemberContainer;
+			if (container != null)
+				return container;
+		}
+
+		return TypeHandle.GetTypeHandle (t);
+	}
+
+	public static Interface LookupInterface (Type t)
+	{
+		return builder_to_declspace [t] as Interface;
+	}
+
+	public static Delegate LookupDelegate (Type t)
+	{
+		return builder_to_declspace [t] as Delegate;
+	}
+
+	public static Enum LookupEnum (Type t)
+	{
+		return builder_to_declspace [t] as Enum;
+	}
+
+	public static TypeContainer LookupClass (Type t)
+	{
+		return builder_to_declspace [t] as TypeContainer;
+	}
+	
+	/// <summary>
+	///   Registers an assembly to load types from.
+	/// </summary>
+	public static void AddAssembly (Assembly a)
+	{
+		int top = assemblies.Length;
+		Assembly [] n = new Assembly [top + 1];
+
+		assemblies.CopyTo (n, 0);
+		
+		n [top] = a;
+		assemblies = n;
+
+		foreach(Type type in a.GetTypes()) {
+			if (type.IsPublic ) // && type. attributed as standard module
+				AddStandardModule(type);
+		}
+	}
+
+	/// <summary>
+	///  Registers a module builder to lookup types from
+	/// </summary>
+	public static void AddModule (System.Reflection.Module mb)
+	{
+		int top = modules != null ? modules.Length : 0;
+		System.Reflection.Module [] n = new System.Reflection.Module [top + 1];
+
+		if (modules != null)
+			modules.CopyTo (n, 0);
+		n [top] = mb;
+		modules = n;
+	}
+
+	private class StandardModule {
+		public readonly string Namespace;
+		public readonly string Name;
+		private readonly string asString;
+		public StandardModule(string _namespace, string name) { 
+			Namespace = _namespace; 
+			Name = name; 
+			asString = ((Namespace != null && Namespace.Length > 0)?(Namespace + "."):"") + Name;
+		}
+		public override string ToString() { return asString; }
+	}
+
+	private static StandardModule[] standardModules;
+
+	/// <summary>
+	///  Registers a new 'standard module' to lookup short-qualified or unqualified members
+	/// </summary>
+	internal static void AddStandardModule(Module module)
+	{
+		int top = standardModules != null ? standardModules.Length : 0;
+		StandardModule [] n = new StandardModule [top + 1];
+
+		if (standardModules != null)
+			standardModules.CopyTo (n, 0);
+		string name = module.Name;
+		int split = name.LastIndexOf('.'); 
+		if (split > 0)
+			name = name.Substring(split+1);
+		n [top] = new StandardModule(module.Namespace.Name, name); 
+		// Console.WriteLine("Standard Module added: " + n [top]);
+		standardModules = n;
+	}
+
+	// 
+	//  Registers an existing 'standard module' to lookup short-qualified or unqualified members
+	// 
+	private static void AddStandardModule(Type type)
+	{
+	    object[] attributes = type.GetCustomAttributes(false);
+	    for (int i = 0; i < attributes.Length; i ++) {
+			if (attributes[i].ToString() == "Microsoft.VisualBasic.CompilerServices.StandardModuleAttribute") {
+				int top = standardModules != null ? standardModules.Length : 0;
+				StandardModule [] n = new StandardModule [top + 1];
+
+				if (standardModules != null)
+					standardModules.CopyTo (n, 0);
+				n [top] = new StandardModule(type.Namespace, type.Name) ;
+				standardModules = n;
+				return;
+			}
+        }
+	}
+
+	/// <summary>
+	/// Find types from pertinent standard modules (from those namespaces in the scope)
+	/// <summary>
+	public static Type[] GetPertinentStandardModules(params string[] namespaces)
+	{
+		ArrayList list = new ArrayList();
+		if (standardModules != null && namespaces != null) {
+			foreach(string Namespace in namespaces)
+			{ 
+				for(int i = 0; i < standardModules.Length; i++) {
+					if (standardModules[i].Namespace.ToLower () == Namespace.ToLower ()) {
+						string name = standardModules[i].ToString();
+						Type t = LookupType(name);
+						if (t == null) {
+							System.Console.WriteLine("Could not find standard module '" + name + "'"); 
+						}
+						else {
+							list.Add(t);
+						}
+					}
+				}
+			}
+		}
+		return (Type[])list.ToArray(typeof(Type));
+	}
+
+	//
+	// Low-level lookup, cache-less
+	//
+	static Type LookupTypeReflection (string name)
+	{
+		Type t;
+
+		try {
+			foreach (Assembly a in assemblies){
+				t = a.GetType (name, false, true);
+				if (t != null)
+					return t;
+			}
+
+			foreach (System.Reflection.Module mb in modules) {
+				t = mb.GetType (name, false, true);
+				if (t != null){
+					return t;
+				}
+			}
+		} catch (Exception e) {
+			System.Console.WriteLine("\nERROR: " + e.ToString() + "WHILE EXECUTING LookupTypeReflection(\"" + name + "\")\n");
+		}
+		return null;
+	}
+
+	static CaseInsensitiveHashtable negative_hits;
+	//
+	// This function is used when you want to avoid the lookups, and want to go
+	// directly to the source.  This will use the cache.
+	//
+	// Notice that bypassing the cache is bad, because on Microsoft.NET runtime
+	// GetType ("DynamicType[]") != GetType ("DynamicType[]"), and there is no
+	// way to test things other than doing a fullname compare
+	//
+	public static Type LookupTypeDirect (string name)
+	{
+		Type t = (Type) types [name];
+		if (t != null)
+			return t;
+
+		if (negative_hits.Contains (name))
+			return null;
+		t = LookupTypeReflection (name);
+		if (t == null)
+			negative_hits [name] = null;
+		else
+			types [name] = t;
+		return t;
+	}
+	
+	/// <summary>
+	///   Returns the Type associated with @name, takes care of the fact that
+	///   reflection expects nested types to be separated from the main type
+	///   with a "+" instead of a "."
+	/// </summary>
+	public static Type LookupType (string name)
+	{
+		Type t;
+
+		//
+		// First lookup in user defined and cached values
+		//
+
+		t = (Type) types [name];
+		if (t != null)
+			return t;
+
+		if (negative_hits.Contains (name))
+			return null;
+
+		//
+		// Optimization: ComposedCast will work with an existing type, and might already have the
+		// full name of the type, so the full system lookup can probably be avoided.
+		//
+		
+		string [] elements = name.Split ('.');
+		int count = elements.Length;
+
+		for (int n = 1; n <= count; n++){
+			string top_level_type = String.Join (".", elements, 0, n);
+
+			if (negative_hits.Contains (top_level_type))
+				continue;
+
+			t = (Type) types [top_level_type];
+			if (t == null){
+				t = LookupTypeReflection (top_level_type);
+				if (t == null){
+					negative_hits [top_level_type] = null;
+					continue;
+				}
+			}
+			
+			if (count == n){
+				types [name] = t;
+				return t;
+			} 
+			
+			string newt = top_level_type + "+" + String.Join ("+", elements, n, count - n);
+			t = LookupTypeReflection (newt);
+			if (t == null)
+				negative_hits [name] = null;
+			else
+				types [name] = t;
+			return t;
+		}
+		negative_hits [name] = null;
+		return null;
+	}
+
+	//
+	// Returns a list of all namespaces in the assemblies and types loaded.
+	//
+	public static CaseInsensitiveHashtable GetNamespaces ()
+	{
+		CaseInsensitiveHashtable namespaces = new CaseInsensitiveHashtable ();
+
+		foreach (Assembly a in assemblies) {
+			foreach (Type t in a.GetTypes ()) {
+				string ns = t.Namespace;
+
+				if (namespaces.Contains (ns))
+					continue;
+				namespaces [ns] = ns;
+			}
+		}
+
+		foreach (System.Reflection.Module mb in modules) {
+			foreach (Type t in mb.GetTypes ()) {
+				string ns = t.Namespace;
+
+				if (namespaces.Contains (ns))
+					continue;
+				namespaces [ns] = ns;
+			}
+		}
+
+		return namespaces;
+	}
+	
+	/// <summary>
+	///   Returns the C# name of a type if possible, or the full type name otherwise
+	/// </summary>
+	static public string MonoBASIC_Name (Type t)
+	{
+		return Regex.Replace (t.FullName, 
+			@"^System\." +
+			@"(Int32|Int16|Int64|Single|Double|Char|Decimal|Byte|Object|Boolean|String|DateTime)" +
+			@"(\W+|\b)", 
+			new MatchEvaluator (MonoBASIC_NameMatch));
+	}	
+	
+	static String MonoBASIC_NameMatch (Match match) 
+	{
+		string s = match.Groups [1].Captures [0].Value;
+		return s.ToLower ().
+		Replace ("int32", "integer").
+		Replace ("int16", "short").
+		Replace ("int64", "long").
+		Replace ("datetime", "date")
+		+ match.Groups [2].Captures [0].Value;
+	}
+
+        /// <summary>
+        ///   Returns the signature of the method
+        /// </summary>
+        static public string MonoBASIC_Signature (MethodBase mb)
+        {
+                string sig = "(";
+
+		//
+		// FIXME: We should really have a single function to do
+		// everything instead of the following 5 line pattern
+		//
+                ParameterData iparams = LookupParametersByBuilder (mb);
+
+		if (iparams == null){
+			ParameterInfo [] pi = mb.GetParameters ();
+			iparams = new ReflectionParameters (pi);
+		}
+		
+                for (int i = 0; i < iparams.Count; i++) {
+                        if (i > 0) {
+                                sig += ", ";
+                        }
+                        sig += iparams.ParameterDesc(i);
+                }
+                sig += ")";
+
+                return mb.DeclaringType.Name + "." + mb.Name + sig;
+        }
+
+	/// <summary>
+	///   Looks up a type, and aborts if it is not found.  This is used
+	///   by types required by the compiler
+	/// </summary>
+	static Type CoreLookupType (string name)
+	{
+		Type t = LookupType (name);
+
+		if (t == null){
+			Report.Error (518, "The predefined type '" + name + "' is not defined or imported");
+			Environment.Exit (0);
+		}
+
+		return t;
+	}
+
+	/// <summary>
+	///   Returns the MethodInfo for a method named 'name' defined
+	///   in type 't' which takes arguments of types 'args'
+	/// </summary>
+	static MethodInfo GetMethod (Type t, string name, Type [] args)
+	{
+		MemberList list;
+		Signature sig;
+
+		sig.name = name;
+		sig.args = args;
+		
+		list = FindMembers (t, MemberTypes.Method, instance_and_static | BindingFlags.Public| BindingFlags.IgnoreCase,
+				    signature_filter, sig);
+		if (list.Count == 0) {
+			Report.Error (-19, "Can not find the core function '" + name + "'");
+			return null;
+		}
+
+		MethodInfo mi = list [0] as MethodInfo;
+		if (mi == null) {
+			Report.Error (-19, "Can not find the core function '" + name + "'");
+			return null;
+		}
+
+		return mi;
+	}
+
+	/// <summary>
+	///    Returns the ConstructorInfo for "args"
+	/// </summary>
+	public static ConstructorInfo GetConstructor (Type t, Type [] args)
+	{
+		MemberList list;
+		Signature sig;
+
+		sig.name = ".ctor";
+		sig.args = args;
+		
+		list = FindMembers (t, MemberTypes.Constructor,
+				    instance_and_static | BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.IgnoreCase,
+				    signature_filter, sig);
+		if (list.Count == 0){
+			Report.Error (-19, "Can not find the core constructor for type '" + t.Name + "'");
+			return null;
+		}
+
+		ConstructorInfo ci = list [0] as ConstructorInfo;
+		if (ci == null){
+			Report.Error (-19, "Can not find the core constructor for type '" + t.Name + "'");
+			return null;
+		}
+
+		return ci;
+	}
+
+	public static void InitEnumUnderlyingTypes ()
+	{
+
+		int32_type    = CoreLookupType ("System.Int32");
+		int64_type    = CoreLookupType ("System.Int64");
+		uint32_type   = CoreLookupType ("System.UInt32"); 
+		uint64_type   = CoreLookupType ("System.UInt64"); 
+		byte_type     = CoreLookupType ("System.Byte");
+		sbyte_type    = CoreLookupType ("System.SByte");
+		short_type    = CoreLookupType ("System.Int16");
+		ushort_type   = CoreLookupType ("System.UInt16");
+	}
+	
+	/// <remarks>
+	///   The types have to be initialized after the initial
+	///   population of the type has happened (for example, to
+	///   bootstrap the corlib.dll
+	/// </remarks>
+	public static void InitCoreTypes ()
+	{
+		object_type   = CoreLookupType ("System.Object");
+		value_type    = CoreLookupType ("System.ValueType");
+
+		InitEnumUnderlyingTypes ();
+
+		char_type     = CoreLookupType ("System.Char");
+		string_type   = CoreLookupType ("System.String");
+		float_type    = CoreLookupType ("System.Single");
+		double_type   = CoreLookupType ("System.Double");
+		char_ptr_type = CoreLookupType ("System.Char*");
+		decimal_type  = CoreLookupType ("System.Decimal");
+		bool_type     = CoreLookupType ("System.Boolean");
+		enum_type     = CoreLookupType ("System.Enum");
+
+		multicast_delegate_type = CoreLookupType ("System.MulticastDelegate");
+		delegate_type           = CoreLookupType ("System.Delegate");
+
+		array_type    = CoreLookupType ("System.Array");
+		void_type     = CoreLookupType ("System.Void");
+		date_type	  = CoreLookupType ("System.DateTime");
+		type_type     = CoreLookupType ("System.Type");
+
+		runtime_field_handle_type = CoreLookupType ("System.RuntimeFieldHandle");
+		runtime_helpers_type = CoreLookupType ("System.Runtime.CompilerServices.RuntimeHelpers");
+		default_member_type  = CoreLookupType ("System.Reflection.DefaultMemberAttribute");
+		runtime_handle_type  = CoreLookupType ("System.RuntimeTypeHandle");
+		asynccallback_type   = CoreLookupType ("System.AsyncCallback");
+		iasyncresult_type    = CoreLookupType ("System.IAsyncResult");
+		ienumerator_type     = CoreLookupType ("System.Collections.IEnumerator");
+		idisposable_type     = CoreLookupType ("System.IDisposable");
+		icloneable_type      = CoreLookupType ("System.ICloneable");
+		monitor_type         = CoreLookupType ("System.Threading.Monitor");
+		intptr_type          = CoreLookupType ("System.IntPtr");
+
+		attribute_type       = CoreLookupType ("System.Attribute");
+		attribute_usage_type = CoreLookupType ("System.AttributeUsageAttribute");
+		dllimport_type       = CoreLookupType ("System.Runtime.InteropServices.DllImportAttribute");
+		methodimpl_attr_type = CoreLookupType ("System.Runtime.CompilerServices.MethodImplAttribute");
+		marshal_as_attr_type  = CoreLookupType ("System.Runtime.InteropServices.MarshalAsAttribute");
+		param_array_type      = CoreLookupType ("System.ParamArrayAttribute");
+		
+		decimal_constant_attribute_type = CoreLookupType ("System.Runtime.CompilerServices.DecimalConstantAttribute");	
+
+		unverifiable_code_type= CoreLookupType ("System.Security.UnverifiableCodeAttribute");
+
+		void_ptr_type         = CoreLookupType ("System.Void*");
+
+		indexer_name_type     = CoreLookupType ("System.Runtime.CompilerServices.IndexerNameAttribute");
+
+		exception_type        = CoreLookupType ("System.Exception");
+
+		//
+		// Attribute types
+		//
+		obsolete_attribute_type = CoreLookupType ("System.ObsoleteAttribute");
+		conditional_attribute_type = CoreLookupType ("System.Diagnostics.ConditionalAttribute");
+
+		//
+		// When compiling corlib, store the "real" types here.
+		//
+		if (!RootContext.StdLib) {
+			system_int32_type = typeof (System.Int32);
+			system_array_type = typeof (System.Array);
+			system_type_type = typeof (System.Type);
+			system_assemblybuilder_type = typeof (System.Reflection.Emit.AssemblyBuilder);
+
+			Type [] void_arg = {  };
+			system_int_array_get_length = GetMethod (
+				system_array_type, "get_Length", void_arg);
+			system_int_array_get_rank = GetMethod (
+				system_array_type, "get_Rank", void_arg);
+			system_object_array_clone = GetMethod (
+				system_array_type, "Clone", void_arg);
+
+			Type [] system_int_arg = { system_int32_type };
+			system_int_array_get_length_int = GetMethod (
+				system_array_type, "GetLength", system_int_arg);
+			system_int_array_get_upper_bound_int = GetMethod (
+				system_array_type, "GetUpperBound", system_int_arg);
+			system_int_array_get_lower_bound_int = GetMethod (
+				system_array_type, "GetLowerBound", system_int_arg);
+
+			Type [] system_array_int_arg = { system_array_type, system_int32_type };
+			system_void_array_copyto_array_int = GetMethod (
+				system_array_type, "CopyTo", system_array_int_arg);
+
+			Type [] system_type_type_arg = { system_type_type, system_type_type, system_type_type };
+
+			try {
+			system_void_set_corlib_type_builders = GetMethod (
+				system_assemblybuilder_type, "SetCorlibTypeBuilders",
+				system_type_type_arg);
+
+			object[] args = new object [3];
+			args [0] = object_type;
+			args [1] = value_type;
+			args [2] = enum_type;
+
+			system_void_set_corlib_type_builders.Invoke (CodeGen.AssemblyBuilder, args);
+			} catch {
+				Console.WriteLine ("Corlib compilation is not supported in Microsoft.NET due to bugs in it");
+			}
+		}
+
+		null_type = typeof (NullType);
+	}
+
+	//
+	// The helper methods that are used by the compiler
+	//
+	public static void InitCodeHelpers ()
+	{
+		//
+		// Now load the default methods that we use.
+		//
+		Type [] string_string = { string_type, string_type };
+		string_concat_string_string = GetMethod (
+			string_type, "Concat", string_string);
+
+		Type [] object_object = { object_type, object_type };
+		string_concat_object_object = GetMethod (
+			string_type, "Concat", object_object);
+
+		Type [] string_ = { string_type };
+		string_isinterneted_string = GetMethod (
+			string_type, "IsInterned", string_);
+		
+		Type [] runtime_type_handle = { runtime_handle_type };
+		system_type_get_type_from_handle = GetMethod (
+			type_type, "GetTypeFromHandle", runtime_type_handle);
+
+		Type [] delegate_delegate = { delegate_type, delegate_type };
+		delegate_combine_delegate_delegate = GetMethod (
+				delegate_type, "Combine", delegate_delegate);
+
+		delegate_remove_delegate_delegate = GetMethod (
+				delegate_type, "Remove", delegate_delegate);
+
+		//
+		// Void arguments
+		//
+		Type [] void_arg = {  };
+		object_getcurrent_void = GetMethod (
+			ienumerator_type, "get_Current", void_arg);
+		bool_movenext_void = GetMethod (
+			ienumerator_type, "MoveNext", void_arg);
+		void_dispose_void = GetMethod (
+			idisposable_type, "Dispose", void_arg);
+		int_get_offset_to_string_data = GetMethod (
+			runtime_helpers_type, "get_OffsetToStringData", void_arg);
+		int_array_get_length = GetMethod (
+			array_type, "get_Length", void_arg);
+		int_array_get_rank = GetMethod (
+			array_type, "get_Rank", void_arg);
+
+		//
+		// Int32 arguments
+		//
+		Type [] int_arg = { int32_type };
+		int_array_get_length_int = GetMethod (
+			array_type, "GetLength", int_arg);
+		int_array_get_upper_bound_int = GetMethod (
+			array_type, "GetUpperBound", int_arg);
+		int_array_get_lower_bound_int = GetMethod (
+			array_type, "GetLowerBound", int_arg);
+
+		//
+		// System.Array methods
+		//
+		object_array_clone = GetMethod (
+			array_type, "Clone", void_arg);
+		Type [] array_int_arg = { array_type, int32_type };
+		void_array_copyto_array_int = GetMethod (
+			array_type, "CopyTo", array_int_arg);
+		
+		//
+		// object arguments
+		//
+		Type [] object_arg = { object_type };
+		void_monitor_enter_object = GetMethod (
+			monitor_type, "Enter", object_arg);
+		void_monitor_exit_object = GetMethod (
+			monitor_type, "Exit", object_arg);
+
+		Type [] array_field_handle_arg = { array_type, runtime_field_handle_type };
+		
+		void_initializearray_array_fieldhandle = GetMethod (
+			runtime_helpers_type, "InitializeArray", array_field_handle_arg);
+
+		//
+		// Array functions
+		//
+		int_getlength_int = GetMethod (
+			array_type, "GetLength", int_arg);
+
+		//
+		// Decimal constructors
+		//
+		Type [] dec_arg = { int32_type, int32_type, int32_type, bool_type, byte_type };
+		void_decimal_ctor_five_args = GetConstructor (
+			decimal_type, dec_arg);
+		void_decimal_ctor_int_arg = GetConstructor (decimal_type, int_arg);
+
+		
+		// DateTime constructor
+		Type [] ticks_arg = { int64_type };
+		void_datetime_ctor_ticks_arg = GetConstructor ( date_type, ticks_arg);
+		
+		//
+		// Attributes
+		//
+		cons_param_array_attribute = GetConstructor (
+			param_array_type, void_arg);
+
+		unverifiable_code_ctor = GetConstructor (
+			unverifiable_code_type, void_arg);
+		
+		default_member_ctor = GetConstructor (
+			default_member_type, string_);
+
+		 decimal_constant_attribute_ctor = GetConstructor (decimal_constant_attribute_type, new Type []
+                        { byte_type, byte_type, uint32_type, uint32_type, uint32_type } );
+
+	}
+
+	const BindingFlags instance_and_static = BindingFlags.Static | BindingFlags.Instance;
+
+	//static CaseInsensitiveHashtable type_hash = new CaseInsensitiveHashtable ();
+
+	/// <remarks>
+	///   This is the "old", non-cache based FindMembers() function.  We cannot use
+	///   the cache here because there is no member name argument.
+	/// </remarks>
+	public static MemberList FindMembers (Type t, MemberTypes mt, BindingFlags bf,
+					      MemberFilter filter, object criteria)
+	{
+		DeclSpace decl = (DeclSpace) builder_to_declspace [t];
+		bf |= BindingFlags.IgnoreCase;
+		//
+		// 'builder_to_declspace' contains all dynamic types.
+		//
+		if (decl != null) {
+			MemberList list;
+			Timer.StartTimer (TimerType.FindMembers);
+			list = decl.FindMembers (mt, bf, filter, criteria);
+			Timer.StopTimer (TimerType.FindMembers);
+			return list;
+		}
+
+		//
+		// We have to take care of arrays specially, because GetType on
+		// a TypeBuilder array will return a Type, not a TypeBuilder,
+		// and we can not call FindMembers on this type.
+		//
+		if (t.IsSubclassOf (TypeManager.array_type))
+			return new MemberList (TypeManager.array_type.FindMembers (mt, bf, filter, criteria));
+
+		//
+		// Since FindMembers will not lookup both static and instance
+		// members, we emulate this behaviour here.
+		//
+		if ((bf & instance_and_static) == instance_and_static){
+			MemberInfo [] i_members = t.FindMembers (
+				mt, (bf & ~BindingFlags.Static) | BindingFlags.IgnoreCase, filter, criteria);
+
+			int i_len = i_members.Length;
+			if (i_len == 1){
+				MemberInfo one = i_members [0];
+
+				//
+				// If any of these are present, we are done!
+				//
+				if ((one is Type) || (one is EventInfo) || (one is FieldInfo))
+					return new MemberList (i_members);
+			}
+				
+			MemberInfo [] s_members = t.FindMembers (
+				mt, (bf & ~BindingFlags.Instance) | BindingFlags.IgnoreCase, filter, criteria);
+
+			int s_len = s_members.Length;
+			if (i_len > 0 || s_len > 0)
+				return new MemberList (i_members, s_members);
+			else {
+				if (i_len > 0)
+					return new MemberList (i_members);
+				else
+					return new MemberList (s_members);
+			}
+		}
+
+		return new MemberList (t.FindMembers (mt, bf, filter, criteria));
+	}
+
+
+	/// <summary>
+	///   This method is only called from within MemberLookup.  It tries to use the member
+	///   cache if possible and falls back to the normal FindMembers if not.  The 'used_cache'
+	///   flag tells the caller whether we used the cache or not.  If we used the cache, then
+	///   our return value will already contain all inherited members and the caller don't need
+	///   to check base classes and interfaces anymore.
+	/// </summary>
+	private static MemberList MemberLookup_FindMembers (Type t, MemberTypes mt, BindingFlags bf,
+							    string name, out bool used_cache)
+	{
+		//
+		// We have to take care of arrays specially, because GetType on
+		// a TypeBuilder array will return a Type, not a TypeBuilder,
+		// and we can not call FindMembers on this type.
+		//
+		if (t.IsSubclassOf (TypeManager.array_type)) {
+			used_cache = true;
+			return TypeHandle.ArrayType.MemberCache.FindMembers (
+				mt, bf, name, FilterWithClosure_delegate, null);
+		}
+
+		//
+		// If this is a dynamic type, it's always in the 'builder_to_declspace' hash table
+		// and we can ask the DeclSpace for the MemberCache.
+		//
+		if (t is TypeBuilder) {
+			DeclSpace decl = (DeclSpace) builder_to_declspace [t];
+			MemberCache cache = decl.MemberCache;
+
+			//
+			// If this DeclSpace has a MemberCache, use it.
+			//
+
+			if (cache != null) {
+				used_cache = true;
+				return cache.FindMembers (
+					mt, bf, name, FilterWithClosure_delegate, null);
+			}
+
+			// If there is no MemberCache, we need to use the "normal" FindMembers.
+
+			MemberList list;
+			Timer.StartTimer (TimerType.FindMembers);
+			list = decl.FindMembers (mt, bf | BindingFlags.DeclaredOnly | BindingFlags.IgnoreCase,
+						 FilterWithClosure_delegate, name);
+			Timer.StopTimer (TimerType.FindMembers);
+			used_cache = false;
+			return list;
+		}
+
+		//
+		// This call will always succeed.  There is exactly one TypeHandle instance per
+		// type, TypeHandle.GetTypeHandle() will either return it or create a new one
+		// if it didn't already exist.
+		//
+		TypeHandle handle = TypeHandle.GetTypeHandle (t);
+
+		used_cache = true;
+		return handle.MemberCache.FindMembers (mt, bf, name, FilterWithClosure_delegate, null);
+	}
+
+	public static bool IsBuiltinType (Type t)
+	{
+		if (t == object_type || t == string_type || t == int32_type || t == uint32_type ||
+		    t == int64_type || t == uint64_type || t == float_type || t == double_type ||
+		    t == char_type || t == short_type || t == decimal_type || t == bool_type ||
+		    t == sbyte_type || t == byte_type || t == ushort_type || t == void_type ||
+			t == date_type)
+			return true;
+		else
+			return false;
+	}
+
+	public static bool IsDelegateType (Type t)
+	{
+		if (t.IsSubclassOf (TypeManager.delegate_type))
+			return true;
+		else
+			return false;
+	}
+	
+	public static bool IsEnumType (Type t)
+	{
+		if (t.IsSubclassOf (TypeManager.enum_type))
+			return true;
+		else
+			return false;
+	}
+
+	//
+	// Whether a type is unmanaged.  This is used by the unsafe code (25.2)
+	//
+	public static bool IsUnmanagedType (Type t)
+	{
+		if (IsBuiltinType (t) && t != TypeManager.string_type)
+			return true;
+
+		if (IsEnumType (t))
+			return true;
+
+		if (t.IsPointer)
+			return true;
+
+		if (IsValueType (t)){
+			if (t is TypeBuilder){
+				TypeContainer tc = LookupTypeContainer (t);
+
+				foreach (Field f in tc.Fields){
+					if (f.FieldBuilder.IsStatic)
+						continue;
+					if (!IsUnmanagedType (f.FieldBuilder.FieldType))
+						return false;
+				}
+			} else {
+				FieldInfo [] fields = t.GetFields ();
+
+				foreach (FieldInfo f in fields){
+					if (f.IsStatic)
+						continue;
+					if (!IsUnmanagedType (f.FieldType))
+						return false;
+				}
+			}
+			return true;
+		}
+
+		return false;
+	}
+		
+	public static bool IsValueType (Type t)
+	{
+		if (t.IsSubclassOf (TypeManager.value_type))
+			return true;
+		else
+			return false;
+	}
+	
+	public static bool IsInterfaceType (Type t)
+	{
+		Interface iface = builder_to_declspace [t] as Interface;
+
+		if (iface != null)
+			return true;
+		else
+			return false;
+	}
+
+	//
+	// Checks whether 'type' is a subclass or nested child of 'parent'.
+	//
+	public static bool IsSubclassOrNestedChildOf (Type type, Type parent)
+	{
+		do {
+			if ((type == parent) || type.IsSubclassOf (parent))
+				return true;
+
+			// Handle nested types.
+			type = type.DeclaringType;
+		} while (type != null);
+
+		return false;
+	}
+
+	//
+	// Checks whether 'type' is a nested child of 'parent'.
+	//
+	public static bool IsNestedChildOf (Type type, Type parent)
+	{
+		if ((type == parent) || type.IsSubclassOf (parent))
+			return false;
+		else
+			return IsSubclassOrNestedChildOf (type, parent);
+	}
+
+	/// <summary>
+	///   Returns the User Defined Types
+	/// </summary>
+	public static ArrayList UserTypes {
+		get {
+			return user_types;
+		}
+	}
+
+	public static CaseInsensitiveHashtable TypeContainers {
+		get {
+			return typecontainers;
+		}
+	}
+
+	static Hashtable builder_to_constant;
+
+	public static void RegisterConstant (FieldBuilder fb, Const c)
+	{
+		if (builder_to_constant == null)
+			builder_to_constant = new PtrHashtable ();
+
+		if (builder_to_constant.Contains (fb))
+			return;
+
+		builder_to_constant.Add (fb, c);
+	}
+
+	public static Const LookupConstant (FieldBuilder fb)
+	{
+		if (builder_to_constant == null)
+			return null;
+		
+		return (Const) builder_to_constant [fb];
+	}
+	
+	/// <summary>
+	///   Gigantic work around for missing features in System.Reflection.Emit follows.
+	/// </summary>
+	///
+	/// <remarks>
+	///   Since System.Reflection.Emit can not return MethodBase.GetParameters
+	///   for anything which is dynamic, and we need this in a number of places,
+	///   we register this information here, and use it afterwards.
+	/// </remarks>
+	static public bool RegisterMethod (MethodBase mb, InternalParameters ip, Type [] args)
+	{
+		if (args == null)
+			args = NoTypes;
+				
+		method_arguments.Add (mb, args);
+		method_internal_params.Add (mb, ip);
+		
+		return true;
+	}
+	
+	static public InternalParameters LookupParametersByBuilder (MethodBase mb)
+	{
+		if (! (mb is ConstructorBuilder || mb is MethodBuilder))
+			return null;
+		
+		if (method_internal_params.Contains (mb))
+			return (InternalParameters) method_internal_params [mb];
+		else
+			throw new Exception ("Argument for Method not registered" + mb);
+	}
+
+	/// <summary>
+	///    Returns the argument types for a method based on its methodbase
+	///
+	///    For dynamic methods, we use the compiler provided types, for
+	///    methods from existing assemblies we load them from GetParameters,
+	///    and insert them into the cache
+	/// </summary>
+	static public Type [] GetArgumentTypes (MethodBase mb)
+	{
+		if (method_arguments.Contains (mb))
+			return (Type []) method_arguments [mb];
+		else {
+			ParameterInfo [] pi = mb.GetParameters ();
+			int c = pi.Length;
+			Type [] types = new Type [c];
+			
+			for (int i = 0; i < c; i++)
+				types [i] = pi [i].ParameterType;
+
+			method_arguments.Add (mb, types);
+			return types;
+		}
+	}
+
+	/// <summary>
+	///    Returns the argument types for an indexer based on its PropertyInfo
+	///
+	///    For dynamic indexers, we use the compiler provided types, for
+	///    indexers from existing assemblies we load them from GetParameters,
+	///    and insert them into the cache
+	/// </summary>
+	static public Type [] GetArgumentTypes (PropertyInfo indexer)
+	{
+		if (indexer_arguments.Contains (indexer))
+			return (Type []) indexer_arguments [indexer];
+		else {
+			// If we're a PropertyBuilder and not in the
+			// 'indexer_arguments' hash, then we're a property and
+			// not an indexer.
+
+			MethodInfo mi = indexer.GetSetMethod (true);
+			if (mi == null) {
+				mi = indexer.GetGetMethod (true);
+				if (mi == null)
+					return NoTypes;
+			}
+
+			ParameterInfo [] pi = mi.GetParameters ();
+			if (pi == null)
+				return NoTypes;
+
+			int c = pi.Length;
+			Type [] types = new Type [c];
+			
+			for (int i = 0; i < c; i++)
+				types [i] = pi [i].ParameterType;
+
+			indexer_arguments.Add (indexer, types);
+			return types;
+		}
+		/*else 
+		{
+			ParameterInfo [] pi = indexer.GetIndexParameters ();
+			// Property, not an indexer.
+			if (pi == null)
+				return NoTypes;
+			int c = pi.Length;
+			Type [] types = new Type [c];
+			
+			for (int i = 0; i < c; i++)
+				types [i] = pi [i].ParameterType;
+
+			indexer_arguments.Add (indexer, types);
+			return types;
+		}*/
+	}
+	
+	// <remarks>
+	//  This is a workaround the fact that GetValue is not
+	//  supported for dynamic types
+	// </remarks>
+	static CaseInsensitiveHashtable fields = new CaseInsensitiveHashtable ();
+	static public bool RegisterFieldValue (FieldBuilder fb, object value)
+	{
+		if (fields.Contains (fb))
+			return false;
+
+		fields.Add (fb, value);
+
+		return true;
+	}
+
+	static public object GetValue (FieldBuilder fb)
+	{
+		return fields [fb];
+	}
+
+	static CaseInsensitiveHashtable fieldbuilders_to_fields = new CaseInsensitiveHashtable ();
+	static public bool RegisterFieldBase (FieldBuilder fb, FieldBase f)
+	{
+		if (fieldbuilders_to_fields.Contains (fb))
+			return false;
+
+		fieldbuilders_to_fields.Add (fb, f);
+		return true;
+	}
+
+	static public FieldBase GetField (FieldInfo fb)
+	{
+		return (FieldBase) fieldbuilders_to_fields [fb];
+	}
+	
+	static CaseInsensitiveHashtable events;
+
+	static public bool RegisterEvent (MyEventBuilder eb, MethodBase add, MethodBase remove)
+	{
+		if (events == null)
+			events = new CaseInsensitiveHashtable ();
+
+		if (events.Contains (eb))
+			return false;
+
+		events.Add (eb, new Pair (add, remove));
+
+		return true;
+	}
+
+	static public MethodInfo GetAddMethod (EventInfo ei)
+	{
+		if (ei is MyEventBuilder) {
+			Pair pair = (Pair) events [ei];
+
+			return (MethodInfo) pair.First;
+		} else
+			return ei.GetAddMethod ();
+	}
+
+	static public MethodInfo GetRemoveMethod (EventInfo ei)
+	{
+		if (ei is MyEventBuilder) {
+			Pair pair = (Pair) events [ei];
+
+			return (MethodInfo) pair.Second;
+		} else
+			return ei.GetAddMethod ();
+	}
+
+	static CaseInsensitiveHashtable priv_fields_events;
+
+	static public bool RegisterPrivateFieldOfEvent (EventInfo einfo, FieldBuilder builder)
+	{
+		if (priv_fields_events == null)
+			priv_fields_events = new CaseInsensitiveHashtable ();
+
+		if (priv_fields_events.Contains (einfo))
+			return false;
+
+		priv_fields_events.Add (einfo, builder);
+
+		return true;
+	}
+
+	static public MemberInfo GetPrivateFieldOfEvent (EventInfo ei)
+	{
+		return (MemberInfo) priv_fields_events [ei];
+	}
+		
+	static CaseInsensitiveHashtable properties;
+	
+	static public bool RegisterProperty (PropertyBuilder pb, MethodBase get, MethodBase set)
+	{
+		if (properties == null)
+			properties = new CaseInsensitiveHashtable ();
+
+		if (properties.Contains (pb))
+			return false;
+
+		properties.Add (pb, new Pair (get, set));
+		indexer_arguments.Add (pb, NoTypes);
+
+		return true;
+	}
+
+	static public bool RegisterIndexer (PropertyBuilder pb, MethodBase get, MethodBase set, Type[] args)
+	{
+		if (!RegisterProperty (pb, get,set))
+			return false;
+
+		indexer_arguments.Add (pb, args);
+
+		return true;
+	}
+
+	static public MethodInfo GetPropertyGetter (PropertyInfo pi)
+	{
+		if (pi is PropertyBuilder){
+			Pair de = (Pair) properties [pi];
+
+			return (MethodInfo) de.Second;
+		} else
+			return pi.GetSetMethod (true);
+	}
+
+	static public MethodInfo GetPropertySetter (PropertyInfo pi)
+	{
+		if (pi is PropertyBuilder){
+			Pair de = (Pair) properties [pi];
+
+			return (MethodInfo) de.First;
+		} else
+			return pi.GetGetMethod (true);
+	}
+
+	/// <summary>
+	///   Given an array of interface types, expand and eliminate repeated ocurrences
+	///   of an interface.  
+	/// </summary>
+	///
+	/// <remarks>
+	///   This expands in context like: IA; IB : IA; IC : IA, IB; the interface "IC" to
+	///   be IA, IB, IC.
+	/// </remarks>
+
+	public static Type [] ExpandInterfaces (Type [] base_interfaces)
+	{	
+		ArrayList new_ifaces = new ArrayList();
+		ExpandAllInterfaces (base_interfaces, ref new_ifaces);
+		Type [] ret = new Type [new_ifaces.Count];
+		new_ifaces.CopyTo (ret, 0);
+		
+		return ret;
+	}
+
+	/// <summary>
+	///   Recursively finds out each base interface in case  
+	///   of multiple inheritance
+	/// </summary>
+	public static void ExpandAllInterfaces 
+			(Type [] base_interfaces, ref ArrayList new_ifaces)
+	{
+		foreach (Type iface in base_interfaces) {
+			if (!new_ifaces.Contains (iface))
+				new_ifaces.Add (iface);
+			
+			Type [] implementing = TypeManager.GetInterfaces (iface);
+			//
+			// Incase any base interface is present call this function again
+			//
+			if (implementing.Length != 0)
+				ExpandAllInterfaces (implementing, ref new_ifaces);
+		}
+	}
+		
+	/// <summary>
+	///   This function returns the interfaces in the type 't'.  Works with
+	///   both types and TypeBuilders.
+	/// </summary>
+	public static Type [] GetInterfaces (Type t)
+	{
+		//
+		// The reason for catching the Array case is that Reflection.Emit
+		// will not return a TypeBuilder for Array types of TypeBuilder types,
+		// but will still throw an exception if we try to call GetInterfaces
+		// on the type.
+		//
+		// Since the array interfaces are always constant, we return those for
+		// the System.Array
+		//
+		
+		if (t.IsArray)
+			t = TypeManager.array_type;
+		
+		if (t is TypeBuilder){
+			Type [] parent_ifaces;
+			
+			if (t.BaseType == null)
+				parent_ifaces = NoTypes;
+			else
+				parent_ifaces = GetInterfaces (t.BaseType);
+			Type [] type_ifaces = (Type []) builder_to_ifaces [t];
+			if (type_ifaces == null)
+				type_ifaces = NoTypes;
+
+			int parent_count = parent_ifaces.Length;
+			Type [] result = new Type [parent_count + type_ifaces.Length];
+			parent_ifaces.CopyTo (result, 0);
+			type_ifaces.CopyTo (result, parent_count);
+
+			return result;
+		} else
+			return t.GetInterfaces ();
+	}
+	
+	/// <remarks>
+	///  The following is used to check if a given type implements an interface.
+	///  The cache helps us reduce the expense of hitting Type.GetInterfaces everytime.
+	/// </remarks>
+	public static bool ImplementsInterface (Type t, Type iface)
+	{
+		Type [] interfaces;
+
+		//
+		// FIXME OPTIMIZATION:
+		// as soon as we hit a non-TypeBuiler in the interface
+		// chain, we could return, as the 'Type.GetInterfaces'
+		// will return all the interfaces implement by the type
+		// or its parents.
+		//
+		do {
+			interfaces = GetInterfaces (t);
+
+			if (interfaces != null){
+				foreach (Type i in interfaces){
+					if (i == iface)
+						return true;
+				}
+			}
+			
+			t = t.BaseType;
+		} while (t != null);
+		
+		return false;
+	}
+
+	// This is a custom version of Convert.ChangeType() which works
+	// with the TypeBuilder defined types when compiling corlib.
+
+	// This function is used by DoDefineMember () in enum.cs
+	// After replacing it with ChangeType1() following function
+  	// can be removed
+	
+	public static object ChangeType (object value, Type conversionType)
+	{
+		if (!(value is IConvertible))
+			throw new ArgumentException ();
+
+		IConvertible convertValue = (IConvertible) value;
+		CultureInfo ci = CultureInfo.CurrentCulture;
+		NumberFormatInfo provider = ci.NumberFormat;
+
+		//
+		// We must use Type.Equals() here since 'conversionType' is
+		// the TypeBuilder created version of a system type and not
+		// the system type itself.  You cannot use Type.GetTypeCode()
+		// on such a type - it'd always return TypeCode.Object.
+		//
+		if (conversionType.Equals (typeof (Boolean)))
+			return (object)(convertValue.ToBoolean (provider));
+		else if (conversionType.Equals (typeof (Byte)))
+			return (object)(convertValue.ToByte (provider));
+		else if (conversionType.Equals (typeof (Char)))
+			return (object)(convertValue.ToChar (provider));
+		else if (conversionType.Equals (typeof (DateTime)))
+			return (object)(convertValue.ToDateTime (provider));
+		else if (conversionType.Equals (typeof (Decimal)))
+			return (object)(convertValue.ToDecimal (provider));
+		else if (conversionType.Equals (typeof (Double)))
+			return (object)(convertValue.ToDouble (provider));
+		else if (conversionType.Equals (typeof (Int16)))
+			return (object)(convertValue.ToInt16 (provider));
+		else if (conversionType.Equals (typeof (Int32)))
+			return (object)(convertValue.ToInt32 (provider));
+		else if (conversionType.Equals (typeof (Int64)))
+			return (object)(convertValue.ToInt64 (provider));
+		else if (conversionType.Equals (typeof (SByte)))
+			return (object)(convertValue.ToSByte (provider));
+		else if (conversionType.Equals (typeof (Single)))
+			return (object)(convertValue.ToSingle (provider));
+		else if (conversionType.Equals (typeof (String)))
+			return (object)(convertValue.ToString (provider));
+		else if (conversionType.Equals (typeof (UInt16)))
+			return (object)(convertValue.ToUInt16 (provider));
+		else if (conversionType.Equals (typeof (UInt32)))
+			return (object)(convertValue.ToUInt32 (provider));
+		else if (conversionType.Equals (typeof (UInt64)))
+			return (object)(convertValue.ToUInt64 (provider));
+		else if (conversionType.Equals (typeof (Object)))
+			return (object)(value);
+		else 
+			throw new InvalidCastException ();
+	}
+
+	static NumberFormatInfo nf_provider = CultureInfo.CurrentCulture.NumberFormat;
+
+	 public static object ChangeType1 (object value, Type conversionType, out bool error)
+        {
+                IConvertible convert_value = value as IConvertible;
+
+                if (convert_value == null){
+                        error = true;
+                        return null;
+                }
+
+                //
+                // We must use Type.Equals() here since `conversionType' is
+                // the TypeBuilder created version of a system type and not
+                // the system type itself.  You cannot use Type.GetTypeCode()
+                // on such a type - it'd always return TypeCode.Object.
+                //
+                error = false;
+                try {
+                        if (conversionType.Equals (typeof (Boolean)))
+                                return (object)(convert_value.ToBoolean (nf_provider));
+                        else if (conversionType.Equals (typeof (Byte)))
+                                return (object)(convert_value.ToByte (nf_provider));
+                        else if (conversionType.Equals (typeof (Char)))
+                                return (object)(convert_value.ToChar (nf_provider));
+                        else if (conversionType.Equals (typeof (DateTime)))
+                                return (object)(convert_value.ToDateTime (nf_provider));
+			 else if (conversionType.Equals (TypeManager.decimal_type)) // typeof (Decimal)))
+                                return (object)(convert_value.ToDecimal (nf_provider));
+                        else if (conversionType.Equals (typeof (Double)))
+                                return (object)(convert_value.ToDouble (nf_provider));
+                        else if (conversionType.Equals (typeof (Int16)))
+                                return (object)(convert_value.ToInt16 (nf_provider));
+                        else if (conversionType.Equals (typeof (Int32)))
+                                return (object)(convert_value.ToInt32 (nf_provider));
+                        else if (conversionType.Equals (typeof (Int64)))
+                                return (object)(convert_value.ToInt64 (nf_provider));
+                        else if (conversionType.Equals (typeof (SByte)))
+                                return (object)(convert_value.ToSByte (nf_provider));
+                        else if (conversionType.Equals (typeof (Single)))
+                                return (object)(convert_value.ToSingle (nf_provider));
+                        else if (conversionType.Equals (typeof (String)))
+                                return (object)(convert_value.ToString (nf_provider));
+                        else if (conversionType.Equals (typeof (UInt16)))
+                                return (object)(convert_value.ToUInt16 (nf_provider));
+                        else if (conversionType.Equals (typeof (UInt32)))
+                                return (object)(convert_value.ToUInt32 (nf_provider));
+                        else if (conversionType.Equals (typeof (UInt64)))
+                                return (object)(convert_value.ToUInt64 (nf_provider));
+                        else if (conversionType.Equals (typeof (Object)))
+                                return (object)(value);
+                        else
+                                error = true;
+                } catch {
+                        error = true;
+		}
+                return null;
+        }
+
+
+	//
+	// This is needed, because enumerations from assemblies
+	// do not report their underlyingtype, but they report
+	// themselves
+	//
+	public static Type EnumToUnderlying (Type t)
+	{
+		if (t == TypeManager.enum_type)
+			return t;
+
+		t = t.UnderlyingSystemType;
+		if (!TypeManager.IsEnumType (t))
+			return t;
+	
+		if (t is TypeBuilder) {
+			// slow path needed to compile corlib
+			if (t == TypeManager.bool_type ||
+					t == TypeManager.byte_type ||
+					t == TypeManager.sbyte_type ||
+					t == TypeManager.char_type ||
+					t == TypeManager.short_type ||
+					t == TypeManager.ushort_type ||
+					t == TypeManager.int32_type ||
+					t == TypeManager.uint32_type ||
+					t == TypeManager.int64_type ||
+					t == TypeManager.float_type ||
+					t == TypeManager.double_type ||
+					t == TypeManager.decimal_type ||
+					t == TypeManager.uint64_type)
+				return t;
+			// Following line is commented out to handle case like 
+			// Module M
+        		// Enum E
+                	//	A
+              		//	B
+        		// End Enum
+        		// Sub Main
+                	//	Dim e1 As E
+                	//	Dim i As Integer
+                	// 	e1 = E.A
+           		//	i = e1
+        		// End Sub
+			// End Module
+
+			// throw new Exception ("Unhandled typecode in enum " + " from " + t.AssemblyQualifiedName);
+		}
+		TypeCode tc = Type.GetTypeCode (t);
+
+		switch (tc){
+		case TypeCode.Boolean:
+			return TypeManager.bool_type;
+		case TypeCode.Byte:
+			return TypeManager.byte_type;
+		case TypeCode.SByte:
+			return TypeManager.sbyte_type;
+		case TypeCode.Char:
+			return TypeManager.char_type;
+		case TypeCode.Int16:
+			return TypeManager.short_type;
+		case TypeCode.UInt16:
+			return TypeManager.ushort_type;
+		case TypeCode.Int32:
+			return TypeManager.int32_type;
+		case TypeCode.UInt32:
+			return TypeManager.uint32_type;
+		case TypeCode.Int64:
+			return TypeManager.int64_type;
+		case TypeCode.UInt64:
+			return TypeManager.uint64_type;
+		case TypeCode.Single:
+			return TypeManager.float_type;
+		case TypeCode.Double:
+			return TypeManager.double_type;
+		case TypeCode.Decimal:
+			return TypeManager.decimal_type;
+		}
+		throw new Exception ("Unhandled typecode in enum " + tc + " from " + t.AssemblyQualifiedName);
+	}
+
+	//
+	// When compiling corlib and called with one of the core types, return
+	// the corresponding typebuilder for that type.
+	//
+	public static Type TypeToCoreType (Type t)
+	{
+		if (RootContext.StdLib || (t is TypeBuilder))
+			return t;
+
+		TypeCode tc = Type.GetTypeCode (t);
+
+		switch (tc){
+		case TypeCode.Boolean:
+			return TypeManager.bool_type;
+		case TypeCode.Byte:
+			return TypeManager.byte_type;
+		case TypeCode.SByte:
+			return TypeManager.sbyte_type;
+		case TypeCode.Char:
+			return TypeManager.char_type;
+		case TypeCode.Int16:
+			return TypeManager.short_type;
+		case TypeCode.UInt16:
+			return TypeManager.ushort_type;
+		case TypeCode.Int32:
+			return TypeManager.int32_type;
+		case TypeCode.UInt32:
+			return TypeManager.uint32_type;
+		case TypeCode.Int64:
+			return TypeManager.int64_type;
+		case TypeCode.UInt64:
+			return TypeManager.uint64_type;
+		case TypeCode.String:
+			return TypeManager.string_type;
+		case TypeCode.DateTime:
+			return TypeManager.date_type;
+		default:
+			if (t == typeof (void))
+				return TypeManager.void_type;
+			if (t == typeof (object))
+				return TypeManager.object_type;
+			if (t == typeof (System.Type))
+				return TypeManager.type_type;
+			return t;
+		}
+	}
+
+	public static TypeExpr TypeToCoreTypeExpr (Type t)
+	{
+		if (t == null)
+			return null;
+
+		TypeCode tc = Type.GetTypeCode (t);
+
+		switch (tc){
+		case TypeCode.Boolean:
+			return TypeManager.system_boolean_expr;
+		case TypeCode.Byte:
+			return TypeManager.system_byte_expr;
+		case TypeCode.SByte:
+			return TypeManager.system_sbyte_expr;
+		case TypeCode.Char:
+			return TypeManager.system_char_expr;
+		case TypeCode.Int16:
+			return TypeManager.system_int16_expr;
+		case TypeCode.UInt16:
+			return TypeManager.system_uint16_expr;
+		case TypeCode.Int32:
+			return TypeManager.system_int32_expr;
+		case TypeCode.UInt32:
+			return TypeManager.system_uint32_expr;
+		case TypeCode.Int64:
+			return TypeManager.system_int64_expr;
+		case TypeCode.UInt64:
+			return TypeManager.system_uint64_expr;
+		case TypeCode.String:
+			return TypeManager.system_string_expr;
+		case TypeCode.Decimal:
+			return TypeManager.system_decimal_expr;
+		case TypeCode.Single:
+			return TypeManager.system_single_expr;
+		case TypeCode.Double:
+			return TypeManager.system_double_expr;
+		case TypeCode.DateTime:
+			return TypeManager.system_date_expr;
+		default:
+			if (t == typeof (void))
+				return TypeManager.system_void_expr;
+			if (t == typeof (object))
+				return TypeManager.system_object_expr;
+			//FIXME : return t; What should be returned here?
+			return null;
+		}
+	}
+	/// <summary>
+	///   Utility function that can be used to probe whether a type
+	///   is managed or not.  
+	/// </summary>
+	public static bool VerifyUnManaged (Type t, Location loc)
+	{
+		if (t.IsValueType || t.IsPointer){
+			//
+			// FIXME: this is more complex, we actually need to
+			// make sure that the type does not contain any
+			// classes itself
+			//
+			return true;
+		}
+
+		if (!RootContext.StdLib && (t == TypeManager.decimal_type))
+			// We need this explicit check here to make it work when
+			// compiling corlib.
+			return true;
+
+		Report.Error (
+			208, loc,
+			"Cannot take the address or size of a variable of a managed type ('" +
+			MonoBASIC_Name (t) + "')");
+		return false;	
+	}
+	
+	/// <summary>
+	///   Returns the name of the indexer in a given type.
+	/// </summary>
+	/// <remarks>
+	///   The default is not always 'Item'.  The user can change this behaviour by
+	///   using the DefaultMemberAttribute in the class.
+	///
+	///   For example, the String class indexer is named 'Chars' not 'Item' 
+	/// </remarks>
+	public static string IndexerPropertyName (Type t, out Type innerType)
+	{
+		innerType = t;
+		
+		if (t is TypeBuilder) {
+			if (t.IsInterface) {
+				Interface i = LookupInterface (t);
+
+				if ((i == null) || (i.DefaultPropName == null))
+					return "Item";
+
+				return i.DefaultPropName;
+			} else {
+				TypeContainer tc = LookupTypeContainer (t);
+
+				if ( tc == null )
+					return null;
+
+				if ( tc.DefaultPropName == null )
+				{
+					while ( tc is Class )
+					{
+						innerType = innerType.BaseType;
+						
+						tc = LookupTypeContainer (innerType);
+						
+						if (tc == null)
+						{	
+							innerType = t;
+							return null;
+						}
+						else if ( tc.DefaultPropName != null )
+							return tc.DefaultPropName;
+					}
+				}
+				
+				//if ((tc == null) || (tc.DefaultPropName == null))
+				//	return "Item";
+
+				return tc.DefaultPropName;
+			}
+		}
+		
+		System.Attribute attr = System.Attribute.GetCustomAttribute (
+			t, TypeManager.default_member_type);
+		if (attr != null){
+			DefaultMemberAttribute dma = (DefaultMemberAttribute) attr;
+			return dma.MemberName;
+		}
+
+		return "Item";
+	}
+
+	public static void MakePinned (LocalBuilder builder)
+	{
+		//
+		// FIXME: Flag the "LocalBuilder" type as being
+		// pinned.  Figure out API.
+		//
+	}
+
+
+	//
+	// Returns whether the array of memberinfos contains the given method
+	//
+	static bool ArrayContainsMethod (MemberInfo [] array, MethodBase new_method)
+	{
+		Type [] new_args = TypeManager.GetArgumentTypes (new_method);
+		
+		foreach (MethodBase method in array){
+			if (method.Name != new_method.Name)
+				continue;
+			
+			Type [] old_args = TypeManager.GetArgumentTypes (method);
+			int old_count = old_args.Length;
+			int i;
+			
+			if (new_args.Length != old_count)
+				continue;
+			
+			for (i = 0; i < old_count; i++){
+				if (old_args [i] != new_args [i])
+					break;
+			}
+			if (i != old_count)
+				continue;
+
+			return true;
+		}
+		return false;
+	}
+	
+	//
+	// We copy methods from 'new_members' into 'target_list' if the signature
+	// for the method from in the new list does not exist in the target_list
+	//
+	// The name is assumed to be the same.
+	//
+	public static ArrayList CopyNewMethods (ArrayList target_list, MemberList new_members)
+	{
+		if (target_list == null){
+			target_list = new ArrayList ();
+
+			foreach (MemberInfo mi in new_members){
+				if (mi is MethodBase)
+					target_list.Add (mi);
+			}
+			return target_list;
+		}
+		
+		MemberInfo [] target_array = new MemberInfo [target_list.Count];
+		target_list.CopyTo (target_array, 0);
+		
+		foreach (MemberInfo mi in new_members){
+			MethodBase new_method = (MethodBase) mi;
+			
+			if (!ArrayContainsMethod (target_array, new_method))
+				target_list.Add (new_method);
+		}
+		return target_list;
+	}
+
+	[Flags]
+	public enum MethodFlags {
+		IsObsolete = 1,
+		IsObsoleteError = 2,
+		ShouldIgnore = 3
+	}
+	
+	//
+	// Returns the TypeManager.MethodFlags for this method.
+	// This emits an error 619 / warning 618 if the method is obsolete.
+	// In the former case, TypeManager.MethodFlags.IsObsoleteError is returned.
+	//
+	static public MethodFlags GetMethodFlags (MethodBase mb, Location loc)
+	{
+		MethodFlags flags = 0;
+		
+		if (mb.DeclaringType is TypeBuilder){
+			MethodData method = (MethodData) builder_to_method [mb];
+			if (method == null) {
+				// FIXME: implement Obsolete attribute on Property,
+				//        Indexer and Event.
+				return 0;
+			}
+
+			return method.GetMethodFlags (loc);
+		}
+
+		object [] attrs = mb.GetCustomAttributes (true);
+		foreach (object ta in attrs){
+			if (!(ta is System.Attribute)){
+				Console.WriteLine ("Unknown type in GetMethodFlags: " + ta);
+				continue;
+			}
+			System.Attribute a = (System.Attribute) ta;
+			if (a.TypeId == TypeManager.obsolete_attribute_type){
+				ObsoleteAttribute oa = (ObsoleteAttribute) a;
+
+				string method_desc = TypeManager.MonoBASIC_Signature (mb);
+
+				if (oa.IsError) {
+					Report.Error (619, loc, "Method '" + method_desc +
+						      "' is obsolete: '" + oa.Message + "'");
+					return MethodFlags.IsObsoleteError;
+				} else
+					Report.Warning (618, loc, "Method '" + method_desc +
+							"' is obsolete: '" + oa.Message + "'");
+
+				flags |= MethodFlags.IsObsolete;
+
+				continue;
+			}
+			
+			//
+			// Skip over conditional code.
+			//
+			if (a.TypeId == TypeManager.conditional_attribute_type){
+				ConditionalAttribute ca = (ConditionalAttribute) a;
+
+				if (RootContext.AllDefines [ca.ConditionString] == null)
+					flags |= MethodFlags.ShouldIgnore;
+			}
+		}
+
+		return flags;
+	}
+	
+#region MemberLookup implementation
+	
+	//
+	// Name of the member
+	//
+	//static string   closure_name;
+
+	//
+	// Whether we allow private members in the result (since FindMembers
+	// uses NonPublic for both protected and private), we need to distinguish.
+	//
+	static bool     closure_private_ok;
+
+	//
+	// Who is invoking us and which type is being queried currently.
+	//
+	static Type     closure_invocation_type;
+	//static Type     closure_queried_type;
+	static Type     closure_start_type;
+
+	//
+	// The assembly that defines the type is that is calling us
+	//
+	static Assembly closure_invocation_assembly;
+
+	//
+	// This filter filters by name + whether it is ok to include private
+	// members in the search
+	//
+	static internal bool FilterWithClosure (MemberInfo m, object filter_criteria)
+	{
+		//
+		// Hack: we know that the filter criteria will always be in the 'closure'
+		// fields. 
+		//
+
+		if ((filter_criteria != null) && (m.Name != (string) filter_criteria))
+				return false;
+
+		if ((closure_start_type == closure_invocation_type) &&
+		    (m.DeclaringType == closure_invocation_type))
+			return true;
+
+		//
+		// Ugly: we need to find out the type of 'm', and depending
+		// on this, tell whether we accept or not
+		//
+		if (m is MethodBase){
+			MethodBase mb = (MethodBase) m;
+			MethodAttributes ma = mb.Attributes & MethodAttributes.MemberAccessMask;
+
+			if (ma == MethodAttributes.Private)
+				return closure_private_ok || (closure_invocation_type == m.DeclaringType);
+
+			//
+			// FamAndAssem requires that we not only derivate, but we are on the
+			// same assembly.  
+			//
+			if (ma == MethodAttributes.FamANDAssem){
+				if (closure_invocation_assembly != mb.DeclaringType.Assembly)
+					return false;
+			}
+
+			// Assembly and FamORAssem succeed if we're in the same assembly.
+			if ((ma == MethodAttributes.Assembly) || (ma == MethodAttributes.FamORAssem)){
+				if (closure_invocation_assembly == mb.DeclaringType.Assembly)
+					return true;
+			}
+
+			// We already know that we aren't in the same assembly.
+			if (ma == MethodAttributes.Assembly)
+				return false;
+
+			// Family and FamANDAssem require that we derive.
+			if ((ma == MethodAttributes.Family) || (ma == MethodAttributes.FamANDAssem)){
+				if (closure_invocation_type == null)
+					return false;
+
+				if (!IsSubclassOrNestedChildOf (closure_invocation_type, mb.DeclaringType))
+					return false;
+
+				return true;
+			}
+
+			// Public.
+			return true;
+		}
+
+		if (m is FieldInfo){
+			FieldInfo fi = (FieldInfo) m;
+			FieldAttributes fa = fi.Attributes & FieldAttributes.FieldAccessMask;
+
+			if (fa == FieldAttributes.Private)
+				return closure_private_ok || (closure_invocation_type == m.DeclaringType);
+
+			//
+			// FamAndAssem requires that we not only derivate, but we are on the
+			// same assembly.  
+			//
+			if (fa == FieldAttributes.FamANDAssem){
+				if (closure_invocation_assembly != fi.DeclaringType.Assembly)
+					return false;
+			}
+
+			// Assembly and FamORAssem succeed if we're in the same assembly.
+			if ((fa == FieldAttributes.Assembly) || (fa == FieldAttributes.FamORAssem)){
+				if (closure_invocation_assembly == fi.DeclaringType.Assembly)
+					return true;
+			}
+
+			// We already know that we aren't in the same assembly.
+			if (fa == FieldAttributes.Assembly)
+				return false;
+
+			// Family and FamANDAssem require that we derive.
+			if ((fa == FieldAttributes.Family) || (fa == FieldAttributes.FamANDAssem)){
+				if (closure_invocation_type == null)
+					return false;
+
+				if (!IsSubclassOrNestedChildOf (closure_invocation_type, fi.DeclaringType))
+					return false;
+
+				// Although a derived class can access protected members of its base class
+				// it cannot do so through an instance of the base class (CS1540).
+				if ((closure_invocation_type != closure_start_type) &&
+				    closure_invocation_type.IsSubclassOf (closure_start_type))
+					return false;
+
+				return true;
+			}
+
+			// Public.
+			return true;
+		}
+
+		//
+		// EventInfos and PropertyInfos, return true
+		//
+		return true;
+	}
+
+	static MemberFilter FilterWithClosure_delegate = new MemberFilter (FilterWithClosure);
+
+	//
+	// Looks up a member called 'name' in the 'queried_type'.  This lookup
+	// is done by code that is contained in the definition for 'invocation_type'.
+	//
+	// The binding flags are 'bf' and the kind of members being looked up are 'mt'
+	//
+	// Returns an array of a single element for everything but Methods/Constructors
+	// that might return multiple matches.
+	//
+	public static MemberInfo [] MemberLookup (Type invocation_type, Type queried_type, 
+						  MemberTypes mt, BindingFlags original_bf, string name)
+	{
+		Timer.StartTimer (TimerType.MemberLookup);
+
+		MemberInfo[] retval = RealMemberLookup (invocation_type, queried_type,
+							mt, original_bf, name);
+
+		Timer.StopTimer (TimerType.MemberLookup);
+
+		return retval;
+	}
+
+	static MemberInfo [] RealMemberLookup (Type invocation_type, Type queried_type, 
+					       MemberTypes mt, BindingFlags original_bf, string name)
+	{
+		BindingFlags bf = original_bf;
+		
+		ArrayList method_list = null;
+		Type current_type = queried_type;
+		if (queried_type == null)
+			throw new ArgumentNullException("queried_type");
+		bool searching = (original_bf & BindingFlags.DeclaredOnly) == 0;
+		bool private_ok;
+		bool always_ok_flag = false;
+		bool skip_iface_check = true, used_cache = false;
+
+		//closure_name = name;
+		closure_invocation_type = invocation_type;
+		closure_invocation_assembly = invocation_type != null ? invocation_type.Assembly : null;
+		closure_start_type = queried_type;
+
+		//
+		// If we are a nested class, we always have access to our container
+		// type names
+		//
+		if (invocation_type != null){
+			string invocation_name = invocation_type.FullName;
+			if (invocation_name.IndexOf ('+') != -1){
+				string container = queried_type.FullName + "+";
+				int container_length = container.Length;
+				
+				if (invocation_name.Length > container_length){
+					string shared = invocation_name.Substring (0, container_length);
+				
+					if (shared == container)
+						always_ok_flag = true;
+				}
+			}
+		}
+		
+		do {
+			MemberList list;
+
+			//
+			// 'NonPublic' is lame, because it includes both protected and
+			// private methods, so we need to control this behavior by
+			// explicitly tracking if a private method is ok or not.
+			//
+			// The possible cases are:
+			//    public, private and protected (internal does not come into the
+			//    equation)
+			//
+			if (invocation_type != null){
+				if (invocation_type == current_type){
+					private_ok = (bf & BindingFlags.NonPublic) != 0;
+				} else
+					private_ok = always_ok_flag;
+
+				if (invocation_type.IsSubclassOf (current_type))
+					private_ok = true;
+				
+				if (private_ok)
+					bf = original_bf | BindingFlags.NonPublic;
+			} else {
+				private_ok = false;
+				bf = original_bf & ~BindingFlags.NonPublic;
+			}
+
+			closure_private_ok = private_ok;
+			//closure_queried_type = current_type;
+
+			Timer.StopTimer (TimerType.MemberLookup);
+			bf |= BindingFlags.IgnoreCase;
+			list = MemberLookup_FindMembers (current_type, mt, bf, name, out used_cache);
+
+			Timer.StartTimer (TimerType.MemberLookup);
+
+			//
+			// When queried for an interface type, the cache will automatically check all
+			// inherited members, so we don't need to do this here.  However, this only
+			// works if we already used the cache in the first iteration of this loop.
+			//
+			// If we used the cache in any further iteration, we can still terminate the
+			// loop since the cache always looks in all parent classes.
+			//
+
+			if (used_cache)
+				searching = false;
+			else
+				skip_iface_check = false;
+
+			if (current_type == TypeManager.object_type)
+				searching = false;
+			else {
+				current_type = current_type.BaseType;
+				
+				//
+				// This happens with interfaces, they have a null
+				// basetype.  Look members up in the Object class.
+				//
+				if (current_type == null)
+					current_type = TypeManager.object_type;
+			}
+			
+			if (list.Count == 0)
+				continue;
+				
+			//
+			// Events and types are returned by both 'static' and 'instance'
+			// searches, which means that our above FindMembers will
+			// return two copies of the same.
+			//
+			if (list.Count == 1 && !(list [0] is MethodBase)){
+				return (MemberInfo []) list;
+			}
+
+			//
+			// Multiple properties: we query those just to find out the indexer
+			// name
+			//
+			if (list [0] is PropertyInfo) {
+				foreach (MemberInfo mi in list)
+					if (mi is FieldInfo)
+						return new MemberInfo [] {mi};
+				return (MemberInfo []) list;
+			}
+
+
+			//
+			// We found an event: the cache lookup returns both the event and
+			// its private field.
+			//
+			if (list [0] is EventInfo) {
+				if ((list.Count == 2) && (list [1] is FieldInfo))
+					return new MemberInfo [] {list [0]};
+
+				// Oooops
+				return null;
+			}
+
+			//
+			// We found methods, turn the search into "method scan"
+			// mode.
+			//
+			
+			method_list = CopyNewMethods (method_list, list);
+			mt &= (MemberTypes.Method | MemberTypes.Constructor);
+		} while (searching);
+
+		if (method_list != null && method_list.Count > 0)
+			return (MemberInfo []) method_list.ToArray (typeof (MemberInfo));
+
+		//
+		// This happens if we already used the cache in the first iteration, in this case
+		// the cache already looked in all interfaces.
+		//
+		if (skip_iface_check)
+			return null;
+
+		//
+		// Interfaces do not list members they inherit, so we have to
+		// scan those.
+		// 
+		if (!queried_type.IsInterface)
+			return null;
+
+		if (queried_type.IsArray)
+			queried_type = TypeManager.array_type;
+		
+		Type [] ifaces = GetInterfaces (queried_type);
+		if (ifaces == null)
+			return null;
+		
+		foreach (Type itype in ifaces){
+			MemberInfo [] x;
+
+			x = MemberLookup (null, itype, mt, bf, name);
+			if (x != null)
+				return x;
+		}
+					
+		return null;
+	}
+#endregion
+	
+}
+
+/// <summary>
+///   There is exactly one instance of this class per type.
+/// </summary>
+public sealed class TypeHandle : IMemberContainer {
+	public readonly TypeHandle BaseType;
+
+	readonly int id = ++next_id;
+	static int next_id = 0;
+
+	/// <summary>
+	///   Lookup a TypeHandle instance for the given type.  If the type doesn't have
+	///   a TypeHandle yet, a new instance of it is created.  This static method
+	///   ensures that we'll only have one TypeHandle instance per type.
+	/// </summary>
+	public static TypeHandle GetTypeHandle (Type t)
+	{
+		TypeHandle handle = (TypeHandle) type_hash [t];
+		if (handle != null)
+			return handle;
+
+		handle = new TypeHandle (t);
+		type_hash.Add (t, handle);
+		return handle;
+	}
+
+	/// <summary>
+	///   Returns the TypeHandle for TypeManager.object_type.
+	/// </summary>
+	public static IMemberContainer ObjectType {
+		get {
+			if (object_type != null)
+				return object_type;
+
+			object_type = GetTypeHandle (TypeManager.object_type);
+
+			return object_type;
+		}
+	}
+
+	/// <summary>
+	///   Returns the TypeHandle for TypeManager.array_type.
+	/// </summary>
+	public static IMemberContainer ArrayType {
+		get {
+			if (array_type != null)
+				return array_type;
+
+			array_type = GetTypeHandle (TypeManager.array_type);
+
+			return array_type;
+		}
+	}
+
+	private static PtrHashtable type_hash = new PtrHashtable ();
+
+	private static TypeHandle object_type = null;
+	private static TypeHandle array_type = null;
+
+	private Type type;
+	private bool is_interface;
+	private MemberCache member_cache;
+
+	private TypeHandle (Type type)
+	{
+		this.type = type;
+		if (type.BaseType != null)
+			BaseType = GetTypeHandle (type.BaseType);
+		else if ((type != TypeManager.object_type) && (type != typeof (object)))
+			is_interface = true;
+		this.member_cache = new MemberCache (this);
+	}
+
+	// IMemberContainer methods
+
+	public string Name {
+		get {
+			return type.FullName;
+		}
+	}
+
+	public Type Type {
+		get {
+			return type;
+		}
+	}
+
+	public IMemberContainer Parent {
+		get {
+			return BaseType;
+		}
+	}
+
+	public bool IsInterface {
+		get {
+			return is_interface;
+		}
+	}
+
+	public MemberList GetMembers (MemberTypes mt, BindingFlags bf)
+	{
+		if (mt == MemberTypes.Event)
+			return new MemberList (type.GetEvents (bf | BindingFlags.DeclaredOnly));
+		else
+			return new MemberList (type.FindMembers (mt, bf | BindingFlags.DeclaredOnly | BindingFlags.IgnoreCase,
+								 null, null));
+	}
+
+	// IMemberFinder methods
+
+	public MemberList FindMembers (MemberTypes mt, BindingFlags bf, string name,
+				       MemberFilter filter, object criteria)
+	{
+		return member_cache.FindMembers (mt, bf, name, filter, criteria);
+	}
+
+	public MemberCache MemberCache {
+		get {
+			return member_cache;
+		}
+	}
+
+	public override string ToString ()
+	{
+		if (BaseType != null)
+			return "TypeHandle (" + id + "," + Name + " : " + BaseType + ")";
+		else
+			return "TypeHandle (" + id + "," + Name + ")";
+	}
+}
+
+}