Fumble

Fumble is a self modifying stack based esolang designed by Moon_

Syntax

The name of something is put inside the brackets i.e {func:pu-1}, data for a function are put in square brackets. Function data is formatted as follows: [args:< var names >]. Arguments cannot be modified. Arguments are given to a function unenclosed, separated by -'s, like so: func-"foo"-bar-1-*baz (that demos all argument types). It uses classic C escape codes. Fumble uses the ! character to express a negative literal

Fumble's comment system uses %* to start a comment and *% to end one.

Return data is best put into its own personal variable or pushed to the stack. () brackets are used to make a new scope inside code, they are useful for local variables defined using [].

Fumble's stack has no size limit, making Fumble potentially turing complete.

Fumble supports threading, and each thread has its own stack to work with. A thread can be started using 'async{%* Code goes here *%}', which pushes the thread id to the stack. Fumble interpreters should associate a simpe value with the real thread id, the main thread always having the value of 1. Fumble can preform operations on other threads besides ending them and pausing them, it can force jumping to other parts of the code and push data to the thread's stack.

Fumble can manipulate other functions in its code using a set of instructions, this is done by a function that contains a 'wrapped' version of the function, functions can also manipulate themselves. Functions are wrapped using [{}] bracket sets, like so: [{function}]. The function can be manipulated based on its wrapped name (<function name>w) to insert, remove, and modify its lines.

Fumble has a pointer system to allow variables to point to another variable.

Commands and operations

pu: push[args:a] pushes

po: pop[args:*a] pops

add: add[args:a,b] pushes number

sub: sub[args:a,b] pushes number

div: div[args:a,b] pushes number

mult: mult[args:a,b] pushes number

inc: inc[args:*a] increments

dec: dec[args:*a] decrements

cmp: cmp[args:a,b] pushes number 0-2, 0 means less than, 1 means equal, and 2 means greater than

set: set[args:*a,b] sets something to a value

print: print[args:a] prints

strin: strin[args:*a,strmaxsize] gets a string

charin: charin[args:*a] gets a char

stackout: stackout[args:a] prints out n values from the stack

al: al[args:wrappedfunction,a,location] Adds a line to a function at the specified location

rml: rml[args:wrappedfunction,a,location] Removes a line from a function

Flow control

for-<initialization>-<condition>-<operation>(< code >)

while-<condition>(< code >)

if-< condition >(< code >)

until-< condition >(< code >)continues until a condition is met.

unless-< condition >(< code >)Preforms code and ends the function/program unless a condition is met

continueuntil-< condition >(< code >) allows the code to continue until a condition is met, once met, it preforms the code and once the code is done jumps back to the instruction it triggered on.

Example programs

Hello world!

 {main[]:
 print-"Hello, World!"
 }

Factorial

 {main[args:num]:
 print-num
 print-"'s factorial is"
 [tmp,tmp2,tmp3,sum]
 until-{cmp-tmp2-1}(
 set[tmp,num]
 dec-tmp2
 mult-tmp2-num
 po-tmp3
 set-sum-tmp3
 set-tmp-tmp2
 )
 print-sum
 }
 %*This is untested (of course) and may not work*%

Pretending decimal numbers exist

 {main[]:
 [nump1,nump2,dat,a] %* nump1 is the whole number and nump2 is the decimal
 set-dat-100 %* 10^n, n being how many decimal places you want. *%
 until-{cmp-nump2-dat pu-a add-a-1}(
   sub-nump2-dat
   add-nump1-1
 )
 }