diff --git a/pycrc/symtable.py b/pycrc/symtable.py
new file mode 100644
index 0000000..e46ab9c
--- /dev/null
+++ b/pycrc/symtable.py
@@ -0,0 +1,352 @@
+#  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
+