5 – Вспомогательная библиотека

Вспомогательная библиотека предоставляет несколько удобных функций для взаимодействия C с Lua. Хотя базовый API предоставляет примитивные функции для всех взаимодействий между C и Lua, вспомогательная библиотека предоставляет функции более высокого уровня для некоторых типичных задач.

Все функции и типы из вспомогательной библиотеки определены в заголовочном файле lauxlib.h и имеют префикс luaL_.

Все функции вспомогательной библиотеки построены поверх базового API, и поэтому они не предоставляют ничего, что нельзя было бы сделать с помощью этого API. Тем не менее использование вспомогательной библиотеки обеспечивает большую согласованность вашего кода.

Некоторые функции вспомогательной библиотеки внутренне используют дополнительные слоты стека. Когда функция вспомогательной библиотеки использует менее пяти слотов, она не проверяет размер стека; она просто предполагает, что слотов достаточно.

Некоторые функции вспомогательной библиотеки используются для проверки аргументов C функций. Поскольку сообщение об ошибке форматируется для аргументов (например, "bad argument #1"), не следует использовать эти функции для других значений стека.

Функции с именем luaL_check* всегда вызывают ошибку, если проверка не выполнена.

5.1 – Функции и типы

Здесь перечислены все функции и типы из вспомогательной библиотеки в алфавитном порядке.

`luaL_addchar`

[-?, +?, m]

void luaL_addchar (luaL_Buffer *B, char c);

Добавляет байт c в буфер B (см. luaL_Buffer).

`luaL_addgsub`

[-?, +?, m]

const void luaL_addgsub (luaL_Buffer *B, const char *s,
                         const char *p, const char *r);

Добавляет копию строки s в буфер B (см. luaL_Buffer), заменяя все вхождения строки p строкой r.

`luaL_addlstring`

[-?, +?, m]

void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);

Добавляет строку, на которую указывает s, длиной l в буфер B (см. luaL_Buffer). Строка может содержать встроенные нули.

`luaL_addsize`

[-?, +?, –]

void luaL_addsize (luaL_Buffer *B, size_t n);

Добавляет в буфер B строку длиной n, ранее скопированную в область буфера (см. luaL_prepbuffer).

`luaL_addstring`

[-?, +?, m]

void luaL_addstring (luaL_Buffer *B, const char *s);

Добавляет строку, завершённую нулём, на которую указывает s, в буфер B (см. luaL_Buffer).

`luaL_addvalue`

[-?, +?, m]

void luaL_addvalue (luaL_Buffer *B);

Добавляет значение на вершине стека в буфер B (см. luaL_Buffer). Снимает значение со стека.

Это единственная функция для строковых буферов, которую можно (и нужно) вызывать с дополнительным элементом в стеке, который является значением, добавляемым в буфер.

`luaL_argcheck`

[-0, +0, v]

void luaL_argcheck (lua_State *L,
                    int cond,
                    int arg,
                    const char *extramsg);

Проверяет, истинно ли cond. Если нет, вызывает ошибку со стандартным сообщением (см. luaL_argerror).

`luaL_argerror`

[-0, +0, v]

int luaL_argerror (lua_State *L, int arg, const char *extramsg);

Вызывает ошибку, сообщая о проблеме с аргументом arg C функции, которая её вызвала, используя стандартное сообщение, включающее extramsg в качестве комментария:

     bad argument #arg to 'funcname' (extramsg)

Эта функция никогда не возвращает управление.

`luaL_argexpected`

[-0, +0, v]

void luaL_argexpected (lua_State *L,
                       int cond,
                       int arg,
                       const char *tname);

Проверяет, истинно ли cond. Если нет, вызывает ошибку о типе аргумента arg со стандартным сообщением (см. luaL_typeerror).

`luaL_Buffer`

typedef struct luaL_Buffer luaL_Buffer;

Тип для строкового буфера.

Строковый буфер позволяет коду на C постепенно строить строки Lua. Схема его использования следующая:

Сначала объявите переменную b типа luaL_Buffer.
Затем инициализируйте её вызовом luaL_buffinit(L,&b).
Затем добавляйте фрагменты строк в буфер, вызывая любую из функций luaL_add*.
Завершите вызовом luaL_pushresult(&b). Этот вызов оставляет итоговую строку на вершине стека.

Если вы заранее знаете максимальный размер результирующей строки, можно использовать буфер следующим образом:

