Создание встраиваемых сценариев на языке lua

Функции

Вот пример обычной функции.

function add(a, b)
  return a + b
end

print(add(5, 3)) -- напечатает "8"

Функции языка позволяют принимать несколько аргументов, и возвращать несколько аргументов. Так аргументы, значения которых не указаны явно, считаются равными nil.

ПОДУМАЙТЕ: зачем может понадобиться возвращать несколько аргументов?

function swap(a, b)
  return b, a
end

x, y = swap(x, y)
-- кстати, это можно сделать и без функции:
x, y = y, x
-- и если уж функция возвращает несколько аргументов, 
-- а они вам не нужны - игнорируйте их с помощью 
-- специальной переменной-подчеркивания "_"
a, _, _, d = some_function()

Функции могут принимать переменное количество аргументов:

-- в прототипе переменное число аргументов записывается как троеточие
function sum(...) 
   s = 0
   for _, n in pairs(arg) do -- в функции обращаются к ним, как к таблице "arg"
      s = s + n
   end
   return a
end

sum(1, 2, 3) -- вернет 6
sum(1, 2, 3, 4) -- вернет 10

Поскольку функции — это полноценный тип данных, то можно создавать переменные-функции, а можно передавать функции как аргументы других функций

a = function(x) return x * 2 end -- функция, умножающая на 2
b = function(x) return x + 1 end -- функция, увеличивающая на 1

function apply(table, f)
  result = {}
  for k, v in pairs(table) do
    result = f(v) -- заменяем элемент на какую-то функцию от этого элемента
  end
end

-- ПОДУМАЙТЕ: что вернут вызовы
t = {1, 3, 5}
apply(t, a)
apply(t, b)

2001

03 Dec 2001: Lua IRC channel
#lua created at Open Projects Network
(now freenode).
20 Aug 2001: lua-users.org,
a meeting place for Lua users,
is online,
courtesy of John Belmonte.
25 Jul 2001: Lua 4.1 (alpha) released.
(removed; the next version will be 5.0)
29 May 2001: Lua store opens at CafePress.
Use Lua, wear Lua!
(no longer exists)
24 May 2001: Roberto
gives an invited talk on the
history of Lua
at the
V Brazilian Symposium on Programming Languages.
08 May 2001: New
mirror in
Russia,
courtesy of the Chernogolovka Science Center.
(no longer active)
19 Mar 2001: lua.org
is online,
courtesy of Jim Mathies and
Soho One.

Использование

См. также категорию: Программное обеспечение, использующее Lua

В настоящее время используется в различных проектах, где требуется встроить достаточно быстрый и нетрудный в освоении скриптовый язык программирования — например, в разработке игр, где Lua часто используется в качестве прослойки между игровым движком и данными для написания сценариев поведения и взаимодействия объектов. Благодаря компактности применим и в портативных устройствах, в частности один из графических микрокалькуляторов Texas Instruments использует язык вместо традиционного для такого класса устройств Бейсика.

Игры

Первыми в разработку компьютерных игр язык Lua внедрила компания LucasArts, начиная с игры Grim Fandango. Авторы языка в своём докладе на конференции HOPL (англ.)русск. вспоминают, что в январе 1997 они получили сообщение от Брета Могилефски, главного разработчика Grim Fandango, где он писал, что, прочитав о языке в статье 1996 года в Dr. Dobb’s Journal, он планирует заменить используемый ими самодельный скриптовый язык SCUMM на Lua. В результате им был создан игровой движок GrimE, используемый также более поздним квестом от LucasArts — Escape from Monkey Island.

В 2003 году в результате опроса на сайте GameDev.net Lua был признан самым популярным скриптовым языком для разработки игр.

Примером игры, программируемой с помощью Lua, является World of Warcraft. На языке Lua описываются уровни игры-головоломки Enigma.

