changelog

一个类似windows

1999-01-11  Markku Rossi  <[e-mail]>

	* lexer.js (JSC$lexer_read_string): Optimized the stream reading
	by using the new String.append(INTEGER) method.

1998-10-26  Markku Rossi  <[e-mail]>

	* parser.js (JSC$parser_parse_stmt): Implemented function
	declarations as statements.

	* gram.js (JSC$stmt_function_declaration): New statement for
	nested function declarations.

	* defs.js: New statement type JSC$STMT_FUNCTION_DECLARATION.

	* gram.js (JSC$expr_call_asm): Added support for function
	pointers.

	* asm.js: Added support for function pointers.
	Added new operands `jsr_w' and `load_global_w' which operate with
	the with chains.

1998-10-12  Markku Rossi  <[e-mail]>

	* gram.js (JSC$expr_additive_constant_folding): Implemented simple
	constant folding optimization.

	* parser.js (JSC$parser_parse_assignment_expr): Implemented
	constant folding optimization.

	* entry.js (JSC$compile_stream): Added a try-finally block over
	the stream compilation.  This assures that the stream is always
	closed, even if the compilation fails.

1998-10-01  Markku Rossi  <[e-mail]>

	* parser.js (JSC$parser_parse_function_declaration): Fixed the
	parameter list parsing.  Now we do require that the parameters are
	separated by a ','.

1998-09-17  Markku Rossi  <[e-mail]>

	* gram.js (JSC$stmt_try_asm): If none of the catch blocks matches
	the exception, we must throw it the upper level.

1998-09-10  Markku Rossi  <[e-mail]>

	* asm.js (JSC$ASM_const_i_print): Cleaned up the output.

	* gram.js (JSC$expr_object_initializer): New expression object for
	object literals.

	* parser.js (JSC$parser_parse_primary_expr): Implemented object
	literals.

	* asm.js (JSC$ASM_const_i): New operand to push a Int32 integer to
	the stack.  Effectively this operand removes all integer constants
	from the constants section.  They can be expressed in the same
	space that was used to present the integer index.

	* gram.js (JSC$expr_integer_asm): Changed to use the new `const_i'
	operand.

1998-09-07  Markku Rossi  <[e-mail]>

	* parser.js (JSC$parser_parse_function_declaration): Implemented
	the `arguments' property of function instance.

	* gram.js (JSC$function_declaration_asm): Added support for the
	`arguments' property of function instance.  If the property is
	used in the function body, we add code to the beginning of the
	function to create the arguments array.
	(JSC$stmt_for_count_locals): Fixed the counting of the local
	variables.
	(JSC$stmt_for_in_count_locals): Fixed the counting of local
	variables.

	* entry.js: New flag JSC$FLAG_WARN_DEPRECATED to generate error
	messages about uses of deprecated features.

	* asm.js (JSC$ASM_load_nth_arg): New byte-code operand to load the
	nth argument of function, where the index is at the top of the
	stack.  This is needed in the implemenation of the `arguments'
	property of function instances.
	Re-organized byte-code operand numbers.  All old byte-code files
	must be re-compiled.

1998-09-04  Markku Rossi  <[e-mail]>

	* asm.js: Re-organized byte-code operand numbers.  All old
	byte-code files must be re-compiled.

	* parser.js (JSC$parser_parse_primary_expr): Changed the way how
	the regular expression constants are handled.  We must decide the
	point when we accept a regexp constant.  The lexer can't do it
	because the div operand and regexp constants can't be
	distinguished based on lexical analysis.
	(JSC$parser_parse_equality_expr): Implemented strict equals and
	does-not-equal operators.  The change affects lexer.js, parser.js,
	gram.js, asm.js, and defs.js.

	* defs.js: Removed constant JSC$tREGEXP.

	* lexer.js (JSC$lexer): Changed the way how the regular expression
	constants are handled.  We no longer return them as a token.  We
	return the starting '/' character as-is and the parser recognizes
	the cases when it can start a regexp constant.  In those cases,
	the parser will call JSC$lexer_read_regexp_constant() that reads
	the constant and compiles it to the RegExp built-in object.