Сначала объявите переменную b типа luaL_Buffer.
Затем инициализируйте его и предварительно выделите область размером sz вызовом luaL_buffinitsize(L,&b,sz).
Затем сформируйте строку в этой области.
Завершите вызовом luaL_pushresultsize(&b,sz), где sz — общий размер результирующей строки, скопированной в эту область (который может быть меньше или равен предварительно выделенному размеру).

Во время нормальной работы строковый буфер использует переменное число слотов стека. Поэтому при использовании буфера нельзя предполагать, что вы знаете, где находится вершина стека. Вы можете использовать стек между последовательными вызовами операций с буфером, если это использование сбалансировано; то есть при вызове операции с буфером стек находится на том же уровне, на котором он был сразу после предыдущей операции с буфером. (Единственное исключение из этого правила — luaL_addvalue.) После вызова luaL_pushresult стек возвращается к уровню, который был при инициализации буфера, плюс итоговая строка на его вершине.

`luaL_buffaddr`

[-0, +0, –]

char *luaL_buffaddr (luaL_Buffer *B);

Возвращает адрес текущего содержимого буфера B (см. luaL_Buffer). Обратите внимание, что любое добавление в буфер может сделать этот адрес недействительным.

`luaL_buffinit`

[-0, +?, –]

void luaL_buffinit (lua_State *L, luaL_Buffer *B);

Инициализирует буфер B (см. luaL_Buffer). Эта функция не выделяет никакого пространства; буфер должен быть объявлен как переменная.

`luaL_bufflen`

[-0, +0, –]

size_t luaL_bufflen (luaL_Buffer *B);

Возвращает длину текущего содержимого буфера B (см. luaL_Buffer).

`luaL_buffinitsize`

[-?, +?, m]

char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz);

Эквивалентна последовательности luaL_buffinit, luaL_prepbuffsize.

`luaL_buffsub`

[-?, +?, –]

void luaL_buffsub (luaL_Buffer *B, int n);

Удаляет n байтов из буфера B (см. luaL_Buffer). Буфер должен содержать как минимум столько байтов.

`luaL_callmeta`

[-0, +(0|1), e]

int luaL_callmeta (lua_State *L, int obj, const char *e);

Вызывает метаметод.

Если объект по индексу obj имеет метатаблицу, и у этой метатаблицы есть поле e, эта функция вызывает это поле, передавая объект в качестве единственного аргумента. В этом случае функция возвращает true и помещает в стек значение, возвращённое вызовом. Если метатаблицы или метаметода нет, функция возвращает false, не помещая в стек никакого значения.

`luaL_checkany`

[-0, +0, v]

void luaL_checkany (lua_State *L, int arg);

Проверяет, есть ли у функции аргумент любого типа (включая nil) в позиции arg.

`luaL_checkinteger`

[-0, +0, v]

lua_Integer luaL_checkinteger (lua_State *L, int arg);

Проверяет, является ли аргумент функции arg целым числом (или может быть преобразован в целое число), и возвращает это целое число.

`luaL_checklstring`

[-0, +0, v]

const char *luaL_checklstring (lua_State *L, int arg, size_t *l);

Проверяет, является ли аргумент функции arg строкой, и возвращает эту строку; если l не равно NULL, записывает по его адресу длину строки.

Эта функция использует lua_tolstring для получения результата, поэтому здесь применимы все преобразования и предостережения этой функции.

`luaL_checknumber`

[-0, +0, v]

lua_Number luaL_checknumber (lua_State *L, int arg);

Проверяет, является ли аргумент функции arg числом, и возвращает это число, преобразованное в lua_Number.

`luaL_checkoption`

[-0, +0, v]

int luaL_checkoption (lua_State *L,
                      int arg,
                      const char *def,
                      const char *const lst[]);

Проверяет, является ли аргумент функции arg строкой, и ищет эту строку в массиве lst (который должен завершаться NULL). Возвращает индекс в массиве, где была найдена строка. Вызывает ошибку, если аргумент не является строкой или если строку не удаётся найти.

Если def не равно NULL, функция использует def в качестве значения по умолчанию, когда аргумент arg отсутствует или когда этот аргумент равен nil.

Это полезная функция для сопоставления строк с C перечислениями. (Обычное соглашение в библиотеках Lua — использовать строки вместо чисел для выбора параметров.)

`luaL_checkstack`

[-0, +0, v]

void luaL_checkstack (lua_State *L, int sz, const char *msg);

Увеличивает размер стека до top + sz элементов, вызывая ошибку, если стек не может вырасти до этого размера. msg — дополнительный текст для сообщения об ошибке (или NULL, если дополнительный текст не нужен).