Доступен ряд свободных игровых движков, программируемых на Lua, таких, как Defold[неавторитетный источник?][значимость факта?], аркадный движок LÖVE, игровой конструктор Novashell и ориентированный на квесты (преимущественно — текстовые) INSTEAD.

Также используется в авиасимуляторе X-Plane, в движке X-Ray для S.T.A.L.K.E.R.

Для популярной игры Minecraft созданы модификации ComputerCraft и его более совершенный аналог OpenComputers, которые добавляют компьютеры, программируемые на языке Lua.

Достаточно известная игра Garry’s Mod программируется, а также поддерживает модификации, написанные на Lua.

Команда Croteam (разработчики Serious Sam и The Talos Principle) используют Lua в скриптах начиная с версии Serious Engine 3.5.

Для игры GTA: San Andreas создаются модификации, написанные на языке Lua и поддерживаемые плагином Moonloader. Также игра Multi Theft Auto поддерживает программирование скриптов на языке Lua.

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

LuaTeX

Программа компьютерной вёрстки LuaTeX, расширенная версия pdfTeX, использует Lua как встроенный скриптовый язык.

Литература

Роберто Иерузалимски. Программирование на языке Lua. — 3-е изд.. — ДМК, 2014. — ISBN 9785940747673. (оригинал: Roberto Ierusalimschy. Programming in Lua. — 3-nd ed.. — 2012. — ISBN 9788590379850.)
Ian Dees. Lua // Seven More Languages in Seven Weeks. Languages That Are Shaping the Future / Bruce Tate, Fred Daoud, Jack Moffitt, Ian Dees. — The Pragmatic Bookshelf, 2015. — С. 1—48. — 320 с. — ISBN 978-1941222157.
Mário Kašuba. Lua Game Development Cookbook. — Packt Publishing, 2015. — 402 с. — ISBN 978-1849515504.
David Young. Learning Game AI Programming with Lua. — Packt Publishing, 2014. — 352 с. — ISBN 978-1783281336.

История языка

Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes. . Reprint from Proceedings of V Brazilian Symposium on Programming Languages (2001) B-14–B-28.. Дата обращения 9 декабря 2011.
Федерико Бьянкуцци, Шейн Уорден. Глава 7. Lua // Пионеры программирования. Диалоги с создателями наиболее популярных языков программирования = Masterminds of Programming: Conversations with the Creators of Major Programming Languages. — Символ, 2011. — С. 211—230. — 608 с. — 1500 экз. — ISBN 9785932861707.

Calling a Function

While creating a Lua function, you give a definition of what the function has to do. To use a method, you will have to call that function to perform the defined task.

When a program calls a function, program control is transferred to the called function. A called function performs the defined task and when its return statement is executed or when its function’s end is reached, it returns program control back to the main program.

To call a method, you simply need to pass the required parameters along with the method name and if the method returns a value, then you can store the returned value. For example −

function max(num1, num2)

   if (num1 > num2) then
      result = num1;
   else
      result = num2;
   end

   return result; 
end

-- calling a function
print("The maximum of the two numbers is ",max(10,4))
print("The maximum of the two numbers is ",max(5,6))

When we run the above code, we will get the following output.

The maximum of the two numbers is 	10
The maximum of the two numbers is 	6

Основные свойства и возможности

Lua — популярный мощный скриптовый язык программирования. Lua в переводе с португальского означает «луна», и это слово не является аббревиатурой или акронимом. Lua разработан подразделением Tecgraf Католического университета Рио-де-Жанейро в Бразилии (Computer Graphics Technology Group of Pontifical Catholic University of Rio de Janeiro), история языка ведёт отсчёт с 1993 года. Lua распространяется свободно, с открытыми исходными текстами на языке Си. Основные особенности языка:

это зрелый, стабильный и популярный язык; Lua используется в промышленных приложениях, и в настоящее время это ведущий язык сценариев в играх;
это один из самых производительных скриптовых языков в принципе;
Lua существует для Linux, Windows и MacOS, а также может быть запущен и на мобильных устройствах;
Lua — компактный и легко встраиваемый язык; имеется документированный API, который позволяет осуществить сильную интеграцию с кодом, написанным на других языках; Lua использовался, чтобы расширить программы, написанные на C, C++, Java, C#, Smalltalk, Фортране, Ада, и даже Perl и Ruby; точно так же можно расширить Lua библиотеками, написанными на других языках;
хотя Lua — не объектно-ориентированный язык в строгом понимании этого термина, он обеспечивает специальные мета-механизмы для того, чтобы реализовать классы и наследование; эти мета-механизмы экономят сущности и сохраняют язык маленьким, позволяя при этом расширить его семантику;
поставка языка компактна; например, поставка Windows x86 Executables имеет размер менее 900 Кб;

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

Чтобы установить Lua на Windows, просто распакуйте бинарный дистрибутив. Можете ассоциировать расширение .lua с интерпретатором lua5.1.exe, а также прописать путь к интерпретатору в PATH.

Основные возможности языка:

есть интерактивный интерпретатор;
можно компилировать скрипты в байт-код;
существует LuaJIT — свободный Just-In-Time компилятор (компилятор «на лету») байт-кода в машинный код (это отдельный продукт).
модульность; код может быть вынесен в отдельные модули (файлы), которые можно подгружать с помощью оператора «require» и обращаться к содержащимся в них переменным и функциям; можно динамически перезагрузить модуль, в случае, если он был изменён с момента загрузки;
мощный механизм ассоциативных массивов (в терминах Lua — таблиц), встроенные функции и удобные синтаксические приёмы для работы с таблицами;
мощный механизм расширения языка с помощью так называемых метатаблиц, позволяющий фактически ввести полноценные объекты и изменить поведение некоторых важнейших стандартных типов данных (например, тех же таблиц);
базовые встроенные функции, позволяющие работать с отладочными сообщениями (assert), выполнить указанный файл скрипта, работать с метатаблицами и модулями, работать с таблицами напрямую (в обход их метатаблиц);
встроенные функции для работы со строками, позволяющие получить массив кодов байтов строки, получить строку из массива кодов байтов, работать с регулярными выражениями, искать вхождения подстрок и получать срезы строк, форматировать строки аналогично printf в Си, получить длину строки, преобразовать регистр символов строки, получить результат конкатенации указанного количества копий исходной строки, осуществить реверсинг строки;
встроенные математические функции: модуль, целая часть (ceil, floor), (гиперболические) (арк)синус, (арк)косинус и (арк)тангенс, остаток от деления, перевод угла из радиан в градусы и обратно, степень, экспонента, натуральный и десятичный логарифм, случайные числа, квадратный корень, константа pi;
встроенные функции для ввода-вывода на консоль и в файлы, работы с датой-временем, вызова команд системы, работы с файлами;
встроенные функции для интерактивной отладки.

Некоторые полезные ресурсы:

Русскоязычный сайт по Lua (документация, форум);
небольшой учебник по Lua (рус.);
уроки по использованию Lua совместно с С++ (рус.);
Lua-Alchemy — порт языка программирования Lua на платформу Adobe Flash при помощи Alchemy (англ.);
LuaForge — сайт сообщества Lua, каталог проектов (англ.);
небольшой FAQ по Lua (англ.).

Реализация

Как и многие интерпретируемые языки программирования, реализация Lua имеет отдельно компилятор с исходного языка в исполняемый байт-код и виртуальную машину для исполнения сгенерированного байт-кода. Причём байт-код — это не команды стековой машины, а команды некоего виртуального процессора с несколькими регистрами, что повышает эффективность исполнения. В стандартной виртуальной машине Lua используется распределение памяти со сборкой мусора (аналогично Java или .NET).

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

