def main(argv): input = FileStream(argv[1]) lexer = DASALexer(input) stream = CommonTokenStream(lexer) parser = DASAParser(stream) tree = parser.programa() dasa = DASAListener() walker = ParseTreeWalker() walker.walk(dasa, tree) vm.run()
def main(argv): input = antlr4.FileStream(argv[1]) lexer = ECMAScriptParser.Lexer(input) stream = antlr4.CommonTokenStream(lexer) parser = ECMAScriptParser.Parser(stream) tree = parser.program() program = VirtualMachine.Code() bytecode = VirtualMachine.BytecodeVisitor(program) tree.accept(bytecode) #program.print() # Uncomment to print the bytecode executor = VirtualMachine.Executor() executor.execute(program)
def test_invalid_bytecode(self): lexer = LexerStateMachine('int x = 5; if(x==5){x=6;}else{x=7;}', self.context) parser = Parser(lexer, self.manager) self.manager.setParser(parser) token = parser.parseStatements(0) bytecodes = self.generator.generateCode(token) vm = VirtualMachine() vm.VMLoad(bytecodes) lexer = LexerStateMachine('x = x +5;', self.context) parser.lexer = lexer token = parser.parseStatements(0) bytecodes = self.generator.generateCode(token) cbytecodes = vm.convertToCArray(bytecodes) vm.dumpBytecodes(cbytecodes)
def test_call_directly_to_dll_VMStep(self): lexer = LexerStateMachine('int x = 5;', self.context) parser = Parser(lexer, self.manager) self.manager.setParser(parser) token = parser.parseStatement(0) byteCodes =self.generator.generateCode(token) byteCodes.insert(0, self.byteCodeGenerator.dumpRegisterHex([7])) # hacked bytecode to display r7 value byteCodes.insert(2, self.byteCodeGenerator.dumpRegisterHex([7])) # vm = VirtualMachine() vm.VMLoad(byteCodes) vm.restype = POINTER(C_Exception) exception = vm.VMStep() exception = vm.VMStep() exception = vm.VMStep() exception = vm.VMStep()
def build_vms(vm_json): ''' Function for triggered the creation of VM's based on json input ''' for vm in vm_json['vms']: vm_name = vm['name'] template_uuid = vm['template_uuid'] template_moref = vm['template_moref'] datacenter = vm['datacenter'] dest_folder = vm['dest_folder'] dest_cluster = vm['dest_cluster'] cpu_sockets = vm['cpu_sockets'] memory_mb = vm['memory_mb'] memory_reservation = vm['reservation'] datastore_cluster = vm['datastore_cluster'] nics = vm['nics'] vmbuild = VirtualMachine.VM(vm_json) build_task = vmbuild.clone_template(si, template_uuid, template_moref, vm_name, datacenter, dest_folder, dest_cluster, dsc=datastore_cluster) obj_utils = utils() # Wait for task to finish and validate success or exit of build failed build_task_resource = obj_utils.wait_for_task(build_task) if build_task.info.state == 'success': logger.debug('VM ' + vm_name + ' built') else: logger.warning('Task result is : ' + build_task.info.state) logger.warning('VM Clone failed') exit() # Perform CPU flex and wait for task completion cpu_task = vmbuild.flex_vm_cpu(si, build_task_resource, cpu_sockets) cpu_task_resource = obj_utils.wait_for_task(cpu_task) logger.debug('cpu task complete for vm : ' + vm_name) if build_task.info.state == 'success': logger.debug('CPU Flex on ' + vm_name + ' complete') else: logger.warning('Task result is : ' + cpu_task.info.state) logger.warning('CPU flex failed') memory_task = vmbuild.flex_vm_memory(si, build_task_resource, memory_mb, reserv=memory_reservation) memory_task_resource = obj_utils.wait_for_task(memory_task) logger.debug('memory task complete for vm : ' + vm_name) if build_task.info.state == 'success': logger.debug('Memory Flex on ' + vm_name + ' complete') else: logger.warning('Task result is : ' + memory_task.info.state) logger.warning('Memory flex failed') for nic in nics: logger.debug('Set Network Adaptor :' + nic['adaptor_number']) nic_id = nic['adaptor_number'] network_moref = nic['network'] nic_task = vmbuild.set_vm_network(si, build_task_resource, nic_id, network_moref) nic_task_resource = obj_utils.wait_for_task(nic_task) if nic_task.info.state == 'success': logger.debug('Network adaptor change on ' + vm_name + ' complete') else: logger.warning('Task result is : ' + nic_task.info.state) logger.warning('Network Adaptor Set Failed') power_task = vmbuild.set_vm_power(si, build_task_resource, vm['state']) power_task_resource = obj_utils.wait_for_task(power_task) logger.debug('power task complete for vm : ' + vm_name) print('build complete')
def printQuads(self): counter = 1 for quad in self.Quads: #print(counter, quad.Operador, quad.OperandoI, quad.OperandoD, quad.Resultado) counter += 1 tables = { "functions": namesTable.functionsT, "globals": namesTable.globalsT, "constants": namesTable.constantsT } namesTable.globalsT["vars"] = self.countVarByTypeScope( "Global") #Obtener el conteo de memoria global virtualMachine = VirtualMachine(self.Quads, tables, Memory.MemSize) virtualMachine.run()
def getDomainInfo(self, domain): dom = Driver.getDomainByID(domain) name = dom.name() id = domain host = hostname type = "silver" if name.lower().startswith("g"): type = "gold" vm = VirtualMachine.VirtualMachine(domain, name, id, host, type) return vm
def get_vm_by_name(self, name): content = self.instance.RetrieveContent() virtual_machine = None container = content.viewManager.CreateContainerView(content.rootFolder, [vim.VirtualMachine], True) for item in container.view: if item.name.lower() == name.lower(): virtual_machine = item break container.Destroy() if virtual_machine is not None: return VirtualMachine(virtual_machine, self.instance) return None
def test_VMStep(self): bytecode = [] bytecode.append(ByteCodeGenerator.dumpRegisterHex(None, [7])) # hacked bytecode to display r7 value bytecode.append(ByteCodeGenerator.dumpRegisterHex(None, [7])) # bytecode.append(ByteCodeGenerator.halt(None)) vm = VirtualMachine() cbytecodes = vm.convertToCArray(bytecode) cCharArray_t = c_char * 300 cCharArray = cCharArray_t(0) cPtr = c_char_p cPtr = cCharArray vm.dumpBytecodes(bytecode) vm.dumpBytecode(bytecode[0]) vm.dumpBytecode(bytecode[1]) vm.dumpBytecode(bytecode[2])
class TestVirtualMachine(unittest.TestCase): vm = None def setUp(self): self.vm = VirtualMachine() def tearDown(self): self.vm = None def test_vm_push(self): self.assertListEqual(self.vm.stack, []) self.vm.code.append(OpcodePush(42)) self.vm.code.append(OpcodeStop()) self.vm.run() self.assertListEqual(self.vm.stack, [42]) def test_vm_add(self): self.assertListEqual(self.vm.stack, []) self.vm.code.append(OpcodePush(1)) self.vm.code.append(OpcodePush(2)) self.vm.code.append(OpcodeAdd()) self.vm.code.append(OpcodeStop()) self.vm.run() self.assertListEqual(self.vm.stack, [3]) def test_vm_print(self): self.vm.code.append(OpcodePush(42)) self.vm.code.append(OpcodePrint()) self.vm.code.append(OpcodeStop()) old_stdout = sys.stdout sys.stdout = io.StringIO() self.vm.run() output = sys.stdout.getvalue() sys.stdout = old_stdout self.assertEqual(output, '42\n')
def scanForExisting(self): configFiles = self.scanForFiles() vmArray = [] xml = XmlDriver.XmlDriver() for i in range(len(configFiles)): fileLocation = configFiles[i] name = xml.getName(fileLocation) ostype = xml.getOsType(fileLocation) harddrive = xml.getHardDrive(fileLocation) mem = xml.getMemory(fileLocation) cpu = xml.getCpuCount(fileLocation) mac = xml.getMac(fileLocation) network = xml.getNetworkAdapter(fileLocation) cddrive = xml.getCdDrive(fileLocation) harddrivesize = self.getFileSize(harddrive, name) vmstate = self.getVmState(name) newVm = VirtualMachine.VirtualMachine(name, vmstate, ostype, mem, cpu, harddrive, harddrivesize, cddrive, network, mac) vmArray.append(newVm) return vmArray
flowControlContext = FlowControlContext(contextManager) defaultContext = DefaultContext(contextManager) declarationContext = DeclarationContext(contextManager) expressionContext = ExpressionContext(contextManager) contexts = [expressionContext, declarationContext, flowControlContext, defaultContext] contextManager.addContext('Default', defaultContext) contextManager.addContext('Declaration', declarationContext) contextManager.addContext('Expression', expressionContext) contextManager.addContext('FlowControl', flowControlContext) contextManager.setCurrentContexts(contexts) generator = GeneratorAPI(context, contextManager) byteCodeGenerator = ByteCodeGenerator(context, contextManager) informationInjector = InformationInjector() vm = VirtualMachine() parser = Parser(None, contextManager) contextManager.setParser(parser) print('Imba the Cinterpreter') while(1): stopSymbol = ' ' StringCode = '' print('> ', end="") for statement in iter(input, stopSymbol): StringCode = StringCode + '\n' +statement print('> ', end="") StringList = StringCode.split('\n') lexer = LexerStateMachine(StringCode, context) parser.lexer = lexer
def get_vm_by_uuid(self, uuid): content = self.instance.RetrieveContent() virtual_machine = content.searchIndex.FindByUuid(None, uuid, True) if virtual_machine is not None: return VirtualMachine(virtual_machine, self.instance) return None
def executeFile(): global fileName #delprof() saveFile() VM.run(fileName)
# para testear con un file import os fileDir = os.path.dirname(os.path.realpath('__file__')) programa = 'advListFunctions.txt' filename = os.path.join(fileDir, 'tomate/tests/FinalTest/' + programa) #filename = os.path.join(fileDir, 'tests/' + programa ) f = open(filename, "r") input = f.read() yacc.parse(input) print("stackListComplete: " + str(stackListsAuxComplete)) print("stackListAux: " + str(stackListsAux)) print("stackOperandos: " + str(stackOperandos)) print("stackTypes: " + str(stackTypes)) print("stackScope: " + str(stackScope)) print("Const Table: " + str(constTable)) print("Address: " + str(address)) print("DirFunctions: " + str(dirFunctions)) quadruples.print() globalVariables() #print(globalMemory) print("======= Output =======") createOvejota() ## VM vm = VirtualMachine() vm.loadOvejota() vm.pointerSomething()
def setUp(self): self.vm = VirtualMachine()
def machine(self): """Return VirtualMachine object associated wit this snapshot""" import VirtualMachine return VirtualMachine(self.machine)
################# # # Joe # # Cloud Controller # ################### from VirtualMachine import * vm1 = VirtualMachine() vm1.printVMDetails()
if __name__ == "__main__": credentials = Credentials.get_credentials() rg_client = ResourceManagementClient(credentials, Credentials.SUBSCRIPTION_ID) network_client = NetworkManagementClient(credentials, Credentials.SUBSCRIPTION_ID) compute_client = ComputeManagementClient(credentials, Credentials.SUBSCRIPTION_ID) print(ResourceGroup.create_resource_group(rg_client, GROUP_NAME, LOCATION)) print( AvailabilitySet.create_availability_set(compute_client, GROUP_NAME, LOCATION, AVLSET_NAME)) print( PIP.create_public_ip_address(network_client, GROUP_NAME, LOCATION, PIP_NAME)) print( VirtualNetwork.create_virtual_network(network_client, GROUP_NAME, LOCATION, VNET_NAME)) print( Subnet.create_subnet(network_client, GROUP_NAME, SUBNET_NAME, VNET_NAME)) print( NIC.create_nic(network_client, GROUP_NAME, LOCATION, NIC_NAME, VNET_NAME, SUBNET_NAME, PIP_NAME)) print( VirtualMachine.create_virtual_machine(network_client, compute_client, GROUP_NAME, LOCATION, VM_NAME, NIC_NAME, AVLSET_NAME)) print('Done')
def get_vm_by_dns_name(self, name): content = self.instance.RetrieveContent() virtual_machine = content.searchIndex.FindByDnsName(None, name, True) if virtual_machine is not None: return VirtualMachine(virtual_machine, self.instance) return None
# строка с кодом, который в последствии будет распознаваться парсером. prog = ''' var i = 5; do { if(i >= 7) logprint(i); i++; } while(i < 10) ''' # вызов конструктора класса Parser. parser = Parser() # вызов конструктора класса Analyzer. analyzer = Analyzer() # в переменной res хранится корень графа, описывающего структуру кода из переменной prog. res = parser.parse(prog) print(*res.tree, sep=os.linesep) # вызов метода analyze, который производит семантический анализ analyzer.analyze(res) if len(analyzer.errors) > 0: for e in analyzer.errors: print("Ошибка: {}".format(e.message)) else: print("Ошибок не обнаружено.") generator = CodeGenerator(res) generator.print_bytecode() vm = VirtualMachine(generator.lines)
def get_vm_by_ip(self, ip): content = self.instance.RetrieveContent() virtual_machine = content.searchIndex.FindByIp(None, ip, True) if virtual_machine is not None: return VirtualMachine(virtual_machine, self.instance) return None