| Age | Commit message (Collapse) | Author |
|---|
|
|
|
Also remove
#pragma comment(lib, "liblua54.a")
from relevant source files.
|
|
Also ditch crufty CMake logic related to lleventhost, which we haven't used
for years.
|
|
If not, the resulting error message is so mysterious that it's worth adding an
error check to explain how to avoid it.
|
|
|
|
following promotion of DRTVWR-578
|
|
|
|
Even though LLVersionInfo::getBuild() already returns a 64-bit int, various
consumers assumed it could fit into 32 bits. It was especially bad to pass it
to a classic C style varargs function. Only on a little-endian CPU, and only
because it was the last argument, the damage was limited to truncation --
instead of arbitrary undefined behavior.
Where the consumer doesn't support 64-bit ints, pass as string instead.
|
|
|
|
|
|
|
|
When lua_tollsd() makes a recursive call, it passes -1 as the index of the
newly-encountered nested table. To traverse the nested table, lua_tollsd()
starts by pushing nil as the initial key. But then calling lua_next(-1) finds
nil -- NOT the nested table!
Converting the index parameter to absolute before pushing nil solves.
|
|
(cherry picked from commit 08a3b56669880101aa705c98e60b76e92d26c93b)
|
|
Add from_lua() function to run a small Lua script that constructs a specified
Lua object and posts it back to the test program via a temporary LLEventPump.
Call this with a variety of Lua objects, comparing to the expected LLSD.
Add round_trip() function to run another small Lua script that listens for
incoming LLEventPump events and, for each, posts the received Lua data back to
the test program as LLSD. Call this with a variety of LLSD objects, comparing
to the expected LLSD. Also collect these objects into an LLSD array and send
that for a round trip; also collect into an LLSD map and send that.
Sadly, tests currently drive an access violation when trying to convert a
nested Lua table to LLSD.
Add verbose debug logging to lua_tollsd() to identify the context at which we
hit the access violation.
Add comments describing further exceptions to LLSD-to-Lua round trip identity.
Add lua_what() iostream manipulator to stream whatever we can readily
discover about a value at a specified Lua stack index.
Add lua_stack() to report the contents of the Lua stack. Since the stack is
created anew for every call to a C function, this shouldn't usually be
enormous.
Add hexdump.h with iostream manipulators to dump a byte range as hex digits,
or to produce readable text from a mix of printing and nonprinting ASCII
characters.
|
|
This branch cleans up crufty code in build.yaml, build.sh and
viewer_manifest.py that was packaging, signing and uploading installers before
the SL-19242 work.
|
|
|
|
DRTVWR-589
|
|
This is referenced after running the packaging.
|
|
|
|
|
|
for Mac and Windows. That's now done by subsequent jobs in the GitHub build.
Remove workflow step to upload installers before signing and packaging jobs.
Remove from viewer_manifest.py conditionals for 32-bit Windows or Mac.
Also bump to actions/checkout@v4, per dependabot.
|
|
DRTVWR-589
|
|
|
|
|
|
|
|
following promotion of DRTVWR-567
|
|
The first test runs a Lua script that calls post_on(), listen_events() and
await_event() to engage in LLEventPump handshakes with the test program.
Make llluamanager.cpp testable by putting LL_TEST conditionals around lots of
viewer-internals headers and the lua_function definitions that engage them.
Since LuaListener::connect() is called by its constructor, make it a static
method that explicitly accepts the lua_State* (instead of finding it as
mState). Add that parameter to its two existing calls.
Add a debug log message when LuaListener is destroyed. This surfaced the need
to pass a no-op deleter when listen_events() constructs a LuaListener::ptr_t.
When compiled for LL_TEST, make LuaListener::mReplyPump an
LLEventLogProxyFor<LLEventStream> instead of a plain LLEventStream.
For debugging purposes, add a type string "LLEventLogProxy" for
LLEventPumps::make(). A make() call with this type will return an
LLEventLogProxyFor<LLEventStream>.
|
|
Break out a lua_print_msg() function common to print_debug(), print_info() and
print_warning(). Instead of accepting a single argument, lua_print_msg()
accepts arbitrary arguments, passing each to the Lua tostring() function and
concatenating the results. In addition to returning the combined string to its
caller for level-appropriate logging, it also posts the message to a "lua
output" LLEventPump for any interested party.
Make LLFloaterLUADebug listen on "lua output" when the floater is constructed,
storing the connection in an LLTempBoundListener to stop listening when the
floater is destroyed. Append each message to the floater's output panel with a
line break.
Make LLTextEditor::addLineBreakChar() public. insertText("\n") only appends a
little rectangle glyph.
Enlarge the text capacity of the floater's output panel to be able to report
whatever messages a Lua script wants to print.
Add diagnostic logging for posting events from Lua, and receiving events to
forward to Lua.
Since lua_pop() is a macro implemented on lua_settop(), replace the awkward
construct lua_pop(L, lua_gettop(L)) with lua_settop(L, 0).
Use lambdas instead of std::bind() to connect LuaListener and LLLeapListener.
|
|
|
|
|
|
|
|
Sprinkle lua_checkstack() calls into functions that push to the Lua stack --
particularly important when traversing nested data structures of unknown depth!
Tweak lua_pushllsd() handling of LLSD arrays.
|
|
This suspends the calling Lua coroutine (and C++ coroutine on which the Lua
state is running) until an event is received on the named LLEventPump.
Returns the event.
Pass optional timeout in seconds as a second argument. With no timeout, waits
indefinitely.
Pass optional timeout discriminator return value as a third argument
(default nil).
|
|
so Lua print() output will go to the viewer log, instead of getting discarded
and possibly causing failures when the buffer fills and there's no open stdout
file handle.
Also name each Lua C++ coroutine with the description we give the LuaState
instance.
|
|
|
|
|
|
|
|
|
|
Add LuaListener, based on LLLeap. LuaListener has an int key so the second and
subsequent calls to listen_events() can find a previously-created one.
LuaListener listens on its LLEventPump and arranges to call the specified Lua
callback with any incoming event. It also instantiates an LLLeapListener.
listen_events() locates the main thread for its state: we only want to call
callbacks on the Lua chunk's main thread, not on a (possibly suspended)
coroutine. It finds or creates a LuaListener and stashes it in the main
thread's registry, along with the passed Lua callback function. Finally it
returns the names of the LuaListener's reply pump and the LLLeapListener's
command pump.
Add LuaState RAII class to manage the lifespan of each lua_State we create.
This encapsulates much of the boilerplate common to runScriptFile() and
runScriptLine(). In addition, LuaState's destructor checks for a LuaListener
key and, if found, destroys the referenced LuaListener.
LuaState's constructor requires a description to clarify log messages.
Move the checkLua() free function to a member of LuaState. This allows
capturing an error message to pass to the C++ completion callback, if any.
Use LuaState in runScriptFile() and runScriptLine(), synthesizing a suitable
description in each case.
Add print_debug() and print_info() logging calls, analogous to
print_warning(). Add luaL_where() prefix to every such message.
Add lua_pushstdstring(), like lua_tostdstring(): convenience for working with
the pointer and length used by lua_pushlstring() and lua_tolstring().
Clean up return values of lua_functions. A lua_CFunction returns the number of
return values it has pushed, so any 'void' lua_CFunction should pop its
arguments and return 0.
|
|
The function formerly known as luaL_typerror() is now luaL_typeerror().
|
|
We were creating the tarball with the app bundle stored as the whole
'Users/someone/.../newview/Release/Second Life Mumble.app' path. Don't.
|
|
|
|
|
|
Given that we at least have a possibility of determining the length of a Lua
table in advance, we might be able to populate a vector of keys with a single
initial allocation. Even if Lua reports the length incorrectly,
vector::push_back() is one of the bread-and-butter operations of the library,
optimized to the extent possible. Inserting elements into a set seems more
likely to incur allocations.
Of course, we must then sort() the vector to determine its largest key value.
Also document the requirement that we use a Lua runtime compiled for C++, that
is, compiled to raise errors by C++ exceptions rather than by longjmp(). We
rely on temporary stack objects being properly destroyed even if errors are
raised.
Conventionally, with lua_tomumble(L, index), 'index' refers to the stack index
of the Lua object being converted to C++. For a Lua table, talk about table
keys rather than table indexes to avoid confusing the maintainer.
|
|
actions/upload-artifact doesn't preserve symlinks, which are important for our
Mac viewer and its embedded frameworks. But tar does, so pack up the whole
bundle as a tarball before posting as a GitHub artifact.
|
|
The previous implementation assumed that the Lua length function would
correctly report the number of entries in a table, and that traversing a table
with integer keys would produce them in numeric order. Neither assumption is
true. Instead, make a preliminary pass to validate and collect indexes, and to
discover the highest integer index. Armed with that, we can construct a
contiguous LLSD array of correct size, and populate it with a second pass.
Also add Lua-callable post_on_pump(pumpname, datablob) function.
|
|
|
|
|
|
|
|
|
