Introduction

Emoticon is a programming langauge based on emoticons, or smileys, such as those that excessivly littered many bad emails and chat posts before the introduction of emojis. In Emoticon these smileys become program instructions, while anything surrounding them becomes data. With some cunning it should be possible to embed Emoticon code in any normal message, though any reader would probably end up being very confused at what mood you were trying to convey!

A web based Emoticon Interpreter, written in PHP, is available on this site.

Emoticon basics

Emoticon involves three basic concepts, Data items, the Emoticon, and the List:

• An Emoticon is the basic component of Emoticon code (each Emoticon is an instruction)
• Data items are any token that is not an Emoticon (e.g. numbers, strings, and other primitives)
• A List is a data structure holding an ordered series of data items or emoticons

An Emoticon program is made up of Emoticons seperated by Data Items. When the program is run Lists are created to hold Data processed (or generated) by the program.

Emoticons

==|8+]

An Emoticon is a sequence of at least two characters, not containing any white space, making up a program instruction. An Emoticon is made up of three elements, the mouth, the nose, and the face. The Mouth (which is the rightmost character) controls what sort of command is being given, the Nose (which is the character immediatly to the left of the mouth) supplies the operator for the command (if any) while the Face (every character excluding the mouth, and the nose if the Emoticon has more than two characters) defines what list the command operates on, or is unused. Note that the characters in an Emoticon are case sensitive, so that 'D' is a valid mouth and 'd' is not.

For example, in the Emoticon above the breakdown is as follows.

Mouth	]
Nose	+
Face	==|8

We will discuss the meaning of this command a little later on.

Lists

A

B

C

1

2

3

A list is the only data type in Emoticon. A list is an ordered series of individual elements, each of which is an Emoticon or a Data item. A List has two accessible elements, the Left ('A' in the example above) and the Right ('3' in the example above), which can be read, moved, or added to. Elements between these two are inaccessible but the list can easily be manipulated so that middle elements become the left or right of the list. New elements can be added to either end of the list, or, using the insert emoticon (version 1.4+), into the middle of it.

Data items

A Data Item is any word in the code that is not recognised as an Emoticon. Note that words that end in valid Emoticon Mouth characters (such as ] or D) will be treated as Emoticons and could lead to errors. When a Data Item is encountered in code it will be put on the right of the currently active list (see below).

The Emoticon Environment

The Emoticon Environment consists of a series of Lists. Some of these are defined by the Interpreter and will always exist, others are defined by the program code. Emoticon code can manipulate any of these Lists.

One List is always designated as the current List. The current List is very important, since most instructions manipulate it in some way. At the start of any Emoticon program the current List is always the default List ':'. During execution of the code this may change, but the List ':' will always exist and be designated as current at the start of the program.

The core lists

The following Lists will always exist.

X:	The program counter
Z:	The program source
A:	The name of the current list
G:	The list of set markers
S:	A single space
E:	An empty list
:	The default list

Program Execution

When an Emoticon program is run the following things happen.

1. The source code is split into its constituent words and they are put (in order) into the list 'Z:', with the word 'START' preprended to them.
2. The program counter ('X:') is set to 1

The interpreter then loops through the code, executing each instruction in 'Z:' as follows.

1. The instruction at the position indicated by the program counter ('X:') is examined, starting with instruction 1, the first after the 'START' element.
2. • If the instuction is a Data item it is placed on the right of the current List
   • If the instruction is an Emoticon it is executed
   • If the instruction is empty (past the end of the code) execution ends
3. The instruction counter is incremented by 1
4. The interpreter returns to the first step.

The behaviour when Data is encountered is very important, since it allows data to be read into lists. Take the following example. Given the code

hello world

The following will be the contents of each of the lists at the end of execution.

X:	3
Z:	START hello world
A:	:
G:
S:
E:
:	hello world

Of course its not enough simply to have data, to actually do anything useful you need Emoticons as well, which we will discuss in the next section.

The Emoticons

All Emoticons are defined by the mouth character (except for the obfuscation control statements). The following are all of the valid Emoticon mouths in Emoticon version 1.2. Each Emoticon is described further in the Emoticon Reference

O	Set current List to this list
C	Put number of elements of this list on left of current list
<	Move left of current list to left of this list
>	Move right of current list to right of this list
[	Copy left of current list to left of this list
]	Copy right of current list to right of this list
V	Insert current list into this list at right of ':' for right of ':'-1 elements
D	Replace conents of this list with contents of current list
@	Rotate this list right a number of times eqal to the left value of current list
P	Print left of this list
Q	Print left of this list and then delete it
*	Add input to this list
7	Explode left of this list and put on left of this list
L	Explode right of this list and put on right of this list
#	Implode a number of items from the left of this list equal to the left of current
$	Implode a number of items from the right of this list equal to the right of current
{	Treat nose as a maths operation to perform on the leftmost two elements of this list, remove them both and put the result on the left of this list
}	Treat nose as a maths operation to perform on the rightmost two elements of this list, remove them both and put the result on the right of this list
\	Treat nose as a comparison operation to perform on the leftmost two elements of this list and put 'TRUE' or 'FALSE' on the left of the default list ':'
/	Treat nose as a comparison operation to perform on the rightmost two elements of this list and put 'TRUE' or 'FALSE' on the left of the default list ':'
(	Open a Block
)	Close a Block and return to matching open
|	Divide a block in two
3	Break - If the left of ':' is 'TRUE' move the program counter 'X:' to the next '|' or ')'. If the left of ':' is 'FALSE' do nothing.
E	Break - If the left of ':' is 'TRUE' move the program counter 'X:' to the next '|' or ')' and remove the 'TRUE' from ':'.If the left of ':' is 'FALSE' remove it.
J	Jump to the marker corresponding to its face
^_^	Enter obfuscated mode
^__^	Leave obfuscated mode
_(._.)_	Toggle literal mode
(°_°)_	Marker for whatever face it is holding in its hand
O_o	Break the output stream to a new line

