Ejemplo n.º 1
0
    def importBeerXML(self):
        fichierBeerXML = self.s
        try:
            self.recipe = Recipe.parse(fichierBeerXML)
            self.currentRecipeMash = self.recipe.mash

        except:
            errors = Errors()
            errors.warningXml()
Ejemplo n.º 2
0
def quantize(input_image: str, output_image: str, r_bits: int, g_bits: int,
             b_bits: int):

    err = Errors()

    with open(input_image, 'rb+') as fi:
        # read the the first part of the header
        header_header = byte_list(fi, 12)
        image_width_raw = byte_list(fi, 2)
        image_width = int_from_bytes(image_width_raw)
        image_height_raw = byte_list(fi, 2)
        image_height = int_from_bytes(image_height_raw)
        # read the rest of the header
        pixel_depth = one_byte(fi)
        image_descriptor = one_byte(fi)

        with open(output_image, 'wb') as fo:

            # copy the header over
            fo.write(bytes(header_header))
            fo.write(bytes(image_width_raw))
            fo.write(bytes(image_height_raw))
            fo.write(bytes([pixel_depth]))
            fo.write(bytes([image_descriptor]))
            # wrap the bits counts inside a convienient list
            colour_bits_count = [b_bits, g_bits, r_bits]

            # process the pixels
            for _ in range(0, image_height):
                for __ in range(0, image_width):
                    # take three bytes for each pixel (BGR *not* RGB)
                    pixel = byte_list(fi, 3)
                    quantized_pixel = []
                    for colour in [0, 1, 2]:
                        # how many bits have to be striped off
                        shift = 8 - colour_bits_count[colour]
                        q = pixel[colour]
                        if shift > 0:
                            # strip off unnecessary bits
                            q = q >> shift
                            # to make sure we've got a middle value of the range that comes from
                            # quantizing the pixel add a one and then fill out the rest with zeroes
                            q = q << 1
                            q += 1
                            if shift > 1:
                                q = q << shift - 1
                        fo.write(bytes([q]))
                        # add appropriate values to SNR and MSE
                        err.register_val(pixel[colour], q, COLOURS[colour])

            # copy the footer over
            x = fi.read(1)
            while x:
                fo.write(x)
                x = fi.read(1)

    return err
    def set_points(self, input_parameters):
        # Gets and sets all the values* to class parameters
        # Values - x and y for every methods and for error approximation

        methods = Methods()
        # ------------------------------------------------
        # Set values given by Numeric methods
        # ------------------------------------------------

        methods.set_x(input_parameters, self.x_common)

        methods.exact_solution(input_parameters, self.x_common, self.y_exact)
        methods.euler_method(input_parameters, self.x_common, self.y_euler)
        methods.improved_euler_method(input_parameters, self.x_common,
                                      self.y_imp_euler)
        methods.runge_kutta_method(input_parameters, self.x_common, self.y_fk)

        # ------------------------------------------------
        # Set values of Local approximation errors
        # ------------------------------------------------

        errors = Errors()
        errors.local_error(self.diff_exact_euler, self.y_exact, self.y_euler)
        errors.local_error(self.diff_exact_imp_euler, self.y_exact,
                           self.y_imp_euler)
        errors.local_error(self.diff_exact_rk, self.y_exact, self.y_fk)

        # ------------------------------------------------
        # Set values of Max approximation errors
        # ------------------------------------------------

        self.n_x, self.n_euler, self.n_euler_imp, self.n_rk = errors.max_error(
            input_parameters)
Ejemplo n.º 4
0
def handle_next_stage(result, next_stage=None):
    if not Errors().is_ok():
        for error in Errors().list:
            print(error)

        exit(-1)

    if next_stage is None:
        return result

    return next_stage(result)
Ejemplo n.º 5
0
def res(code=Errors.SUCCESS, data=None, error=None, extra_msg=None):
    result = {
        'code': code,
    }
    if Errors.is_succeed(code):
        result['success'] = True
        result['detail'] = data
    else:
        result['success'] = False
        if error:
            result['error'] = error
        else:
            result['error'] = Errors.error_msg(code, extra_msg)
    return jsonify(**result)
Ejemplo n.º 6
0
def parse_source_code(text: str):
    ast = parser.parse(text, tracking=True)

    if Args().stop_after_parsing and Errors().is_ok():
        print(json.dumps(AstToDictVisitor().visit(ast)))
        exit(0)

    return handle_next_stage(ast, visit_ast)
Ejemplo n.º 7
0
 def testConflict(self):
     st = SymbolTable()
     errors = Errors()
     st.add('x', self.x, errors)
     st.add('x', self.x2, errors)
     self.assertEquals(errors.num_errors, 1)
     self.assertEquals(st.get_names(), set(['x']))
     self.assertEquals(st.lookup('x'), self.x)
Ejemplo n.º 8
0
 def __init__(self, lib_path, do_type_check):
     self.errors = Errors()
     self.lib_path = lib_path
     self.do_type_check = do_type_check
     self.sem_analyzer = SemanticAnalyzer(lib_path, self.errors)
     self.type_checker = TypeChecker(self.errors, self.sem_analyzer.modules)
     self.states = []
     self.module_files = {}
Ejemplo n.º 9
0
 def auth_function(*args, **kwargs):
     if AUTH_ENABLED == True:
         user = r.get(request.headers.get('Authorization'))
         print(user)
         if user == None:
             return Errors.unauthorized()
     else:
         return f(*args, **kwargs)
Ejemplo n.º 10
0
 def __init__(self):
     checker.types = TopTypes()
     checker.errors = Errors()
     for ast in PREDEF_CLASSES:
         checker.types.put(ast.type_name, self.make_class_info(ast))
     for name in PREDEF_TYPES:
         checker.types.put(name, PrimitiveType(name))
     nilType = NilType()
     checker.types.put(nilType.name, nilType)
Ejemplo n.º 11
0
    def assertSuccess(self, input):
        errors = Errors()
        fl = Flatten(input, errors)
        self.assertEquals(errors.num_errors, 0)
        self.assertEquals(errors.num_warnings, 0)

        inl = Inline(input, errors)
        self.assertEquals(errors.num_errors, 0)
        self.assertEquals(errors.num_warnings, 0)
Ejemplo n.º 12
0
    def __init__(self, threadID, dataSet, minStartWeight, maxStartWeight):
        Process.__init__(self)
        self.threadID = threadID

        self.weights = Weights(dataSet.getDataPoint(0).dimension())
        self.weights.generateRandom(minStartWeight, maxStartWeight)
        weight = """*****\nThread {0} initial weights:\n{1}\n*****"""
        print(weight.format(self.threadID, self.weights.vector))

        self.trainingErrors = Errors(dataSet.trainingDataPoints, dataSet.trainingActualValues)
        self.testingErrors = Errors(dataSet.testingDataPoints, dataSet.testingActualValues)

        self.hypothesis = Hypothesis()

        self.trainingErrors.updateToLower(self.weights, self.hypothesis)

        self.iterations = 0
        self.alpha = STARTING_ALPHA
Ejemplo n.º 13
0
 def testShadow(self):
     parent = SymbolTable()
     parent.add('x', self.x, None)
     st = SymbolTable(parent)
     errors = Errors()
     st.add('x', self.x2, errors)
     self.assertEquals(errors.num_warnings, 1)
     self.assertEquals(st.get_names(), set(['x']))
     self.assertEquals(st.get_all_names(), set(['x']))
     self.assertEquals(st.lookup('x'), self.x2)
Ejemplo n.º 14
0
def query():
    """Processes 'query' method"""
    filter_by = request.args.get('filter_by')
    group_by = request.args.get('group_by')
    sort_by = request.args.get('sort_by')
    columns = request.args.get('columns')
    arguments = {
        "filter_by": filter_by,
        "group_by": group_by,
        "sort_by": sort_by,
        "columns": columns,
    }
    # returns the json dictionary
    try:
        return Handler.creating_answer(arguments)
    except OperationalError as e:
        return Errors.existing_errors(e)
    except IndexError:
        return Errors.created_errors("IndexError")
Ejemplo n.º 15
0
    def enregistrer(self):
        if self.recipe.name != self.lineEditRecette.text():
            self.nameChanged = True
        else:
            self.nameChanged = False

        self.recipe.name = self.lineEditRecette.text()
        self.recipe.style = self.lineEditGenre.text()
        self.recipe.brewer = self.lineEditBrewer.text()
        self.recipe.boil = self.spinBoxBoil.value()
        if not self.s:
            destination = recettes_dir + "/" + \
                self.recipe.name.replace('/', ' ') + ".xml"
            if os.path.exists(destination):
                errors = Errors()
                errors.warningExistingPath()
                self.fileSaved = False
            else:
                self.s = destination
                self.enregistrerRecette(destination)
        else:
            self.enregistrerRecette(self.s)
