Crazy Rebel: викификация, оформление, иллюстрация

2010-11-18T14:23:40Z

викификация, оформление, иллюстрация

Новая статья

: '''''Lua''''' Язык программирования сценариев, встраиваемый в ваши приложения

==''Lua'': Встроим его в код==

{{Цикл/Lua}}

: '''Часть 4''': Вот уже четвертый номер мы пропагандируем ''Lua'' как хороший встраиваемый язык, и теперь пришла пора подтвердить слова делом. '''Андрей Боровский''' скрестит его с ''C'' и ''C++''

Говорят, что когда Билл Гейтс и Пол Аллен писали первый интерпретатор ''Basic'' для «Альтаира», они не пользовались генераторами лексических и синтаксических анализаторов и формальными грамматиками, потому что не знали об их существовании. Тут можно усмотреть как проявление гениальности основателей Microsoft, так и отсутствие надлежащей квалификации. Как бы там ни было, современные программисты также могут наделять свои приложения встроенными интерпретаторами скриптовых языков, ничего не зная о принципах написания последних. Умные люди упростили решение этой задачи до такой
степени, что теперь результатами их труда могут пользоваться все желающие. Остается только надеяться, что с годами избалованные программисты не станут глупее.

Все синтаксические красоты ''Lua'' вряд ли привлекли бы к нему внимание, если бы не главное: возможность встраивать интерпретатор в программы, написанные на ''C'' и других компилируемых языках. О том, что это дает разработчику, мы говорили в [[LXF122:LUA|LXF122]]. С точки зрения программного интерфейса, объединение ''Lua'' и ''C'' позволяет решить две (как правило, связанные) задачи: управление программой ''Lua'' из приложения на ''C'' и вызов из программ
''Lua'' функций, написанных на ''C'' (в этом случае можно сказать, что программа ''Lua'' управляет ''C''-кодом).

{{Врезка|Содержание=[[Изображение:LXF125_72_1.jpg|300px]] Игра ''Unknown Horizon'' — пример программы, использующей интерпретатор ''Lua''.|Ширина=300px}}

===Состояние и стек===

Ядро интерпретатора ''Lua'' находится в библиотеке ''liblua''. Программа-интерпретатор, которой мы пользовались до сих пор (файл '''lua5.1'''), представляет собой лишь тоненькую обертку вокруг нее. Чтобы наделить программу на ''C'' возможностью использовать язык ''Lua'', нужно связать ее с ''liblua'' и задействовать экспортируемый библиотекой API. Прежде чем выполнять примеры из этой статьи, убедитесь, что файл '''liblua.so''' в вашей системе является ссылкой на библиотеку '''liblua.so.5.1'''. API'' C'' довольно заметно изменился при переходе от версии ''Lua'' 5.0 к 5.1, а в наших примерах мы будем использовать API последней версии.

Два наиболее важных понятия в ''Lua C'' API – это «состояние Lua» (Lua state) и стек. Первое есть структура, содержащая сведения об интерпретаторе, к которым можно получить доступ из функции и макросов ''Lua'' API. Адрес данной структуры является обязательным параметром для всех функций и макросов ''Lua C'' API (и всегда передается в качестве первого аргумента, так что дальше мы не будем каждый раз о нем упоминать). Для тех, кто регулярно имеет дело с различными программными интерфейсами в стиле ''C'' (скажем, ''GTK''), структура, описывающая состояние ''Lua'', не представляет собой ничего необычного – ее аналоги, содержащие информацию о состоянии программируемого элемента (окна, кодека, драйвера устройства и тому подобного), есть практически везде. Указатель на структуру, описывающую состояние ''Lua'', можно рассматривать как дескриптор экземпляра интерпретатора ''Lua'' (только нужно помнить, что экземпляра как такового не существует).

Если состояние ''Lua'' выглядит абстрактным понятием, то стек ''Lua'' еще более абстрактен. Как мы знаем, переменные ''Lua'' очень сильно отличаются от переменных ''C'', поэтому нет возможности установить прямое соответствие между таковыми в программе-хозяине и сценарии ''Lua''. Стек играет роль средства для обмена данными, и также является частью состояния ''Lua''. В него можно помещать элементы, которые затем могут быть извлечены в обратном порядке. Практически все функции ''Lua C'' API выполняют операции над элементами стека и помещают в него результат. Поскольку переменные ''Lua'' полиморфны, ячейки стека могут содержать данные любого типа, поддерживаемого ''Lua''. Прежде чем использовать данные из стека в программе на ''С'', необходимо убедиться, что они имеют требуемый тип. С помощью стека между программой на ''C'' и кодом ''Lua ''передаются не только простые переменные, но и ссылки на функции и таблицы, описывающие загруженные модули. Вот почему стек ''Lua'' является важнейшей концепцией всего API.

