|
Edrx's page on Lua, Forth, and in-betweens
Main links (2021):
My init file (with lots of cruft).
A very terse tutorial on Lua made with eepitch blocks.
eoo.lua: my implementation of OO in Lua.
Some classes written with eoo:
Tos, for creating tostring-like functions.
EdrxRepl: a simple REPL.
Uses EdrxPcall.
Also EdrxRepl: a simple REPL.
Also here.
"Boostrapping a Forth in 40 lines of
Lua code" - my article in the Lua
Gems book.
My presentation at the EmacsConf 2020
mentions that eev borrowed some ideas from Forth.
Dednat6: an extensible (semi-)preprocessor for LuaLaTeX
that understands diagrams in ASCII art
BlogMe3 - an extensible language for generating HTML
The rest of this page is very old.
April, 2011: Lua bindings for Retro. See:
January, 2011: http://0branch.com/.
December, 2008: the Lua Gems book was
published (finally!8-), with my article
about "bootstrapping a Forth in 40 lines of Lua code" in it. The
bootstrap-ish Forth described in it, "MiniForth", is not really
usable, but Marc Simpson's RubyForth (e-scripts, ref) is, and my port of it to Lua (tests) is half-done.
I have not cleaned the rest of this page yet! There are still
some fossil parts in it - some 4 or 5 years old -, and most parts are
not dated...
Quick index:
Lua:
- My init file:
LUA_INIT=@$HOME/LUA/lua50init.lua
- At some point I will replace its pretty-printer
by code based on this.
- Notes about Read-Eval-Print loops
- Some programs that I wrote using Lua:
- BlogMe, which generates the HTML of these pages
- Dednat4. As a curiosity, here are two of
its ancestors: the original was a one-hour
hack written in Icon (I don't understand its code anymore), and
dednat, written in Lua.
- BlogMe and Dednat4 were only annouced
"officially" in october 2005.
- The examples that I use for short presentations on Lua are
here and
here.
I still need to join them, sorry.
- tinyftp.lua, that uses luasocket; I used it on w32
boxes at real-world jobs that I had in 2005 and 2006.
- My (very spartan) page on
the Lua Wiki.
- The main Lua links:
- Some articles:
implementation,
filters/sources/sinks,
exceptions,
coroutines,
coroutines again and
again,
VM,
scripting (Ousterhout)
- My even older page about Lua.
- People are discussing in the mailing list about creating a common
stdlua.lua file that
we'd import with a dofile("stdlua.lua") command... I've
been using something like that in my programs: inc.lua. Be warned that it is ugly and changes very often.
1. Running the Lua API interactively from GDB
The relevant code is in this GDB script: PP.gdb. Some functions
in it call global Lua functions - PP and PPeval - that are defined in my $LUA_INIT file.
The first GDB transcript below uses neither PP.gdb nor PP ; the second one uses everything. The e-script that I used to
generate them is here, and here is a screenshot
of Emacs running it (click to enlarge):

echo 'math.sin(0)' > /tmp/foo.lua
|
Current directory is /home/edrx/usrc/lua-5.1.2/src/
Using host libthread_db library "/lib/tls/i686/cmov/libthread_db.so.1".
(gdb) set args /tmp/foo.lua
(gdb) br math_sin
Breakpoint 1 at 0x80673ef: file lmathlib.c, line 32.
(gdb) run
Starting program: /home/edrx/usrc/lua-5.1.2/src/lua_O0 /tmp/foo.lua
Breakpoint 1, math_sin (L=0x8071008) at lmathlib.c:32
(gdb) call lua_pushstring(L, "print")
(gdb) call lua_gettable(L, -10002)
(gdb) call lua_pushstring(L, "Foo!")
(gdb) call lua_pushstring(L, "Bar!")
(gdb) p lua_gettop(L)
$1 = 4
(gdb) call lua_call(L, 2, 0)
Foo! Bar!
(gdb) p lua_gettop(L)
$2 = 1
(gdb)
|
Current directory is /home/edrx/usrc/lua-5.1.2/src/
Using host libthread_db library "/lib/tls/i686/cmov/libthread_db.so.1".
(gdb) source ~/.lua51/PP.gdb
(gdb) quickstart
Breakpoint 1 at 0x80673ef: file lmathlib.c, line 32.
math_sin (L=0x8071008) at lmathlib.c:32
depth
(gdb) $1 = 1
(gdb) PPeval "a = 32"
(gdb) PPeval "= a, a+2"
32 34
(gdb) PPeval "= {a, a+2}, 40"
table: 0x80781b0 40
(gdb) PPeval "== {a, a+2}, 40"
{1=32, 2=34} 40
(gdb) depth
$2 = 1
(gdb) lua_pusheval "20 + 42"
(gdb) depth
$3 = 2
(gdb) PP -1
62
(gdb) depth
$4 = 2
(gdb)
|
2. Gavin Wraith's functional syntax patch
3. Ldb
(From this point on everything is very old...)
Lua for Debian:
- In 2001 I made the first publically-available Debian packages for
Lua (files, e-scripts).
- The current Debian packages are maintained by Daniel Silverstone,
and are excellent. Do:
- I have packaged Lua-4.0 for Debian. My patches and add-ons are in this directory, and there are instructions to compile my package
for other distros here. My package
includes:
- A TeXinfo version of the Lua reference manual (here is the .texi),
- A non-standard interpreter called
dllua that has:
- Reuben Thomas' functions
for bit operations and regexps,
- the
loadlib /unloadlib /callfromlib functions
from CGILua's loadlib.c,
- an extra API function,
dllua_open , that works as
lua_open but also loads all the standard
libraries, plus the bitops/regexps/loadlib libraries, into the
newly-created Lua_State.
Forth:
Forth-like languages interpreted on top of Lua:
- An outdated project: Flua. It has access to the
standard C library and to extensions written in C
and in other languages (see jcw's project Minotaur). I'm
planning to use Flua for the computational part of my ideas
about skeletons of mathematical proofs, and for adding cLIeNUX-like extensions to the Hurd.
- A follow-up to Flua: miniforth, and the bare
beginnings of a technical report on its
main ideas. It has the same goals as Flua, and it is much more
modular; the part that generates bytecodes for an inner
interpreter written in C is kept separate
from the rest.
- Note that both Flua and miniforth are far from being really
usable.
Flua, a Forth-like language written in Lua+C+Nasm:
Important local links:
I gave a minicourse about Lua in 2004 (link?) and I'll give it
again (much updated, of couse!) at the beginning of October/2005, at
http://www.c3sl.ufpr.br/secomp/... Here is the current summary
(in Portuguese only, and still without links):
Curso de Lua
Resumo: Uma "introdução em profundidade" à linguagem de
programação Lua. Como a linguagem é bastante simples (o manual de
referência completo, incluindo a descrição de todas as funções e da
API em C, tem 65 páginas), será possível abordar todos os aspectos
principais da linguagem, e mais algumas extensões, ferramentas, e
várias técnicas de uso.
Tópicos:
- Instalando e rodando o Lua
- O núcleo do Lua:
- Tipos de dados; expressões e statements. Sintaxe. ";"s implícitos.
- Variáveis globais e locais; escopo.
- Tabelas associativas; como arrays, classes e variáveis globais são
implementados via tabelas.
- Funções como objetos; closures; blocos de código; propagação de
erros.
- Bibliotecas padrão:
- Suporte a I/O e arquivos.
- dofile, dostring e require.
- Operações sobre tabelas; modos de percorrer tabelas.
- Operações sobre strings; regexps em Lua.
- Carregando bibliotecas extras com loadlib.
- As entranhas do Lua:
- A biblioteca "debug".
- Byte-compilação, a máquina virtual interna do Lua, a pilha.
- Rodando o Lua passo a passo com gdb; examinando o conteúdo da
pilha. Seguindo passo a passo algumas funções Lua definidas em C.
A API do Lua.
- Executando scripts e funções Lua a partir de C.
- Algumas bibliotecas e extensões: bitlib, pcre, posixlib, luagtk.
- Uma ferramenta para ligar Lua e C mais facilmente: tolua.
Pré-requisitos (aluno): inglês técnico básico (para entender a
documentação), alguma familiaridade com C (para quem quiser acompanhar
a parte final do curso).
Links:
|