Ejemplo n.º 16
0
    def __init__(self, ast, output_name):
        self.output_name = output_name
        #if set to true, remains labels
        self.debug = False

        self.a = None
        self.b = None
        self.c = None
        self.d = None
        self.e = None
        self.f = None

        self.types = {}
        self.types['var'] = 'int'
        self.types['number'] = 'number'
        self.types['table'] = 'table'
        self.counter = 0

        #access to errors
        self.error = Errors()
        self.iterators = {}
        # indicates next address to assign
        self.ptr = 4
        self.load_registers()
        self.parse_tree = ast
        self.variables = self.get_variables()
        self.declarations = self.variables.keys()
        self.decoder = RegisterInstructions()
        self.assembler = self.decoder.get_assembler()
        self.commands = ast[2]
        # help addresses to swap or for temporary storage
        self.help1 = 0
        self.help2 = 1
        self.help3 = 2
        self.help4 = 3
        ##############
        self.storeNumberInVariables('1', '')
Ejemplo n.º 17
0
def api():
    if request.method == 'GET':
        return jsonify(text='This is how you should format your POST data.')
    if request.method == 'POST':
        try:
            f = request.get_json()
        except Exception as e:
            # Should log this error maybe?
            print(e)
            return Errors.bad_request()
        else:
            for text in f:
                print(
                    datetime.datetime.fromtimestamp(timestamp).strftime(
                        '%Y-%m-%d %H:%M:%S'))
                return jsonify(Sentiment.demo_vader_instance(f[text]))
