View difference between Paste ID: wS9r2e2R and edAEkfYa

 #!/usr/bin/env python3
 
 """tptasm.py
 
 TPTASM is an assembly language for The Powder Toy's "8-bit processor v1.0" (see http://powdertoy.co.uk/Discussions/Thread/View.html?Thread=17358). Assembly languages make low-level programming a lot easier by getting rid of the bit manipulation and replacing it with friendlier words and numbers that actually show what the code does.
 
 Here is an overview of its syntax:
 
 * Comments start with semicolons (";") e.g. "; This is a comment"
 * RAM addresses are represented with square brackets e.g.
   "[6]" = RAM SLOT 6.
 * To set A, B, C, RAM addresses or STDOUT to something
   use "SET" e.g. "SET A, [6]" (sets A to the value at RAM
   SLOT 7) or "SET [15], 5" (sets RAM SLOT 15 to 5) or "SET
   OUT, [54]" (outputs RAM SLOT 54 to STDOUT)
 * To utilise the ALU use "ADD", "AND" etc. e.g. "ADD [4]"
   (adds A + B and puts the result in RAM SLOT 4) or
   "OR C" (puts A OR B in C)
 * To jump to a line use "JMP" e.g. "JMP 3" (jump to ROM SLOT 3)
 * To conditionally jump to a line use "IFE" e.g. "IFE 5" (if
   A doesn't equal B, jump to line 5)
 * To quit use END by itself on a line.
 """
 
 import re
 import sys
 
 # The regex for a TPTASM number
 number_re = r"(?:[0-9]+|0[xX][0-9a-fA-F]+|0[bB][0-1]+)"
 
 # The regex for a TPTASM name
 name_re = r"(?:[A-Za-z_][A-Za-z0-9_]*)"
 
 # The regex for a line of TPTASM code
