S.I.L.O.S

S.I.L.O.S or SIL is designed for a nostalgic view of the past. It is simple and minimalistic, but remains capable of universal computation. Feel free to | try this language online! The interpreter is hosted by Dennis Mitchell.

Naming

S.I.L.O.S stands for

• Superb
• Interpreted
• Language's
• Obviously
• Superior

It is also known as SIL (Simple Interpreted Language)

Syntax

The syntax is simple

//One command per line
//one letter variable names
//Only type integer 
//No declaration needed they all start at 0
//direct access to the memory array 
a = get 5
lblFoo
GOTO Foo
No syntax checking
VB like behavior allowing erros to pass unnoticed and unhandled
if x Foo //goes to Foo iff x>0
a - b subtraction
a + b addition
a * b multiplication
a / b division
a % b modulus
a | //absolute value of a and reassigns this to 
a ~ bitwise not
a < b left shift
a > b right shift
a & b bitwise and
a : b or
a ! b xor
a ? b xnor
a ^ b a raised to the b 

//all assignment operators x - 5 is the equivalent of x-=5 for those familiar with C styled languages

That is the basic syntax, note that as of this printing, integers are 32 bit signed integers [-1*2^31,2^31-1] which overflow and wrap around. There is a plan to make them big numbers with unbounded size.

Memory Buffer

You can directly write to the memory buffer like such

set 288 57
//acccesses the heap at 288 and sets it to 57
a = get 288
//gets back what the thing at position 288
printInt a
set a 88
//sets the thing at position a to 88
b = get a
//gets the thing at position a and sets it in the value of b
printInt b
printIntNoLine a
printLine
a + 10
b + 11
set b a
//sets what is at b's position to a
c = get b
//gets the number from above
printInt c

Remember please be careful to not use any positions below 256 on the array as these can be used for ascii variable names, touch these at great peril

IO

input and output is done like so

readIO SOME PROMPT FOR THE USER

the magical interpreter thus prints out SOME PROMPT FOR THE USER and stores the value in the variable i NOTE that for the onlne version it is imperative you avoid the use of this command. All prompts are disabled in the online version, so

printLine SOME PROMPT

and then

readIO :

Printing is done with three commands

printInt a
//prints out the value of a with a trailing newline
printLine a
//prints out "a" with a trailing newline
print a
//prints out "a" with no trailing new line
printChar x prints out the value of x as a character

Entropy

the randomness is provided by a prng currently the prng is provided courtesy of Oracle and uses the system time as a seed

rand x

gets a random number [0,x) 0 inclusive to max exclusive and stores it in the variable r max may also be a literal like 12

Functions

See the usage of functions in functions.txt to better comperehend it, but here is the basics. Function should be declared as such

GOTO endOfAllFunctions
funcfunctionname
//code the function here
return
funcsomeFunc
return
lblendOfAllFunctions

now at any point in the code you may calll the function named functionname as such

GOSUB functionname

The stack is automagically handled works similar to most languages. However one must be cuatious of properly enclosing the function safely with returns. Also ensure to jump around the functions with the Goto's otherwise all the functions will run.

Ideally functions should have only one return statement.

As of this printing functions can only be void and have no return type.

Style

the first line is used by the interpreter to allocate the size of the array (heap) this number should be at least 256 if you omit this line the interpretter will just allocate 8192 slots in its memory for its future use you are allowed to use single character identifiiers

1 = 5
printInt 1
//prints five
print 1
//1

But never do this unless it is for obfuscation purposes the compiler will struggle with resolving what you are talking about also as far as commenting goes the compiler will ignore non code thus

this is a comment

is valid syntax but don't abuse this as

1 = foo

could break your code instead // is recommended to start all comments lastly as input and randomness are stored into the variables i and r when requested it is recommended that you reserve these variables for that use

New Features in v1.5

As of 8/24/2016 SIL has new, improved input, here are the new features

//This shows the new features of SIL
def p print load loadLine : lbl
//With the new "illiterate preprocessor" (tm) the above statement (which must appear on the second line) defines any number of macros in the form of def string replace string2 
replace

p Hello,
pLine  World!
pSee
pLine!
a = 5
pInt a
//loading the next line of stdin as a string is easy.
load testing!
//the loadLine command will take one line (either one single command line argument on TIO (Try it Online!), or STDIN on java and loads it in starting at the 256th heap spot and 
working out)
//look the macro now will allow : to work as a label
a = 256
:a
x = get a
printInt x
if x continue
GOTO end
:continue
pChar x
a + 1
if x a
:end

Graphics

Support for Graphical Output has been added in SILOS 2.0. SILOS 2.0 comes primarily with support for graphics, but also features I highly optimized interpreter (thanks to kckennylau!), and a

wait x

command which as the name would suggest, waits x milliseconds. Now, let's take a look at how graphical output works.

canvas width height wordForTheHeader

You first must use the above command to declare a canvas THan you must decide to create objects Each object will be in the current pen color. THe pen color gets set with

pen r g b

where r g and b are variables represent red green and blue values of a color (of any name) or integer literals.

Than you can create an object

newObj type height width

a square is type 0 an elipse is type one. Height and width and type are all variables/integer literals. This will add a new object to the drawable list. This list is zero indexed.

moveObj index x y

will move an object to a designated location.

refresh

is a mandatory command to be invoked once you have moved the objects around. refresh is the only way to actually trigger the painting.

Please see the game.txt and gui.txt files in the examples folder for an explanation.

Keyboard Bindings

At any point you can place a binding to certain characters

bind intRepresentingChar1 heapSpot1 intOfChar2 heapSpot2 etcetera

Where intRepresentingChar is an integer literal or variable representing a char ((ascii convention used) 97 would mean 'a') and heapspot is an integer value of a valid spot on the heap.

When the corresponding characters get typed (and a canvas has already been created) the corresponding heapspot will be set to one. This feature only works on the desktop version when a canvas is in focus

Whitespace

Most whitespace dependency is gone. The only necessary whitespace separates arguments and the new lines between commands. All lines are now indentable! Bitwise operators now have support. Please view the bitwise.txt document for a full rundown.

Stacks and Queues

You have access to 32 stacks and 32 queues

stack x y

will add y to the xth stack

queue x y

will queue y onto the xth queue

stackPop x

will pop a value off of the xth stack and store in variable m

queuePop x

will dequeue a value off of the front of the xth queue and store in variable m

Please note that all interactivity including graphics support is unavailable on Try it Online! all input must be through command line arguments.