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

Полное описание функций и типов вспомогательной библиотеки Lua (lauxlib)
Tags:
Categories:

Оглавление

  1. Введение
  2. Функции и типы

Введение

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

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

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

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

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

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

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

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

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 строкой, и возвращает эту строку.

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

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 пользовательскими данными типа tname (см. luaL_newmetatable), и возвращает адрес блока памяти пользовательских данных (см. 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. В противном случае создает новую таблицу для использования в качестве метатаблицы для пользовательских данных, добавляет в эту новую таблицу пару __name = tname, добавляет в реестр пару [tname] = new table и возвращает 1.

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

luaL_newstate

[-0, +0, –]

lua_State *luaL_newstate (void);

Создает новое состояние Lua. Вызывает lua_newstate с luaL_alloc в качестве функции распределения памяти и результатом luaL_makeseed(NULL) в качестве seed, а затем устанавливает функцию предупреждения и функцию паники (см. §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), его длина считается нулевой.

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

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);

Если аргумент функции arg является строкой, возвращает эту строку. Если этот аргумент отсутствует или равен nil, возвращает 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) в таблице на вершине стека (ниже необязательных upvalues, см. далее).

Когда nup не равен нулю, все функции создаются с nup upvalues, инициализированными копиями 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;

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

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

Эти пользовательские данные должны начинаться со структуры luaL_Stream; они могут содержать другие данные после этой начальной структуры. Поле f указывает на соответствующий поток C или равно NULL, чтобы указать на не полностью созданный дескриптор. Поле closef указывает на функцию Lua, которая будет вызвана для закрытия потока при закрытии или сборке дескриптора; эта функция получает файловый дескриптор в качестве единственного аргумента и должна возвращать либо true в случае успеха, либо false плюс сообщение об ошибке в случае ошибки. Как только 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 — функция, вызвавшая выполняющуюся функцию, и т.д.

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