Ejemplo n.º 18
0
class Methods():
    def __init__(self, ast, output_name):
        self.output_name = output_name
        #if set to true, remains labels
        self.debug = False

        self.a = None
        self.b = None
        self.c = None
        self.d = None
        self.e = None
        self.f = None

        self.types = {}
        self.types['var'] = 'int'
        self.types['number'] = 'number'
        self.types['table'] = 'table'
        self.counter = 0

        #access to errors
        self.error = Errors()
        self.iterators = {}
        # indicates next address to assign
        self.ptr = 4
        self.load_registers()
        self.parse_tree = ast
        self.variables = self.get_variables()
        self.declarations = self.variables.keys()
        self.decoder = RegisterInstructions()
        self.assembler = self.decoder.get_assembler()
        self.commands = ast[2]
        # help addresses to swap or for temporary storage
        self.help1 = 0
        self.help2 = 1
        self.help3 = 2
        self.help4 = 3
        ##############
        self.storeNumberInVariables('1', '')

    def load_registers(self):
        self.a = Register("a", self.ptr)
        self.ptr += 1
        self.b = Register("b", self.ptr)
        self.ptr += 1
        self.c = Register("c", self.ptr)
        self.ptr += 1
        self.d = Register("d", self.ptr)
        self.ptr += 1
        self.e = Register("e", self.ptr)
        self.ptr += 1
        self.f = Register("f", self.ptr)
        self.ptr += 1

    ############################################33
    # load declarations / arrays/ variables
    ##############################################3
    def get_variables(self):
        declarations = []
        dict = {}

        def get_arr(t):
            arr = list(t)
            if isinstance(arr[0], str) == False:
                del arr[0]
            return arr

        def go_rec(tree):
            copy = tree
            declarations.append(get_arr(tree))
            if isinstance(tree[0], tuple):
                go_rec(tree[0])

        go_rec(self.parse_tree[1])

        for declaration in declarations:

            declaration_id = declaration[1]
            if declaration_id in dict.keys():
                if declaration[0] == self.types['table']:
                    line = declaration[4]
                else:
                    line = declaration[2]
                self.error.redeclaration(line)
            else:
                # array declaration
                if declaration[0] == self.types['table']:
                    line = declaration[4]
                    # wrong table declaration
                    if int(declaration[2]) > int(declaration[3]):

                        self.error.wrong_array_declaration(line)
                    else:

                        first = int(declaration[2])
                        last = int(declaration[3])
                        table = Table(declaration_id, first, last)

                        table.first_address_id = self.ptr
                        self.ptr += table.length - 1
                        table.last_address_id = self.ptr
                        self.ptr = self.ptr + 1
                        dict[table.name] = table

                else:
                    variable = Variable(declaration_id)
                    variable.address = self.ptr
                    self.ptr += 1
                    dict[variable.name] = variable
        return dict

    def compile(self):
        self.assembly()

    #############################################33
    # UTILS methods
    ##############################################3

    def get_assembler(self):

        commands = self.parse_tree[2:][0]
        for command in commands:
            self.match_action(command)

        self.assembler.append("HALT")
        self.clear_assembly_code(self.assembler, self.debug)
        f = open(self.output_name, "w")
        for a in self.assembler:
            f.write(str(a) + '\n')
        f.close()

    def add_var_to_variables(self, name):
        variable = Variable(name)
        self.ptr += 1
        variable.address = self.ptr
        self.variables[variable.name] = variable

    def check_if_correct_tab_index(self, tab_name, idx):
        obj = self.variables[tab_name]
        start = obj.first
        end = obj.last
        if not int(start) <= idx <= int(end):
            self.error.wrong_table_index("")

    def remove_variable_from_variables(self, name):
        self.variables.pop(name, None)

    def setValueInRegister(self, register, value):
        self.set_number_in_register(register.name, value)
        #self.decoder.STORE(register.name,register.name)

    def setAddressInRegister(self, register, memory_cell):
        register.address = memory_cell
        self.set_number_in_register(register.name, memory_cell)

    def getVarAddress(self, name):
        obj = self.variables[str(name)]
        return obj.address

    def getNumberAddress(self, name):
        obj = self.variables[str(name)]
        return obj.get_address()

    def set_number_in_register(self, reg, number, bound=5):

        self.decoder.RESET(reg)
        temp = []
        number = int(number)
        while number > bound:
            if number % 2:
                number -= 1
                temp.append(self.decoder.INC(reg, False))
            else:
                number = number // 2
                temp.append(self.decoder.SHL(reg, False))

        while number > 0:
            number -= 1
            temp.append(self.decoder.INC(reg, False))

        temp.reverse()
        self.decoder.executeList(temp)

    def loadValueOfAddressToRegister(self, address, register):
        self.setValueInRegister(self.f, int(address))
        self.decoder.LOAD(register, self.f.name)

    def printValueOfAddress(self, address):
        self.loadValueOfAddressToRegister(address, self.a)
        self.decoder.STORE(self.a.name, self.f.name)
        self.decoder.PUT(self.f.name)

    def storeNumberInVariables(self, value, line):
        if value in self.variables.keys():
            self.error.redeclaration(str(line))

        self.ptr = self.ptr + 1
        addr = self.ptr
        obj = Number(value)
        obj.value = int(value)
        obj.address = addr
        self.variables[value] = obj
        self.setValueInRegister(self.b, int(value))
        self.setValueInRegister(self.c, addr)
        self.decoder.STORE(self.b.name, self.c.name)

    # based on index  number or variable  return its addr in b register
    def set_table_address_in_B(self, tab_name, value):

        obj = self.variables[tab_name]
        # get the address of fires tab value
        first_address = obj.get_first_address()
        first_idx = obj.first
        variable_address = self.getVarAddress(value)
        self.setValueInRegister(self.e, first_idx)
        self.loadValueOfAddressToRegister(variable_address, self.d.name)
        #off set
        self.decoder.SUB(self.d.name, self.e.name)
        # add offset and strign address for particular array
        # store res in b
        self.setValueInRegister(self.b, first_address)
        self.decoder.ADD(self.b.name, self.d.name)

    ################################################
    # READ
    ################################################

    def read(self, command):
        self.decoder.RESET(self.b.name)
        self.decoder.RESET(self.c.name)
        self.decoder.RESET(self.d.name)
        self.decoder.RESET(self.f.name)
        self.decoder.RESET(self.e.name)
        self.decoder.RESET(self.a.name)
        # read to a
        line = command[2]
        type = command[1][0]
        self.set_var_declared(command[1][1], line)
        if type == self.types['var']:

            variable_name = command[1][1]
            if variable_name not in self.variables.keys():
                self.error.undeclared_variable(line)
            # ustawiam rejest a na wartosc adresu int var
            addr = self.getVarAddress(variable_name)
            self.setAddressInRegister(self.a, addr)
            # czytam do tego adresu
            self.decoder.GET(self.a)

        # tab
        elif type == self.types['table']:
            tab_name = command[1][1]
            if command[1][2][0] == self.types['number']:

                value = command[1][2][1]
                tab_name = command[1][1]

                if tab_name not in self.variables.keys():
                    self.error.undeclared_table(line)

                self.check_if_correct_tab_index(tab_name, int(value))

                if value not in self.variables.keys():
                    self.storeNumberInVariables(value, line)
                self.set_table_address_in_B(tab_name, value)
                # now in b we got proper tab(n) address
                # so we can GET into it
                self.decoder.GET(self.b)
                self.decoder.RESET(self.b.name)

            #int
            else:

                line = command[2]
                variable_name = command[1][2][1]
                tab_name = command[1][1]

                if tab_name not in self.variables.keys():
                    self.error.undeclared_table(line)

                if variable_name not in self.variables.keys():
                    self.error.unknown_variable(line)

                self.set_table_address_in_B(tab_name, variable_name)
                # now in b we got proper tab(n) address
                # so we can GET into it
                self.decoder.GET(self.b)
                self.decoder.RESET(self.b.name)

        else:
            self.error.read_error(line)

    #############################################33
    # WRITE
    ##############################################3

    def write(self, command):
        line = int(command[2])
        type = command[1][0]
        id = command[1][1]
        self.decoder.RESET(self.b.name)
        self.decoder.RESET(self.c.name)
        self.decoder.RESET(self.d.name)
        self.decoder.RESET(self.f.name)
        self.decoder.RESET(self.e.name)
        self.decoder.RESET(self.a.name)

        # int var
        if type == self.types['var']:

            self.check_var_declared(id, line)

            # get address of a variavle
            addr = self.getVarAddress(id)
            # set address as a value of register a
            self.setValueInRegister(self.a, addr)
            self.decoder.LOAD(self.b.name, self.a.name)
            # store in b
            self.decoder.STORE(self.b.name, self.f.name)
            # write
            self.decoder.PUT(self.f.name)
        #tab
        elif type == self.types['table']:
            tab_name = command[1][1]
            line = command[2]

            #  tab with int variable alike tab(n)
            if command[1][2][0] == self.types['var']:
                variable_name = command[1][2][1]
                if variable_name not in self.variables.keys():
                    self.error.unknown_variable(line)
                #get address of particual element
                self.set_table_address_in_B(tab_name, variable_name)
                self.decoder.LOAD(self.d.name, self.b.name)
                self.decoder.STORE(self.d.name, self.c.name)
                self.decoder.PUT(self.c.name)

            else:
                index_value = command[1][2][1]
                if index_value not in self.variables.keys():
                    self.storeNumberInVariables(index_value, line)
                self.check_if_correct_tab_index(tab_name, int(index_value))
                #get address of particual element
                self.set_table_address_in_B(tab_name, index_value)
                self.decoder.LOAD(self.d.name, self.b.name)
                self.decoder.STORE(self.d.name, self.c.name)
                self.decoder.PUT(self.c.name)

        elif type == self.types['number']:
            # set numeric value in a register b
            self.setValueInRegister(self.b, int(command[1][1]))
            # do write we have to store it in helper memory slot and then
            # invoke by its address
            # load value of helper addres into c
            self.setValueInRegister(self.c, self.help1)
            # store numeric value in help addres
            self.decoder.STORE(self.b.name, self.c.name)
            # now we can invoke put on helper address to write number
            self.decoder.PUT(self.c.name)
            self.decoder.RESET(self.b.name)
        else:
            self.error.write_error(line)

    #######################################################
    # Expressions
    #######################################################
    def addition(self):
        # left ->  a register
        # right -> c register

        self.decoder.RESET(self.b.name)
        self.decoder.LOAD(self.b.name, self.a.name)
        self.decoder.LOAD(self.a.name, self.c.name)
        self.decoder.ADD(self.b.name, self.a.name)

    def exp_subtraction(self):

        self.decoder.RESET(self.b.name)
        self.decoder.LOAD(self.b.name, self.a.name)
        self.decoder.LOAD(self.a.name, self.c.name)
        self.decoder.SUB(self.b.name, self.a.name)

    def multiplication(self):
        labels = self.get_label_dict(4)
        self.decoder.LOAD(self.a.name, self.a.name)
        self.decoder.LOAD(self.c.name, self.c.name)
        self.decoder.RESET(self.b.name)
        self.decoder.setLabel(labels[1])
        self.decoder.JZERO(self.c.name, labels[4])
        self.decoder.JODD(self.c.name, labels[3])
        self.decoder.setLabel(labels[2])
        self.decoder.SHR(self.c.name)
        self.decoder.ADD(self.a.name, self.a.name)
        self.decoder.JUMP(labels[1])
        self.decoder.setLabel(labels[3])
        self.decoder.ADD(self.b.name, self.a.name)
        self.decoder.JUMP(labels[2])
        self.decoder.setLabel(labels[4])

    def division(self, register):

        labels = self.get_label_dict(7)
        self.decoder.LOAD(self.d.name, self.a.name)
        self.decoder.LOAD(self.c.name, self.c.name)
        self.decoder.RESET(register.name)
        self.decoder.JZERO(self.c.name, labels[7])
        self.decoder.RESET(self.e.name)
        self.decoder.ADD(self.e.name, self.c.name)
        self.decoder.RESET(register.name)
        self.decoder.addLabel(labels[2])
        self.decoder.ADD(register.name, self.e.name)
        self.decoder.SUB(register.name, self.d.name)
        self.decoder.JZERO(register.name, 2)
        self.decoder.JUMP(labels[3])
        self.decoder.SHL(self.e.name)
        self.decoder.JUMP(labels[2])
        self.decoder.addLabel(labels[3])
        self.decoder.RESET(register.name)
        self.decoder.addLabel(labels[1])
        self.decoder.RESET(self.f.name)
        self.decoder.ADD(self.f.name, self.e.name)
        self.decoder.SUB(self.f.name, self.d.name)
        self.decoder.JZERO(self.f.name, labels[6])
        self.decoder.SHL(register.name)
        self.decoder.SHR(self.e.name)
        self.decoder.JUMP(labels[5])
        self.decoder.addLabel(labels[6])
        self.decoder.SHL(register.name)
        self.decoder.INC(register.name)
        self.decoder.SUB(self.d.name, self.e.name)
        self.decoder.SHR(self.e.name)
        self.decoder.addLabel(labels[5])
        self.decoder.RESET(self.f.name)
        self.decoder.ADD(self.f.name, self.c.name)
        self.decoder.SUB(self.f.name, self.e.name)
        self.decoder.JZERO(self.f.name, labels[1])
        self.decoder.addLabel(labels[7])

    # returns dict of labels
    # predefined number of labels needed
    def get_label_dict(self, amount):
        labels = {}
        for i in range(1, amount + 1):
            labels[i] = self.injectAsmLabel()

        return labels

    def modulo(self):

        labels = self.get_label_dict(4)

        # by default operating data stored in a,c addresses
        # load them into b and d
        self.decoder.LOAD(self.d.name, self.a.name)
        self.decoder.LOAD(self.c.name, self.c.name)
        # by rules mod 0 is zero if right side value
        # is zero then jump and return 0
        self.decoder.JZERO(self.c.name, labels[4])
        self.decoder.RESET(self.e.name)
        self.decoder.ADD(self.e.name, self.c.name)
        self.decoder.addLabel(labels[1])
        self.decoder.RESET(self.b.name)
        self.decoder.ADD(self.b.name, self.e.name)
        self.decoder.SUB(self.b.name, self.d.name)
        self.decoder.JZERO(self.b.name, 2)
        self.decoder.JUMP(3)
        self.decoder.ADD(self.e.name, self.e.name)
        self.decoder.JUMP(labels[1])
        self.decoder.RESET(self.b.name)
        self.decoder.RESET(self.f.name)
        self.decoder.addLabel(labels[3])
        self.decoder.ADD(self.f.name, self.e.name)
        self.decoder.SUB(self.f.name, self.d.name)
        self.decoder.JZERO(self.f.name, 4)
        self.decoder.ADD(self.b.name, self.b.name)
        self.decoder.SHR(self.e.name)
        self.decoder.JUMP(labels[2])
        self.decoder.ADD(self.b.name, self.b.name)
        self.decoder.INC(self.b.name)
        self.decoder.SUB(self.d.name, self.e.name)
        self.decoder.SHR(self.e.name)
        self.decoder.addLabel(labels[2])
        self.decoder.RESET(self.f.name)
        self.decoder.ADD(self.f.name, self.c.name)
        self.decoder.SUB(self.f.name, self.e.name)
        self.decoder.JZERO(self.f.name, labels[3])
        self.decoder.JUMP(2)
        self.decoder.addLabel(labels[4])
        self.decoder.RESET(self.d.name)
        self.decoder.RESET(self.b.name)
        self.decoder.ADD(self.b.name, self.d.name)

    def undeclared_check(self, data, register, setbound=False):

        type = data[0]
        if type == self.types['number']:
            line = data[2]
            value = data[1]
            if value not in self.variables.keys():
                self.storeNumberInVariables(value, line)
        elif type == self.types['var']:
            line = data[2]
            value = data[1]
            self.check_var_declared(value, line)

        elif type == self.types['table']:
            line = data[3]
            tab_name = data[1]
            index_value = data[2][1]
            index_type = data[2][0]
            # check if index in variables
            if index_type == self.types['number']:
                if index_value not in self.variables.keys():
                    self.storeNumberInVariables(index_value, line)
                self.check_if_correct_tab_index(tab_name, int(index_value))
            elif index_type == self.types['var']:
                self.check_var_declared(index_value, line)

            else:
                self.error.unknown_type(line)

    def store_address_in_register(self, data, register, setbound=False):
        self.decoder.RESET(register.name)

        type = data[0]
        if type == self.types['number']:
            value = data[1]
            line = data[2]
            if value not in self.variables.keys():
                self.storeNumberInVariables(value, line)

            address = self.getNumberAddress(value)
            self.setValueInRegister(register, address)
        elif type == self.types['var']:
            line = data[2]
            value = data[1]
            self.check_var_declared(value, line)

            address = self.getVarAddress(value)
            self.setValueInRegister(register, address)

        elif type == self.types['table']:
            line = data[3]
            tab_name = data[1]
            index_value = data[2][1]
            index_type = data[2][0]
            # check if index in variables
            if index_type == self.types['number']:
                if index_value not in self.variables.keys():
                    self.storeNumberInVariables(index_value, line)
                self.check_if_correct_tab_index(tab_name, int(index_value))
            elif index_type == self.types['var']:
                self.check_var_declared(index_value, line)

            else:
                self.error.unknown_type(line)

            # get  object of array from variables
            obj = self.variables[tab_name]
            # get the address of fires tab value
            first_address = obj.get_first_address()
            first_idx = obj.first
            variable_address = self.getVarAddress(index_value)
            self.setValueInRegister(self.e, first_idx)
            self.loadValueOfAddressToRegister(variable_address, self.d.name)
            #off set
            self.decoder.SUB(self.d.name, self.e.name)
            # add offset and strign address for particular array
            # store res in b
            self.setValueInRegister(register, first_address)
            self.decoder.ADD(register.name, self.d.name)

    def calculate_expression(self, command):

        # set left side address in a register avlue
        # set right side address in c register value
        operator = command[0]
        line = command[3]
        left = command[1]
        right = command[2]
        # store numer as variable to have access later

        self.store_address_in_register(command[1], self.a)
        self.store_address_in_register(command[2], self.c)
        if operator == '+':
            self.addition()
        elif operator == '-':
            self.exp_subtraction()
        elif operator == '*':
            self.multiplication()
        elif operator == '/':
            self.division(self.b)
        elif operator == '%':
            self.modulo()
        else:
            self.error.unsupported_operation(line)

    def check_var_declared(self, name, line):
        if name not in self.variables.keys():
            self.error.usage_undeclared_var(line)

        var_obj = self.variables[name]
        if var_obj.declared == False:
            self.error.usage_uninitialized_var(line)

    def set_var_declared(self, name, line):
        if name not in self.variables.keys():
            self.error.usage_undeclared_var(line)

        var_obj = self.variables[name]
        var_obj.declared = True

    def type_check(self, name, type, line):
        if name not in self.variables.keys():
            self.error.usage_undeclared_var(line)
        obj = self.variables[name]
        if obj.type != type:
            self.error.wrong_syntax(line)

    def assign(self, command):
        self.decoder.RESET(self.b.name)
        self.decoder.RESET(self.c.name)
        self.decoder.RESET(self.d.name)
        self.decoder.RESET(self.f.name)
        self.decoder.RESET(self.e.name)
        self.decoder.RESET(self.a.name)
        line = command[3]
        left_id = command[1][1]
        left_type = command[1][0]
        right_id = command[2][1]
        right_type = command[2][0]
        self.type_check(left_id, left_type, line)

        if left_type == self.types['var']:

            self.set_var_declared(left_id, line)

            # check if it is iterator if not u can try modyfying
            if self.variables[left_id].iterator == False:
                if right_type == self.types['number']:
                    #get value to assign
                    value = command[2][1]
                    # get variable addres from memory
                    addr = self.getVarAddress(left_id)
                    # set value in b register
                    self.setValueInRegister(self.b, value)
                    # set address as value of c register
                    self.setValueInRegister(self.c, addr)
                    # store value in memory addres of variable
                    self.decoder.STORE(self.b.name, self.c.name)

                elif right_type == self.types['var']:
                    #error
                    self.type_check(right_id, right_type, line)
                    self.check_var_declared(right_id, line)

                    addr = self.getVarAddress(right_id)
                    addl = self.getVarAddress(left_id)
                    # set value of right side  addres in b register
                    self.setValueInRegister(self.b, addr)
                    # set value of  left side addres in d register
                    self.setValueInRegister(self.d, addl)
                    # load right side variable value to c register
                    self.decoder.LOAD(self.c.name, self.b.name)
                    # store upper right side value in adres of left side stored in d
                    self.decoder.STORE(self.c.name, self.d.name)

                elif right_type == self.types['table']:
                    #2 cases  first table(number)
                    self.type_check(right_id, right_type, line)

                    if command[2][2][0] == self.types['number']:
                        tab_name = command[2][1]
                        value = command[2][2][1]

                        if value not in self.variables.keys():
                            self.storeNumberInVariables(value, line)
                        variable_addr = self.getNumberAddress(value)
                        addl = self.getVarAddress(left_id)
                        self.set_table_address_in_B(tab_name, value)
                        self.decoder.LOAD(self.c.name, self.b.name)
                        self.setValueInRegister(self.d, addl)
                        self.decoder.STORE(self.c.name, self.d.name)

                    # case tab(n) -> tab with int variable
                    elif command[2][2][0] == self.types['var']:

                        variable_name = command[2][2][1]
                        tab_name = command[2][1]
                        self.check_var_declared(variable_name, line)

                        addl = self.getVarAddress(left_id)
                        # set value of  left side addres in d register
                        self.setValueInRegister(self.c, addl)
                        self.set_table_address_in_B(tab_name, variable_name)
                        self.decoder.LOAD(self.d.name, self.b.name)
                        # store upper right side value in adres of left side stored in d
                        self.decoder.STORE(self.d.name, self.c.name)
                    else:
                        self.error.unknown_type(line)
                else:
                    addl = self.getVarAddress(left_id)
                    self.calculate_expression(command[2])
                    self.setValueInRegister(self.c, addl)
                    self.decoder.STORE(self.b.name, self.c.name)
            else:
                self.error.iterator_modification(line)

        elif left_type == self.types['table']:

            tab_name = command[1][1]
            index_type = command[1][2][0]
            index_value = command[1][2][1]
            line = command[3]

            self.type_check(left_id, left_type, line)

            # check if index in variables
            if index_type == self.types['number']:
                if index_value not in self.variables.keys():
                    self.storeNumberInVariables(index_value, line)
                self.check_if_correct_tab_index(tab_name, int(index_value))
            elif index_type == self.types['var']:
                if index_value not in self.variables.keys():
                    self.error.unknown_type(line)
            else:
                self.error.unknown_type(line)

            if right_type == self.types['number']:
                num_value = command[2][1]
                # get left side address in b register
                self.set_table_address_in_B(tab_name, index_value)
                #set value in d register
                self.setValueInRegister(self.d, num_value)
                self.decoder.STORE(self.d.name, self.b.name)

            elif right_type == self.types['var']:
                self.type_check(right_id, right_type, line)

                var_value = command[2][1]
                # check if declared and initialized
                self.check_var_declared(var_value, line)

                var_address = self.getVarAddress(var_value)
                # get left side address in b register
                self.set_table_address_in_B(tab_name, index_value)
                #set value in d register
                self.loadValueOfAddressToRegister(var_address, self.d.name)
                self.decoder.STORE(self.d.name, self.b.name)

            elif right_type == self.types['table']:
                self.type_check(right_id, right_type, line)
                line = command[3]

                right_tab_name = command[2][1]
                right_type = command[2][2][0]
                right_index = command[2][2][1]
                if right_type == self.types['var']:
                    if right_index not in self.variables.keys():
                        self.error.unknown_variable(line)
                elif right_type == self.types['number']:
                    if right_index not in self.variables.keys():
                        self.storeNumberInVariables(right_index, line)
                    self.check_if_correct_tab_index(right_tab_name,
                                                    int(right_index))
                else:
                    self.error.unknown_variable(line)

                # get LEFT side address in b register
                self.set_table_address_in_B(tab_name, index_value)
                self.setValueInRegister(self.f, 1)
                self.decoder.STORE(self.b.name, self.f.name)
                # get RIGHT side address in b register
                self.set_table_address_in_B(right_tab_name, right_index)
                self.decoder.LOAD(self.c.name, self.b.name)
                self.setValueInRegister(self.f, 1)
                self.decoder.LOAD(self.d.name, self.f.name)
                self.decoder.STORE(self.c.name, self.d.name)

            else:
                # get LEFT side address in b register
                self.set_table_address_in_B(tab_name, index_value)
                self.setValueInRegister(self.f, 1)
                self.decoder.STORE(self.b.name, self.f.name)
                expression = command[2]
                # store result of expression in b
                self.calculate_expression(expression)
                self.setValueInRegister(self.f, 1)
                #we got left addres in c
                self.decoder.LOAD(self.c.name, self.f.name)
                # store result of expression in  left assign address
                self.decoder.STORE(self.b.name, self.c.name)

        else:
            self.error.assignment_error(line)

    # conditions evaluated at addresses stored in a and c
    def conditions(self, operand):
        # store in B
        if operand == '>=':
            # if sub(b + 1, d) != 0 , then b >= d
            self.decoder.LOAD(self.b.name, self.a.name)
            self.decoder.LOAD(self.d.name, self.c.name)

            self.decoder.INC(self.b.name)
            self.decoder.SUB(self.b.name, self.d.name)

        elif operand == '>':
            # if sub(b, d) != 0 , then b > d

            self.decoder.LOAD(self.b.name, self.a.name)
            self.decoder.LOAD(self.d.name, self.c.name)
            self.decoder.SUB(self.b.name, self.d.name)

        elif operand == '<=':
            # reverse greater or equal
            self.decoder.LOAD(self.b.name, self.a.name)
            self.decoder.LOAD(self.d.name, self.c.name)
            self.decoder.INC(self.d.name)
            self.decoder.SUB(self.d.name, self.b.name)
            self.decoder.STORE(self.d.name, self.f.name)
            self.decoder.LOAD(self.b.name, self.f.name)

        elif operand == '<':
            # reverse reverse greater
            self.decoder.LOAD(self.b.name, self.a.name)
            self.decoder.LOAD(self.d.name, self.c.name)
            self.decoder.SUB(self.d.name, self.b.name)
            self.decoder.STORE(self.d.name, self.f.name)
            self.decoder.LOAD(self.b.name, self.f.name)

        elif operand == '!=':
            # if sub(b,d) + sub(d,b) != 0 then b != d
            self.decoder.LOAD(self.b.name, self.a.name)
            self.decoder.LOAD(self.d.name, self.c.name)
            self.decoder.LOAD(self.e.name, self.a.name)

            self.decoder.SUB(self.b.name, self.d.name)
            self.decoder.SUB(self.d.name, self.e.name)
            self.decoder.ADD(self.b.name, self.d.name)

        elif operand == '=':
            labels = self.get_label_dict(2)
            self.decoder.LOAD(self.b.name, self.a.name)
            self.decoder.LOAD(self.d.name, self.c.name)
            self.decoder.STORE(self.d.name, self.e.name)
            self.decoder.LOAD(self.f.name, self.e.name)
            self.decoder.SUB(self.f.name, self.b.name)
            self.decoder.SUB(self.b.name, self.d.name)
            self.decoder.ADD(self.b.name, self.f.name)
            self.decoder.JZERO(self.b.name, labels[1])
            self.decoder.RESET(self.b.name)
            self.decoder.JUMP(labels[2])
            self.decoder.setLabel(labels[1])
            self.decoder.INC(self.b.name)
            self.decoder.addLabel(labels[2])

    def clear_assembly_code(self, asembler, debug=False):

        if debug == False:

            base = "LABEL"
            l = len(base)
            storage = {}

            def check_if_label(instruct):
                #this is label
                if instruct[:l] == base:
                    return True
                else:
                    return False

            def get_label(instruct):

                first_idx = instruct.index(base)
                return instruct[first_idx:]

            def label_into_lineidx(instruct, label, current):
                return instruct.replace(label,
                                        str(storage[label] - current)).strip()

            k = 0
            j = 0

            while len(asembler) > k:
                if check_if_label(asembler[k]):

                    storage[asembler[k]] = k
                    asembler.remove(asembler[k])
                else:
                    k += 1
            m = len(asembler)
            n = 0
            while n < m:
                instruct = asembler[n]
                if base in instruct:
                    label = get_label(instruct)
                    asembler[j] = label_into_lineidx(instruct, label, j)
                j += 1
                n += 1
        else:
            print(">DEBUG")

    def injectAsmLabel(self):
        self.counter += 1
        self.decoder.createLabel(self.counter)
        return "LABEL" + str(self.counter)

    def if_statement(self, command):

        cond = command[1]
        actions = command[2]
        op = cond[0]
        labels = self.get_label_dict(1)
        line = cond[3]
        left = cond[1]
        right = cond[2]
        self.store_address_in_register(left, self.a)
        self.store_address_in_register(right, self.c)
        self.conditions(op)
        self.decoder.JZERO(self.b.name, labels[1])
        for a in actions:
            self.match_action(a)

        self.decoder.addLabel(labels[1])

    def if_else_statement(self, command):

        line = command[4]
        else_inner_operations = command[3]
        if_inner_operations = command[2]
        condition_statement = command[1]
        labels = self.get_label_dict(2)
        left = condition_statement[1]
        right = condition_statement[2]
        self.store_address_in_register(left, self.a)
        self.store_address_in_register(right, self.c)
        # result of condition stored in b
        self.conditions(condition_statement[0])
        # if condition is false  jummp to label 2 and do else command
        # if condition is true do id command and jump to end label
        self.decoder.JZERO(self.b.name, labels[2])
        for a in if_inner_operations:
            self.match_action(a)
        self.decoder.JUMP(labels[1])
        self.decoder.addLabel(labels[2])
        for a in else_inner_operations:
            self.match_action(a)
        self.decoder.addLabel(labels[1])

    # generatues special variable name that will be used for
    # storing upper or lower bound of iterations  in LOOPS
    def generate_bound_var_id(self, iterator_object, type, line):
        if type == "upper":
            base = str(iterator_object.name) + "_upper"
            while base in self.variables.keys():
                base += random.choice(string.ascii_letters)
        elif type == "lower":
            base = str(iterator_object.name) + "lower"
            while base in self.variables.keys():
                base += random.choice(string.ascii_letters)

        else:
            self.error.error_while_creating_iterator(line)
        return base

    def for_loop_with_to(self, command):

        line = command[5]
        iterator = command[1]
        inner_commands = command[4]
        labels = self.get_label_dict(2)

        start_value_address = command[2]
        end_value_address = command[3]

        # check declarations, case when current bounds are undeclared
        # or bound is the same as current iterator
        self.undeclared_check(end_value_address, self.a, True)
        self.undeclared_check(start_value_address, self.c, True)

        # define iterator in varialbes as long as for executes if possible
        if iterator in self.variables.keys():
            self.error.redeclaration(line)

        self.add_var_to_variables(iterator)
        self.set_var_declared(iterator, line)
        iterator_address = self.getVarAddress(iterator)
        obj = self.variables[iterator]
        obj.iterator = True

        #to ensure that upper bound won't change define
        #upper fild in iterator that have same value as upper
        # bound of iterations in loop
        upper_var_id = self.generate_bound_var_id(obj, "upper", line)
        #we are sure that upper_ver_id not in self.vars so
        self.add_var_to_variables(upper_var_id)
        upper_var_address = self.getVarAddress(upper_var_id)

        # set start value to iterator
        self.store_address_in_register(start_value_address, self.a)
        self.decoder.LOAD(self.d.name, self.a.name)
        self.setValueInRegister(self.c, iterator_address)
        self.decoder.STORE(self.d.name, self.c.name)
        #self.decoder.PUT(self.c.name)
        #set lower boud value to  number of iterations
        self.store_address_in_register(end_value_address, self.a, True)
        self.store_address_in_register(start_value_address, self.c, True)

        # condtiion to  proper start the loop start fulfilled ( condition on bounds)
        self.decoder.LOAD(self.b.name, self.a.name)
        self.decoder.LOAD(self.d.name, self.c.name)
        self.decoder.INC(self.b.name)
        self.decoder.SUB(self.b.name, self.d.name)
        self.decoder.JZERO(self.b.name, labels[2])

        self.decoder.RESET(self.d.name)
        self.decoder.LOAD(self.d.name, self.a.name)
        self.decoder.LOAD(self.a.name, self.c.name)
        self.decoder.SUB(self.d.name, self.a.name)
        self.decoder.INC(self.d.name)
        self.setValueInRegister(self.c, upper_var_address)
        self.decoder.STORE(self.d.name, self.c.name)
        #self.decoder.PUT(self.c.name)

        ######################################## START
        self.decoder.addLabel(labels[1])

        self.loadValueOfAddressToRegister(upper_var_address, self.b.name)

        # IF HAVE STOP ITERATING JUMP TO END
        self.decoder.JZERO(self.b.name, labels[2])
        self.decoder.RESET(self.b.name)
        # make loop's inner commands
        for command in inner_commands:
            self.match_action(command)

        # inc iterator
        self.loadValueOfAddressToRegister(iterator_address, self.f.name)
        self.decoder.INC(self.f.name)
        self.setValueInRegister(self.c, iterator_address)
        self.decoder.STORE(self.f.name, self.c.name)
        #self.decoder.PUT(self.c.name)

        # dec couter
        self.loadValueOfAddressToRegister(upper_var_address, self.f.name)
        self.decoder.DEC(self.f.name)
        self.setValueInRegister(self.c, upper_var_address)
        self.decoder.STORE(self.f.name, self.c.name)
        #self.decoder.PUT(self.c.name)

        # JUMP TO START
        self.decoder.JUMP(labels[1])

        ######################################## END

        # END LABEL
        self.decoder.addLabel(labels[2])
        #==============
        # at the end remove  temporary iterator variable
        self.remove_variable_from_variables(iterator)
        self.remove_variable_from_variables(upper_var_id)

    def while_loop(self, command):

        self.decoder.RESET(self.b.name)
        self.decoder.RESET(self.a.name)
        self.decoder.RESET(self.c.name)
        self.decoder.RESET(self.d.name)
        self.decoder.RESET(self.e.name)
        self.decoder.RESET(self.f.name)

        condition_statement = command[1]
        line = command[3]
        inner_actions = command[2]
        labels = self.get_label_dict(2)

        self.decoder.addLabel(labels[1])
        left = condition_statement[1]
        right = condition_statement[2]
        self.store_address_in_register(left, self.a)
        self.store_address_in_register(right, self.c)

        #if condition ok then resolve inner commands
        self.conditions(condition_statement[0])
        self.decoder.JZERO(self.b.name, labels[2])

        for actions in inner_actions:
            self.match_action(actions)

        self.decoder.JUMP(labels[1])
        self.decoder.addLabel(labels[2])

    def repeat_until_loop(self, command):
        inner_commands = command[1]
        condition_statement = command[2]
        line = command[3]
        labels = self.get_label_dict(2)

        self.decoder.addLabel(labels[1])
        # do inner commands
        for c in inner_commands:
            self.match_action(c)

        left = condition_statement[1]
        right = condition_statement[2]
        self.store_address_in_register(left, self.a)
        self.store_address_in_register(right, self.c)

        self.conditions(condition_statement[0])
        self.decoder.JZERO(self.b.name, labels[1])
        self.decoder.JUMP(labels[2])
        self.decoder.addLabel(labels[2])

    def for_loop_with_downto(self, command):

        line = command[5]
        iterator = command[1]
        inner_commands = command[4]
        labels = self.get_label_dict(2)
        start_value_address = command[2]
        end_value_address = command[3]

        # check declarations ic case when bounds are uncedlared
        # or bound is the same as current iterator
        self.undeclared_check(end_value_address, self.a, True)
        self.undeclared_check(start_value_address, self.c, True)

        # define iterator in varialbes as long as for executes if possible
        if iterator in self.variables.keys():
            self.error.redeclaration(line)

        self.add_var_to_variables(iterator)
        self.set_var_declared(iterator, line)
        iterator_address = self.getVarAddress(iterator)

        #to ensure that lower bound won't change define
        #lower field in iterator that have same value as lower
        # bound of iterations in loop
        obj = self.variables[iterator]
        lower_var_id = self.generate_bound_var_id(obj, "lower", line)
        #we are sure that lower_ver_id not in self.vars so
        self.add_var_to_variables(lower_var_id)
        lower_var_address = self.getVarAddress(lower_var_id)

        # set start value to iterator
        self.store_address_in_register(start_value_address, self.a)
        self.decoder.LOAD(self.d.name, self.a.name)
        self.setValueInRegister(self.c, iterator_address)
        self.decoder.STORE(self.d.name, self.c.name)
        #self.decoder.PUT(self.c.name)

        # condtiion to  proper start the loop start fulfilled ( condition on bounds)
        self.store_address_in_register(start_value_address, self.a)
        self.store_address_in_register(end_value_address, self.c)
        self.decoder.LOAD(self.b.name, self.a.name)
        self.decoder.LOAD(self.d.name, self.c.name)

        self.decoder.INC(self.b.name)
        self.decoder.SUB(self.b.name, self.d.name)
        self.decoder.JZERO(self.b.name, labels[2])

        #set lower boud value to  number of iterations
        self.store_address_in_register(start_value_address, self.a)
        self.store_address_in_register(end_value_address, self.c)
        self.decoder.RESET(self.d.name)
        self.decoder.LOAD(self.d.name, self.a.name)
        self.decoder.LOAD(self.a.name, self.c.name)
        self.decoder.SUB(self.d.name, self.a.name)
        self.decoder.INC(self.d.name)
        self.setValueInRegister(self.c, lower_var_address)
        self.decoder.STORE(self.d.name, self.c.name)
        #self.decoder.PUT(self.c.name)

        ######################################## START
        self.decoder.addLabel(labels[1])

        self.loadValueOfAddressToRegister(lower_var_address, self.b.name)

        # IF HAVE REACHED STOP OF ITERATING JUMP TO END
        self.decoder.JZERO(self.b.name, labels[2])
        self.decoder.RESET(self.b.name)
        # make loop's inner commands
        for command in inner_commands:
            self.match_action(command)

        # decrement iterator
        self.loadValueOfAddressToRegister(iterator_address, self.f.name)
        self.decoder.DEC(self.f.name)
        self.setValueInRegister(self.c, iterator_address)
        self.decoder.STORE(self.f.name, self.c.name)
        #self.decoder.PUT(self.c.name)

        # decrement counter
        self.loadValueOfAddressToRegister(lower_var_address, self.f.name)
        self.decoder.DEC(self.f.name)
        self.setValueInRegister(self.c, lower_var_address)
        self.decoder.STORE(self.f.name, self.c.name)
        #self.decoder.PUT(self.c.name)

        # JUMP TO START
        self.decoder.JUMP(labels[1])

        # END LABEL
        self.decoder.addLabel(labels[2])

        #==============
        # at the end remove  temporary iterator variable
        self.remove_variable_from_variables(iterator)
        self.remove_variable_from_variables(lower_var_id)

    def match_action(self, command):

        command_id = command[0]
        if command_id == "ASSIGN":
            self.assign(command)
        elif command_id == "WRITE":
            self.write(command)
        elif command_id == "READ":
            self.read(command)
        elif command_id == "IF_STATEMENT":
            self.if_statement(command)
        elif command_id == "IF_ELSE_STATEMENT":
            self.if_else_statement(command)
        elif command_id == "FOR_LOOP_WITH_TO":
            self.for_loop_with_to(command)
        elif command_id == "WHILE_LOOP":
            self.while_loop(command)
        elif command_id == "FOR_LOOP_WITH_DOWNTO":
            self.for_loop_with_downto(command)
        elif command_id == "REPEAT_UNTIL_LOOP":
            self.repeat_until_loop(command)
