Lil is a small, highly dynamic programming language designed as an extension language with minimal syntax and around 50 core functions. It allows for easy embedding within host programs and supports runtime modifications, including the creation and redefining of functions. The language is easy to integrate using a simple API and is suitable for various applications, including game logic and server responses.

1. The LIL Language
What is LIL

2. What is LIL
 LIL is a small programming language
 LIL stands for Little Interpreted Language
 Focused on being an extension language
 Highly dynamic
 Minimal syntax
 Easy to embed

3. LIL is small
 A small core set of functions (about 50)
 String handling
 Lists
 Flow control
 etc
 A pair of .c and .h files
 About 3000 lines of C source code
 Could be smaller, but had to be usable :-)
 The ”lil” executable is ~40K (Linux x86)

4. Extension languages
 A language to write extensions for a host
program
 Extensions depend on the program but most
complex programs can be extended via scripts
 A wizard for an office application
 The logic for a game character
 Responses for web requests in a server
 A text editor script to convert a set of ”#define” lines
to ”case” lines for C code which return a string with
the constant's name without some prefix
 I need this more often than i would want...

5. LIL is an extension language
 A host can extend the language by providing
new functions
 in LIL everything is done via functions, including
control structures like if, for, while, etc
 a function can execute code passed as a function
argument, set a new local or global variable, create
new execution environments, etc
 Listen to callbacks for I/O, errors, exit requests,
writing and reading to variables, etc
 I/O callbacks can be used to sandbox script
 Variable callbacks can expose host variables

6. LIL is highly dynamic
 No separate compilation and execution step
 The runtime can be modified at any time
 New variables can be introduced
 New functions can be defined – or redefined
 Functions can be renamed – including natives
 The runtime can be inspected via reflection
 All code and data is stored as strings and
converted to the appropriate type when needed
 Code can be generated and is evaluated lazyly
 String functions can be used with, e.g. lists

7. LIL has minimal syntax
 Everything follows a simple format:
word1 word2 word3 … wordn
 For commands the first word is the function name
and the rest are the function arguments
 Words are separated by space, but they can
contain special characters and/or be inside
special quotes (single quotes, double quotes,
braces and brackets)
 Words can contain spaces or other special
characters, including – if escaped properly –
characters with a special meaning for LIL

8. LIL has minimal syntax (cont.)
 Single and double quotes can be used to
include spaces and/or escaping characters
 A command inside [ and ] is executed and its
result is used in place of the […]
 Anything inside { and } is used as-is
 however LIL will count the {s and }s so that they can
be nested
 $ followed by a word evalutes to a variable read
 this can be changed at runtime to do other things
 And that is it. See LIL's readme.txt for details

9. LIL is easy to embed
 Uses a readable and permissive license: zlib
 Written in C89 with few common C99 features
 Can be used as a shared or static library
 or just drop the lil.c and lil.h pair in your project
 Small API to learn with few simple calls needed
for practical use
 Can be used with C and C++ directly and from
languages which support C shared libraries
 Import LIL is a project that provides bindings for
Free Pascal and .NET (and others in the future)

10. Some examples
LIL language examples

11. LIL examples
 Mandatory hello world
print Hello, world
 Notice how quotes are not needed
 Error-try-catch
try { if stuff { error ”Bad stuff” } } { print
Got an error: [reflect error] }
 Factorial of 10
print [[func {x} { if [expr $x == 1] { return 1
} { return [expr [[reflect name] [expr $x ­ 1]]
* $x] }}] 10]

12. LIL examples (cont.)
# print all known functions with name lengths
# less than five characters
set known­funcs [reflect funcs]
set predicate {[length $x] < 5}
set small­funcs [filter $known­funcs $predicate]
print "Functions with small names:"
foreach $small­funcs {print " $i"}

13. C API examples
 Create and destroy a LIL runtime
lil_t lil = lil_new();
/* do stuff here */
lil_free(lil);
 Run some LIL code
lil_free_value(lil_parse(lil,”print hi”,0,0));
 Register a custom function
lil_register(lil, ”newfunc”, fnc_newfunc);
 fnc_newfunc is defined in the next slide

14. C API examples (cont.)
/* myfunc native function */
LILCALLBACK lil_value_t fnc_myfunc(
lil_t lil, /* lil runtime */
size_t argc, /* number of arguments */
lil_value_t* argv) /* arguments array */
{
size_t i;
printf(”I've got %i arguments:”, (int)argc);
for (i=0; i<argc; i++)
printf(” '%s'n”,
lil_to_string(argv[i]));
return lil_alloc_string(”myfunc result!”);
}

15. print ”That was it”
That was it

16. More information
 LIL at github: https://github.com/badsector/lil
 Latest source code
 Wiki
 Issue db
 The readme.txt file in LIL's source code
 Everything about LIL
 Syntax
 Reference
 Import LIL: https://github.com/badsector/implil
 Bindings for Free Pascal, .NET and maybe others