def test_shift_left(): asm_path = join(dirname(dirname(__file__)), 'lib', 'binary', 'shift.asm') asm = template.format(arg='{arg}', call='binary_shift_left', path=asm_path) assert VirtualMachine().run(asm.format(arg=10)) == '20' assert VirtualMachine().run(asm.format(arg=1)) == '2' assert VirtualMachine().run(asm.format(arg=0)) == '0'
def __init__(self): # Windows does not have GNU readline, and has different environment variables if osname == 'nt': username = environ["USERNAME"] else: import readline import atexit username = environ["USER"] # Uses the readline library to gain tab completion, matching # parenthesis, and automatic history readline.set_completer(self.complete) readline.parse_and_bind('tab: complete') readline.parse_and_bind('set blink-matching-paren on') self.histfile = join(expanduser("~"), ".pylisp_history") try: readline.read_history_file(self.histfile) except FileNotFoundError: open(self.histfile, 'a').close() self.completion_candidates = [] atexit.register(readline.write_history_file, self.histfile) # Initialises using the user's username as the prompt self.prompt = username + "> " self.intro = "Welcome to the PyLisp interpreter" self.vm = VirtualMachine({}) self.load_std() self.registers = None
def test_divide(): asm_path = join(dirname(dirname(__file__)), 'lib', 'math', 'divide.asm') asm = template.format(arg0='{arg0}', arg1='{arg1}', call='math_divide', path=asm_path) assert VirtualMachine().run(asm.format(arg0=10, arg1=2)) == '5' assert VirtualMachine().run(asm.format(arg0=5, arg1=7)) == '0' assert VirtualMachine().run(asm.format(arg0=25, arg1=25)) == '1' assert VirtualMachine().run(asm.format(arg0=10, arg1=1)) == '10'
def test_multiply(): asm_path = join(dirname(dirname(__file__)), 'lib', 'math', 'multiply.asm') asm = template.format(arg0='{arg0}', arg1='{arg1}', call='math_multiply', path=asm_path) # asm += open(asm_path).read() print(asm) assert VirtualMachine().run(asm.format(arg0=10, arg1=2)) == '20' assert VirtualMachine().run(asm.format(arg0=5, arg1=7)) == '35' assert VirtualMachine().run(asm.format(arg0=25, arg1=10)) == '250' assert VirtualMachine().run(asm.format(arg0=10, arg1=25)) == '250'
def getVirtualMachineByName(self, name, folder=None): """Return VM object using PyVmomi""" recursive = True if folder is None or folder == '/': content = self._vmh.content container = content.rootFolder viewType = [vim.VirtualMachine] vmView = content.viewManager.CreateContainerView( container, viewType, recursive) vms = vmView.view for vm in vms: if vm.name == name: return VirtualMachine(vm) raise Exception( 'Impossibile trovare una VM con nome {}\n'.format(name)) vmList = self.getVirtualMachineList(folder, recursive) for vm in vmList: if vm.name == name: return vm raise Exception( 'Impossibile trovare una VM con nome {}\n'.format(name))
def getVirtualMachineList(self, folder=None, recursive=False, template=False): if (type(folder) == str): container = self.getFolderByName(folder) elif (type(folder) == vim.Folder): container = folder elif folder is None: container = self.getFolderByName('/') containers = [container] while containers: container = containers.pop() for child in container.childEntity: if type(child) == vim.VirtualMachine: if template or not self._isVmTemplate(child): yield VirtualMachine(child) elif type(child) == vim.Folder and recursive == True: containers.append(child) raise StopIteration
def get_all_vms(self): all_vms = [] vim_type = [vim.VirtualMachine] objects = self.__get_all_objects_by_type(vim_type) for obj in objects: if not obj.config.template: all_vms.append(VirtualMachine(obj)) return all_vms
def getVirtualMachineByMoId(self, moid): """Lookup a vm from a given moId string (like "vm-123" """ vm_obj = vim.VirtualMachine(moid) try: vm_obj._stub = self._vmh._stub except Exception: raise Exception( 'Impossibile trovare una VM con moid {}'.format(moid)) return VirtualMachine(vm_obj)
def get_all_templates(self): global all_templates if (len(all_templates) != 0): return all_templates vim_type = [vim.VirtualMachine] objects = self.__get_all_objects_by_type(vim_type) for obj in objects: try: if obj.config.template: all_templates.append(VirtualMachine(obj)) except: pass return all_templates
def getVirtualMachineIpAddress(self, ip): """Return VM object using PyVmomi""" searchIndex = self._vmh.RetrieveContent().searchIndex _vms = searchIndex.FindAllByIp(ip=ip, vmSearch=True) vms = [] oid = [] for vm in _vms: if vm._moId not in oid: oid.append(vm._moId) vms.append(VirtualMachine(vm)) return vms
def get_vm_by_name(self, name): vim_type = [vim.VirtualMachine] objects = self.__get_all_objects_by_type(vim_type) all_vms = [] for obj in objects: try: if not obj.config.template: all_vms.append(VirtualMachine(obj)) except: pass for vm in all_vms: if vm.name == name: return vm return -1
def main(): """ The main function called when the program is run. Will either start the interpreter or run a file if a filename is provided """ if len(sys.argv) == 1: from interpreter import Interpreter # Main loop which prompts user for input and print the response of the input handed to the rep function interpreter = Interpreter() interpreter.load_std() interpreter.cmdloop() else: from fileparser import FileParser from virtualmachine import VirtualMachine parser = FileParser(sys.argv[1], VirtualMachine({})) parser.load_std() parser.run()
def get_vm_by_uuid(self, uuid): vm = VirtualMachine(self.__get_obj_by_uuid(uuid)) return vm
def add_vm(self, ip, vmid, alias): self.vms.append(VirtualMachine(ip, vmid, alias))
def _match(pattern, iterable): assert isinstance(pattern, Pattern) code = pattern.compile() vm = VirtualMachine(code) m = Match() # Start VM vm.do_epsilon_transitions() m.state = vm.accepting_state(None) vm.cutoff() for x in iterable: if not vm.is_alive(): break vm.feed(x) vm.do_epsilon_transitions() m.state = vm.accepting_state(m.state) vm.cutoff() if m.state == None: return None return m
def finditer_alt(pattern, iterable): """ An experimental implementation of finditer. The idea here is to make an implementation that is able to work with any iterator, not necessariry the indexable ones. This implies (among other things) that each element is feeded only once and then discarded. """ assert isinstance(pattern, Pattern) pattern = Star(Star(Any(), greedy=False) + Group(pattern, None)) code = pattern.compile() vm = VirtualMachine(code) m = Match() new = Match() # Start VM vm.do_epsilon_transitions() vm.cutoff() for x in iterable: if not vm.is_alive(): break vm.feed(x) vm.do_epsilon_transitions() new.state = vm.accepting_state(None) if new.state != None: if m.state == None: m.state = new.state elif m.start() == new.start() and m.end() < new.end(): m.state = new.state elif m.start() != new.start(): yield m m = new new = Match() vm.cutoff() if m.state != None: yield m
class Interpreter(): """ A read eval print loop interactive interpreter. Takes input from the user and displays the resultant output on the next line """ def __init__(self): # Windows does not have GNU readline, and has different environment variables if osname == 'nt': username = environ["USERNAME"] else: import readline import atexit username = environ["USER"] # Uses the readline library to gain tab completion, matching # parenthesis, and automatic history readline.set_completer(self.complete) readline.parse_and_bind('tab: complete') readline.parse_and_bind('set blink-matching-paren on') self.histfile = join(expanduser("~"), ".pylisp_history") try: readline.read_history_file(self.histfile) except FileNotFoundError: open(self.histfile, 'a').close() self.completion_candidates = [] atexit.register(readline.write_history_file, self.histfile) # Initialises using the user's username as the prompt self.prompt = username + "> " self.intro = "Welcome to the PyLisp interpreter" self.vm = VirtualMachine({}) self.load_std() self.registers = None def load_std(self): """ Adds the core libraries to the environment """ for i in env.standard_env: libs = env.include_lib(i) for lib in libs: if lib[0] == "py": self.vm.env.update(lib[1]) elif lib[0] == "pyl": file_parse = FileParser(lib[1], self.vm) file_parse.run() def complete(self, text, state): """ The completer function. Works by finding all the symbols in the environment and in the core keywords and checking if they start with the provided text """ if state == 0: self.completion_candidates = [] tmp = [] tmp.extend(self.repl_env.keys()) tmp.extend(self.vm.core_keywords.keys()) for i in tmp: if i.startswith(text): self.completion_candidates.append(i) if state < len(self.completion_candidates): result = self.completion_candidates[state] else: result = None return result def precmd(self, line): """ Executed on the input before the line is evaluated. Used to ensure that if the opening brackets do not match the closing brackets, the prompt is just extended """ ret = line prompt_indent = len(self.prompt) - len("...") while ret.count("(") > ret.count(")"): indent = (ret.count("(") - ret.count(")")) * 2 ret += " " + \ input("\r" + " " * prompt_indent + "..." + indent * " ") return ret def cmdloop(self): """ The main loop. Gets the input, sends it to precmd, then runs it. If it encounters a pylisp error, prints the error and cleans up. If it enconters an EOF i.e. Ctrl-D it closes gracefully """ print(self.intro) while True: self.registers = self.vm.get_registers() try: inp = input(self.prompt) inp = self.precmd(inp) parser = Parser() print(self.vm.evaluate(parser.parse_buffer(inp))) except PylispError as e: print(e) self.vm.set_registers(self.registers) except (KeyboardInterrupt, EOFError): return
def vm(): return VirtualMachine()
'--version', action='version', version=VERSION, help='print the version and exit') ap.add_argument('-v', '--verbose', action='store_true', help='print verbosely') ap.add_argument('source', default=None, nargs='?', help='text | file') ns = ap.parse_args() print ns lexer = Lexer(PATTERNS, ns.verbose) parser = Parser(ns.verbose) vm = VirtualMachine() if not ns.source: exitcode = repl(lexer, parser) if os.path.isfile(ns.source): source = open(ns.source).read() else: source = '(print %s)' % ns.source tokens = lexer.Scan(source) opcodes = parser.Parse(tokens) exitcode = vm.Execute(opcodes) sys.exit(exitcode)