# -*- coding: Latin-1 -*-

#  pycrc -- parametrisable CRC calculation utility and C source code generator
#
#  Copyright (c) 2006-2012  Thomas Pircher  <tehpeh@gmx.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:

    from crc_opt import Options
    from crc_symtable import SymbolTable

    opt = Options("0.6")
    sym = SymbolTable(opt)

    str = " ....  "
    terminal = sym.getTerminal(str)
"""

from crc_algorithms import Crc
import time
import os


# Class SymbolTable
###############################################################################
class SymbolTable:
    """
    The symbol table class.
    """
    opt = None
    table = {}


    # Class constructor
    ###############################################################################
    def __init__(self, opt):
        """
        The class constructor.
        """
        self.opt = opt
        self.table["nop"] = ""
        self.table["datetime"] = time.asctime()
        self.table["program_version"] = self.opt.VersionStr
        self.table["program_url"] = self.opt.WebAddress
        if self.opt.OutputFile == None:
            self.table["filename"] = "pycrc_stdout"
        else:
            self.table["filename"] = self.opt.OutputFile

        if self.opt.OutputFile == None:
            self.table["header_filename"] = "pycrc_stdout.h"
        elif self.opt.OutputFile[-2:] == ".c":
            self.table["header_filename"] = self.opt.OutputFile[0:-1] + "h"
        else:
            self.table["header_filename"] = self.opt.OutputFile + ".h"

        self.table["crc_width"] = self.__pretty_str(self.opt.Width)
        self.table["crc_poly"] = self.__pretty_hex(self.opt.Poly, self.opt.Width)
        self.table["crc_reflect_in"] = self.__pretty_bool(self.opt.ReflectIn)
        self.table["crc_xor_in"] = self.__pretty_hex(self.opt.XorIn, self.opt.Width)
        self.table["crc_reflect_out"] = self.__pretty_bool(self.opt.ReflectOut)
        self.table["crc_xor_out"] = self.__pretty_hex(self.opt.XorOut, self.opt.Width)
        self.table["crc_table_idx_width"] = str(self.opt.TableIdxWidth)
        self.table["crc_table_width"] = str(1 << self.opt.TableIdxWidth)
        self.table["crc_table_mask"] = self.__pretty_hex(self.opt.TableWidth - 1, 8)
        self.table["crc_mask"] = self.__pretty_hex(self.opt.Mask, self.opt.Width)
        self.table["crc_msb_mask"] = self.__pretty_hex(self.opt.MSB_Mask, self.opt.Width)
        if self.opt.Algorithm == self.opt.Algo_Table_Driven and (self.opt.Width == None or self.opt.Width < 8):
            self.table["crc_do_shift"] = self.__pretty_bool(True)
            if self.opt.Width == None:
                self.table["crc_shift"] = self.__pretty_str(None)
            else:
                self.table["crc_shift"] = self.__pretty_str(8 - self.opt.Width)
        else:
            self.table["crc_do_shift"] = self.__pretty_bool(False)
            self.table["crc_shift"] = self.__pretty_str(0)

        self.table["cfg_width"] = "$if ($crc_width != Undefined) {:$crc_width:} $else {:cfg->width:}"
        self.table["cfg_poly"] = "$if ($crc_poly != Undefined) {:$crc_poly:} $else {:cfg->poly:}"
        self.table["cfg_poly_shifted"] = "$if ($crc_do_shift == True) {:($cfg_poly << $cfg_shift):} $else {:$cfg_poly:}"
        self.table["cfg_reflect_in"] = "$if ($crc_reflect_in != Undefined) {:$crc_reflect_in:} $else {:cfg->reflect_in:}"
        self.table["cfg_xor_in"] = "$if ($crc_xor_in != Undefined) {:$crc_xor_in:} $else {:cfg->xor_in:}"
        self.table["cfg_reflect_out"] = "$if ($crc_reflect_out != Undefined) {:$crc_reflect_out:} $else {:cfg->reflect_out:}"
        self.table["cfg_xor_out"] = "$if ($crc_xor_out != Undefined) {:$crc_xor_out:} $else {:cfg->xor_out:}"
        self.table["cfg_table_idx_width"] = "$if ($crc_table_idx_width != Undefined) {:$crc_table_idx_width:} $else {:cfg->table_idx_width:}"
        self.table["cfg_table_width"] = "$if ($crc_table_width != Undefined) {:$crc_table_width:} $else {:cfg->table_width:}"
        self.table["cfg_mask"] = "$if ($crc_mask != Undefined) {:$crc_mask:} $else {:cfg->crc_mask:}"
        self.table["cfg_mask_shifted"] = "$if ($crc_do_shift == True) {:($cfg_mask << $cfg_shift):} $else {:$cfg_mask:}"
        self.table["cfg_msb_mask"] = "$if ($crc_msb_mask != Undefined) {:$crc_msb_mask:} $else {:cfg->msb_mask:}"
        self.table["cfg_msb_mask_shifted"] = "$if ($crc_do_shift == True) {:($cfg_msb_mask << $cfg_shift):} $else {:$cfg_msb_mask:}"
        self.table["cfg_shift"] = "$if ($crc_shift != Undefined) {:$crc_shift:} $else {:cfg->crc_shift:}"

        self.table["undefined_parameters"] = self.__pretty_bool(self.opt.UndefinedCrcParameters)
        self.table["use_cfg_t"] = self.__pretty_bool(self.opt.UndefinedCrcParameters)
        self.table["c_std"] = self.opt.CStd
        self.table["c_bool"] = "$if ($c_std == C89) {:int:} $else {:bool:}"
        self.table["c_true"] = "$if ($c_std == C89) {:1:} $else {:true:}"
        self.table["c_false"] = "$if ($c_std == C89) {:0:} $else {:false:}"

        self.table["underlying_crc_t"] = self.__get_underlying_crc_t()
        self.table["include_file"] = self.__get_include_file()

        self.table["crc_prefix"] = self.opt.SymbolPrefix
        self.table["crc_t"] = self.opt.SymbolPrefix + "t"
        self.table["cfg_t"] = self.opt.SymbolPrefix + "cfg_t"
        self.table["crc_reflect_function"] = self.opt.SymbolPrefix + "reflect"
        self.table["crc_table_gen_function"] = self.opt.SymbolPrefix + "table_gen"
        self.table["crc_init_function"] = self.opt.SymbolPrefix + "init"
        self.table["crc_update_function"] = self.opt.SymbolPrefix + "update"
        self.table["crc_finalize_function"] = self.opt.SymbolPrefix + "finalize"


    # function getTerminal
    ###############################################################################
    def getTerminal(self, id):
        """
        Return the expanded terminal, if it exists or None otherwise.
        """

        if id != None:
            if id == "":
                return ""
            if id in self.table:
                return self.table[id]
            key = self.__getTerminal(id)
            if key != None:
                self.table[id] = key
                return key
        raise LookupError


    # function __getTerminal
    ###############################################################################
    def __getTerminal(self, id):
        """
        Return the expanded terminal, if it exists or None otherwise.
        """
        if id == "constant_crc_init":
            if self.__get_init_value() == None:
                return  self.__pretty_bool(False)
            else:
                return   self.__pretty_bool(True)

        if id == "constant_crc_table":
            if self.opt.Width != None and self.opt.Poly != None and self.opt.ReflectIn != None:
                return  self.__pretty_bool(True)
            else:
                return   self.__pretty_bool(False)

        elif id == "simple_crc_update_def":
            if self.opt.Algorithm in set([self.opt.Algo_Bit_by_Bit, self.opt.Algo_Bit_by_Bit_Fast]):
                if self.opt.Width != None and self.opt.Poly != None and self.opt.ReflectIn != None:
                    return  self.__pretty_bool(True)
            elif self.opt.Algorithm == self.opt.Algo_Table_Driven:
                if self.opt.Width != None and self.opt.ReflectIn != None:
                    return  self.__pretty_bool(True)
            return  self.__pretty_bool(False)

        elif id == "inline_crc_finalize":
            if self.opt.Algorithm in set([self.opt.Algo_Bit_by_Bit_Fast, self.opt.Algo_Table_Driven]) and \
                    (self.opt.Width != None and self.opt.ReflectIn != None and self.opt.ReflectOut != None and self.opt.XorOut != None):
                return  self.__pretty_bool(True)
            else:
                return  self.__pretty_bool(False)

        elif id == "simple_crc_finalize_def":
            if self.opt.Algorithm == self.opt.Algo_Bit_by_Bit:
                if self.opt.Width != None and self.opt.Poly != None and self.opt.ReflectOut != None and self.opt.XorOut != None:
                    return  self.__pretty_bool(True)
            elif self.opt.Algorithm == self.opt.Algo_Bit_by_Bit_Fast:
                if self.opt.Width != None and self.opt.ReflectOut != None and self.opt.XorOut != None:
                    return  self.__pretty_bool(True)
            elif self.opt.Algorithm == self.opt.Algo_Table_Driven:
                if self.opt.Width != None and self.opt.ReflectIn != None and self.opt.ReflectOut != None and self.opt.XorOut != None:
                    return  self.__pretty_bool(True)
            return  self.__pretty_bool(False)

        elif id == "use_reflect_func":
            if self.opt.ReflectOut == False and self.opt.ReflectIn == False:
                return  self.__pretty_bool(False)
            else:
                return  self.__pretty_bool(True)

        elif id == "static_reflect_func":
            if self.opt.Algorithm == self.opt.Algo_Table_Driven:
                return  self.__pretty_bool(False)
            elif self.opt.ReflectOut != None and self.opt.Algorithm == self.opt.Algo_Bit_by_Bit_Fast:
                return  self.__pretty_bool(False)
            else:
                return  self.__pretty_bool(True)

        elif id == "crc_algorithm":
            if self.opt.Algorithm == self.opt.Algo_Bit_by_Bit:
                return  "bit-by-bit"
            elif self.opt.Algorithm == self.opt.Algo_Bit_by_Bit_Fast:
                return  "bit-by-bit-fast"
            elif self.opt.Algorithm == self.opt.Algo_Table_Driven:
                return  "table-driven"
            else:
                return  "UNDEFINED"

        elif id == "crc_table_init":
            return  self.__get_table_init()
        elif id == "crc_table_core_algorithm_ni":
            return  self.__get_table_core_algorithm_ni()
        elif id == "crc_table_core_algorithm_ri":
            return  self.__get_table_core_algorithm_ri()

        elif id == "header_protection":
            return  self.__pretty_hdrprotection()

        elif id == "crc_init_value":
            ret = self.__get_init_value()
            if ret == None:
                return  ""
            else:
                return  ret

        elif id == "crc_final_value":
            return  """\
