Clear and initialize empty settings instance

Adjust flags: default width mode + stretch columns are not allowed when auto extending

Pop trailing draw command (used before merging or presenting to user) Note that this leaves the ImDrawList in a state unfit for further commands, as m

Initialize before use in a new frame. We always have a command ready in the buffer.

* Close directory stream opened by opendir() function. This invalidates the * DIR structure as well as any directory entry read previously by * _wr

Add an attribute to a given group in the compiler attribues map

Adds an upvalue to [compiler]'s function with the given properties. Does not add one if an upvalue for that variable is already in the list. Returns t

zlib & jpeg huffman tables assume that the output symbols can either be arbitrarily arranged, or have monotonically increasing frequencies--they rely

** Add integer part of 'x' to buffer and return new 'x' */

Helper: Text buffer for logging/accumulating text

** returns the index for 'k' if 'k' is an appropriate key to live in ** the array part of a table, 0 otherwise. */

** Clears all gray lists, sweeps objects, and prepare sublists to enter ** generational mode. The sweeps remove dead objects and turn all ** surviving

** Auxiliary function to create the iteration function for 'lines'. ** The iteration function is a closure over 'io_readline', with ** the following u

** Resumes a coroutine. Returns the number of results for non-error ** cases or -1 for errors. */

** t[k] = value at the top of the stack (where 'k' is a string) */

** get (if 'get' is true) or set an upvalue from a closure */

** call all pending finalizers */

** If possible, shrink string table. */

** Check whether message is a control message. If so, execute the ** control or ignore it if unknown. */

** Check that 'arg' either is a table or can behave like one (that is, ** has a metatable with the required metamethods) */

Compiles a class definition. Assumes the "class" token has already been consumed (along with a possibly preceding "foreign" token).

** clear entries with unmarked keys from all weaktables in list 'l' */

Close directory stream */

** Code arithmetic operators ('+', '-', ...). If second operand is a ** constant in the proper range, use variant opcodes with K operands. */

** Emit an "extra argument" instruction (format 'iAx') */

** Emit code for order comparisons. When using an immediate operand, ** 'isfloat' tells whether the original value was a float. */

** Get the constant value from a constant expression */

** Try to "constant-fold" an operation; return 1 iff successful. ** (In this case, 'e1' has the final result.) */

** Traverse all ephemeron tables propagating marks from keys to values. ** Repeat until it converges, that is, nothing new is marked. 'dir' ** inverts

copy strings in stack from top - n up to top - 1 to buffer */

Copy the current attributes stored in the compiler into a destination map This also resets the counter, since the intent is to consume the attributes

Creates a new class. If [numFields] is -1, the class is a foreign class. The name and superclass should be on top of the fiber's stack. After calling

** Create a new label with the given 'name' at the given 'line'. ** 'last' tells whether label is the last non-op statement in its ** block. Solves al

** creates a new string object */

Loads the enclosing class onto the stack and then binds the function already on the stack as a method on that class.

Compiles a "definition". These are the statements that bind new variables. They can only appear at the top level of a block and are prohibited in plac

** Read an integer numeral from string 'fmt' or return 'df' if ** there is no numeral */

Get first directory entry */

Get next directory entry */

** Ensure expression value is in a register, making 'e' a ** non-relocatable expression. ** (Expression still may have jump lists.) */

** Ensure expression value is in register 'reg', making 'e' a ** non-relocatable expression. ** (Expression still may have jump lists.) */

** Do the REPL: repeatedly read (load) a line, evaluate (call) it, and ** print any results. */