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