1998-09-03  Markku Rossi  <[e-mail]>

	* lexer.js (JSC$lexer): Changed the way how errors are returned
	form the malformed regular expression constants.  This is needed
	because the syntax of the try-statement was changed.

	* gram.js (JSC$stmt_for): Added support for local variable
	declarations.
	(JSC$stmt_for_in): Added support for local variable declarations.

	* parser.js (JSC$parser_parse_iteration_stmt): Added support for
	local variable declarations in the head of the for statement.

	* entry.js (JSC$compile_stream): Clear the syntax tree after the
	assembler has been generated.  This saves some memory.

	* Replaced all JC$Lists in the compiler sources with built-in
	Array objects.
	Removed the list.js file from the project.

	* asm.js (JSC$asm_print): Cleaned up the annotated assembler
	output.

	* gram.js (JSC$ContBreak): Added support for labeled statements.
	The constructor and all calculation methods were fixed to support
	the labels.
	(JSC$ContBreak$is_unique_label): New method is_unique_label() to
	check if the given label is unique in the current continue-break
	stack.
	(JSC$stmt_continue): Added support for labeled statements.
	(JSC$stmt_break): Added support for labeled statements.
	(JSC$stmt_labeled_stmt): New statement for the labeled
	statements.

	* parser.js (JSC$parser_parse_stmt): Implemented labeled
	statements.
	(JSC$parser_parse_stmt): Added optional label to break and
	continue statements.

1998-09-02  Markku Rossi  <[e-mail]>

	* parser.js (JSC$parser_parse_try): New function to parse try
	statements.

	* gram.js (JSC$stmt_break_asm): Cleaned up the try and with
	nesting calculation.  Now we use the methods, instead of directly
	investigating the top frame in the cont_break stack.
	(JSC$stmt_try): Re-implemented the try statement, including its
	asm() and count_locals() methods.  Now the implementation is
	ECMAScript compatible.

1998-09-01  Markku Rossi  <[e-mail]>

	* asm.js (JSC$asm_optimize): Optimize cases `const_true, iftrue'
	and `const_false, iffalse' to jumps.
	(JSC$asm_optimize): Cleaned up the peephole optimizations.
	Implemented a new byte-code side optimization that removes
	unnecessary jumps to the immediately following labels.

	* gram.js (JSC$stmt_switch): New statement object for the switch
	statements.
	(JSC$stmt_continue_asm): Fixed to work inside a switch statement.
	(JSC$ContBreak): Cleaned up the continue-break handling in loops.
	Now it should work inside switch statements, including nested
	switch statements.

	* parser.js (JSC$parser_parse_switch): New function to parse
	switch statements.

1998-08-25  Markku Rossi  <[e-mail]>

	* parser.js (JSC$parser_parse_stmt): Added strict_ecma warning
	about line terminators between `throw' and the expression.

	* gram.js (JSC$stmt_do_while): New statement object for do...while
	statements.

	* parser.js (JSC$parser_parse_variable_stmt): Fixed the variable
	declaration parsing.  Now it should co-operate correctly with the
	automatic semicolon insertion.
	(JSC$parser_parse_iteration_stmt): Implemented do...while
	statements.

	* lexer.js (JSC$lexer_read_regexp): New function to read regular
	expression literals.  The backslash escapes within them are so
	different from string literals that they need an own function to
	handle them.
	(JSC$lexer_read_backslash_escape): New function to handle
	backslash escapes in strings, character constants, and partly in
	regular expression literals.
	(JSC$lexer_read_backslash_escape): Added support for \xHH and
	\uHHHH escapes.
	Now the lexer should be ECMAScript 2.0 (draft) compatible.

1998-08-19  Markku Rossi  <[e-mail]>

	* parser.js: New functions JSC$warning() and JSC$message() to
	report warnings and messages from the compiler.  Changed all
	outputs in the sources to use these functions.  There shouldn't be
	any System.error() calls left.

1998-08-17  Markku Rossi  <[e-mail]>

	* gram.js (JSC$expr_array_initializer): New expression for array
	initializers.

	* parser.js (JSC$parser_parse_primary_expr): Implemented array
	initializers.

	* defs.js: New expression type JSC$EXPR_ARRAY_INITIALIZER.

	* list.js: Cleaned up the code.

1998-08-14  Markku Rossi  <[e-mail]>

	* asm.js: Changed JSC$CONST_REGEXP's value to 11.  It is returned
	as a JS_BUILTIN.

	* parser.js: Added support for the regular expression constants.

	* gram.js (JSC$expr_regexp): New grammar component for the regular
	expression constants.

	* asm.js: Added support for the regular expression constants.

	* defs.js: New type constant JSC$JS_BUILTIN.

1998-08-13  Markku Rossi  <[e-mail]>

	* defs.js: New token constant JSC$tREGEXP.

	* parser.js (JSC$parser_parse): Fixed to report the number of
	missing semicolons only if there are any.

	* entry.js: New flag JSC$FLAG_WARN_STRICT_ECMA to generate error
	messages about features that are supported but which are agains
	the ECMAScript standard.

	* lexer.js (JSC$lexer): Fixed all error messages to be in the
	`FILENAME:LINENUM: MESSAGE' format.
	(JSC$lexer_read_string): Added warning about line terminators in
	string and regular expression constants.
	Fixed all error messages.
	Optimized the data creation to use the String.append() method.
	(JSC$lexer): Implemented regular expression literals.

