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 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 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 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
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 __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 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 _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 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 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)