Ejemplo n.º 19
0
class BuildManager:
    """This is the central class for building a mypy program.

    It coordinates parsing, import processing, semantic analysis and
    type checking. It manages state objects that actually perform the
    build steps.
    """
    do_type_check = None    # Do we perform a type check?
    lib_path = None        # Library path for looking up modules
    sem_analyzer = None # Semantic analyzer
    type_checker = None      # Type checker
    errors = None                 # For reporting all errors
    
    # States of all individual files that are being processed. Each file in a
    # build is always represented by a single state object (after it has been
    # encountered for the first time). This is the only place where states are
    # stored.
    states = None
    # Map from module name to source file path. There is a 1:1 mapping between
    # modules and source files.
    module_files = None
    
    def __init__(self, lib_path, do_type_check):
        self.errors = Errors()
        self.lib_path = lib_path
        self.do_type_check = do_type_check
        self.sem_analyzer = SemanticAnalyzer(lib_path, self.errors)
        self.type_checker = TypeChecker(self.errors, self.sem_analyzer.modules)
        self.states = []
        self.module_files = {}
    
    def \
                process(self, initial_state):
        """Perform a build.

        The argument is a state that represents the main program
        file. This method should only be called once per a build
        manager object.  The return values are identical to the return
        values of the build function.
        """
        self.states.append(initial_state)
        
        # Process states in a loop until all files (states) are finished.
        while True:
            # Find the next state that has all its dependencies met.
            next = self.next_available_state()
            if not next:
                trace('done')
                break
            
            # Potentially output some debug information.
            trace('next {} ({})'.format(next.path, next.state()))
            
            # Set the import context for reporting error messages correctly.
            self.errors.set_import_context(next.import_context)
            # Process the state. The process method is reponsible for adding a
            # new state object representing the new state of the file.
            next.process()
        
            # Raise exception if the build failed. The build can fail for
            # various reasons, such as parse error, semantic analysis error,
            # etc.
            if self.errors.is_errors():
                self.errors.raise_error()
        
        # If there were no errors, all files should have been fully processed.
        for s in self.states:
            assert s.state() == final_state, (
                '{} still unprocessed'.format(s.path))
        
        # Collect a list of all files.
        trees = []
        for state in self.states:
            trees.append((state).tree)
        
        return (trees, self.sem_analyzer.modules, self.sem_analyzer.types,
                self.type_checker.type_map)
    
    def next_available_state(self):
        """Find a ready state (one that has all its dependencies met)."""
        i = len(self.states) - 1
        while i >= 0:
            if self.states[i].is_ready():
                return self.states[i]
            i -= 1
        return None
    
    def has_module(self, name):
        """Have we seen a module yet?"""
        return name in self.module_files
    
    def file_state(self, path):
        """Return the state of a source file.

        In particular, return UNSEEN_STATE if the file has no associated
        state.

        This function does not consider any dependencies.
        """
        for s in self.states:
            if s.path == path:
                return s.state()
        return UNSEEN_STATE
    
    def module_state(self, name):
        """Return the state of a module.

        In particular, return UNSEEN_STATE if the file has no associated
        state.

        This considers also module dependencies.
        """
        if not self.has_module(name):
            return UNSEEN_STATE
        state = final_state
        fs = self.file_state(self.module_files[name])
        if earlier_state(fs, state):
            state = fs
        return state
    
    def all_imported_modules_in_file(self, file):
        """Return tuple (module id, line number of import) for all
        modules imported in a file.
        """
        # TODO also find imports not at the top level of the file
        res = []
        for d in file.defs:
            if isinstance(d, Import):
                for id, _ in (d).ids:
                    res.append((id, d.line))
            elif isinstance(d, ImportFrom):
                imp = d
                res.append((imp.id, imp.line))
                # Also add any imported names that are submodules.
                for name, __ in imp.names:
                    sub_id = imp.id + '.' + name
                    if self.is_module(sub_id):
                        res.append((sub_id, imp.line))
            elif isinstance(d, ImportAll):
                res.append(((d).id, d.line))
        return res
    
    def is_module(self, id):
        """Is there a file in the file system corresponding to the
        given module?"""
        return find_module(id, self.lib_path) is not None