`luaL_checkstring`

[-0, +0, v]

const char *luaL_checkstring (lua_State *L, int arg);

Проверяет, является ли аргумент функции arg строкой, и возвращает эту строку.

`luaL_checktype`

[-0, +0, v]

void luaL_checktype (lua_State *L, int arg, int t);

Проверяет, имеет ли аргумент функции arg тип t. См. lua_type для кодировки типов для t.

`luaL_checkudata`

[-0, +0, v]

void *luaL_checkudata (lua_State *L, int arg, const char *tname);

Проверяет, является ли аргумент функции arg userdata типа tname (см. luaL_newmetatable), и возвращает адрес блока памяти userdata (см. lua_touserdata).

`luaL_checkversion`

[-0, +0, v]

void luaL_checkversion (lua_State *L);

Проверяет, используют ли код, выполняющий вызов, и вызываемая библиотека Lua одну и ту же версию Lua и одни и те же числовые типы.

`luaL_dofile`

[-0, +?, m]

int luaL_dofile (lua_State *L, const char *filename);

Загружает и выполняет заданный файл. Она определена как следующий макрос:

     (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))

Она возвращает 0 (LUA_OK), если ошибок нет, или 1 в случае ошибок. (За исключением ошибок нехватки памяти, которые вызываются.)

`luaL_dostring`

[-0, +?, –]

int luaL_dostring (lua_State *L, const char *str);

Загружает и выполняет заданную строку. Она определена как следующий макрос:

     (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))

Она возвращает 0 (LUA_OK), если ошибок нет, или 1 в случае ошибок.

`luaL_error`

[-0, +0, v]

int luaL_error (lua_State *L, const char *fmt, ...);

Вызывает ошибку. Формат сообщения об ошибке задаётся fmt плюс любые дополнительные аргументы, следуя тем же правилам, что и lua_pushfstring. Она также добавляет в начало сообщения имя файла и номер строки, где произошла ошибка, если эта информация доступна.

Эта функция никогда не возвращает управление, но в C функциях принято использовать её как return luaL_error(args).

`luaL_execresult`

[-0, +3, m]

int luaL_execresult (lua_State *L, int stat);

Эта функция формирует возвращаемые значения для функций стандартной библиотеки, связанных с процессами (os.execute и io.close).

`luaL_fileresult`

[-0, +(1|3), m]

int luaL_fileresult (lua_State *L, int stat, const char *fname);

Эта функция формирует возвращаемые значения для функций стандартной библиотеки, связанных с файлами (io.open, os.rename, file:seek и т. д.).

`luaL_getmetafield`

[-0, +(0|1), m]

int luaL_getmetafield (lua_State *L, int obj, const char *e);

Помещает в стек поле e из метатаблицы объекта по индексу obj и возвращает тип помещённого значения. Если у объекта нет метатаблицы или если в метатаблице нет этого поля, ничего не помещает и возвращает LUA_TNIL.

`luaL_getmetatable`

[-0, +1, m]

int luaL_getmetatable (lua_State *L, const char *tname);

Помещает в стек метатаблицу, связанную с именем tname в реестре (см. luaL_newmetatable), или nil, если с этим именем не связана никакая метатаблица. Возвращает тип помещённого значения.

`luaL_getsubtable`

[-0, +1, e]

int luaL_getsubtable (lua_State *L, int idx, const char *fname);

Гарантирует, что значение t[fname], где t — значение по индексу idx, является таблицей, и помещает эту таблицу в стек. Возвращает true, если там найдена существующая таблица, и false, если создаётся новая таблица.

`luaL_gsub`

[-0, +1, m]

const char *luaL_gsub (lua_State *L,
                       const char *s,
                       const char *p,
                       const char *r);

Создаёт копию строки s, заменяя все вхождения строки p строкой r. Помещает результирующую строку в стек и возвращает её.

`luaL_len`

[-0, +0, e]

lua_Integer luaL_len (lua_State *L, int index);

Возвращает "длину" значения по заданному индексу как число; это эквивалентно оператору '#' в Lua (см. §3.4.7). Вызывает ошибку, если результат операции не является целым числом. (Этот случай может произойти только через метаметоды.)

`luaL_loadbuffer`

[-0, +1, –]

int luaL_loadbuffer (lua_State *L,
                     const char *buff,
                     size_t sz,
                     const char *name);

