def test_memory(): from memory import memory mem = memory() assert (isinstance(mem, float)) assert (mem > -1e-6) mem = memory(children=True) assert (isinstance(mem, float)) assert (mem > -1e-6)
def buildFOPC(sentence): global statements global recentMemory global longTermMemory statements.append(Red+sentence+st) recentMemory=memory.memory() print(lf+"Processing sentence:",sentence, lf) doc = languageTools.nlp(sentence) languageTools.showTree(doc) category = languageTools.catagorize(doc) print(lf+"Sentence is an instance of:", category) if category == "S:Existential": buildExistential(doc) if category == "S:Feature": student_code.buildFeatureStatement(doc) longTermMemory = recentMemory print(lf+"Long Term Memory", longTermMemory)
def buildFOPC(sentence): global statements global recentMemory global longTermMemory statements.append(Red + sentence + st) recentMemory = memory.memory() print(lf + "Processing sentence:", sentence, lf) doc = languageTools.nlp(sentence) languageTools.showTree(doc) category = languageTools.catagorize(doc) print(lf + "Sentence is an instance of:", category) if category == "S:Existential": buildExistential(doc) if category == "S:Feature": student_code.buildFeatureStatement(doc) longTermMemory = recentMemory print(lf + "Long Term Memory", longTermMemory)
def __init__(self, ip, mac, mask): self.myip = ip self.mymac = mac self.mymask = mask self.tools = tools() self.mem = memory() self.network_map = network_map(ip, mac)
def __init__(self): self.RegisterFile = register() self.Memory = memory() self.sp=0x7ffffffc self.PC = 0 self.IR = 0 self.RZ = 0 self.RA = 0 self.RB = 0 self.RY = 0 self.RM = 0 self.imm = 0 self.cycle = 0 self.stalls_data = 0 self.stalls_control = 0 self.do_dataForwarding = True self.memAccess_run = False self.alu_run = False self.decode_run = False self.fetch_run = False self.stopPipeLine = False self.RDQueue = [] self.branchTaken = False self.total_ins = 0 self.total_control_ins = 0 self.total_data_ins = 0 self.total_alu_ins = 0 self.data_hazards = 0 self.control_hazards = 0 self.was_data_hazard = False self.knob3 = False self.knob4 = False self.knob5 = False self.buffer_line_no = 0
def __init__(self, seed, n_state, n_action, batch_size=64, buffer=1e5, gamma=0.99, lr_actor=1e-4, lr_critic=1e-3, weight_decay=0, tau=1e-3): self.batch_size = batch_size #init actor self.local_actor = Actor(n_state, n_action, seed).to(device) self.target_actor = Actor(n_state, n_action, seed).to(device) self.optim_actor = torch.optim.Adam(self.local_actor.parameters(), lr=lr_actor) #init critic self.local_critic = Critic(n_state, n_action, seed).to(device) self.target_critic = Critic(n_state, n_action, seed).to(device) self.optim_critic = torch.optim.Adam(self.local_critic.parameters(), lr=lr_critic, weight_decay=weight_decay) #init memory self.memory = memory(int(buffer), device, seed) self.tau = tau self.gamma = gamma self.noise = noise(n_action, seed=seed)
def __init__(self,ip,mac): self.myip=ip self.mymac=mac self.tools=tools() self.mem=memory() self.network=network() self.replyTimeout=20
def __init__(self,ip,mac,mask): self.myip=ip self.mymac=mac self.mymask=mask self.tools=tools() self.mem=memory() self.network_map=network_map(ip,mac)
def __init__(self, ip, mac): self.myip = ip self.mymac = mac self.tools = tools() self.mem = memory() self.network = network() self.replyTimeout = 20
def reset(self): self.game = {} self.mem = memory.memory("deglia_v") self.stock = {} self.oppStock = {} self.score = 0 self.oppScore = 0 self.nbTurns = 0
def main(): print("Start dqn") env = gym.make("CartPole-v0") env.seed(RANDOM_SEED) random.seed(RANDOM_SEED) np.random.seed(RANDOM_SEED) memories = memory(MEMORY_SIZE) n_actions = env.action_space.n n_states = np.prod(np.array(env.observation_space.shape)) print(datetime.today().strftime('%Y-%m-%d-%H:%M')) dqn = DQN(n_actions, n_states) average_cumulative_reward = 0.0 writer = SummaryWriter('./log_files/') writer_name = "DQN-" + datetime.today().strftime('%Y-%m-%d-%H:%M') epsilon = 1.0 for episode in range(EPISODES): state = env.reset() cumulative_reward = 0.0 steps = 0 while True: steps += 1 # render env.render() # act action = dqn.choose_action(state, epsilon) next_state, reward, done, _ = env.step(action) memories.remember(state, action, reward, next_state, done) size = memories.size # learn if size > BATCH_SIZE * 2: batch = random.sample(range(size), BATCH_SIZE) dqn.learn(*memories.sample(batch)) state = next_state cumulative_reward += reward if done: break epsilon = max(EPSILON_END, epsilon * DECAY_EPSILON) # Per-episode statistics average_cumulative_reward *= 0.95 average_cumulative_reward += 0.05 * cumulative_reward print(episode, cumulative_reward, average_cumulative_reward) writer.add_scalar("Cumulative Reward " + writer_name, cumulative_reward, episode) writer.add_scalar("Mean Cumulative Reward" + writer_name, average_cumulative_reward, episode) print('Complete') env.render() env.close()
def __init__(self, memory_size, io): self.io = io self.acc = 0 self.b = 0 self.mem = memory.memory(memory_size) self.stack = [] self.hooks = [] self.callf = '' self.exe_file = ''
def __init__(self, ip, mac): self.myip = ip self.mymac = mac self.tools = tools() self.mem = memory() self.ruleconstructor = ruleconstructor() self.recv_target = None self.sent_target = None self.network = network()
def __init__(self,ip,mac): self.myip=ip self.mymac=mac self.tools=tools() self.mem=memory() self.ruleconstructor=ruleconstructor() self.recv_target=None self.sent_target=None self.network=network()
def __init__(self): self.log = [[],[],[],[]] self.running = False self.mem = memory.memory(self.update_view) self.dataBus = connexion.bus(self.mem, self.update_view) self.clk = clock.clock(self.update_clock) self.cores_list = [] self.local_total_list=[0,0,0,0] for i in range(4): self.cores_list.append(core.core(i,self.dataBus,self.clk,self.update_core))
def __init__(self, funcName): self.funcName = funcName self.startPosition = 0 self.returnType = None self.memory = memory(4000, 5000, 6000, 0) self.parameters = [] self.localVariables = 0 self.temporalVariables = 0 self.intParameters = 0 self.boolParameters = 0 self.charParameters = 0
def _sendRequest(self, o): """ sends a request, returns a Deferred, which you can do addCallback on. If this is in fact synchronous, your callback will be called immediately, otherwise it will be called upon availability of data from socket. """ if self.s is None: self.s = socket.socket() self.s.connect((self._message_maker._host, self._message_maker._port)) s = self.s tosend = self._message_maker.make(o, keepalive=True) if DEBUG: print "*** Sending: ***\n%s" % tosend s.send(tosend) # get headers, read size, read the rest h = [] c = None if DEBUG: print "receiving:" while c != '<': c = s.recv(1) if DEBUG: sys.stdout.write(c) sys.stdout.flush() h.append(c) if DEBUG: print headers = ''.join(h[:-1]) content_length = self.contentLengthFromHeaders(headers) # Connection: close close_socket = self.closeSocketFromHeaders(headers) if close_socket and DEBUG_CLOSE: print "Will close socket" if DEBUG: print "expecting %s" % content_length # this loop is required for getting large stuff, like # getRemoteImage (1200000~ bytes for 640x480 RGB) rest = [] left = content_length - 1 while left > 0: rest.append(s.recv(content_length-1)) left -= len(rest[-1]) if DEBUG: print "memory = %s" % memory.memory() body = h[-1] + ''.join(rest) if DEBUG: print "*** Got: ***\n%s" % compresstoprint( headers + body, 1000, 1000) print "*************************" if close_socket: self.s.close() self.s = None xml = minidom.parseString(body) soapbody = xml.documentElement.firstChild return succeed(soapbody)
def get_memory(): result = {} f = open("/proc/meminfo") data = f.readlines() f.close() KB = 1024.0 memtotal = int(data[0].split()[1]) / KB memfree = int(data[1].split()[1]) / KB result['total'] = memtotal result['free'] = memfree result['used'] = memtotal-memfree result['self-resident'] = memory.resident() / memory.MB result['self-memory'] = memory.memory() / memory.MB return result
def __init__(self, cb=None): self.RANGE = range(8) self.EGNAR = range(7,-1,-1) self.RANGE3 = range(3) self.RANGE16 = range(16) self.EGNAR16 = range(15,-1,-1) self.PAUSE = True self.NOSTEP = False self.RUN = True self.ALU = alu() self.REGISTER = register() self.CONTROL = control() self.DATABUS = [0,0,0,0,0,0,0,0] self.ADDRESSBUS = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] self.MEMORY = memory() self.CALLBACK = cb self.CONTROLREGISTER = [0,0,0] # Cy, Z, S self.Inst = [0,0,0,0,0,0,0,0] self.regLoadMap = { (0,0,0) : self.loadA, \ (0,0,1) : self.loadB, \ (0,1,0) : self.loadC, \ (0,1,1) : self.loadD, \ (1,0,0) : self.loadM1, \ (1,0,1) : self.loadM2, \ (1,1,0) : self.loadX, \ (1,1,1) : self.loadY } self.regSelectMap = { (0,0,0) : self.selectA, \ (0,0,1) : self.selectB, \ (0,1,0) : self.selectC, \ (0,1,1) : self.selectD, \ (1,0,0) : self.selectM1, \ (1,0,1) : self.selectM2, \ (1,1,0) : self.selectX, \ (1,1,1) : self.selectY } self.start = time() self.H = "" self.M = "" self.S = "" self.ENCODER = encodercore()
def get_memory(): result = {} f = open("/proc/meminfo") data = f.readlines() f.close() KB = 1024.0 memtotal = int(data[0].split()[1]) / KB memfree = int(data[1].split()[1]) / KB result['total'] = memtotal result['free'] = memfree result['used'] = memtotal - memfree result['self-resident'] = memory.resident() / memory.MB result['self-memory'] = memory.memory() / memory.MB return result
def __init__(self): self.mem = memory.memory() self.MAR = register.register() self.MDR = register.register() self.IC = register.register() self.IR = register.register() self.OP = register.register() self.OI = register.register() self.AC = register.register() self.SP = 0x0ffe self.end = True self.ula = ULA.ULA() self.devs = [] self.devs.append(device.device(0, 0)) self.devs.append(device.device(1, 0))
def sys_stats(): """ Return a string of statistics: nodename time: user+sys elapsed, realtime elapsed, CPU usage, memory usage """ nodename = os.uname()[1] t = os.times() usersystime = t[0] + t[1] realtime = t[4] - __initrealtime usage = 100. * usersystime / (realtime + 0.00001) usersystime = datetime.timedelta(seconds=usersystime) realtime = datetime.timedelta(seconds=realtime) return "%s %s: %s user+sys, %s real, %.2f%% usage, %.2f MB" % ( nodename, datetime.datetime.now(), usersystime, realtime, usage, memory.memory() / 1024. / 1024.)
def __init__(self, inputSize, actionNums = 2, memorySize = 20000, batch = 128): self.model = QValueMap(inputSize, inputSize*2, actionNums) self.memory = memory(memorySize, batch) self.target = deepcopy(self.model) self.gamma = 0.95 self.tua = 0.01 self.optimizer = optim.Adam(self.model.parameters(), lr=0.001) self.loss_function = nn.MSELoss(size_average = False) self.traincnt = 0 self.totalloss = 0 self.actions = actionNums self.dims = util.getDims()
def exec_command(self): # import pdb # pdb.set_trace() if functions.curr_time() - self.curr_time >= 1: data = { 'network': network(self.network), 'cpu': cpu(self.cpu), 'storage': storage(self.storage), 'memory': memory(self.memory), 'timestamp': functions.curr_time(), 'id': self.system_data['id'] } # pdb.set_trace() print data['timestamp'] self.send_data(data, 'live') self.curr_time = functions.curr_time()
def do_info(obj): """ Shows information about the running server. Synopsis: @info """ mem = psutil.virtual_memory() proc_size = memory() obj.notify('Server information:') obj.notify('Python Version: %s.' % platform.python_version()) obj.notify('PID: %s.' % os.getpid()) obj.notify('Process Size: %.2fMB (%.2f bytes).' % (proc_size / (1024.0 ** 2), proc_size)) obj.notify('Opperating System: %s.' % platform.platform()) obj.notify('Processor: %s.' % (platform.processor() or 'Unknown')) obj.notify('Memory: Used %.2fMB of %.2fGB (%.2f%%).' % (mem.used / (1024.0 ** 2), mem.total / (1024.0 ** 3), mem.percent)) obj.notify('Max Concurrent Threads: %s.' % multiprocessing.cpu_count()) obj.notify('Objects in database: %s.' % len(db.objects)) return True
def start(cores): if __triv__: log.info("Aborting and returning trivial data...") print __triv__ return coreLst = [Core(i, memory.memory()) for i in xrange(0, cores)] queues = [coreLst[i].inbox for i in xrange(0, cores)] for core in coreLst: core.link(queues) p = multiprocessing.Process( target = core.start, name = "C " + str(core.identifier)) p.start() global __cores__ __cores__ = coreLst
def __init__( self, mapping_type=0, cache_size=512, block_size=4 ): # Cache_size: number of blocks; Block size: Number of Words self.cache_size = cache_size #number of blocks self.block_size = block_size # Number of Words self.mapping_type = mapping_type self.cache_list = {} self.dq = [] # self.key_fully_associative = 0 self.memory_object = memory() self.number_of_blocks = int(cache_size / block_size) self.block_bits = int(math.log2(cache_size)) self.word_bits = int(math.log2(block_size)) self.total_bits = self.word_bits + self.block_bits + 2 self.tag_bits = 32 - self.total_bits
def __init__(self, timeInterrupt=False, time_limit=50, timeout_input=0, quiet=False): self.mem=memory.memory() self.MAR=register.register() self.MDR=register.register() self.IC=register.register() self.IR=register.register() self.OP=register.register() self.OI=register.register() self.AC=register.register() self.SP=0x0ffe self.end=True self.timeInterrupt=timeInterrupt self.NUM=time_limit self.TIMEOUT=timeout_input self.quiet=quiet self.nsteps=0 self.ula=ULA.ULA() self.devs=[] self.devs.append(device.device(0,0, self.quiet)) self.devs.append(device.device(1,0, self.quiet))
def bot(request): Report_ID = 0 userText = request.GET.get('msg', False) if userText.lower() == 'hi' or userText.lower() == 'hello': return HttpResponse('Hi There.') if userText.lower() == 'how are you': return HttpResponse("I'm Good, Thanks for Asking") if userText.lower() == 'are you human': return HttpResponse("No, I am a Chat Bot, Your Personal Sales Assistant :)") if 'bye' in userText.lower(): return HttpResponse("Bye, Thank You.") grain, date, end_date, date_string = Parse_date_duckling(userText) if Report_ID == 0 and date is not None: try: id = str(memory()) if int(id) != 0: update_report_id(0) return HttpResponse('Report Id:' + str(id)) except Exception as e: return HttpResponse("I Can't Answer This Query.") Report_ID, self_flag, date1, end_date1, ai_input_string, confidence = ai.user_input(userText) if int(confidence) < 70.0: return HttpResponse("I Can't Answer This Query.") try: if date is not None: date = str(date).split('T')[0] except: pass if date is None or date == 'None': # return 'For Which Date You are Looking for?' update_report_id(Report_ID) return HttpResponse("For Which Date You are Looking for?") # return ' Report Id: '+str(Report_ID)+' and Date: '+str(date) return HttpResponse(' Report Id: ' + str(Report_ID))
def btest_case_verifying_memory( self ): """Verificando o conteudo da memoria, fazendo varredura geral """ def test( clk, chip_select, address, load_store, data_in, data_out ): l = len( MEM_AUX ) for i in range( l ): #Sequencial chip_select.next = 1 load_store.next = 0 address.next = i yield clk.posedge yield clk.posedge chip_select.next = 0 self.assertEqual( data_out, MEM_AUX[i] ) for i in range( l ): #Aleatoria chip_select.next = 1 load_store.next = 0 aleatorio = randrange( l ) address.next = aleatorio yield clk.posedge yield clk.posedge self.assertEqual( data_out, MEM_AUX[aleatorio] ) raise StopSimulation clk_s = Signal( bool( 1 ) ) clkgen = clk_gen( clk_s ) address, data_in, data_out =[Signal( intbv( 0 )[32:] ) for i in range( 3 )] chip_select, load_store = [Signal( bool( 0 ) ) for i in range( 2 )] mem_test = memory.memory( clk_s, chip_select, address, load_store, data_in, data_out ) #check = test( clk_s, chip_select, address, load_store, data_in, data_out ) ch = traceSignals(test, clk_s, chip_select, address, load_store, data_in, data_out) #me = traceSignals(memory.memory, clk_s, chip_select, address, load_store, data_in, data_out ) #sim = Simulation( mem_test, check, clkgen ) sim = Simulation( ch, mem_test, clkgen ) sim.run( quiet=1 )
def my_form_post(): Report_ID = 0 userText = request.args.get('msg') if userText.lower() == 'hi' or userText.lower() == 'hello': return 'Hi There.' if userText.lower() == 'how are you': return "I'm Good, Thanks for Asking" if userText.lower() == 'are you human': return "No, I am a Chat Bot, Your Personal Sales Assistant :)" if 'bye' in userText.lower(): return "Bye, Thank You." grain, date, end_date, date_string = Parse_date_duckling(userText) if Report_ID == 0 and date is not None: try: id = str(memory()) if int(id) != 0: update_report_id(0) return 'Report Id:' + id except: return 'Error' Report_ID, self_flag, date1, end_date1, ai_input_string, confidence = ai.user_input(userText) if int(confidence) < 70.0: return "I Can't Answer This Query." try: if date is not None: date = str(date).split('T')[0] except: pass if date is None or date == 'None': # return 'For Which Date You are Looking for?' update_report_id(Report_ID) return redirect('/clarification') # return ' Report Id: '+str(Report_ID)+' and Date: '+str(date) return ' Report Id: ' + str(Report_ID)
def test_case_store_data_memory( self ): """Inserindo dados na memoria """ MEM_AUX = memory.fetch_system_memory() def test( clk, chip_select, address, load_store, data_in, data_out ): count = len( MEM_AUX ) for i in range( count+10 , count+100 ): chip_select.next = 1 load_store.next = 1 address.next = i data_in.next = i*32 MEM_AUX[i]=i*32 yield clk.posedge yield clk.posedge #chip_select.next = 1 load_store.next = 0 #address.next = i data_in.next = 0 yield clk.posedge yield clk.posedge chip_select.next = 0 self.assertEqual( data_out, MEM_AUX[i] ) raise StopSimulation clk_s = Signal( bool( 1 ) ) clkgen = clk_gen( clk_s ) address, data_in, data_out =[Signal( intbv( 0 )[32:] ) for i in range( 3 )] chip_select, load_store = [Signal( bool( 0 ) ) for i in range( 2 )] mem_test = memory.memory( clk_s, chip_select, address, load_store, data_in, data_out ) #check = test( clk_s, chip_select, address, load_store, data_in, data_out ) #sim = Simulation( mem_test, check, clkgen ) te = traceSignals(test, clk_s, chip_select, address, load_store, data_in, data_out) sim = Simulation( mem_test, te, clkgen ) sim.run( quiet=1 )
from forensic_protocol_prober import forensic_protocol_prober from forensic_switchport_prober import forensic_switchport_prober from network_map import network_map from ruleconstructor import ruleconstructor from map_net import map_net from tools import tools from memory import memory from network import network import socket import fcntl import struct import os import sys tools=tools() mem=memory() network=network() #get public IP address of host def get_ip_address(ifname): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) return socket.inet_ntoa(fcntl.ioctl( s.fileno(), 0x8915, # SIOCGIFADDR struct.pack('256s', ifname[:15]) )[20:24]) #get MAC address of host def getHwAddr(ifname): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) info = fcntl.ioctl(s.fileno(), 0x8927, struct.pack('256s', ifname[:15]))
def __init__(self): self.RegisterFile = register() self.Memory = memory() self.sp=0x7ffffffc self.PC = 0 self.IR = 0
def __init__(self, pid): self.memory = memory(pid)
def show_mem(): print "memory usage:" import memory print memory.memory()/(1024*1024) print memory.resident()/(1024*1024)
def get_mem_usage(): return int(memory.memory()) >> 20
def __init__(self): self.network=network() self.mem=memory()
def __init__(self): self.states = {} self.state = None self.memory = memory.memory()
class AangCustomListener(AangListener): PilaO = stack() PilaOper = stack() Avail = avail() PSaltos = stack() FilaQuads = [] FilaQuadsMemoria = [] PilaTipos = stack() PilaFunc = stack() PilaFuncParam = stack() PilaArr = stack() ParameterCounter = 0 TempParameters = [] memoriaGlobal = memory(1000, 2000, 3000, 0) memoriaConstante = memory(7000, 8000, 9000, 0) memoriaTemporal = memory(10000, 11000, 12000, 0) # Memory address # global varTable global varIntAddr global varCharAddr functionDirectory = FunctionDir() varTable = VariableTable({}) constTable = ConstantTable() localVarTable = VariableTable({}) # ========================== PROGRAMA ========================== def enterPrograma(self, ctx: AangParser.ProgramaContext): operator = "Goto" rightOperand = None leftOperand = None result = "vacio" quad = Quadruple(operator, rightOperand, leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) pass def exitPrograma(self, ctx: AangParser.ProgramaContext): operator = "Exit" rightOperand = None leftOperand = None result = None quad = Quadruple(operator, rightOperand, leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) for index, quad in enumerate(self.FilaQuads, 1): print(index, quad) for index, quad in enumerate(self.FilaQuadsMemoria, 1): print(index, quad) # ========== CUADRUPLOS PARA VM ========= pickle_out = open("Quadruplos.pickle", "wb") pickle.dump(self.FilaQuadsMemoria, pickle_out) pickle.dump(self.functionDirectory, pickle_out) pickle.dump(self.constTable, pickle_out) pickle_out.close() def enterExpresion(self, ctx: AangParser.ExpresionContext): if ctx.Y_SIMBOLO() != None: self.PilaOper.push(str(ctx.Y_SIMBOLO())) if ctx.O_SIMBOLO() != None: self.PilaOper.push(str(ctx.O_SIMBOLO())) def exitExpresion(self, ctx: AangParser.ExpresionContext): if ctx.Y_SIMBOLO() != None or ctx.O_SIMBOLO() != None: operator = self.PilaOper.pop() leftOperand = self.PilaO.pop() rightOperand = self.PilaO.pop() Type = SemanticCube().cube[rightOperand[1], leftOperand[1], operator] if Type == Types().ERROR: raise Exception(Types().ERROR) elif Type == Types().INT: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getEntera())) elif Type == Types().CHAR: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getChar())) elif Type == Types().BOOL: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getBooleanos())) result = self.PilaO.top() quad = Quadruple(operator, rightOperand[0], leftOperand[0], result[0]) self.FilaQuads.append(quad) quad2 = Quadruple(operator, rightOperand[2], leftOperand[2], result[2]) self.FilaQuadsMemoria.append(quad2) def enterE(self, ctx: AangParser.EContext): if ctx.MAYOR() != None: self.PilaOper.push(str(ctx.MAYOR())) if ctx.MENOR() != None: self.PilaOper.push(str(ctx.MENOR())) if ctx.IGUAL() != None: self.PilaOper.push(str(ctx.IGUAL())) if ctx.DIFERENTE() != None: self.PilaOper.push(str(ctx.DIFERENTE())) pass def exitE(self, ctx: AangParser.EContext): if ctx.MAYOR() != None or ctx.MENOR() != None or ctx.IGUAL( ) != None or ctx.DIFERENTE() != None: operator = self.PilaOper.pop() leftOperand = self.PilaO.pop() rightOperand = self.PilaO.pop() Type = SemanticCube().cube[rightOperand[1], leftOperand[1], operator] if Type == Types().ERROR: raise Exception(Types().ERROR) elif Type == Types().INT: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getEntera())) elif Type == Types().CHAR: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getChar())) elif Type == Types().BOOL: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getBooleanos())) result = self.PilaO.top() quad = Quadruple(operator, rightOperand[0], leftOperand[0], result[0]) self.FilaQuads.append(quad) quad2 = Quadruple(operator, rightOperand[2], leftOperand[2], result[2]) self.FilaQuadsMemoria.append(quad2) pass # ========================== ASIGNACION ========================== def enterAsignacion(self, ctx: AangParser.AsignacionContext): self.PilaOper.push(str(ctx.ASIGNAR())) def exitAsignacion(self, ctx: AangParser.AsignacionContext): # quad Asignar leftOperand = self.PilaO.pop() operator = self.PilaOper.pop() rightOperand = None if ctx.I_LLAVE() != None: # quad de direccion operator2 = '+*' rightOperand2 = self.PilaO.pop() # quad de verificacion operator3 = 'Ver' rightOperand3 = 0 if len(self.PilaFunc.items) == 0: self.varTable.exist(str(ctx.ID())) # quad de verificacion result3 = self.varTable.getLSup(str(ctx.ID())) # quad de direccion leftOperand2 = self.varTable.vars[str(ctx.ID())].memoryDir Type = self.varTable.vars[str(ctx.ID())].dataType else: if self.localVarTable.get_local_variable(str(ctx.ID())): self.localVarTable.exist(str(ctx.ID())) # quad de verificacion result3 = self.localVarTable.getLSup(str(ctx.ID())) # quad de direccion leftOperand2 = self.localVarTable.vars[str( ctx.ID())].memoryDir Type = self.localVarTable.vars[str(ctx.ID())].dataType else: self.varTable.exist(str(ctx.ID())) # quad de verificacion result3 = self.varTable.getLSup(str(ctx.ID())) # quad de direccion leftOperand2 = self.varTable.vars[str(ctx.ID())].memoryDir Type = self.varTable.vars[str(ctx.ID())].dataType # genera variable temporal que contiene la direccion, se la asigna negativo para identificar self.PilaO.push(("-" + self.Avail.newElement(), Type, self.memoriaTemporal.getEntera() * -1)) # quad direccion result2 = self.PilaO.top() # quad ver leftOperand3 = self.PilaO.top() # aprend quads de suma de direcciones quad3 = Quadruple(operator2, leftOperand2, rightOperand2[0], result2[0]) self.FilaQuads.append(quad3) quad4 = Quadruple(operator2, leftOperand2, rightOperand2[2], result2[2]) self.FilaQuadsMemoria.append(quad4) # quads de verificacion, se usa rightOperand2 porque se necesita el valor dentre de los corchetes quad5 = Quadruple(operator3, rightOperand2[0], rightOperand3, result3) self.FilaQuads.append(quad5) quad6 = Quadruple(operator3, rightOperand2[2], rightOperand3, result3) self.FilaQuadsMemoria.append(quad6) result = self.PilaO.pop() # quad Asingar else: if len(self.PilaFunc.items) == 0: self.varTable.exist(str(ctx.ID())) result = (str(ctx.ID()), self.varTable.vars[str(ctx.ID())].dataType, self.varTable.vars[str(ctx.ID())].memoryDir) else: if self.localVarTable.get_local_variable(str(ctx.ID())): result = (str(ctx.ID()), self.localVarTable.vars[str(ctx.ID())].dataType, self.localVarTable.vars[str(ctx.ID())].memoryDir) else: self.varTable.exist(str(ctx.ID())) result = (str(ctx.ID()), self.varTable.vars[str(ctx.ID())].dataType, self.varTable.vars[str(ctx.ID())].memoryDir) # quad Asignar if SemanticCube().cube[result[1], leftOperand[1], operator] == Types().ERROR: raise Exception(Types().ERROR) quad = Quadruple(operator, leftOperand[0], rightOperand, result[0]) self.FilaQuads.append(quad) quad2 = Quadruple(operator, leftOperand[2], rightOperand, result[2]) self.FilaQuadsMemoria.append(quad2) # ========================== ESCRIBIR ========================== def enterEscribir(self, ctx: AangParser.EscribirContext): self.PilaOper.push(str(ctx.PRINT())) pass def exitEscribir(self, ctx: AangParser.EscribirContext): operator = self.PilaOper.pop() leftOperand = self.PilaO.pop() rightOperand = None result = None quad = Quadruple(operator, leftOperand[0], rightOperand, result) self.FilaQuads.append(quad) quad2 = Quadruple(operator, leftOperand[2], rightOperand, result) self.FilaQuadsMemoria.append(quad2) pass def enterE1(self, ctx: AangParser.E1Context): if ctx.SUMA() != None: self.PilaOper.push(str(ctx.SUMA())) if ctx.RESTA() != None: self.PilaOper.push(str(ctx.RESTA())) def enterFactor(self, ctx: AangParser.FactorContext): if ctx.I_PARENTESIS() != None: self.PilaOper.push(str(ctx.I_PARENTESIS())) pass def exitFactor(self, ctx: AangParser.FactorContext): if ctx.D_PARENTESIS() != None: self.PilaOper.pop() if (self.PilaOper.top() == '/' or self.PilaOper.top() == '*'): operator = str(self.PilaOper.pop()) rightOperand = self.PilaO.pop() leftOperand = self.PilaO.pop() Type = SemanticCube().cube[rightOperand[1], leftOperand[1], operator] if Type == Types().ERROR: raise Exception(Types().ERROR) elif Type == Types().INT: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getEntera())) elif Type == Types().CHAR: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getChar())) elif Type == Types().BOOL: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getBooleanos())) result = self.PilaO.top() quad = Quadruple(operator, leftOperand[0], rightOperand[0], result[0]) self.FilaQuads.append(quad) quad2 = Quadruple(operator, leftOperand[2], rightOperand[2], result[2]) self.FilaQuadsMemoria.append(quad2) # ========================== CONSTANTES ========================== def enterCte_var(self, ctx): if ctx.I_LLAVE() != None: self.PilaOper.push(str(ctx.I_LLAVE())) def exitCte_var(self, ctx: AangParser.Cte_varContext): if ctx.CTE_INT() != None: if not self.constTable.get_constant(ctx.CTE_INT()): self.constTable.add_constant(str(ctx.CTE_INT()), "int", self.memoriaConstante.getEntera()) self.PilaO.push( (int(str(ctx.CTE_INT())), "int", self.constTable.constants[str(ctx.CTE_INT())].memoryDir)) elif ctx.CTE_CHAR() != None: if not self.constTable.get_constant(ctx.CTE_CHAR()): self.constTable.add_constant(str(ctx.CTE_CHAR()), "char", self.memoriaConstante.getChar()) self.PilaO.push( (str(ctx.CTE_CHAR()), "char", self.constTable.constants[str(ctx.CTE_CHAR())].memoryDir)) elif ctx.CTE_BOOL() != None: if not self.constTable.get_constant(ctx.CTE_BOOL()): self.constTable.add_constant( str(ctx.CTE_BOOL()), "bool", self.memoriaConstante.getBooleanos()) self.PilaO.push( (str(ctx.CTE_BOOL()), "bool", self.constTable.constants[str(ctx.CTE_BOOL())].memoryDir)) elif ctx.ID() != None and ctx.I_LLAVE() == None: # if str(ctx.ID()) == 'b': # print(self.PilaFunc.items) if len(self.PilaFunc.items) == 0: self.varTable.exist(str(ctx.ID())) self.PilaO.push( (str(ctx.ID()), self.varTable.vars[str(ctx.ID())].dataType, self.varTable.vars[str(ctx.ID())].memoryDir)) else: if self.localVarTable.get_local_variable(str(ctx.ID())): self.PilaO.push( (str(ctx.ID()), self.localVarTable.vars[str(ctx.ID())].dataType, self.localVarTable.vars[str(ctx.ID())].memoryDir)) else: self.varTable.exist(str(ctx.ID())) self.PilaO.push( (str(ctx.ID()), self.varTable.vars[str(ctx.ID())].dataType, self.varTable.vars[str(ctx.ID())].memoryDir)) elif ctx.ID() != None and ctx.I_LLAVE() != None: # quad de direccion operator2 = '+*' rightOperand2 = self.PilaO.pop() # quad de verificacion operator = "Ver" rightOperand = 0 if len(self.PilaFunc.items) == 0: self.varTable.exist(str(ctx.ID())) # quad de verificacion result = self.varTable.getLSup(str(ctx.ID())) # quad de direccion leftOperand2 = self.varTable.vars[str(ctx.ID())].memoryDir Type = self.varTable.vars[str(ctx.ID())].dataType else: if self.localVarTable.get_local_variable(str(ctx.ID())): self.localVarTable.exist(str(ctx.ID())) # quad de verificacion result = self.localVarTable.getLSup(str(ctx.ID())) # quad de direccion leftOperand2 = self.localVarTable.vars[str( ctx.ID())].memoryDir Type = self.localVarTable.vars[str(ctx.ID())].dataType else: self.varTable.exist(str(ctx.ID())) # quad de verificacion result = self.varTable.getLSup(str(ctx.ID())) # quad de direccion leftOperand2 = self.varTable.vars[str(ctx.ID())].memoryDir Type = self.varTable.vars[str(ctx.ID())].dataType # genera variable temporal que contiene la direccion, se la asigna negativo para identificar self.PilaO.push(("-" + self.Avail.newElement(), Type, self.memoriaTemporal.getEntera() * -1)) # quad direccion result2 = self.PilaO.top() # quad ver leftOperand = self.PilaO.top() # aprend quads de suma de direcciones, , se usa rightOperand2 porque se necesita el valor dentre de los corchetes quad3 = Quadruple(operator2, leftOperand2, rightOperand2[0], result2[0]) self.FilaQuads.append(quad3) quad4 = Quadruple(operator2, leftOperand2, rightOperand2[2], result2[2]) self.FilaQuadsMemoria.append(quad4) # quads de verificacion quad = Quadruple(operator, rightOperand2[0], rightOperand, result) self.FilaQuads.append(quad) quad2 = Quadruple(operator, rightOperand2[2], rightOperand, result) self.FilaQuadsMemoria.append(quad2) if ctx.I_LLAVE() != None: self.PilaOper.pop() def exitTermino(self, ctx: AangParser.TerminoContext): if (self.PilaOper.top() == '-' or self.PilaOper.top() == '+'): operator = str(self.PilaOper.pop()) rightOperand = self.PilaO.pop() leftOperand = self.PilaO.pop() Type = SemanticCube().cube[rightOperand[1], leftOperand[1], operator] if Type == Types().ERROR: raise Exception(Types().ERROR) elif Type == Types().INT: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getEntera())) elif Type == Types().CHAR: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getChar())) elif Type == Types().BOOL: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getBooleanos())) result = self.PilaO.top() quad = Quadruple(operator, leftOperand[0], rightOperand[0], result[0]) self.FilaQuads.append(quad) quad2 = Quadruple(operator, leftOperand[2], rightOperand[2], result[2]) self.FilaQuadsMemoria.append(quad2) def enterT(self, ctx: AangParser.TContext): if ctx.MULT() != None: self.PilaOper.push(str(ctx.MULT())) if ctx.DIVISION() != None: self.PilaOper.push(str(ctx.DIVISION())) def enterAcciones(self, ctx): pass # ========================== VARIABLES ========================== def exitVariable(self, ctx: AangParser.VariableContext): self.PilaTipos.pop() pass def enterTipo_id(self, ctx: AangParser.Tipo_idContext): if ctx.INT() != None: self.PilaTipos.push(str(ctx.INT())) if ctx.CHAR() != None: self.PilaTipos.push(str(ctx.CHAR())) if ctx.BOOL() != None: self.PilaTipos.push(str(ctx.BOOL())) def enterV(self, ctx: AangParser.VContext): if ctx.ID() != None: if self.PilaFunc.top() == None: direccion = 0 if self.PilaTipos.top() == 'int': direccion = self.memoriaGlobal.getEntera() elif self.PilaTipos.top() == 'char': direccion = self.memoriaGlobal.getChar() elif self.PilaTipos.top() == 'bool': direccion = self.memoriaGlobal.getBooleanos() self.varTable.add_variable(str(ctx.ID()), self.PilaTipos.top(), "global", direccion) else: direccion = 0 if self.PilaTipos.top() == 'int': direccion = self.functionDirectory.getNextInt( self.PilaFunc.top()) elif self.PilaTipos.top() == 'char': direccion = self.functionDirectory.getNextBool( self.PilaFunc.top()) elif self.PilaTipos.top() == 'bool': direccion = self.functionDirectory.getNextChar( self.PilaFunc.top()) self.localVarTable.add_variable(str(ctx.ID()), self.PilaTipos.top(), "local", direccion) if ctx.I_LLAVE() != None: self.PilaArr.push(str(ctx.ID())) if self.PilaFunc.top() == None: self.varTable.setIsArray(str(ctx.ID())) else: self.localVarTable.setIsArray(str(ctx.ID())) pass def enterV3(self, ctx: AangParser.VContext): if self.PilaArr.top() != None: if self.PilaFunc.top() == None: # El limite superior es igual al tamaño del arreglo menos 1 self.varTable.setLSup(self.PilaArr.top(), self.PilaO.pop()[0]) if self.PilaTipos.top() == 'int': self.memoriaGlobal.i = self.memoriaGlobal.i + \ self.varTable.getLSup(self.PilaArr.top()) - 1 if self.PilaTipos.top() == 'bool': self.memoriaGlobal.b = self.memoriaGlobal.b + \ self.varTable.getLSup(self.PilaArr.top()) - 1 if self.PilaTipos.top() == 'char': self.memoriaGlobal.c = self.memoriaGlobal.c + \ self.varTable.getLSup(self.PilaArr.top()) - 1 else: # El limite superior es igual al tamaño del arreglo menos 1 self.localVarTable.setLSup(self.PilaArr.top(), self.PilaO.pop()[0]) if self.PilaTipos.top() == 'int': self.memoriaGlobal.i = self.memoriaGlobal.i + \ self.localVarTable.getLSup(self.PilaArr.top()) - 1 if self.PilaTipos.top() == 'bool': self.memoriaGlobal.b = self.memoriaGlobal.b + \ self.localVarTable.getLSup(self.PilaArr.top()) - 1 if self.PilaTipos.top() == 'char': self.memoriaGlobal.c = self.memoriaGlobal.c + \ self.localVarTable.getLSup(self.PilaArr.top()) - 1 self.PilaArr.pop() def enterV1(self, ctx: AangParser.V1Context): if ctx.ID() != None: if self.PilaFunc.top() == None: direccion = 0 if self.PilaTipos.top() == 'int': direccion = self.memoriaGlobal.getEntera() elif self.PilaTipos.top() == 'char': direccion = self.memoriaGlobal.getChar() elif self.PilaTipos.top() == 'bool': direccion = self.memoriaGlobal.getBooleanos() self.varTable.add_variable(str(ctx.ID()), self.PilaTipos.top(), "global", direccion) else: direccion = 0 if self.PilaTipos.top() == 'int': direccion = self.functionDirectory.getNextInt( self.PilaFunc.top()) elif self.PilaTipos.top() == 'char': direccion = self.functionDirectory.getNextBool( self.PilaFunc.top()) elif self.PilaTipos.top() == 'bool': direccion = self.functionDirectory.getNextChar( self.PilaFunc.top()) self.localVarTable.add_variable(str(ctx.ID()), self.PilaTipos.top(), "local", direccion) if ctx.I_LLAVE() != None: self.PilaArr.push(str(ctx.ID())) if self.PilaFunc.top() == None: self.varTable.setIsArray(str(ctx.ID())) else: self.localVarTable.setIsArray(str(ctx.ID())) # ========================== CONDICION ========================== def enterC1(self, ctx: AangParser.C1Context): if (self.PilaO.top()[1] != 'bool'): raise Exception( "El resultado del la condicion del if no es booleano") operator = "GotoF" rightOperand = self.PilaO.pop() leftOperand = None result = "vacio" quad = Quadruple(operator, rightOperand[0], leftOperand, result) self.FilaQuads.append(quad) quad2 = Quadruple(operator, rightOperand[2], leftOperand, result) self.FilaQuadsMemoria.append(quad2) self.PSaltos.push(len(self.FilaQuads) - 1) pass def enterC2(self, ctx: AangParser.C2Context): if ctx.ELSE() == None: numeroQuad = self.PSaltos.pop() # Pila normal self.FilaQuads[numeroQuad].result = len(self.FilaQuads) + 1 # Pila Direcciones self.FilaQuadsMemoria[numeroQuad].result = len( self.FilaQuadsMemoria) + 1 else: operator = "Goto" rightOperand = None leftOperand = None result = "vacio" quad = Quadruple(operator, rightOperand, leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) numeroQuad = self.PSaltos.pop() self.FilaQuads[numeroQuad].result = len(self.FilaQuads) + 1 self.FilaQuadsMemoria[numeroQuad].result = len( self.FilaQuadsMemoria) + 1 self.PSaltos.push(len(self.FilaQuads)) def exitC2(self, ctx: AangParser.C2Context): if ctx.ELSE() != None: salto = self.PSaltos.pop() - 1 self.FilaQuads[salto].result = len(self.FilaQuads) + 1 self.FilaQuadsMemoria[salto].result = len(self.FilaQuads) + 1 # ========================== CICLO ========================== def enterCiclo1(self, ctx: AangParser.Ciclo1Context): self.PSaltos.push(len(self.FilaQuads) + 1) pass def enterCiclo2(self, ctx: AangParser.Ciclo2Context): if (self.PilaO.top()[1] != 'bool'): raise Exception( "El resultado del la condicion del if no es booleano") operator = "GotoF" rightOperand = self.PilaO.pop() leftOperand = None result = "vacio" quad = Quadruple(operator, rightOperand[0], leftOperand, result) self.FilaQuads.append(quad) quad2 = Quadruple(operator, rightOperand[2], leftOperand, result) self.FilaQuadsMemoria.append(quad2) self.PSaltos.push(len(self.FilaQuads)) pass def exitCiclo2(self, ctx: AangParser.Ciclo2Context): operator = "Goto" rightOperand = None leftOperand = None result = "vacio" quad = Quadruple(operator, rightOperand, leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) numeroQuad = self.PSaltos.pop() self.FilaQuads[numeroQuad - 1].result = len(self.FilaQuads) + 1 self.FilaQuadsMemoria[numeroQuad - 1].result = len(self.FilaQuadsMemoria) + 1 numeroQuad = self.PSaltos.pop() self.FilaQuads[len(self.FilaQuads) - 1].result = numeroQuad self.FilaQuadsMemoria[len(self.FilaQuadsMemoria) - 1].result = numeroQuad pass def enterFuncion(self, ctx: AangParser.FuncionContext): self.functionDirectory.add_function(str(ctx.ID())) self.PilaFunc.push(str(ctx.ID())) self.localVarTable = VariableTable({}) self.functionDirectory.setStartPosition(self.PilaFunc.top(), len(self.FilaQuadsMemoria) + 1) pass def exitFuncion(self, ctx: AangParser.FuncionContext): self.functionDirectory.setLocalVariables(self.PilaFunc.top(), len(self.localVarTable.vars)) self.functionDirectory.setTemporalVariables(self.PilaFunc.top(), self.memoriaGlobal.t) self.PilaFunc.pop() operator = "EndFunc" rightOperand = None leftOperand = None result = None quad = Quadruple(operator, rightOperand, leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) # self.memoriaGlobal.resetTemporales() def exitF(self, ctx: AangParser.FContext): if ctx.VOID() != None: self.functionDirectory.setReturnType(self.PilaFunc.top(), str(ctx.VOID())) else: self.functionDirectory.setReturnType(self.PilaFunc.top(), self.PilaTipos.pop()) pass def exitF1(self, ctx: AangParser.F1Context): if ctx.ID() != None: tipo = self.PilaTipos.pop() self.functionDirectory.addParameter(self.PilaFunc.top(), tipo) if tipo == "int": self.localVarTable.add_variable( str(ctx.ID()), tipo, "local", self.functionDirectory.getNextInt(self.PilaFunc.top())) elif tipo == "bool": self.localVarTable.add_variable( str(ctx.ID()), tipo, "local", self.functionDirectory.getNextBool(self.PilaFunc.top())) elif tipo == "char": self.localVarTable.add_variable( str(ctx.ID()), tipo, "local", self.functionDirectory.getNextChar(self.PilaFunc.top())) def exitF2(self, ctx: AangParser.F2Context): if ctx.ID() != None: tipo = self.PilaTipos.pop() self.functionDirectory.addParameter(self.PilaFunc.top(), tipo) if tipo == "int": self.localVarTable.add_variable( str(ctx.ID()), tipo, "local", self.functionDirectory.getNextInt(self.PilaFunc.top())) elif tipo == "bool": self.localVarTable.add_variable( str(ctx.ID()), tipo, "local", self.functionDirectory.getNextBool(self.PilaFunc.top())) elif tipo == "char": self.localVarTable.add_variable( str(ctx.ID()), tipo, "local", self.functionDirectory.getNextChar(self.PilaFunc.top())) def exitFun_regresar(self, ctx: AangParser.Fun_regresarContext): if self.PilaO.top()[1] == self.functionDirectory.getReturnType( self.PilaFunc.top()): operator = "RETURN" rightOperand = None leftOperand = None result = self.PilaO.pop() quad = Quadruple(operator, rightOperand, leftOperand, result[0]) quad2 = Quadruple(operator, rightOperand, leftOperand, result[2]) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) else: raise Exception( "The return type does not match with the function {}".format( self.PilaFunc.top())) pass # ========================== PROGRAMA MAIN ========================== def enterPrincipal(self, ctx: AangParser.PrincipalContext): self.FilaQuads[0].result = len(self.FilaQuads) + 1 self.FilaQuadsMemoria[0].result = len(self.FilaQuadsMemoria) + 1 pass # ========================== LLAMAR FUNCION ========================== def enterLlamar_fun(self, ctx: AangParser.Llamar_funContext): if self.functionDirectory.exist(str(ctx.ID())): self.PilaFuncParam.push(str(ctx.ID())) operator = "ERA" rightOperand = None leftOperand = None result = str(ctx.ID()) quad = Quadruple(operator, rightOperand, leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) self.ParameterCounter = self.functionDirectory.numOfParameters( str(ctx.ID())) self.TempParameters = self.functionDirectory.ParameterList( str(ctx.ID())) pass def exitLlamar_fun(self, ctx: AangParser.Llamar_funContext): if self.ParameterCounter > 0: raise Exception("Less Arguments Passed in to {} Function".format( self.PilaFuncParam.top())) pass # ========================== ARGUMENTOS ========================== def exitArgumentos(self, ctx: AangParser.ArgumentosContext): if ctx.exp() != None: if self.ParameterCounter < 0: raise Exception( "More Arguments Passed in to {} Function".format( self.PilaFuncParam.top())) Result = self.PilaO.pop() if Result[1] != self.TempParameters.pop(0): raise Exception( "Types not match between Function call and Function parameter" ) pass def enterAgregar_args(self, ctx: AangParser.Agregar_argsContext): self.ParameterCounter = self.ParameterCounter - 1 Result = self.PilaO.top() operator = "PARAMETER" rightOperand = Result[2] leftOperand = None result = ("Par" + str( self.functionDirectory.numOfParameters(self.PilaFuncParam.top()) - (self.ParameterCounter))) quad = Quadruple(operator, Result[0], leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) pass def exitAgregar_args(self, ctx: AangParser.Agregar_argsContext): if ctx.COMA() != None: if self.ParameterCounter < 0: raise Exception( "More Arguments Passed in to {} Function".format( self.PilaFuncParam.top())) Result = self.PilaO.pop() if Result[1] != self.TempParameters.pop(0): raise Exception( "Types not match between Function call and Function parameter" ) pass def enterFc(self, ctx: AangParser.FcContext): operator = "GOSUB" rightOperand = self.PilaFuncParam.top() leftOperand = None result = None quad = Quadruple(operator, rightOperand, leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) if not self.functionDirectory.checkVoid(self.PilaFuncParam.top()): operator = "=*" rightOperand = self.PilaFuncParam.top() leftOperand = None Type = self.functionDirectory.getReturnType( self.PilaFuncParam.top()) # self.PilaO.push((self.Avail.newElement(), Type, self.memoriaGlobal.getTemporales())) if Type == Types().INT: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getEntera())) elif Type == Types().CHAR: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getChar())) elif Type == Types().BOOL: self.PilaO.push((self.Avail.newElement(), Type, self.memoriaTemporal.getBooleanos())) result = self.PilaO.top() quad = Quadruple(operator, rightOperand, leftOperand, result[0]) quad2 = Quadruple(operator, rightOperand, leftOperand, result[2]) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) self.PilaFuncParam.pop() pass # ========================== FUNCIONES ESPECIALES ========================== def enterPintar(self, ctx: AangParser.PintarContext): operator = "pintar" rightOperand = None leftOperand = None result = None quad = Quadruple(operator, rightOperand, leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) def exitPintar(self, ctx: AangParser.PintarContext): pass def enterMover(self, ctx: AangParser.MoverContext): pass def exitMover(self, ctx: AangParser.MoverContext): operator = "mover" rightOperand = self.PilaO.pop() leftOperand = None result = None quad = Quadruple(operator, rightOperand[0], leftOperand, result) quad2 = Quadruple(operator, rightOperand[2], leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) pass def enterCambiar(self, ctx: AangParser.CambiarContext): operator = "cambiar" leftOperand = None result = None if ctx.ARRIBA() != None: rightOperand = 'Arriba' elif ctx.ABAJO() != None: rightOperand = 'Abajo' elif ctx.DERECHA() != None: rightOperand = 'Derecha' else: rightOperand = 'Izquierda' quad = Quadruple(operator, rightOperand, leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) pass def exitCambiar(self, ctx: AangParser.CambiarContext): pass def enterColor(self, ctx: AangParser.ColorContext): operator = "color" rightOperand = str(ctx.HEXADECIMAL()) leftOperand = None result = None quad = Quadruple(operator, rightOperand, leftOperand, result) quad2 = Quadruple(operator, rightOperand, leftOperand, result) self.FilaQuads.append(quad) self.FilaQuadsMemoria.append(quad2) pass def exitColor(self, ctx: AangParser.ColorContext): pass
def __init__(self,ip,mac): self.myip=ip self.mymac=mac self.tools=tools() self.mem=memory() self.ruleconstructor=ruleconstructor()
def stats(): """ Return a string of statistics: nodename time: user+sys elapsed, realtime elapsed, CPU usage, memory usage """ nodename = os.uname()[1] t = os.times() usersystime = t[0] + t[1] realtime = t[4] - __initrealtime usage = 100. * usersystime / (realtime + 0.00001) usersystime = datetime.timedelta(seconds=usersystime) realtime = datetime.timedelta(seconds=realtime) return "%s %s: %s user+sys, %s real, %.2f%% usage, %.2f MB" % (nodename, datetime.datetime.now(), usersystime, realtime, usage, memory.memory()/1024./1024.)
import languageTools, utilities, reader, kb, memory, student_code global longTermMemory global statements longTermMemory = memory.memory() statements = [] #Red = "\u001b[31m" #Grn = "\u001b[32m" #Ylw = "\u001b[33m" #Blu = "\u001b[34m" #Mag = "\u001b[35m" #Cyn = "\u001b[36m" # #rd = "\033[31;1m" #em = "\033[4m" #st = "\033[0m" Red = "" Grn = "" Ylw = "" Blu = "" Mag = "" Cyn = "" rd = "" em = "" st = "" lf = "\n"
import os import memory import datetime __initrealtime = os.times()[4] def stats(): """ Return a string of statistics: nodename time: user+sys elapsed, realtime elapsed, CPU usage, memory usage """ nodename = '' try: nodename = os.uname()[1] except Exception, e: nodename = 'zengzengfeng' t = os.times() usersystime = t[0] + t[1] realtime = t[4] - __initrealtime usage = 100. * usersystime / (realtime + 0.00001) usersystime = datetime.timedelta(seconds=usersystime) realtime = datetime.timedelta(seconds=realtime) return "%s %s: %s user+sys, %s real, %.2f%% usage, %.2f MB" % ( nodename, datetime.datetime.now(), usersystime, realtime, usage, memory.memory() / 1024. / 1024.)
def __init__(self, access_token): self.access_token = access_token self.config = configparser.ConfigParser() self.config.read("config.ini") self.memory = memory(cache_name="secret")
logging.debug('taking shot') if dtime.hour in GIF_HOURS: (brightness,written_file) = take_shot.get_image(camera,filename) else: (brightness,written_file) = take_shot.get_image(camera,False) logging.debug('completed shot') logging.debug('writing to db') sqlite_access.append(written_file,brightness,dtime) for hour in GIF_HOURS: if dtime.hour == hour and dtime.minute == 0: logging.debug('creating animation') logging.debug('getting files to be processed for hour %d'%hour) files = [] files = [f['filename'] for f in sqlite_access.query_last_ndays(ndays=30, hour=hour)] logging.debug(files) creategif.create_animation(files,'./animations/sunshine_%dh.gif'%hour) logging.info("Created animation for hour %d"%hour) logging.debug("cleaning up") cleanup_gifs(days_limit=31) logging.debug("memory usage: %.1fMB"%memory()) # check when is the next (minute/hour), set sleep accordingly delay = (5- dtime.minute%5 -1)*60 + 60 - dtime.second logging.debug("delay till next capture %d seconds"%delay) sleep(delay)
def __init__(self): self.config = configparser.ConfigParser() self.config.read("config.ini") self.oauth = self.config.get("jue", "api_oauth") self.memory = memory(cache_name="auth")
import os f1=open("coded.mc") lines=f1.readlines() pc_dict={} for line in lines: [a1,a2]=line.split() pc_dict[int(a1,16)]=a2 from registers import registers from memory import memory my_mem=memory() my_reg=registers() from my_memory import mem_from_data for key in mem_from_data: my_mem.write_byte(key,int(mem_from_data[key],2)) print(pc_dict) class pipelining: def __init__(self): self.PC=0x0 self.IR=0 self.PC_temp=self.PC self.clock=0 self.Cycles = 0 self.IF = ''; self.ID = {}; self.IE = {}; self.IM = []; self.data = [] self.stall_one = False self.stall_two = False self.total_cycles = 0
import register import memory import alu import translator import reportor # Check Input Argument if len(sys.argv)!=2: print "[-] Usage: python " + sys.argv[0] + " [Assembly File]" #Get all line from input file input_file = sys.argv[1] lines = [e.strip() for e in open(input_file)] #Init class mem = memory.memory(ins=lines) reg = register.register() tran = translator.translator() re = reportor.reportor(numMemory=len(lines), startSign='@@@', mem=mem.getAll(), reg=reg.getAll(), pc=0) #Init variable exited = False exception = False cause = "" pc = 0 re.report() #Start Simulator while not exited: #Fetch ins from mem and translate it
import time import signal import sys import memory import botapi import botservice from log import log import tokens log.open("verbot.log") log.out("starting...") MEMORY = "memory.json" mem = memory.memory(MEMORY) m = mem.get() if not m.has_key("offset"): m["offset"] = 0 if not m.has_key("bot"): m["bot"] = {} offset = m["offset"] log.out("offset is %d" % (offset,)) session = botapi.session(tokens.BOT_TOKEN, offset) bot = botservice.bot(m["bot"], session) log.out("started")
def memSim(ref_sequence, frames = 256, pra = 0): #split values from the file ref_sequence page_list = []; offset_list = []; with open(ref_sequence , "r") as seq: for line in seq: address =int(line) page_list.append(address//256) offset_list.append(address%256) #Memory structure creation tlb_l = tlb() page_table_l = page_table(pra) sec_mem = open("BACKING_STORE.bin", "rb") phys_mem = memory(sec_mem, frames) num_addresses = len(page_list) num_tlb_hits = 0 num_tlb_misses = 0 num_page_fault = 0 #memory unit main loop while len(page_list) != 0: tlb_miss = False page_fault = False page_num = page_list[0] offset = offset_list[0] ''' page_backup = page_list.copy() offset_backup = offset_list.copy() ''' page_list.pop(0) offset_list.pop(0) #check for tlb hit frame_number = tlb_l.get(page_num) if frame_number == -1: num_tlb_misses += 1 #check for page_table hit frame_number = page_table_l.get_page(page_num) else: num_tlb_hits += 1 if pra == 1: page_table_l.lru_swap(page_num) elif pra == 3: page_table_l.sec_set(page_num) if frame_number == -1: #page fault num_page_fault += 1 if phys_mem.size == phys_mem.max_size: #page replacement if pra == 2: target_info = page_table_l.void_page(page_list) else: target_info = page_table_l.void_page() frame_number = target_info[1] tlb_l.void(target_info[0]) phys_mem.swap_data(page_num, frame_number) page_table_l.load_page(page_num, frame_number) tlb_l.load(page_num, frame_number) else: #page load frame_number = phys_mem.append_data(page_num) page_table_l.load_page(page_num, frame_number) tlb_l.load(page_num, frame_number) #write out to file data = phys_mem.get_data(frame_number) value = data[offset] if value > 127: value -= 256 address = str(256*page_num+offset) d_string = "" for byte in data: d_string += "{:0>2X}".format(byte) p_string = "{}, {:-}, {}, {}".format(address, value, frame_number, d_string) print(p_string) ''' page_list = page_backup offset_list = offset_backup ''' print("Number of Translated Addresses = {}".format(num_addresses)) print("Page Faults = {}".format(num_page_fault)) print("Page Fault Rate = {:.3f}".format(num_page_fault / num_addresses)) print("TLB Hits = {}".format(num_tlb_hits)) print("TLB Misses = {}".format(num_tlb_misses)) print("TLB Hit Rate = {:.3f}".format(num_tlb_hits / num_addresses)) return 0
import languageTools, utilities, reader, kb, memory, student_code global longTermMemory global statements longTermMemory = memory.memory() statements = [] #Red = "\u001b[31m" #Grn = "\u001b[32m" #Ylw = "\u001b[33m" #Blu = "\u001b[34m" #Mag = "\u001b[35m" #Cyn = "\u001b[36m" # #rd = "\033[31;1m" #em = "\033[4m" #st = "\033[0m" Red = "" Grn = "" Ylw = "" Blu = "" Mag = "" Cyn = "" rd = "" em = "" st = "" lf = "\n" # buildFOPC takes a sentence and Asserts the facts that are derived from it
def __init__(self,ip,mac): self.myip=ip self.mymac=mac self.tools=tools() self.mem=memory()
#January 23, 2018 #Brainfuck interpreter from memory import memory from linter import linter from time import sleep print("BRAINFUCK INTERPRETER:\nBy Anas Elmi ") sleep(1.8) print( "Welcome to the Brainfuck Interpreter. Enter your Brainfuck code below, and it'll run in Python!" ) sleep(1.8) code = input("Enter code here: ") valid_code = linter(code) mem_env = memory() print(mem_env) index = 0 while True: try: char = valid_code[index] #This runs at the end of our loop, printing the status of our tape and exitng the program except: print(mem_env) break if char == "+": mem_env.increase_cell() index += 1 continue
import os import memory import datetime __initrealtime = os.times()[4] def stats(): """ Return a string of statistics: nodename time: user+sys elapsed, realtime elapsed, CPU usage, memory usage """ nodename='' try: nodename = os.uname()[1] except Exception, e: nodename = 'zengzengfeng' t = os.times() usersystime = t[0] + t[1] realtime = t[4] - __initrealtime usage = 100. * usersystime / (realtime + 0.00001) usersystime = datetime.timedelta(seconds=usersystime) realtime = datetime.timedelta(seconds=realtime) return "%s %s: %s user+sys, %s real, %.2f%% usage, %.2f MB" % (nodename, datetime.datetime.now(), usersystime, realtime, usage, memory.memory()/1024./1024.)