2004-01-25  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* Relational.cs: Initial generation of CIL for relational operators.

2004-01-23  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: formal_param_list receives a parent too.

	* SymbolTable.cs: added size and current_symbols properties.

	* JSLocalField.cs: don't throw not ImplementedException from
	constructor (same reason, testing purposes, must get implemented
	for real).

	* IdentificationTable.cs: added num_of_locals and current_locals properties.

	* FunctionDeclaration.cs: added a LocalBuilder and DictionaryEntry
	as fields. Not throw NotImplementedException for
	JScriptFunctionDeclaration (testing purposes, must get implemeted
	for real). Let's build our function closures! Added functions:
	build_closure and build_closure_nested, build_local_fields. Keep
	track of current parameters and locals defs.

	* FormalParameterList.cs: made FormalParam inherit from
	AST. Implement the Emit for parameters, yeah!

	* CodeGenerator.cs: added a ModuleBuilder reference. New constructor.	

	* Closure.cs: do not throw the exception (this allow me to run the
	tests  at mcs/jtests and check that at least i'm not generating
	invalid CIL). Be aware that this must be really implemented.

	* Block.cs: renamed field, and implement the double pass for
	nested function declarations code emittion, yeah!.

2004-01-16  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* Microsoft.JScript/VsaReferenceItem.cs: renamed field, reuse parent's ctr.
	* Microsoft.JScript/VsaItem.cs: renamed some fields, added ctr, 
	* Microsoft.JScript/VsaGlobalItem.cs: reuse parent ctr.
	* Microsoft.JScript/VsaCodeItem.cs: reuse parent ctr.
	* Microsoft.JScript/GlobalScope.cs: reuse constructors from parent.

	* UnaryOp.cs: inherit from Exp now.
	* Plus.cs: Don't throw the exception when calling constructor, let
	it build the default handler. Return a new object when calling
	EvaluatePlus until properly implemented.

	* NumericUnary.cs: added new Resolve.
	* NumericBinary.cs: assign operator val at ctr. Return a new
	object when calling EvaluateNumericBinary until properly
	implemented. Added Resolve.
	* Equality.cs: added ctr and return false for EvaluateEquality
	until properly implemented. Added Resolve's functions.

	* Block.cs (Resolve): That check was not necessary.
	
	* InstanceOf.cs, PostOrPrefixOperator.cs, Relational.cs,
	StrictEquality.cs, TypeOf.cs: added Resolve inherited from
	BinaryOp and UnaryOp, and this from Exp.
	* IdentificationTable.cs, ScriptBlock.cs: deleted debugging messages.
	* jscript-lexer-parser.g: deleted debugging messages. Create a
	Assign object instance of a simple Binary obj. Same case for Equality.

	* expression.cs: added Exp abstract class. Classes that are ast of
	language constructions that can appear as global expressions that
	get evaluated and then the result is discarded inherit from this
	new class. This let meee keep track of things that must get Popped
	or can even avoid the evaluation of it. Wrote real Resolve method
	for classes: Unary, Binary.
	Implemted Emit method for some binary operations (+, -, / and *),
	for other operators some more code is still missing.	
	Identifier: handle assignment cases and global exp cases.
	Added class Assign (compisite assignment still missing tough :-(

	* driver.cs: deleted debug messages, added "Compilation Succeeded"
	message ;-).
	* VariableStatement.cs, VariableDeclaration.cs: wrote real Resolve method.	
	* Literal.cs (BooleanLiteral, NumericLiteral): now inherits from
	Exp and handle the case for global expressions that must be popped
	after evaluation. no more invalid IL being generated! yeah!
	* Block.cs: wrote real Resolve method, erased debug messages.
	* BitwiseBinary.cs, InstanceOf.cs, UnaryOp.cs: : add new Resolve inherited from Exp.
	* BinaryOp.cs, Conditional: now inherits from Exp.

2004-01-15  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* ReferenceAttribute.cs: moved it back to namespace Microsoft.JScript.

	* CodeGenerator.cs: small fixes to generate same things that ms.

2004-01-13  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* VariableDeclaration.cs: get the this.type which is a Type not a TypeBuilder.

2004-01-12  Atsushi Enomoto  <atsushi@ximian.com>

	* JSMethodInfo.cs : tiny fix for NET_1_2 build.

2003-12-24  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: keep track of parent reference for
	IDENTIFIER, STRING_LITERAL.

	* expression.cs: Added 'binding' field. Added 'parent' parameter
	to constructor. Now we emit the proper code for the identifier.

	* VariableStatement.cs: updated to field names instead of the old
	property's name.

	* VariableDeclaration.cs: Added class Decl, it constains the
	references to the static field or LocalBuilder that are created
	when a declaration is emitted. Deleted unuseful properties (Id,
	InitValue, Type).

	* SymbolTable.cs: Deleted Retrieve method. Contains now returns an
	object instead of a boolean.

	* StringLiteral.cs: Deleted unuseful properties. Use ig instead of ec.ig.

	* IdentificationTable.cs: Deleted Retrieve method. Contains method
	now return an object instead of a boolean, that reference is the
	binding associated with the identifier being searched.

2003-12-18  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: Keep track of parent for numeric_literal.

	* VariableDeclaration.cs: now I handle initialization (ex. var x =
	2; or function f () { var x = 4; }) at global scope or at
	function's body.

	* Literal.cs: Added parent param to NumericLiteral constructor.

	* FunctionDeclaration.cs: Added Ret opcode for all function declaration bodies.

2003-12-17  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* CodeGenerator.cs: Added IL emittion for ldnull on default ending code for 'Global Code'.

2003-12-10  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: added 'tokens { IN = "in"; INSTANCE_OF =
	"instanceof"; }' in order to be able to parse both keywords. When
	generating the parser, one warning about nondeterminism
	(k==1:"in") is generated ignore it.