$if ($crc_algorithm == "table-driven") {:
$if ($crc_reflect_in == $crc_reflect_out) {:
$if ($crc_do_shift == True) {:(crc >> $cfg_shift):} $else {:crc:} ^ $crc_xor_out\
:} $else {:
$crc_reflect_function($if ($crc_do_shift == True) {:(crc >> $cfg_shift):} $else {:crc:}, $crc_width) ^ $crc_xor_out\
:}:} $elif ($crc_reflect_out == True) {:
$crc_reflect_function(crc, $crc_width) ^ $crc_xor_out\
:} $else {:
crc ^ $crc_xor_out\
:}\
"""
        elif id == "h_template":
            return  """\
$source_header
#ifndef $header_protection
#define $header_protection

$if ($include_file != Undefined) {:
#include $include_file
:}
#include <stdlib.h>
$if ($c_std != C89) {:
#include <stdint.h>
:}
$if ($undefined_parameters == True and $c_std != C89) {:
#include <stdbool.h>
:}

#ifdef __cplusplus
extern "C" {
#endif


/**
 * The definition of the used algorithm.
 *****************************************************************************/
$if ($crc_algorithm == "bit-by-bit") {:
#define CRC_ALGO_BIT_BY_BIT 1
:} $elif ($crc_algorithm == "bit-by-bit-fast") {:
#define CRC_ALGO_BIT_BY_BIT_FAST 1
:} $elif ($crc_algorithm == "table-driven") {:
#define CRC_ALGO_TABLE_DRIVEN 1
:}


/**
 * The type of the CRC values.
 *
 * This type must be big enough to contain at least $cfg_width bits.
 *****************************************************************************/
typedef $underlying_crc_t $crc_t;


$if ($undefined_parameters == True) {:
/**
 * The configuration type of the CRC algorithm.
 *****************************************************************************/
typedef struct {
$if ($crc_width == Undefined) {:
    unsigned int width;     /*!< The width of the polynomial */
:}
$if ($crc_poly == Undefined) {:
    $crc_t poly;             /*!< The CRC polynomial */
:}
$if ($crc_reflect_in == Undefined) {:
    $c_bool reflect_in;         /*!< Whether the input shall be reflected or not */
:}
$if ($crc_xor_in == Undefined) {:
    $crc_t xor_in;           /*!< The initial value of the algorithm */
:}
$if ($crc_reflect_out == Undefined) {:
    $c_bool reflect_out;        /*!< Wether the output shall be reflected or not */
:}
$if ($crc_xor_out == Undefined) {:
    $crc_t xor_out;          /*!< The value which shall be XOR-ed to the final CRC value */
:}
$if ($crc_width == Undefined) {:

    /* internal parameters */
    $crc_t msb_mask;             /*!< a bitmask with the Most Significant Bit set to 1
                                     initialise as 1UL << (width - 1) */
    $crc_t crc_mask;             /*!< a bitmask with all width bits set to 1
                                     initialise as (cfg->msb_mask - 1) | cfg->msb_mask */
    unsigned int crc_shift;     /*!< a shift count that is used when width < 8
                                     initialise as cfg->width < 8 ? 8 - cfg->width : 0 */
:}
} $cfg_t;


:}
$if ($use_reflect_func == True and $static_reflect_func != True) {:
$crc_reflect_doc
$crc_reflect_function_def;


:}
$if ($crc_algorithm == "table-driven" and $constant_crc_table != True) {:
$crc_table_gen_doc
$crc_table_gen_function_def;


:}
$crc_init_doc
$if ($constant_crc_init == False) {:
$crc_init_function_def;
:} $elif ($c_std == C89) {:
#define $crc_init_function()      ($crc_init_value$if ($crc_do_shift == True) {: << $cfg_shift:})
:} $else {:
static inline $crc_init_function_def$nop
{
    return $crc_init_value$if ($crc_do_shift == True) {: << $cfg_shift:};
}
:}


$crc_update_doc
$crc_update_function_def;


$crc_finalize_doc
$if ($inline_crc_finalize == True) {:
$if ($c_std == C89) {:
#define $crc_finalize_function(crc)      ($crc_final_value)
:} $else {:
static inline $crc_finalize_function_def$nop
{
    return $crc_final_value;
}
:}
:} $else {:
$crc_finalize_function_def;
:}


#ifdef __cplusplus
}           /* closing brace for extern "C" */
#endif

