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)