2003-12-07  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: things like 'new Point (10, 20).x' were
	not parsable now they are. Mozilla's and Janet's  test suites are
	being really helpful.

2003-12-05  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: added check for non-null reference at
	var_decl_list rule. Added single quote STRING_LITERAL lexical rule
	and multiple lines comments rule.

	* jscript-lexer-parser.g: Now I keep track of the parent for most
	of the syntatic constructs. Fixed object_literal rule.

	* ast.cs: Added field parent. This will help me to track nested
	blocks for all of the syntatic constructs and will allow to Emit
	everything in one single pass.
	* FunctionDeclaration.cs, FunctionExpression.cs: Rearranged the
	parent stuff.
	* Block.cs, FunctionObject.cs: deleted parent field as AST will
	hold it. Delete parent parameter from constructor.
	* CodeGenerator.cs: Add field gc_ig (global code IL generator) to
	EmitContext class. The idea is Emitting everything in one pass (decls
	and 'Global Code' method, the parent reference let me know which IL
	generator use, gc_ig or ig).
	* Equality.cs, BooleanLiteral, Relational.cs: Added new parameter to
	constructor. Use new parent reference for choosing the IL
	generator. NumericLiteral a 'hard coded' int32 IL emittion added
	for testing. 
	* StringLiteral.cs, Literal.cs (BooleanLiteral.Emit): now I use
	the parent reference to infere which IL generator to use.
	* VariableDeclaration.cs: deleted parent field. At Emit, now I use the parent
	reference to infer which IL generator to use.
	* expression.cs: Added paramenter parent to constructor of: Unary,
	Binary, Conditional, Call.

2003-11-30  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* expression.cs: Added new field to Call class, so it can handle more arguments.

	* StringLiteral.cs (Emit) : Load the string value.

	* Literal.cs: BooleanLiteral, Resolve always return true. Emit the value and box it to Boolean.

	* CodeGenerator.cs: Set parent if 'JScript 0' to GlobalScope. Set
	custom attribute. Build default 'JScript 0' constructor. Emit
	default initial/final code of 'Global Code'. Create default
	'JScript Main'.

2003-11-29  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* jscript-lexer-grammar.g: define new rule 'arguments' instead of
	repeating hand written rule all around. Change "." for DOT, dumb
	mistake by myself. Added rule new_expr. Now we handle properly the
	call_expr rule (as defined on the spec), and added a new
	argument. Added subrule new_expr to  left_hand_side_expr rule.

2003-11-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* expression.cs (Expression): implemented Emit.

	* expression.cs (Binary): Emit now creates a local for the
	different kinds of binary expressions (initial code for this).

	* ast.cs: Emit method now is abstract instead of virtual.

	* CodeGenerator.cs: changed no_global_code_method to is_global_code_method.

	* ASTList.cs, ArrayLiteral.cs, BitwiseBinary.cs, DebugBreak.cs,
	Enum.cs, Equality.cs, Eval.cs, ForIn.cs, FormalParameterList.cs,
	FunctionExpression.cs, Import.cs, InstanceOf.cs, Literal.cs,
	NumericLiteral, NumericBinary.cs, NumericUnary.cs, Package.cs,
	Plus.cs, PostOrPrefixOperator.cs, Print.cs, Relational.cs,
	Continue, Break, Return, StrictEquality.cs, StringLiteral.cs,
	Throw.cs, Try.cs, TypeOf.cs, VariableDeclaration.cs, With.cs,
	Conditional, Call, Identifier, Args, Expression, :
	added Emit method.

	* FunctionDeclaration.cs: Check if values are not null first (at
	Resolve). Ignore code generation is at 'Global Code'.

	* VariableDeclaration.cs: Now I take care of IL generation when we
	are at statements and expressions at global code, 'Global Code'
	method is populated with that IL.  

	* CodeGenerator.cs: Added flag for 'Global Code' method
	emittion. Now I call 'Emit' twice. The first for declarations the
	follower for statements and expressions at global scope.
	
2003-11-10 cesar lopez nataren <cesar@ciencias.unam.mx>

	* Visitor.cs: Deleted.