Запутались? Все это не так сложно, как кажется. Рассмотрим пример программы на ''C'', загружающий скрипт ''Lua'' (файл '''runlua.c''' на LXFDVD):

#include <lua.h>
#include <lauxlib.h>
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
int result;
lua_State * L;
L = luaL_newstate();
luaL_openlibs(L);
result = luaL_loadfile(L, “script.lua”);
if (result) {
fprintf(stderr, “Ошибка загрузки: %s\n”, lua_tostring(L, -1));
exit(1);
}
lua_pushnumber(L, 2);
lua_setglobal(L, “var”);
result = lua_pcall(L, 0, LUA_MULTRET, 0);
if (result) {
fprintf(stderr, “Ошибка выполнения: %s\n”, lua_tostring(L,-1));
exit(1);
}
printf(“Успешное завершение\n”);
lua_close(L);
return EXIT_SUCCESS;
}

Здесь считывается файл '''script.lua''', создается глобальная переменная ''Lua'' '''var''' со значением 2 и выполняется ''Lua''-программа. Элементы ''Lua C'' API описаны в заголовочных файлах '''lua.h''' и '''lauxlib.h'''. Переменная '''L''' – это указатель на структуру, описывающую состояние ''Lua''. Саму структуру мы создаем с помощью функции '''luaL_newstate()'''. Функция '''luaL_openlibs()''' открывает стандартные библиотеки ''Lua'' для заданного состояния. Если ее не вызывать, загруженная программа ''Lua'' не сможет обращаться к элементам стандартных библиотек ''Lua'', например, функции '''print()'''. Вызов '''luaL_loadfile()''' загружает текст программы ''Lua'' из файла. В случае успеха функция возвращает '''0'''; ненулевое значение свидетельствует об ошибке.

Библиотека ''Lua'' возвращает подробные текстовые описания всех обнаруженных ошибок, причем использует для этого стандартный механизм передачи данных между ''Lua'' и программой-хозяином, то есть стек. В случае возникновения ошибки мы читаем ее описание посредством функции '''lua_tostring()'''. Обратите внимание на ее второй аргумент. Как и в большинстве функций ''Lua ''API, имеющих дело с данными ''Lua'', в качестве источника сведений для '''lua_tostring()''' мы указываем ячейку стека. Они обозначаются индексами, причем начиная с единицы, а не с нуля. Вызов функции

lua_tostring(L, -1)

преобразует в строку ''C'' значение, находящееся в верхней ячейке стека (т.е. попавшее в стек последним). Аналогично, конструкция

lua_tostring(L, 1)

считывает значение, которое было помещено в стек первым. Ячейку, где находится самое последнее из помещенных в стек значений (и на которую ссылается индекс '''-1'''), мы называем вершиной стека. Ячейку, где находится самое первое помещенное в стек значение (самое старое, которому соответствует индекс '''1'''), мы называем дном. Документация ''Lua'' придерживается противоположных обозначений (то, что мы называем дном стека, там считается вершиной, и наоборот). В данном примере будет считано описание ошибки, которое помещается на вершину стека.

Важно отметить, что функция '''lua_tostring()''' (а также '''lua_tonumber()''' и ей подобные) не удаляет значение из стека. При работе с функциями Lua API следует всегда помнить, как они влияют на стек. Библиотеки ''Lua'' не следят за переполнением стека – вы сами должны заботиться о том, чтобы в нем не было ничего лишнего. Для удаления из стека заданного значения предназначена функция '''lua_pop()'''. Мы не вызываем ее после '''lua_tostring()''' только потому, что программа в этом случае все равно завершится и очищать стек специально нет необходимости.

