clyne/interpreter
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update README.md

Browse Source
This commit is contained in:
Clyne Sullivan 2018-03-25 22:00:14 -04:00
parent ee4cfcdd2f
commit 2f3ffd1109
1 changed files with 28 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
README.md
View File

@ -1,24 +1,36 @@
# interpreter
This project aims to provide a very minimal scripting language for embedded systems. Many other languages already exist, such as Lua, Tcl, or BASIC; however, most implementations require certain system calls like read() and write(), as they expect a filesystem. This interpreter wants to be as system-independent and portable as possible: parsing script from strings one at a time, having minimal built-in functions (so the user can define their own IO calls and such), and only requiring a few standard library functions.
To use this program with your own device, you'll need some malloc/free implementation, and a freestanding standard library. Newlib works well for this; however, functions like atoi() and snprintf() will probably need to be rewritten (if you don't have an \_sbrk defined).
Interpreter features:
* Variable/function definition - in C and in script
* if/else and while loops
* a solve function to parse strings at runtime
Inconvenient features:
* no local variables
* whitespace sometimes ignored
*interpreter* is a minimal scripting language aimed at low-spec embedded systems.
Many other scripting languages currently exist for embedded use, including Lua, Tcl, and BASIC; however, their implementations require certain system calls (e.g. read()/write()) that may not be available or used on an embedded device. As a result, *interpreter* was made with the goal to allow advanced scripts to be run in minimal conditions. This included things like having only a few built-in functions, and only loading script from C-strings one at a time.
Some TODO items:
To use *interpreter* with your own device, you will need some malloc/free implementation and a freestanding standard library. Newlib can work well for this, although functions like atoi() and snprintf() will probably need to be rewritten (if you don't have an \_sbrk defined).
### interpreter features:
* Variable/function definition - in C and in script
* if/else conditionals
* while loops
* a solve function to parse strings at script runtime
### inconvenient features:
* some code formatting is enforced due to parser limitation
* all variables are global
* whitespace is not always ignored
### some TODO items:
* fix all memory leaks
* add better error messages
* arrays?
* for loops
* for loops
* variable scopes
This project can be made for the host system (```make```) or an ARM system (```make arm```).
This project is still in heavy development, so don't expect much. To include it in your own project, just link in libinterp.a (for ARM) and use the header files.
## building and running
This project can be made for the host system (```mv shell.c.bak shell.c; make```) or an ARM system (```mv shell.c shell.c.bak; make arm```). Make's ```-j``` argument may be used to multithread compilation.
To run on the host system, run ```./shell some_script_file```. Note that no IO functions are built in, so you must define your own.
To use on an ARM device, simply link ```libinterp.a``` into your program and use the header files. See ```shell.c``` for an idea of how to the interpreter.
 
This project is still in heavy development, so don't expect too much. See the wiki for a scripting guide.