GASOIL

GASOIL (General Application Stack Oriented Imperative Language) is a postfix notation esoteric programming language invented by User:Morex in 2009. 
==Description==
The main idea was to test a language (and interpreter) that instead of loading the program in a fixed memory, loads the program in a "program stack". This way the program is freeing memory as it is executed (instructions are not available anymore once they are executed (except calling a subroutine more than once)). There is no need for an "Instruction Pointer", meaning recursion is the only way to implement loops.
Inspiration for creating GASOIL was taken from the HP-41C and HP-28S (RPL) languages.
The GASOIL programming language is:
*Imperative
*Structured
*Recursive without a call stack or return stack (Infinite recursive loops do not overflow)
*Stack oriented (with a data stack and a program stack)
*Full postfix (for operators, functions, and control structures too)
*Reflection oriented (code can create code to be run on the fly) 
	
GASOIL has a lot of features: One Program Stack (PS), one Data Stack (DS), one directionable memory area for variable data storing, arithmetic functions, a lot of stack functions, control structures, comments, logic operators, subroutine calls, recursion and a rich instruction set.
Both stacks and the memory area can handle diferent data types in each memory cell. These data types are: 
*Floating point numbers
*Strings, enclosed in ""
*Program Instructions
*Program Blocks, enclosed in () with elements delimited by ;
The interpreter environment should let the user interact with the Data Stack, Showing output values, and letting users enter Input values. 
Standar I/O functions READ and WRITE are available too.
When running, in each step, the interpreter pops an element from the PS and takes the following actions depending on the data type:
*If the element is a valid Instruction then it is executed.
*If the element is a Number, a String or a Program block, it is pushed to DS.
The execution stops when the program stack is empty.
The PARSE instruction pops a program block from the DS (or a string containing a program block), and after parsing, push the resultant elements backwards on the Program Stack.
==Instructions==
===Literals===
*Numbers: 2, -4, 3.1416
*Strings: "Hello"
*Program Blocks: (1; 2; +; NOP Add 1 plus 2)
===Flow Control===		
*PARSE: Pop a program block from the DS (or a string containing a program block), and after parsing, push the resultant elements backwards on the Program Stack.
*CALL: Load a named subroutine pushing it to the PS
*CCALL: Conditional Call - Load a named subroutine pushing it to the PS if condition is true.
*STOP: Stop execution. User can resume.
*NOP:	Do Nothing. Ignore rest of element. Could be used to code comment: (1; NOP This is a comment; 2; +; NOP Another comment)
===Extended Flow Control===		
These instructions could be implemented or not in lightweight interpreters. It is possible to write them as GASOIL subroutines based in CCALL.
*ITE (If Then Else): Pop three DS elements: Cond.Value; (then block); (else block); ITE
*WHILE: Pop two DS elements: (Condition expresion); (Block); WHILE
*UNTIL: Pop two DS elements: (Block); (Condition expresion); UNTIL
*FOR: Pop four DS elements: Memory_address; InitialValue; FinalValue; (Block); FOR
			
===Arithmetic===	
*+
*-
* *
*/
*MOD
*SQRT
*RND: Returns a pseudo-random number less than 1 but greater than or equal to 0
*INT: Truncate a number to integer
		
===Stack===
*DROP: Drop the #1 DS element
*DROP2: Drop the #2 DS element
*DROP3: Drop the #3 DS element
*DROP4: Drop the #4 DS element
*DUP: Duplicate the #1 DS element
*DUP2: Duplicate the #1 and #2 DS elements
*DUP3: Duplicate the #1, #2 and #3 DS elements
*DUP4: Duplicate the #1, #2, #3 and #4 DS elements
*SWAP12: Swap DS elements #1 and #2
*SWAP13: Swap DS elements #1 and #3
*SWAP23: Swap DS elements #2 and #3
*SWAP14: Swap DS elements #1 and #4
*SWAP24: Swap DS elements #2 and #4
*SWAP34: Swap DS elements #3 and #4
		
===Logic & comparison===	
*=: Pop two DS elements: If #1 = #2 then push 1 (true) else push 0 (false)
*>
*>=
*<
*<=
*!=
*NOT
*AND
*OR
*XOR
		
===Memory access===
*STO: Pop two DS elements. Store #2 DS value onto memory address pointed by #1 DS value
*RCL: Pop one DS element. Push to DS the value from memory address pointed by #1 DS value
===I/O===
*READ
*WRITE
		 
