Smellcode

Smellcode is like FALSE, but smellier.
The name is a play on the phrase "code smell".
== Virtual machine state ==
The following item describes a mental model for a running Smellcode program.
* Integer variables A-Z
** zero-initialized
** there are only these 26 predefined variables
** letter case is used to distinguish between storing to the variable vs fetching its value
* Code stack
** Is initially empty
** Holds addresses for function entry points
* Data stack
** Is initially empty
** Holds integers
* Return stack
** Is initially empty
** Holds return addresses
** This is only accessible indirectly and holds return addresses for function calls (from the @ operator)
== Operators ==
These are the language's built-in operations. The set of operators is deliberately lacking because these can be composed to achieve the effect of other "basic" operations.
* 0-9... :: push the denoted (non-negative) integer to the data stack
* ` :: push the next character as a literal to the data stack
* - :: negate the top integer on the data stack
* + :: pop and add the top 2 integers of the data stack and push the result
* * :: pop and multiply the top 2 integers of the data stack and push the result
* / :: pop and divide the top 2 integers of the data stack and push the dividend and the remainder to the data stack
* = :: pop the top 2 items from the data stack and push 1 if they are equal but push 0 otherwise
* > :: pop the top 2 items from the data stack and push 1 if the top item is greater than the other item but push 0 otherwise
* $ :: swap the top 2 items on the data stack
* # :: pick value from stack (0 is top, 1 is next, etc...), a.k.a dup the N-deep element of the stack 
* { ... } :: create and push a lambda onto the code stack
* & :: push current lambda/entry address onto the code stack
** This allows a lambda to refer to call itself recursively
** When this operator is not within a lambda, it pushes the code address of the entry point, which is the first operator in the top-level
* @ :: pop the top item off of the data stack and call the top value of code stack as function if the top data value was not 0
* \ :: pop the top item off of the data stack and jump to the top value of code stack as function if the top data value was not 0
* [ :: pop the top item off of the data stack and push it to the code stack
* ] :: pop the top item off of the code stack and push it to the data stack
* . :: (dot), pop and print the top data stack item as a character
* , :: (comma), read an input character and push it to the data stack
* a :: push value of variable "a" to data stack
** letter case is used to distinguish between storing to the variable vs fetching its value
* A :: pop item from data stack and store value in the variable "a"
** letter case is used to distinguish between storing to the variable vs fetching its value
== Idioms ==
Here is a list of common sequences of operations to achieve one thing:
* 9- :: the minus sign comes after a number (9 in this case) and makes it negative
* 0+ :: drop the top item of the data stack
* 0# :: dup, duplicates the top of data stack
* ]0#[[ :: dup the top item of the code stack
* 1# :: over, duplicate the 2nd item on the data stack
* $0+ :: nip, removes the 2nd item on the data stack
* 1@ :: call code unconditionally
* /$0+ :: modulus, get just the remainder from division
* /0+ :: quotient, get just the quotient from division
* $> :: less than, checks if the top data stack item is less than the next one
* 1#1# :: 2dup, duplicates the top 2 items of the data stack
* &1@ :: recurse, lambda recursively calls itself
* { true }0#@ 0={ false }@ :: if/else assuming there are no data stack items added in the true lambda
* { code &1@}1@ :: forever loop / infinite recursion
* { code }]0#[[1@1@ :: run the code twice
* aB :: copy value of variable "a" to variable "b"
* ab$AB :: swap values of variables "a" and "b"
* { code }]A :: store the function in a variable (in this case, the variable "a")
* a[1@ :: call the function stored in the variable "a"
== Example programs ==
=== Hello world ===
 `h.`e.`l.`l.`o.` .`w.`o.`r.`l.`d.
Category:Stack-based
Category:Languages
Category:Unimplemented