def main():
queue = Queue(10)
queue.add("Douglas")
queue.add("Schneider")
queue.add("Serena")
print(queue.showFull())
print(queue.show())
class Assembler:
class QNode:
"""
This class is used in queue for JP command, each node
can be waiting for its JP to be found or be ready to
get yielded out.
"""
def __init__(self, code: str, line_num: Union[None, int],
jp_name: Union[str, None]):
self.code = code
self.line_num = line_num
self.jp_name = jp_name
# noinspection SpellCheckingInspection
instructions = {
# ins: (hex_code, accepts_addr)
"load": (0x0, True),
"iload": (0x8, True),
"store": (0x1, True),
"istore": (0x9, True),
"add": (0x2, True),
"iadd": (0xA, True),
"and": (0x3, True),
"iand": (0xB, True),
"jump": (0x4, True),
"ijump": (0xC, True),
"jumpz": (0x5, True),
"ijumpz": (0xD, True),
"comp": (0x6, False),
"lsl": (0x7, False)
}
def __init__(self, reader_handler: Iterable[str]):
"""
:param reader_handler: an iterable containing strings of each line
of file
"""
self.reader_handler = reader_handler
self.jump_points = {} # jump_point_name: 3bits_addr
self.variables = {} # variable name: (address, init_value) of it
self.variable_names = [] # ordered variable names for yielding
# them in order to the output.
self.last_free_addr = 0x1 # used for variables
self.current_addr = None # used for instructions
self.queue = Queue() # used make JP work, contains QNode
def __check_variable(self, line_num, ins):
if ins[0].lower().strip() == "var":
# Defining variable
if (len(ins) != 3 or ins[1] in self.variables
or ins[1].lower() in self.instructions
or ins[1][0].isnumeric() or self.current_addr is not None):
raise AssembleSyntaxError(f"Invalid syntax or variable name"
f" at {line_num}")
# following line will add the address and init value of the var
self.variables[ins[1]] = (self.last_free_addr,
self.__get_hex(ins[2], line_num))
self.variable_names.append(ins[1])
self.last_free_addr += 1
return True
return False
@staticmethod
def __remove_comment(line: str):
index = line.find("#")
if index >= 0:
return line[:index]
return line
def __check_jp(self, line_num, ins):
if len(ins) > 0 and ins[0].lower() == "jp":
if (len(ins) == 2 and ins[1] not in self.jump_points
and ins[1] not in self.variables and ins[1][0].isalpha()
and ins[1].lower() not in self.instructions):
self.jump_points[ins[1]] = self.current_addr
return True
else:
raise AssembleSyntaxError(f"Invalid JP syntax or Invalid JP "
f"name at line {line_num}")
return False
def __check_group1_ins(self, line_num, ins):
"""
check for load, store, add, and
"""
if len(ins) >= 1 and ins[0].lower() in ("add", "load", "and", "store"):
if len(ins) == 2:
self.current_addr += 1
ins_code, ins_addr = self.instructions[ins[0].lower()]
tmp = hex(ins_code)[2:] # instruction address in hex
tmp2 = self.__get_hex(ins[1], line_num)
ins.clear() # for letting caller know that it worked
yield tmp + tmp2[1:]
else:
raise AssembleSyntaxError(f"Invalid Syntax at line {line_num}"
f" - Instruction must be two parts")
def __check_group2_ins(self, line_num, ins):
if len(ins) >= 1 and ins[0].lower() in ("comp", "lsl"):
if not len(ins) == 1:
raise AssembleSyntaxError(f"Invalid Syntax, Instruction must"
f"one part - at line {line_num}")
ins_code, tmp = self.instructions[ins[0].lower()]
self.current_addr += 1
ins.clear()
yield self.__get_hex(ins_code, line_num)[0] + "000"
def __check_group3_ins(self, line_num, ins):
if len(ins) >= 1 and ins[0].lower() in ("jump", "jumpz"):
if len(ins) == 2:
ins_code, tmp = self.instructions[ins[0]]
if ins[1] in self.jump_points:
tmp = hex(ins_code)[2:] # instruction address in hex
tmp2 = self.__get_hex(self.jump_points[ins[1]], line_num)
yield tmp + tmp2[1:]
else:
tmp = hex(ins_code)[2:] + "000"
self.queue.put(Assembler.QNode(tmp, line_num, ins[1]))
self.current_addr += 1
ins.clear()
else:
raise AssembleSyntaxError(f"Invalid Syntax, jump needs a JP at"
f" line {line_num}")
def __mainloop(self):
# read every line from the input
for line_num, line in enumerate(self.reader_handler):
# comments
line = self.__remove_comment(line)
if not line:
continue
ins = line.split()
if not ins:
continue
# variables
if self.__check_variable(line_num, ins):
continue
# check if first ins after VAR definitions and insert them
if self.current_addr is None:
# means this is last VAR define, so lets begin instruction part
self.current_addr = self.last_free_addr
# now lets first insert the lines into the file
# first of all we have to tell it to jump to the last free
# place available after all variables
tmp = hex(self.current_addr)[2:]
yield "4" + ("0" * (3 - len(tmp))) + tmp
# now we have to insert variables
# it's already ordered, so starts from 1
for var_name in self.variable_names:
yield self.variables[var_name][1]
# jump points
if self.__check_jp(line_num, ins):
continue
if not ins[0].lower() in self.instructions:
raise AssembleSyntaxError(f"Invalid instruction name "
f"at line {line_num}")
# check - load, store, add, and,
yield from self.__check_group1_ins(line_num, ins)
if not ins:
continue
# check - comp, lsl,
yield from self.__check_group2_ins(line_num, ins)
if not ins:
continue
# check - jump, jumpz
yield from self.__check_group3_ins(line_num, ins)
if not ins:
continue
raise AssembleSyntaxError(f"Unknown syntax at line {line_num}")
# the for has ended, lets check if current_addr is None
if self.current_addr is None:
self.current_addr = self.last_free_addr
# first of all we have to tell it to jump to the last free place
# available after all variables
tmp = hex(self.current_addr)[2:]
yield "4" + ("0" * (3 - len(tmp))) + tmp
# now we have to insert variables
# it's already ordered, so starts from 1
for var_name in self.variable_names:
yield self.variables[var_name][1]
# now let's add a loop at the end of code.
tmp = hex(self.current_addr)[2:]
yield "4" + ("0" * (3 - len(tmp))) + tmp
def __get_hex(self, _input: Union[int, str], line_num: int) -> str:
"""
gets a "0x5" hex like or an integer or variable name
as input and returns hex string.
:param _input: hex or integer string
:param line_num: line number for syntax error raising
:return: hex string
"""
if isinstance(_input, int):
res = hex(_input)[2:]
return ("0" * (4 - len(res))) + res
elif isinstance(_input, str):
if _input.isnumeric():
num = hex(int(_input))[2:]
return ("0" * (4 - len(num))) + num
elif len(_input) > 2 and "x" == _input[1].lower() and \
_input[0] == "0" and self.__ishex(_input[2:]):
num = hex(int(_input, 16))[2:]
return ("0" * (4 - len(num))) + num
elif _input in self.variables:
num = hex(self.variables[_input][0])[2:]
return ("0" * (4 - len(num))) + num
else:
raise AssembleSyntaxError("Invalid syntax while converting to "
f"hex at line {line_num}")
else:
raise AssembleSyntaxError("Invalid func argument")
@staticmethod
def __ishex(_input: str) -> bool:
"""
checks whether all characters in _input is 0 to 9 and a to f
"""
return all(map(Assembler.__ishex_tool1, _input))
@staticmethod
def __ishex_tool1(ch):
return ch.isnumeric or ch.lower() in "abcdef"
def run_assemble(self):
for i in self.__mainloop():
if self.queue.empty():
yield i
else:
self.queue.put(Assembler.QNode(i, None, None))
waiting_code: Assembler.QNode = self.queue.show()
if waiting_code.jp_name in self.jump_points:
while not self.queue.empty():
item: Assembler.QNode = self.queue.show()
if item.jp_name is None:
self.queue.get()
yield item.code
elif item.jp_name in self.jump_points:
self.queue.get()
addr = self.__get_hex(
self.jump_points[item.jp_name],
item.line_num)[1:]
yield item.code[0] + addr
else:
break
from Queue import Queue
import os, sys
currentdir = os.path.dirname(os.path.realpath(__file__))
parentdir = os.path.dirname(currentdir)
sys.path.append(parentdir)
from helpers import readData
from env import env
if __name__ == "__main__":
airbnbList = readData(env['path_airbnb'])
myQueue = Queue()
for i in range(myQueue.limit):
myQueue.insert(airbnbList[i])
myQueue.show()
#myQueue.remove()
print(
"##############################################################################################################################"
)
myQueue.tam()
myQueue.remove()
print(
"##############################################################################################################################"
)
myQueue.insert(airbnbList[0])
myQueue.show()
from Stack import Stack from Queue import Queue myStack = Stack() myStack.push(12) myStack.push(34) myStack.push(78) myStack.show() myStack.pop() myStack.show() myQueue = Queue() myQueue.push(54) myQueue.push(67) myQueue.push(13) myQueue.show() myQueue.pop() myQueue.show()