===String manipulation===
*&: Concatenate two strings
*STRLEN: Find the length of a string
*INSTR: Return a number specifying the start position of the first occurrence of one string within another
*SUBSTR: Return a string containing a specified number of characters from a string
*REPLACE: Return a string in which a specified substring has been replaced with another substring 
*ASCII: Return a number representing the character code corresponding to a character
*CHR: Return the character associated with the specified character code
*STR2NUM: Return the number contained in a string as a numeric value
*NUM2STR: Return a string representation of a number
==Examples==
Hello, world!
 main
 ("Hello World!"; WRITE)
Endless loop	
 main
 (NOP This is a endless loop; "main"; CALL)
		
Fibonacci numbers up to 100
 main
 (1;1;"suma";CALL)
 suma
 (DUP2; +; DUP; 100; < ; "suma"; CCALL)
Add integers up to 20 using CCALL
 main
 (0; 1; 0; STO; "r"; CALL)
 r
 (0; RCL; +; 0; RCL; 1; +; DUP; 0; STO; 20; <=; "r"; CCALL)
Add integers up to 20 using WHILE
 main
 (0;1;0;STO;(0;RCL;20;<=);(0;RCL;+;0;RCL;1;+;0;STO);WHILE)
Add integers up to 20 using UNTIL
 main
 (0;0;0;STO;(0;RCL;1;+;0;STO;0;RCL;+);(0;RCL;20;=);UNTIL)
Add integers up to 20 using FOR
 main
 (0;0;1;20;(0;RCL;+);FOR)
Prime number generator up to 50
 ( 0; NOP Reg 0 for outer loop;
 2; NOP from 2;
 50; NOP to 50;
 (
 1; 1; STO; NOP Flag as prime;
 
 2; NOP Reg 2 for inner loop;
 2; NOP from 2;
 0; RCL; SQRT; INT; NOP to Int(sqrt(Reg 0));
 (
 0; RCL; 2; RCL; /; DUP; INT; =; NOP eval (Reg 0 / Reg 2 = int(Reg 0 / Reg 2) ?);
 (0; 1; STO); NOP Then Flag as No prime;
 (NOP); 
 ITE
 ); 
 FOR;
 
 1; RCL; 1; =; NOP Is Prime Flag set?;
 (0; RCL; " es primo."; &); NOP Push info if Prime;
 (NOP);
 ITE
 ); 
 FOR
 )
99 Bottles of Beer
 main
 (99; 0; STO; ""; ("e1"; CALL; 0;RCL; 1; -; 0; STO; "e2"; CALL); (0; RCL; 1;<=);UNTIL; "e1"; CALL; "n"; &; "f2"; CALL; &; "f1"; CALL;
 &; "."; &; 10; CHR; &; "N"; &; "f2"; CALL; &; "f1"; CALL; &; ", n";&;"f2";CALL;&;". Go to the store and buy some more, "; &; 99; 0;
 STO; "bo"; CALL; &; "f1"; CALL; &; "."; &)
 e1
 ("bo"; CALL; &; "f1"; CALL; &;", "; &; "bo"; CALL; &; ". Take one down and pass it around, ";&)
 e2
 ("bo"; CALL ;&; "f1"; CALL; &; "."; & ;10;CHR;&)
 bo
 (0; RCL; " bottle"; &; 0; RCL; 1; =; (""); ("s"); ITE; &; " of beer"; &)
 f1
 (" on the wall")
 f2
 ("o more bottles of beer")
Brainfuck interpreter
 main
 ("Input Brainfuck code"; READ; ""; &; 0; STO; DROP; 1; 1; STO; 2; 3; 100; (0; 2; RCL; STO); FOR; 3; 2; STO; (0; RCL; STRLEN; 1; RCL;
 >=); (0; RCL; 1; RCL; 1; SUBSTR; CALL; 1; RCL; 1; +; 1; STO); WHILE)
 >
 (2; RCL; 1; +; 2; STO)
 <
 (2; RCL; 1; -; 2; STO)
 +
 (2; RCL; DUP; RCL; 1; +; SWAP12; STO)
 -
 (2; RCL; DUP; RCL; 1; -; SWAP12; STO)
 .
 (2; RCL;RCL; CHR; WRITE)
 ,
 (READ; 2; RCL; STO)
 [
 (2; RCL; RCL; 0; =; ((0; RCL; 1; RCL; 1; SUBSTR; "]"; !=); (1; RCL; 1; +; 1;STO); WHILE); (NOP); ITE)
 ]
 ((0; RCL; 1; RCL; 1; SUBSTR; "["; !=); (1; RCL; 1; -; 1; STO); WHILE; 1; RCL; 1; -; 1; STO)
==External resources==
* GASOIL 0.83 - a GASOIL interpreter in Excel. 	
Category:Languages 
Category:Stack-based 
Category:High-level
Category:Implemented 
Category:Self-modifying
Category:2009