Ejemplo n.º 20
0
from yee_method import yee_1d
from yee_method import yee_3d
from sympy import *
from matplotlib import pyplot as plt

# An analytical solution for the one-dimensional case is obtained by initializing the class with
# desired initial conditions.

x, t, c = symbols("x t c")
speed_of_light = 299792458
f = sin(2 * pi * x)
g = -2 * pi * speed_of_light * cos(2 * pi * x)
m = 200
n = 200
OneDimSolutions = Solutions(f, g, speed_of_light)
OneDimErrors = Errors(OneDimSolutions)
init_electric = OneDimSolutions.plot_analytical(0,
                                                1,
                                                m,
                                                1 / speed_of_light,
                                                get_field=True)
init_magnetic = OneDimSolutions.plot_analytical(0,
                                                1,
                                                m,
                                                1 / speed_of_light,
                                                get_field=True)
init_fields = init_electric, init_magnetic

# Obtaining convergence plot in 1D space using the classes. Initial conditions can changed as pleased

OneDimErrors.plot_error_space(4, 10, 1, 1 / (1 * speed_of_light))
Ejemplo n.º 21
0
 def assertSuccess(self, input_lines):
     errors = Errors()
     render = Render(input_lines, errors, indent=False)
     self.assertEquals(errors.num_errors, 0)
     self.assertEquals(errors.num_warnings, 0)
     return render
 def __init__(self):
     self.t_simbolos = Tabla_simbolos('Global')
     self.t_tipos = Tabla_tipos()
     self.t_ambitos = Tabla_ambitos()
     self.errors = Errors()