Эквивалентна luaL_loadbufferx с mode, равным NULL.

`luaL_loadbufferx`

[-0, +1, –]

int luaL_loadbufferx (lua_State *L,
                      const char *buff,
                      size_t sz,
                      const char *name,
                      const char *mode);

Загружает буфер как чанк Lua. Эта функция использует lua_load для загрузки чанка в буфере, на который указывает buff, размером sz.

Эта функция возвращает те же результаты, что и lua_load. name — имя чанка, используемое для отладочной информации и сообщений об ошибках. Строка mode работает так же, как в функции lua_load. В частности, эта функция поддерживает режим 'B' для фиксированных буферов.

`luaL_loadfile`

[-0, +1, m]

int luaL_loadfile (lua_State *L, const char *filename);

Эквивалентна luaL_loadfilex с mode, равным NULL.

`luaL_loadfilex`

[-0, +1, m]

int luaL_loadfilex (lua_State *L, const char *filename,
                                            const char *mode);

Загружает файл как чанк Lua. Эта функция использует lua_load для загрузки чанка из файла с именем filename. Если filename равно NULL, то загрузка выполняется из стандартного ввода. Первая строка файла игнорируется, если она начинается с #.

Строка mode работает так же, как в функции lua_load.

Эта функция возвращает те же результаты, что и lua_load, или LUA_ERRFILE для ошибок, связанных с файлами.

Как и lua_load, эта функция только загружает чанк; она не выполняет его.

`luaL_loadstring`

[-0, +1, –]

int luaL_loadstring (lua_State *L, const char *s);

Загружает строку как чанк Lua. Эта функция использует lua_load для загрузки чанка из строки s, завершённой нулём.

Эта функция возвращает те же результаты, что и lua_load.

Также как lua_load, эта функция только загружает чанк; она не выполняет его.

`luaL_makeseed`

[-0, +0, –]

unsigned int luaL_makeseed (lua_State *L);

Возвращает значение со слабой попыткой обеспечить случайность. Параметр L может быть NULL, если состояние Lua недоступно.

`luaL_newlib`

[-0, +1, m]

void luaL_newlib (lua_State *L, const luaL_Reg l[]);

Создаёт новую таблицу и регистрирует в ней функции из списка l.

Она реализована как следующий макрос:

     (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))

Массив l должен быть самим массивом, а не указателем на него.

`luaL_newlibtable`

[-0, +1, m]

void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);

Создаёт новую таблицу с размером, оптимизированным для хранения всех элементов массива l (но фактически не сохраняет их). Она предназначена для использования вместе с luaL_setfuncs (см. luaL_newlib).

Она реализована как макрос. Массив l должен быть самим массивом, а не указателем на него.

`luaL_newmetatable`

[-0, +1, m]

int luaL_newmetatable (lua_State *L, const char *tname);

Если в реестре уже есть ключ tname, возвращает 0. В противном случае создаёт новую таблицу для использования в качестве метатаблицы для userdata, добавляет в эту новую таблицу пару __name = tname, добавляет в реестр пару [tname] = new table и возвращает 1.

В обоих случаях функция помещает в стек итоговое значение, связанное с tname в реестре.

Примечание по использованию: остерегайтесь использовать возвращаемое значение этой функции для условной инициализации новой метатаблицы (например, путём добавления в неё метаметодов). Если инициализация вызывает ошибку, метатаблица не будет должным образом инициализирована, но последующее выполнение этого кода обнаружит, что метатаблица уже существует, и затем пропустит инициализацию.

`luaL_newstate`

[-0, +0, –]

lua_State *luaL_newstate (void);

Создаёт новое состояние Lua. Она вызывает lua_newstate с luaL_alloc в качестве функции-аллокатора и результатом luaL_makeseed(NULL) в качестве начального значения, а затем устанавливает функцию предупреждений и функцию паники (см. §4.4), которые выводят сообщения в стандартный поток ошибок.

Возвращает новое состояние или NULL в случае ошибки выделения памяти.

`luaL_opt`

[-0, +0, –]

T luaL_opt (L, func, arg, dflt);

Этот макрос определён следующим образом:

     (lua_isnoneornil(L,(arg)) ? (dflt) : func(L,(arg)))

Иными словами, если аргумент arg равен nil или отсутствует, макрос выдаёт значение по умолчанию dflt. В противном случае он выдаёт результат вызова func с состоянием L и индексом аргумента arg в качестве аргументов. Обратите внимание, что выражение dflt вычисляется только при необходимости.

