| Commit message (Collapse) | Author | Files | Lines |
|---|
|
Lua will change a nil as error object to a string message, so that it
never reports an error with nil as the error object.
|
|
Instead of receiving nil as a second argument, __close metamethods are
called with just one argument when there are no errors.
|
|
Lua can easily overflow an unsigned short counting nested calls.
(The limit to this value is the maximum stack size, LUAI_MAXSTACK,
which is currently 1e6.)
|
|
Comments, small changes in the manual, an extra test for errors in
error handling, small changes in tests.
|
|
Array sizes are always int and are dumped as int, so there is no reason
to read them back as unsigned.
|
|
By default, the code assumes it is safe to use a dealocated pointer
as long as the code does not access it.
|
|
They were already allocated as a single block, so there is no need
for the global_State to point to its main thread.
|
|
|
|
- Added support for negative stack indices in the "C interpreter"
- Improved format when printing values
|
|
Since commit f407b3c4a, it was being used for two distinct (and
incompatible) meanings:
A: Function has TBC variables (now bit CIST_TBC)
B: Interpreter is closing TBC variables (original bit CIST_CLSRET)
B implies A, but A does not imply B.
|
|
'lua_numbertostrbuff' -> 'lua_numbertocstring'
'lua_pushextlstring' -> 'lua_pushexternalstring'
|
|
Tables don't accept sizes larger than int.
|
|
The "faster way" to check whether a value is not 'nilvalue' is not
faster. (Both forms entail one memory access.)
|
|
'luaD_throw' may call 'luaE_resetthread', which returns an error code
but clears 'L->status'; so, 'luaD_throw' should set that status again.
|
|
New year (2024->2025), typos in comments
|
|
Plus some other details. (Option '-Wuninitialized' was removed from
the makefile because it is already enabled by -Wall.)
|
|
Syntax errors are easier to handle than semantic errors.
|
|
Added comments so that all braces pair correctly. (The parser has
several instances of unmatched braces as characters ('{' or '}'), which
hinders matching regular braces in the code.)
|
|
Using gcc's option '-Og' (instead of '-O0') for testing/debugging.
|
|
Plus details
|
|
The compilation of a goto or a label just create an entry and generate
boilerplate code for the gotos. As we don't know yet whether it needs a
CLOSE, we code a jump followed by a CLOSE, which is then dead code.
When a block ends (and then we know for sure whether there are variables
that need to be closed), we check the goto's against the labels of that
block. When closing a goto against a label, if it needs a CLOSE, the
compiler swaps the order of the jump and the CLOSE, making the CLOSE
active.
|
|
Small improvement in line-tracing for internal debugging.
|
|
When compiling with option HARDMEMTESTS, every creation of a new key
in a table forces an emergency GC.
|
|
|
|
Do not optimize only for table updates (key already present).
Creation of new short keys in new tables can be quite common in
programs that create lots of small tables, for instance with
constructors like {x=e1,y=e2}.
|
|
Ensure that float constants never use integer keys, so that only
floats can collide in 'k2proto'.
|
|
Protect stack top before possible stack reallocation. (In the current
implementation, a stack reallocation cannot call an emergency
collection, so there is no bug, but it is safer not to depend on that.)
|
|
Moreover, each function being parsed has its own table.
The code is cleaner when each table is used for one specific purpose:
The scanner uses its table to anchor and unify strings, mapping strings
to themselves; the parser uses it to reuse constants in the code,
mapping constants to their indices in the constant table. A different
table for each task avoids false collisions.
|
|
|
|
The extra check in checknoTM (versus only checking whether there is a
metatable) is cheap, and it is not that uncommon for a table to have a
metatable without a __newindex metafield.
|
|
Optimize this opcode for the common case. For long names or method
calls after too many constants, operation can be coded as a move
followed by 'gettable'.
|
|
When reinserting elements into a table during a rehash, the code does
not need to invoke all the complexity of a full 'luaH_set':
- The table has space for all keys.
- The key cannot exist in the new hash.
- The keys are valid (not NaN nor nil).
- The keys are normalized (1.0 -> 1).
- The values cannot be nil.
- No barrier needed (the table already pointed to the key and value).
|
|
Function broke in two and some checks moved to the caller. (We may
want to call it without the checks.)
|
|
The array at the end of a Lua closure has pointers to upvalues, not
to tagged values. This bug cannot cause any issue: The ISO C standard
requires that all pointers to structures have the same representation,
so sizeof(TValue*) must be equal to sizeof(UpVal*).
|
|
|
|
Added two warnings to the makefile.
|
|
Instead of using 'alimit' for keeping the size of the array and at
the same time being a hint for '#t', a table now keeps these two
values separate. The Table structure has a field 'asize' with the
size of the array, while the length hint is kept in the array itself.
That way, tables with no array part waste no space with that field.
Moreover, the space for the hint may have zero cost for small arrays,
if the array of tags plus the hint still fits in a single word.
|
|
|
|
The call to 'f' is done by the macro, to give it more flexibility.
|
|
'debug.getinfo' can return number of extra arguments added to a call by
a chain of __call metavalues. That information is being used to improve
error messages about errors in these extra arguments.
|
|
This counter will allow (in a later commit) error messages to correct
argument numbers in functions called through __call metamethods.
|
|
|
|
Sums of size_t may not fit in a size_t.
|
|
It allows code that is only used by assertions but that are not
assertions (e.g., declaration of a variable used in a later assertion).
|
|
|
|
That allows 'getfreepos' to treat it like a regular hash part that has
a deleted entry.
|
|
Without this extra space, sequences of insertions/deletions (and
some other uses) can have unpexpected low performances. See the
added tests for an example, and *Mathematical Models to Analyze Lua
Hybrid Tables and Why They Need a Fix* (MartÃnez, Nicaud, Rotondo;
arXiv:2208.13602v2) for detais.
|
|
Array part needs 1/3 of its elements filled, instead of 1/2.
Array entries use ~1/3 the memory of hash entries, so this new rule
still ensures that array parts do not use more memory than keeping
the values in the hash, while allowing more uses of the array part,
which is more efficient than the hash.
|
|
|
|
If there are no integer keys outside the array part, there is no
reason to resize it, saving the time to count its elements. Moreover,
assignments to non-integer keys will not collapse a table created with
'table.create'.
|