#endif      /* $header_protection */
"""

        elif id == "source_header":
            return  """\
/**
 * \\file $filename
 * Functions and types for CRC checks.
 *
 * Generated on $datetime,
 * by $program_version, $program_url
 * using the configuration:
 *    Width        = $crc_width
 *    Poly         = $crc_poly
 *    XorIn        = $crc_xor_in
 *    ReflectIn    = $crc_reflect_in
 *    XorOut       = $crc_xor_out
 *    ReflectOut   = $crc_reflect_out
 *    Algorithm    = $crc_algorithm
 *****************************************************************************/\
"""

        elif id == "crc_reflect_doc":
            return  """\
/**
 * Reflect all bits of a \\a data word of \\a data_len bytes.
 *
 * \\param data         The data word to be reflected.
 * \\param data_len     The width of \\a data expressed in number of bits.
 * \\return             The reflected data.
 *****************************************************************************/\
"""

        elif id == "crc_reflect_function_def":
            return  """\
$crc_t $crc_reflect_function($crc_t data, size_t data_len)\
"""

        elif id == "crc_reflect_function_body":
            return  """\
$if ($crc_reflect_in == Undefined or $crc_reflect_in == True or $crc_reflect_out == Undefined or $crc_reflect_out == True) {:
$crc_reflect_doc
$crc_reflect_function_def$nop
{
    unsigned int i;
    $crc_t ret;

    ret = data & 0x01;
    for (i = 1; i < data_len; i++) {
        data >>= 1;
        ret = (ret << 1) | (data & 0x01);
    }
    return ret;
}
:}\
"""

        elif id == "crc_table_gen_doc":
            return  """\
/**
 * Populate the private static crc table.
 *
 * \\param cfg  A pointer to a initialised $cfg_t structure.
 * \\return     void
 *****************************************************************************/\
"""

        elif id == "crc_table_gen_function_def":
            return  """\
void $crc_table_gen_function(const $cfg_t *cfg)\
"""

        elif id == "crc_init_doc":
            return  """\
/**
 * Calculate the initial crc value.
 *
$if ($use_cfg_t == True) {:
 * \\param cfg  A pointer to a initialised $cfg_t structure.
:}
 * \\return     The initial crc value.
 *****************************************************************************/\
