duktape

Commit Graph

Author	SHA1	Message	Date
Sami Vaarala	3667b040a8	Reformat some source files with clang-format	3 years ago
Sami Vaarala	228525c2cd	Use 'ECMAScript' spelling in misc places	7 years ago
Sami Vaarala	461261dc31	Use 'ECMAScript' spelling in src-input	7 years ago
Sami Vaarala	4cf68c86f7	Fixes to RegExp vs. division lexing	7 years ago
Sami Vaarala	8f38a00bf0	Some -Wsign-conversion fixes * Change duk_bool_to to duk_small_uint_t from duk_small_int_t. This may cause some sign warnings in calling code. * Reject attempt to unpack an array-like value whose length is 2G or over; previously was not checked explicitly, and the length was cast to duk_idx_t with a sign change and the unpack would then later fail. Now it fails with a clean RangeError. * Add wrap check for Node.js Buffer.concat(). * API DUK_TYPE_xxx, DUK_TYPE_MASK_xxx, flag constants etc are now unsigned.	7 years ago
Sami Vaarala	e11753082f	Use DUK_COMPILE_xxx flags are internally Avoids unnecessary translation.	8 years ago
Sami Vaarala	cb1c8957d4	Add shebang comment parsing (on first line only)	8 years ago
Sami Vaarala	661f84a128	ES6 object literal id/method shorthand, dup keys * Allow duplicates keys, even in strict mode (ES6). * Add identifier reference shorthand: { Math }. * Add method definition shorthand: { foo(a,b) { return a + b; } }. * Eval/program code no longer has the CONSTRUCTABLE flag which was previously set. Calling an eval/program function as a constructor makes no sense and wasn't really supported previously. This change has no compliance impact because eval/program code doesn't exist as an unexecuted function in Ecmascript. * Eval/program code no longer has a NAMEBINDING flag which was previously set. The revised behavior is cleaner because eval/program code must not have a name binding. However, the flag is only consulted if NEWENV is also set, and NEWENV is never set for eval/program code. So this change has no other effect other than affecting dumped bytecode.	8 years ago
Sami Vaarala	39ecb8b7eb	Source fixes for #ifdef and #ifndef convention	8 years ago
Sami Vaarala	8e5da76ee0	Improve _Varmap and _Formals dropping, initial bc Previously _Varmap was kept if any slow path accesses were made. Improve this behavior so that, in the absence of eval() etc, safe slow path accesses are allowed while still dropping the _Varmap. A safe slow path access is one that doesn't match any of the statically declared variables in the function so that (again assuming no new variables are declared by e.g. eval()) the varmap won't be needed at runtime. Allow dropping of _Formals even in presence of eval() or a potentially dangerous slow path access if _Formals is empty and _Formals.length matches nargs so that .length computation works out even without _Formals. Also reduce initial bytecode allocation from 2kB to 256 bytes when DUK_USE_PREFER_SIZE is defined (in absence of a more specific define).	8 years ago
Sami Vaarala	96d301b3cb	Rename src/ to src-input/ to match dist With this change the directory naming in the main repo and dist is the same.	8 years ago
Sami Vaarala	75c57ad6f4	Rework executor to use a single level dispatch Change dispatch to use an 8-bit main opcode instead of a 6-bit one. This removes the need for "EXTRA" opcodes and a secondary switch clause in the executor dispatch loop. The new opcode layout uses four 8-bit fields: opcode, A, B, C. The previous reg/const concept which used 9-bit B and C fields, with the top bit reserved to denote reg vs const, is now implemented by using four consecutive opcode slots and moving the B and C reg/const flags into the opcode. For example: ADD_RR reg(A) <- reg(B) + reg(C) ADD_CR reg(A) <- const(B) + reg(C) ADD_RC reg(A) <- reg(B) + const(C) ADD_CC reg(A) <- const(B) + const(C) From a footprint standpoint this allows the executor to remain roughly the same size: four dispatched opcodes (each a function pointer in a compiled jump table) point to the same case clause handler, which does the reg/const decision based on an instruction bit test as before. However, when performance is more important than footprint, each reg/const case can be handled separately in the executor so that there's no longer a reg/const check when the opcode executes. Note that not all opcodes require a reg/const qualifier, so that opcode space is effectively increased even if reg/const opcodes consume multiple entries from the opcode table. Other minor changes: * Optimize behavior of several opcodes to e.g. avoid unnecessary support for shuffling/indirection when wider register arguments are now available.	8 years ago
Sami Vaarala	a804a2a630	Rename internal struct/define names Improve readability by doing the following renames: * duk_hcompiledfunction -> duk_hcompfunc * duk_hnativefunction -> duk_hnatfunc * duk_hbufferobject -> duk_hbufobj Corresponding renames for all caps defines.	9 years ago
Sami Vaarala	c96d5fc726	Tailcall -> tail call in src	9 years ago
Sami Vaarala	7ca3ed85fd	Program vs. global code clarifications in src	9 years ago
Sami Vaarala	08c0457d80	Replace DUK_USE_DEEP_C_STACK with explicit limits	9 years ago
Sami Vaarala	f9074b846d	Rework compiler to avoid duk_hbuffer spare	10 years ago
Sami Vaarala	c281a7e8a0	Rework pre/post inc/dec in compiler and executor Pre/post inc/dec are an important fast path for fastints. Reimplement these operations as atomic opcodes so that fast pathing is easier. Opcodes emitted for typical loop constructs are also reduced by the change. Several opcodes were moved to extraops to make space for the 12 pre/post inc/dec reg/var/prop variants, and the compiler was changed to support two-argument (dest, dest, src) extraop arithmetic for its ispec/ivalue. Example of bytecode change, in Duktape 1.1.0: function foo() { var x = 10; print(x++, x++, x--, x--, x--); print(x); } BC 0000: LDINT 0, 10, 256 ; 0x80028003 op=3 (LDINT) a=0 b=10 c=256 BC 0001: CSVAR 1, 256, 0 ; 0x00400052 op=18 (CSVAR) a=1 b=256 c=0 BC 0002: LDREG 3, 0, 0 ; 0x000000c0 op=0 (LDREG) a=3 b=0 c=0 BC 0003: TONUM 3, 3 ; 0x0180c2fe op=62 (EXTRA) a=11 b=3 c=3 BC 0004: INC 0, 3 ; 0x0180067e op=62 (EXTRA) a=25 b=0 c=3 BC 0005: LDREG 4, 0, 0 ; 0x00000100 op=0 (LDREG) a=4 b=0 c=0 BC 0006: TONUM 4, 4 ; 0x020102fe op=62 (EXTRA) a=11 b=4 c=4 BC 0007: INC 0, 4 ; 0x0200067e op=62 (EXTRA) a=25 b=0 c=4 BC 0008: LDREG 5, 0, 0 ; 0x00000140 op=0 (LDREG) a=5 b=0 c=0 BC 0009: TONUM 5, 5 ; 0x028142fe op=62 (EXTRA) a=11 b=5 c=5 BC 0010: DEC 0, 5 ; 0x028006be op=62 (EXTRA) a=26 b=0 c=5 BC 0011: LDREG 6, 0, 0 ; 0x00000180 op=0 (LDREG) a=6 b=0 c=0 BC 0012: TONUM 6, 6 ; 0x030182fe op=62 (EXTRA) a=11 b=6 c=6 BC 0013: DEC 0, 6 ; 0x030006be op=62 (EXTRA) a=26 b=0 c=6 BC 0014: LDREG 7, 0, 0 ; 0x000001c0 op=0 (LDREG) a=7 b=0 c=0 BC 0015: TONUM 7, 7 ; 0x0381c2fe op=62 (EXTRA) a=11 b=7 c=7 BC 0016: DEC 0, 7 ; 0x038006be op=62 (EXTRA) a=26 b=0 c=7 BC 0017: CALL 0, 1, 5 ; 0x02804034 op=52 (CALL) a=0 b=1 c=5 BC 0018: CSVAR 1, 256, 0 ; 0x00400052 op=18 (CSVAR) a=1 b=256 c=0 BC 0019: LDREG 3, 0, 0 ; 0x000000c0 op=0 (LDREG) a=3 b=0 c=0 BC 0020: CALL 0, 1, 1 ; 0x00804034 op=52 (CALL) a=0 b=1 c=1 BC 0021: RETURN 1, 0, 0 ; 0x00000073 op=51 (RETURN) a=1 b=0 c=0 After this commit: function foo() { var x = 10; print(x++, x++, x--, x--, x--); print(x); } BC 0000: LDINT 0, 10, 256 ; 0x80028003 op=3 (LDINT) a=0 b=10 c=256 BC 0001: CSVAR 1, 256, 0 ; 0x00400052 op=18 (CSVAR) a=1 b=256 c=0 BC 0002: POSTINC 3, 0, 0 ; 0x000000f9 op=57 (POSTINC) a=3 b=0 c=0 BC 0003: POSTINC 4, 0, 0 ; 0x00000139 op=57 (POSTINC) a=4 b=0 c=0 BC 0004: POSTDEC 5, 0, 0 ; 0x0000017c op=60 (POSTDEC) a=5 b=0 c=0 BC 0005: POSTDEC 6, 0, 0 ; 0x000001bc op=60 (POSTDEC) a=6 b=0 c=0 BC 0006: POSTDEC 7, 0, 0 ; 0x000001fc op=60 (POSTDEC) a=7 b=0 c=0 BC 0007: CALL 0, 1, 5 ; 0x02804030 op=48 (CALL) a=0 b=1 c=5 BC 0008: CSVAR 1, 256, 0 ; 0x00400052 op=18 (CSVAR) a=1 b=256 c=0 BC 0009: LDREG 3, 0, 0 ; 0x000000c0 op=0 (LDREG) a=3 b=0 c=0 BC 0010: CALL 0, 1, 1 ; 0x00804030 op=48 (CALL) a=0 b=1 c=1 BC 0011: RETURN 1, 0, 0 ; 0x0000006f op=47 (RETURN) a=1 b=0 c=0 For an empty for-loop, in Duktape 1.1.0: function foo() { for (var i = 0; i < 1000; i++) {} } BC 0000: LABEL 0, 0, 0 ; 0x00000036 op=54 (LABEL) a=0 b=0 c=0 BC 0001: JUMP 11 (to pc+12) ; 0x800002f2 op=50 (JUMP) a=11 b=0 c=256 BC 0002: JUMP 5 (to pc+6) ; 0x80000172 op=50 (JUMP) a=5 b=0 c=256 BC 0003: LDINT 0, 0, 256 ; 0x80000003 op=3 (LDINT) a=0 b=0 c=256 BC 0004: LT 1, 0, 256 ; 0x8000006d op=45 (LT) a=1 b=0 c=256 BC 0005: IF 0, 1, 0 ; 0x0000402f op=47 (IF) a=0 b=1 c=0 BC 0006: JUMP 1 (to pc+2) ; 0x80000072 op=50 (JUMP) a=1 b=0 c=256 BC 0007: JUMP 5 (to pc+6) ; 0x80000172 op=50 (JUMP) a=5 b=0 c=256 BC 0008: LDREG 1, 0, 0 ; 0x00000040 op=0 (LDREG) a=1 b=0 c=0 BC 0009: TONUM 1, 1 ; 0x008042fe op=62 (EXTRA) a=11 b=1 c=1 BC 0010: INC 0, 1 ; 0x0080067e op=62 (EXTRA) a=25 b=0 c=1 BC 0011: JUMP -8 (to pc-7) ; 0x7ffffe32 op=50 (JUMP) a=248 b=511 c=255 BC 0012: JUMP -5 (to pc-4) ; 0x7ffffef2 op=50 (JUMP) a=251 b=511 c=255 BC 0013: ENDLABEL 0, 0, 0 ; 0x00000037 op=55 (ENDLABEL) a=0 b=0 c=0 BC 0014: RETURN 1, 0, 0 ; 0x00000073 op=51 (RETURN) a=1 b=0 c=0 After this commit: function foo() { for (var i = 0; i < 1000; i++) {} } BC 0000: LABEL 0, 0 ; 0x0000083f op=63 (EXTRA) a=32 b=0 c=0 BC 0001: JUMP 9 (to pc+10) ; 0x8000026e op=46 (JUMP) a=9 b=0 c=256 BC 0002: JUMP 5 (to pc+6) ; 0x8000016e op=46 (JUMP) a=5 b=0 c=256 BC 0003: LDINT 0, 0, 256 ; 0x80000003 op=3 (LDINT) a=0 b=0 c=256 BC 0004: LT 1, 0, 256 ; 0x8000006b op=43 (LT) a=1 b=0 c=256 BC 0005: IF 0, 1, 0 ; 0x0000402d op=45 (IF) a=0 b=1 c=0 BC 0006: JUMP 1 (to pc+2) ; 0x8000006e op=46 (JUMP) a=1 b=0 c=256 BC 0007: JUMP 3 (to pc+4) ; 0x800000ee op=46 (JUMP) a=3 b=0 c=256 BC 0008: POSTINC 1, 0, 0 ; 0x00000079 op=57 (POSTINC) a=1 b=0 c=0 BC 0009: JUMP -6 (to pc-5) ; 0x7ffffeae op=46 (JUMP) a=250 b=511 c=255 BC 0010: JUMP -3 (to pc-2) ; 0x7fffff6e op=46 (JUMP) a=253 b=511 c=255 BC 0011: ENDLABEL 0, 0 ; 0x0000087f op=63 (EXTRA) a=33 b=0 c=0 BC 0012: RETURN 1, 0, 0 ; 0x0000006f op=47 (RETURN) a=1 b=0 c=0	10 years ago
Sami Vaarala	869ac61514	Fix NEXTENUM jump slot shuffle issue	10 years ago
Sami Vaarala	5c22523ebf	Add debugger support to core engine	10 years ago
Sami Vaarala	95057396af	Source comment fixes for int key capitalization	10 years ago
Sami Vaarala	1fa66cd25a	Symbol visibility changes for code and headers	10 years ago
Sami Vaarala	ddd0619f78	Intermediate commit of compiler typing cleanup	10 years ago
Sami Vaarala	2f80307641	Miscellaneous typing work here and there	11 years ago
Sami Vaarala	d6e7b66ea4	Change duk_js_compile() to use an explicit buffer This change is needed to implement DUK_COMPILE_FUNCTION more efficiently, and is also needed when compiling directly from a user buffer.	11 years ago
Sami Vaarala	8c292ccf58	Pack compilation arguments into a stack struct This is in preparation to adding more duk_compile_raw() arguments.	11 years ago
Sami Vaarala	c382af2209	add a DUK_HOBJECT_FLAG_NOTAIL flag and 'use duk notail' directive	11 years ago
Sami Vaarala	80fd4fe13e	fixme cleanups	11 years ago
Sami Vaarala	fbc6a2a854	make compiler line number tracking conditionl to DUK_USE_PC2LINE; now always enabled, but can be disabled for memory optimization later	11 years ago
Sami Vaarala	5155f8cdf2	relocate all compiler function struct pointers to beginning of struct to avoid mixing pointers and integers, saves >30 bytes on 64-bit	11 years ago
Sami Vaarala	31c5477ecf	fix compiler O(depth^2) inner function parsing by recording a lexer point on first inner function compilation, and then skipping the inner function on the second pass	11 years ago
Sami Vaarala	c21a20b766	rename a few defines with DUK_ prefix, also note that they're now unused	11 years ago
Sami Vaarala	408670ce5e	add a token parse limit as a backstop to regexp and ecmascript compilation: this helps break out of very deep inner function cases	11 years ago
Sami Vaarala	dd0803c186	c typing fixes for pc2line	11 years ago
Sami Vaarala	9fa1ec592d	clean up #define, #undef, #ifdef etc to have a single space after the directive	11 years ago
Sami Vaarala	761ef90976	first step to reducing temp/const limits through automatic shuffling; compiler fixes: change INTERNAL errors to RANGE errors when limits reached, normalize constant folding NaNs, recursion value stack check for expressions, do-while continue label target fix, larger limit for compiler recursion with deep stack mode	11 years ago
Sami Vaarala	884045b1d1	typedef C99 'wrapper' types like duk_uint32_t; bulk replacement of duk_u32 with duk_uint32_t, and other type usage replacements	11 years ago
Sami Vaarala	fad076afa6	rename growable buffers 'dynamic' buffers (more common and more accurate); other api related changes and placeholders	11 years ago
Sami Vaarala	4862b7aa49	fix include guard names, don't use leading underscores as they are reserved	12 years ago
Sami Vaarala	781d58ca9e	trivial struct member name changes to javascript compiler (for uniformity)	12 years ago
Sami Vaarala	95b904a44a	compiler recursion limits	12 years ago
Sami Vaarala	9c8fbd509d	add a 'parse function expression' mode to duk_js_compile(), this is needed for the Function constructor placeholder (but may be removed later)	12 years ago
Sami Vaarala	202f8b6f01	rename duk_js_compile_program -> duk_js_compile, inherit eval strictness from caller	12 years ago
Sami Vaarala	ef02914f4c	remove compiler point structure; rewinding in the middle of a function is currently not needed	12 years ago
Sami Vaarala	2464dc1a53	compiler internal header	12 years ago

11 Commits (8b1999473b206b90f799cf153c1032ff48b22f46)