There is increasing demand for customizable applications. As applications became more complex, customization with simple parameters became impossible: users now want to make configuration decisions at execution time; users also want to write macros and scripts to increase productivity [1, 2, 3, 4]. In response to these needs, there is an important trend nowadays to split complex systems in two parts: kernel and configuration. The kernel implements the basic classes and objects of the system, and is usually written in a compiled, statically typed language, like C or Modula-2. The configuration part, usually written in an interpreted, flexible language, connects these classes and objects to give the final shape to the application .
Configuration languages come in several flavors, ranging from simple languages for selecting preferences, usually implemented as parameter lists in command lines or as variable-value pairs read from configuration files (e.g., MS-Windows' .ini files, X11 resource files) to embedded languages, for extending applications with user defined functions based on primitives provided by the applications. Embedded languages can be quite powerful, being sometimes simplified variants of mainstream programming languages such as Lisp and C. Such configuration languages are also called extension languages, since they allow the extension of the basic kernel semantics with new, user defined capabilities.
What makes extension languages different from stand alone languages is that they only work embedded
in a host client, called the host program. Moreover, the host program can usually provide
domain-specific extensions to customize the embedded language for its own purposes, typically by providing
higher level abstractions. For this, an embedded language has both a syntax for its own programs
and an application program interface (API) for communicating with hosts. Unlike simpler configuration
languages, which are used to supply parameter values and sequences of actions to hosts, there is a
two-way communication between embedded languages and host programs.
It is important to note that the requirements on extension languages are different from those on general purpose programming languages. The main requirements for extension languages are:
ffl extension languages need good data description facilities, since they are frequently used as configuration languages;
ffl extension languages should have a clear and simple syntax, because their main users are not professional programmers;
ffl extension languages should be small, and have a small implementation. Otherwise, the costs of adding the library to an application may be too high;
ffl extension languages are not for writing big pieces of software, with hundreds of thousands lines. Therefore, mechanisms for supporting programming-in-the large, like static type checking, information hiding, and exception handling, are not essential;
ffl finally, extension languages should also be extensible. Unlike conventional languages, extension languages are used in a very high abstraction level, adequate for interfacing with users in quite diverse domains.
This paper describes Lua, an extensible procedural language with powerful data description facilities, designed to be used as a general purpose extension language. Lua arose as the fusion of two descriptive languages, designed for the configuration of two specific applications: one for scientific data entry , the other for visualizing lithology profiles obtained from geological probes. When users began to demand increasingly more power in these languages, it became clear that real programming facilities were needed. Instead of upgrading and maintaining two different languages in parallel, the solution adopted was to design a single language that could be used not only for these two applications, but for any other application. Therefore, Lua incorporates facilities common to most procedural programming languages | control structures (whiles, if s, etc), assignments, subroutines, and infix operators | but abstracts out facilities specific to any particular domain. In this way, Lua can be used as a complete language or as a language framework.
Lua satisfies the requirements listed above quite well. Its syntax and control structures are quite simple, Pascal-like. Lua is small; the whole library is around six thousand lines of ANSI C, of which