Logicode

Logicode is a minimalistic language designed by user:Qwerp-Derp on August 31, 2016. It is heavily inspired by Logisim.

Built-ins
Logicode has three built-in logic gates -

a&b -> AND of a and b   a|b -> OR of a and b    !a  -> NOT of a

...and that's about it. The rest is up to you to build.

DIY Stuff
Circuits

Circuits are basically Logisim's version of functions.

Circuits are built like so:

circ circ_name(arg1,arg2...)->{insert code here}

Breakdown:


 * "circ" is the circuit declarer
 * "circ_name" is the circuit name
 * "arg1,arg2..." are the arguments
 * Everything after the `->` is the code that is executed. NOTE: you do not need curly brackets.

You can also have multi-line circuits, which are like this:

circ circ_name(arg1,arg2...)->[ {code block 1} {code block 2} etc. etc.   ]

The square brackets denote the start and end of a circuit. You can declare variables, do conditions, and return things. Return is implicit.

Variables

Variables are the same as always - except, they can only hold 's and  's.

Variables are built like so:

var var_name=var_value

Breakdown:


 * "var" is the variable declarer
 * "var_name" is the variable name
 * "var_value" is the value. The value can consist of function calls, and can only consist of 's and  's.

Conditionals

The conditionals here are if-else statements, essentially.

They are made like so:

cond cond_arg->{if cond_arg = 1}/{else}

Breakdown:


 * "cond" is the conditional declarer
 * "cond_arg" is either 0 or 1.
 * "/" is required to separate the two blocks of code.

I/O
Input

Input can be inserted into any variable, condition or function like so:

circ foo(a)->input&a (calculates the AND of an input and a)   var bar=input (sets variable bar to an input) cond input->out 1/out 0

Output

Output is declared like so:

out {variable, string of bits, function calls, etc.}

Where  is the output declarer.

Other stuff
Comments

All comments in Logicode are lines which start with a.

Comments are like this:

# This is a comment!

 operator

The  operator is essentially concatenation between two "strings" of binary digits.

It can be used in both circuits (to output multiple bits) and variables/outputs (to concatenate two strings).

in circuits is like this:

circ foo(a,b)->a+b out foo(1,1)

Outputs: 11

in variables/outputs is like this:

var foo=100 var bar=foo+1 out bar+11

Outputs: 100111

ASCII support

The  operator is used to convert binary strings to ASCII.

It is used like this:

out @111111 # Converts 111111 (63 in decimal) to "?" (character code 63)

Outputs: ?

Example Code
Semi-truth-machine

This is a semi-truth-machine (i.e. it doesn't output 1 indefinitely):

circ loop(a)->loop(a) var in=input cond in->out loop(a)/out 0

The circuit  calls itself, and is essentially the infinite loop.

The variable  is the input.

The conditional goes into the loop if  is 1, otherwise it outputs 0.

Half-adder

This is a half-adder:

circ xor(a,b)->(!(a&b))&(a|b) circ halfadder(a,b)->(a&b)+(xor(a,b))

The circuit  is an XOR gate, and the circuit   is the half-adder, which outputs two bits:


 * The bit before the  (which is used to separate output bits for circuits) is , and
 * The bit after the  is.

Interpreters

 * This here is my working interpreter for Logicode as it is now. There may be changes.
 * You can also try it online!