# # ed25519_microcode_parser.py # # Author: Pavel Shatov # # Copyright (c) 2018, NORDUnet A/S # # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # * Neither the name of the NORDUnet A/S nor the # names of its contributors may be used to endorse or promote products # derived from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # Imports import re import sys from enum import Enum # Source File C_FILES = [ "ed25519_fpga_curve_microcode.cpp", "../curve25519/curve25519_fpga_microcode.cpp"] class MICROCODE_PARSER: # enumerate microcode pieces class MICROCODE_PIECE_ENUM(Enum): NONE = -1 PREPARE = 0 BEFORE_ROUND_K0 = 1 BEFORE_ROUND_K1 = 2 DURING_ROUND = 3 AFTER_ROUND_K0 = 4 AFTER_ROUND_K1 = 5 BEFORE_INVERSION = 6 DURING_INVERSION = 7 AFTER_INVERSION = 8 FINAL_REDUCTION = 9 HANDLE_SIGN = 10 OUTPUT = 11 # magic pair of begin/end markers MARKER_BEGIN_MICROCODE = "BEGIN_MICROCODE:" MARKER_END_MICROCODE = "END_MICROCODE" # names of banks MICROCODE_C_NAME_BANK_LO = "BANK_LO" MICROCODE_C_NAME_BANK_HI = "BANK_HI" # micro-operation names MICROCODE_C_NAME_UOP_MOVE = "uop_move" MICROCODE_C_NAME_UOP_CALC = "uop_calc" MICROCODE_C_NAME_UOP_CYCLE = "uop_cycle" MICROCODE_C_NAME_UOP_REPEAT = "uop_repeat" MICROCODE_C_NAME_UOP_CALC_EVEN = "uop_calc_if_even" MICROCODE_C_NAME_UOP_CALC_ODD = "uop_calc_if_odd" # calculate micro-operations MICROCODE_C_NAME_UOP_MATH_MUL = "MUL" MICROCODE_C_NAME_UOP_MATH_ADD = "ADD" MICROCODE_C_NAME_UOP_MATH_SUB = "SUB" # names of banks in C source MICROCODE_C_NAMES_BANKS = [MICROCODE_C_NAME_BANK_LO, MICROCODE_C_NAME_BANK_HI] # names of operands in C source MICROCODE_C_NAMES_OPERANDS = [ "CONST_ZERO", "CONST_ONE", "INVERT_R1", "INVERT_R2", "INVERT_T_1", "INVERT_T_10", "INVERT_T_1001", "INVERT_T_1011", "INVERT_T_X5", "INVERT_T_X10", "INVERT_T_X20", "INVERT_T_X40", "INVERT_T_X50", "INVERT_T_X100", "CONST_G_X", "CONST_G_Y", "CONST_G_T", "CYCLE_R0_X", "CYCLE_R0_Y", "CYCLE_R0_Z", "CYCLE_R0_T", "CYCLE_R1_X", "CYCLE_R1_Y", "CYCLE_R1_Z", "CYCLE_R1_T", "CYCLE_S_X", "CYCLE_S_Y", "CYCLE_S_Z", "CYCLE_S_T", "CYCLE_T_X", "CYCLE_T_Y", "CYCLE_T_Z", "CYCLE_T_T", "CYCLE_U_X", "CYCLE_U_Y", "CYCLE_U_Z", "CYCLE_U_T", "CYCLE_V_X", "CYCLE_V_Y", "CYCLE_V_Z", "CYCLE_V_T", "PROC_A", "PROC_B", "PROC_C", "PROC_D", "PROC_E", "PROC_F", "PROC_G", "PROC_H", "PROC_I", "PROC_J"] # names of banks in Verilog source MICROCODE_V_NAME_BANKS_DUMMY = "UOP_BANKS_DUMMY" MICROCODE_V_NAMES_BANKS = ["UOP_BANKS_LO2HI", "UOP_BANKS_HI2LO"] # names of operands in Verilog source MICROCODE_V_NAMES_OPERANDS = ["UOP_OPERAND_" + op for op in MICROCODE_C_NAMES_OPERANDS] # names of opcodes in Verilog source MICROCODE_V_NAME_OPCODE_MOVE = "UOP_OPCODE_COPY" MICROCODE_V_NAME_OPCODE_MUL = "UOP_OPCODE_MUL" MICROCODE_V_NAME_OPCODE_ADD = "UOP_OPCODE_ADD" MICROCODE_V_NAME_OPCODE_SUB = "UOP_OPCODE_SUB" MICROCODE_V_NAME_OPCODE_STOP = "UOP_OPCODE_STOP" MICROCODE_V_NAME_OPERAND_DONTCARE = "UOP_OPERAND_DONTCARE" # match group to catch operand names MATCH_GROUP_09AZ = "([0-9A-Z_]+)" # match group to catch bank names MATCH_GROUP_BANK = "(" + MICROCODE_C_NAME_BANK_LO + "|" + MICROCODE_C_NAME_BANK_HI + ")" # match group to catch number of loop iterations MATCH_GROUP_NUMBER = "(\d+)" # match group to catch math instruction MATCH_GROUP_MATH = "(" + MICROCODE_C_NAME_UOP_MATH_MUL + "|" + MICROCODE_C_NAME_UOP_MATH_ADD + "|" + MICROCODE_C_NAME_UOP_MATH_SUB + ")" # match groups to catch dummy C pointers MATCH_GROUP_DUMMY_C_PTR = "BUF_LO\,\s*BUF_HI" MATCH_GROUP_DUMMY_C_MOD = "MOD_[1-2]P" # match group to catch calculation micro-operation MATCH_GROUP_CALC = "(" + MICROCODE_C_NAME_UOP_CALC + "|" + MICROCODE_C_NAME_UOP_CALC_EVEN + "|" + MICROCODE_C_NAME_UOP_CALC_ODD + ")" # map string microcode piece names to enum values MICROCODE_PIECE_DICT = { "PREPARE": MICROCODE_PIECE_ENUM.PREPARE, "BEFORE_ROUND_K0": MICROCODE_PIECE_ENUM.BEFORE_ROUND_K0, "BEFORE_ROUND_K1": MICROCODE_PIECE_ENUM.BEFORE_ROUND_K1, "DURING_ROUND": MICROCODE_PIECE_ENUM.DURING_ROUND, "AFTER_ROUND_K0": MICROCODE_PIECE_ENUM.AFTER_ROUND_K0, "AFTER_ROUND_K1": MICROCODE_PIECE_ENUM.AFTER_ROUND_K1, "BEFORE_INVERSION": MICROCODE_PIECE_ENUM.BEFORE_INVERSION, "DURING_INVERSION": MICROCODE_PIECE_ENUM.DURING_INVERSION, "AFTER_INVERSION": MICROCODE_PIECE_ENUM.AFTER_INVERSION, "FINAL_REDUCTION": MICROCODE_PIECE_ENUM.FINAL_REDUCTION, "HANDLE_SIGN": MICROCODE_PIECE_ENUM.HANDLE_SIGN, "OUTPUT": MICROCODE_PIECE_ENUM.OUTPUT} # map C bank names to Verilog bank names MICROCODE_BANK_DICT = dict(zip(MICROCODE_C_NAMES_BANKS, MICROCODE_V_NAMES_BANKS)) # map C operand names to Verilog operand names MICROCODE_OPERAND_DICT = dict(zip(MICROCODE_C_NAMES_OPERANDS, MICROCODE_V_NAMES_OPERANDS)) # map C calculation names to Verilog opcode names MICROCODE_MATH_DICT = { MICROCODE_C_NAME_UOP_MATH_MUL: MICROCODE_V_NAME_OPCODE_MUL, MICROCODE_C_NAME_UOP_MATH_ADD: MICROCODE_V_NAME_OPCODE_ADD, MICROCODE_C_NAME_UOP_MATH_SUB: MICROCODE_V_NAME_OPCODE_SUB} # microcode format MICROCODE_FORMAT_ADDR = "9'd%03d" MICROCODE_FORMAT_LINE = MICROCODE_FORMAT_ADDR + ": data <= %s;" MICROCODE_FORMAT_OFFSET = "localparam [UOP_ADDR_WIDTH-1:0] %s = " + MICROCODE_FORMAT_ADDR + ";" # pieces of microcode MICROCODE_LINES_PREPARE = [] MICROCODE_LINES_BEFORE_ROUND_K0 = [] MICROCODE_LINES_BEFORE_ROUND_K1 = [] MICROCODE_LINES_DURING_ROUND = [] MICROCODE_LINES_AFTER_ROUND_K0 = [] MICROCODE_LINES_AFTER_ROUND_K1 = [] MICROCODE_LINES_BEFORE_INVERSION = [] MICROCODE_LINES_DURING_INVERSION = [] MICROCODE_LINES_AFTER_INVERSION = [] MICROCODE_LINES_FINAL_REDUCTION = [] MICROCODE_LINES_HANDLE_SIGN = [] MICROCODE_LINES_OUTPUT = [] MICROCODE_LINE_STOP = "{%s, %s, %s, %s, %s}" % ( MICROCODE_V_NAME_OPCODE_STOP, MICROCODE_V_NAME_BANKS_DUMMY, MICROCODE_V_NAME_OPERAND_DONTCARE, MICROCODE_V_NAME_OPERAND_DONTCARE, MICROCODE_V_NAME_OPERAND_DONTCARE) def __init__(self, filenames): self.__filenames = filenames def parse(self): for next_filename in self.__filenames: print("Parsing '%s'..." % (next_filename)) parsing_now = False line_num = 0 with open(next_filename, "r") as c_file: c_lines = c_file.readlines() for next_c_line in c_lines: line_num += 1 self.__line_num = line_num self.__next_c_line = next_c_line.strip() if len(self.__next_c_line) == 0: continue if self.__next_c_line.startswith("//"): continue if not parsing_now: self.__current_piece = self.__try_start_parsing() if self.__current_piece != self.MICROCODE_PIECE_ENUM.NONE: print(" Found piece of microcode: %s" % (str(self.__current_piece))) parsing_now = True else: parsing_now = self.__continue_parsing() def format(self): if len(self.MICROCODE_LINES_PREPARE) == 0: sys.exit("sys.exit(): Empty PREPARE piece!") if len(self.MICROCODE_LINES_BEFORE_ROUND_K0) == 0: sys.exit("sys.exit(): Empty BEFORE_ROUND_K0 piece!") if len(self.MICROCODE_LINES_BEFORE_ROUND_K1) == 0: sys.exit("sys.exit(): Empty BEFORE_ROUND_K1 piece!") if len(self.MICROCODE_LINES_DURING_ROUND) == 0: sys.exit("sys.exit(): Empty DURING_ROUND piece!") if len(self.MICROCODE_LINES_AFTER_ROUND_K0) == 0: sys.exit("sys.exit(): Empty AFTER_ROUND_K0 piece!") if len(self.MICROCODE_LINES_AFTER_ROUND_K1) == 0: sys.exit("sys.exit(): Empty AFTER_ROUND_K1 piece!") if len(self.MICROCODE_LINES_BEFORE_INVERSION) == 0: sys.exit("sys.exit(): Empty BEFORE_INVERSION piece!") if len(self.MICROCODE_LINES_DURING_INVERSION) == 0: sys.exit("sys.exit(): Empty DURING_INVERSION piece!") if len(self.MICROCODE_LINES_AFTER_INVERSION) == 0: sys.exit("sys.exit(): Empty AFTER_INVERSION piece!") if len(self.MICROCODE_LINES_FINAL_REDUCTION) == 0: sys.exit("sys.exit(): Empty FINAL_REDUCTION piece!") if len(self.MICROCODE_LINES_HANDLE_SIGN) == 0: sys.exit("sys.exit(): Empty HANDLE_SIGN piece!") if len(self.MICROCODE_LINES_OUTPUT) == 0: sys.exit("sys.exit(): Empty OUTPUT piece!") length = 0 length += len(self.MICROCODE_LINES_PREPARE) length += len(self.MICROCODE_LINES_BEFORE_ROUND_K0) length += len(self.MICROCODE_LINES_BEFORE_ROUND_K1) length += len(self.MICROCODE_LINES_DURING_ROUND) length += len(self.MICROCODE_LINES_AFTER_ROUND_K0) length += len(self.MICROCODE_LINES_AFTER_ROUND_K1) length += len(self.MICROCODE_LINES_BEFORE_INVERSION) length += len(self.MICROCODE_LINES_DURING_INVERSION) length += len(self.MICROCODE_LINES_AFTER_INVERSION) length += len(self.MICROCODE_LINES_FINAL_REDUCTION) length += len(self.MICROCODE_LINES_OUTPUT) print("Total number of micro-operations (w/o stops): %s" % (length)) self.__addr = 0 print("\n -=-=-=-=-=- CUT AND PASTE BELOW -=-=-=-=-=-\n") offset_prepare = self.__addr; print("// PREPARE"); for line in self.MICROCODE_LINES_PREPARE: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_before_round_k0 = self.__addr; print("// BEFORE_ROUND_K0"); for line in self.MICROCODE_LINES_BEFORE_ROUND_K0: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_before_round_k1 = self.__addr; print("// BEFORE_ROUND_K1"); for line in self.MICROCODE_LINES_BEFORE_ROUND_K1: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_during_round = self.__addr; print("// DURING_ROUND"); for line in self.MICROCODE_LINES_DURING_ROUND: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_after_round_k0 = self.__addr; print("// AFTER_ROUND_K0"); for line in self.MICROCODE_LINES_AFTER_ROUND_K0: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_after_round_k1 = self.__addr; print("// AFTER_ROUND_K1"); for line in self.MICROCODE_LINES_AFTER_ROUND_K1: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_before_inversion = self.__addr; print("// BEFORE_INVERSION"); for line in self.MICROCODE_LINES_BEFORE_INVERSION: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_during_inversion = self.__addr; print("// DURING_INVERSION"); for line in self.MICROCODE_LINES_DURING_INVERSION: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_after_inversion = self.__addr; print("// AFTER_INVERSION"); for line in self.MICROCODE_LINES_AFTER_INVERSION: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_final_reduction = self.__addr; print("// FINAL_REDUCTION"); for line in self.MICROCODE_LINES_FINAL_REDUCTION: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_handle_sign = self.__addr; print("// HANDLE_SIGN"); for line in self.MICROCODE_LINES_HANDLE_SIGN: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) offset_output = self.__addr; print("// OUTPUT"); for line in self.MICROCODE_LINES_OUTPUT: self.__format_line(line) self.__format_line(self.MICROCODE_LINE_STOP) print("\n") self.__format_offset("UOP_OFFSET_PREPARE ", offset_prepare) self.__format_offset("UOP_OFFSET_BEFORE_ROUND_K0 ", offset_before_round_k0) self.__format_offset("UOP_OFFSET_BEFORE_ROUND_K1 ", offset_before_round_k1) self.__format_offset("UOP_OFFSET_DURING_ROUND ", offset_during_round) self.__format_offset("UOP_OFFSET_AFTER_ROUND_K0 ", offset_after_round_k0) self.__format_offset("UOP_OFFSET_AFTER_ROUND_K1 ", offset_after_round_k1) self.__format_offset("UOP_OFFSET_BEFORE_INVERSION", offset_before_inversion) self.__format_offset("UOP_OFFSET_DURING_INVERSION", offset_during_inversion) self.__format_offset("UOP_OFFSET_AFTER_INVERSION ", offset_after_inversion) self.__format_offset("UOP_OFFSET_FINAL_REDUCTION ", offset_final_reduction) self.__format_offset("UOP_OFFSET_HANDLE_SIGN ", offset_handle_sign) self.__format_offset("UOP_OFFSET_OUTPUT ", offset_output) def __format_line(self, line): print(self.MICROCODE_FORMAT_LINE % (self.__addr, line)) self.__addr += 1 def __format_offset(self, name, offset): print(self.MICROCODE_FORMAT_OFFSET % (name, offset)) def __try_start_parsing(self): piece = self.MICROCODE_PIECE_ENUM.NONE begin_marker = re.match("^/\*\s*" + self.MARKER_BEGIN_MICROCODE + "\s*" + self.MATCH_GROUP_09AZ + "\s*\*/$", self.__next_c_line); if begin_marker: piece = self.MICROCODE_PIECE_DICT[begin_marker.group(1)] return piece def __encode_uop(self, opcode, banks, src1, src2, dst): return "{%s, %s, %s, %s, %s}" % (opcode, banks, src1, src2, dst) def __continue_parsing(self): end_marker = re.match("^/\*\s*" + self.MARKER_END_MICROCODE + "\s*\*/$", self.__next_c_line); if end_marker: return False # move? uop_move = re.match("^" + self.MICROCODE_C_NAME_UOP_MOVE + "\(" + self.MATCH_GROUP_BANK + "\,\s*" + self.MATCH_GROUP_09AZ + "\,\s*" + self.MATCH_GROUP_BANK + "\,\s*" + self.MATCH_GROUP_09AZ + "\,\s*" + self.MATCH_GROUP_DUMMY_C_PTR + "\)\;$", self.__next_c_line, re.IGNORECASE) if uop_move: ok = self.__parse_uop_move(uop_move) if ok: return True else: self.__print_parse_error("parse_uop_move() failed!") self.__abort() # calc? uop_calc = re.match("^" + self.MATCH_GROUP_CALC + "\s*\(" + self.MATCH_GROUP_MATH + "\,\s*" + self.MATCH_GROUP_BANK + "\,\s*" + self.MATCH_GROUP_09AZ + "\,\s*" + self.MATCH_GROUP_09AZ + "\,\s*" + self.MATCH_GROUP_BANK + "\,\s*" + self.MATCH_GROUP_09AZ + "\,\s*" + self.MATCH_GROUP_DUMMY_C_PTR + "\,\s*" + self.MATCH_GROUP_DUMMY_C_MOD + "\)\;$", self.__next_c_line, re.IGNORECASE) if uop_calc: ok = self.__parse_uop_calc(uop_calc) if ok: return True else: self.__print_parse_error("parse_uop_calc() failed!") self.__abort() # cycle? uop_cycle = re.match("^" + self.MICROCODE_C_NAME_UOP_CYCLE + "\(" + self.MATCH_GROUP_NUMBER + "\)\;$", self.__next_c_line, re.IGNORECASE) if uop_cycle: ok = self.__parse_uop_cycle(uop_cycle) if ok: return True else: self.__print_parse_error("parse_uop_cycle() failed!") self.__abort() # repeat? uop_repeat = re.match("^" + self.MICROCODE_C_NAME_UOP_REPEAT + "\(" + "\)\;$", self.__next_c_line, re.IGNORECASE) if uop_repeat: ok = self.__parse_uop_repeat() if ok: return True else: self.__print_parse_error("__parse_uop_repeat() failed!") self.__abort() self.__print_parse_error("unknown micro-operation!") self.__abort() def __check_math(self, math): if not math in self.MICROCODE_MATH_DICT: print_parse_error("bad math!") return False return True def __check_banks(self, src, dst): if not src in self.MICROCODE_BANK_DICT: print_parse_error("bad src bank!") return False if not dst in self.MICROCODE_BANK_DICT: print_parse_error("bad dst bank!") return False if src == dst: print_parse_error("src bank == dst bank!") return False return True def __check_op3(self, src1, src2, dst): if not src1 in self.MICROCODE_OPERAND_DICT: self.__print_parse_error("bad src1 operand!") return False if src2 != "" and not src2 in self.MICROCODE_OPERAND_DICT: self.__print_parse_error("bad src2 operand!") return False if not dst in self.MICROCODE_OPERAND_DICT: self.__print_parse_error("bad dst operand!") return False return True def __check_op2(self, src, dst): return self.__check_op3(src, "", dst) def __parse_uop_move(self, params): bank_src = params.group(1) bank_dst = params.group(3) op_src = params.group(2) op_dst = params.group(4) if not self.__check_banks(bank_src, bank_dst): self.__print_parse_error("check_banks() failed!") return False if not self.__check_op2(op_src, op_dst): self.__print_parse_error("check_op2() failed!") return False opcode = self.MICROCODE_V_NAME_OPCODE_MOVE bank = self.MICROCODE_BANK_DICT[bank_src] src1 = self.MICROCODE_OPERAND_DICT[op_src] src2 = self.MICROCODE_V_NAME_OPERAND_DONTCARE dst = self.MICROCODE_OPERAND_DICT[op_dst] data = self.__encode_uop(opcode, bank, src1, src2, dst) self.__store_uop(data) return True def __parse_uop_calc(self, params): calc = params.group(1) math = params.group(2) bank_src = params.group(3) bank_dst = params.group(6) op_src1 = params.group(4) op_src2 = params.group(5) op_dst = params.group(7) if not self.__check_math(math): self.__print_parse_error("check_calc() failed!") return False if not self.__check_banks(bank_src, bank_dst): self.__print_parse_error("check_banks() failed!") return False if not self.__check_op3(op_src1, op_src2, op_dst): self.__print_parse_error("check_op3() failed!") return False opcode = self.MICROCODE_MATH_DICT[math] banks = self.MICROCODE_BANK_DICT[bank_src] src1 = self.MICROCODE_OPERAND_DICT[op_src1] src2 = self.MICROCODE_OPERAND_DICT[op_src2] dst = self.MICROCODE_OPERAND_DICT[op_dst] data = self.__encode_uop(opcode, banks, src1, src2, dst) if calc == self.MICROCODE_C_NAME_UOP_CALC: self.__store_uop(data) elif calc == self.MICROCODE_C_NAME_UOP_CALC_EVEN: self.__loop_even = data elif calc == self.MICROCODE_C_NAME_UOP_CALC_ODD: self.__loop_odd = data else: return False return True def __parse_uop_cycle(self, params): self.__loop_iters = int(params.group(1)) return True def __parse_uop_repeat(self): print(" Unrolling loop (%d iters)..." % (self.__loop_iters)) for i in range(0, self.__loop_iters): if i % 2 == 0: self.__store_uop(self.__loop_even) else: self.__store_uop(self.__loop_odd) return True def __store_uop(self, data): #print("\t" + data) if self.__current_piece == self.MICROCODE_PIECE_ENUM.PREPARE: self.MICROCODE_LINES_PREPARE.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.BEFORE_ROUND_K0: self.MICROCODE_LINES_BEFORE_ROUND_K0.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.BEFORE_ROUND_K1: self.MICROCODE_LINES_BEFORE_ROUND_K1.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.DURING_ROUND: self.MICROCODE_LINES_DURING_ROUND.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.AFTER_ROUND_K0: self.MICROCODE_LINES_AFTER_ROUND_K0.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.AFTER_ROUND_K1: self.MICROCODE_LINES_AFTER_ROUND_K1.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.BEFORE_INVERSION: self.MICROCODE_LINES_BEFORE_INVERSION.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.DURING_INVERSION: self.MICROCODE_LINES_DURING_INVERSION.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.AFTER_INVERSION: self.MICROCODE_LINES_AFTER_INVERSION.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.FINAL_REDUCTION: self.MICROCODE_LINES_FINAL_REDUCTION.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.HANDLE_SIGN: self.MICROCODE_LINES_HANDLE_SIGN.append(data) elif self.__current_piece == self.MICROCODE_PIECE_ENUM.OUTPUT: self.MICROCODE_LINES_OUTPUT.append(data) def __print_parse_error(self, msg): print("PARSE ERROR: %s" % (msg)) def __abort(self): sys.exit("Stopped at line #%d:\n%s" % (self.__line_num, self.__next_c_line)) # ----------------------------------------------------------------------------- def main(filenames): # ----------------------------------------------------------------------------- parser = MICROCODE_PARSER(filenames) parser.parse() parser.format() # ----------------------------------------------------------------------------- if __name__ == "__main__": # ----------------------------------------------------------------------------- main(C_FILES) # # End-of-File #