"""

        elif id == "crc_init_function_def":
            return  """\
$if ($constant_crc_init == False) {:
$crc_t $crc_init_function(const $cfg_t *cfg)\
:} $else {:
$crc_t $crc_init_function(void)\
:}\
"""

        elif id == "crc_update_doc":
            return  """\
/**
 * Update the crc value with new data.
 *
 * \\param crc      The current crc value.
$if ($simple_crc_update_def != True) {:
 * \\param cfg      A pointer to a initialised $cfg_t structure.
:}
 * \\param data     Pointer to a buffer of \\a data_len bytes.
 * \\param data_len Number of bytes in the \\a data buffer.
 * \\return         The updated crc value.
 *****************************************************************************/\
"""

        elif id == "crc_update_function_def":
            return  """\
$if ($simple_crc_update_def != True) {:
$crc_t $crc_update_function(const $cfg_t *cfg, $crc_t crc, const unsigned char *data, size_t data_len)\
:} $else {:
$crc_t $crc_update_function($crc_t crc, const unsigned char *data, size_t data_len)\
:}\
"""

        elif id == "crc_finalize_doc":
            return  """\
/**
 * Calculate the final crc value.
 *
$if ($simple_crc_finalize_def != True) {:
 * \\param cfg  A pointer to a initialised $cfg_t structure.
:}
 * \\param crc  The current crc value.
 * \\return     The final crc value.
 *****************************************************************************/\
"""

        elif id == "crc_finalize_function_def":
            return  """\
$if ($simple_crc_finalize_def != True) {:
$crc_t $crc_finalize_function(const $cfg_t *cfg, $crc_t crc)\
:} $else {:
$crc_t $crc_finalize_function($crc_t crc)\
:}\
"""

        elif id == "c_template":
            return  """\
$source_header
$if ($include_file != Undefined) {:
#include $include_file
:}
#include "$header_filename"     /* include the header file generated with pycrc */
#include <stdlib.h>
$if ($c_std != C89) {:
#include <stdint.h>
$if ($undefined_parameters == True or $crc_algorithm == "bit-by-bit" or $crc_algorithm == "bit-by-bit-fast") {:
#include <stdbool.h>
:}
:}

$if ($use_reflect_func == True and $static_reflect_func == True) {:
static $crc_reflect_function_def;

:}
$if ($crc_algorithm == "bit-by-bit") {:
$c_bit_by_bit
:} $elif ($crc_algorithm == "bit-by-bit-fast") {:
$c_bit_by_bit_fast
:} $elif ($crc_algorithm == "table-driven") {:
$c_table_driven
:}
"""

        elif id == "c_table":
            return  """\
/**
 * Static table used for the table_driven implementation.
$if ($undefined_parameters == True) {:
 * Must be initialised with the $crc_init_function function.
:}
 *****************************************************************************/
$if ($constant_crc_table != True) {:
static $crc_t crc_table[$crc_table_width];
:} $else {:
static const $crc_t crc_table[$crc_table_width] = {
$crc_table_init
};
:}
"""

        elif id == "c_bit_by_bit":
            return  """\
$if ($use_reflect_func == True) {:
$crc_reflect_function_body

:}
$if ($constant_crc_init == False) {:
$crc_init_doc
$crc_init_function_def$nop
{
    unsigned int i;
    $c_bool bit;
    $crc_t crc = $cfg_xor_in;
    for (i = 0; i < $cfg_width; i++) {
        bit = crc & 0x01;
        if (bit) {
            crc = ((crc ^ $cfg_poly) >> 1) | $cfg_msb_mask;
        } else {
            crc >>= 1;
        }
    }
    return crc & $cfg_mask;
}
:}

$crc_update_doc
$crc_update_function_def$nop
{
    unsigned int i;
    $c_bool bit;
    unsigned char c;

    while (data_len--) {
$if ($crc_reflect_in == Undefined) {:
        if ($cfg_reflect_in) {
            c = $crc_reflect_function(*data++, 8);
        } else {
            c = *data++;
        }
:} $elif ($crc_reflect_in == True) {:
        c = $crc_reflect_function(*data++, 8);
:} $else {:
        c = *data++;
:}
        for (i = 0; i < 8; i++) {
            bit = $if ($c_std == C89) {:!!(crc & $cfg_msb_mask):} $else {:crc & $cfg_msb_mask:};
            crc = (crc << 1) | ((c >> (7 - i)) & 0x01);
            if (bit) {
                crc ^= $cfg_poly;
            }
        }
        crc &= $cfg_mask;
    }
    return crc & $cfg_mask;
}


$crc_finalize_doc
$crc_finalize_function_def$nop
{
    unsigned int i;
    $c_bool bit;

    for (i = 0; i < $cfg_width; i++) {
        bit = $if ($c_std == C89) {:!!(crc & $cfg_msb_mask):} $else {:crc & $cfg_msb_mask:};
        crc = (crc << 1) | 0x00;
        if (bit) {
            crc ^= $cfg_poly;
        }
    }
$if ($crc_reflect_out == Undefined) {:
    if ($cfg_reflect_out) {
        crc = $crc_reflect_function(crc, $cfg_width);
    }
:} $elif ($crc_reflect_out == True) {:
    crc = $crc_reflect_function(crc, $cfg_width);
:}
    return (crc ^ $cfg_xor_out) & $cfg_mask;
}
"""

        elif id == "c_bit_by_bit_fast":
            return  """\
$if ($use_reflect_func == True) {:
$crc_reflect_function_body

:}
$if ($constant_crc_init == False) {:
$crc_init_doc
$crc_init_function_def$nop
{
    return $cfg_xor_in & $cfg_mask;
}
:}