Для задач, критичных по времени, имеется JIT-компилятор Lua — LuaJIT. Также разработан компилятор llvm-lua, генерирующий код для виртуальной машины LLVM, предоставляющей возможность последующей компиляции в очень эффективный машинный код для процессоров различной архитектуры.

Объекты = функции + таблицы

Раз мы можем сохранять функции в переменных, то и в полях таблиц тоже сможем. А это уже получаются как-бы-методы. Для тех, кто не знаком с ООП скажу, что основная его польза (по крайней мере в Lua) в том, что функции и данные, с которыми они работают находятся рядом — в пределах одного объекта. Для тех, кто знаком с ООП скажу, что классов здесь нет, а наследование прототипное.

Перейдем к примерам. Есть у нас объект, скажем, лампочка. Она умеет гореть и не гореть. Ну а действия с ней можно сделать два — включить и выключить:

lamp = {
  on = false
}

function turn_on(l)
  l.on = true
end

function turn_off(l)
  l.on = false
end

-- это просто функции для работы со структурой
turn_on(lamp)
turn_off(lamp)

А если лампочку сделать объектом, и функции turn_off и turn_on сделать полями объекта, то получится:

lamp = {
  on = false
  turn_on = function(l) l.on = true end
  turn_off = function(l) l.on = false end 
}
lamp.turn_on(lamp)
lamp.turn_off(lamp)

Мы вынуждены передавать сам объект лампочки в качестве первого аргумента, потому что иначе наша функция не узнает с какой именно лампочкой надо работать, чтобы сменить состояние on/off. Но чтобы не быть многословными, в Lua есть сокращенная запись, которую обычно и используют — lamp:turn_on(). Итого, мы уже знаем несколько таких упрощений синтаксиса:

lamp:turn_on() -- самая общепринятая запись
lamp.turn_on(lamp) -- то с точки зрения синтаксиса это тоже правильно
lamp(lamp) -- и это

Продолжая говорить о сокращениях, функции можно описывать не только явно, как поля структуры, но и в более удобной форме:

lamp = {
  on = false
}

-- через точку, тогда аргумент надо указывать
function lamp.turn_on(l) l.on = true end

-- через двоеточкие, тогда аргумент неявно задается сам, как переменная "self"
-- "self" - и есть та лампочка, для которой вызвали метод
function lamp:turn_off() self.on = false end

Интересно?

Lua великолепен

Lua — это чрезвычайно легкий в использовании язык, но его простой синтаксис маскирует его мощь: язык поддерживает объекты (аналогичные объектам Perl), мета-таблицы делают его тип table абсолютно гибким, а C API разрешает отличную интеграцию и расширение сценариев и базового языка. Lua может использоваться совместно с языками C, C++, C#, Java и Python.

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

Встроить и расширить

Кроме простого синтаксиса и мощной структуры таблиц, реальная мощь Lua очевидна при использовании его совместно с базовым языком. Как уже говорилось, Lua-сценарии могут расширить собственные возможности базового языка. Но справедливо также и обратное — базовый язык может одновременно расширять Lua. Например, C-функции могут вызывать Lua-функции и наоборот.

Сердцем симбиотического взаимодействия между Lua и его базовым языком является виртуальный стек. Виртуальный стек (как и реальный) является структурой данных «последний вошел — первый вышел» (last in-first out — LIFO), которая временно сохраняет аргументы функции и ее результаты. Для вызова из Lua базового языка (и наоборот) вызывающая сторона помещает значения в стек и вызывает целевую функцию; принимающая сторона достает аргументы из стека (конечно же, проверяя тип и значение каждого аргумента), обрабатывает данные и помещает в стек результаты. Когда управление возвращается вызывающей стороне, она извлекает значения из стека.

Фактически, все С-интерфейсы прикладного программирования (API) для Lua-операций работают через стек. Стек может хранить любое Lua-значение; однако тип значения должен быть известен как вызывающей стороне, так и вызываемой, а конкретные функции помещают в стек и извлекают из него каждый тип (например, и ).