Если текст программы загружен успешно, функция '''luaL_loadfile()''' создает выполняемый интерпретатором ''Lua'' фрагмент и помещает его на вершину стека. Далее мы создаем глобальную переменную '''var'''. Функция '''lua_pushnumber()''' помещает в стек числовое значение. Макрос '''lua_setglobal()''' создает глобальную переменную и присваивает ей значение из ячейки, находящейся на вершине стека. Если мы посмотрим определение макроса '''lua_setglobal()''', то увидим, что он сводится к вызову '''lua_setfield()'''. Первым аргументом этой функции является указатель на структуру,
описывающую состояние ''Lua'', вторым – индекс таблицы, в которую добавляется переменная, а третьим – строка ''C'' с ее именем. Позволю себе напомнить, что все переменные ''Lua'' являются элементами каких-либо таблиц. Так, глобальные переменные содержатся в '''_G''' ([[LXF124:LUA|LXF124]]) – именно с этой таблицей и работает макрос '''lua_setglobal()'''. Разумеется, с помощью функции '''lua_setfield()''' (и макроса '''lua_setglobal()''') можно не только создавать новые переменные, но и модифицировать значения уже существующих. С помощью этих же функций можно уничтожать переменные ''Lua''. Делается это так же, как и внутри ''Lua''-кода, то есть путем присвоения переменной значения '''nil'''. Для записи его в стек предназначена специальная функция '''lua_pushnil()'''. Функция '''lua_setfield()''' удаляет значение с вершины стека, так что вызов '''lua_pop()''' после нее не нужен.

Функция '''lua_pcall()''' выполняет самую волшебную часть нашей программы – запускает сценарий ''Lua'' на выполнение. Второй ее аргумент – число параметров, переданных выполняемому фрагменту (в нашем примере – '''0'''), третий – число значений, которые возвращает фрагмент (мы используем константу '''LUA_MULTRET''', указывающую, что оно может быть переменным).

Помимо функции '''lua_pcall()''', API предоставляет нам '''lua_call()'''. Те, кто читал предыдущую статью, наверняка уже догадались, в чем разница между ними. Функция '''lua_pcall()''' выполняет загруженный код в «защищенном режиме», то есть подавляет все возникшие во время выполнения кода ''Lua'' ошибки, а не передает их на более высокий уровень. Но откуда функция '''lua_pcall()''' знает, какой фрагмент кода ''Lua'' она должна выполнить? В процессе
ее вызова из стека извлекаются аргументы, переданные фрагменту кода ''Lua'' (если они есть), а после них '''lua_pcall()''' ожидает увидеть ссылку на сам фрагмент. Она также извлекается из стека, и на ее месте оказываются значения, возвращенные выполненным фрагментом. Последний аргумент '''lua_pcall()''' – индекс в стеке функции ''Lua'', используемой для обработки ошибок. Если он равен '''0''', то в случае возникновения ошибки на вершине стека оказывается текстовое описание, которое мы выводим так же, как и в случае с '''luaL_loadfile()'''. Теперь нетрудно понять, как интерпретатор ''Lua'' выполняет несколько фрагментов программы, содержащихся в разных файлах, в едином контексте. Все, что для этого нужно – вызвать несколько функций '''lua_[p]call()''' с одной и той же переменной, описывающей состояние интерпретатора ''Lua''. Наконец, мы уничтожаем структуру, описывающую состояние ''Lua'', функцией '''lua_close()'''.

Файл '''script.lua''', который мы загружаем на выполнение в программе-примере, может содержать любой корректный фрагмент программы ''Lua''. Нашу среду выполнения ''Lua'' отличает то, что фрагменту доступна глобальная переменная '''var'''. Это можно проверить с помощью простейшей конструкции:

print(“переменная var”, var)

Сохранив эту строку в файле '''script.lua''', скомпилируйте нашу ''C''-программу:

gcc runlua.c -o runlua -llua

Наберите '''./runlua''' и убедитесь, что приложение работает. Попробуйте отредактировать текст '''script.lua''' и посмотрите, как наша
программа реагирует на различные ошибки в коде ''Lua''.

===И снова калькулятор===

В прошлый раз мы использовали возможности ''Lua'' для создания программы-калькулятора. Теперь давайте попробуем применить ''Lua'' для добавления функций калькулятора в приложение ''C++'' (файл '''calc.cpp'''):

<source lang=c>
#include <iostream>
#include <string>
extern “C” {
#include “lualib.h”
#include “lauxlib.h”
}
using namespace std;
size_t l;
const char * reader (lua_State *L, void *data, size_t *size) {
char * result;
* size = l;
if (!l)
result = 0;
else
result = (char *) data;
l = 0;
return result;
}
int main()
{
int result;
lua_State * L;
L = luaL_newstate();
luaL_openlibs(L);
while (true) {
cout << “Введи те строку или на жми те Ctrl-C” << endl;
string s;
cin >> s;
s = “do return “ + s + “ end \0”;
l = s.length() + 1;
result = lua_load(L, reader, &s[0], “calc”);
if (result) {
cout << lua_tostring(L, -1) << endl;
}
else {
result = lua_pcall(L, 0, 1, 0);
if (result != LUA_ERRRUN)
cout << lua_tonumber(L, -1) << endl;
else
cout << lua_tostring(L, -1) << endl;
}
lua_pop(L, 1);
}
lua_close(L);
}
</source>