class EvalVisitor(decafVisitor):
    # declare the tables
    t_simbolos = 0
    t_tipos = 0
    t_ambitos = 0
    errors = 0

    def __init__(self):
        self.t_simbolos = Tabla_simbolos('Global')
        self.t_tipos = Tabla_tipos()
        self.t_ambitos = Tabla_ambitos()
        self.errors = Errors()

    # -------------------------------------------- METHOD DECLARATION ----------------------------------------------       
 

    def visitVarType(self, ctx):
        # try and get the ID if not return only gettext
        options = ctx.getChildCount()
        # this is a struct
        if options == 2:
            return ctx.getChild(1)
        if options == 1:
            return ctx.getText()

    def visitVarDeclarationCUSTOM(self, ctx):
        # tipo = ctx.varType().getText()
        tipo = str(self.visitVarType(ctx.varType()))
        nombre = ctx.ID().getText()
        arreglo = False
        len_arr = 1
        if ctx.getChildCount() == 6:
            arreglo = True
            len_arr = int(ctx.NUM().getText())
        return [tipo, nombre, arreglo, len_arr]

    # for the structs
    def visitVarDeclaration(self, ctx):
        # tipo = str(self.visitVarType(ctx.varType()))
        if ctx.varType().getChildCount() == 2:
            nombre = ctx.ID().getText()
            tipo_str = str(ctx.varType().getChild(1))

            # buscar el tipo del struct encontrado
            tipo = self.t_tipos.search_type(tipo_str)
            # TODO: if -1 raise NON DEFINED VAR
            if tipo == -1:
                self.errors.insert_error('NON DEFINED TYPE '+str(tipo_str) + ' ' + str(nombre), [ctx.start.line, ctx.start.column])
            ambito = 0
            tamanio = self.t_tipos.search_size(tipo)
            self.t_simbolos.create_entry(nombre, tipo, ambito, tamanio, 1)
        if ctx.varType().getChildCount() == 1:
            nombre = ctx.ID().getText()
            tipo_str = str(ctx.varType().getText())

            # buscar el tipo del struct encontrado
            tipo = self.t_tipos.search_type(tipo_str)
            # TODO: if -1 raise NON DEFINED VAR
            if tipo == -1:
                self.errors.insert_error('NON DEFINED TYPE '+str(tipo_str) + ' ' + str(nombre), [ctx.start.line, ctx.start.column])
            ambito = 0
            tamanio = self.t_tipos.search_size(tipo)
            self.t_simbolos.create_entry(nombre, tipo, ambito, tamanio, 1)
            

    def visitBlockMETHOD(self, ctx, parent):
        declarations = []

        for value in ctx.varDeclaration():
            declarations.append(self.visitVarDeclarationCUSTOM(value))
        
        # iterate over the declarations inside the method to insert into the symbol table
        for declaration in declarations:
            number_of = 1
            if declaration[2] == False:
                number_of = 1
            if declaration[2] == True:
                number_of = declaration[3]
            # search the table for the type
            tipo = self.t_tipos.search_type(declaration[0])
            # TODO: if -1 raise NON DEFINED VAR
            if tipo == -1:
                self.errors.insert_error('NON DEFINED TYPE '+str(declaration[0] + ' ' + str(declaration[1])), [ctx.start.line, ctx.start.column])
            # serach the ambito for the block
            padre = self.t_ambitos.search_ambito(parent)
            # TODO: if -1 raise NON DEFINED PARENT
            if padre == -1:
                self.errors.insert_error('NON FOUND IN SCOPE '+str(declaration[0])+ ' ' + str(declaration[1]), [ctx.start.line, ctx.start.column])

            # search the size of the type in the table
            tamanio = self.t_tipos.search_size(tipo)

            self.t_simbolos.create_entry(declaration[1], tipo, padre, tamanio, number_of)

        # for value in ctx.statement():
            # self.visitStatement(value)
        # FIXME: yep c*k

        for value in ctx.statement():
            if value != None:
                self.visit(value)
                # FIXME: RETURNS
                # print(self.visit(value) )

    # def visitIfstmt(self, ctx):
        
    # def visitWhilestmt(self, ctx):
        
    def visitReturnstmt(self, ctx):
        expressions = ctx.expression()
        if expressions != None:
            return ['RETURN', self.visit(expressions)]
        
    # def visitMethodstmt(self, ctx):
        
    # def visitBlockstmt(self, ctx):

    # def visitLocationstmt(self, ctx):

    # def visitExpressionstmt(self, ctx):

    def visitLiteralexpr(self, ctx):
        return self.visit(ctx.literal())

    def visitLiteral(self, ctx):
        if ctx.int_Literal():
            return 'int'
        if ctx.char_Literal():
            return 'char'
        if ctx.bool_Literal():
            return 'bool'

    # def visitExpression(self, ctx):
    #     return ctx.getText()
        
    
    def visitParameter(self, ctx):
        tipo = ctx.parametertype().getText()
        nombre = ctx.ID().getText()
        arreglo = False
        if ctx.getChildCount() == 4:
            arreglo = True
        return(tipo, nombre, arreglo)
        


    def visitMethoDeclaration(self, ctx):
        tipo = ctx.methodType().getText()
        nombre = ctx.ID().getText()
        parameter_list = []

        parameter_context = ctx.parameter()
        if parameter_context != []:
            for value in parameter_context:
                parameter_list.append(self.visitParameter(value))

        # search the table for the type
        t_tipo = self.t_tipos.search_type(tipo)
        
        # insert into table de ambitos
        self.t_ambitos.create_entry(nombre, 'Program', t_tipo)

        block_context = ctx.block()
        self.visitBlockMETHOD(block_context, nombre)


    # -------------------------------------------- STRUCT DECLARATION ---------------------------------------------- 


    def visitStructDeclaration(self, ctx):
        nombre = ctx.ID().getText()
        vardeclar_context = ctx.varDeclaration()

        if vardeclar_context != []:
            # get the length of variables inside of the struct for memory usage calculation
            n_vars = len(vardeclar_context)

            # insert into the tokens using the values known til now
            self.t_tipos.create_entry(nombre, 4*n_vars, 'definido')

            # insert struct into the scopes (ambitos) for the insides
            self.t_ambitos.create_entry(nombre, 'Program', self.t_tipos.search_type('struct'))

            # throw a vardeclaration for each of the elements found inside the struct
            declarations = []

            for value in vardeclar_context:
                declarations.append(self.visitVarDeclarationCUSTOM(value))
            
            # iterate over the declarations inside the method to insert into the symbol table
            for declaration in declarations:
                number_of = 1
                if declaration[2] == False:
                    number_of = 1
                if declaration[2] == True:
                    number_of = declaration[3]
                # search the table for the type
                tipo = self.t_tipos.search_type(declaration[0])
                # TODO: if -1 raise NON DEFINED VAR
                if tipo == -1:
                    self.errors.insert_error('NON DEFINED TYPE '+str(declaration[0] + ' ' + str(declaration[1])), [ctx.start.line, ctx.start.column])
                # serach the ambito for the block
                padre = self.t_ambitos.search_ambito(nombre)
                # TODO: if -1 raise NON DEFINED PARENT
                if padre == -1:
                    self.errors.insert_error('NON FOUND IN SCOPE '+str(declaration[0])+ ' ' + str(declaration[1]), [ctx.start.line, ctx.start.column])

                # search the size of the type in the table
                tamanio = self.t_tipos.search_size(tipo)

                self.t_simbolos.create_entry(declaration[1], tipo, padre, tamanio, number_of)
        else:
            # line = ctx.start.line
            # column = ctx.start.column
            # TODO raise an exeption EMPTY STRUCT
            self.errors.insert_error('EMPTY STRUCT '+str(nombre), [ctx.start.line, ctx.start.column])