2003-11-09 cesar lopez nataren <cesar@ciencias.unam.mx>

	* FormalParameterList.cs: Now inherits from AST. Each of the
	formal parameters gets into the IdentificationTable at Resolve.

	* FunctionDeclaration.cs:Resolve (), We open a new block when
	encountering a FunctionDeclaration, resolve de parameters and the
	body, at the end we close the block.

	* IdentificationTable.cs: Now we keep track of parent of the
	current block. 'Enter (...)' now receives an object, not a
	VarDecl. 'Contains' now take care of searching through the binding
	chain.

	* Literal.cs: Deleted 'Literal' class, was being used for
	nothing. All the classes the inherited from it, now do it from
	AST. A 'literal' does resolve to true by default.

	* Relational.cs: Resolve recursively left and right.

	* SemanticAnalyser.cs: added flag for 'print statement'.

	* Statement.cs: 'If' class, resolves firstly the condition, the true_stm
	and false_stm.

	* driver.cs:  Init the semantic analysis phase.

	* expression.cs: 'Unary' class, resolves its operand
	first. 'Binary' class,resolves left and right first. 'Args' class
	resolve all the formal parameters first. 'Expression' resolve all
	the nested expressions first.

	* jscript-lexer-parser.g: Replaced 'Literal' references for AST ones.
	
2003-11-08 cesar lopez nataren <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: Allow the building of numeric_literal and DECIMAL_LITERAL,
	this is temporal in order to get Factorial compiled by mjs (must
	build the types according to Ecma-262 spec).

	* Literal.cs: Added NumericLiteral class.

2003-11-06 cesar lopez nataren <cesar@ciencias.unam.mx>

	* FunctionDeclaration.cs: Build a ScriptFunction local variable,
	if inside a nested block.

2003-11-05 cesar lopez nataren <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: Now we take care of parents. This allows
	to keep track if we are inside nested blocks. At
	'func_decl_or_expr', now I built the FunctionDeclaration or
	FunctionExpression first and then assign its body to it - this let
	me get a non-null value of the FunctionExpression or
	FunctionDeclaration so I can detect if it's a nested block (thanks go to Jackson!).

	* Block.cs, FunctionObject.cs, VariableDeclaration.cs: Added 'AST parent' field.
	* Block.cs, FunctionDeclaration.cs, FunctionExpression.cs,
	FunctionObject.cs, VariableDeclaration.cs: Added 'AST parent' parameter to constructor.

	* ScriptBlock.cs: Initiate the global block with 'null' as parent.
	
	* FunctionDeclaration.cs: Added 'get_composite_name ()' method
	(gets the name of a function if it's nested). Emit code for
	function's body. At 'Emit ()' now we take care if it's a nested
	declaration.

	* FunctionObject.cs: default return type is 'void' not
	'Object'. Function declarations without parameters map to functions with
	'Object this' and 'VsaEngine engine' as parameters by
	default. Assign parent to nested block.

	* VariableDeclaration.cs: At 'Emit ()', now we take care if we are
	a global declaration or inside a function declaration.
	
2003-11-04 cesar lopez nataren <cesar@ciencias.unam.mx>

	* FunctionObject.cs: Handle no parameters on functions.
	
	* jscript-lexer-parser.g: Allow functions without parameters.

2003-11-03 cesar lopez nataren <cesar@ciencias.unam.mx>

	* ASTList.cs, ArrayLiteral.cs, BitwiseBinary.cs, Blocks.cs,
	DebugBreak.cs, Enum.cs, Equality.cs, Eval.cs, ForIn.cs,
	FunctionDeclaration.cs, FunctionExpression.cs, Import.cs,
	InstanceOf.cs, Literal.cs, NumericBinary.cs, NumericUnary.cs,
	Package.cs, Plus.cs, PostOrPrefixOperator.cs, Print.cs,
	Relational.cs, ScriptBlock.cs, StrictEquality.cs, Throw.cs,
	Try.cs, TypeOf.cs, VariableDeclaration.cs, VariableStatement.cs,
	With.cs, expression.cs : Added 
	'Resolve' method stub.

	* CodeGenerator.cs: Added a ILGenerator field to EmitContext.

	* FormalParameterList.cs: Added FormalParam class. Change Add
	method to receive the id and the type annotation from function's parameters.

	* FunctionDeclaration.cs: Added code for initial function's
	definition code generation.

	* FunctionObject.cs: Added MethodAttributes and type_annot
	fields. Added params_types function, which returns an array of
	types from each of the function's parameters.

	* IdentificationTable.cs: Added ToString method.

	* SemanticAnalizer.cs: Fixed the file name (maybe I should erase it
	and add it again with the correct name). Not based on the Visitor
	pattern anymore. Deleted all the VisitFOO methods. Added a
	IdentificationTable field. Added Run, Dump methods.

	* Statement.cs: Deleted Statement class (it was being used for
	nothing). All classes that were having Statement as parent,
	changed their parent to be AST.

	* SymbolTable.cs: Added Add method that receives the id and the
	declaration class. Retrieve changed to return an AST. Added
	ToString method. Added 'SymbolTable parent' field.

	* VariableDeclaration.cs: Added InitValue property.

	* ast.cs: Added some comments and abstract method 'Resolve'.

	* jscript-lexer-parser.g: Added parsing support for formal
	parameters type annotations.
	
2003-10-30  cesar lopez nataren <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: fixed function call parsing! yeah! (give
	thanks to Hector!) 

2003-10-28  cesar lopez nataren <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: allow empty program files. Added type
	annotations on var decl and function decl.
	* VariableDeclaration.cs: added return type annotation field.
	* FunctionExpression.cs: added return type parameter to constructor.
	* FunctionDeclaration.cs: added return type parameter to
	constructor. Added Emit method (just creates the static field at
	the global object, for now).
	* FunctionObject.cs: added return type to constructor. Changed
	names to readable ones ;-) 

	* ScriptStream.cs: added WriteLine.

