KimL

KimL is an esoteric programming language consisting of invocations on pre-defined pseudo-objects. KimL was created by User:Alexanderdna, who created other languages such as ILYC and TS#.
The current implementation of KimL is written in C++ as both a compiler and a virtual machine that executes the compiled bytecode.
KimL is a case-sensitive language.
== History ==
KimL was firstly developed and implemented in 2009. As the project was started in December of 2009, the first language specification is Specification 09.12 and the interpreter was written using Visual Basic .NET.
In the later year, another version called Specification 10.07 was implemented in Visual C# in July 2010.
The third version of KimL, born in January 2011 and called Specification 11.01, is the last version till now and is described in this document.
== Structure ==
There are three data types in KimL, which are int, real and string. int is 32-bit integer. real is 64-bit floating-point number. string is array of 8-bit character or the std::string type in the C++ Standard Template Library.
Values of type int can be converted to type real or string. Values of type real can be converted to type int or string. Values of type string generally cannot be converted to int or real. However, in some situations, string to numeric conversions are allowed and the runtime will try to parse the string for a valid value or choose 0 if it fails.
A KimL program has an internal stack call the k-stack. This is a supposedly-unbound stack that can store objects of any type.
Besides, there is an array of 128 objects called the tape. The tape also accepts any of the three data types. A tape pointer exists to point to the current item on the tape.
== Objects ==
There are pseudo-objects taking care of different tasks in the program. Each object has a set of methods corresponding to the works it represents. Some methods have arguments, some do not.
=== io ===
As the name suggests, io is the object performing input and output tasks. It has two methods, which are in and out.
====io.in====
This method takes data from a text line the user has entered.
One version of io.in uses a type keyword as argument. It then converts the input data to the specified type and pushes it to the k-stack.
 io.in int
 io.in real
 io.in string
Another version uses a variable name as argument. The input data is converted to the variable’s type and stored in that variable.
 io.in a	;where 'a' is a variable
Note: if the type conversion fails, the default value is used.
====io.out====
This method uses an expression a argument, converts the expression result to string (if needed) and prints that on the screen.
 io.out "Hello World!"
===var===
The var object is used to work on variables.
====var.decl====
This method helps declaring a variable for use in the program. It uses a type keyword and a variable name as arguments. The variable should not be declared before unless it has been deleted by var.del (discussed later).
 var.decl int n
 var.decl real r
 var.decl string s
The variable can have an initial value as showed below:
 var.decl int n = 10
 var.decl string s = "a simple stupid string"
 var.decl real r = n * 3.14
The initial value's type should be convertible to the variable type, otherwise an error will occur in compile time or runtime depending on the nature of the expression. 
====var.del====
This method deletes an existing variable. If the variable is not declared before, a compile error will occur.
 var.del n	;suppose that 'n' exist
Variable declaration and deletion in a KimL program are checked sequentially at compile time. That means, a variable is considered to exist if a former line of code has declared it, and to no longer exist if a former line of code has deleted it. Control flows are not included in the check.
Due to this characteristic of the compiler, if the program, in runtime, jumps to a position where a variable has not been declared and references or deletes it, an error or undefined behaviour will occur.
Programmers are recommended not to have a branching between the declaration and deletion of a variable.
====var.set====
This method assigns a value to a variable.
 var.set i = i + 1
A compile error will occur if the variable does not exist.
=== stack ===
The stack object have methods to operate on the k-stack.
====stack.push====
This method pushes a value to the k-stack.
 stack.push n + r / 2
====stack.pop====
This method pops the top value off the k-stack. If the stack is empty, a runtime error will occur.
 stack.pop
If given a variable as argument, this method stores the popped value in the variable.
 stack.pop n	;n should exist
====stack.peek====
This method stores the top value on the stack in the given variable. A runtime error will occur if the stack is empty.
 stack.peek n	;n should exist
====stack.swap====
This method swaps the top two values on the stack. A runtime error will occur if the stack has less than two values.
 stack.swap
====stack.clear====
This method clears the whole stack.
 stack.clear
If given a constant integer number as argument, this method clears that number of values on the stack. A runtime error will occur if the stack has less values than specified.
 stack.clear 5
=== tape ===
The tape object operates on the program tape and tape pointer.
====tape.read====
This method reads the current value on the tape, pointed to by the tape pointer. The read value is then stored in a variable or pushed on the k-stack. Like io.in, the argument is a variable or a type keyword (for pushing on the stack).
 tape.read a	;a should exist
 tape.read string
If the value cannot be converted to the specified type, a runtime error will occur.
If an 'at index' phrase is provided, the value at that index will be read. The index should be a constant integer number in the range from 0 through 127.
 tape.read int at 3
 tape.read n at 127
====tape.write====
This method writes the given value to the current object on the tape, pointed to by the tape pointer. If an index is provided, the value is written to the object at that position.
 tape.write 10	;write to current
 tape.write a * b + c at 0
====tape.next====
This method moves the tape pointer one position forward. If the tape pointer is currently 127, it will be set to 0.
 tape.next