Ejemplo n.º 24
0
def test_add_error():
    e = Errors()
    e.add_error('_1')
    with e.with_path('a'):
        e.add_error('a_1')
        e.add_error('a_2')
        with e.with_path('aa'):
            e.add_error('aa_1')
    with e.with_path('b'):
        e.add_error('b_1')
        with e.with_path(0):
            e.add_error('b0_1')

    assert e
    assert e.has_errors

    assert e.as_dict == {
        '': ['_1'],
        'a': {
            '': ['a_1', 'a_2'],
            'aa': {
                '': ['aa_1'],
            }
        },
        'b': {
            '': ['b_1'],
            0: {
                '': ['b0_1'],
            }
        }
    }
Ejemplo n.º 25
0
 def __init__(self):
     self.errors = Errors()
Ejemplo n.º 26
0
 def assertSuccess(self, input):
     errors = Errors()
     red = Reduce(input, errors)
     self.assertEquals(errors.num_errors, 0)
     self.assertEquals(errors.num_warnings, 0)
Ejemplo n.º 27
0
 def assertSuccess(self, input, expected_errors=0, expected_warnings=0):
     errors = Errors()
     vc = VarCheck(input, errors)
     self.assertEquals(errors.num_errors, expected_errors)
     self.assertEquals(errors.num_warnings, expected_warnings)