В листинге 2 показана простая C-программа (взятая из главы 24 книги «Программирование в Lua», ссылка на которую приведена в разделе «»), реализующая минимальный, но функциональный Lua-интерпретатор.

Листинг 2. Простой Lua-интерпретатор

 1 #include <stdio.h>
 2 #include <lua.h>
 3 #include <lauxlib.h>
 4 #include <lualib.h>
 5
 6 int main (void) {
 7   char buff;
 8   int error;
 9   lua_State *L = lua_open();   /* открывает Lua */
10   luaopen_base(L);             /* открывает основную библиотеку */
11   luaopen_table(L);            /* открывает библиотеку table */
12   luaopen_io(L);               /* открывает библиотеку I/O */
13   luaopen_string(L);           /* открывает библиотеку string */
14   luaopen_math(L);             /* открывает библиотеку math */
15
16   while (fgets(buff, sizeof(buff), stdin) != NULL) {
17     error = luaL_loadbuffer(L, buff, strlen(buff), "line") ||
18             lua_pcall(L, 0, 0, 0);
19     if (error) {
20       fprintf(stderr, "%s", lua_tostring(L, -1));
21       lua_pop(L, 1);  /* извлечь сообщение об ошибке из стека */
22     }
23   }
24
25   lua_close(L);
26   return 0;
27 }

Строки с 2 по 4 включают стандартные Lua-функции, несколько удобных функций, используемых во всех Lua-библиотеках, и функции для открытия библиотек, соответственно. Строка 9 создает Lua-структуру. Все структуры сначала пусты; вы добавляете библиотеки или функции к структуре при помощи , как показано в строках с 10 по 14.

В строке 17 принимает входную информацию с в виде порции и компилирует ее, помещая порцию в виртуальный стек. Строка 18 извлекает порцию из стека и выполняет ее. Если во время исполнения возникает ошибка, Lua-строка помещается в стек. Строка 20 обращается к вершине стека (вершина стека имеет индекс ) как к Lua-строке, распечатывает сообщение и удаляет значение из стека.

Используя C API, ваше приложение может также «достать» информацию из Lua-структуры. Следующий фрагмент кода извлекает две глобальные переменные из Lua-структуры:

..
if (luaL_loadfile(L, filename) || lua_pcall(L, 0, 0, 0))
  error(L, "cannot run configuration file: %s", lua_tostring(L, -1));

lua_getglobal(L, "width");
lua_getglobal(L, "height");
..
width = (int) lua_tonumber(L, -2);
height = (int) lua_tonumber(L, -1);
..

Опять же, обратите внимание на то, что передачу разрешает стек. Вызов любой Lua-функции из C аналогичен следующему коду: извлечь функцию при помощи , поместить аргументы, выполнить и обработать результаты

Если Lua-функция возвращает n значений, первое значение находится по индексу -n в стеке, а последнее — по индексу -1.

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

Специальные функции

Некоторые имена функций таблиц (методов) зарезервированы, и они несут особый смысл:

* __add(a, b), __sub(a, b), __div(a, b), __mul(a, b), __mod(a, b), __pow(a, b) — вызываются, когда выполняются арифметические операции над таблицей
* __unm(a) — унарная операция «минус» (когда пишут что-то типа «x = -x»)
* __lt(a, b), __le(a, b), __eq(a, b) — вычисляют результат сравнения (<, <=, ==)
* __len(a) — вызывается, когда делается «#a»
* __concat(a, b) — вызывается при «a..b»
* __call(a, …) — вызывается при «a()». Переменные аргументы — это аргументы при вызове
* __index(a, i) — обращение к a, при условии, что такого элемента не существует
* __newindex(a, i, v) — создание «a = v»
* __gc(a) — когда объект удаляется при сборке мусора

Подменяя эти методы, можно перегружать операторы и использовать синтаксис языка для своих целей. Главное не переусердствовать.

IDE

Существует как минимум две «родные» среды разработки для Lua, это:

ZeroBrane Studio — мультиплатформенная среда разработки, написанная на самом Lua.
Decoda — среда разработки под Windows, написанная на C++, с богатыми возможностями отладки Lua-скриптов, в том числе в работающих приложениях. На 2018 год последний выпуск среды датируется 2014 годом и имеет статус beta-версии.

Кроме того, Lua поддерживается некоторыми универсальными IDE, в частности:

Geany
Lua Development Tools для среды Eclipse
Плагин EmmyLua для среды IntelliJ IDEA, также оснащенный проверкой синтаксиса «на лету» и развитой системой аннотаций типов

Существовал модуль поддержки Lua для среды NetBeans, но его развитие прекратилось в 2013 году и он доступен только для версии NetBeans 7.4 и более ранних. В NetBeans 8 плагин не поддерживается.

2007

20 Dec 2007

Launched campaign to

18 Dec 2007

Reference manual available in
Spanish.

09 Dec 2007

Lua Workshop 2008
to be held at George Washington University in Washington, D.C.,
courtesy of Matthew Burke.
Read the
preliminary announcement.

10 Sep 2007

Reference manual available in
Portuguese.

28 Aug 2007

Article on LuaView
appears in
LabVIEW World
(in Italian).

23 Aug 2007

Article
«Traveling light, the Lua way»
by Ashwin Hirschi
appears in
IEEE Software.

Read a
review.

05 Aug 2007

Lua climbs to position 15 in the
TIOBE Programming Community Index.

17 Jul 2007

Workshop
on
LuaTeX
held at
TUG 2007.
Watch the
videos of the talks.

08 Jul 2007

Lua climbs to position 18 in the
TIOBE Programming Community Index.

25 Jun 2007

Korean translation
of
Programming in Lua
published.

09 Jun 2007

Paper on
the evolution of Lua
presented at the
Third
ACM SIGPLAN History of Programming Languages Conference
(HOPL III),
a part of .
See the
slides
and the
video.

09 May 2007

Article on Lua
to appear in
Linux Journal.

28–29 Apr 2007

Scheduled maintenance at lua.org.
Mirror site at PUC-Rio
activated during downtime.

02 Apr 2007

Lua 5.1.2
released.
This is a bug-fix release.

06 Mar 2007

Lua climbs to position 25 in the
TIOBE Programming Community Index.

20 Feb 2007

Mailing list
turns 10.
Read the
announcement.

01 Feb 2007

43 abstracts selected
for
Lua Programming Gems.

Explicit File Descriptors

We often use explicit file descriptor which allows us to manipulate multiple files at a time. These functions are quite similar to implicit file descriptors. Here, we use file:function_name instead of io.function_name. The following example of the file version of the same implicit file descriptors example is shown below.

-- Opens a file in read mode
file = io.open("test.lua", "r")

-- prints the first line of the file
print(file:read())

-- closes the opened file
file:close()

-- Opens a file in append mode
file = io.open("test.lua", "a")

-- appends a word test to the last line of the file
file:write("--test")

-- closes the open file
file:close()

When you run the program, you will get a similar output as the implicit descriptors example.

-- Sample test.lua

All the modes of file open and params for read for external descriptors is same as implicit file descriptors.

Other common file methods includes,

file:seek(optional whence, optional offset) − Whence parameter is «set», «cur» or «end». Sets the new file pointer with the updated file position from the beginning of the file. The offsets are zero-based in this function. The offset is measured from the beginning of the file if the first argument is «set»; from the current position in the file if it’s «cur»; or from the end of the file if it’s «end». The default argument values are «cur» and 0, so the current file position can be obtained by calling this function without arguments.
file:flush() − Clears the default output buffer.
io.lines(optional file name) − Provides a generic for loop iterator that loops through the file and closes the file in the end, in case the file name is provided or the default file is used and not closed in the end of the loop.