2003-10-24  cesar lopez nataren <cesar@ciencias.unam.mx>

	* ast.cs: Added 'virtual' Emit method (I might change it to be
	abstract, but I would have to added to all classes that derive
	from it. I'll do it later)
	* Block.cs: Added Emit method.
	* CodeGnerator.cs: Restructured it (not based on the Visitor pattern
	anymore) - still missing some methods, ut on the way. A nice
	hacking weekend coming. Added EmitContext class.
	* ScriptBlock.cs: Added Emit method.
	* VariableDeclaration.cs: Changed type field from string to
	Type. Added Emit method.
	* VariableStatement.cs: Added Emit method.
	* driver.cs: Added CodeGeneration phase (only simple var
	declarations support it. More coming soon).


2003-10-22  cesar lopez nataren <cesar@ciencias.unam.mx>

	* statement.cs: added Return class.

	* Throw.cs: Added expression field, constructor and ToString.
	
	* jscript-lexer-parser.g: Allow return_stm and throw_stm tree
	building.  
	
	* With.cs: added constructor and ToString. Back to the non-tmp
	namespace.

	* jscript-parser-lexer.g: allow with_stm tree building.

	* jscript-lexer-parser.g: changed the return type from if_stm from
	'If' to AST. Added tree for continue_stm. Allowed building of
	Break tree.

	* statement.cs: switched to internal 'If' class. Added Continue
	class. Added Break class.
	
	* jscript-lexer-parser.g: build tree for function decl or expr.

	* FunctionDeclaration.cs: added internal constructor.

	* FunctionExpression.cs: added internal constructor.

	* FunctionObject.cs: added internal constructor and ToString method.

	* jscript-lexer-parser.g: added building tree for if_stm.
	* Statement.cs: Added if class for 'if' statement.
	

2003-10-21  cesar lopez nataren  <cesar@ciencias.unam.mx>

	* VariableDeclaration.cs: added the initializer to ToString.
	
	* jscript-lexer-parser.g: Allow "christmas trees" (aka expression
	trees) building.
	
	* Block.cs, Equality.cs, Relational.cs: modified ToString 

	* Equality.cs, Relational.cs, StringLiteral.cs,
	VariableDeclaration.cs: Added constructor 

	* VariableStatement.cs, ScriptBlock.cs: changed from hungarian
	name convetion style to mono style.

	* UnaryOp.cs: added operator and operand fields.

	* VariableDeclaration.cs: chenged field name from assignExp to val.

	*  BinaryOp.cs: Made "internal" the attributes, added the two
	operators holders.

	* JScriptLexer.cs, JScriptParser.cs, JScriptParserokenTypes.cs,: updates from grammar changes.
	
	* driver.cs: Dump the string representation of the parsed exps.

	* Literal.cs:  added BooleanLiteral

	* Relational.cs: added constructor, ToString, 

2003-10-10  cesar lopez nataren <cesar@ciencias.unam.mx>

	* README: added some info about hacking the grammar

	* JSparser.cs: Updated the constructor to not receiving params.

	* JScriptLexer.cs, JScriptParser.cs, JScriptParserTokenTypes.cs,
	JScriptParserTokenTypes.txt: update of antlr generated files from
	grammar changes. 

	* jscript-lexer-parser.g: Rewrote the EcmaScript grammar. Now we
	can parse a little bit more useful programs like:

	function factorial (i)
	{
		var k;

		if (i <= 0)
			return 1;
		else {
			k = factorial (i - 1);
			return i * k;
		}
	}

	var x;
	x = factorial (4); 
	print (x);

	As you can see, it's not the classic factorial function
	definition, I still have to make some tricks like storing the
	result from the recursive call and then multiply. But this new
	grammar it's easier to alter than the old one. Also we got support
	for for-in statements, for statements, global expressions, support
	for object accesors or better known as the "dot" operator. Two
	rules are on the eye: left_hand_size_expr and call_expr, in order
	to finish the parsing grammar and fix the bugs.


2003-09-29    <cesar@ciencias.unam.mx>

	* Added: VsaGlobalItem.cs, VsaReferenceItem.cs, VsaCodeItem.cs

	* Added VsaItem.cs, implements IVsaItem.

2003-09-28    <cesar@ciencias.unam.mx>

	* VsaItems.cs: Check that no name is repeated (this was docs fault
	:-)). This is the beauty of testing.

	* Add VsaItems.cs, implements IVsaItems.