Ejemplo n.º 28
0
import time
from uart import BaseStation
from mail_sender import notify_all
from errors import Errors
from config import smtp_server, smtp_port, sender_email, password, error_send_interval, serial_port

error1 = Errors(timeout_sec=error_send_interval)
error2 = Errors(timeout_sec=error_send_interval)
error3 = Errors(timeout_sec=error_send_interval)
error4 = Errors(timeout_sec=error_send_interval)

pc_str = '[PC program]'

base_station = BaseStation(port=serial_port)
base_station.start()

while not base_station.is_connected:  # Wait connection
    if base_station.is_stopped:
        print(pc_str, 'Stop')
        exit(1)
    print(pc_str, 'Not connected')
    time.sleep(1)

while True:
    if base_station.is_stopped:
        break

    try:
        time.sleep(1)

        if base_station.errors:
Ejemplo n.º 29
0
    "GWin32OSType":("integer(c_int)", "c_int")
}

# Two words types:
TYPES2_DICT = {
    "long double": ("real(c_long_double)", "c_long_double"),
    "unsigned long":("integer(c_long)", "c_long"),
    "unsigned short":("integer(c_short)", "c_short"),
    "unsigned int":("integer(c_int)", "c_int")
}

# An instance of the Statistics class:
my_stats = Statistics()

# An instance of the Errors class:
my_errors = Errors()

#*************************************************************************
# Pass 1: scan all header files to find all enum types, all pointers to
# functions (funptr) and add derived GTK types
#*************************************************************************
print("\033[1m Pass 1: looking for enumerators, funptr and derived types...\033[0m")

gtk_types = []

# These lists will be used by the iso_c_binding() function:
gtk_enums = []
gtk_funptr = []

T0 = time.time()     # To calculate computing time
for library_path in PATH_DICT:
Ejemplo n.º 30
0
class Run (Process):
    def __init__(self, threadID, dataSet, minStartWeight, maxStartWeight):
        Process.__init__(self)
        self.threadID = threadID

        self.weights = Weights(dataSet.getDataPoint(0).dimension())
        self.weights.generateRandom(minStartWeight, maxStartWeight)
        weight = """*****\nThread {0} initial weights:\n{1}\n*****"""
        print(weight.format(self.threadID, self.weights.vector))

        self.trainingErrors = Errors(dataSet.trainingDataPoints, dataSet.trainingActualValues)
        self.testingErrors = Errors(dataSet.testingDataPoints, dataSet.testingActualValues)

        self.hypothesis = Hypothesis()

        self.trainingErrors.updateToLower(self.weights, self.hypothesis)

        self.iterations = 0
        self.alpha = STARTING_ALPHA
    # __init__

    def run(self):
        while(self.trainingErrors.greaterThan(ALLOWABLE_MSE_DELTA) and self.iterations < MAX_ITERATIONS and self.alpha > 0):
            self.iterations += 1

            self.weights.update(self.alpha, self.trainingErrors)

            if (not self.trainingErrors.updateToLower(self.weights, self.hypothesis)):
                self.alpha /= ALPHA_BASE
                self.weights.revert()
            # if

            if (self.iterations % 10 == 0):
                self.alpha *= 1.1
            # if
        # while

        self.print()
    # run

    def print(self):
        output = """
        ==========================================================================================================================================
        RUN RESULTS for thread {0}:
        ALPHA and ITERATIONS:
        {1}
        {2}
        ----------------------------------------------------------------------------------
        WEIGHT VECTOR:
        {3}
        ----------------------------------------------------------------------------------
        Lowest training data MSE:
        {4}
        ----------------------------------------------------------------------------------
        Test data MSE:
        {5}
        ==========================================================================================================================================
        """

        self.testingErrors.updateToLower(self.weights, self.hypothesis)
        print(output.format(self.threadID,
                            self.alpha,
                            self.iterations,
                            self.weights.vector,
                            self.trainingErrors.mse,
                            self.testingErrors.mse))
Ejemplo n.º 31
0
# Wojciech Wróblewski 250349 kompilator

import sys
from parser import OneBeerLexer, OneBeerParser
from methods import Methods
from errors import Errors

error = Errors()
argument = sys.argv
length_arguments = len(argument)
if length_arguments < 3:
    error.run_error()

file_in = sys.argv[1]
file_out = sys.argv[2]
lexer = OneBeerLexer()
parser = OneBeerParser()

with open(file_in) as file:
    text = file.read()
    parse_tree = parser.parse(lexer.tokenize(text))
    machine = Methods(parse_tree, file_out)
    machine.get_assembler()
Ejemplo n.º 32
0
 def assertSuccess(self, input):
     errors = Errors()
     linearise = Linearise(input, errors)
     self.assertEquals(errors.num_errors, 0)
     self.assertEquals(errors.num_warnings, 0)
     return linearise