sBasic -- yet another simple programming language
*************************************************

.. contents::

sBasic Usage
============

sBasic is designed for freely programmable embedded
applications that do not allow scripting languages like JS,
Lua or Python. 

One should not write applications with it, in contrary it is
designed to write extensions for micro controller projects.

sBasic Language Specification
=============================

Whitespace
==========

The following whitespace characters will be converted to
a single blank (``0x20``): ``\t\r`` and multiple blanks.

The newline character (``\n``) is a special character
however multiple newline characters will be interpreted as
one.

A statement always ends with a newline character. Tokens are
separated by blanks.

Variables and Arithmetic Operations
-----------------------------------

Variables have data types. Usually they will be integers,
but there might be other application specific datatypes.

Variables have to be declared explicitly using the scheme::

	<datatype> <variablename> '=' <value>

**Note** that variable names must start with an alphabetic
character. Variable names can contain after the first
character all of the following characters::

	a..zA..Z0..9_

Datatype names must follow the same conventions as the
variable name convention.

**Note**: Variables are always global.

Here is an example for valid variable declarations::

	int A = 2
	int B = 3
	int A_plus_B = 0

Arithmetic commands are application specific, for integer
usually ``+ - * /`` are defined. Arithmetic commands can be
grouped by using parenthesis ``()``. 

``*`` and ``/`` will be executed before ``+`` and ``-``, the
inner of parenthesis will be executed before the outer and
by default commands will be executed in the order they
appear.

Conditional Statements
----------------------

sBasic knows the if-else-structure::

	IF <expr>
	THEN
		<statement>
		{<statement>}
	[ELSE
		<statement>
		{<statement>}]
	FI
	

Loops
-----

sBasic knows the while-loop::

	WHILE <expr>
	DO
		<statement>
		{<statement>}
	DONE

Routines
--------

Because in sBasic variables are always global there is no
need for functions. Instead Routines are used to group code.

Routines can be defined defined at any point of the code but
the first statement.
However when the program execution reaches a Routine this
will result in a stack-underflow. The compiler will
therefore check that a routine cannot be reached without
a call.

Any routine must therefore not be the first statement and
must follow either a ``CALL`` or the ``HALT`` command.

A routine is defined like this::

	ROUTINE <routine_name>
		<statement>
		{<statement>}
	END

The name of a Routine must follow the conventions for
variable names.

Routines can be executed by calling them::

	CALL <routine_name>

Special Commands
----------------

There is one built-in special command::

	STOP

that will cause the bytecode interpreter to halt.

Comments
--------

Comments start with a ``#`` at the beginning of the line and
span over the entire line. The ``#`` sign might follow one
(or more) blanks.

Strings
-------

There are two types of strings in sBasic: single line
strings and multi line strings.

A single line string starts and ends with a ``"`` character
and must not span over several lines. The following
conventions for strings are used: ````` is treated as
character `````, ``\\`` is treated as a single ``\``,
``\n,r,t`` is the newline, carriage return, tab character.
Any other combination of ``\`` and a character is a syntax
error.

A multi line string starts and ends with a ````` character
and can span over several lines. Every newline character in
the string will be treated as such. ``"`` is treated as
character ``"``.
The rest of the conventions follow the conventions for
single line strings.

**Note** that strings in sBasic are static and stored in the
program memory.

Datatypes
---------

- Strings are indicated by the ``str`` keyword. The variable
  itself is a pointer to the actual string that will be
  stored at the end of the program memory
- Integers are indicated by the ``int`` keyword.
- Characters are indicated by the ``chr`` keyword. Literal
  characters are surrounded by two ``'`` characters. They
  can contain escape sequences (``\ntr'``).
- Floats are not supported by vanilla sBasic. They should
  however be marked using the ``flt`` or ``dbl`` keywords.

sBasic Application Extensions
=============================

When it comes to real world applications the sBasic language
should be extended with Application Specific Commands (ASC).
Those provide a way to directly access the assembly language
controlling the bytecode interpreter.

ASCs should typically compile to few assembly commands,
like::

	# sBasic
	string string_part = string + 1
	PUTCREF string_part
	
	; assembly
	; string_part = string + 1
	ld 0, string
	ld 1, 1
	add 0, 1
	st 0, string_part

	; PUTCREF string_part
	ld 0, string_part
	putcref 0