`luaL_optinteger`

[-0, +0, v]

lua_Integer luaL_optinteger (lua_State *L,
                             int arg,
                             lua_Integer d);

Если аргумент функции arg является целым числом (или может быть преобразован в целое число), возвращает это целое число. Если этот аргумент отсутствует или равен nil, возвращает d. В противном случае вызывает ошибку.

`luaL_optlstring`

[-0, +0, v]

const char *luaL_optlstring (lua_State *L,
                             int arg,
                             const char *d,
                             size_t *l);

Если аргумент функции arg является строкой, возвращает эту строку. Если этот аргумент отсутствует или равен nil, возвращает d. В противном случае вызывает ошибку.

Если l не равно NULL, заполняет объект, на который оно указывает, длиной результата. Если результат равен NULL (это возможно только при возврате d и d == NULL), его длина считается равной нулю.

`luaL_optnumber`

[-0, +0, v]

lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number d);

Если аргумент функции arg является числом, возвращает это число как lua_Number. Если этот аргумент отсутствует или равен nil, возвращает d. В противном случае вызывает ошибку.

`luaL_optstring`

[-0, +0, v]

const char *luaL_optstring (lua_State *L,
                            int arg,
                            const char *d);

`luaL_prepbuffer`

[-?, +?, m]

char *luaL_prepbuffer (luaL_Buffer *B);

Эквивалентна luaL_prepbuffsize с предопределённым размером LUAL_BUFFERSIZE.

`luaL_prepbuffsize`

[-?, +?, m]

char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz);

Возвращает адрес области размером sz, куда можно скопировать строку для добавления в буфер B (см. luaL_Buffer). После копирования строки в эту область необходимо вызвать luaL_addsize с размером строки, чтобы фактически добавить её в буфер.

`luaL_pushfail`

[-0, +1, –]

void luaL_pushfail (lua_State *L);

Помещает значение fail в стек (см. §6).

`luaL_pushresult`

[-?, +1, m]

void luaL_pushresult (luaL_Buffer *B);

Завершает использование буфера B, оставляя итоговую строку на вершине стека.

`luaL_pushresultsize`

[-?, +1, m]

void luaL_pushresultsize (luaL_Buffer *B, size_t sz);

Эквивалентна последовательности luaL_addsize, luaL_pushresult.

`luaL_ref`

[-1, +0, m]

int luaL_ref (lua_State *L, int t);

Создаёт и возвращает ссылку в таблице по индексу t для объекта на вершине стека (и снимает объект со стека).

Система ссылок использует целочисленные ключи таблицы. Ссылка — это уникальный целочисленный ключ; luaL_ref обеспечивает уникальность возвращаемых ключей. Запись 1 зарезервирована для внутреннего использования. Перед первым использованием luaL_ref целочисленные ключи таблицы должны образовывать правильную последовательность (без дырок), а значение в записи 1 должно быть false: nil, если последовательность пуста, false в противном случае. Не следует вручную устанавливать целочисленные ключи в таблице после первого использования luaL_ref.

Можно получить объект, на который ссылается ссылка r, вызвав lua_rawgeti(L,t,r) или lua_geti(L,t,r). Функция luaL_unref освобождает ссылку.

Если объект на вершине стека равен nil, luaL_ref возвращает константу LUA_REFNIL. Константа LUA_NOREF гарантированно отличается от любой ссылки, возвращаемой luaL_ref.

`luaL_Reg`

typedef struct luaL_Reg {
  const char *name;
  lua_CFunction func;
} luaL_Reg;

Тип для массивов функций, регистрируемых с помощью luaL_setfuncs. name — имя функции, а func — указатель на функцию. Любой массив luaL_Reg должен заканчиваться сторожевым элементом, в котором и name, и func равны NULL.

`luaL_requiref`

[-0, +1, e]

void luaL_requiref (lua_State *L, const char *modname,
                    lua_CFunction openf, int glb);

Если package.loaded[modname] не равно true, вызывает функцию openf со строкой modname в качестве аргумента и устанавливает результат вызова в package.loaded[modname], как если бы эта функция была вызвана через require.

Если glb равно true, также сохраняет модуль в глобальной переменной modname.

Оставляет копию модуля в стеке.

`luaL_setfuncs`

[-nup, +0, m]

void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);

Регистрирует все функции из массива l (см. luaL_Reg) в таблице на вершине стека (ниже необязательных upvalue, см. далее).