====tape.prev====
This method moves the tape pointer one position backward. If the tape pointer is currently 0, it will be set to 127.
 tape.prev
====tape.move====
This method uses an expression as argument. The value of the expression will be converted to integer if needed and assigned to the tape pointer.
If the type conversion fails or the value is out of range (0 to 127), a runtime error will occur.
 tape.move i + 3 * j
===ctrl===
The ctrl object provides control flow operations.
====ctrl.goto====
This method move the program counter to a defined label.
 ctrl.goto L1
 ;...
 L1:
 ;...
If a condition phrase is provided, the branching is done only if the specified condition is met.
 ctrl.goto L1 if a > 0
====ctrl.call====
This method works like ctrl.goto but it stores the current program counter in a call stack before branching.
 ctrl.call proc1
A condition is also allowed.
 ctrl.call proc1 if name = "john" and age > 15
====ctrl.return====
This method pops a value from the call stack and sets it to the current program counter. If the call stack is empty, it will set 0 to the program counter.
 ctrl.return
This method is, by convention, used with ctrl.call.
====ctrl.end====
This method halts the execution of the program.
 ctrl.end
==Expressions==
===Literals===
Valid int literals are 0, 10, 300, 1000000, etc.
Valid real literals are 0.0, 1.23, 0.245, etc.
String literals are enclosed by double-quotes. Allowed escape sequences are \n, \r, \t, \\, \".
===Operators===
The following list are allowed operators in KimL, in descending order of priority.
* # converts to real, @ converts to int
* ^ exponentiation
* unary + and -, not (logic)
* multiplication, / division, \ integral division
* + addition, - subtraction
* & string concatenation
* < less than, <= less than or equal, > greater than, >= greater than or equal
* = equal, <> not equal
* xor (logic)
* and (logic)
* or (logic)
The # and @ conversion operators have a function syntax, that is, they require the converted expression be enclosed in parentheses.
===Functions===
KimL provides a set of built-in functions as listed below:
* abs(numeric): returns the absolute value of a number, the return type depends on the argument type.
* real sqrt(numeric): returns the square root of a number.
* real sin(numeric): returns the sine of an angle (in radians).
* real cos(numeric): returns the cosine of an angle.
* real tan(numeric): returns the tangent of an angle.
* real asin(numeric): returns the arc-sine of a number.
* real acos(numeric): returns the arc-cosine of a number.
* real atan(numeric): returns the arc-tangent of a number.
* string chr(numeric): returns a character from the given number(mod 256).
* int asc(string s): returns the ASCII value of the first character in the given string or 0 if the string is empty.
* int len(string s): returns the length of the given string.
* string left(string s, int n): returns the leading n characters of the given string, or the string itself if n is bigger than its length.
* string mid(string s, int i, int n): returns n characters of the given string, starting from i; or the string itself if i or i+n is bigger than its length.
* string right(string s, int n): returns the trailing n characters of the given string, or the string itself if n is bigger than its length.
* iif(cond, t, f): returns t if cond is true, otherwise f; the return type depends on the type of t or f.
* _tape(int idx): returns a value on the tape, pointed to by idx.
* _stack(int offset): returns a value on the stack, at the given offset from the top of the stack. _stack(1) returns the top value, _stack(2) returns the next to top value, and so on.
* _pop(): pops and returns the top value on the stack.
* _peek(): returns the top value on the stack.
==Examples==
===Hello World===
 io.out "Hello World!\n"
===Factorial===
 var.decl int f
 io.out "n = "
 io.in int
 ctrl.call fact
 var.set f = _tape(0)
 io.out "n! = " & f
 ctrl.end
 
 ; the following factorial function is recursive
 fact:
 	ctrl.goto fact_0 if _peek() < 0
 	ctrl.goto fact_1 if _peek() <= 1
 	stack.push _peek() - 1
 	ctrl.call fact
 	tape.write _pop() * _tape(0) at 0
 	ctrl.return
 fact_0:
 	stack.pop
 	tape.write 0 at 0
 	ctrl.return
 fact_1:
 	stack.pop
 	tape.write 1 at 0
 	ctrl.return
===99 bottles of beer===
 var.decl int bot = 99
 
 loop:
 	io.out bot & " bottles of beer on the wall.\n"
 	io.out bot & " bottles of beer.\n"
 	var.set bot = bot - 1
 ctrl.goto loop if bot > 0
 
 io.out "No bottle of beer on the wall.\nNo bottle of beer.\n"
 io.out "Go to the store. Buy some more.\n"
 io.in string
==The KimL calling convention==
Below is the standard calling convention in KimL:
* Arguments are pushed on the stack, in right-to-left order.
* Return value is stored on the tape at 0.
* The callee is responsible for clearing the stack.
==External resources==
The KimL compiler/virtual machine is written in C++ and distributed under the MIT license. The source code is successfully compiled on Microsoft Windows XP and Ubuntu Linux using Microsoft Visual C++ 2008 Express and GCC 3.4.2.
Please visit http://www.sourceforge.net/projects/kiml to download the package.
Category:Languages
Category:Implemented
Category:2011