def set_value_to_var(self, variable, value): var_frame0 = re.search("^(GF|TF|LF)@", variable) # FRAME DETECTION var0 = re.sub("^(GF|TF|LF)@", "", variable) # VAR NAME DETECTION if (var_frame0.group() == "GF@"): if (var0 not in self.GF): errors.error_exit(errors.VAR_NEXISTS_ERR) else: self.GF[var0] = value elif (var_frame0.group() == "LF@"): if (self.LF == None): errors.error_exit(errors.FRAME_NEXISTS_ERR) if (var0 not in self.LF): errors.error_exit(errors.VAR_NEXISTS_ERR) else: self.LF[var0] = value elif (var_frame0.group() == "TF@"): if (self.TF == None): errors.error_exit(errors.FRAME_NEXISTS_ERR) if (var0 not in self.TF): errors.error_exit(errors.VAR_NEXISTS_ERR) else: self.TF[var0] = value
def readXML(self, xml_file): try: xml_tree = ET.parse(xml_file) xml_root = xml_tree.getroot() except: errors.error_exit(errors.XML_WELLFORMED_ERR) return xml_root
def parseLabels(self, program): for instruction in program: # LABEL <label> if instruction.attrib["opcode"] == "LABEL": if (instruction[0].text in self.labels): errors.error_exit(errors.IPPCODE19_SEM_ERR) else: # Label Name Label Line self.labels[ instruction[0].text] = instruction.attrib["order"]
def checkXMLArg(self, instr): arg_order = 0 for arg in instr: arg_order += 1 arg_ref_tag = "arg" + str(arg_order) if (arg.tag != arg_ref_tag): errors.error_exit(errors.XML_LEXSYN_ERR) if ((arg.tag != arg_ref_tag) or ("type" not in arg.attrib) or (len(arg.attrib) != 1)): errors.error_exit(errors.XML_LEXSYN_ERR)
def checkIntOp(self, instruction): if instruction.attrib["type"] == "var": value = self.get_value_from_var(instruction.text) if (value[0] != "int"): errors.error_exit(errors.OP_TYPES_ERR) else: int_val = value[1] elif (instruction.attrib["type"] == "int"): int_val = instruction.text else: errors.error_exit(errors.OP_TYPES_ERR) return int_val
def checkXMLInstrElement(self, program): for instruction in program: if (instruction.tag != "instruction"): errors.error_exit(errors.XML_LEXSYN_ERR) if ("order" not in instruction.attrib): errors.error_exit(errors.XML_LEXSYN_ERR) if ("opcode" not in instruction.attrib) or (len(instruction.attrib) != 2): errors.error_exit(errors.XML_LEXSYN_ERR) instruction.attrib["opcode"] = instruction.attrib["opcode"].upper( ) if (instruction.attrib["opcode"] not in OP_CODES): errors.error_exit(errors.XML_LEXSYN_ERR) try: instruction.attrib["order"] = int(instruction.attrib["order"]) except: errors.error_exit(errors.XML_LEXSYN_ERR)
def checkArgVal(self, arg): if ((not arg.text) and (arg.attrib["type"] != "string")): errors.error_exit(errors.XML_LEXSYN_ERR) if (arg.attrib["type"] == "nil"): OK_flag = re.search(v_nil, arg.text) if (arg.attrib["type"] == "int"): OK_flag = re.search(v_int, arg.text) if (arg.attrib["type"] == "string"): if (arg.text == None): arg.text = "" OK_flag = re.search(v_string, arg.text) if (arg.attrib["type"] == "bool"): OK_flag = re.search(v_bool, arg.text) if (arg.attrib["type"] == "var"): OK_flag = re.search(v_var, arg.text) if (arg.attrib["type"] == "type"): OK_flag = re.search(v_type, arg.text) if (arg.attrib["type"] == "label"): OK_flag = re.search(v_label, arg.text) if (not OK_flag): errors.error_exit(errors.XML_LEXSYN_ERR)
def checkXMLProgElement(self, program): if (program.tag != "program"): errors.error_exit(errors.XML_LEXSYN_ERR) for attr in program.attrib: if (attr != "language") and (attr != "name") and (attr != "description"): errors.error_exit(errors.XML_LEXSYN_ERR) if (program.attrib["language"] != "IPPcode19"): errors.error_exit(errors.XML_LEXSYN_ERR)
def parseArguments(self): # Parsing try: opts, args = getopt.getopt(sys.argv[1:], self.short_arg_opts, self.long_arg_opts) except getopt.GetoptError: errors.error_exit(errors.ARGS_ERR) ############################# argc = len(sys.argv[1:]) opts_count = len(opts) if (argc != opts_count): errors.error_exit(errors.ARGS_ERR) ############################## input_file = sys.stdin source_file = sys.stdin stats_file = None source_flag = 0 input_flag = 0 insts_flag = False vars_flag = False insts_first_flag = False for o, a in opts: if (o == "--help") and (argc == 1): print(HELP_MSG) exit(errors.SCRIPT_SUCC) elif (o == "--source"): source_flag = 1 source_file = abspath(a) # Is it file? if not(os.path.isfile(source_file)): errors.error_exit(errors.INPUT_FILE_ERR) elif (o == "--input"): input_flag = 1 input_file = abspath(a) # Is it file? if not(os.path.isfile(input_file)): errors.error_exit(errors.INPUT_FILE_ERR) elif (o == "--stats"): stats_file = abspath(a) # Is it file? elif (o == "--insts"): if vars_flag == True: insts_first_flag = False insts_flag = True stats_flag = False for o, a in opts: if (o == "--stats"): stats_flag = True if (stats_flag == False): errors.error_exit(errors.ARGS_ERR) elif (o == "--vars"): if insts_flag == True: insts_first_flag = True vars_flag = True stats_flag = False for o, a in opts: if (o == "--stats"): stats_flag = True if (stats_flag == False): errors.error_exit(errors.ARGS_ERR) else: errors.error_exit(errors.ARGS_ERR) if (source_flag == 0) and (input_flag == 0): errors.error_exit(errors.ARGS_ERR) return (source_file, input_file, stats_file, insts_flag, vars_flag, insts_first_flag)
def get_value_from_var(self, variable): var_frame1 = re.search("^(GF|TF|LF)@", variable) # FRAME DETECTION var1 = re.sub("^(GF|TF|LF)@", "", variable) # VAR NAME DETECTION if (var_frame1.group() == "GF@"): if (var1 not in self.GF): errors.error_exit(errors.VAR_NEXISTS_ERR) else: value = [self.GF[var1][0], self.GF[var1][1]] elif (var_frame1.group() == "LF@"): if (self.LF == None): errors.error_exit(errors.FRAME_NEXISTS_ERR) if (var1 not in self.LF): errors.error_exit(errors.VAR_NEXISTS_ERR) else: value = [self.LF[var1][0], self.LF[var1][1]] elif (var_frame1.group() == "TF@"): if (self.TF == None): errors.error_exit(errors.FRAME_NEXISTS_ERR) if (var1 not in self.TF): errors.error_exit(errors.VAR_NEXISTS_ERR) else: value = [self.TF[var1][0], self.TF[var1][1]] if value[0] == None: errors.error_exit(errors.MISS_VAL_ERR) return value
def interprete(self, program): global stats_insts global stats_vars stats_vars = 0 for instruction in program: stats_insts += 1 stats_vars_new = 0 if (self.GF): for var in self.GF: if (self.GF[var][0] != None): stats_vars_new += 1 if (self.TF): for var in self.TF: if (self.TF[var][0] != None): stats_vars_new += 1 if (self.LF): for var in self.LF: if (self.LF[var][0] != None): stats_vars_new += 1 if (stats_vars_new > stats_vars): stats_vars = stats_vars_new for arg in instruction: # Convert "string int" to int if arg.attrib["type"] == "int": arg.text = int(arg.text) # Convert "string bool" to bool if arg.attrib["type"] == "bool": if arg.text == "true": arg.text = True else: arg.text = False # Convert "string nil" to None if arg.attrib["type"] == "nil": arg.text = None # Convert escape sequence to char if arg.attrib["type"] == "string": esc = re.findall("\\\\\d\d\d", arg.text) for escape_seq in esc: arg.text = arg.text.replace( escape_seq, chr(int(escape_seq.lstrip('\\')))) #################################################################### # MOVE <var> <symb> if instruction.attrib["opcode"] == "MOVE": if (instruction[1].attrib["type"] == "var"): value = self.get_value_from_var(instruction[1].text) else: value = [ instruction[1].attrib["type"], instruction[1].text ] self.set_value_to_var(instruction[0].text, value) # CREATEFRAME if instruction.attrib["opcode"] == "CREATEFRAME": self.TF = {} # PUSHFRAME if instruction.attrib["opcode"] == "PUSHFRAME": if (self.TF != None): self.LF_stack.append(self.TF) self.LF = self.TF self.TF = None else: errors.error_exit(errors.FRAME_NEXISTS_ERR) # POPFRAME if instruction.attrib["opcode"] == "POPFRAME": if (self.LF != None): self.TF = self.LF self.LF_stack.pop() if (self.LF_stack): self.LF = self.LF_stack[len(self.LF_stack) - 1] else: self.LF = None else: errors.error_exit(errors.FRAME_NEXISTS_ERR) # DEFVAR <var> if instruction.attrib["opcode"] == "DEFVAR": var_frame = re.search("^(GF|TF|LF)@", instruction[0].text) var = re.sub("^(GF|TF|LF)@", "", instruction[0].text) if (var_frame.group() == "GF@"): self.GF[var] = [None, None] elif (var_frame.group() == "LF@"): if (self.LF != None): self.LF[var] = [None, None] else: errors.error_exit(errors.FRAME_NEXISTS_ERR) elif (var_frame.group() == "TF@"): if (self.TF != None): self.TF[var] = [None, None] else: errors.error_exit(errors.FRAME_NEXISTS_ERR) # CALL <label> if instruction.attrib["opcode"] == "CALL": if (instruction[0].text not in self.labels): errors.error_exit(errors.IPPCODE19_SEM_ERR) else: self.call_stack.append(instruction.attrib["order"]) self.interprete( xml_root[int(self.labels[instruction[0].text] ):]) # xml_root from main break # RETURN if instruction.attrib["opcode"] == "RETURN": try: ret_inst = self.call_stack.pop() except: errors.error_exit(errors.MISS_VAL_ERR) self.interprete(xml_root[ret_inst:]) # xml_root from main break #################################################################### # PUSHS <symb> if instruction.attrib["opcode"] == "PUSHS": if (instruction[0].attrib["type"] == "var"): value = self.get_value_from_var(instruction[0].text) else: value = [ instruction[0].attrib["type"], instruction[0].text ] self.data_stack.append(value) # POPS <var> if instruction.attrib["opcode"] == "POPS": try: value = self.data_stack[len(self.data_stack) - 1] self.data_stack.pop() except: errors.error_exit(errors.MISS_VAL_ERR) self.set_value_to_var(instruction[0].text, value) #################################################################### # ADD <var> <symb1> <symb2> if instruction.attrib["opcode"] == "ADD": int1 = self.checkIntOp(instruction[1]) int2 = self.checkIntOp(instruction[2]) result = int1 + int2 value = ["int", result] self.set_value_to_var(instruction[0].text, value) # SUB <var> <symb1> <symb2> if instruction.attrib["opcode"] == "SUB": int1 = self.checkIntOp(instruction[1]) int2 = self.checkIntOp(instruction[2]) result = int1 - int2 value = ["int", result] self.set_value_to_var(instruction[0].text, value) # MUL <var> <symb1> <symb2> if instruction.attrib["opcode"] == "MUL": int1 = self.checkIntOp(instruction[1]) int2 = self.checkIntOp(instruction[2]) result = int1 * int2 value = ["int", result] self.set_value_to_var(instruction[0].text, value) # IDIV <var> <symb1> <symb2> if instruction.attrib["opcode"] == "IDIV": int1 = self.checkIntOp(instruction[1]) int2 = self.checkIntOp(instruction[2]) if int2 == 0: errors.error_exit(errors.WRONG_VAL_ERR) result = int1 // int2 value = ["int", result] self.set_value_to_var(instruction[0].text, value) # LT <var> <symb1> <symb2> if instruction.attrib["opcode"] == "LT": if (instruction[1].attrib["type"] == "var"): value1 = self.get_value_from_var(instruction[1].text) else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if (instruction[2].attrib["type"] == "var"): value2 = self.get_value_from_var(instruction[2].text) else: value2 = [ instruction[2].attrib["type"], instruction[2].text ] # Different operand types if ((value1[0] != value2[0]) or (value1[0] == "nil")): errors.error_exit(errors.OP_TYPES_ERR) # Compare result = value1[1] < value2[1] value = ["bool", result] self.set_value_to_var(instruction[0].text, value) # GT <var> <symb1> <symb2> if instruction.attrib["opcode"] == "GT": if (instruction[1].attrib["type"] == "var"): value1 = self.get_value_from_var(instruction[1].text) else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if (instruction[2].attrib["type"] == "var"): value2 = self.get_value_from_var(instruction[2].text) else: value2 = [ instruction[2].attrib["type"], instruction[2].text ] # Different operand types if ((value1[0] != value2[0]) or (value1[0] == "nil")): errors.error_exit(errors.OP_TYPES_ERR) # Compare result = value1[1] > value2[1] value = ["bool", result] self.set_value_to_var(instruction[0].text, value) # EQ <var> <symb1> <symb2> if instruction.attrib["opcode"] == "EQ": if (instruction[1].attrib["type"] == "var"): value1 = self.get_value_from_var(instruction[1].text) else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if (instruction[2].attrib["type"] == "var"): value2 = self.get_value_from_var(instruction[2].text) else: value2 = [ instruction[2].attrib["type"], instruction[2].text ] if ((value1[0] != value2[0]) and (value1[0] != "nil" and value2[0] != "nil")): errors.error_exit(errors.OP_TYPES_ERR) # Compare result = value1[1] == value2[1] value = ["bool", result] self.set_value_to_var(instruction[0].text, value) # AND <var> <symb1> <symb2> if instruction.attrib["opcode"] == "AND": if (instruction[1].attrib["type"] == "var"): value1 = self.get_value_from_var(instruction[1].text) else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if (instruction[2].attrib["type"] == "var"): value2 = self.get_value_from_var(instruction[2].text) else: value2 = [ instruction[2].attrib["type"], instruction[2].text ] if value1[0] != "bool": errors.error_exit(errors.OP_TYPES_ERR) if value2[0] != "bool": errors.error_exit(errors.OP_TYPES_ERR) # Compare result = value1[1] and value2[1] value = ["bool", result] self.set_value_to_var(instruction[0].text, value) # OR <var> <symb1> <symb2> if instruction.attrib["opcode"] == "OR": if (instruction[1].attrib["type"] == "var"): value1 = self.get_value_from_var(instruction[1].text) else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if (instruction[2].attrib["type"] == "var"): value2 = self.get_value_from_var(instruction[2].text) else: value2 = [ instruction[2].attrib["type"], instruction[2].text ] if value1[0] != "bool": errors.error_exit(errors.OP_TYPES_ERR) if value2[0] != "bool": errors.error_exit(errors.OP_TYPES_ERR) # Compare result = value1[1] or value2[1] value = ["bool", result] self.set_value_to_var(instruction[0].text, value) # NOT <var> <symb> if instruction.attrib["opcode"] == "NOT": if (instruction[1].attrib["type"] == "var"): value1 = self.get_value_from_var(instruction[1].text) else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if value1[0] != "bool": errors.error_exit(errors.OP_TYPES_ERR) # Compare result = (not value1[1]) value = ["bool", result] self.set_value_to_var(instruction[0].text, value) # INT2CHAR <var> <symb> if instruction.attrib["opcode"] == "INT2CHAR": if (instruction[1].attrib["type"] == "var"): value1 = self.get_value_from_var(instruction[1].text) else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if value1[0] != "int": errors.error_exit(errors.OP_TYPES_ERR) try: result = chr(value1[1]) except: errors.error_exit(errors.STRING_ERR) value = ["string", result] self.set_value_to_var(instruction[0].text, value) # STRI2INT <var> <symb1> <symb2> if instruction.attrib["opcode"] == "STRI2INT": if (instruction[1].attrib["type"] == "var"): value1 = self.get_value_from_var(instruction[1].text) else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if (instruction[2].attrib["type"] == "var"): value2 = self.get_value_from_var(instruction[2].text) else: value2 = [ instruction[2].attrib["type"], instruction[2].text ] if value1[0] != "string": errors.error_exit(errors.OP_TYPES_ERR) if value2[0] != "int": errors.error_exit(errors.OP_TYPES_ERR) try: result = ord(value1[1][value2[1]]) except: errors.error_exit(errors.STRING_ERR) value = ["int", result] self.set_value_to_var(instruction[0].text, value) #################################################################### # READ <var> <type> if instruction.attrib["opcode"] == "READ": value2 = [instruction[1].attrib["type"], instruction[1].text] interpret_input = "" try: interpret_input = input() except: if (value2[1] == "int"): value = ["int", 0] elif (value2[1] == "string"): value = ["string", ""] elif (value2[1] == "bool"): value = ["bool", False] if (value2[1] == "int"): try: value = ["int", int(interpret_input)] except: value = ["int", 0] elif (value2[1] == "string"): try: value = ["string", interpret_input] except: value = ["string", ""] elif (value2[1] == "bool"): if (interpret_input.upper() == "TRUE"): value = ["bool", True] else: value = ["bool", False] self.set_value_to_var(instruction[0].text, value) # WRITE <symb> if instruction.attrib["opcode"] == "WRITE": if (instruction[0].attrib["type"] == "var"): value = self.get_value_from_var(instruction[0].text) else: value = [ instruction[0].attrib["type"], instruction[0].text ] if value[0] == None: errors.error_exit(errors.MISS_VAL_ERR) if value[0] == "nil": value[1] = "" if value[0] == "bool": if value[1] == True: value[1] = "true" elif value[1] == False: value[1] = "false" print(value[1], end='') #################################################################### # CONCAT <var> <symb1> <symb2> if instruction.attrib["opcode"] == "CONCAT": string1 = self.checkStringOp(instruction[1]) string2 = self.checkStringOp(instruction[2]) value = ["string", string1 + string2] self.set_value_to_var(instruction[0].text, value) # STRLEN <var> <symb> if instruction.attrib["opcode"] == "STRLEN": string1 = self.checkStringOp(instruction[1]) value = ["int", len(string1)] self.set_value_to_var(instruction[0].text, value) # GETCHAR <var> <symb1> <symb2> if instruction.attrib["opcode"] == "GETCHAR": string1 = self.checkStringOp(instruction[1]) int2 = self.checkIntOp(instruction[2]) try: value = ["string", string1[int2]] except: errors.error_exit(errors.STRING_ERR) self.set_value_to_var(instruction[0].text, value) # SETCHAR <var> <symb1> <symb2> if instruction.attrib["opcode"] == "SETCHAR": string0 = self.checkStringOp(instruction[0]) int1 = self.checkIntOp(instruction[1]) string2 = self.checkStringOp(instruction[2]) try: string0 = list(string0) string0[int1] = string2[0] string0 = ''.join(string0) except: errors.error_exit(errors.STRING_ERR) value = ["string", string0] self.set_value_to_var(instruction[0].text, value) #################################################################### # TYPE <var> <symb> if instruction.attrib["opcode"] == "TYPE": if (instruction[1].attrib["type"] == "var"): var_frame1 = re.search( "^(GF|TF|LF)@", instruction[1].text) # FRAME DETECTION var1 = re.sub("^(GF|TF|LF)@", "", instruction[1].text) # VAR NAME DETECTION if (var_frame1.group() == "GF@"): if (var1 not in self.GF): errors.error_exit(errors.VAR_NEXISTS_ERR) else: value1 = [self.GF[var1][0], self.GF[var1][1]] elif (var_frame1.group() == "LF@"): if (self.LF == None): errors.error_exit(errors.FRAME_NEXISTS_ERR) if (var1 not in self.LF): errors.error_exit(errors.VAR_NEXISTS_ERR) else: value1 = [self.LF[var1][0], self.LF[var1][1]] elif (var_frame1.group() == "TF@"): if (self.TF == None): errors.error_exit(errors.FRAME_NEXISTS_ERR) if (var1 not in self.TF): errors.error_exit(errors.VAR_NEXISTS_ERR) else: value1 = [self.TF[var1][0], self.TF[var1][1]] else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if (value1[0] == "int"): value = ["string", "int"] elif (value1[0] == "string"): value = ["string", "string"] elif (value1[0] == "bool"): value = ["string", "bool"] elif (value1[0] == "nil"): value = ["string", "nil"] else: value = ["string", ""] self.set_value_to_var(instruction[0].text, value) #################################################################### # JUMP <label> if instruction.attrib["opcode"] == "JUMP": if (instruction[0].text not in self.labels): errors.error_exit(errors.IPPCODE19_SEM_ERR) else: self.interprete( xml_root[int(self.labels[instruction[0].text] ):]) # xml_root from main break # JUMPIFEQ <label> <symb1> <symb2> if instruction.attrib["opcode"] == "JUMPIFEQ": if (instruction[0].text not in self.labels): errors.error_exit(errors.IPPCODE19_SEM_ERR) if (instruction[1].attrib["type"] == "var"): value1 = self.get_value_from_var(instruction[1].text) else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if (instruction[2].attrib["type"] == "var"): value2 = self.get_value_from_var(instruction[2].text) else: value2 = [ instruction[2].attrib["type"], instruction[2].text ] if (value1[0] != value2[0]): errors.error_exit(errors.OP_TYPES_ERR) if (value1[1] == value2[1]): self.interprete( xml_root[int(self.labels[instruction[0].text] ):]) # xml_root from main break # JUMPIFNEQ <label> <symb1> <symb2> if instruction.attrib["opcode"] == "JUMPIFNEQ": if (instruction[0].text not in self.labels): errors.error_exit(errors.IPPCODE19_SEM_ERR) if (instruction[1].attrib["type"] == "var"): value1 = self.get_value_from_var(instruction[1].text) else: value1 = [ instruction[1].attrib["type"], instruction[1].text ] if (instruction[2].attrib["type"] == "var"): value2 = self.get_value_from_var(instruction[2].text) else: value2 = [ instruction[2].attrib["type"], instruction[2].text ] if (value1[0] != value2[0]): errors.error_exit(errors.OP_TYPES_ERR) if (value1[1] != value2[1]): self.interprete( xml_root[int(self.labels[instruction[0].text] ):]) # xml_root from main break # EXIT <symb> if instruction.attrib["opcode"] == "EXIT": int0 = self.checkIntOp(instruction[0]) if ((int0 >= 0) and (int0 <= 49)): return int0 else: errors.error_exit(errors.WRONG_VAL_ERR) #################################################################### # DPRINT <symb> if instruction.attrib["opcode"] == "DPRINT": if (instruction[0].attrib["type"] == "var"): value = self.get_value_from_var(instruction[0].text) else: value = [ instruction[0].attrib["type"], instruction[0].text ] print(value[1], file=sys.stderr, end='') # BREAK if instruction.attrib["opcode"] == "BREAK": print("Position in code:\t", instruction.attrib["order"], file=sys.stderr) print("Global frame:\t\t", self.GF, file=sys.stderr) print("Local frame:\t\t", self.LF, file=sys.stderr) print("Temporary frame:\t", self.TF, file=sys.stderr) print("Local frames stack:\t", self.LF_stack, file=sys.stderr) print("Labels:\t\t\t", self.labels, file=sys.stderr) print("Calls stack:\t\t", self.call_stack, file=sys.stderr) print("Data stack:\t\t", self.data_stack, file=sys.stderr) # Interpret ends return errors.SCRIPT_SUCC
def checkArgType(self, arg, type): if (arg.attrib["type"] not in type): errors.error_exit(errors.XML_LEXSYN_ERR)
def checkInstrLen(self, instruction, length): if (len(instruction) != length): errors.error_exit(errors.XML_LEXSYN_ERR)
def checkXMLInstructions(self, program): instr_order = 0 for instruction in program: instr_order += 1 if (instruction.attrib["order"] != instr_order): errors.error_exit(errors.XML_LEXSYN_ERR) # Checking element argument self.checkXMLArg(instruction) # INSTRUCTION FORMAT 1: op_code if (instruction.attrib["opcode"] in O): # Checking instruction length self.checkInstrLen(instruction, 0) # INSTRUCTION FORMAT 2: op_code <var> if (instruction.attrib["opcode"] in OV): # Checking instruction length self.checkInstrLen(instruction, 1) # Checking argument type self.checkArgType(instruction[0], t_var) # Checking argument value self.checkArgVal(instruction[0]) # INSTRUCTION FORMAT 3: op_code <symb> if (instruction.attrib["opcode"] in OS): # Checking instruction length self.checkInstrLen(instruction, 1) # Checking argument type self.checkArgType(instruction[0], t_symb) # Checking argument value self.checkArgVal(instruction[0]) # INSTRUCTION FORMAT 4: op_code <label> if (instruction.attrib["opcode"] in OL): # Checking instruction length self.checkInstrLen(instruction, 1) # Checking argument type self.checkArgType(instruction[0], t_label) # Checking argument value self.checkArgVal(instruction[0]) # INSTRUCTION FORMAT 5: op_code <var> <symb> if (instruction.attrib["opcode"] in OVS): # Checking instruction length self.checkInstrLen(instruction, 2) # Checking arguments type self.checkArgType(instruction[0], t_var) self.checkArgType(instruction[1], t_symb) # Checking argument value self.checkArgVal(instruction[0]) self.checkArgVal(instruction[1]) # INSTRUCTION FORMAT 6: op_code <var> <type> if (instruction.attrib["opcode"] in OVT): # Checking instruction length self.checkInstrLen(instruction, 2) # Checking arguments type self.checkArgType(instruction[0], t_var) self.checkArgType(instruction[1], t_type) # Checking argument value self.checkArgVal(instruction[0]) self.checkArgVal(instruction[1]) # INSTRUCTION FORMAT 7: op_code <var> <symb1> <symb2> if (instruction.attrib["opcode"] in OVSS): # Checking instruction length self.checkInstrLen(instruction, 3) # Checking arguments type self.checkArgType(instruction[0], t_var) self.checkArgType(instruction[1], t_symb) self.checkArgType(instruction[2], t_symb) # Checking argument value self.checkArgVal(instruction[0]) self.checkArgVal(instruction[1]) self.checkArgVal(instruction[2]) # INSTRUCTION FORMAT 8: op_code <label> <symb1> <symb2> if (instruction.attrib["opcode"] in OLSS): # Checking instruction length self.checkInstrLen(instruction, 3) # Checking arguments type self.checkArgType(instruction[0], t_label) self.checkArgType(instruction[1], t_symb) self.checkArgType(instruction[2], t_symb) # Checking argument value self.checkArgVal(instruction[0]) self.checkArgVal(instruction[1]) self.checkArgVal(instruction[2])