In the table above the current list is the one indicated by 'A:'. This list is the one indicated by the face of the Emoticon being executed. For example in the following Emoticon

)8->

this list is ')8' and the rightmost element of the current list will be moved to the right of ')8'.

Hello World

As a short example to make everything described above make sense here is the Hello World program in Emoticon.

hello world :-Q S:-P :-Q

Lets step through this code to see what happens.

hello	The data item 'hello' is placed on the right of the current list ':'
world	The data item 'world' is placed on the right of the current list ':'
:-Q	The left of the list ':' ('hello') is printed out and then removed
S:-P	The left of the list 'S:' (' ') is printed out
:-Q	The left of the list ':' ('world') is printed out and then removed

You can view this in action (and watch the lists change) using the interpreter.

Flow Control

Flow control in Emoticon is handled by dividing the code into blocks using the '(', ')', '|', '3' and 'E' emoticons.

When an open block '(' is encountered the current value of the program counter 'X:' is stored on the right of the list 'G:'. When a close block ')' is encountered the rightmost value of the list 'G:' is removed and the program counter is set to that value. This causes execution to return to the open block.

For example the following code will print 'help!' forever

help! :-( :-P :-)

Each time the code reaches the last Emoticon (the close block) it will return to the location set in 'G:', which is the location of the last open block.

The Break Emoticons allow you to exit from a block. When a break ('3' or 'E') is executed the left of ':' is examined. If it is 'TRUE' then the program counter is moved forward to the next '|' or ')' and restarts from there. This allows you to exit from a loop, or to use a block as an IF-ELSE construct.

Loops

Here is a break being used to exit a loop

help! :-(
   :-Q
   8-O
   :=\
   :-E
:-)

IF-THEN-ELSE

Here is one being used as an IF - ELSE

8-O 1 [8-O 10
:-(
   8=\
   :-E
   :-O not equal
:-|
   :-O equal
:-)
:~# :-P

Naturally if the interpreter executes a '|' it will move onwards to the end of the corresponding block.

GOTO

You can easily replicate a GOTO instruction by storing the program counter in a List and later setting the program counter to that list using 'D'. Here is an example.

1	X:-O	Set current list to X: (the counter)
2	[8-[	Copy counter (2) to [8
3	...	Do some stuff
4	[8-O	Set current list to [8
5	X:-D	Copy value in X: with that in [8

Because the program counter is always incremented at the end of each cycle the result will be to set the counter to the position of '[8' + 1, in this case 3. So at the end of this example the code will jump back to the '...' instruction. Alternatively, use the Jump emoticon.

Emoticon Reference

Utility Emoticons

Assignment Emoticons

Output Emoticons

Input Emoticons

Maths Emoticons

Comparison Emoticons

Flow Control Emoticons

Compilation Control Emoticons

Output Control Emoticons

Examples

Hello World

Prints "hello world"

hello world :-Q S:-P :-Q

Quine

Prints its own source

Z:-O 8-D 8-O ===||8-< :-( 8-Q [8=\ [8~E S:-P :-)

Reverse Input

Prints its input (the words on the first line), reversed.

hello world
)]:-O :-C :~# :-7
:-O
:-(   [:]o<    8=\ 8-E    :-)
[:]oO
:-(   [:]oQ    8=\ 8-E    :-)

Self-Modifying

Constructs a print-and-pop operator and inserts it into it's own code. The central routine should be entirely portable.

** set up the operator we want to insert **
    8O : - Q
    $:-O 3 8-$   ** implode the characters we read **

** preform the insert **
    E:-O :D      ** clear the : list                                    **
    :-O 0        ** load the length for the splice, 0 means just insert **
    X:-O :-]     ** use prog counter to get the location for the splice **
    :-O 8 :+}    ** increment splice location by offset to location (8) **
    8O Z:-V      ** actually do the splice                              **

** continue after insert **
    :-O
    not_printed  ** insertion point for new code   **
    S:-P
    printed :-Q

Loops

Loops a set number of times, printing the current loop counter.

** first set up some useful values **
    |8-O   5               ** this is the counter for the loop          **
    =|8-O  1               ** this is the decrement value               **
    ()=O   0               ** this is the comparison value for stopping **

** now do the actual looping **
    :-(
       |8-P                ** print the current inner loop value        **
       =|8-O               ** select the decrement value                **
       |8-[                ** copy the decrement value to the counter   **
       |8-}                ** decrement the counter                     **
       |8-O                ** select the counter                        **
       ()=\                ** is the counter equal to the stop value?   **
       :-E                 ** if so break the loop                      **
       :-O - :-Q           ** print a divider                           **
    :-)