mcs/class/Microsoft.JScript/Microsoft.JScript/ChangeLog

   1 2004-06-24  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
   2
   3         * jscript-lexer-parser.g: added ast building for object_literal,
   4         it's disabled for now while I fix the "block Vs object_literal"
   5         non-determinism problem on the parser. Added rule for
   6         array_literal. Build PropertyName ast build.
   7         * Literal.cs: fixed the negative numbers code generation (we must
   8         optimize this). Added initial ObjectLiteral's class, code generation and
   9         Resolve process. Added class ObjectLiteralItem and PropertyName.
  10         * ArrayLiteral.cs: added internal size field as an ArrayLiteral can have
  11         elisions we keep track of the "real" size here. Added constructor. Added initial
  12         Resolve and Emit code.
  13         * ASTList.cs: added Size property.
  14         * Globals.cs, ASTList.cs: Back to the useful namespace (M.J).
  15
  16 2004-06-20  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  17
  18         * CodeGenerator.cs: Added LoopBegin and LoopEnd to EmitContext, they are used by
  19         break and continue in order to jump to the desired place. Added
  20         check for converting to boolean if we encounter an identifier (at need_convert_to_boolean).
  21         * Statement.cs: class If.Emit, call fall_true instead of fall_false so we don't
  22         need to jump if the expression evaluates to true. Continue class,
  23         replaced ParentIsItrStm with InLoop, emit jump to correct
  24         place. Break class, implemented Resolve; deleted
  25         ParentIsCorrect. DoWhile, While classes, set LoopBegin and
  26         LoopEnd. While class, set LoopBegin and LoopEnd.
  27         * ast.cs: Added InLoop and InSwitch.
  28         * jscript-lexer-parser.g: pass parent to break_stm. Added block as
  29         a statement. Temporarily disabled object_literal in order to test
  30         the block structure and continue and break statements.
  31
  32 2004-05-28  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  33
  34         * Statement.cs: changed parent_is_itr_stm method to ParentIsItrStm
  35         property. Added initial pieces for Break's Resolve. Fixed bug that
  36         did not let Emit the code for case clauses that came after the
  37         default clause (we match the jsc behavior).
  38         * jscript-lexer-parser.g: set parent of switch's clauses.
  39
  40 2004-05-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  41
  42         * Statement.cs: added parent as a parameter on Continue constructor. Added parent_is_itr_stm
  43         * jscript-lexer-parser.g: set parent hierarchy for continue
  44         statement. Set to correct parent in iteration_stm.
  45
  46 2004-05-24  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  47
  48         * StrictEquality.cs, JSFieldInfo.cs: got it back to Microsoft.JScript namespace.
  49
  50         * Statement.cs: Added code generation support for 'switch' statement.
  51
  52         * jscript-lexer-parser.g: added 'using' for
  53         System.Collections. Allow 'switch' statement building of its
  54         ast. Added parent parameter to constructor of With. Build
  55         inside_for ast.
  56
  57         * With.cs: code generation support for 'with' stm.
  58
  59 2004-05-21  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  60
  61         * Statement.cs: initial code generation of 'for'.
  62         * jscript-lexer-parser.g: let's build for's ast.
  63
  64 2004-05-18  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  65
  66         * jscript-lexer-parser.g: let's build Try/Catch/Finally ast.
  67         * expression.cs: handle Try case for field or local vars allocation.
  68         * Try.cs: implemented Emit.
  69         * Throw.cs: implemented code generation.
  70         * FunctionDeclaration.cs: cache some values.
  71
  72 2004-04-26  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  73
  74         * FunctionDeclaration.cs: let's make function name formation
  75         (get_name ()) a little bit less dumb. We cache the prefix now so
  76         we don't have to recalculate it everytime.
  77
  78 2004-04-22  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  79
  80         * Literal.cs: emit the correct code for negative numbers.
  81         * jscript-lexer-parser.g: set parent unary_expr.
  82
  83 2004-04-18  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  84
  85         * expression.cs: added code generation for 'x1 ? x2 :x3' op.
  86         * Statement.cs: Added code generation for while and do-while.
  87
  88 2004-04-17  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  89
  90         * Statement.cs (class if): reimplemented Emit based on fall_false.
  91         * Equality.cs: added code generation for != and emit jumping code
  92         only in the case we are at a global expression not statement.
  93         * CodeGenerator.cs (fall_true, fall_false): Check if convertion to
  94         boolean needed. Made emit_to_boolean internal. Added need_convert_to_boolean.
  95
  96 2004-04-14  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
  97
  98         * expression.cs (Binary.Emit): treat boolean operator
  99         specially. Added emit_jumping_code.
 100         * CodeGenerator.cs: Added emit_to_boolean. Added fall_true and
 101         fall_false, which will express all boolean expressions and control
 102         flow conditions.
 103
 104 2004-04-02  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 105
 106         * Equality.cs: Moved the Emit and Resolve code here.
 107         * jscript-lexer-parser.g: Build a Equality object instead of a
 108         Binary object for equality_expr.
 109         * expression.cs: moved equality oeprators (resolve and IL gen) to
 110         Equality.Emit and Equality.Resolve.
 111
 112 2004-03-31  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 113
 114         * expression.cs: Added shift operators IL emit.
 115         * BitwiseBinary.cs: added constructor for building it according to
 116         JSToken enum. return a new object on EvaluateBitwiseBinary (this
 117         needs a real implementation).
 118         * expression.cs: added code for evaluation of bitwise operators at emit_op_eval.
 119
 120         * Statement.cs: added stub for While and DoWhile ast
 121         representation (reworking my Emit code).
 122         * jscript-parser-lexer.g: allow iteration statement ast build.
 123
 124         * FunctionDeclaration.cs: agrouped code for setting custom attribute.
 125
 126         * expression.cs: added Modulo operator case.
 127
 128 2004-03-16  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 129
 130         * Convert.cs: added rule for string conversion.
 131
 132         * Plus.cs: added rule for string addition.
 133
 134         * PostOrPrefixOperator.cs: added constructor, returned to Microsoft.JScript ns, initial Resolve and
 135         Emit (cases where there's no real operator).
 136
 137         * StringLiteral.cs: now implements Exp as can appear as a simple
 138         exp in global code. Added check for Pop generation.
 139
 140         * expression.cs: added IL generation code for print func call.
 141         Args class added get_element, Size and made Resolve behave as the
 142         others (collect the differents Resolve's return values from each
 143         of the arguments). Expression class, added default Resolve call
 144         for non-Exp implementers.
 145
 146         * jscript-lexer-parser.g: postfix_expr rule now returns a simple
 147         AST, this handles the case where no postOrPrefixOp present; Unary
 148         returns an AST too.
 149
 150         * FormalParameterList.cs: added get_element, retrieves nth element.
 151
 152 2004-03-14  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 153
 154         * ScriptStream.cs: let's print some messages.
 155
 156         * jscript-lexer-parser.g (STRING_LITERAL): Do not include the ' in the text of the rule.
 157
 158 2004-03-13  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 159
 160         * jscript-lexer-parser.g: keep track of return's parent.
 161         * Statement.cs: added parent parameter to constructor.
 162
 163         * expression.cs: refactored Emit code from Identifier, now we take
 164         care of function's paramenter references. First attack to function
 165         calls, check if Resolve from Call succeed.
 166
 167         * VariableDeclaration.cs: Deleted Decl class, field_info and
 168         local_builder fields were being used only by VariableDeclaration,
 169         I'll keep them there.
 170
 171         * FormalParameterList.cs: added field pos to FormalParam, and set
 172         it at FormalParameterList's Resolve stage.
 173
 174         * TODO: updated TODO.
 175
 176 2004-03-07  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 177
 178         * jscript-lexer-parser.g: build If's ast. Keep track of expr parent.
 179
 180         * expression.cs: At class Conditional renamed fields. Class
 181         Expression inherits from Exp as we must keep track if we must pop
 182         the last value (this is for the comma operator), track the parent,
 183         at Resolve we take care of the last value of the expression,
 184
 185         * VariableDeclaration.cs: updates needed because of EmitContext change.
 186
 187         * Statement.cs: added parent param to If constructor. Implement
 188         Resolve and Emit for If statement.
 189
 190         * Relational.cs: Set parent. The boxing happens in the containing statement.
 191
 192         * FunctionDeclaration.cs: Added func_type field, will be used to determine the
 193         type of the function we are generating (global function, method
 194         from a class, etc) and attach to it the correct custom
 195         attribute. Simplified the code for nested functions:
 196         refactored the code so no code duplication is involved, now we
 197         have only one function that retrieves  the name of the function,
 198         now create a new EmitContext for the body of the method.
 199
 200         * FormalParameterList.cs, Literal.cs, StringLiteral.cs:  use
 201         current EmitContext's ILGenerator.
 202
 203         * Convert.cs: Do not throw the NotImplementedException anymore for
 204         method ToBoolean, for now we always return false. This must get a
 205         real implementation.
 206
 207         * CodeGenerator.cs:  Deleted one of ILGenerator fields
 208         from EmitContext, suffices using only one (more notes about the
 209         change on the Functiondeclaration entry). Imitate jsc behavior for
 210         compiled files names, aggregate the exe or dll extension after last dot.
 211
 212         * Block.cs: In order to implement the comma operator (i.e., expression,
 213         assign_exp), we must track if our expressions are at a global
 214         scope, in which case we must pop the last result too.
 215
 216 2004-01-25  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 217
 218         * Relational.cs: Initial generation of CIL for relational operators.
 219
 220 2004-01-23  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 221
 222         * jscript-lexer-parser.g: formal_param_list receives a parent too.
 223
 224         * SymbolTable.cs: added size and current_symbols properties.
 225
 226         * JSLocalField.cs: don't throw not ImplementedException from
 227         constructor (same reason, testing purposes, must get implemented
 228         for real).
 229
 230         * IdentificationTable.cs: added num_of_locals and current_locals properties.
 231
 232         * FunctionDeclaration.cs: added a LocalBuilder and DictionaryEntry
 233         as fields. Not throw NotImplementedException for
 234         JScriptFunctionDeclaration (testing purposes, must get implemeted
 235         for real). Let's build our function closures! Added functions:
 236         build_closure and build_closure_nested, build_local_fields. Keep
 237         track of current parameters and locals defs.
 238
 239         * FormalParameterList.cs: made FormalParam inherit from
 240         AST. Implement the Emit for parameters, yeah!
 241
 242         * CodeGenerator.cs: added a ModuleBuilder reference. New constructor.
 243
 244         * Closure.cs: do not throw the exception (this allow me to run the
 245         tests  at mcs/jtests and check that at least i'm not generating
 246         invalid CIL). Be aware that this must be really implemented.
 247
 248         * Block.cs: renamed field, and implement the double pass for
 249         nested function declarations code emittion, yeah!.
 250
 251 2004-01-16  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 252
 253         * Microsoft.JScript/VsaReferenceItem.cs: renamed field, reuse parent's ctr.
 254         * Microsoft.JScript/VsaItem.cs: renamed some fields, added ctr,
 255         * Microsoft.JScript/VsaGlobalItem.cs: reuse parent ctr.
 256         * Microsoft.JScript/VsaCodeItem.cs: reuse parent ctr.
 257         * Microsoft.JScript/GlobalScope.cs: reuse constructors from parent.
 258
 259         * UnaryOp.cs: inherit from Exp now.
 260         * Plus.cs: Don't throw the exception when calling constructor, let
 261         it build the default handler. Return a new object when calling
 262         EvaluatePlus until properly implemented.
 263
 264         * NumericUnary.cs: added new Resolve.
 265         * NumericBinary.cs: assign operator val at ctr. Return a new
 266         object when calling EvaluateNumericBinary until properly
 267         implemented. Added Resolve.
 268         * Equality.cs: added ctr and return false for EvaluateEquality
 269         until properly implemented. Added Resolve's functions.
 270
 271         * Block.cs (Resolve): That check was not necessary.
 272
 273         * InstanceOf.cs, PostOrPrefixOperator.cs, Relational.cs,
 274         StrictEquality.cs, TypeOf.cs: added Resolve inherited from
 275         BinaryOp and UnaryOp, and this from Exp.
 276         * IdentificationTable.cs, ScriptBlock.cs: deleted debugging messages.
 277         * jscript-lexer-parser.g: deleted debugging messages. Create a
 278         Assign object instance of a simple Binary obj. Same case for Equality.
 279
 280         * expression.cs: added Exp abstract class. Classes that are ast of
 281         language constructions that can appear as global expressions that
 282         get evaluated and then the result is discarded inherit from this
 283         new class. This let meee keep track of things that must get Popped
 284         or can even avoid the evaluation of it. Wrote real Resolve method
 285         for classes: Unary, Binary.
 286         Implemted Emit method for some binary operations (+, -, / and *),
 287         for other operators some more code is still missing.
 288         Identifier: handle assignment cases and global exp cases.
 289         Added class Assign (compisite assignment still missing tough :-(
 290
 291         * driver.cs: deleted debug messages, added "Compilation Succeeded"
 292         message ;-).
 293         * VariableStatement.cs, VariableDeclaration.cs: wrote real Resolve method.
 294         * Literal.cs (BooleanLiteral, NumericLiteral): now inherits from
 295         Exp and handle the case for global expressions that must be popped
 296         after evaluation. no more invalid IL being generated! yeah!
 297         * Block.cs: wrote real Resolve method, erased debug messages.
 298         * BitwiseBinary.cs, InstanceOf.cs, UnaryOp.cs: : add new Resolve inherited from Exp.
 299         * BinaryOp.cs, Conditional: now inherits from Exp.
 300
 301 2004-01-15  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 302
 303         * ReferenceAttribute.cs: moved it back to namespace Microsoft.JScript.
 304
 305         * CodeGenerator.cs: small fixes to generate same things that ms.
 306
 307 2004-01-13  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 308
 309         * VariableDeclaration.cs: get the this.type which is a Type not a TypeBuilder.
 310
 311 2004-01-12  Atsushi Enomoto  <atsushi@ximian.com>
 312
 313         * JSMethodInfo.cs : tiny fix for NET_2_0 build.
 314
 315 2003-12-24  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 316
 317         * jscript-lexer-parser.g: keep track of parent reference for
 318         IDENTIFIER, STRING_LITERAL.
 319
 320         * expression.cs: Added 'binding' field. Added 'parent' parameter
 321         to constructor. Now we emit the proper code for the identifier.
 322
 323         * VariableStatement.cs: updated to field names instead of the old
 324         property's name.
 325
 326         * VariableDeclaration.cs: Added class Decl, it constains the
 327         references to the static field or LocalBuilder that are created
 328         when a declaration is emitted. Deleted unuseful properties (Id,
 329         InitValue, Type).
 330
 331         * SymbolTable.cs: Deleted Retrieve method. Contains now returns an
 332         object instead of a boolean.
 333
 334         * StringLiteral.cs: Deleted unuseful properties. Use ig instead of ec.ig.
 335
 336         * IdentificationTable.cs: Deleted Retrieve method. Contains method
 337         now return an object instead of a boolean, that reference is the
 338         binding associated with the identifier being searched.
 339
 340 2003-12-18  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 341
 342         * jscript-lexer-parser.g: Keep track of parent for numeric_literal.
 343
 344         * VariableDeclaration.cs: now I handle initialization (ex. var x =
 345         2; or function f () { var x = 4; }) at global scope or at
 346         function's body.
 347
 348         * Literal.cs: Added parent param to NumericLiteral constructor.
 349
 350         * FunctionDeclaration.cs: Added Ret opcode for all function declaration bodies.
 351
 352 2003-12-17  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 353
 354         * CodeGenerator.cs: Added IL emittion for ldnull on default ending code for 'Global Code'.
 355
 356 2003-12-10  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 357
 358         * jscript-lexer-parser.g: added 'tokens { IN = "in"; INSTANCE_OF =
 359         "instanceof"; }' in order to be able to parse both keywords. When
 360         generating the parser, one warning about nondeterminism
 361         (k==1:"in") is generated ignore it.
 362
 363 2003-12-07  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 364
 365         * jscript-lexer-parser.g: things like 'new Point (10, 20).x' were
 366         not parsable now they are. Mozilla's and Janet's  test suites are
 367         being really helpful.
 368
 369 2003-12-05  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 370
 371         * jscript-lexer-parser.g: added check for non-null reference at
 372         var_decl_list rule. Added single quote STRING_LITERAL lexical rule
 373         and multiple lines comments rule.
 374
 375         * jscript-lexer-parser.g: Now I keep track of the parent for most
 376         of the syntatic constructs. Fixed object_literal rule.
 377
 378         * ast.cs: Added field parent. This will help me to track nested
 379         blocks for all of the syntatic constructs and will allow to Emit
 380         everything in one single pass.
 381         * FunctionDeclaration.cs, FunctionExpression.cs: Rearranged the
 382         parent stuff.
 383         * Block.cs, FunctionObject.cs: deleted parent field as AST will
 384         hold it. Delete parent parameter from constructor.
 385         * CodeGenerator.cs: Add field gc_ig (global code IL generator) to
 386         EmitContext class. The idea is Emitting everything in one pass (decls
 387         and 'Global Code' method, the parent reference let me know which IL
 388         generator use, gc_ig or ig).
 389         * Equality.cs, BooleanLiteral, Relational.cs: Added new parameter to
 390         constructor. Use new parent reference for choosing the IL
 391         generator. NumericLiteral a 'hard coded' int32 IL emittion added
 392         for testing.
 393         * StringLiteral.cs, Literal.cs (BooleanLiteral.Emit): now I use
 394         the parent reference to infere which IL generator to use.
 395         * VariableDeclaration.cs: deleted parent field. At Emit, now I use the parent
 396         reference to infer which IL generator to use.
 397         * expression.cs: Added paramenter parent to constructor of: Unary,
 398         Binary, Conditional, Call.
 399
 400 2003-11-30  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 401
 402         * expression.cs: Added new field to Call class, so it can handle more arguments.
 403
 404         * StringLiteral.cs (Emit) : Load the string value.
 405
 406         * Literal.cs: BooleanLiteral, Resolve always return true. Emit the value and box it to Boolean.
 407
 408         * CodeGenerator.cs: Set parent if 'JScript 0' to GlobalScope. Set
 409         custom attribute. Build default 'JScript 0' constructor. Emit
 410         default initial/final code of 'Global Code'. Create default
 411         'JScript Main'.
 412
 413 2003-11-29  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 414
 415         * jscript-lexer-grammar.g: define new rule 'arguments' instead of
 416         repeating hand written rule all around. Change "." for DOT, dumb
 417         mistake by myself. Added rule new_expr. Now we handle properly the
 418         call_expr rule (as defined on the spec), and added a new
 419         argument. Added subrule new_expr to  left_hand_side_expr rule.
 420
 421 2003-11-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 422
 423         * expression.cs (Expression): implemented Emit.
 424
 425         * expression.cs (Binary): Emit now creates a local for the
 426         different kinds of binary expressions (initial code for this).
 427
 428         * ast.cs: Emit method now is abstract instead of virtual.
 429
 430         * CodeGenerator.cs: changed no_global_code_method to is_global_code_method.
 431
 432         * ASTList.cs, ArrayLiteral.cs, BitwiseBinary.cs, DebugBreak.cs,
 433         Enum.cs, Equality.cs, Eval.cs, ForIn.cs, FormalParameterList.cs,
 434         FunctionExpression.cs, Import.cs, InstanceOf.cs, Literal.cs,
 435         NumericLiteral, NumericBinary.cs, NumericUnary.cs, Package.cs,
 436         Plus.cs, PostOrPrefixOperator.cs, Print.cs, Relational.cs,
 437         Continue, Break, Return, StrictEquality.cs, StringLiteral.cs,
 438         Throw.cs, Try.cs, TypeOf.cs, VariableDeclaration.cs, With.cs,
 439         Conditional, Call, Identifier, Args, Expression, :
 440         added Emit method.
 441
 442         * FunctionDeclaration.cs: Check if values are not null first (at
 443         Resolve). Ignore code generation is at 'Global Code'.
 444
 445         * VariableDeclaration.cs: Now I take care of IL generation when we
 446         are at statements and expressions at global code, 'Global Code'
 447         method is populated with that IL.
 448
 449         * CodeGenerator.cs: Added flag for 'Global Code' method
 450         emittion. Now I call 'Emit' twice. The first for declarations the
 451         follower for statements and expressions at global scope.
 452
 453 2003-11-10 cesar lopez nataren <cesar@ciencias.unam.mx>
 454
 455         * Visitor.cs: Deleted.
 456
 457 2003-11-09 cesar lopez nataren <cesar@ciencias.unam.mx>
 458
 459         * FormalParameterList.cs: Now inherits from AST. Each of the
 460         formal parameters gets into the IdentificationTable at Resolve.
 461
 462         * FunctionDeclaration.cs:Resolve (), We open a new block when
 463         encountering a FunctionDeclaration, resolve de parameters and the
 464         body, at the end we close the block.
 465
 466         * IdentificationTable.cs: Now we keep track of parent of the
 467         current block. 'Enter (...)' now receives an object, not a
 468         VarDecl. 'Contains' now take care of searching through the binding
 469         chain.
 470
 471         * Literal.cs: Deleted 'Literal' class, was being used for
 472         nothing. All the classes the inherited from it, now do it from
 473         AST. A 'literal' does resolve to true by default.
 474
 475         * Relational.cs: Resolve recursively left and right.
 476
 477         * SemanticAnalyser.cs: added flag for 'print statement'.
 478
 479         * Statement.cs: 'If' class, resolves firstly the condition, the true_stm
 480         and false_stm.
 481
 482         * driver.cs:  Init the semantic analysis phase.
 483
 484         * expression.cs: 'Unary' class, resolves its operand
 485         first. 'Binary' class,resolves left and right first. 'Args' class
 486         resolve all the formal parameters first. 'Expression' resolve all
 487         the nested expressions first.
 488
 489         * jscript-lexer-parser.g: Replaced 'Literal' references for AST ones.
 490
 491 2003-11-08 cesar lopez nataren <cesar@ciencias.unam.mx>
 492
 493         * jscript-lexer-parser.g: Allow the building of numeric_literal and DECIMAL_LITERAL,
 494         this is temporal in order to get Factorial compiled by mjs (must
 495         build the types according to Ecma-262 spec).
 496
 497         * Literal.cs: Added NumericLiteral class.
 498
 499 2003-11-06 cesar lopez nataren <cesar@ciencias.unam.mx>
 500
 501         * FunctionDeclaration.cs: Build a ScriptFunction local variable,
 502         if inside a nested block.
 503
 504 2003-11-05 cesar lopez nataren <cesar@ciencias.unam.mx>
 505
 506         * jscript-lexer-parser.g: Now we take care of parents. This allows
 507         to keep track if we are inside nested blocks. At
 508         'func_decl_or_expr', now I built the FunctionDeclaration or
 509         FunctionExpression first and then assign its body to it - this let
 510         me get a non-null value of the FunctionExpression or
 511         FunctionDeclaration so I can detect if it's a nested block (thanks go to Jackson!).
 512
 513         * Block.cs, FunctionObject.cs, VariableDeclaration.cs: Added 'AST parent' field.
 514         * Block.cs, FunctionDeclaration.cs, FunctionExpression.cs,
 515         FunctionObject.cs, VariableDeclaration.cs: Added 'AST parent' parameter to constructor.
 516
 517         * ScriptBlock.cs: Initiate the global block with 'null' as parent.
 518
 519         * FunctionDeclaration.cs: Added 'get_composite_name ()' method
 520         (gets the name of a function if it's nested). Emit code for
 521         function's body. At 'Emit ()' now we take care if it's a nested
 522         declaration.
 523
 524         * FunctionObject.cs: default return type is 'void' not
 525         'Object'. Function declarations without parameters map to functions with
 526         'Object this' and 'VsaEngine engine' as parameters by
 527         default. Assign parent to nested block.
 528
 529         * VariableDeclaration.cs: At 'Emit ()', now we take care if we are
 530         a global declaration or inside a function declaration.
 531
 532 2003-11-04 cesar lopez nataren <cesar@ciencias.unam.mx>
 533
 534         * FunctionObject.cs: Handle no parameters on functions.
 535
 536         * jscript-lexer-parser.g: Allow functions without parameters.
 537
 538 2003-11-03 cesar lopez nataren <cesar@ciencias.unam.mx>
 539
 540         * ASTList.cs, ArrayLiteral.cs, BitwiseBinary.cs, Blocks.cs,
 541         DebugBreak.cs, Enum.cs, Equality.cs, Eval.cs, ForIn.cs,
 542         FunctionDeclaration.cs, FunctionExpression.cs, Import.cs,
 543         InstanceOf.cs, Literal.cs, NumericBinary.cs, NumericUnary.cs,
 544         Package.cs, Plus.cs, PostOrPrefixOperator.cs, Print.cs,
 545         Relational.cs, ScriptBlock.cs, StrictEquality.cs, Throw.cs,
 546         Try.cs, TypeOf.cs, VariableDeclaration.cs, VariableStatement.cs,
 547         With.cs, expression.cs : Added
 548         'Resolve' method stub.
 549
 550         * CodeGenerator.cs: Added a ILGenerator field to EmitContext.
 551
 552         * FormalParameterList.cs: Added FormalParam class. Change Add
 553         method to receive the id and the type annotation from function's parameters.
 554
 555         * FunctionDeclaration.cs: Added code for initial function's
 556         definition code generation.
 557
 558         * FunctionObject.cs: Added MethodAttributes and type_annot
 559         fields. Added params_types function, which returns an array of
 560         types from each of the function's parameters.
 561
 562         * IdentificationTable.cs: Added ToString method.
 563
 564         * SemanticAnalizer.cs: Fixed the file name (maybe I should erase it
 565         and add it again with the correct name). Not based on the Visitor
 566         pattern anymore. Deleted all the VisitFOO methods. Added a
 567         IdentificationTable field. Added Run, Dump methods.
 568
 569         * Statement.cs: Deleted Statement class (it was being used for
 570         nothing). All classes that were having Statement as parent,
 571         changed their parent to be AST.
 572
 573         * SymbolTable.cs: Added Add method that receives the id and the
 574         declaration class. Retrieve changed to return an AST. Added
 575         ToString method. Added 'SymbolTable parent' field.
 576
 577         * VariableDeclaration.cs: Added InitValue property.
 578
 579         * ast.cs: Added some comments and abstract method 'Resolve'.
 580
 581         * jscript-lexer-parser.g: Added parsing support for formal
 582         parameters type annotations.
 583
 584 2003-10-30  cesar lopez nataren <cesar@ciencias.unam.mx>
 585
 586         * jscript-lexer-parser.g: fixed function call parsing! yeah! (give
 587         thanks to Hector!)
 588
 589 2003-10-28  cesar lopez nataren <cesar@ciencias.unam.mx>
 590
 591         * jscript-lexer-parser.g: allow empty program files. Added type
 592         annotations on var decl and function decl.
 593         * VariableDeclaration.cs: added return type annotation field.
 594         * FunctionExpression.cs: added return type parameter to constructor.
 595         * FunctionDeclaration.cs: added return type parameter to
 596         constructor. Added Emit method (just creates the static field at
 597         the global object, for now).
 598         * FunctionObject.cs: added return type to constructor. Changed
 599         names to readable ones ;-)
 600
 601         * ScriptStream.cs: added WriteLine.
 602
 603 2003-10-24  cesar lopez nataren <cesar@ciencias.unam.mx>
 604
 605         * ast.cs: Added 'virtual' Emit method (I might change it to be
 606         abstract, but I would have to added to all classes that derive
 607         from it. I'll do it later)
 608         * Block.cs: Added Emit method.
 609         * CodeGnerator.cs: Restructured it (not based on the Visitor pattern
 610         anymore) - still missing some methods, ut on the way. A nice
 611         hacking weekend coming. Added EmitContext class.
 612         * ScriptBlock.cs: Added Emit method.
 613         * VariableDeclaration.cs: Changed type field from string to
 614         Type. Added Emit method.
 615         * VariableStatement.cs: Added Emit method.
 616         * driver.cs: Added CodeGeneration phase (only simple var
 617         declarations support it. More coming soon).
 618
 619
 620 2003-10-22  cesar lopez nataren <cesar@ciencias.unam.mx>
 621
 622         * statement.cs: added Return class.
 623
 624         * Throw.cs: Added expression field, constructor and ToString.
 625
 626         * jscript-lexer-parser.g: Allow return_stm and throw_stm tree
 627         building.
 628
 629         * With.cs: added constructor and ToString. Back to the non-tmp
 630         namespace.
 631
 632         * jscript-parser-lexer.g: allow with_stm tree building.
 633
 634         * jscript-lexer-parser.g: changed the return type from if_stm from
 635         'If' to AST. Added tree for continue_stm. Allowed building of
 636         Break tree.
 637
 638         * statement.cs: switched to internal 'If' class. Added Continue
 639         class. Added Break class.
 640
 641         * jscript-lexer-parser.g: build tree for function decl or expr.
 642
 643         * FunctionDeclaration.cs: added internal constructor.
 644
 645         * FunctionExpression.cs: added internal constructor.
 646
 647         * FunctionObject.cs: added internal constructor and ToString method.
 648
 649         * jscript-lexer-parser.g: added building tree for if_stm.
 650         * Statement.cs: Added if class for 'if' statement.
 651
 652
 653 2003-10-21  cesar lopez nataren  <cesar@ciencias.unam.mx>
 654
 655         * VariableDeclaration.cs: added the initializer to ToString.
 656
 657         * jscript-lexer-parser.g: Allow "christmas trees" (aka expression
 658         trees) building.
 659
 660         * Block.cs, Equality.cs, Relational.cs: modified ToString
 661
 662         * Equality.cs, Relational.cs, StringLiteral.cs,
 663         VariableDeclaration.cs: Added constructor
 664
 665         * VariableStatement.cs, ScriptBlock.cs: changed from hungarian
 666         name convetion style to mono style.
 667
 668         * UnaryOp.cs: added operator and operand fields.
 669
 670         * VariableDeclaration.cs: chenged field name from assignExp to val.
 671
 672         *  BinaryOp.cs: Made "internal" the attributes, added the two
 673         operators holders.
 674
 675         * JScriptLexer.cs, JScriptParser.cs, JScriptParserokenTypes.cs,: updates from grammar changes.
 676
 677         * driver.cs: Dump the string representation of the parsed exps.
 678
 679         * Literal.cs:  added BooleanLiteral
 680
 681         * Relational.cs: added constructor, ToString,
 682
 683 2003-10-10  cesar lopez nataren <cesar@ciencias.unam.mx>
 684
 685         * README: added some info about hacking the grammar
 686
 687         * JSparser.cs: Updated the constructor to not receiving params.
 688
 689         * JScriptLexer.cs, JScriptParser.cs, JScriptParserTokenTypes.cs,
 690         JScriptParserTokenTypes.txt: update of antlr generated files from
 691         grammar changes.
 692
 693         * jscript-lexer-parser.g: Rewrote the EcmaScript grammar. Now we
 694         can parse a little bit more useful programs like:
 695
 696         function factorial (i)
 697         {
 698                 var k;
 699
 700                 if (i <= 0)
 701                         return 1;
 702                 else {
 703                         k = factorial (i - 1);
 704                         return i * k;
 705                 }
 706         }
 707
 708         var x;
 709         x = factorial (4);
 710         print (x);
 711
 712         As you can see, it's not the classic factorial function
 713         definition, I still have to make some tricks like storing the
 714         result from the recursive call and then multiply. But this new
 715         grammar it's easier to alter than the old one. Also we got support
 716         for for-in statements, for statements, global expressions, support
 717         for object accesors or better known as the "dot" operator. Two
 718         rules are on the eye: left_hand_size_expr and call_expr, in order
 719         to finish the parsing grammar and fix the bugs.
 720
 721
 722 2003-09-29    <cesar@ciencias.unam.mx>
 723
 724         * Added: VsaGlobalItem.cs, VsaReferenceItem.cs, VsaCodeItem.cs
 725
 726         * Added VsaItem.cs, implements IVsaItem.
 727
 728 2003-09-28    <cesar@ciencias.unam.mx>
 729
 730         * VsaItems.cs: Check that no name is repeated (this was docs fault
 731         :-)). This is the beauty of testing.
 732
 733         * Add VsaItems.cs, implements IVsaItems.
 734
 735 2003-09-22    <cesar@ciencias.unam.mx>
 736
 737         * DocumentContext.cs: changed constructor from internal to public,
 738         this a kind of hack ;), but we can build mjs.exe with that change.
 739
 740         * driver.cs, ast.cs, VsaEngine.cs, VariableStatement.cs,
 741         VariableDeclaration.cs, VBArrayConstructor.cs, StringObject.cs,
 742         StringLiteral.cs, StringConstructor.cs, Statement.cs,
 743         ScriptStream.cs, ScriptObject.cs, ScriptFunction.cs,
 744         ScriptBlock.cs, RegExpObject.cs, RegExpConstructor.cs, Print.cs,
 745         Package.cs, ObjectConstructor.cs, NumberObject.cs,
 746         NumberConstructor.cs, MathObject.cs, Literal.cs,
 747         LenientGlobalObject.cs, JSVariableField.cs, JSToken.cs,
 748         JSScanner.cs, JSParser.cs, JSObject.cs, JSLocalField.cs,
 749         JSFunctionAttributeEnum.cs, JSFunctionAttibute.cs, JSField.cs,
 750         JSBuiltIn.cs, IVsaScriptScope.cs, IRedirectOutput.cs,
 751         IActivationObject.cs, GlobalScope.cs, GlobalObject.cs,
 752         FunctionObject.cs, FunctionExpression.cs, FunctionDeclaration.cs,
 753         FunctionConstructor.cs, FormalParameterList.cs, ErrorObject.cs,
 754         ErrorConstructor.cs, EnumeratorObject.cs,
 755         EnumeratorConstructor.cs, Enum.cs, Empty.cs, DocumentContext.cs,
 756         DateObject.cs, DateConstructor.cs, Context.cs, Closure.cs,
 757         BooleanObject.cs, BooleanConstructor.cs, Block.cs, BinaryOp.cs,
 758         BaseVsaEngine.cs, ArrayObject.cs, ArrayConstructor.cs,
 759         ActiveXObjectConstructor.cs, ActivationObject.cs:
 760
 761         indentation comformance to mono style. Returned to
 762         Microsoft.JScript namespace name. Now we can build
 763         Microsoft.JScript.dll on Linux/Windows, and build mjs.exe on
 764         linux/Windows with our Microsoft.JScript.dll. To build mjs.exe:
 765         $(CSC) /r:Microsoft.JScript.dll  driver.cs. Also changed my mind
 766         about the namespace stuff, because I want people
 767         to contribute NUnit tests for Microsoft.JScript public API.
 768
 769         * jscript-lexer-parser.g: Now we are back to Microsoft.JScript namespace.
 770
 771 2003-09-21    <cesar@ciencias.unam.mx>
 772
 773         * jscript-lexer-parser.g: fixed typo and added SEMI_COLON to print_statement.
 774
 775 2003-09-20    <cesar@ciencias.unam.mx>
 776
 777         * jscript-lexer-parser.g: We are little bit closer to the spec on
 778         StringLiteral definition.
 779
 780         * jscript-lexer-parser.g: One line patch, the beauty of tests :-)
 781
 782         * jscript-lexer-parser.g: Build ast for FunctionExpression.
 783
 784         * JSObject.cs: we don't throw NotImplementedException anymore,
 785         this let us use FunctionExpression to build the ast.
 786
 787         * FunctionExpression.cs: Added a FunctionObject as field, a
 788         default constructor.
 789
 790         * FunctionObject.cs: Added default constructor.
 791
 792         * driver.cs: Deleted the Jsc class. We are not generating code
 793         now. I'm moving to provide something like mcs's EmitContext
 794         instead of the CodeGenerator class having the Reflection.Emit
 795         builders and ILGenerator. This driver is just for Lexical and
 796         Parsing phases testing.
 797
 798         * driver.cs: Now we are using the Microsoft.JScript public API
 799         functions to load the lexer and parser.
 800
 801         * ScriptBlock.cs,Block.cs: Added ToString function.
 802
 803 2003-09-20    <cesar@ciencias.unam.mx>
 804
 805         * ASTList.cs, ArrayLiteral.cs, BitwiseBinary.cs, Block.cs,
 806         DebugBreak.cs, Enum.cs, Equality.cs, Eval.cs, ForIn.cs,
 807         FunctionExpression.cs, Import.cs, In.cs, InstanceOf.cs,
 808         Literal.cs, NumericBinary.cs, NumericUnary.cs, Package.cs,
 809         Plus.cs, PostOrPrefixOperator.cs, Print.cs, Relational.cs,
 810         Statement.cs, StrictEquality.cs, StringLiteral.cs, Throw.cs,
 811         Try.cs, TypeOf.cs, VariableDeclaration.cs, With.cs, ast.cs,
 812         : erased Visit method and made some mono indentation style changes.
 813
 814         * CodeGenerator.cs: commented some function calls.
 815         * FunctionDeclaration.cs: moved function attributes to
 816         FunctionObject class, erased Visit method.
 817         * FunctionObject.cs: Here is where we store a function
 818         expression/declaration info, erased Visit method.
 819         * ScriptBlock.cs: Added a Block field, Block will contain the
 820         source elements.
 821         * jscript-lexer-parser.g: updated the grammar to build the program
 822         representation based on ScriptBlock.
 823
 824 2003-09-19    <cesar@ciencias.unam.mx>
 825
 826         * JSToken.cs: public API compliance.
 827
 828 2003-09-07 Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 829
 830         * Context.cs: Added constructor and Document field.
 831         * DocumentContext.cs: Added Name field.
 832         * JSParser.cs: Integration of antlr's generated parser with
 833         JSParser public API. ScriptBlock is now the principal data structure that
 834         represents a Jscript .Net program.
 835         * JSScanner.cs: Integration of antlr's generated lexer with
 836         JSScanner public API.
 837
 838 2003-07-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 839         * Added files StringLiteral.cs, CodeGenerator.cs and Print.cs.
 840
 841 2003-07-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 842
 843         * jscript-lexer-parser.g: Changed the namespace to
 844         Microsoft.JScript.Tmp.
 845
 846         * jscript-lexer-parser.g: Fixwd a typo at source_elements rule.
 847
 848         * jscript-lexer-parser.g: Got the name of a
 849         global_function_declaration and also its return type if
 850         available.
 851
 852         * jscript-lexer-parser.g: Added syntatic rule for print_statement.
 853         * jscript-lexer-parser.g: Initial construction of AST for
 854         enum_statement and package_statement.
 855
 856         * jscript-lexer-parser.g: Fixed the enum_statement to accept
 857         empty enum declarations.
 858
 859         * jscript-lexer-parser.g: Got the type of a
 860         veriable_declaration.
 861
 862         * jscript-lexer-parser.g: Initial construction of AST for
 863         primary_expression (in particular literal).
 864
 865
 866 2003-07-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 867
 868         * driver.cs: Modified the driver structure to be compatible
 869         with our new CodeGenrator and SemanticAnalizer. I
 870         removed the builders from Reflection.Emit to the
 871         CodeGenerator. Added an ASTList, SemanticAnalizer and
 872         CodeGenerator here. Adde methods Run, GenerateCode
 873
 874
 875 2003-07-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 876         * Statement.cs: Forgot to include it on last commit.
 877
 878 2003-07-27  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 879
 880         * Decided to change temporarly namespace name
 881         Microsoft.JScript to Microsoft.JScript.Tmp in order to be able
 882         to run the code generated by our CIL code generator (on  next
 883         commit will come). The problem is that we don't have the
 884         runtime support for our compiler, this involve VsaEngine class
 885         and its "friends", which I have not found a lot of
 886         doumentation for. If someone knows a docs place for them,
 887         don't hesitate to send me a email pointing to them.
 888
 889         * Changed from public to internal Visit function at some
 890         classes.
 891
 892         * Package.cs: Added Name and Members fields.
 893
 894         * SemanticAnalizer.cs: Added methods VisitPrint and
 895         VisitStringLiteral.
 896
 897         * VariableDeclaration.cs: Added Type field.
 898
 899         * Visitor.cs: Changed from public to internal. Added
 900         VisitPrint and VisitStringLiteral methods.
 901
 902         * VsaEngine.cs: Fixed namespace name from Microsoft.JScript to
 903         Microsoft.JScript.Vsa and then to Microsoft.JScript.Vsa.Tmp.
 904
 905
 906
 907
 908 2003-07-22  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 909
 910         * Added CmdLineError.cs and JSError.cs, last night I forgot to
 911         commit them.
 912
 913 2003-07-21 Cesar Lopez Nataren <cesar@ciencias.unam.mx>
 914         * Added files:
 915         ArrayPrototype.cs, ArrayWrapper.cs, BitwiseBinary.cs,
 916         BlockScope.cs, BooleanPrototype.cs, BreakOutOfFinally.cs,
 917         CmdLineException.cs, CmdLineOptionParser.cs,
 918         ContinueOutOfFinally.cs, Convert.cs, DatePrototype.cs,
 919         DocumentContext.cs, EnumeratorPrototype.cs, Equality.cs,
 920         ErrorPrototype.cs, EvalErrorObject.cs, Expando.cs,
 921         FieldAccessor.cs, FunctionPrototype.cs, FunctionWrapper.cs,
 922         Globals.cs, In.cs, InstanceOf.cs, JSConstructor.cs,
 923         JScriptException.cs, JSFieldInfo.cs, JSMethodInfo.cs, JSParser.cs,
 924         JSPrototypeObject.cs, JSScanner.cs, LateBinding.cs,
 925         LenientArrayPrototype.cs, LenientBooleanPrototype.cs,
 926         LenientDateConstructor.cs, LenientDatePrototype.cs,
 927         LenientEnumeratorPrototype.cs, LenientErrorPrototype.cs,
 928         LenientFunctionPrototype.cs, LenientMathObject.cs,
 929         LenientNumberPrototype.cs, LenientObjectPrototype.cs,
 930         LenientRegExpPrototype.cs, LenientStringConstructor.cs,
 931         LenientStringPrototype.cs, LenientVBArrayPrototype.cs,
 932         MemberInfoList.cs, MethodInvoker.cs, Missing.cs, Namespace.cs,
 933         NotRecommendedAttribute.cs, NumberPrototype.cs, NumericBinary.cs,
 934         NumericUnary.cs, ObjectPrototype.cs, Plus.cs,
 935         PostOrPrefixOperator.cs, RangeErrorObject.cs,
 936         ReferenceAttribute.cs, ReferenceErrorObject.cs, RegExpMatch.cs,
 937         RegExpPrototype.cs, Relational.cs, ResInfo.cs,
 938         ReturnOutOfFinally.cs, ScriptStream.cs, SimpleHashtable.cs,
 939         StackFrame.cs, StrictEquality.cs, StringPrototype.cs,
 940         SuperTypeMembersSorter.cs, SyntaxErrorObject.cs, TypedArray.cs,
 941         TypeErrorObject.cs, TypeOf.cs, TypeReflector.cs,
 942         URIErrorObject.cs, VBArrayObject.cs, VBArrayPrototype.cs,
 943         VersionableAttribute.cs
 944
 945         Now, I must fill in the blanks :-)
 946
 947
 948 2003-07-09  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 949         * jscript-lexer-parser.g: Added conditional_compilation_directive,
 950         which is the beginning of our support for conditional compilation
 951         statements and directives in our parser. Added
 952         cc_on_statement, and some lexer rules for getting the needed
 953         tokens (COND_SET, COND_DEBUG, COND_POSITION, COND_POSITION,
 954         COND_IF, COND_ELIF, COND_ELSE, COND_END and CC_ON.
 955
 956
 957 2003-07-03  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
 958
 959         * jscript-lexer-parser.g: Changed the format of copyright notice.
 960
 961         This changes will allow the support
 962         for the grammar added by MS to EcmaScript (aka its JScript .Net),
 963         I'm still missing some, but they are on the way.
 964
 965         * jscript-lexer-parser.g: Deleted function_declaration, and
 966         added global_function_declaration and type_function_declaration.
 967         I decided  to make the grammar as strict as the MS docs mark,
 968         but there's a difference between what their docs says and what
 969         their compiler does. For this case I decided to follow the
 970         docs. A program like:
 971                 private function F ()
 972                 {}
 973         according to the docs, would not be syntaticly correct. But the MS
 974         compiler, accepts the grammar construct and mark the error at
 975         semantic analysis phase. I followed the docs this time.
 976
 977         * jscript-lexer-parser.g: Added debbuger_statement.
 978         * jscript-lexer-parser.g: Added import_statement.
 979         * jscript-lexer-parser.g: Added package_statement and package_member(s).
 980         * jscript-lexer-parser.g: Added super_statement.
 981         * jscript-lexer-parser.g: Added const_statement.
 982         * jscript-lexer-parser.g: Added class_statement,
 983         interfaces_list and class_members.
 984
 985         * jscript-lexer-parser.g: Added interface_statement and
 986         interface_members.
 987
 988         * jscript-lexer-parser.g: Added enum_statement.
 989         * jscript-lexer-parser.g: Added static_statement. The rule for
 990         this syntatic construc is: static identifier { [body] }
 991         body does not get well specified in the docs. Must search wich
 992         are the possible values of it.
 993
 994         * jscript-lexer-parser.g: At variable_declaration, added
 995         support for explicit type declaration.
 996
 997         * jscript-lexer-parser.g: Added numeric_literal,
 998         DECIMAL_LITERAL and HEX_INTEGER_LITERAL.
 999
1000         * jscript-lexer-parser.g: Added modifiers, modifier, version_modifier.
1001
1002
1003 2003-06-09  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
1004
1005
1006         * Added the Visit method to classes: AST, ArrayLiteral, ASTList,
1007         Block, DebugBreak, Eval, ForIn, FunctionDeclaration,
1008         FunctionExpression, Import, Package, ScriptBlock, Throw, Try,
1009         With,
1010
1011         That method will be the driver that will allow classes
1012         that implement the Visitor interface do a walk through the AST's
1013         elements, in particular the Semantic Analizer and the Code
1014         Generator. Every class that inherits from AST will have a Visit
1015         method, that method will receive a Visitor and a object as
1016         parameters, the only thing that it'll do is letting the Visitor
1017         call the respective method VisitX, where X is the name of the
1018         currently visited class.
1019
1020         * ASTList.cs:Added constructor, Add, Visit, ToString  methods.
1021
1022         * FunctionDeclaration.cs: Added constructor, Visit and ToString
1023         methods.
1024
1025         * jscript-lexer-parser.g: Added a ASTList as a parameter to the
1026         program (the main entry of the parser). Also added as parameters:
1027                 - An AST to source_element.
1028                 - A Statement to statement.
1029                 - A VariableStatement to variable_statement.
1030                 - A VariableStatement to variable_declaration_list.
1031                 - A FormalParamerList by formal_parameter_list.
1032                 - A ASTList by function_body.
1033
1034         And now some rules return objects:
1035                 - A VariableDeclaration by variable_declaration.
1036                 - A Functiondeclaration by function_declaration.
1037
1038         * driver.cs: Added the construction of the AST of the EcmaScript
1039         program.
1040
1041         * Visitor.cs: Added this file. It's the visitor interface.
1042
1043         * VariableDeclaration.cs: Added this class, it's the AST
1044         representation of a variable declaration.
1045
1046         * Statement.cs: Added this file. It's the logical representation
1047         of a Statement.
1048
1049         * VariableStatement.cs: Added this class. It's the AST
1050         representation of a chain of variable declarations.
1051
1052         * FormalParameterList.cs: The function declaration needs to store
1053         its parameter, we will put them on this class.
1054
1055         * SemanticAnalizer.cs: Added this class. I'll use the Visitor pattern in order to
1056         implement the semantic analysis and code generation
1057         phases. SemanticAnalizer and CodeGenerator will implement the
1058         Visitor interface, they will walk a program's
1059         AST tree and do their respective work.
1060
1061         * IdentificationTable.cs: Added this class. The SymbolTable will be used
1062         by the SemanticAnalyzer in order to keep track of the variable
1063         declaration encountered, etc..
1064
1065         * SymbolTable.cs: A simple hashtable but for commodity i'll call
1066         it this way.
1067
1068
1069 2003-05-03  Cesar Lopez Nataren  <cesar@ciencias.unam.mx>
1070
1071         * jscript-lexer-parser.g:
1072         - Deleted the assignment_operator COMPOUND_ASSIGNMENT, and added
1073         MULTIPLICATION_ASSIGN, DIVISION_ASSIGN, REMAINDER_ASSIGN,
1074         ADDITION_ASSIGN, SUBSTRACTION_ASSIGN, SIGNED_LEFT_SHIFT_ASSIGN,
1075         SIGNED_RIGHT_SHIFT_ASSIGN, UNSIGNED_RIGHT_SHIFT_ASSIGN,
1076         BITWISE_AND_ASSIGN, BITWISE_OR_ASSIGN.
1077         - Changed INTERROGATION to CONDITIONAL.
1078         - Changed TRIANGLE to BITWISE_XOR.
1079         - Changed SLASH to DIVISION.
1080         - Changed PERCENT to REMAINDER.
1081         - Changed ADMIRATION to LOGICAL_NOT
1082         - Added BITWISE_NOT (~).
1083         - Added the INCREMENT and DECREMENT rules for
1084         left_hand_side_expression.
1085         - Increased lexer lookup from 2 to 4.
1086         - Redefined the definitions of: L_THAN, G_THAN, MINUS, TIMES,
1087         BITWISE_AND, BITWISE_OR,
1088         - Added operator: EQUALS, DOES_NOT_EQUALS, STRICT_EQUALS,
1089         REMAINDER, UNSIGNED_RIGHT_SHIFT.
1090         - Added the recursion rules for equality_expression.
1091         - Added the recursion rules for shift_expression.
1092         - Now we skip tabs.
1093         - The most important thing, added support for expressions like:
1094         sdf.[hgh], cool!
1095
1096 2003-04-20      Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>
1097
1098         * driver.cs:
1099         - Erased the Context class, it was used for the first
1100         test of the print_statement and Reflection.Emit. As I erased the
1101         Program, SourceElements, SourceElement from the ANTLR grammar (for
1102         the rework of the AST tied to the MS JScript public API), I erased
1103         some uses in here.
1104         - Erased the methods: EmitJScript0Type, EmitJScript0Cons,
1105         EmitGlobalCode, EmitJScript0, EmitJScriptMainType,
1106         EmitJScriptMainCons, EmitJScriptMainFunction, EmitJScriptMain,
1107         Emit.
1108
1109         * jscript-lexer-parser.g:
1110         - Erased the references to the classes Program, SourceElements,
1111         SourceElement, Statement, FunctionDeclaration and erased
1112         print_statement rule.
1113
1114         * JSCriptLexer.cs JScriptParser.cs and the other files generated
1115         by antlr, reflect changes from the grammar changes.
1116
1117 2003-04-19      Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>
1118         * Added stubs for the classes:
1119         ASTList.cs
1120         ActivationObject.cs
1121         ActiveXObjectConstructor.cs
1122         ArrayConstructor.cs
1123         ArrayLiteral.cs
1124         ArrayObject.cs
1125         AssemblyCustomAttributeList.cs
1126         BaseVsaEngine.cs
1127         BinaryOp.cs
1128         Binding.cs
1129         Block.cs
1130         BooleanConstructor.cs
1131         BooleanObject.cs
1132         Closure.cs
1133         Context.cs
1134         DateConstructor.cs
1135         DateObject.cs
1136         DebugBreak.cs
1137         Empty.cs
1138         EnumeratorConstructor.cs
1139         EnumeratorObject.cs
1140         ErrorConstructor.cs
1141         ErrorObject.cs
1142         Eval.cs
1143         ForIn.cs
1144         FunctionConstructor.cs
1145         FunctionDeclaration.cs
1146         FunctionExpression.cs
1147         FunctionObject.cs
1148         GlobalObject.cs
1149         GlobalScope.cs
1150         IActivationObject.cs
1151         IRedirectOutput.cs
1152         IVsaScriptScope.cs
1153         Import.cs
1154         JSBuiltIn.cs
1155         JSField.cs
1156         JSFunctionAttribute.cs
1157         JSFunctionAttributeEnum.cs
1158         JSLocalField.cs
1159         JSObject.cs
1160         JSToken.cs
1161         JSVariableField.cs
1162         LenientGlobalObject.cs
1163         MathObject.cs
1164         NumberConstructor.cs
1165         NumberObject.cs
1166         ObjectConstructor.cs
1167         Package.cs
1168         RegExpConstructor.cs
1169         RegExpObject.cs
1170         ScriptBlock.cs
1171         ScriptFunction.cs
1172         ScriptObject.cs
1173         StringConstructor.cs
1174         StringObject.cs
1175         Throw.cs
1176         Try.cs
1177         UnaryOp.cs
1178         VBArrayConstructor.cs
1179         VsaEngine.cs
1180         With.cs
1181
1182
1183 2003-04-11      Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>
1184
1185         * jscript-lexer-parser.g:
1186         - Added rules for: continue_statement, break_statement,
1187         return_statement, throw statement (all of them do not ensure that
1188         no LineSeparator appears between the keyword on the left and the
1189         identifier, expression or semicolon on the right, that must be fixed).
1190         - Added single line comments rule.
1191
1192 2003-04-08      Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>
1193
1194         * jscript-lexer-parser.g: Added syntatic rule for:
1195         - if_statement.
1196         - while and for-in subrules of iteration_statement.
1197         - Added array_literal - got tricky - I just could get the simplest rule going :)
1198         - Added elision.
1199
1200
1201 2003-04-08      Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>
1202
1203         * jscript-lexer-parser.g:
1204         - Syntatic rule for iteration_statement.
1205         - "do" subrule for it.
1206         - Added ((L_THAN | G_THAN | LE_THAN | GE_THAN | "instanceof" |
1207         "in") relational_expression | ) rule to relational_expression.
1208         -Added function_expression syntatic rule.
1209         - Added STRING_LITERAL to literal rules.
1210         - "Less/Greater or equal than" lexer rule.
1211
1212 2003-04-03      Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>
1213
1214         * jscript-lexer-parser.g: Added switch_statement rule, case_block, case_clauses, case_clause, default_clause, labelled_statement, try_statement, catch_exp, finally_exp.
1215
1216 2003-04-01    Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>
1217
1218         * jscript-lexer-parser.g: Added the grammar rules for: with_statement, object_literal, ( expression ), property_name_and_value_list, property_name and expression.
1219
1220
1221 2003-03-30    Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>
1222
1223         * Added a README file. Explains the dependencies and build process.
1224
1225 2003-03-30   Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>
1226
1227         * Added this ChangeLog file.
1228
1229         * ast.cs: Added this file. Contains the classes used for building
1230         the EcmaScript 's AST.
1231
1232         * JScript*: These are the files generated by antlr (the parser generator).
1233
1234         * TODOAttribute.cs: Changed the namespace in order to use it freely on Microsoft.JScript.
1235
1236         * driver.cs: Added this file. Contains the compiler entry point. And some Reflection.Emit methods,
1237         that will be moved to other file in the future.
1238
1239         * jscript-lexer-parser.g: The EcmaScript's antlr grammar.