| # pycrc -- parameterisable CRC calculation utility and C source code generator |
| # |
| # Copyright (c) 2006-2017 Thomas Pircher <tehpeh-web@tty1.net> |
| # |
| # Permission is hereby granted, free of charge, to any person obtaining a copy |
| # of this software and associated documentation files (the "Software"), to |
| # deal in the Software without restriction, including without limitation the |
| # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| # sell copies of the Software, and to permit persons to whom the Software is |
| # furnished to do so, subject to the following conditions: |
| # |
| # The above copyright notice and this permission notice shall be included in |
| # all copies or substantial portions of the Software. |
| # |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| # IN THE SOFTWARE. |
| |
| |
| """ |
| Symbol table for the macro processor used by pycrc. |
| use as follows: |
| |
| import pycrc.opt as opt |
| import pycrc.symtable as sym |
| |
| opt = opt.Options() |
| sym = sym.SymbolTable(opt) |
| |
| print(sym['crc_width']) |
| print('width: {crc_width}, poly: {crc_poly}'.format(**sym)) |
| """ |
| |
| from pycrc.algorithms import Crc |
| import collections |
| import time |
| import os |
| |
| |
| class SymbolTable(object): |
| def __init__(self, opt): |
| self.opt = opt |
| |
| |
| class SymbolTable(collections.MutableMapping): |
| """A dictionary that applies an arbitrary key-altering |
| function before accessing the keys""" |
| |
| def __init__(self, opt): |
| self.opt = opt |
| self.tbl_shift = _tbl_shift(opt) |
| self.cache = dict() |
| self.generator = dict({ |
| 'datetime': lambda: time.asctime(), |
| 'program_version': lambda: self.opt.version_str, |
| 'program_url': lambda: self.opt.web_address, |
| 'filename': lambda: 'pycrc_stdout' if self.opt.output_file is None else os.path.basename(self.opt.output_file), |
| 'header_filename': lambda: _pretty_header_filename(self.opt.output_file), |
| 'header_protection': lambda: _pretty_hdrprotection(self.opt), |
| |
| 'crc_algorithm': lambda: _pretty_algorithm(self.opt), |
| 'crc_width': lambda: _pretty_str(self.opt.width), |
| 'crc_poly': lambda: _pretty_hex(self.opt.poly, self.opt.width), |
| 'crc_reflect_in': lambda: _pretty_bool(self.opt.reflect_in), |
| 'crc_xor_in': lambda: _pretty_hex(self.opt.xor_in, self.opt.width), |
| 'crc_reflect_out': lambda: _pretty_bool(self.opt.reflect_out), |
| 'crc_xor_out': lambda: _pretty_hex(self.opt.xor_out, self.opt.width), |
| 'crc_slice_by': lambda: _pretty_str(self.opt.slice_by), |
| 'crc_table_idx_width': lambda: str(self.opt.tbl_idx_width), |
| 'crc_table_width': lambda: _pretty_str(1 << self.opt.tbl_idx_width), |
| 'crc_table_mask': lambda: _pretty_hex(self.opt.tbl_width - 1, 8), |
| 'crc_mask': lambda: _pretty_hex(self.opt.mask, self.opt.width), |
| 'crc_msb_mask': lambda: _pretty_hex(self.opt.msb_mask, self.opt.width), |
| 'crc_shift': lambda: _pretty_str(self.tbl_shift), |
| |
| 'cfg_width': lambda: self.__getitem__('crc_width') if self.opt.width is not None else 'cfg->width', |
| 'cfg_poly': lambda: self.__getitem__('crc_poly') if self.opt.poly is not None else 'cfg->poly', |
| 'cfg_reflect_in': lambda: self.__getitem__('crc_reflect_in') if self.opt.reflect_in is not None else 'cfg->reflect_in', |
| 'cfg_xor_in': lambda: self.__getitem__('crc_xor_in') if self.opt.xor_in is not None else 'cfg->xor_in', |
| 'cfg_reflect_out': lambda: self.__getitem__('crc_reflect_out') if self.opt.reflect_out is not None else 'cfg->reflect_out', |
| 'cfg_xor_out': lambda: self.__getitem__('crc_xor_out') if self.opt.xor_out is not None else 'cfg->xor_out', |
| 'cfg_table_idx_width': lambda: self.__getitem__('crc_table_idx_width') if self.opt.tbl_idx_width is not None else 'cfg->table_idx_width', |
| 'cfg_table_width': lambda: self.__getitem__('crc_table_width') if self.opt.tbl_width is not None else 'cfg->table_width', |
| 'cfg_mask': lambda: self.__getitem__('crc_mask') if self.opt.mask is not None else 'cfg->crc_mask', |
| 'cfg_msb_mask': lambda: self.__getitem__('crc_msb_mask') if self.opt.msb_mask is not None else 'cfg->msb_mask', |
| 'cfg_shift': lambda: self.__getitem__('crc_shift') if self.tbl_shift is not None else 'cfg->crc_shift', |
| 'cfg_poly_shifted': lambda: '('+self.__getitem__('cfg_poly')+' << '+self.__getitem__('cfg_shift')+')' if self.tbl_shift is None or self.tbl_shift > 0 else self.__getitem__('cfg_poly'), |
| 'cfg_mask_shifted': lambda: '('+self.__getitem__('cfg_mask')+' << '+self.__getitem__('cfg_shift')+')' if self.tbl_shift is None or self.tbl_shift > 0 else self.__getitem__('cfg_mask'), |
| 'cfg_msb_mask_shifted': lambda: '('+self.__getitem__('cfg_msb_mask')+' << '+self.__getitem__('cfg_shift')+')' if self.tbl_shift is None or self.tbl_shift > 0 else self.__getitem__('cfg_msb_mask'), |
| |
| 'c_bool': lambda: 'int' if self.opt.c_std == 'C89' else 'bool', |
| 'c_true': lambda: '1' if self.opt.c_std == 'C89' else 'true', |
| 'c_false': lambda: '0' if self.opt.c_std == 'C89' else 'false', |
| |
| 'underlying_crc_t': lambda: _get_underlying_crc_t(self.opt), |
| 'crc_t': lambda: self.opt.symbol_prefix + 't', |
| 'cfg_t': lambda: self.opt.symbol_prefix + 'cfg_t', |
| 'crc_reflect_function': lambda: self.opt.symbol_prefix + 'reflect', |
| 'crc_table_gen_function': lambda: self.opt.symbol_prefix + 'table_gen', |
| 'crc_init_function': lambda: self.opt.symbol_prefix + 'init', |
| 'crc_update_function': lambda: self.opt.symbol_prefix + 'update', |
| 'crc_finalize_function': lambda: self.opt.symbol_prefix + 'finalize', |
| |
| 'crc_init_value': lambda: _get_init_value(self.opt), |
| 'crc_table_init': lambda: _get_table_init(self.opt), |
| }) |
| |
| def __getitem__(self, key): |
| """ |
| Return the value for the requested key |
| """ |
| if key in self.cache: |
| return self.cache[key] |
| if key not in self.generator: |
| raise KeyError(key) |
| generator = self.generator[key] |
| val = self.generator[key]() |
| self.cache[key] = val |
| return val |
| |
| def __setitem__(self, key, value): |
| self.generator[key] = value |
| |
| def __delitem__(self, key): |
| del self.generator[key] |
| |
| def __iter__(self): |
| return iter(self.generator) |
| |
| def __len__(self): |
| return len(self.generator) |
| |
| |
| |
| def _pretty_str(value): |
| """ |
| Return a value of width bits as a pretty string. |
| """ |
| if value is None: |
| return 'Undefined' |
| return str(value) |
| |
| |
| def _pretty_hex(value, width=None): |
| """ |
| Return a value of width bits as a pretty hexadecimal formatted string. |
| """ |
| if value is None: |
| return 'Undefined' |
| if width is None: |
| return '{0:#x}'.format(value) |
| width = (width + 3) // 4 |
| hex_str = "{{0:#0{0:d}x}}".format(width + 2) |
| return hex_str.format(value) |
| |
| |
| def _pretty_bool(value): |
| """ |
| Return a boolen value of width bits as a pretty formatted string. |
| """ |
| if value is None: |
| return 'Undefined' |
| return 'True' if value else 'False' |
| |
| |
| def _pretty_algorithm(opt): |
| """ |
| Return the algorithm name. |
| """ |
| if opt.algorithm == opt.algo_bit_by_bit: |
| return 'bit-by-bit' |
| elif opt.algorithm == opt.algo_bit_by_bit_fast: |
| return 'bit-by-bit-fast' |
| elif opt.algorithm == opt.algo_table_driven: |
| return 'table-driven' |
| else: |
| return 'UNDEFINED' |
| |
| def _pretty_header_filename(filename): |
| """ |
| Return the sanitized filename of a header file. |
| """ |
| if filename is None: |
| return 'pycrc_stdout.h' |
| filename = os.path.basename(filename) |
| if filename[-2:] == '.c': |
| return filename[0:-1] + 'h' |
| else: |
| return filename + '.h' |
| |
| |
| def _pretty_hdrprotection(opt): |
| """ |
| Return the name of a C header protection (e.g. CRC_IMPLEMENTATION_H). |
| """ |
| if opt.output_file is None: |
| filename = 'pycrc_stdout' |
| else: |
| filename = os.path.basename(opt.output_file) |
| out_str = ''.join([s.upper() if s.isalnum() else '_' for s in filename]) |
| return out_str |
| |
| |
| def _get_underlying_crc_t(opt): |
| """ |
| Return the C type of the crc_t typedef. |
| """ |
| # pylint: disable=too-many-return-statements, too-many-branches |
| |
| if opt.crc_type is not None: |
| return opt.crc_type |
| if opt.c_std == 'C89': |
| if opt.width is None: |
| return 'unsigned long int' |
| if opt.width <= 8: |
| return 'unsigned char' |
| elif opt.width <= 16: |
| return 'unsigned int' |
| else: |
| return 'unsigned long int' |
| else: # C99 |
| if opt.width is None: |
| return 'unsigned long long int' |
| if opt.width <= 8: |
| return 'uint_fast8_t' |
| elif opt.width <= 16: |
| return 'uint_fast16_t' |
| elif opt.width <= 32: |
| return 'uint_fast32_t' |
| elif opt.width <= 64: |
| return 'uint_fast64_t' |
| elif opt.width <= 128: |
| return 'uint_fast128_t' |
| else: |
| return 'uintmax_t' |
| |
| |
| def _get_init_value(opt): |
| """ |
| Return the init value of a C implementation, according to the selected |
| algorithm and to the given options. |
| If no default option is given for a given parameter, value in the cfg_t |
| structure must be used. |
| """ |
| if opt.algorithm == opt.algo_bit_by_bit: |
| if opt.xor_in is None or opt.width is None or opt.poly is None: |
| return None |
| crc = Crc( |
| width=opt.width, poly=opt.poly, |
| reflect_in=opt.reflect_in, xor_in=opt.xor_in, |
| reflect_out=opt.reflect_out, xor_out=opt.xor_out, |
| table_idx_width=opt.tbl_idx_width) |
| init = crc.nondirect_init |
| elif opt.algorithm == opt.algo_bit_by_bit_fast: |
| if opt.xor_in is None: |
| return None |
| init = opt.xor_in |
| elif opt.algorithm == opt.algo_table_driven: |
| if opt.reflect_in is None or opt.xor_in is None or opt.width is None: |
| return None |
| if opt.poly is None: |
| poly = 0 |
| else: |
| poly = opt.poly |
| crc = Crc( |
| width=opt.width, poly=poly, |
| reflect_in=opt.reflect_in, xor_in=opt.xor_in, |
| reflect_out=opt.reflect_out, xor_out=opt.xor_out, |
| table_idx_width=opt.tbl_idx_width) |
| if opt.reflect_in: |
| init = crc.reflect(crc.direct_init, opt.width) |
| else: |
| init = crc.direct_init |
| else: |
| init = 0 |
| return _pretty_hex(init, opt.width) |
| |
| |
| def _get_simple_table(opt, crc_tbl, values_per_line, format_width, indent): |
| """ |
| Get one CRC table, formatted as string with appropriate indenting and |
| line breaks. |
| """ |
| out = "" |
| for i in range(opt.tbl_width): |
| if i % values_per_line == 0: |
| out += " " * indent |
| tbl_val = _pretty_hex(crc_tbl[i], format_width) |
| if i == (opt.tbl_width - 1): |
| out += "{0:s}".format(tbl_val) |
| elif i % values_per_line == (values_per_line - 1): |
| out += "{0:s},\n".format(tbl_val) |
| else: |
| out += "{0:s}, ".format(tbl_val) |
| return out |
| |
| |
| def _get_table_init(opt): # TODO: change to return a list |
| """ |
| Return the precalculated CRC table for the table_driven implementation. |
| """ |
| if opt.algorithm != opt.algo_table_driven: |
| return "0" |
| if opt.width is None or opt.poly is None or opt.reflect_in is None: |
| return "0" |
| crc = Crc( |
| width=opt.width, poly=opt.poly, |
| reflect_in=opt.reflect_in, |
| xor_in=0, reflect_out=False, xor_out=0, # set unimportant variables to known values |
| table_idx_width=opt.tbl_idx_width, |
| slice_by=opt.slice_by) |
| crc_tbl = crc.gen_table() |
| if opt.width > 32: |
| values_per_line = 4 |
| elif opt.width >= 16: |
| values_per_line = 8 |
| else: |
| values_per_line = 16 |
| format_width = max(opt.width, 8) |
| if opt.slice_by == 1: |
| indent = 4 |
| else: |
| indent = 8 |
| |
| out = [''] * opt.slice_by |
| for i in range(opt.slice_by): |
| out[i] = _get_simple_table(opt, crc_tbl[i], values_per_line, format_width, indent) |
| fixed_indent = ' ' * (indent - 4) |
| out = '{0:s}{{\n'.format(fixed_indent) + \ |
| '\n{0:s}}},\n{0:s}{{\n'.format(fixed_indent).join(out) + \ |
| '\n{0:s}}}'.format(fixed_indent) |
| if opt.slice_by == 1: |
| return out |
| return '{\n' + out + '\n}' |
| |
| |
| def _tbl_shift(opt): |
| """ |
| Return the table shift value |
| """ |
| if opt.algorithm == opt.algo_table_driven and (opt.width is None or opt.width < 8): |
| if opt.width is None: |
| return None |
| else: |
| return 8 - opt.width |
| else: |
| return 0 |
| |