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, 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()
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]))
#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.)
