August 30, 2013 17:41 · jgarte · Apr 5, 2021 · Tyler887 · Mar 5, 2022
diff --git a/fish.py b/fish.py
 #!/usr/local/bin/python3.2

 """

 Python interpreter for the esoteric language ><> (pronounced /ˈfɪʃ/).
 Usage: ./fish.py --help

 More information: http://esolangs.org/wiki/Fish

 Requires python 2.7/3.2 or higher.

 """

 import sys
 import time
 import random
 from collections import defaultdict

 # constants
 NCHARS = "0123456789abcdef"
 ARITHMETIC = "+-*%" # not division, as it requires special handling
 COMPARISON = { "=": "==", "(": "<", ")": ">" }
 DIRECTIONS = { ">": (1,0), "<": (-1,0), "v": (0,1), "^": (0,-1) }
 MIRRORS = { 
    "/": lambda x,y: (-y, -x),
    "\\": lambda x,y: (y, x),
    "|": lambda x,y: (-x, y),
    "_": lambda x,y: (x, -y),
    "#": lambda x,y: (-x, -y)
 }


 class _Getch:
    """

    Provide cross-platform getch functionality. Shamelessly stolen from 
    http://code.activestate.com/recipes/134892/

    """
    def __init__(self):
        try:
            self._impl = _GetchWindows()
        except ImportError:
            self._impl = _GetchUnix()

    def __call__(self): return self._impl()


 class _GetchUnix:
    def __init__(self):
        import tty, sys

    def __call__(self):
        import sys, tty, termios
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(sys.stdin.fileno())
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch


 class _GetchWindows:
    def __init__(self):
        import msvcrt

    def __call__(self):
        import msvcrt
        return msvcrt.getch()
 getch = _Getch()


 def read_character():
    """Read one character from stdin. Returns -1 when no input is available."""
    if sys.stdin.isatty():
        # we're in console, read a character from the user
        char = getch() 
        # check for ctrl-c (break)
        if ord(char) == 3:
            sys.stdout.write("^C")
            sys.stdout.flush()
            raise KeyboardInterrupt
        else: return char
    else:
        # input is redirected using pipes
        char = sys.stdin.read(1)
        # return -1 if there is no more input available
        return char if char != "" else -1


 class Interpreter:
    """

    ><> "compiler" and interpreter.

    """
    def __init__(self, code):
        """
        Initialize a new interpreter.

        Arguments:
            code -- the code to execute as a string
        """
        # check for hashbang in first line
        lines = code.split("\n")
        if lines[0][:2] == "#!":
            code = "\n".join(lines[1:])
        
        # construct a 2D defaultdict to contain the code
        self._codebox = defaultdict(lambda: defaultdict(int))
        line_n = char_n = 0
        for char in code:
            if char != "\n":
                self._codebox[line_n][char_n] = 0 if char == " " else ord(char)
                char_n += 1
            else:
                char_n = 0
                line_n += 1
        

        self._position = [-1,0]
        self._direction = DIRECTIONS[">"]
        
        # the register is initially empty
        self._register_stack = [None]
        # string mode is initially disabled
        self._string_mode = None
        # have we encountered a skip instruction?
        self._skip = False
        
        self._stack = []
        self._stack_stack = [self._stack]

        # is the last outputted character a newline?
        self._newline = None
    
    def move(self):
        """
        Move one step in the execution process, and handle the instruction (if
        any) at the new position.
        """
        # move one step in the current direction
        self._position[0] += self._direction[0]
        self._position[1] += self._direction[1]

        # wrap around if we reach the borders of the codebox
        if self._position[1] > max(self._codebox.keys()):
            # if the current position is beyond the number of lines, wrap to
            # the top
            self._position[1] = 0
        elif self._position[1] < 0:
            # if we're above the top, move to the bottom
            self._position[1] = max(self._codebox.keys())
        
        if self._direction[0] == 1 and self._position[0] > max(self._codebox[self._position[1]].keys()):
            # wrap to the beginning if we are beyond the last character on a 
            # line and moving rightwards
            self._position[0] = 0;
        elif self._position[0] < 0:
            # also wrap if we reach the left hand side
            self._position[0] = max(self._codebox[self._position[1]].keys())
        
        # execute the instruction found
        if not self._skip:
            instruction = int(self._codebox[self._position[1]][self._position[0]])
            # the current position might not be a valid character
            try:
                # use space if current cell is 0
                instruction = chr(instruction) if instruction > 0 else " "
            except:
                instruction = None
            try:
                self._handle_instruction(instruction)
            except StopExecution:
                raise
            except KeyboardInterrupt:
                # avoid catching as error
                raise KeyboardInterrupt
            except Exception as e:
                raise StopExecution("something smells fishy...")
            return instruction
        
        self._skip = False
    
    def _handle_instruction(self, instruction):
        """
        Execute an instruction.
        """
        if instruction == None:
            # error on invalid characters
            raise Exception
        
        # handle string mode
        if self._string_mode != None and self._string_mode != instruction:
            self._push(ord(instruction))
            return
        elif self._string_mode == instruction:
            self._string_mode = None
            return
        
        # instruction is one of ^v><, change direction
        if instruction in DIRECTIONS:
            self._direction = DIRECTIONS[instruction]

        # direction is a mirror, get new direction
        elif instruction in MIRRORS:
            self._direction = MIRRORS[instruction](*self._direction)
        
        # pick a random direction
        elif instruction == "x":
            self._direction = random.choice(list(DIRECTIONS.items()))[1]
        
        # portal; move IP to coordinates
        elif instruction == ".":
            y, x = self._pop(), self._pop()
            # IP cannot reach negative codebox
            if x < 0 or y < 0:
                raise Exception
            self._position = [x,y]
        
        # instruction is 0-9a-f, push corresponding hex value
        elif instruction in NCHARS:
            self._push(int(instruction, len(NCHARS)))
        
        # instruction is an arithmetic operator
        elif instruction in ARITHMETIC:
            a, b = self._pop(), self._pop()
            exec("self._push(b{}a)".format(instruction))
        
        # division
        elif instruction == ",":
            a, b = self._pop(), self._pop()
            # try converting them to floats for python 2 compability
            try:
                a, b = float(a), float(b)
            except OverflowError:
                pass
            self._push(b/a)
        
        # comparison operators
        elif instruction in COMPARISON:
            a, b = self._pop(), self._pop()
            exec("self._push(1 if b{}a else 0)".format(COMPARISON[instruction]))

        # turn on string mode
        elif instruction in "'\"": # turn on string parsing
            self._string_mode = instruction

        # skip one command
        elif instruction == "!":
            self._skip = True
        
         # skip one command if popped value is 0
        elif instruction == "?":
            if not self._pop():
                self._skip = True

        # push length of stack
        elif instruction == "l":
            self._push(len(self._stack))
        
        # duplicate top of stack
        elif instruction == ":":
            self._push(self._stack[-1])

        # remove top of stack
        elif instruction == "~":
            self._pop()
        
        # swap top two values
        elif instruction == "$":
            a, b = self._pop(), self._pop()
            self._push(a)
            self._push(b)
        
        # swap top three values
        elif instruction == "@":
            a, b, c = self._pop(), self._pop(), self._pop()
            self._push(a)
            self._push(c)
            self._push(b)
        
        # put/get register
        elif instruction == "&":
            if self._register_stack[-1] == None:
                self._register_stack[-1] = self._pop()
            else:
                self._push(self._register_stack[-1])
                self._register_stack[-1] = None
        
        # reverse stack
        elif instruction == "r":
            self._stack.reverse()

        # right-shift stack
        elif instruction == "}":
            self._push(self._pop(), index=0)
        
        # left-shift stack
        elif instruction == "{":
            self._push(self._pop(index=0))
        
        # get value in codebox
        elif instruction == "g":
            x, y = self._pop(), self._pop()
            self._push(self._codebox[x][y])
        
        # set (put) value in codebox
        elif instruction == "p":
            x, y, z = self._pop(), self._pop(), self._pop()
            self._codebox[x][y] = z
        
        # pop and output as character
        elif instruction == "o":
            self._output(chr(int(self._pop())))
        
        # pop and output as number
        elif instruction == "n":
            n = self._pop()
            # try outputting without the decimal point if possible
            self._output(int(n) if int(n) == n else n)

        # get one character from input and push it
        elif instruction == "i":
            i = self._input()
            self._push(ord(i) if isinstance(i, str) else i)
        
        # pop x and create a new stack with x members moved from the old stack
        elif instruction == "[":
            count = int(self._pop())
            if count == 0:
                self._stack_stack[-1], new_stack = self._stack, []
            else:
                self._stack_stack[-1], new_stack = self._stack[:-count], self._stack[-count:]
            self._stack_stack.append(new_stack)
            self._stack = new_stack

            # create a new register for this stack
            self._register_stack.append(None)
        
        # remove current stack, moving its members to the previous stack. 
        # if this is the last stack, a new, empty stack is pushed
        elif instruction == "]":
            old_stack = self._stack_stack.pop()
            if not len(self._stack_stack):
                self._stack_stack.append([])
            else:
                self._stack_stack[-1] += old_stack
            self._stack = self._stack_stack[-1]
            
            # register is dropped
            self._register_stack.pop()
            if not len(self._register_stack):
                self._register_stack.append(None)
        
        # the end
        elif instruction == ";":
            raise StopExecution()
        
        # space is NOP
        elif instruction == " ":
            pass

        # invalid instruction
        else:
            raise Exception("Invalid instruction", instruction)
    
    def _push(self, value, index=None):
        """
        Push a value to the current stack.

        Keyword arguments:
            index -- the index to push/insert to. (default: end of stack)
        """
        self._stack.insert(len(self._stack) if index == None else index, value)
        
    def _pop(self, index=None):
        """
        Pop and return a value from the current stack.

        Keyword arguments:
            index -- the index to pop from (default: end of stack)
        """
        # don't care about exceptions - they are handled at a higher level
        value = self._stack.pop(len(self._stack)-1 if index == None else index)
        # convert to int where possible to avoid float overflow
        if value == int(value):
            value = int(value)
        return value

    def _input(self):
        """
        Return an inputted character.
        """
        return read_character()

    
    def _output(self, output):
        """
        Output a string without a newline appended.
        """
        output = str(output)
        self._newline = output.endswith("\n")
        sys.stdout.write(output)
        sys.stdout.flush()


 class StopExecution(Exception):
    """
    Exception raised when a script has finished execution.
    """
    def __init__(self, message=None):
        self.message = message

 if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description="""
    Execute a ><> script.

    Executing a script is as easy as:
        %(prog)s <script file>

    You can also execute code directly using the -c/--code flag:
        %(prog)s -c '1n23nn;'
        > 132

    The -v and -s flags can be used to prepopulate the stack:
        %(prog)s echo.fish -s "hello, world" -v 32 49 50 51 -s "456"
        > hello, world 123456""", usage="""%(prog)s [-h] (<script file> | -c <code>) [<options>]""", 
    formatter_class=argparse.RawDescriptionHelpFormatter)
    
    group = parser.add_argument_group("code")
    # group script file and --code together to only allow one
    code_group = group.add_mutually_exclusive_group(required=True)
    code_group.add_argument("script", 
                            type=argparse.FileType("r"), 
                            nargs="?", 
                            help=".fish file to execute")
    code_group.add_argument("-c", "--code", 
                            metavar="<code>", 
                            help="string of instructions to execute")
    
    options = parser.add_argument_group("options")
    options.add_argument("-s", "--string", 
                         action="append", 
                         metavar="<string>", 
                         dest="stack")
    options.add_argument("-v", "--value", 
                         type=float, 
                         nargs="+", 
                         action="append",
                         metavar="<number>",  
                         dest="stack", 
                         help="push numbers or strings onto the stack before execution starts")
    options.add_argument("-t", "--tick", 
                         type=float,
                         default=0.0,
                         metavar="<seconds>",
                         help="define a tick time, or a delay between the execution of each instruction")
    options.add_argument("-a", "--always-tick",
                         action="store_true", 
                         default=False,
                         dest="always_tick", 
                         help="make every instruction cause a tick (delay), even whitespace and skipped instructions")
    
    # parse arguments from sys.argv
    arguments = parser.parse_args()
    
    # initialize an interpreter
    if arguments.script:
        code = arguments.script.read()
        arguments.script.close()
    else:
        code = arguments.code
    
    interpreter = Interpreter(code)

    # add supplied values to the interpreters stack
    if arguments.stack:
        for x in arguments.stack:
            if isinstance(x, str):
                interpreter._stack += [float(ord(c)) for c in x]
            else:
                interpreter._stack += x

    # run the script
    try:
        while True:
            try:
                instr = interpreter.move()
            except StopExecution as stop:
                # only print a newline if the script didn't
                newline = ("\n" if (not interpreter._newline) and interpreter._newline != None else "")
                parser.exit(message=(newline+stop.message+"\n") if stop.message else newline)
            
            if instr and not instr == " " or arguments.always_tick:
                time.sleep(arguments.tick)
    except KeyboardInterrupt:
        # exit cleanly
        parser.exit(message="\n")
	#!/usr/local/bin/python3.2

	"""

	Python interpreter for the esoteric language ><> (pronounced /ˈfɪʃ/).
	Usage: ./fish.py --help

	More information: http://esolangs.org/wiki/Fish

	Requires python 2.7/3.2 or higher.

	"""

	import sys
	import time
	import random
	from collections import defaultdict

	# constants
	NCHARS = "0123456789abcdef"
	ARITHMETIC = "+-*%" # not division, as it requires special handling
	COMPARISON = { "=": "==", "(": "<", ")": ">" }
	DIRECTIONS = { ">": (1,0), "<": (-1,0), "v": (0,1), "^": (0,-1) }
	MIRRORS = {
	"/": lambda x,y: (-y, -x),
	"\\": lambda x,y: (y, x),
	"\|": lambda x,y: (-x, y),
	"_": lambda x,y: (x, -y),
	"#": lambda x,y: (-x, -y)
	}


	class _Getch:
	"""

	Provide cross-platform getch functionality. Shamelessly stolen from
	http://code.activestate.com/recipes/134892/

	"""
	def __init__(self):
	try:
	self._impl = _GetchWindows()
	except ImportError:
	self._impl = _GetchUnix()

	def __call__(self): return self._impl()


	class _GetchUnix:
	def __init__(self):
	import tty, sys

	def __call__(self):
	import sys, tty, termios
	fd = sys.stdin.fileno()
	old_settings = termios.tcgetattr(fd)
	try:
	tty.setraw(sys.stdin.fileno())
	ch = sys.stdin.read(1)
	finally:
	termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
	return ch


	class _GetchWindows:
	def __init__(self):
	import msvcrt

	def __call__(self):
	import msvcrt
	return msvcrt.getch()
	getch = _Getch()


	def read_character():
	"""Read one character from stdin. Returns -1 when no input is available."""
	if sys.stdin.isatty():
	# we're in console, read a character from the user
	char = getch()
	# check for ctrl-c (break)
	if ord(char) == 3:
	sys.stdout.write("^C")
	sys.stdout.flush()
	raise KeyboardInterrupt
	else: return char
	else:
	# input is redirected using pipes
	char = sys.stdin.read(1)
	# return -1 if there is no more input available
	return char if char != "" else -1


	class Interpreter:
	"""

	><> "compiler" and interpreter.

	"""
	def __init__(self, code):
	"""
	Initialize a new interpreter.

	Arguments:
	code -- the code to execute as a string
	"""
	# check for hashbang in first line
	lines = code.split("\n")
	if lines[0][:2] == "#!":
	code = "\n".join(lines[1:])

	# construct a 2D defaultdict to contain the code
	self._codebox = defaultdict(lambda: defaultdict(int))
	line_n = char_n = 0
	for char in code:
	if char != "\n":
	self._codebox[line_n][char_n] = 0 if char == " " else ord(char)
	char_n += 1
	else:
	char_n = 0
	line_n += 1


	self._position = [-1,0]
	self._direction = DIRECTIONS[">"]

	# the register is initially empty
	self._register_stack = [None]
	# string mode is initially disabled
	self._string_mode = None
	# have we encountered a skip instruction?
	self._skip = False

	self._stack = []
	self._stack_stack = [self._stack]

	# is the last outputted character a newline?
	self._newline = None

	def move(self):
	"""
	Move one step in the execution process, and handle the instruction (if
	any) at the new position.
	"""
	# move one step in the current direction
	self._position[0] += self._direction[0]
	self._position[1] += self._direction[1]

	# wrap around if we reach the borders of the codebox
	if self._position[1] > max(self._codebox.keys()):
	# if the current position is beyond the number of lines, wrap to
	# the top
	self._position[1] = 0
	elif self._position[1] < 0:
	# if we're above the top, move to the bottom
	self._position[1] = max(self._codebox.keys())

	if self._direction[0] == 1 and self._position[0] > max(self._codebox[self._position[1]].keys()):
	# wrap to the beginning if we are beyond the last character on a
	# line and moving rightwards
	self._position[0] = 0;
	elif self._position[0] < 0:
	# also wrap if we reach the left hand side
	self._position[0] = max(self._codebox[self._position[1]].keys())

	# execute the instruction found
	if not self._skip:
	instruction = int(self._codebox[self._position[1]][self._position[0]])
	# the current position might not be a valid character
	try:
	# use space if current cell is 0
	instruction = chr(instruction) if instruction > 0 else " "
	except:
	instruction = None
	try:
	self._handle_instruction(instruction)
	except StopExecution:
	raise
	except KeyboardInterrupt:
	# avoid catching as error
	raise KeyboardInterrupt
	except Exception as e:
	raise StopExecution("something smells fishy...")
	return instruction

	self._skip = False

	def _handle_instruction(self, instruction):
	"""
	Execute an instruction.
	"""
	if instruction == None:
	# error on invalid characters
	raise Exception

	# handle string mode
	if self._string_mode != None and self._string_mode != instruction:
	self._push(ord(instruction))
	return
	elif self._string_mode == instruction:
	self._string_mode = None
	return

	# instruction is one of ^v><, change direction
	if instruction in DIRECTIONS:
	self._direction = DIRECTIONS[instruction]

	# direction is a mirror, get new direction
	elif instruction in MIRRORS:
	self._direction = MIRRORS[instruction](*self._direction)

	# pick a random direction
	elif instruction == "x":
	self._direction = random.choice(list(DIRECTIONS.items()))[1]

	# portal; move IP to coordinates
	elif instruction == ".":
	y, x = self._pop(), self._pop()
	# IP cannot reach negative codebox
	if x < 0 or y < 0:
	raise Exception
	self._position = [x,y]

	# instruction is 0-9a-f, push corresponding hex value
	elif instruction in NCHARS:
	self._push(int(instruction, len(NCHARS)))

	# instruction is an arithmetic operator
	elif instruction in ARITHMETIC:
	a, b = self._pop(), self._pop()
	exec("self._push(b{}a)".format(instruction))

	# division
	elif instruction == ",":
	a, b = self._pop(), self._pop()
	# try converting them to floats for python 2 compability
	try:
	a, b = float(a), float(b)
	except OverflowError:
	pass
	self._push(b/a)

	# comparison operators
	elif instruction in COMPARISON:
	a, b = self._pop(), self._pop()
	exec("self._push(1 if b{}a else 0)".format(COMPARISON[instruction]))

	# turn on string mode
	elif instruction in "'\"": # turn on string parsing
	self._string_mode = instruction

	# skip one command
	elif instruction == "!":
	self._skip = True

	# skip one command if popped value is 0
	elif instruction == "?":
	if not self._pop():
	self._skip = True

	# push length of stack
	elif instruction == "l":
	self._push(len(self._stack))

	# duplicate top of stack
	elif instruction == ":":
	self._push(self._stack[-1])

	# remove top of stack
	elif instruction == "~":
	self._pop()

	# swap top two values
	elif instruction == "$":
	a, b = self._pop(), self._pop()
	self._push(a)
	self._push(b)

	# swap top three values
	elif instruction == "@":
	a, b, c = self._pop(), self._pop(), self._pop()
	self._push(a)
	self._push(c)
	self._push(b)

	# put/get register
	elif instruction == "&":
	if self._register_stack[-1] == None:
	self._register_stack[-1] = self._pop()
	else:
	self._push(self._register_stack[-1])
	self._register_stack[-1] = None

	# reverse stack
	elif instruction == "r":
	self._stack.reverse()

	# right-shift stack
	elif instruction == "}":
	self._push(self._pop(), index=0)

	# left-shift stack
	elif instruction == "{":
	self._push(self._pop(index=0))

	# get value in codebox
	elif instruction == "g":
	x, y = self._pop(), self._pop()
	self._push(self._codebox[x][y])

	# set (put) value in codebox
	elif instruction == "p":
	x, y, z = self._pop(), self._pop(), self._pop()
	self._codebox[x][y] = z

	# pop and output as character
	elif instruction == "o":
	self._output(chr(int(self._pop())))

	# pop and output as number
	elif instruction == "n":
	n = self._pop()
	# try outputting without the decimal point if possible
	self._output(int(n) if int(n) == n else n)

	# get one character from input and push it
	elif instruction == "i":
	i = self._input()
	self._push(ord(i) if isinstance(i, str) else i)

	# pop x and create a new stack with x members moved from the old stack
	elif instruction == "[":
	count = int(self._pop())
	if count == 0:
	self._stack_stack[-1], new_stack = self._stack, []
	else:
	self._stack_stack[-1], new_stack = self._stack[:-count], self._stack[-count:]
	self._stack_stack.append(new_stack)
	self._stack = new_stack

	# create a new register for this stack
	self._register_stack.append(None)

	# remove current stack, moving its members to the previous stack.
	# if this is the last stack, a new, empty stack is pushed
	elif instruction == "]":
	old_stack = self._stack_stack.pop()
	if not len(self._stack_stack):
	self._stack_stack.append([])
	else:
	self._stack_stack[-1] += old_stack
	self._stack = self._stack_stack[-1]

	# register is dropped
	self._register_stack.pop()
	if not len(self._register_stack):
	self._register_stack.append(None)

	# the end
	elif instruction == ";":
	raise StopExecution()

	# space is NOP
	elif instruction == " ":
	pass

	# invalid instruction
	else:
	raise Exception("Invalid instruction", instruction)

	def _push(self, value, index=None):
	"""
	Push a value to the current stack.

	Keyword arguments:
	index -- the index to push/insert to. (default: end of stack)
	"""
	self._stack.insert(len(self._stack) if index == None else index, value)

	def _pop(self, index=None):
	"""
	Pop and return a value from the current stack.

	Keyword arguments:
	index -- the index to pop from (default: end of stack)
	"""
	# don't care about exceptions - they are handled at a higher level
	value = self._stack.pop(len(self._stack)-1 if index == None else index)
	# convert to int where possible to avoid float overflow
	if value == int(value):
	value = int(value)
	return value

	def _input(self):
	"""
	Return an inputted character.
	"""
	return read_character()


	def _output(self, output):
	"""
	Output a string without a newline appended.
	"""
	output = str(output)
	self._newline = output.endswith("\n")
	sys.stdout.write(output)
	sys.stdout.flush()


	class StopExecution(Exception):
	"""
	Exception raised when a script has finished execution.
	"""
	def __init__(self, message=None):
	self.message = message

	if __name__ == "__main__":
	import argparse

	parser = argparse.ArgumentParser(description="""
	Execute a ><> script.

	Executing a script is as easy as:
	%(prog)s <script file>

	You can also execute code directly using the -c/--code flag:
	%(prog)s -c '1n23nn;'
	> 132

	The -v and -s flags can be used to prepopulate the stack:
	%(prog)s echo.fish -s "hello, world" -v 32 49 50 51 -s "456"
	> hello, world 123456""", usage="""%(prog)s [-h] (<script file> \| -c <code>) [<options>]""",
	formatter_class=argparse.RawDescriptionHelpFormatter)

	group = parser.add_argument_group("code")
	# group script file and --code together to only allow one
	code_group = group.add_mutually_exclusive_group(required=True)
	code_group.add_argument("script",
	type=argparse.FileType("r"),
	nargs="?",
	help=".fish file to execute")
	code_group.add_argument("-c", "--code",
	metavar="<code>",
	help="string of instructions to execute")

	options = parser.add_argument_group("options")
	options.add_argument("-s", "--string",
	action="append",
	metavar="<string>",
	dest="stack")
	options.add_argument("-v", "--value",
	type=float,
	nargs="+",
	action="append",
	metavar="<number>",
	dest="stack",
	help="push numbers or strings onto the stack before execution starts")
	options.add_argument("-t", "--tick",
	type=float,
	default=0.0,
	metavar="<seconds>",
	help="define a tick time, or a delay between the execution of each instruction")
	options.add_argument("-a", "--always-tick",
	action="store_true",
	default=False,
	dest="always_tick",
	help="make every instruction cause a tick (delay), even whitespace and skipped instructions")

	# parse arguments from sys.argv
	arguments = parser.parse_args()

	# initialize an interpreter
	if arguments.script:
	code = arguments.script.read()
	arguments.script.close()
	else:
	code = arguments.code

	interpreter = Interpreter(code)

	# add supplied values to the interpreters stack
	if arguments.stack:
	for x in arguments.stack:
	if isinstance(x, str):
	interpreter._stack += [float(ord(c)) for c in x]
	else:
	interpreter._stack += x

	# run the script
	try:
	while True:
	try:
	instr = interpreter.move()
	except StopExecution as stop:
	# only print a newline if the script didn't
	newline = ("\n" if (not interpreter._newline) and interpreter._newline != None else "")
	parser.exit(message=(newline+stop.message+"\n") if stop.message else newline)

	if instr and not instr == " " or arguments.always_tick:
	time.sleep(arguments.tick)
	except KeyboardInterrupt:
	# exit cleanly
	parser.exit(message="\n")