| Age | Commit message (Collapse) | Author |
|---|
|
|
|
Introduce `ScriptCommand` class that parses a command line into a script name
and optional args, using bash-like quoting and escaping. `ScriptCommand`
searches for a file with that script name on a passed list of directories; the
directories may be specified relative to a particular base directory.
`ScriptCommand` supports the special case of a script name containing unescaped
spaces. It guarantees that either the returned script file exists, or its
`error()` string is non-empty.
Replace `LLLeap::create()` logic, from which `ScriptCommand` was partly
derived, with a `ScriptCommand` instance.
Make `LLLUAmanager::runScriptFile()` use a `ScriptCommand` instance to parse
the passed command line.
Subsume `LLAppViewer::init()` script-path-searching logic for `--luafile`
into `ScriptCommand`. In fact that lambda now simply calls
`LLLUAmanager::runScriptFile()`.
Make `lluau::dostring()` accept an optional vector of script argument strings.
Following PUC-Rio Lua convention, pass these arguments into a Lua script as
the predefined global `arg`, and also as the script's `...` argument.
`LuaState::expr()` also accepts and passes through script argument strings.
Change the log tag for the Lua script interruption message: if we want it, we
can still enable it, but we don't necessarily want it along with all other
"Lua" DEBUG messages.
Remove `LuaState::script_finished_fn`, which isn't used any more. Also remove
the corresponding `LLLUAmanager::script_finished_fn`. This allows us to
simplify `~LuaState()` slightly, as well as the parameter signatures for
`LLLUAmanager::runScriptFile()` and `runScriptLine()`.
|
|
With the About info added, `getProfileStatsContext()` need not redundantly add
`"channel"`, `"version"` or `"region"`.
Slightly improve the efficiency of `LlsdToJson()` and `LlsdFromJson()` by
preallocating the known size of the source array or map. (Unfortunately the C++
`LLSD` class offers us no way to preallocate a map.)
In `LLAppViewer::getViewerInfo()`, avoid immediate successive calls to
`gAgent.getRegion()`.
|
|
|
|
Make Develop->Render Tests->Frame Profile dump JSON to a file too (#2412)
|
|
|
|
If the C++ runtime is already handling an exception, don't try to launch more
Lua operations.
|
|
MSVC's `std::basic_ostream<CHAR>` template is not implemented in a general way:
it can only be instantiated for certain specific `CHAR` types. Declaring a
`std::basic_ostringstream<llwchar>` fails on MSVC with C2941.
Fortunately both llstring.cpp functions that build a `LLWString` incrementally
have the same characteristics: (a) they each build it one character at a time,
and (b) the length of the result `LLWString` won't exceed the known length of
the input string. So it works to declare a `std::vector<llwchar>`, `reserve()`
the input length and `push_back()` individual characters. Then we can use
`LLWString`'s range constructor to immediately allocate the right size.
|
|
MSVC's `std::basic_ostream<CHAR>` template is not implemented in a general way:
it can only be instantiated for certain specific `CHAR` types. Declaring a
`std::basic_ostringstream<llwchar>` fails on MSVC with C2941.
The ugly workaround from Stack Overflow is to clone-and-edit Microsoft's
`std::numpunct` template, locally specializing it for the desired `CHAR` type.
|
|
|
|
Many of the string conversion functions in llstring.cpp would build their
result strings using successive concatenation operations, piece by piece. This
can be expensive in allocations. Instead, use a std::basic_ostringstream of
char type appropriate to the return string type to aggregate piecewise string
building.
|
|
`wchar_to_utf8chars()` used to require a `char*` output buffer with no length,
assuming that its caller knew enough to provide a buffer of sufficient length.
In fact a `char[8]` buffer suffices, but nothing in the header indicated that.
Eliminate the output parameter and return `std::string`. Fix the few existing
callers.
Also set an `ll_convert_alias` so that `ll_convert_to<std::string>(llwchar)`
directly calls `wchar_to_utf8chars()`. Replace instances of the workaround
`wstring_to_utf8str(LLWString(1, llwchar))`.
|
|
|
|
Consensus seems to be that (a) string_view is, in effect, already a reference,
(b) it's small enough to make pass-by-value reasonable and (c) the optimizer
can reason about values way better than it can about references.
|
|
|
|
|
|
|
|
Make central Lua engine functionality conditional on that flag.
|
|
Add tests to verify that llless() correctly handles signed <=> unsigned
comparison, which native "<" does not.
|
|
|
|
|
|
|
|
Also add develop branch's comments about llcoro::LockType being deprecated.
|
|
|
|
|
|
(#2507)
|
|
|
|
|
|
|
|
Changes on new main and changes on Lua project branch combined into a header
circularity. Resolved by hoisting coroutine-aware synchronization primitives
out to a new llcoromutex.h file in the `llcoro` namespace, rather than being
literally members of the `LLCoros` class. But retained `using` declarations in
`LLCoros` for backwards compatibility.
|
|
When asked to retrieve a slice starting at an `index > 0`, `getSliceStart()` was
returning an LLSD array whose first `index` entries were `isUndefined()`,
followed by the desired data. Fix to omit those undefined entries.
|
|
That includes scripts run by LLLUAmanager::runScriptFile(), runScriptLine()
et al.
|
|
We may well want to leverage that API for additional queries that could
potentially return large datasets.
|
|
|
|
That is, our replacement `pairs()` forwards the call to built-in `pairs()`
when the passed object has no `__iter()` metamethod. Similarly, our
replacement `ipairs()` forwards to built-in `ipairs()` when the passed object
has no `__index()` metamethod.
This allows for the possibility that the built-in `pairs()` and `ipairs()`
functions engage more efficient implementations than the obvious ones.
|
|
Specifically, make pairs(obj) honor obj's __iter() metamethod if any.
Make ipairs(obj) honor obj's __index() metamethod, if any. Given the semantics
of the __index() metamethod, though, this only works for a proxy table if the
proxy has no array entries (int keys) of its own.
|
|
The point of LLIntTracker is to generate its keys implicitly, so that its int
getKey() can be treated more or less like an instance pointer, with the added
bonus that the key can be passed around via LLSD.
LLIntTracker generates random int keys to try to make it a little harder for
one script to mess with an LLIntTracker instance belonging to another.
|
|
One could argue that LLInstanceTracker is a container of sorts, and erase() is
more conventional. This affects no other code, as destruct() is not currently
referenced.
|
|
Replace the global next(), pairs() and ipairs() functions with a C++ function
that drills down through layers of setdtor() proxy objects and then forwards
the updated arguments to the original global function.
Add a Luau __iter() metamethod to setdtor() proxy objects that, like other
proxy metamethods, drills down to the underlying _target object. __iter()
recognizes the case of a _target table which itself has a __iter() metamethod.
Also add __idiv() metamethod to support integer division.
Add tests for proxy // division, next(proxy), next(proxy, key), pairs(proxy),
ipairs(proxy) and 'for k, v in proxy'. Also test the case where the table
wrapped in the proxy has an __iter() metamethod of its own.
|
|
|
|
|
|
|
|
Trim redundant output from test_setdtor.lua.
|
|
secondlife/viewer#2445
|
|
`setdtor('description', object, function)` returns a proxy userdata object
referencing object and function. When the proxy is garbage-collected, or at
the end of the script, its destructor calls `function(object)`.
The original object may be retrieved as `proxy._target`, e.g. to pass it to
the `table` library. The proxy also has a metatable with metamethods
supporting arithmetic operations, string concatenation, length and table
indexing. For other operations, retrieve `proxy._target`. (But don't assign to
`proxy._target`. It will appear to work, in that subsequent references to
`proxy._target` will retrieve the replacement object -- however, the
destructor will still call `function(original object)`.)
Fix bugs in `lua_setfieldv()`, `lua_rawgetfield()` and `lua_rawsetfield()`.
Add C++ functions `lua_destroyuserdata()` to explicitly destroy a
`lua_emplace<T>()` userdata object, plus `lua_destroybounduserdata()`. The
latter can bind such a userdata object as an upvalue to pass to `LL.atexit()`.
Make `LL.help()` and `LL.leaphelp()` help text include the `LL.` prefix.
|
|
|
|
|
|
and Beq (#2423)
|
|
|
|
|