1998-08-12  Markku Rossi  <[e-mail]>

	* parser.js: Changed messages about automatic semicolon inserting
	to warnings.

	* entry.js: New flag JSC$FLAG_WARN_MISSING_SEMICOLON.

1998-08-11  Markku Rossi  <[e-mail]>

	* parser.js (JSC$parser_parse_source_element): Tag the global
	level variable declarations so that we can distinguish them at the
	assembler creation time.
	Implemented automatic semicolon inserting.
	(JSC$parser_parse): Added statistics about the missing
	semicolons.

	* gram.js (JSC$stmt_variable_asm): Changed the variables, declared
	at the global level, to be global variables.
	Fixed some panic() calls to report the error with the `error()'
	global method.

1998-08-05  Markku Rossi  <[e-mail]>

	* entry.js: New flag JSC$FLAG_GENERATE_EXECUTABLE_BC_FILES.
	(JSC$compile_stream): Added support for
	JSC$FLAG_GENERATE_EXECUTABLE_BC_FILES.

1998-06-08  Markku Rossi  <[e-mail]>

	* parser.js (JSC$parser_parse_arguments): Fixed a bug that allowed
	us to call functions so that the individual arguements were not
	separated by a comma #','.

	* asm.js: Removed operands `assert_args', `assert_min_args', and
	`assert_max_args'.
	Added operands `min_args', `add_1_i', and `add_2_i'.

	* gram.js (JSC$function_declaration_asm): Removed conditional
	function argument count checks.  The check were replaced with
	`min_args' operand that arranges things so that the minimum amount
	of arguments is present.

	* entry.js (JSC$compile_stream): Removed flag
	JSC$FLAG_ARGUMENT_COUNT_CHECKS.  JavaScript allows functions to be
	called with any number of arguments.  Therefore, we can't assert
	the minimum amount of arguments for function.

	* gram.js (JSC$expr_new_asm): Added support for `new Foo'
	expressions.

	* asm.js: Changed constant types to new values.

1998-06-05  Markku Rossi  <[e-mail]>

	* asm.js (JSC$ASM_mod): Implemented operand mod.
	Cleaned up byte-code operand opcodes.

1998-06-03  Markku Rossi  <[e-mail]>

	* asm.js: Cleaned up the byte-code creation.  Now we have common
	byte-code creation methods for different operand values: int8,
	int16, etc.  This cleanup removes redundancy and saves nine
	functions.
	Cleaned up the compiler progress messages.

1998-06-02  Markku Rossi  <[e-mail]>

	* lexer.js (JSC$lexer): Implemented 'data' -strings.  The
	character constants are now presented as #'a'.

1998-05-15  Markku Rossi  <[e-mail]>