2003-09-22    <cesar@ciencias.unam.mx>

	* DocumentContext.cs: changed constructor from internal to public,
	this a kind of hack ;), but we can build mjs.exe with that change.

	* driver.cs, ast.cs, VsaEngine.cs, VariableStatement.cs,
	VariableDeclaration.cs, VBArrayConstructor.cs, StringObject.cs,
	StringLiteral.cs, StringConstructor.cs, Statement.cs,
	ScriptStream.cs, ScriptObject.cs, ScriptFunction.cs,
	ScriptBlock.cs, RegExpObject.cs, RegExpConstructor.cs, Print.cs,
	Package.cs, ObjectConstructor.cs, NumberObject.cs,
	NumberConstructor.cs, MathObject.cs, Literal.cs,
	LenientGlobalObject.cs, JSVariableField.cs, JSToken.cs,
	JSScanner.cs, JSParser.cs, JSObject.cs, JSLocalField.cs,
	JSFunctionAttributeEnum.cs, JSFunctionAttibute.cs, JSField.cs,
	JSBuiltIn.cs, IVsaScriptScope.cs, IRedirectOutput.cs,
	IActivationObject.cs, GlobalScope.cs, GlobalObject.cs,
	FunctionObject.cs, FunctionExpression.cs, FunctionDeclaration.cs,
	FunctionConstructor.cs, FormalParameterList.cs, ErrorObject.cs,
	ErrorConstructor.cs, EnumeratorObject.cs,
	EnumeratorConstructor.cs, Enum.cs, Empty.cs, DocumentContext.cs,
	DateObject.cs, DateConstructor.cs, Context.cs, Closure.cs,
	BooleanObject.cs, BooleanConstructor.cs, Block.cs, BinaryOp.cs,
	BaseVsaEngine.cs, ArrayObject.cs, ArrayConstructor.cs,
	ActiveXObjectConstructor.cs, ActivationObject.cs: 

	indentation comformance to mono style. Returned to
	Microsoft.JScript namespace name. Now we can build
	Microsoft.JScript.dll on Linux/Windows, and build mjs.exe on
	linux/Windows with our Microsoft.JScript.dll. To build mjs.exe:
	$(CSC) /r:Microsoft.JScript.dll  driver.cs. Also changed my mind
	about the namespace stuff, because I want people 
	to contribute NUnit tests for Microsoft.JScript public API.
		
	* jscript-lexer-parser.g: Now we are back to Microsoft.JScript namespace.

2003-09-21    <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: fixed typo and added SEMI_COLON to print_statement.

2003-09-20    <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: We are little bit closer to the spec on
	StringLiteral definition.  

	* jscript-lexer-parser.g: One line patch, the beauty of tests :-)

	* jscript-lexer-parser.g: Build ast for FunctionExpression.

	* JSObject.cs: we don't throw NotImplementedException anymore,
	this let us use FunctionExpression to build the ast.

	* FunctionExpression.cs: Added a FunctionObject as field, a
	default constructor.

	* FunctionObject.cs: Added default constructor.

	* driver.cs: Deleted the Jsc class. We are not generating code
	now. I'm moving to provide something like mcs's EmitContext
	instead of the CodeGenerator class having the Reflection.Emit
	builders and ILGenerator. This driver is just for Lexical and
	Parsing phases testing.

	* driver.cs: Now we are using the Microsoft.JScript public API
	functions to load the lexer and parser.

	* ScriptBlock.cs,Block.cs: Added ToString function.

2003-09-20    <cesar@ciencias.unam.mx>

	* ASTList.cs, ArrayLiteral.cs, BitwiseBinary.cs, Block.cs,
	DebugBreak.cs, Enum.cs, Equality.cs, Eval.cs, ForIn.cs,
	FunctionExpression.cs, Import.cs, In.cs, InstanceOf.cs,
	Literal.cs, NumericBinary.cs, NumericUnary.cs, Package.cs,
	Plus.cs, PostOrPrefixOperator.cs, Print.cs, Relational.cs,
	Statement.cs, StrictEquality.cs, StringLiteral.cs, Throw.cs,
	Try.cs, TypeOf.cs, VariableDeclaration.cs, With.cs, ast.cs, 
	: erased Visit method and made some mono indentation style changes.

	* CodeGenerator.cs: commented some function calls.
	* FunctionDeclaration.cs: moved function attributes to
	FunctionObject class, erased Visit method.
	* FunctionObject.cs: Here is where we store a function
	expression/declaration info, erased Visit method.
	* ScriptBlock.cs: Added a Block field, Block will contain the
	source elements.
	* jscript-lexer-parser.g: updated the grammar to build the program
	representation based on ScriptBlock.

2003-09-19    <cesar@ciencias.unam.mx>

	* JSToken.cs: public API compliance.

2003-09-07 Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* Context.cs: Added constructor and Document field.
	* DocumentContext.cs: Added Name field.
	* JSParser.cs: Integration of antlr's generated parser with
	JSParser public API. ScriptBlock is now the principal data structure that
	represents a Jscript .Net program.
	* JSScanner.cs: Integration of antlr's generated lexer with
	JSScanner public API.

2003-07-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
	* Added files StringLiteral.cs, CodeGenerator.cs and Print.cs.

