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

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