| Commit message (Collapse) | Author | Files | Lines |
|---|
|
New function 'resetCI' resets the CallInfo list of a thread, ensuring
a proper state when creating a new thread, closing a thread, or
closing a state, so that we can run code after that. (When closing a
thread, we need to run its __close metamethods; when closing a
state, we need to run its __close metamethods and its finalizers.)
|
|
|
|
The string "_ENV" is erroneously identified as a variable _ENV,
so that results from a field is classified as a global.
|
|
|
|
If a metatable is a weak table, its __newindex field could be collected
by an emergency collection while being used in 'luaV_finishset'. (This
bug has similarities with bug 5.3.2-1, fixed in commit a272fa66.)
|
|
This function can be called unprotected, so it should not raise any
kind of errors. (It could raise a memory-allocation error when creating
a message).
|
|
|
|
All test files refer to the main copyright notice in 'lua.h'.
|
|
Tests for memory-allocation errors moved from 'api.lua' to this new
file, as 'api.lua' was already too big. (Besides, these tests have
nothing to do with the API.)
|
|
After a weak table is traversed in the atomic phase, if it does not
have white values ('hasclears') it does not need to be retraversed
again. (Comments were correct, but code did not agree with them.)
|
|
The structure 'AbsLineInfo' is hard-dumped into binary chunks, and
it comprises two 'int' fields.
|
|
Added macro LUA_FAILISFALSE to make easier to change the fail value
from nil to false.
|
|
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.
|
|
|