Если nup не равно нулю, все функции создаются с nup upvalue, инициализированными копиями nup значений, ранее помещённых в стек над таблицей библиотеки. Эти значения снимаются со стека после регистрации.

Функция со значением NULL представляет собой заполнитель, который заполняется значением false.

`luaL_setmetatable`

[-0, +0, –]

void luaL_setmetatable (lua_State *L, const char *tname);

Устанавливает метатаблицу объекта на вершине стека как метатаблицу, связанную с именем tname в реестре (см. luaL_newmetatable).

`luaL_alloc`

void *luaL_alloc (void *ud, void *ptr, size_t osize, size_t nsize);

Стандартная функция-аллокатор для Lua (см. lua_Alloc), построенная на основе функций C realloc и free.

`luaL_Stream`

typedef struct luaL_Stream {
  FILE *f;
  lua_CFunction closef;
} luaL_Stream;

Стандартное представление файловых дескрипторов, используемое стандартной библиотекой ввода-вывода.

Файловый дескриптор реализован как полный userdata с метатаблицей под названием LUA_FILEHANDLE (где LUA_FILEHANDLE — макрос с фактическим именем метатаблицы). Метатаблица создаётся библиотекой ввода-вывода (см. luaL_newmetatable).

Этот userdata должен начинаться со структуры luaL_Stream; после этой начальной структуры он может содержать другие данные. Поле f указывает на соответствующий поток C или равно NULL, что означает неполностью созданный дескриптор. Поле closef указывает на функцию Lua, которая будет вызвана для закрытия потока, когда дескриптор закрывается или собирается сборщиком мусора; эта функция получает файловый дескриптор в качестве единственного аргумента и должна возвращать либо истинное значение в случае успеха, либо ложное значение плюс сообщение об ошибке в случае ошибки. После того как Lua вызывает это поле, оно изменяет значение поля на NULL, чтобы сигнализировать о том, что дескриптор закрыт.

`luaL_testudata`

[-0, +0, m]

void *luaL_testudata (lua_State *L, int arg, const char *tname);

Эта функция работает как luaL_checkudata, за исключением того, что при неудачной проверке она возвращает NULL вместо вызова ошибки.

`luaL_tolstring`

[-0, +1, e]

const char *luaL_tolstring (lua_State *L, int idx, size_t *len);

Преобразует любое значение Lua по заданному индексу в строку C в разумном формате. Результирующая строка помещается в стек и также возвращается функцией (см. §4.1.3). Если len не равно NULL, функция также устанавливает *len равным длине строки.

Если значение имеет метатаблицу с полем __tostring, то luaL_tolstring вызывает соответствующий метаметод со значением в качестве аргумента и использует результат вызова как свой результат.

`luaL_traceback`

[-0, +1, m]

void luaL_traceback (lua_State *L, lua_State *L1, const char *msg,
                     int level);

Создаёт и помещает в стек трассировку стека L1. Если msg не равно NULL, оно добавляется в начало трассировки. Параметр level указывает, с какого уровня начинать трассировку.

`luaL_typeerror`

[-0, +0, v]

int luaL_typeerror (lua_State *L, int arg, const char *tname);

Вызывает ошибку типа для аргумента arg C функции, которая её вызвала, используя стандартное сообщение; tname — "имя" ожидаемого типа. Эта функция никогда не возвращает управление.

`luaL_typename`

[-0, +0, –]

const char *luaL_typename (lua_State *L, int index);

Возвращает имя типа значения по заданному индексу.

`luaL_unref`

[-0, +0, –]

void luaL_unref (lua_State *L, int t, int ref);

Освобождает ссылку (см. luaL_ref). Целое число ref должно быть либо LUA_NOREF, LUA_REFNIL, либо ссылкой, ранее возвращённой luaL_ref и ещё не освобождённой. Если ref равно LUA_NOREF или LUA_REFNIL, эта функция ничего не делает. В противном случае запись удаляется из таблицы, чтобы объект, на который указывает ссылка, можно было собрать сборщиком мусора, а ссылку ref можно было снова использовать в luaL_ref.

`luaL_where`

[-0, +1, m]

void luaL_where (lua_State *L, int lvl);

Помещает в стек строку, идентифицирующую текущую позицию управления на уровне lvl в стеке вызовов. Обычно эта строка имеет следующий формат:

     chunkname:currentline:

Уровень 0 — это выполняющаяся функция, уровень 1 — функция, которая вызвала выполняющуюся функцию, и т. д.

Эта функция используется для построения префикса сообщений об ошибках.