2003-07-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: Changed the namespace to
	Microsoft.JScript.Tmp.

	* jscript-lexer-parser.g: Fixwd a typo at source_elements rule.

	* jscript-lexer-parser.g: Got the name of a
	global_function_declaration and also its return type if
	available. 

	* jscript-lexer-parser.g: Added syntatic rule for print_statement.
	* jscript-lexer-parser.g: Initial construction of AST for
	enum_statement and package_statement.

	* jscript-lexer-parser.g: Fixed the enum_statement to accept
	empty enum declarations.

	* jscript-lexer-parser.g: Got the type of a
	veriable_declaration.

	* jscript-lexer-parser.g: Initial construction of AST for
	primary_expression (in particular literal).


2003-07-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* driver.cs: Modified the driver structure to be compatible
	with our new CodeGenrator and SemanticAnalizer. I
	removed the builders from Reflection.Emit to the
	CodeGenerator. Added an ASTList, SemanticAnalizer and
	CodeGenerator here. Adde methods Run, GenerateCode


2003-07-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
	* Statement.cs: Forgot to include it on last commit.

2003-07-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
	
	* Decided to change temporarly namespace name
	Microsoft.JScript to Microsoft.JScript.Tmp in order to be able
	to run the code generated by our CIL code generator (on  next
	commit will come). The problem is that we don't have the
	runtime support for our compiler, this involve VsaEngine class
	and its "friends", which I have not found a lot of
	doumentation for. If someone knows a docs place for them,
	don't hesitate to send me a email pointing to them.

	* Changed from public to internal Visit function at some
	classes.

	* Package.cs: Added Name and Members fields.
	
	* SemanticAnalizer.cs: Added methods VisitPrint and
	VisitStringLiteral.

	* VariableDeclaration.cs: Added Type field.

	* Visitor.cs: Changed from public to internal. Added
	VisitPrint and VisitStringLiteral methods.

	* VsaEngine.cs: Fixed namespace name from Microsoft.JScript to
	Microsoft.JScript.Vsa and then to Microsoft.JScript.Vsa.Tmp.
	



2003-07-22  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* Added CmdLineError.cs and JSError.cs, last night I forgot to
	commit them.

2003-07-21 Cesar Lopez Nataren <cesar@ciencias.unam.mx>
	* Added files:
	ArrayPrototype.cs, ArrayWrapper.cs, BitwiseBinary.cs, 
	BlockScope.cs, BooleanPrototype.cs, BreakOutOfFinally.cs, 
	CmdLineException.cs, CmdLineOptionParser.cs, 
	ContinueOutOfFinally.cs, Convert.cs, DatePrototype.cs, 
	DocumentContext.cs, EnumeratorPrototype.cs, Equality.cs, 
	ErrorPrototype.cs, EvalErrorObject.cs, Expando.cs, 
	FieldAccessor.cs, FunctionPrototype.cs, FunctionWrapper.cs, 
	Globals.cs, In.cs, InstanceOf.cs, JSConstructor.cs, 
	JScriptException.cs, JSFieldInfo.cs, JSMethodInfo.cs, JSParser.cs, 
	JSPrototypeObject.cs, JSScanner.cs, LateBinding.cs, 
	LenientArrayPrototype.cs, LenientBooleanPrototype.cs, 
	LenientDateConstructor.cs, LenientDatePrototype.cs, 
	LenientEnumeratorPrototype.cs, LenientErrorPrototype.cs, 
	LenientFunctionPrototype.cs, LenientMathObject.cs, 
	LenientNumberPrototype.cs, LenientObjectPrototype.cs, 
	LenientRegExpPrototype.cs, LenientStringConstructor.cs, 
	LenientStringPrototype.cs, LenientVBArrayPrototype.cs, 
	MemberInfoList.cs, MethodInvoker.cs, Missing.cs, Namespace.cs, 
	NotRecommendedAttribute.cs, NumberPrototype.cs, NumericBinary.cs, 
	NumericUnary.cs, ObjectPrototype.cs, Plus.cs, 
	PostOrPrefixOperator.cs, RangeErrorObject.cs, 
	ReferenceAttribute.cs, ReferenceErrorObject.cs, RegExpMatch.cs, 
	RegExpPrototype.cs, Relational.cs, ResInfo.cs, 
	ReturnOutOfFinally.cs, ScriptStream.cs, SimpleHashtable.cs, 
	StackFrame.cs, StrictEquality.cs, StringPrototype.cs, 
	SuperTypeMembersSorter.cs, SyntaxErrorObject.cs, TypedArray.cs, 
	TypeErrorObject.cs, TypeOf.cs, TypeReflector.cs, 
	URIErrorObject.cs, VBArrayObject.cs, VBArrayPrototype.cs, 
	VersionableAttribute.cs 

	Now, I must fill in the blanks :-)


