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.
Category:Languages Category:Implemented