An example to use the seek method is shown below. It offsets the cursor from the 25 positions prior to the end of file. The read function prints remainder of the file from seek position.

-- Opens a file in read
file = io.open("test.lua", "r")

file:seek("end",-25)
print(file:read("*a"))

-- closes the opened file
file:close()

You will get some output similar to the following.

sample2 test.lua
--test

You can play around all the different modes and parameters to know the full ability of the Lua file operations.

Previous Page
Print Page

2017

16–17 Oct 2017

Lua Workshop 2017
held in San Francisco.

16 Aug 2017

Roberto
participates in
Seminбrio Inovanзas
at the
Museum of Tomorrow in Rio.

24 Jul 2017

Lua Workshop 2017
to be held in San Francisco, CA,
courtesy of Kong.

05 Jul 2017

Added
showcase page.

20 Jun 2017

Roberto
gives a keynote at
Curry On 2017.
Watch the
video.

03 Jun 2017

LuaConf 2017
held in Rio de Janeiro.

25 Apr 2017

Fourth edition of
Programming in Lua
available as
e-book.

25 Apr 2017

Lua features in the
«Inovanзas – Creations Brazilian style»
exhibition at
the
Museum of Tomorrow in Rio.

Watch the
welcome video
and read the
catalog.

23 Mar 2017

Roberto
will give a keynote at
Curry On 2017
in June.

05 Mar 2017

Lua in Moscow Conference 2017
held in Moscow.

20 Feb 2017

Mailing list
turns 20.
Read the
announcement.

30 Jan 2017

Lua 5.3.4
released.
This is a bug-fix release.
See the diffs.

08 Jan 2017

LuaConf 2017
to be held in June.
Read the
announcement.

2006

24 Nov 2006: Released
call for contributions
to Lua Programming Gems.
06 Oct 2006: German translation
of
Programming in Lua
published.
05 Oct 2006: Lua entered the top 50 in the
TIOBE Programming Community Index.
04–05 Sep 2006: Lua Workshop 2006
held at Ocй.
See
photos
and
videos.
17 Aug 2006: Reference manual
available as a book.
Buy a copy
and
help to support
the Lua project.
06 Jul 2006: Created official page for the
Lua Workshop 2006.
30 Jun 2006: A
poll
at
GameDev.net
shows Lua as the favorite embeddable scripting language.
26 Jun 2006: Lua 5.0.3
released.
This is a bug-fix release.
09 Jun 2006: Lua 5.1.1
released.
This is a bug-fix release.
03 Jun 2006: Lua elected for
.
23 Mar 2006: of
Programming in Lua
published.
21 Feb 2006: Lua 5.1
released.
Check out its
.
15 Feb 2006: Lua Workshop 2006
to be held at the Ocй R&D site in Venlo (NL),
courtesy of Wim Couwenberg.
Read the
announcement.
23 Jan 2006: Some
audio recordings
from the
Lua Workshop 2005 available,
courtesy of Shannon Bailey.
Read the original
announcement
(but note that the URL has changed).

2003

15 Dec 2003

The book
Programming in Lua
by Roberto Ierusalimschy is published.

27 Nov 2003

Added page listing
individuals and institutions that have supported Lua.

25 Nov 2003

Lua 5.0.1
released.
This is a bug-fix release.

08 Nov 2003

Roberto
gives a

about the innards of Lua at
Lightweight Languages 2003.
See the
slides.

29 Sep 2003

A
poll
at
GameDev.net
shows Lua as the most popular language for game scripting.

16 Jun 2003

Added page listing
all known bugs
in Lua since Lua 4.0.

07 Jun 2003

Roberto
gives an
invited talk
on Lua at the
IV Forum Internacional Software Livre.
See the
slides.

19 May 2003

Mirror of mailing list at Yahoo! Groups closed down.

14 May 2003

Mailing list
has a new
home,
courtesy of
Conectiva
and Gustavo Niemeyer.
(moved to lists.lua.org)