2003-07-09  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
	* jscript-lexer-parser.g: Added conditional_compilation_directive,
	which is the beginning of our support for conditional compilation
	statements and directives in our parser. Added
	cc_on_statement, and some lexer rules for getting the needed
	tokens (COND_SET, COND_DEBUG, COND_POSITION, COND_POSITION,
	COND_IF, COND_ELIF, COND_ELSE, COND_END and CC_ON.


2003-07-03  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: Changed the format of copyright notice.

	This changes will allow the support
	for the grammar added by MS to EcmaScript (aka its JScript .Net),
	I'm still missing some, but they are on the way.

	* jscript-lexer-parser.g: Deleted function_declaration, and
	added global_function_declaration and type_function_declaration.
	I decided  to make the grammar as strict as the MS docs mark,
	but there's a difference between what their docs says and what
	their compiler does. For this case I decided to follow the
	docs. A program like: 
		private function F () 
		{}
	according to the docs, would not be syntaticly correct. But the MS
	compiler, accepts the grammar construct and mark the error at
	semantic analysis phase. I followed the docs this time.	

	* jscript-lexer-parser.g: Added debbuger_statement.
	* jscript-lexer-parser.g: Added import_statement.
	* jscript-lexer-parser.g: Added package_statement and package_member(s).
	* jscript-lexer-parser.g: Added super_statement.
	* jscript-lexer-parser.g: Added const_statement.
	* jscript-lexer-parser.g: Added class_statement,
	interfaces_list and class_members. 

	* jscript-lexer-parser.g: Added interface_statement and
	interface_members.

	* jscript-lexer-parser.g: Added enum_statement.
	* jscript-lexer-parser.g: Added static_statement. The rule for
	this syntatic construc is: static identifier { [body] }
	body does not get well specified in the docs. Must search wich
	are the possible values of it.

	* jscript-lexer-parser.g: At variable_declaration, added
	support for explicit type declaration.

	* jscript-lexer-parser.g: Added numeric_literal,
	DECIMAL_LITERAL and HEX_INTEGER_LITERAL.

	* jscript-lexer-parser.g: Added modifiers, modifier, version_modifier.


2003-06-09  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>


	* Added the Visit method to classes: AST, ArrayLiteral, ASTList,
	Block, DebugBreak, Eval, ForIn, FunctionDeclaration,
	FunctionExpression, Import, Package, ScriptBlock, Throw, Try,
	With, 
	
	That method will be the driver that will allow classes
	that implement the Visitor interface do a walk through the AST's
	elements, in particular the Semantic Analizer and the Code
	Generator. Every class that inherits from AST will have a Visit
	method, that method will receive a Visitor and a object as
	parameters, the only thing that it'll do is letting the Visitor
	call the respective method VisitX, where X is the name of the
	currently visited class.
	
	* ASTList.cs:Added constructor, Add, Visit, ToString  methods.

	* FunctionDeclaration.cs: Added constructor, Visit and ToString
	methods.
	
	* jscript-lexer-parser.g: Added a ASTList as a parameter to the
	program (the main entry of the parser). Also added as parameters: 
		- An AST to source_element.
		- A Statement to statement.
		- A VariableStatement to variable_statement.
		- A VariableStatement to variable_declaration_list.
		- A FormalParamerList by formal_parameter_list.
		- A ASTList by function_body.
	
	And now some rules return objects:
		- A VariableDeclaration by variable_declaration.
		- A Functiondeclaration by function_declaration.

	* driver.cs: Added the construction of the AST of the EcmaScript
	program.

	* Visitor.cs: Added this file. It's the visitor interface. 

	* VariableDeclaration.cs: Added this class, it's the AST
	representation of a variable declaration.

	* Statement.cs: Added this file. It's the logical representation
	of a Statement.

	* VariableStatement.cs: Added this class. It's the AST
	representation of a chain of variable declarations.
	
	* FormalParameterList.cs: The function declaration needs to store
	its parameter, we will put them on this class.

	* SemanticAnalizer.cs: Added this class. I'll use the Visitor pattern in order to
	implement the semantic analysis and code generation
	phases. SemanticAnalizer and CodeGenerator will implement the
	Visitor interface, they will walk a program's
	AST tree and do their respective work.

	* IdentificationTable.cs: Added this class. The SymbolTable will be used
	by the SemanticAnalyzer in order to keep track of the variable
	declaration encountered, etc..

	* SymbolTable.cs: A simple hashtable but for commodity i'll call
	it this way.

	
2003-05-03  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g:
	- Deleted the assignment_operator COMPOUND_ASSIGNMENT, and added
	MULTIPLICATION_ASSIGN, DIVISION_ASSIGN, REMAINDER_ASSIGN,
	ADDITION_ASSIGN, SUBSTRACTION_ASSIGN, SIGNED_LEFT_SHIFT_ASSIGN,
	SIGNED_RIGHT_SHIFT_ASSIGN, UNSIGNED_RIGHT_SHIFT_ASSIGN,
	BITWISE_AND_ASSIGN, BITWISE_OR_ASSIGN.
	- Changed INTERROGATION to CONDITIONAL.
	- Changed TRIANGLE to BITWISE_XOR.
	- Changed SLASH to DIVISION.
	- Changed PERCENT to REMAINDER.
	- Changed ADMIRATION to LOGICAL_NOT
	- Added BITWISE_NOT (~).
	- Added the INCREMENT and DECREMENT rules for
	left_hand_side_expression.
	- Increased lexer lookup from 2 to 4.
	- Redefined the definitions of: L_THAN, G_THAN, MINUS, TIMES,
	BITWISE_AND, BITWISE_OR,
	- Added operator: EQUALS, DOES_NOT_EQUALS, STRICT_EQUALS,
	REMAINDER, UNSIGNED_RIGHT_SHIFT.
	- Added the recursion rules for equality_expression.
	- Added the recursion rules for shift_expression.
	- Now we skip tabs.
	- The most important thing, added support for expressions like:
	sdf.[hgh], cool!

2003-04-20	Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>

	* driver.cs: 
	- Erased the Context class, it was used for the first
	test of the print_statement and Reflection.Emit. As I erased the
	Program, SourceElements, SourceElement from the ANTLR grammar (for
	the rework of the AST tied to the MS JScript public API), I erased
	some uses in here.
	- Erased the methods: EmitJScript0Type, EmitJScript0Cons,
	EmitGlobalCode, EmitJScript0, EmitJScriptMainType,
	EmitJScriptMainCons, EmitJScriptMainFunction, EmitJScriptMain,
	Emit.

	* jscript-lexer-parser.g: 
	- Erased the references to the classes Program, SourceElements,
	SourceElement, Statement, FunctionDeclaration and erased
	print_statement rule. 

	* JSCriptLexer.cs JScriptParser.cs and the other files generated
	by antlr, reflect changes from the grammar changes.

2003-04-19	Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>
	* Added stubs for the classes:
	ASTList.cs 
	ActivationObject.cs 
	ActiveXObjectConstructor.cs 
	ArrayConstructor.cs 
	ArrayLiteral.cs 
	ArrayObject.cs 
	AssemblyCustomAttributeList.cs 
	BaseVsaEngine.cs 
	BinaryOp.cs 
	Binding.cs 
	Block.cs 
	BooleanConstructor.cs 
	BooleanObject.cs 
	Closure.cs 
	Context.cs 
	DateConstructor.cs 
	DateObject.cs 
	DebugBreak.cs 
	Empty.cs 
	EnumeratorConstructor.cs 
	EnumeratorObject.cs 
	ErrorConstructor.cs 
	ErrorObject.cs 
	Eval.cs 
	ForIn.cs 
	FunctionConstructor.cs 
	FunctionDeclaration.cs 
	FunctionExpression.cs 
	FunctionObject.cs 
	GlobalObject.cs 
	GlobalScope.cs 
	IActivationObject.cs 
	IRedirectOutput.cs 
	IVsaScriptScope.cs 
	Import.cs 
	JSBuiltIn.cs 
	JSField.cs 
	JSFunctionAttribute.cs 
	JSFunctionAttributeEnum.cs 
	JSLocalField.cs 
	JSObject.cs 
	JSToken.cs 
	JSVariableField.cs 
	LenientGlobalObject.cs 
	MathObject.cs 
	NumberConstructor.cs 
	NumberObject.cs 
	ObjectConstructor.cs 
	Package.cs 
	RegExpConstructor.cs 
	RegExpObject.cs 
	ScriptBlock.cs 
	ScriptFunction.cs 
	ScriptObject.cs 
	StringConstructor.cs 
	StringObject.cs 
	Throw.cs 
	Try.cs 
	UnaryOp.cs 
	VBArrayConstructor.cs 
	VsaEngine.cs 
	With.cs 	
	

2003-04-11	Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g:
	- Added rules for: continue_statement, break_statement,
	return_statement, throw statement (all of them do not ensure that
	no LineSeparator appears between the keyword on the left and the
	identifier, expression or semicolon on the right, that must be fixed).
	- Added single line comments rule.

2003-04-08	Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: Added syntatic rule for:
	- if_statement.
	- while and for-in subrules of iteration_statement.
	- Added array_literal - got tricky - I just could get the simplest rule going :)
	- Added elision.

	
