Litteraly everybody working in IT has at least touched code once and is able to write a simple Hello World program. It is however, a common occurance that it's hard for people to explain to interested non-IT people (for example family members) what they're doing on a daily basis. Most languages feature all kinds of fancy operators and syntax requirements that're very powerful, but prevent non-IT people from trying a little something out themselves. In these kind of situations, SRPL comes into play; the SupeR simPle Language!

Course requirements: Check the course markdown file for description of meeting course requirements.

SRPL can interpret a file, can be used as a shell and is able to compile files to assembly. To start the shell, execute python srpl.py in the commandline. To run 'main.srpl' execute python srpl.py main.srpl in the commandline. Please note that the newlines can be replaced by semicolons and that every line in the file needs to end with a space. To compile an SRPL sourcefile, execute python srpl.py example/source/even.srpl example/source/even.asm. The SRPL sourcecode in even.srpl will then be compiled to assembly in even.asm. For large code-bases one can (luckily) compile all SRPL source files in any parent-directory by executing compile in the SRPL shell.

The compiler has been written with compatibility and simplicity in mind; it's very efficient most of the times, but for example the checking of conditions is done in such a way that it's easier to read than it is fast. This checking of conditions is done by first storing the boolean representation in a register and then checking for it being larger than 0. This could also have been done with a more complex branch statement, but hey; the method described above is very suited to the ideology behind SRPL.

Furthermore, only the really used registers are pushed to the stack and there's a neat optimization that recognizes registers being used in either case of an if-statement. This results in registers being allowed to be used in both the if- and else-statement. Other than that, there's one more feature that's very suited to SRPL; informative comment generation. This allows for easy checks of the compiled assembly files.

Last but not least, the compiler has been tested extensively with the help of unit-tests. These can be found in the example directory and can be compiled with the compile command in the SRPL shell.

Everything has been documented with usability and neccesity in mind. This boils down to not documenting every method or function, but just making sure every 'type' of function has at least been documented once. Documenting every operator of a number for example, would be useless and even distracting.

The heart of this language is the number. Numbers can be an integer or a float. Furthermore, a true is seen as a Number larger than 0.

flush 5.3 plus 4 variable day is 6 flush day is_larger_than_or_equal_to 5 

Of course a language should support simple math with taking the order of operations into account.

variable sum is 5 plus 3 variable product is sum multiplied_by 3 variable part is product divided_by 2.1 variable freezing is part min 90 

Functions (when interpreted) can have zero or more parameters and can return zero or more values. Furthermore, a file can contain multiple functions.

task add with a and b contains	flush a plus b end variable sum is execute add with 3 and 5 now flush sum 

While-loops are fully supported. An error is printed when loop is infinite.

variable i is 1 while i is_less_than 5 then	variable i is i plus 1 end flush i 

For-loops are fully supported as of version 2.1. Not just a simple version though; with custom stepsize that can be both positive or negative.

task fact with n contains	variable result is 1	for variable i is 2 to n then	variable result is result multiplied_by i end	flush result end 

If statements can have an optional else statement. Furthermore, all conventional conditions are supported. For a complete list; check out tokens.py.

variable fun is 5 flush if fun is_greater_than 8 then ; 22 else 10 end 

Functions are first-class citizens; they can be stored in variables and passed to functions.

task apply with number and lambda contains	execute lambda with number now end task makeTwenty with n contains	variable n is 20	flush n end variable applyCopy is apply variable wasntTwenty is 18 variable wasntTwenty is execute applyCopy with wastnZero & makeTwenty now flush wasntTwenty 

Unlike most other languages, functions and the file can return multiple values. This has been done since it's more natural to non-it people. Executing multiple tasks yields multiple results; not one single. As one can imagine, this doesn't work when it's compiled to assembly. Then only the last return statement is effective.

task multi contains flush 3 flush 5 execute multi now 

Error handling is also a little less conventional. It is able to determine when things are missing and it prints an error message in the terminal, but it still tries to continue. Very life-like again; when you fall with the bike on your way to the train-station, you (hopefully) stand up and continue your commute. You don't end your day there... If you're curious as to how this functions; try it out yourself.

 task add with a and b contains	flush a plus b end variable result is execute add with 3 & 5 now variable sum is add variable otherResult is execute sum with 4 & 5 now flush result flush otherResult variable i is 1 while i is_less_than 5 then	variable i is i plus 1 end flush i task odd with n contains	flush if n is_equal_to 0 then	0 else execute even with n min 1 now end end task even with n contains	flush if n is_equal_to 0 then	1 else execute odd with n min 1 now end end variable evenCopy is even flush execute even with 4 now flush execute odd with 4 now flush execute evenCopy with 3 now flush execute odd with 3 now task apply with number and lambda contains	execute lambda with number now end task makeTwenty with n contains	variable n is 20	flush n end variable wasntTwenty is 18 variable wasntTwenty is execute apply with wastnZero & makeTwenty now flush wasntTwenty task sommig with n contains	variable result is 0	while n is_greater_than_or_equal_to 1 then	variable result is result plus n	variable n is n min 1 end	flush result end flush execute sommig with 5 now flush execute sommig with 34 now task fact with n contains	variable result is 1	for variable i is 2 to n plus 1 then	variable result is result multiplied_by i end	flush result end flush execute fact with 5 now flush i task neg_for with n contains	variable result is 1	for variable i is 10 to 0 step 0 min 2 then	variable result is result plus i end	flush result end flush execute neg_for with 5 now 

Output: [8, 9, 5, 1, 0, 0, 1, 20, 15, 595, 120, 5, 31]