-    (?P<line>
+
-        (?P<name>SET|ADD|AND|OR|IFE|JMP|END)
+
-        (   (?<=SET)\s+(?P<set1>A|B|C|OUT|\[{number}\])\s*,\s*(?P<set2>A|B|C|\[{number}\]|{number})
+
-          | (?<=ADD)\s+(?P<add1>\[{number}\]|C)
+    (?:(?P<label>{name}):)? # label
-          | (?<=AND)\s+(?P<and1>\[{number}\]|C)
+
-          | (?<= OR)\s+(?P<or1>\[{number}\]|C)
+    (?P<thingy>
-          | (?<=IFE)\s+(?P<ife1>{number})
+        (?P<line>
-          | (?<=JMP)\s+(?P<jmp1>{number})
+            (?P<name>SET|ADD|SUB|AND|OR|IFE|IFG|IFL|JMP|CLR|END)
-          | (?<=END)
+            (   (?<=SET) \s+(?P<set1>A|B|C|OUT|\[{number}\]|\${name}|\[B\])\s*,\s*(?P<set2>A|B|C|\[{number}\]|\${name}|{number}|INP)
               | (?<=ADD) \s+(?P<add1>\[{number}\]|\${name}|C)
               | (?<=SUB) \s+(?P<sub1>\[{number}\]|\${name}|C)
               | (?<=AND) \s+(?P<and1>\[{number}\]|\${name}|C)
               | (?<= OR) \s+(?P<or1>\[{number}\]|\${name}|C)
               | (?<=IFE) \s+(?P<ife1>{number}|{name})
-    """.format(number=number_re), re.X)
+              | (?<=IFG) \s+(?P<ifg1>{number}|{name})
               | (?<=IFL) \s+(?P<ifl1>{number}|{name})
               | (?<=JMP) \s+(?P<jmp1>{number}|{name})
-    """Check if a string is a PTASM memory address."""
+              | (?<=CLR) \s+(?P<clr1>\[(?:A|B|{number})\]|\${name})
-    return s.startswith('[')
+              | (?<=END)
             )
         )
     )?
     \s*
     (?P<comment>;.*)? # comment
     $
     """.format(number=number_re, name=name_re), re.X)
 
 def isaddr(s):
     """Check if a string is a TPTASM memory address."""
     return s.startswith('[') and isnum(s[1:-1])
 
 def isvar(s):
     """Check if a string is a TPTASM variable."""
     return s.startswith("$")
 
 def isnum(s):
     """Check if a string is a valid Python integer."""
     try:
         int(s, 0)
     except:
         return False
     return True
 
 def num(s):
     """Turn a number string or RAM address into a Python integer."""
     if s.startswith('['):
         return int(s[1:-1], 0)
     return int(s, 0)
 
 def binary(s, width):
     """Make a number binary. Also restrict it to a certain width by adding
     preceding zeros (when necessary)."""
     # YAY double string formatting :)
     return ("{:>0%s}" % width).format(bin(num(s))[2:])
 
-                out.append("{}0000000000000001".format(binary(set2, 8)))
+def getvar(name, varmap):
     """Get a variable's address from a varmap.
-                out.append("{}0000000000000010".format(binary(set2, 8)))
+    If the variable does not exist, create it and give it an address."""
     if name not in varmap:
-                out.append("{}0000000000000011".format(binary(set2, 8)))
+        if len(varmap) == 0:
             n = 1
-                out.append("{}0{}0000100".format(binary(set1, 7), binary(set2, 8)))
+
             n = sorted(varmap.values())[-1] + 1
-                out.append("111111110{}00000101".format(binary(set2, 7)))
+        varmap[name] = n
         #print("Added var {} [{}]".format(name, n))
-                out.append("111111110{}00000110".format(binary(set2, 7)))
+        if n > 100:
             print("WARNING: RAM all used up!")
-                out.append("111111110{}00000111".format(binary(set2, 7)))
+    return "[" + str(varmap[name]) + "]"
 
-                out.append("000000000000000000001000")
+
     """Parse multiple lines of code and output the compiled program in
-                out.append("000000000000000000001001")
+
     lines = text.upper().split('\n')
-                out.append("000000000{}00001010".format(binary(set1, 7)))
+
     labelmap = {}
-                out.append("111111110{}00001101".format(binary(set2, 7)))
+    varmap = {}
     instrno = -1
-                raise Exception("unsupported SET operation")
+
         line2 = line_re.match(line)
         if line2 is None:
-                out.append("000000000000000000011011")
+
         if line2.groupdict()['label'] is not None:
             labelmap[line2.groupdict()['label']] = instrno + 2
-                out.append("000000000{:>07}00011100".format(number))
+        if line2.groupdict()['line'] is None:
             continue
         instrno += 1
-                out.append("000000000000000000101011")
+    instrno = -1
     for lineno, line in enumerate(lines):
         line2 = line_re.match(line)
-                out.append("000000000{:>07}00101100".format(number))
+
         if gd['line'] is None:
             continue
-                out.append("000000000000000000111011")
+        instrno += 1
         if gd['name'] == 'SET':
             set1 = gd['set1']
-                out.append("000000000{:>07}00111100".format(number))
+
             if isvar(set1):
-            number = bin(int(gd['ife1'], 0))[2:]  # convert to binary
+                set1 = getvar(set1, varmap)
-            out.append("000000000{:>07}01000000".format(number))
+            if isvar(set2):
                 set2 = getvar(set2, varmap)
-            number = bin(int(gd['jmp1'], 0))[2:]  # convert to binary
+
-            out.append("000000000{:>07}01010000".format(number))
+                out.append("{}00000000000000001".format(binary(set2, 8)))
             elif set1 == 'B' and isnum(set2):
-            out.append("000000001000000000000000")
+                out.append("{}00000000000000010".format(binary(set2, 8)))
             elif set1 == 'C' and isnum(set2):
                 out.append("{}00000000000000011".format(binary(set2, 8)))
             elif isaddr(set1) and isnum(set2):
                 out.append("{}0{}000000100".format(binary(set2, 8), binary(set1, 7)))
             elif set1 == 'A' and isaddr(set2):
                 out.append("111111110{}000000101".format(binary(set2, 7)))
             elif set1 == 'B' and isaddr(set2):
-    print(
+                out.append("111111110{}000000110".format(binary(set2, 7)))
             elif set1 == 'C' and isaddr(set2):
                 out.append("111111110{}000000111".format(binary(set2, 7)))
             elif set1 == 'A' and set2 == 'C':
                 out.append("0000000000000000000001000")
             elif set1 == 'B' and set2 == 'C':
                 out.append("0000000000000000000001001")
             elif isaddr(set1) and set2 == 'C':
                 out.append("000000000{}000001010".format(binary(set1, 7)))
             elif set1 == 'OUT' and isaddr(set2):
                 out.append("111111110{}000001101".format(binary(set2, 7)))
             elif set1 == '[B]' and set2 == 'A':
                 out.append("0000000000000000000001110")
             elif isaddr(set1) and set2 == "INP":
                 out.append("000000000{}000010010".format(binary(set1, 7)))
             else:
                 raise Exception("unsupported SET operation on line {}".format(lineno + 1))
         elif gd['name'] == 'ADD':
             if isvar(gd['add1']):
                 gd['add1'] = getvar(gd['add1'], varmap)
-    print("Enter code (press {} to finish):".format(("Ctrl-D", "Ctrl-Z")[sys.platform == "win32"]))
+
-    program = sys.stdin.read()
+                out.append("0000000000000000000101011")
             else:  # RAM value
-    print("Here is your program! Enjoy!")
+
                 out.append("000000000{:>07}000101100".format(number))
-        print(i)
+
-    sys.stdin.readline()
+            if isvar(gd['and1']):
                 gd['and1'] = getvar(gd['and1'], varmap)
             if gd['and1'] == 'C':  # register C
                 out.append("0000000000000000001001011")
             else:  # RAM value
                 number = bin(int(gd['and1'][1:-1], 0))[2:]  # convert to binary
                 out.append("000000000{:>07}001001100".format(number))
         elif gd['name'] == 'OR':
             if isvar(gd['or1']):
                 gd['or1'] = getvar(gd['or1'], varmap)
             if gd['or1'] == 'C':  # register C
                 out.append("0000000000000000001101011")
             else:  # RAM value
                 number = bin(int(gd['or1'][1:-1], 0))[2:]  # convert to binary
                 out.append("000000000{:>07}001101100".format(number))
         elif gd['name'] == 'IFE':
             if isnum(gd['ife1']):  # line number
                 number = bin(int(gd['ife1'], 0))[2:]  # convert to binary
             else:  # label
                 number = bin(labelmap[gd['ife1']])[2:]
             out.append("000000000{:>07}010001011".format(number))
         elif gd['name'] == 'JMP':
             if isnum(gd['jmp1']):  # line number
                 number = bin(int(gd['jmp1'], 0))[2:]  # convert to binary
             else:  # label
                 number = bin(labelmap[gd['jmp1']])[2:]
             out.append("000000000{:>07}010101011".format(number))
         elif gd['name'] == 'IFG':
             if isnum(gd['ifg1']):  # line number
                 number = bin(int(gd['ifg1'], 0))[2:]  # convert to binary
             else:  # label
                 number = bin(labelmap[gd['ifg1']])[2:]
             out.append("000000000{:>07}011001011".format(number))  # made up
         elif gd['name'] == 'IFL':
             if isnum(gd['ifl1']):  # line number
                 number = bin(int(gd['ifl1'], 0))[2:]  # convert to binary
             else:  # label
                 number = bin(labelmap[gd['ifl1']])[2:]
             out.append("000000000{:>07}011101011".format(number))  # made up
         elif gd['name'] == 'SUB':
             if isvar(gd['sub1']):
                 gd['sub1'] = getvar(gd['sub1'], varmap)
             if gd['add1'] == 'C':  # register C
                 out.append("0000000000000000100001011")  # made up
             else:  # RAM value
                 number = bin(int(gd['sub1'][1:-1], 0))[2:]  # convert to binary
                 out.append("000000000{:>07}100001100".format(number))  # made up
         elif gd['name'] == 'CLR':
             if isvar(gd['clr1']):
                 gd['clr1'] = getvar(gd['clr1'], varmap)
             if gd['clr1'] == '[A]':
                 out.append("0000000000000000000010000")
             elif gd['clr1'] == '[B]':
                 out.append("0000000000000000000010001")
             else:  # RAM address
                 out.append("000000000{}000001111".format(binary(gd['clr1'], 7)))
         elif gd['name'] == 'END':
             out.append("0000000010000000000000000")
         else:
             raise Exception("something strange happened! Please report this bug!")
 
     if not all([len(i) == 25 for i in out]):
         print(out)
         for i, v in enumerate(out):
             if len(v) != 25:
                 print(i, v)
         raise Exception("uh-oh, something bad happened! Please report this bug!")
 
     return out
 
 def print_(s):
     print("[{}][{}][{}][{}][{}]".format(s[:8], s[8:9], s[9:16], s[16:20], s[20:]))
 
 def main(argv):
     f = sys.stdin
     if len(argv) > 1:
         f = open(argv[1])
     if f == sys.stdin:
         print(
 """TPTASM is an assembly language for The Powder Toy's "8-bit processor v1.0" (see http://powdertoy.co.uk/Discussions/Thread/View.html?Thread=17358). Assembly languages make low-level programming a lot easier by getting rid of the bit manipulation and replacing it with friendlier words and numbers that actually show what the code does.
 
 Here is an overview of its syntax:
 
 * Comments start with semicolons (";") e.g. "; This is a comment"
 * RAM addresses are represented with square brackets e.g.
   "[6]" = RAM SLOT 6.
 * To set A, B, C, RAM addresses or STDOUT to something
   use "SET" e.g. "SET A, [6]" (sets A to the value at RAM
   SLOT 7) or "SET [15], 5" (sets RAM SLOT 15 to 5) or "SET
   OUT, [54]" (outputs RAM SLOT 54 to STDOUT)
 * To utilise the ALU use "ADD", "AND" etc. e.g. "ADD [4]"
   (adds A + B and puts the result in RAM SLOT 4) or
   "OR C" (puts A OR B in C)
 * To make a label use colons e.g. "mainloop:"
 * To jump to a line use "JMP" e.g. "JMP 3" (jump to ROM SLOT 3)
   or use labels e.g. "JMP mainloop" (jump to the label "mainloop")
 * To conditionally jump to a line use "IFE" e.g. "IFE 5" (if
   A doesn't equal B, jump to line 5)
 * To quit use END by itself on a line.
 """)
         print("Enter code (press {} to finish):".format(("Ctrl-D", "Ctrl-Z")[sys.platform == "win32"]))
     program = f.read()
     result = parse(program)
     if f == sys.stdin:
         print("Here is your program! Enjoy!")
     for i in result:
         yield i
     if len(result) > 100:
         print("WARNING: program too long! ({})".format(len(result)))
     if f == sys.stdin:
         sys.stdin.readline()
 
 if __name__ == "__main__":
     for i in main(sys.argv):
         print_(i)