NOR

Description

NOR is an esoteric language created by Dylan Turner to replicate how a processor interprets data on a physical transistor level.

However, instead of using all the logic gates (AND, OR, NOT, NAND, XOR, etc.) it just uses NOR.

NOR is a universal logic gate and thus can be used to make the other gates, just in a much less convenient way.

Data Manipulation

NOR stores data in a strange way. Instead of a data pointer or variables, every time you call the NOR operation, it stores that operation as that line's value. This can be accessed by other NOR calls and outputs. You can access these stored values for lines by placing a "#" followed by a number, a ":", and a default value ("0" or "1"). When the interpreter reads this value, it does the default value if the number hasn't happened yet. It also as an array of input values for program input. At the beginning of each program, you place a line of a single number which is the size of that array. You access the values of this array by saying "IN" and then the index of that array.

Example to show Data Manipulation:

"100 NOR #300:0, 1" - stores the NOR of line 300 and 1 into line 100. Except that at the start, line 300 hasn't happened yet, so it does the default value of 0.

"200 OUT #100:1" - prints the value of that last NOR

"300 NOR 0, IN0" - stores the NOR of 0 and input[0]

"400 JMP 100" - Jumps back to 100, now with a value for line 300

Op Codes

NOR has 10 OpCodes: NOR, INP, OUT, OLN, JMP, REM, RND, OFF, MUX, and RST, and it works much like basic, with line numbers. Commas are optional, but they help to make the code look nice.

OpCode	Arguments	Meaning
NOR	LN NOR #1, #2	At line LN, set the line value to the NOR operation of #1 and #2
INP	LN INP IN#	At line LN, input a 0 or 1 to the array of input values
OUT	LN OUT #	At line LN, prints out the value of #
OLN	LN OLN	At line LN, prints a new line
JMP	LN JMP #	At line LN, jump to line #
REM	LN REM blah blah blah	Works as a comment (NOTE: still needs a line number)
RND	LN RND IN#	At line LN, sets input[#] to a random value between 0 and 1, or without argument sets the line to a random number.
OFF	LN OFF	At Line LN, turn off the circuit (end the program)
MUX	LN MUX #, Jump1, Jump2	At line LN, if # is 0 go to line Jump1, and if # is 1 go to line Jump2. This is essentially a multiplexer.
RST	LN RST	At line LN, reset all line values to nonexistance

Obviously the key opcode is the NOR opcode. Not only does it work as a NOR, but it can be used to represent some conditionals.

LN NOR #, 0

Is the same as:

if (# == 0)
    line[LN]=1
else
    line[LN]=0

Where line is an infinite array that stores the value of each line number, and # is a value equal to 0, 1, line[some number], or input[some number].

For the multiplexer command:

LN MUX #, Jump1, Jump2

Is the same as

if(# == 0)
    Goto Jump1
else if(# == 1)
    Goto Jump2

Turing Completeness

NOR was previously proven to not be Turing-complete because it was possible to solve for the halting problem, but that was before the OFF and MUX commands were added which change this result. No longer is that known.

Example Programs

Here are a few example programs:

1bit Adder.nor

Adds two 1bit numbers together (w/ carry):

2

0 INP IN0
100 INP IN1
150 OLN

200 REM XOR logic here
  300 NOR IN0, IN0
  400 NOR IN1, IN1
  500 NOR #300:0, #400:0
  600 NOR IN0, IN1
  650 NOR #600:0, #620:0
700 REM AND logic here
  800 NOR IN0, IN0
  900 NOR IN1, IN1
  1000 NOR #800:0, #900:0
1100 REM Output carry then value
  1200 OUT #1000:0
  1300 OUT #650:0
  1310 OLN
1325 JMP 1375

1350 OFF

1375 REM Input and repeat if 1
  1400 INP IN0
  1500 MUX IN0, 1350, 1600

1600 OLN
1700 JMP 0

Infinite Loop.nor

Infinitely prints 0 and 1 (alternating)

0
0 REM Infinite loop
50 NOR #50:0, 0
100 OUT #50:0
200 JMP 50

Truth Machine.nor

Prints 0 if input is 0.

Prints 1 infinitely if input is 1

1
0 REM Input a value
10 INP in1

20 REM Split the circuit into two paths:
30 REM if 0, goto OUT 0 (Line 70)
40 REM if 1, goto OUT 1 (Line 100 - the infinite loop)
50 MUX in1, 70, 100

60 REM Print 0 and then quit
    70 OUT 0
    80 OFF

90 REM Print 1 indefinitely 
    100 OUT 1
    110 JMP 100

Hello, world.nor

You can't print ascii values directly, but you can print the binary equivalent

Also, you can print directly 1s and 0s with OUT, but I take the long way, changing individual line values and printing a string of changing values

Because of its tediousness, I only go to print "Hello" in ascii

1
0 REM store the H in line values
 10 NOR 0, 1
 20 NOR 0, 0
 30 NOR 0, 1
 40 NOR 0, 1
 50 NOR 0, 0
 60 NOR 0, 1
 70 NOR 0, 1
 80 NOR 0, 1
90 REM print it all out
 100 OUT #10:0
 110 OUT #20:0
 120 OUT #30:0
 130 OUT #40:0
 140 OUT #50:0
 150 OUT #60:0
 160 OUT #70:0
 170 OUT #80:0
 175 OLN
180 REM Change to little e
 190 NOR #30:0, 0
 200 NOR #50:0, 0
 210 NOR #60:0, 0
 230 NOR #80:0, 0
240 REM Output with replaced values
 250 OUT #10:0
 260 OUT #20:0
 270 OUT #190:0
 280 OUT #40:0
 290 OUT #200:0
 300 OUT #210:0
 310 OUT #70:0
 320 OUT #230:0
 325 OLN
330 REM Change to little l
 340 NOR #200:0, 0
 350 NOR #230:0, 0
 360 REM Output little l twice
 370 OUT #10:0
 380 OUT #20:0
 390 OUT #190:0
 400 OUT #40:0
 410 OUT #340:0
 420 OUT #210:0
 430 OUT #70:0
 440 OUT #350:0
 445 OLN
 450 OUT #10:0
 460 OUT #20:0
 470 OUT #190:0
 480 OUT #40:0
 490 OUT #340:0
 500 OUT #210:0
 510 OUT #70:0
 520 OUT #350:0
 525 OLN
530 REM Change to little o
 540 NOR #70:0, 0
 550 NOR #350:0, 0
560 REM Output little o
 570 OUT #10:0
 580 OUT #20:0
 590 OUT #190:0
 600 OUT #40:0
 610 OUT #340:0
 620 OUT #210:0
 630 OUT #540:0
 640 OUT #550:0
 645 OLN
650 REM Pause at end
 660 INP in0

Decrement Test.nor

A program which counts down two line numbers.

It outputs 11, 10, 01, 00.

1
0 REM Decreases line values from 11 -> 10 -> 0 -> 00
10 NOR #90:0, #90:0
20 NOR #60:0, #60:0

30 NOR #10:1, #20:1
40 MUX #30:0, 50, 100

50 NOR #20:1, 0
60 NOR #50:0, #50:0

70 NOR #10:1, #10:1
80 NOR #70:1, #50:0
90 NOR #80:1, #80:1

95 JMP 10

24 OUT #10:1
25 OUT #20:1
26 OLN

100 INP IN0

Guess the Number (4-bit).nor

Input 4 bits of a number as your guess.

It says "L" in binary if your guess is less than the number, meaning you should guess higher.

It says "G" in binary if your guess is greater than the number, meaning you should guess lower.

It says "W" in binary if you guess the number and waits to see if you want to play again.

It says "D" in binary if you run out of guesses (you start with 3) and waits to see if you want to play again.

At the end it inputs a value: a 0 ends the program, a 1 has you play again.

4
99 REM Get 4 inputs and 4 random numbers
  100 RND
  101 RND
  102 RND
  103 RND
  150 INP in0
  200 INP in1
  250 INP in2
  300 INP in3
  
301 REM Store value of lives, starting with lives = 11 (3)
  302 NOR #4101:0, #4101:0
  303 NOR #4051:0, #4051:0

349 REM Check for in0 == 1 && #100 == 0
  350 NOR in0, 0
  400 NOR #100:0, #350:0
450 REM if #400 == 0, Move on, else Check for error
  500 MUX #400:1, 650, 550
550 REM Number is greater than #100: print "G" in binary
  599 OLN
  600 OUT 0
  601 OUT 1
  602 OUT 0
  603 OUT 0
  604 OUT 0
  605 OUT 1
  606 OUT 1
  607 OUT 1
  608 OLN
  610 JMP 4000

4000 REM Decrease lives and retake input
  4050 NOR #303:1, 0
  4051 NOR #4050:0, #4050:0
  
  4052 NOR #302:1, #302:1
  4100 NOR #4052:0, #4050:0
  4101 NOR #4100:0, #4100:0

  4102 REM Check if dead
    4103 NOR #4100:1, #4050:1
    4104 MUX #4103:0, 4150, 4200

  4150 JMP 150

4200 REM Game over: print "D" in binary
  4249 OLN
  4250 OUT 0
  4251 OUT 1
  4252 OUT 0
  4253 OUT 0
  4254 OUT 0
  4255 OUT 1
  4256 OUT 0
  4257 OUT 0
  4300 OLN
  4350 JMP 2560

650 REM Check for less than => in0 == 0 && #100 = 1
  700 NOR #100:1, 0
  750 NOR #700:0, in0
  800 MUX #750:1, 950, 850
850 REM if input is less than #100: print "L" in binary
  900 OLN
  901 OUT 0
  902 OUT 1
  903 OUT 0
  904 OUT 0
  905 OUT 1
  906 OUT 1
  907 OUT 0
  908 OUT 0
  909 OLN
  910 JMP 4000
950 REM they must be equal, so repeat with next part of the nibble

1000 REM Check for in0 == 1 && #100 == 0
  1050 NOR in0, 0
  1100 NOR #100:0, #350:0
1150 REM if #400 == 0, Move on, else Check for error
  1200 MUX #400:1, 1250, 550
1250 REM Check for less than => in0 == 0 && #100 = 1
  1300 NOR #100:1, 0
  1350 NOR #700:0, in0
  1400 MUX #750:1, 1450, 850
1450 REM Next part is equal, so move on

1500 REM Check for in0 == 1 && #100 == 0
  1550 NOR in0, 0
  1600 NOR #100:0, #350:0
1650 REM if #400 == 0, Move on, else Check for error
  1700 MUX #400:1, 1750, 550
1750 REM Check for less than => in0 == 0 && #100 = 1
  1800 NOR #100:1, 0
  1850 NOR #700:0, in0
  1900 MUX #750:1, 1950, 850
1950 REM Next part is equal, so move on

2000 REM Check for in0 == 1 && #100 == 0
  2050 NOR in0, 0
  2100 NOR #100:0, #350:0
2150 REM if #400 == 0, Move on, else Check for error
  2200 MUX #400:1, 2250, 550
2250 REM Check for less than => in0 == 0 && #100 = 1
  2300 NOR #100:1, 0
  2350 NOR #700:0, in0
  2400 MUX #750:1, 2450, 850
2450 REM Last part is equal, you win
2500 REM print W in binary
  2550 OLN
  2551 OUT 0
  2552 OUT 1
  2553 OUT 0
  2554 OUT 1
  2555 OUT 0
  2556 OUT 1
  2557 OUT 1
  2558 OUT 1
  2559 OLN
  2560 INP in0
  2600 MUX in0, 2650, 2700
2650 OFF

2700 RST
2750 JMP 99

Interpreter/Compiler

So far there's just one interpreter made in C# for the language: NOR Language Interpreter which can run all NOR programs.