$crc_update_doc
$crc_update_function_def$nop
{
    unsigned int i;
    $c_bool bit;
    unsigned char c;

    while (data_len--) {
$if ($crc_reflect_in == Undefined) {:
        if ($cfg_reflect_in) {
            c = $crc_reflect_function(*data++, 8);
        } else {
            c = *data++;
        }
:} $else {:
        c = *data++;
:}
$if ($crc_reflect_in == True) {:
        for (i = 0x01; i & 0xff; i <<= 1) {
:} $else {:
        for (i = 0x80; i > 0; i >>= 1) {
:}
            bit = $if ($c_std == C89) {:!!(crc & $cfg_msb_mask):} $else {:crc & $cfg_msb_mask:};
            if (c & i) {
                bit = !bit;
            }
            crc <<= 1;
            if (bit) {
                crc ^= $cfg_poly;
            }
        }
        crc &= $cfg_mask;
    }
    return crc & $cfg_mask;
}

$if ($inline_crc_finalize != True) {:
$crc_finalize_doc
$crc_finalize_function_def$nop
{
$if ($crc_reflect_out == Undefined) {:
    if (cfg->reflect_out) {
        crc = $crc_reflect_function(crc, $cfg_width);
    }
:} $elif ($crc_reflect_out == True) {:
    crc = $crc_reflect_function(crc, $cfg_width);
:}
    return (crc ^ $cfg_xor_out) & $cfg_mask;
}

:}
"""

        elif id == "c_table_driven":
            return  """\
$c_table
$if ($use_reflect_func == True) {:
$crc_reflect_function_body
:}

$if ($constant_crc_init == False) {:
$crc_init_doc
$crc_init_function_def$nop
{
$if ($crc_reflect_in == Undefined) {:
    if ($cfg_reflect_in) {
        return $crc_reflect_function($cfg_xor_in & $cfg_mask, $cfg_width)$if ($crc_do_shift == True) {: << $cfg_shift:};
    } else {
        return $cfg_xor_in & $cfg_mask$if ($crc_do_shift == True) {: << $cfg_shift:};
    }
:} $elif ($crc_reflect_in == True) {:
    return $crc_reflect_function($cfg_xor_in & $cfg_mask, $cfg_width)$if ($crc_do_shift == True) {: << $cfg_shift:};
:} $else {:
    return $cfg_xor_in & $cfg_mask$if ($crc_do_shift == True) {: << $cfg_shift:};
:}
}
:}

$if ($constant_crc_table != True) {:
$crc_table_gen_doc
$crc_table_gen_function_def
{
    $crc_t crc;
    unsigned int i, j;

    for (i = 0; i < $cfg_table_width; i++) {
$if ($crc_reflect_in == Undefined) {:
        if (cfg->reflect_in) {
            crc = $crc_reflect_function(i, $cfg_table_idx_width);
        } else {
            crc = i;
        }
:} $elif ($crc_reflect_in == True) {:
        crc = $crc_reflect_function(i, $cfg_table_idx_width);
:} $else {:
        crc = i;
:}
$if ($crc_do_shift == True) {:
        crc <<= ($cfg_width - $cfg_table_idx_width + $cfg_shift);
:} $else {:
        crc <<= ($cfg_width - $cfg_table_idx_width);
:}
        for (j = 0; j < $cfg_table_idx_width; j++) {
            if (crc & $cfg_msb_mask_shifted) {
                crc = (crc << 1) ^ $cfg_poly_shifted;
            } else {
                crc = crc << 1;
            }
        }
$if ($crc_reflect_in == Undefined) {:
        if (cfg->reflect_in) {
$if ($crc_do_shift == True) {:
            crc = $crc_reflect_function(crc >> $cfg_shift, $cfg_width) << $cfg_shift;
:} $else {:
            crc = $crc_reflect_function(crc, $cfg_width);
:}
        }
:} $elif ($crc_reflect_in == True) {:
$if ($crc_do_shift == True) {:
        crc = $crc_reflect_function(crc >> $cfg_shift, $cfg_width) << $cfg_shift;
:} $else {:
        crc = $crc_reflect_function(crc, $cfg_width);
:}
:}
        crc_table[i] = crc & $cfg_mask_shifted;
    }
}

:}
$crc_update_doc
$crc_update_function_def$nop
{
    unsigned int tbl_idx;

$if ($crc_reflect_in == Undefined) {:
    if (cfg->reflect_in) {
        while (data_len--) {
$crc_table_core_algorithm_ri
            data++;
        }
    } else {
        while (data_len--) {
$crc_table_core_algorithm_ni
            data++;
        }
    }
:} $else {:
    while (data_len--) {
$if ($crc_reflect_in == True) {:
$crc_table_core_algorithm_ri
:} $elif ($crc_reflect_in == False) {:
$crc_table_core_algorithm_ni
:}
        data++;
    }
:}
    return crc & $cfg_mask_shifted;
}

$if ($inline_crc_finalize == False) {:
$crc_finalize_doc
$crc_finalize_function_def$nop
{
$if ($crc_do_shift == True) {:
    crc >>= $cfg_shift;
:}
$if ($crc_reflect_in == Undefined or $crc_reflect_out == Undefined) {:
$if ($crc_reflect_in == Undefined and $crc_reflect_out == Undefined) {:
    if (cfg->reflect_in == !cfg->reflect_out):}
 $elif ($crc_reflect_out == Undefined) {:
    if ($if ($crc_reflect_in == True) {:!:}cfg->reflect_out):}
 $elif ($crc_reflect_in == Undefined) {:
    if ($if ($crc_reflect_out == True) {:!:}cfg->reflect_in):} {
        crc = $crc_reflect_function(crc, $cfg_width);
    }
:} $elif ($crc_reflect_in != $crc_reflect_out) {:
    crc = $crc_reflect_function(crc, $cfg_width);
:}
    return (crc ^ $cfg_xor_out) & $cfg_mask;
}
:}
"""

        elif id == "main_template":
            return  """\
$if ($include_file != Undefined) {:
#include $include_file
:}
#include <stdio.h>
#include <getopt.h>
$if ($undefined_parameters == True) {:
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
:}
$if ($c_std != C89) {:
#include <stdbool.h>
:}
#include <string.h>

static char str[256] = "123456789";
static $c_bool verbose = $c_false;

void print_params($if ($undefined_parameters == True) {:const $cfg_t *cfg:} $else {:void:});
$getopt_template

void print_params($if ($undefined_parameters == True) {:const $cfg_t *cfg:} $else {:void:})
{
    char format[20];

    snprintf(format, sizeof(format), "%%-16s = 0x%%0%dx\\n", (unsigned int)($cfg_width + 3) / 4);
    printf("%-16s = %d\\n", "width", (unsigned int)$cfg_width);
    printf(format, "poly", (unsigned int)$cfg_poly);
    printf("%-16s = %s\\n", "reflect_in", $if ($crc_reflect_in == Undefined) {:$cfg_reflect_in ? "true": "false":} $else {:$if ($crc_reflect_in == True) {:"true":} $else {:"false":}:});
    printf(format, "xor_in", $cfg_xor_in);
    printf("%-16s = %s\\n", "reflect_out", $if ($crc_reflect_out == Undefined) {:$cfg_reflect_out ? "true": "false":} $else {:$if ($crc_reflect_out == True) {:"true":} $else {:"false":}:});
    printf(format, "xor_out", (unsigned int)$cfg_xor_out);
    printf(format, "crc_mask", (unsigned int)$cfg_mask);
    printf(format, "msb_mask", (unsigned int)$cfg_msb_mask);
}

/**
 * C main function.
 *
 * \\return     0 on success, != 0 on error.
 *****************************************************************************/
int main(int argc, char *argv[])
{
$if ($undefined_parameters == True) {:
    $cfg_t cfg = {
$if ($crc_width == Undefined) {:
            0,      /* width */
:}
$if ($crc_poly == Undefined) {:
            0,      /* poly */
:}
$if ($crc_xor_in == Undefined) {:
            0,      /* xor_in */
:}
$if ($crc_reflect_in == Undefined) {:
            0,      /* reflect_in */
:}
$if ($crc_xor_out == Undefined) {:
            0,      /* xor_out */
:}
$if ($crc_reflect_out == Undefined) {:
            0,      /* reflect_out */
:}
$if ($crc_width == Undefined) {:

            0,      /* crc_mask */
            0,      /* msb_mask */
            0,      /* crc_shift */
:}
    };
:}
    $crc_t crc;

$if ($undefined_parameters == True) {:
    get_config(argc, argv, &cfg);
:} $else {:
    get_config(argc, argv);
:}
$if ($crc_algorithm == "table-driven" and $constant_crc_table != True) {:
    $crc_table_gen_function(&cfg);
:}
    crc = $crc_init_function($if ($constant_crc_init != True) {:&cfg:});
    crc = $crc_update_function($if ($simple_crc_update_def != True) {:&cfg, :}crc, (unsigned char *)str, strlen(str));
    crc = $crc_finalize_function($if ($simple_crc_finalize_def != True) {:&cfg, :}crc);

    if (verbose) {
        print_params($if ($undefined_parameters == True) {:&cfg:});
    }
    printf("0x%lx\\n", (unsigned long)crc);
    return 0;
}
"""

        elif id == "getopt_template":
            return  """\
$if ($crc_reflect_in == Undefined or $crc_reflect_out == Undefined) {:
static $c_bool atob(const char *str);
:}
$if ($crc_poly == Undefined or $crc_xor_in == Undefined or $crc_xor_out == Undefined) {:
static crc_t xtoi(const char *str);
:}
static int get_config(int argc, char *argv[]$if ($undefined_parameters == True) {:, $cfg_t *cfg:});


$if ($crc_reflect_in == Undefined or $crc_reflect_out == Undefined) {:
$c_bool atob(const char *str)
{
    if (!str) {
        return 0;
    }
    if (isdigit(str[0])) {
        return ($c_bool)atoi(str);
    }
    if (tolower(str[0]) == 't') {
        return $c_true;
    }
    return $c_false;
}

:}
$if ($crc_poly == Undefined or $crc_xor_in == Undefined or $crc_xor_out == Undefined) {:
crc_t xtoi(const char *str)
{
    crc_t ret = 0;

    if (!str) {
        return 0;
    }
    if (str[0] == '0' && tolower(str[1]) == 'x') {
        str += 2;
        while (*str) {
            if (isdigit(*str))
                ret = 16 * ret + *str - '0';
            else if (isxdigit(*str))
                ret = 16 * ret + tolower(*str) - 'a' + 10;
            else
                return ret;
            str++;
        }
    } else if (isdigit(*str)) {
        while (*str) {
            if (isdigit(*str))
                ret = 10 * ret + *str - '0';
            else
                return ret;
            str++;
        }
    }
    return ret;
}


:}
static int get_config(int argc, char *argv[]$if ($undefined_parameters == True) {:, $cfg_t *cfg:})
{
    int c;
    int option_index;
    static struct option long_options[] = {
$if ($crc_width == Undefined) {:
        {"width",           1, 0, 'w'},
:}
$if ($crc_poly == Undefined) {:
        {"poly",            1, 0, 'p'},
:}
$if ($crc_reflect_in == Undefined) {:
        {"reflect-in",      1, 0, 'n'},
:}
$if ($crc_xor_in == Undefined) {:
        {"xor-in",          1, 0, 'i'},
:}
$if ($crc_reflect_out == Undefined) {:
        {"reflect-out",     1, 0, 'u'},
:}
$if ($crc_xor_out == Undefined) {:
        {"xor-out",         1, 0, 'o'},
:}
        {"verbose",         0, 0, 'v'},
        {"check-string",    1, 0, 's'},
$if ($crc_width == Undefined) {:
        {"table-idx-with",  1, 0, 't'},
:}
        {0, 0, 0, 0}
    };

    while (1) {
        option_index = 0;

        c = getopt_long (argc, argv, "w:p:n:i:u:o:s:vt", long_options, &option_index);
        if (c == -1)
            break;

        switch (c) {
            case 0:
                printf ("option %s", long_options[option_index].name);
                if (optarg)
                    printf (" with arg %s", optarg);
                printf ("\\n");
$if ($crc_width == Undefined) {:
            case 'w':
                cfg->width = atoi(optarg);
                break;
:}
$if ($crc_poly == Undefined) {:
            case 'p':
                cfg->poly = xtoi(optarg);
                break;
:}
$if ($crc_reflect_in == Undefined) {:
            case 'n':
                cfg->reflect_in = atob(optarg);
                break;
:}
$if ($crc_xor_in == Undefined) {:
            case 'i':
                cfg->xor_in = xtoi(optarg);
                break;
:}
$if ($crc_reflect_out == Undefined) {:
            case 'u':
                cfg->reflect_out = atob(optarg);
                break;
:}
$if ($crc_xor_out == Undefined) {:
            case 'o':
                cfg->xor_out = xtoi(optarg);
                break;
:}
            case 's':
                memcpy(str, optarg, strlen(optarg) < sizeof(str) ? strlen(optarg) + 1 : sizeof(str));
                str[sizeof(str) - 1] = '\\0';
                break;
            case 'v':
                verbose = $c_true;
                break;
$if ($crc_width == Undefined) {:
            case 't':
                /* ignore --table_idx_width option */
                break;
:}
            case '?':
                return -1;
            case ':':
                fprintf(stderr, "missing argument to option %c\\n", c);
                return -1;
            default:
                fprintf(stderr, "unhandled option %c\\n", c);
                return -1;
        }
    }
$if ($crc_width == Undefined) {:
    cfg->msb_mask = 1UL << (cfg->width - 1);
    cfg->crc_mask = (cfg->msb_mask - 1) | cfg->msb_mask;
    cfg->crc_shift = cfg->width < 8 ? 8 - cfg->width : 0;
:}

$if ($crc_poly == Undefined) {:
    cfg->poly &= $cfg_mask;
:}
$if ($crc_xor_in == Undefined) {:
    cfg->xor_in &= $cfg_mask;
:}
$if ($crc_xor_out == Undefined) {:
    cfg->xor_out &= $cfg_mask;
:}
    return 0;
}\
"""


    # function __pretty_str
    ###############################################################################
    def __pretty_str(self, value):
        """
        Return a value of width bits as a pretty string.
        """
        if value == None:
            return "Undefined"
        return str(value)


    # function __pretty_hex
    ###############################################################################
    def __pretty_hex(self, value, width = None):
        """
        Return a value of width bits as a pretty hexadecimal formatted string.
        """
        if value == None:
            return "Undefined"
        if width == None:
            return "0x%x" % value
        width = (width + 3) // 4
        hex_str = "0x%%0%dx" % width
        return hex_str % value


    # function __pretty_bool
    ###############################################################################
    def __pretty_bool(self, value):
        """
        Return a boolen value of width bits as a pretty formatted string.
        """
        if value == None:
            return "Undefined"
        if value:
            return "True"
        else:
            return "False"


    # function __pretty_hdrprotection
    ###############################################################################
    def __pretty_hdrprotection(self):
        """
        Return the name of a C header protection (e.g. __CRC_IMPLEMENTATION_H__).
        """
        tr_str = ""
        for i in range(256):
            if chr(i).isalpha():
                tr_str += chr(i).upper()
            else:
                tr_str += '_'
        if self.opt.OutputFile == None:
            out_str = "pycrc_stdout"
        else:
            out_str = self.opt.OutputFile
        out_str = os.path.basename(out_str)
        out_str = out_str.upper()
        out_str = out_str.translate(tr_str)
        return "__" + out_str + "__"


    # function __get_underlying_crc_t
    ###############################################################################
    def __get_underlying_crc_t(self):
        """
        Return the C type of the crc_t typedef.
        """
        if self.opt.CrcType != None:
            return self.opt.CrcType
        if self.opt.Width == None:
            return "unsigned long"
        if self.opt.CStd == "C89":
            if self.opt.Width <= 8:
                return "unsigned char"
            elif self.opt.Width <= 16:
                return "unsigned int"
            else:
                return "unsigned long"
        else:       # C99
            if self.opt.Width <= 8:
                return "uint8_t"
            elif self.opt.Width <= 16:
                return "uint16_t"
            elif self.opt.Width <= 32:
                return "uint32_t"
            else:
                return "unsigned long"
        return "unsigned long"


    # function __get_include_file
    ###############################################################################
    def __get_include_file(self):
        """
        Return an addittional include instruction if specified.
        """
        if self.opt.IncludeFile == None:
            return None
        if self.opt.IncludeFile[0] == '"' or self.opt.IncludeFile[0] == '<':
            return self.opt.IncludeFile
        return '"%s"' % self.opt.IncludeFile


    # function __get_init_value
    ###############################################################################
    def __get_init_value(self):
        """
        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 self.opt.Algorithm == self.opt.Algo_Bit_by_Bit:
            if self.opt.XorIn == None or self.opt.Width == None or self.opt.Poly == None:
                return None
            crc = Crc(width = self.opt.Width, poly = self.opt.Poly,
                    reflect_in = self.opt.ReflectIn, xor_in = self.opt.XorIn,
                    reflect_out = self.opt.ReflectOut, xor_out = self.opt.XorOut,
                    table_idx_width = self.opt.TableIdxWidth)
            init = crc.NonDirectInit
        elif self.opt.Algorithm == self.opt.Algo_Bit_by_Bit_Fast:
            if self.opt.XorIn == None:
                return None
            init = self.opt.XorIn
        elif self.opt.Algorithm == self.opt.Algo_Table_Driven:
            if self.opt.ReflectIn == None or self.opt.XorIn == None or self.opt.Width == None:
                return None
            if self.opt.Poly == None:
                poly = 0
            else:
                poly = self.opt.Poly
            crc = Crc(width = self.opt.Width, poly = poly,
                    reflect_in = self.opt.ReflectIn, xor_in = self.opt.XorIn,
                    reflect_out = self.opt.ReflectOut, xor_out = self.opt.XorOut,
                    table_idx_width = self.opt.TableIdxWidth)
            if self.opt.ReflectIn:
                init = crc.reflect(crc.DirectInit, self.opt.Width)
            else:
                init = crc.DirectInit
        else:
            init = 0
        return self.__pretty_hex(init, self.opt.Width)


    # function __get_table_init
    ###############################################################################
    def __get_table_init(self):
        """
        Return the precalculated CRC table for the table_driven implementation.
        """
        if self.opt.Algorithm != self.opt.Algo_Table_Driven:
            return "0"
        if self.opt.Width == None or self.opt.Poly == None or self.opt.ReflectIn == None:
            return "0"
        crc = Crc(width = self.opt.Width, poly = self.opt.Poly,
                reflect_in = self.opt.ReflectIn,
                xor_in = 0, reflect_out = False, xor_out = 0,       # set unimportant variables to known values
                table_idx_width = self.opt.TableIdxWidth)
        tbl = crc.gen_table()
        if self.opt.Width >= 32:
            values_per_line = 4
        elif self.opt.Width >= 16:
            values_per_line = 8
        else:
            values_per_line = 16
        format_width = max(self.opt.Width, 8)
        out  = ""
        for i in range(self.opt.TableWidth):
            if i % values_per_line == 0:
                out += "    "
            if i == (self.opt.TableWidth - 1):
                out += "%s" % self.__pretty_hex(tbl[i], format_width)
            elif i % values_per_line == (values_per_line - 1):
                out += "%s,\n" % self.__pretty_hex(tbl[i], format_width)
            else:
                out += "%s, " % self.__pretty_hex(tbl[i], format_width)
        return out


    # function __get_table_core_algorithm_ni
    ###############################################################################
    def __get_table_core_algorithm_ni(self):
        """
        Return the core loop of the table-driven algorithm.
        """
        if self.opt.Algorithm != self.opt.Algo_Table_Driven:
            return ""

        loop_core_ni = ""
        loop_indent = ""
        if self.opt.UndefinedCrcParameters:
            loop_indent = "            "
        else:
            loop_indent = "        "

        if self.opt.Width == None:
            shr = "($cfg_width - $cfg_table_idx_width + $cfg_shift)"
        elif self.opt.Width < 8:
            shr = "%d" % (self.opt.Width - self.opt.TableIdxWidth + 8 - self.opt.Width)
        else:
            shr = "%d" % (self.opt.Width - self.opt.TableIdxWidth)

        reg_shift = "$if ($crc_do_shift == True) {:($cfg_table_idx_width - $cfg_shift):} $else {:$cfg_table_idx_width:}"

        if self.opt.TableIdxWidth == 8:
            loop_core_ni += loop_indent + "tbl_idx = ((crc >> " + shr + ") ^ *data) & $crc_table_mask;" + '\n' + \
                            loop_indent + "crc = (crc_table[tbl_idx] ^ (crc << " + reg_shift + ")) & $cfg_mask_shifted;" + '\n'
        else:
            for i in range (8 / self.opt.TableIdxWidth):
                str_idx = "%s" % (8 - (i + 1) * self.opt.TableIdxWidth)
                loop_core_ni += loop_indent + "tbl_idx = (crc >> " + shr + ") ^ (*data >> " + str_idx + ");" + '\n' + \
                                loop_indent + "crc = crc_table[tbl_idx & $crc_table_mask] ^ (crc << " + reg_shift + ");" + '\n'
        return loop_core_ni


    # function __get_table_core_algorithm_ri
    ###############################################################################
    def __get_table_core_algorithm_ri(self):
        """
        Return the core loop of the table-driven algorithm.
        """
        if self.opt.Algorithm != self.opt.Algo_Table_Driven:
            return ""

        loop_core_ri = ""
        loop_indent = ""
        if self.opt.UndefinedCrcParameters:
            loop_indent = "            "
        else:
            loop_indent = "        "
        crc_shifted = "$if ($crc_do_shift == True) {:(crc >> $cfg_shift):} $else {:crc:}"

        if self.opt.TableIdxWidth == 8:
            loop_core_ri += loop_indent + "tbl_idx = (" + crc_shifted + " ^ *data) & $crc_table_mask;" + '\n' + \
                            loop_indent + "crc = (crc_table[tbl_idx] ^ (crc >> $cfg_table_idx_width)) & $cfg_mask_shifted;" + '\n'
        else:
            for i in range (8 / self.opt.TableIdxWidth):
                str_idx = "%d" % i
                loop_core_ri += loop_indent + "tbl_idx = " + crc_shifted + " ^ (*data >> (" + str_idx + " * $cfg_table_idx_width));" + '\n' + \
                                loop_indent + "crc = crc_table[tbl_idx & $crc_table_mask] ^ (crc >> $cfg_table_idx_width);" + '\n'

        return loop_core_ri