Программа считывает строку со стандартного потока ввода и пытается вычислить содержащееся в ней математическое выражение (а на самом деле – все, что догадался набрать пользователь, так что будьте осторожны с этим в реальных приложениях!). Наш микрокалькулятор принимает выражения вида 2*(3+4), math.sin(3.14) и им подобные. Работа выполняется в бесконечном цикле, из которого можно выйти с помощью '''Ctrl+C'''.

Обратите внимание, что в программе, написанной на ''C++'', нужно явным образом указать, что функции ''Lua'' API экспортируются в формате ''C''. После того как мы считали строку (переменная '''s'''), нужно скомпилировать ее в функцию ''Lua''. В калькуляторе, написанном на чистом ''Lua'', для этого можно было использовать специальные функции. В ''Lua C'' API такие тоже были (например, '''lua_dostring())''', но теперь они признаны устаревшими. Вместо них следует использовать '''lua_load()''', которая умеет загружать исходный текст программы ''Lua'' из любого источника с помощью специальной вспомогательной функции. В нашем примере это '''reader()'''. При каждом вызове она должна вернуть указатель на новый фрагмент исходного текста программы ''Lua''. Длина очередного фрагмента возвращается в параметре '''size'''. Параметр '''data''' представляет собой указатель на данные, определенные программистом. Функция '''reader()''' сигнализирует о том, что она прочитала весь исходный текст, возвращая значение '''NULL'''. При первом вызове наша функция просто преобразует введенную пользователем программы строку ''C++'' в '''char *''' и возвращает ее длину. При втором вызове '''reader()''' сразу же возвращает '''NULL'''.

Вернемся к '''lua_load()'''. Ее второй параметр – адрес вспомогательной функции для чтения исходного текста, третий – адрес данных для вспомогательной функции. Далее следует строка с именем загружаемого фрагмента (можно передать пустую строку). Обработка ошибок, возникших во время выполнения функции '''lua_load()''', осуществляется так же, как и в случае с '''luaL_loadfile()'''. Аналогично, функция '''lua_load()''' создает выполняемый интерпретатором ''Lua'' фрагмент и помещает его на вершину стека. После завершения '''lua_pcall()''' стек содержит значение, вычисленное нашим калькулятором. В случае ошибки оно будет иметь тип '''nil''', и мы считываем его с верхушки стека с помощью вызова '''lua_tonumber()'''. Если вершина стека содержит нечисловое значение, вызов '''lua_tonumber()''' возвращает '''0'''. После этого нам остается только удалить значение из стека с помощью '''lua_pop()'''.

===И наоборот===

Посмотрим теперь, как вызвать из ''Lua'' функцию, написанную на ''C''. Разумеется, в ''Lua'' нельзя импортировать любую функцию из ''C''-библиотеки – слишком уж разные это языки программирования. Тем не менее, написать ''C''-функцию в «экспортном варианте» оказывается на удивление просто. Рассмотрим сначала исходный текст библиотеки '''testlib''' (файл '''testlib.c'''), написанной на ''C'':

<source lang=c>
#include “lua.h”
#include “lualib.h”
#include “lauxlib.h”
#include <stdlib.h>
static int _system (lua_State *L)
{
int result = system(lua_tostring(L, -1));
lua_pushinteger(L, result);
return 1;
}
int luaopen_testlib(lua_State *L)
{
static const luaL_reg Map [] = {{“system”, _system},
{NULL,NULL}} ;
luaL_register(L, “testlib”, Map);
return 1;
}
</source>

Данная библиотека предоставляет ''Lua'' одну функцию – '''system()'''. Функция '''testlib.system()''' (под этим именем она будет доступна в ''Lua'') делает то же, что и ее тезка из стандартной библиотеки ''C'' (разумеется, в стандартной библиотеке ''Lua'' она тоже есть). Во избежание неоднозначностей, в нашей ''C''-библиотеке экспортируемой функции присвоено имя '''_system()'''.

Чтобы понять, как работает экспорт ''C''-функций, необходимо различать передачу аргументов и возврат значений в контексте ''C'' и те же действия в контексте ''Lua''. Единственным аргументом экспортируемой функции в контексте ''C'' должен быть указатель на структуру '''lua_State''', а возвращаемым значением (в контексте ''C'') – число значений, возвращаемых в контексте ''Lua''. Да, вы правильно поняли: в контексте ''Lua'' экспортируемая функция может получать произвольное количество аргументов различных типов и возвращать любое число значений. Все аргументы и значения в контексте ''Lua'' передаются, разумеется, через стек. Мы считываем единственный аргумент функции '''testlib.system()''' с вершины стека, превращаем его в строку, вызываем ''C''-функцию '''system()''' и помещаем результат выполнения функции в стек ''Lua''. Поскольку в контексте ''Lua'' наша функция всегда возвращает только одно значение, в ''C''-коде мы пишем '''return 1'''.

Чтобы подготовить библиотеку к работе с ''Lua'', нам надо написать еще одну функцию – '''luaopen_libname()''', где '''libname''' соответствует имени библиотеки. Она будет вызвана интерпретатором ''Lua'' при загрузке нашей библиотеки. Именно она позволяет использовать ''C''-библиотеку как стандартный пакет ''Lua''.

Массив '''Map''' состоит из пар «имя функции в контексте ''Lua'' – указатель на ''C''-функцию». Эти данные интерпретатор ''Lua'' будет использовать для вызова функции, написанной на ''C''. Между прочим, поскольку имя функции в библиотеке ''C'' не имеет значения для интерпретатора, функции, в принципе, можно экспортировать и из кода ''C++'', не указывая формат (это не касается '''luaopen_*()''', которую интерпретатор ищет по имени ''C''). Функция '''luaL_register()''' регистрирует новую библиотеку и помещает ссылку на соответствующий объект на вершину стека. Вторым аргументом функции '''luaL_register()''' должно быть имя библиотеки в контексте ''Lua'', которое может и не совпадать с именем разделяемого модуля.

Для компиляции библиотеки скомандуем

gcc testlib.c -shared -o testlib.so

Теперь можно перейти к ''Lua''-коду:

require “testlib”
print(“Вызов функции C”)
res = testlib.system(“/usr/bin/mc”)
if res ~= 0 then
print(“Код завершения программы”, res)
else
print(“Нормальный выход”)
end

Наш модуль '''testlib''' подключается к программе ''Lua'' так же, как и обычные библиотеки ''Lua'' ([[LXF124:LUA|LXF124]]). Обратите внимание, что хотя
в библиотеке '''testlib''' и используются функции ''Lua'' API, при компиляции мы не связываем ее с '''liblua'''. В этом нет необходимости, так как библиотека '''testlib''' будет загружена интерпретатором в то же адресное пространство, что и '''liblua'''. Между прочим, экспортировать функции ''C'' в ''Lua'' можно не только из разделяемых библиотек, но и непосредственно из файла программы, загружающей код ''Lua'' на выполнение. В этом случае нам пригодится другая функция ''Lua'' API – '''lua_register()'''.

Каким образом функция ''C'' может узнать, сколько аргументов ей передано? В этом ей поможет функция '''lua_gettop()''', которая возвращает число элементов в стеке. В момент вызова функции ''C'' оно равно количеству аргументов, переданных функции. Строго говоря, '''lua_gettop()''' возвращает индекс последней ячейки стека, которая в терминологии ''Lua'' именуется вершиной (в описании стека я, как и авторы многих руководств по ''Lua'', придерживался других обозначений: вершина – первый элемент стека). Этой функцией можно пользоваться и для того, чтобы узнать, не переполнен ли стек. Глубина стека ''Lua'' контролируется константой '''MAX_STACK''', значение которой невелико (обычно не больше 32), но для любого разумного использования этого должно быть достаточно. В конце концов, глубина стека математического сопроцессора у Intel составляет всего 8 ячеек.

Встраивание скриптовых языков программирования в пользовательские программы вполне соответствует идеологии Unix, согласно которой все, что может быть настроено пользователем под свои нужды, должно быть не зашито в исходном коде программы, а вынесено в отдельные системы конфигурации. Язык ''Lua'' – простое и мощное средство, позволяющее наделить вашу программу такими возможностями. '''LXF'''

LXF125:Lua - История изменений

Crazy Rebel: викификация, оформление, иллюстрация