2003-04-08	Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g:
	- Syntatic rule for iteration_statement.
	- "do" subrule for it.
	- Added ((L_THAN | G_THAN | LE_THAN | GE_THAN | "instanceof" |
	"in") relational_expression | )	rule to relational_expression.
	-Added function_expression syntatic rule.
	- Added STRING_LITERAL to literal rules.
	- "Less/Greater or equal than" lexer rule.

2003-04-03	Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: Added switch_statement rule, case_block, case_clauses, case_clause, default_clause, labelled_statement, try_statement, catch_exp, finally_exp.

2003-04-01    Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>

	* jscript-lexer-parser.g: Added the grammar rules for: with_statement, object_literal, ( expression ), property_name_and_value_list, property_name and expression.
	

2003-03-30    Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>

	* Added a README file. Explains the dependencies and build process.

2003-03-30   Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>

	* Added this ChangeLog file.
	
	* ast.cs: Added this file. Contains the classes used for building
	the EcmaScript 's AST.

	* JScript*: These are the files generated by antlr (the parser generator). 

	* TODOAttribute.cs: Changed the namespace in order to use it freely on Microsoft.JScript.

	* driver.cs: Added this file. Contains the compiler entry point. And some Reflection.Emit methods,
	that will be moved to other file in the future.

	* jscript-lexer-parser.g: The EcmaScript's antlr grammar.	
