Edrx's page on Lua, Forth, and in-betweens

Main links (2024):
 
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. It is very REPL-friendly, sort of like SmallTalk.
All my recent programs in Lua are documented using test blocks. Some examples:
    Repl3 (2024) - see its section on testing code,
    find-luaso-links (2024), REPLs in strange places (2023), a repl for TikZ (2022),
    luatree (for Maxima), Pict2e-lua, emlua.
Some classes written with eoo:
    Tos, for creating tostring-like functions.
    Repl1, Repl2, Repl3: several REPLs.
    LpegRex2: some tests for lpegrex,
    Gram1 (screenshot): build lpeg grammars incrementally.
    ELpeg1: similar, but with many features from lpegrex; see this.
 
"Boostrapping a Forth in 40 lines of Lua code" (PDF) - 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:

http://rx-core.org/rx.fossil/index
http://rx-core.org/dev/retrolua.fossil/index
http://anggtwu.net/RETRO/

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...

• 1. Running the Lua API interactively from GDB
• 2. Gavin Wraith's functional syntax patch
• 3. Ldb

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 (rmt).
• The main Lua links:
  • http://www.lua.org/ (rmt), http://lua-users.org/ (rmt)
  • http://lua-users.org/lists/lua-l/ (rmt) - mailing list archives (gmane)
  • http://lua-users.org/wiki/ (rmt) - a Wiki about Lua
  • http://www.lua.org/pil/ (rmt) (e-script)
  • http://www.keplerproject.org/ (rmt)
  • Sputnik, and its mailing list
  • http://lua-users.org/wiki/LuaNews
• Some articles: implementation (rmt), filters/sources/sinks (rmt), exceptions (rmt), coroutines (rmt), coroutines again (rmt) and again (rmt), VM (rmt), scripting (Ousterhout) (rmt)
• My even older page about Lua.
• People are discussing in the mailing list (rmt) 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.

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

# (find-es "lua5" "lua-api-from-gdb")
# (find-angg ".lua51/PP.gdb")
# (find-angg ".emacs" "eepitch-gdb-lua")
# (find-eevarticlesection "eepitch-gud")

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) 

# (find-es "lua5" "risclua")
# (find-es "lua5" "minimal_GCW_SUGAR")
# (find-es "lua5" "install-5.1.3")
# (find-es "lua5" "install-5.2")
# (find-angg "bin/patch-lua-5.1.3")
# (find-angg "bin/patch-lua-5.2")

# (find-es "davinci" "ldb-rewriting-functions")
# (find-es "lua5" "ldb-from-tgz")
# (find-es "lua5" "ldb")

Lua for Debian:

• In 2001 (rmt) 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:
  • apt-get install liblua50 liblualib50 lua50
  • apt-get install liblua50-dev liblualib50-dev lua50-doc
• 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 (rmt) (here is the .texi),
  • A non-standard interpreter called dllua that has:
    • Reuben Thomas' (rmt) functions for bit operations and regexps,
    • the loadlib/unloadlib/callfromlib functions from CGILua (rmt)'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:

• The Forth world has largely split into a pro-ANSForth half (which is the bad half, so no links) and an anti-ANSForth half, for which http://www.ultratechnology.com/ (rmt) is a good starting point. Other interesting links:
  • Forth pages at c2.com (rmt)
  • http://www.thelma-louise.net/ (rmt) - Peter Appelman's page
  • Myron Plichota's Forth-based, hobbyist-friendly processors (rmt)
  • http://forthlinks.com (rmt)
  • http://www.retroforth.org/ (rmt)
  • http://galileo.phys.virginia.edu/classes/551.jvn.fall01/ (rmt)
• 2007feb02: a good link about ColorForth: http://www.inventio.co.uk/. It should be possible to run cfdos.com from qemu - more on this later...
• My (old) page about 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 (rmt)'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 (rmt)-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:

• e-scripts on running flua
• the e-scripts I use to upload flua :)
• Flua itself - the files whose names start with "demo" are generated automatically when we run "make v".
  • http://anggtwu.net/flua/flua-0.03.tar.gz
  • http://anggtwu.net/flua/
  • http://anggtwu.net/LUA/flua-0.02.tar.gz
  • http://anggtwu.net/LUA/flua-0.02/
  • http://anggtwu.net/LUA/flua-0.01.tar.gz
  • http://anggtwu.net/LUA/flua-0.01/
  • A good starting point is flua_demo1_old} this.
• Flua is the newest incarnation of the Crim project; see my Forth page for some old docs, and my Crim page for some VERY old docs that may contain some interesting things about the RSR words and the third stack.

Important local links:

• I have converted the Lua manual to TeXinfo format: browse it
• About the Debian package of Lua, that contains the TeXinfo'ed manual, Reuben Thomas' regexps+bitops patch, and other goodies:
  • lua
  • lua
  • lua (about installing it in any GNU system)
• LUA/
• LUA/inc.lua
• A tool for TeXing proof trees:
  • LUA/dednat.lua
  • How my ~/LATEX/Makefile uses it
  • My TeX page says something about its predecessor, dednat.icn.

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/ (rmt)... 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.

• 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).

• http://www.lua.org/ftp/refman-5.0.ps.gz (rmt)
• http://www.lua.org/pil/ (rmt)
• http://umn.dl.sourceforge.net/sourceforge/lua-users/shortref-d2.pdf (rmt)
• http://umn.dl.sourceforge.net/sourceforge/lua-users/luaapiref-d1.pdf (rmt)