06 May 2003

Added a
version history page
listing the main features in each version.

11 Apr 2003

Lua 5.0
released.
Check out its
.

10 Mar 2003

11 Feb 2003

Added page listing
recent changes
in the site
and an
RSS feed.

05 Feb 2003

Lua web forums
created at Icy North Technologies,
courtesy of Brett Kapilik.
(moved to LuaHUB)

14 Jan 2003

The Year in Scripting Languages
released. It contains a review of what happened to Lua in 2002.

Lua как встроенный язык текстового редактора SciTE

Как пример рассмотрим использование Lua в текстовом редакторе SciTE.

SciTE — мощный кросс-платформeнный (Win32, Linux) популярный текстовый редактор с открытым исходным кодом. Русскую сборку SciTE со множеством полезных дополнений и подробной русской документацией вы можете взять здесь (редактор не требует инсталляции в обычном понимании этого слова; дистрибутив является просто самораспаковывающимся архивом). SciTE Lua Scripting Extension в качестве языка сценариев использует Lua 5.1.

Изложенное ниже ни в коем случае не является руководством по настройке SciTE с помощью Lua; это лишь маленький пример, показывающий, как может выглядеть использование Lua как встроенного языка. Для получения информации обращайтесь к документации в поставке SciTE, а также изучайте файлы конфигурации и уже существующие в поставке скрипты. Примеры скриптов Lua для SciTE и документацию по этому вопросу вы можете найти здесь и здесь, а также в вышеупомянутой русской сборке SciTE (там же есть и русская документация). С помощью написания сценариев на Lua вы можете настроить SciTE под ваши потребности, добавляя новое поведение и функциональность.

Вы можете объявить новые команды, которые доступны через меню Tools и клавиатуру. Например, в файл настроек SciTEGlobal.properties в каталоге установки SciTE можно поместить следующие команды:

# имя команды №200 в меню "Tools":
command.name.200.*=Запустить мой скрипт
# подсистема Lua, не запрашивать сохранение текущего файла перед запуском:
command.mode.200.*=subsystem:lua,savebefore:no
# выполнить скрипт Lua из файла:
command.200.*=dofile $(SciteDefaultHome)\tools\myScript.lua

В результате в меню «Tools» появится команда «Запустить мой скрипт», при выборе которой исполнится скрипт \tools\myScript.lua, если он существует по такому пути в папке установки SciTE. Чтобы проверить работу скрипта, сохраните в нём текст наподобие следующего:

print('запущен')

Теперь в любой момент при вызове меню «Запустить мой скрипт» вы будете получать сообщение в нижней панели редактора.

Вы можете обрабатывать события, объявленные в интерфейсе расширений SciTE (SciTE Extension Interface), просто объявляя функции с именами этих событий: OnOpen, OnClose, OnSwitchFile и т.д. Для некоторых событий SciTE передаёт один или несколько аргументов в функцию обработки события. Обработчики событий возвращают булево значение (true показывает, что событие полностью обработано и другие обработчики не будут вызываться; в большинстве случаев обработчик должен вернуть false).

В файле \tools\SciTEStartup.lua в каталоге установки SciTE с помощью функции dofile грузятся скрипты, обрабатывающие события редактора (этот файл стартует при загрузке SciTE). Вы можете загрузить и свой скрипт, добавив в этот файл команду наподобие следующей:

dofile (props.."\\tools\\myScript.lua")

Чтобы проверить работу скрипта \tools\myScript.lua, сохраните в нём текст наподобие следующего:

function OnChar(code)
    print('Вы ввели: ' .. code)
    return false
end

Теперь, после перезапуска SciTE, будет обрабатываться событие OnChar, в результате чего вы будете получать сообщение в нижней панели редактора при вводе каждого символа.

SciTE добавляет в глобальный контекст Lua ряд переменных, функций и объектов (таблиц), которые позволяют управлять редактором и изменять его внешний вид.