Ignore:
Timestamp:
May 1, 2008, 6:48:45 PM (16 years ago)
Author:
rosiere
Message:
  • support locale (now must "just" translate)
  • update all component with new test format
  • update all component with usage
  • New component : decod queue and prediction_unit
Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/SelfTest/src/test.cpp

    r81 r82  
    77 */
    88
     9#define NB_ITERATION 64
     10#define CYCLE_MAX    (1024*NB_ITERATION)
     11
    912#include "Behavioural/Generic/Shifter/SelfTest/include/test.h"
    1013#include "Common/include/BitManipulation.h"
    1114#include "Common/include/Test.h"
    12 
    13 #define NB_ITERATION 64
    1415
    1516void test (string name,
     
    4142                                    param_stat,
    4243#endif
    43                                     param);
     44                                    &param,
     45                                    USE_ALL);
    4446 
    4547#ifdef SYSTEMC
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/include/Parameters.h

    r81 r82  
    5959  public : ~Parameters () ;
    6060
    61   public :        std::string  msg_error  (void);
    62   public :        std::string   print      (uint32_t depth);
    63   public : friend std::ostream& operator<< (std::ostream& output_stream,
    64                                             morpheo::behavioural::generic::shifter::Parameters & x);
     61  public :        Parameters_test msg_error  (void);
     62  public :        std::string     print      (uint32_t depth);
     63  public : friend std::ostream&   operator<< (std::ostream& output_stream,
     64                                              morpheo::behavioural::generic::shifter::Parameters & x);
    6565  };
    6666
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/include/Shifter.h

    r81 r82  
    2525#endif
    2626#include "Behavioural/include/Component.h"
     27#include "Behavioural/include/Usage.h"
    2728
    2829namespace morpheo                    {
     
    3940    // -----[ fields ]----------------------------------------------------
    4041    // Parameters
    41   protected : const std::string     _name;
     42  protected : const std::string  _name;
     43  protected : const Parameters * _param;
     44  private   : const Tusage_t     _usage;
    4245
    43   protected : const Parameters _param;
    4446#ifdef STATISTICS
    4547  public    : Stat                           * _stat;
     
    8486                                           morpheo::behavioural::Parameters_Statistics * param_statistics,
    8587#endif
    86                                            Parameters                                    param );
     88                                           Parameters                                  * param,
     89                                           morpheo::behavioural::Tusage_t                usage
     90                                           );
    8791   
    8892  public  :          Shifter              (Parameters param );
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Parameters_msg_error.cpp

    r81 r82  
    1515namespace shifter {
    1616
    17   std::string Parameters::msg_error(void)
     17  Parameters_test Parameters::msg_error(void)
    1818  {
    19     std::string msg = "";
     19    Parameters_test test ("Shifter");
    2020
    2121    if (_size_data < 2)
    22       {
    23         msg += "  - size_data must be > 1\n";
    24         msg += "    * size_data                       : " + toString(_size_data) + "\n";
    25       }
    26 
     22      test.error("size_data must be > 1\n");
     23   
    2724    if (is_positive(_nb_port) == false)
    28       {
    29         msg += "  - nb_port must be > 0\n";
    30         msg += "    * nb_port                         : " + toString(_nb_port) + "\n";
    31       }
    32 
     25      test.error("nb_port must be > 0\n");
     26   
    3327    if (_shift_value > _size_data)
    34       {
    35         msg += "  - shift_value must be < size_data\n";
    36         msg += "    * shift_value                     : " + toString(_shift_value) + "\n";
    37         msg += "    * size_data                       : " + toString(_size_data)   + "\n";
    38       }   
    39 
     28      test.error("shift_value must be < size_data\n"); 
     29   
    4030    if ( (_rotate == internal_rotate) && (_carry != internal_logic))
    41       {
    42         msg += "  - Incompatible parameters : internal_rotate have never carry (must be set at \"internal_logic\"\n";
    43         msg += "    * rotate                          : " + toString(_rotate) + "\n";
    44         msg += "    * carry                           : " + toString(_carry ) + "\n";
    45       }   
    46 
     31      test.error("Incompatible parameters : internal_rotate have never carry (must be set at \"internal_logic\"\n");
     32   
    4733    if (_type_completion_bool && (_size_data_completion != 1))
    48       {
    49         msg += "  - Incompatible parameters : you can't have the type of port in_SHIFTER_COMPLETION at bool. Because, This port must be more bits\n";
    50         msg += "    * size_data_completion            : " + toString (_size_data_completion) + "\n";
    51       }
     34      test.error("Incompatible parameters : you can't have the type of port in_SHIFTER_COMPLETION at bool. Because, This port must be more bits\n");
    5235     
    53     return msg;
     36    return test;
    5437  };
    5538
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Shifter.cpp

    r81 r82  
    1414
    1515
     16  Shifter::Shifter (
    1617#ifdef SYSTEMC
    17   Shifter::Shifter (sc_module_name name
     18                    sc_module_name name
    1819#else
    19   Shifter::Shifter (string name
     20                    std::string name
    2021#endif
    2122#ifdef STATISTICS
    2223                    ,morpheo::behavioural::Parameters_Statistics * param_statistics
    2324#endif
    24                     ,morpheo::behavioural::generic::shifter::Parameters param ):
    25                     _name   (name)
    26                     ,_param (param)
     25                    ,morpheo::behavioural::generic::shifter::Parameters *param
     26                    ,morpheo::behavioural::Tusage_t                usage ):
     27    _name   (name)
     28    ,_param (param)
     29    ,_usage (usage)
    2730  {
    2831#ifdef SYSTEMC
     
    5053    dont_initialize ();
    5154    sensitive << (*(in_CLOCK)).neg();
    52     for (uint32_t i=0; i<param._nb_port; i++)
     55    for (uint32_t i=0; i<param->_nb_port; i++)
    5356      {
    5457        sensitive << (*(in_SHIFTER_DATA      [i]));
    55         if (param._shift_value == 0)
     58        if (param->_shift_value == 0)
    5659        sensitive << (*(in_SHIFTER_SHIFT     [i]));
    57         if (param._direction   == external_direction)
     60        if (param->_direction   == external_direction)
    5861        sensitive << (*(in_SHIFTER_DIRECTION [i]));
    59         if (_param._rotate     == external_rotate)
     62        if (_param->_rotate     == external_rotate)
    6063        sensitive << (*(in_SHIFTER_TYPE      [i]));
    61         if (param._carry       == external_carry)
     64        if (param->_carry       == external_carry)
    6265        sensitive << (*(in_SHIFTER_CARRY     [i]));
    63         if (param._carry       == external_completion)
    64           if (_param._type_completion_bool == true)
     66        if (param->_carry       == external_completion)
     67          if (_param->_type_completion_bool == true)
    6568            sensitive << (*(in_SHIFTER_CARRY_IN  [i]));
    6669          else
     
    7073#ifdef SYSTEMCASS_SPECIFIC
    7174    // List dependency information
    72     for (uint32_t i=0; i<param._nb_port; i++)
     75    for (uint32_t i=0; i<param->_nb_port; i++)
    7376      {
    7477        (*(out_SHIFTER_DATA [i])) (*(in_SHIFTER_DATA      [i]));
    75         if (param._shift_value == 0)
     78        if (param->_shift_value == 0)
    7679        (*(out_SHIFTER_DATA [i])) (*(in_SHIFTER_SHIFT     [i]));
    77         if (param._direction   == external_direction)
     80        if (param->_direction   == external_direction)
    7881        (*(out_SHIFTER_DATA [i])) (*(in_SHIFTER_DIRECTION [i]));
    79         if (_param._rotate     == external_rotate)
     82        if (_param->_rotate     == external_rotate)
    8083        (*(out_SHIFTER_DATA [i])) (*(in_SHIFTER_TYPE      [i]));
    81         if (param._carry       == external_carry)
     84        if (param->_carry       == external_carry)
    8285        (*(out_SHIFTER_DATA [i])) (*(in_SHIFTER_CARRY     [i]));
    83         if (param._carry       == external_completion)
    84         if (_param._type_completion_bool == true)
     86        if (param->_carry       == external_completion)
     87        if (_param->_type_completion_bool == true)
    8588        (*(out_SHIFTER_DATA [i])) (*(in_SHIFTER_CARRY_IN  [i]));
    8689        else
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Shifter_allocation.cpp

    r81 r82  
    1717  void Shifter::allocation (void)
    1818  {
    19     _component   = new Component ();
     19    _component   = new Component (_usage);
    2020
    2121    Entity * entity = _component->set_entity (_name       
     
    4545    {
    4646      // Interface "shifter"
    47        in_SHIFTER_DATA      = new SC_IN (Tdata_t)      * [_param._nb_port];
    48       if (_param._shift_value == 0)
    49        in_SHIFTER_SHIFT     = new SC_IN (Tshift_t)     * [_param._nb_port];
    50       if (_param._direction   == external_direction)
    51        in_SHIFTER_DIRECTION = new SC_IN (Tdirection_t) * [_param._nb_port];
    52       if (_param._rotate      == external_rotate)
    53        in_SHIFTER_TYPE      = new SC_IN (Ttype_t)      * [_param._nb_port];
    54       if (_param._carry       == external_carry)
    55        in_SHIFTER_CARRY     = new SC_IN (Tcarry_t)     * [_param._nb_port];
    56       if (_param._carry       == external_completion)
    57       if (_param._type_completion_bool == true)
    58        in_SHIFTER_CARRY_IN  = new SC_IN (Tcontrol_t)   * [_param._nb_port];
     47       in_SHIFTER_DATA      = new SC_IN (Tdata_t)      * [_param->_nb_port];
     48      if (_param->_shift_value == 0)
     49       in_SHIFTER_SHIFT     = new SC_IN (Tshift_t)     * [_param->_nb_port];
     50      if (_param->_direction   == external_direction)
     51       in_SHIFTER_DIRECTION = new SC_IN (Tdirection_t) * [_param->_nb_port];
     52      if (_param->_rotate      == external_rotate)
     53       in_SHIFTER_TYPE      = new SC_IN (Ttype_t)      * [_param->_nb_port];
     54      if (_param->_carry       == external_carry)
     55       in_SHIFTER_CARRY     = new SC_IN (Tcarry_t)     * [_param->_nb_port];
     56      if (_param->_carry       == external_completion)
     57      if (_param->_type_completion_bool == true)
     58       in_SHIFTER_CARRY_IN  = new SC_IN (Tcontrol_t)   * [_param->_nb_port];
    5959      else
    60        in_SHIFTER_COMPLETION= new SC_IN (Tdata_t)      * [_param._nb_port];
    61       out_SHIFTER_DATA      = new SC_OUT(Tdata_t)      * [_param._nb_port];
     60       in_SHIFTER_COMPLETION= new SC_IN (Tdata_t)      * [_param->_nb_port];
     61      out_SHIFTER_DATA      = new SC_OUT(Tdata_t)      * [_param->_nb_port];
    6262     
    63       for (uint32_t i=0; i<_param._nb_port; i++)
     63      for (uint32_t i=0; i<_param->_nb_port; i++)
    6464        {
    6565          Interface_fifo * interface = _interfaces->set_interface("shifter_"+toString(i)
     
    7171                                                                  );
    7272         
    73            in_SHIFTER_DATA       [i] = interface->set_signal_in  <Tdata_t     > ("data"      ,_param._size_data);
    74           if (_param._shift_value == 0)
    75            in_SHIFTER_SHIFT      [i] = interface->set_signal_in  <Tshift_t    > ("shift"     ,static_cast<uint32_t>(ceil(log2(_param._size_data))));
    76           if (_param._direction == external_direction)
     73           in_SHIFTER_DATA       [i] = interface->set_signal_in  <Tdata_t     > ("data"      ,_param->_size_data);
     74          if (_param->_shift_value == 0)
     75           in_SHIFTER_SHIFT      [i] = interface->set_signal_in  <Tshift_t    > ("shift"     ,static_cast<uint32_t>(ceil(log2(_param->_size_data))));
     76          if (_param->_direction == external_direction)
    7777           in_SHIFTER_DIRECTION  [i] = interface->set_signal_in  <Tdirection_t> ("direction" ,1);
    78           if (_param._rotate  == external_rotate)
     78          if (_param->_rotate  == external_rotate)
    7979           in_SHIFTER_TYPE       [i] = interface->set_signal_in  <Ttype_t     > ("type"      ,1);
    80           if (_param._carry == external_carry)
     80          if (_param->_carry == external_carry)
    8181           in_SHIFTER_CARRY      [i] = interface->set_signal_in  <Tcarry_t    > ("carry"     ,1);
    82           if (_param._carry       == external_completion)
    83           if (_param._type_completion_bool == true)
     82          if (_param->_carry       == external_completion)
     83          if (_param->_type_completion_bool == true)
    8484           in_SHIFTER_CARRY_IN   [i] = interface->set_signal_in  <Tcontrol_t  > ("carry_in"  ,1);
    8585          else
    86            in_SHIFTER_COMPLETION [i] = interface->set_signal_in  <Tdata_t     > ("completion",_param._size_data_completion);
    87           out_SHIFTER_DATA       [i] = interface->set_signal_out <Tdata_t     > ("data"      ,_param._size_data);
     86           in_SHIFTER_COMPLETION [i] = interface->set_signal_in  <Tdata_t     > ("completion",_param->_size_data_completion);
     87          out_SHIFTER_DATA       [i] = interface->set_signal_out <Tdata_t     > ("data"      ,_param->_size_data);
    8888        }                                                                                                                       
    8989    }
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Shifter_deallocation.cpp

    r81 r82  
    2222
    2323    delete []  in_SHIFTER_DATA      ;
    24     if (_param._shift_value == 0)
     24    if (_param->_shift_value == 0)
    2525    delete []  in_SHIFTER_SHIFT     ;
    26     if (_param._direction   == external_direction )
     26    if (_param->_direction   == external_direction )
    2727    delete []  in_SHIFTER_DIRECTION ;
    28     if (_param._rotate      == external_rotate    )
     28    if (_param->_rotate      == external_rotate    )
    2929    delete []  in_SHIFTER_TYPE      ;
    30     if (_param._carry       == external_carry     )
     30    if (_param->_carry       == external_carry     )
    3131    delete []  in_SHIFTER_CARRY     ;
    32     if (_param._carry       == external_completion)
    33     if (_param._type_completion_bool == true)
     32    if (_param->_carry       == external_completion)
     33    if (_param->_type_completion_bool == true)
    3434    delete []  in_SHIFTER_CARRY_IN  ;
    3535    else
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Shifter_genMealy_shift.cpp

    r81 r82  
    1818  void Shifter::genMealy_shift (void)
    1919  {
    20     for (uint32_t i=0; i<_param._nb_port; i++)
     20    for (uint32_t i=0; i<_param->_nb_port; i++)
    2121      {
    2222        // Read
    2323        Tdata_t      data_in     = PORT_READ(in_SHIFTER_DATA [i]);
    2424        Tdata_t      data_out    = data_in;
    25         Tshift_t     shift_value = _param._shift_value;
     25        Tshift_t     shift_value = _param->_shift_value;
    2626        if (shift_value == 0)
    2727          shift_value = PORT_READ(in_SHIFTER_SHIFT [i]);
    2828
    2929        Tdirection_t direction;
    30         if (_param._direction == external_direction)
     30        if (_param->_direction == external_direction)
    3131          direction = PORT_READ(in_SHIFTER_DIRECTION [i]);
    3232        else
    33           direction = _param._internal_direction;
     33          direction = _param->_internal_direction;
    3434
    3535        Ttype_t      type;
    36         if (_param._rotate    == external_rotate)
     36        if (_param->_rotate    == external_rotate)
    3737          type      = PORT_READ(in_SHIFTER_TYPE      [i]);
    3838        else
    39           type      = _param._internal_type;
     39          type      = _param->_internal_type;
    4040
    4141        Tcarry_t     carry;     
    42         if (_param._carry     == external_carry)
     42        if (_param->_carry     == external_carry)
    4343          carry     = PORT_READ(in_SHIFTER_CARRY     [i]);
    4444        else
    45           carry     = _param._internal_carry;
     45          carry     = _param->_internal_carry;
    4646       
    4747        if (type == _shift)
    4848          {
    49             data_out = shift  <Tdata_t> (_param._size_data, data_in, shift_value, direction == _left, carry == _arithmetic);
     49            data_out = shift  <Tdata_t> (_param->_size_data, data_in, shift_value, direction == _left, carry == _arithmetic);
    5050
    51             if (_param._size_data_completion > 0)
     51            if (_param->_size_data_completion > 0)
    5252              {
    5353                Tdata_t completion;
    5454
    55                 if (_param._type_completion_bool == true)
     55                if (_param->_type_completion_bool == true)
    5656                  completion = (PORT_READ(in_SHIFTER_CARRY_IN   [i])==true)?1:0;
    5757                else
     
    6666                else
    6767                  {
    68                     mask       = gen_mask<Tdata_t> (shift_value)      << (_param._size_data-shift_value);
     68                    mask       = gen_mask<Tdata_t> (shift_value)      << (_param->_size_data-shift_value);
    6969                  }
    7070                 
     
    7373          }
    7474        else
    75           data_out = rotate <Tdata_t> (_param._size_data, data_in, shift_value, direction == _left);
     75          data_out = rotate <Tdata_t> (_param->_size_data, data_in, shift_value, direction == _left);
    7676
    7777        // Write
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Shifter_vhdl_body.cpp

    r81 r82  
    1717  void Shifter::vhdl_body (Vhdl * & vhdl)
    1818  {
    19     //uint32_t log2_size_data = static_cast<uint32_t>(ceil(log2(_param._size_data)));
     19    //uint32_t log2_size_data = static_cast<uint32_t>(ceil(log2(_param->_size_data)));
    2020
    2121    vhdl->set_body ("-- Compute all case of shift");
    2222
    23     for (uint32_t i=0; i<_param._nb_port; i++)
     23    for (uint32_t i=0; i<_param->_nb_port; i++)
    2424      {
    2525        //-----[ Shift logic Left ]--------------------------------------------
    26         if (_param._have_shift_logic_left)
     26        if (_param->_have_shift_logic_left)
    2727          vhdl->set_body ("shift_logic_left_"+toString(i)+"        <= TO_STDLOGICVECTOR(TO_BITVECTOR(in_SHIFTER_"+toString(i)+"_DATA) sll CONV_INTEGER(shift_"+toString(i)+"));");
    2828        //-----[ Shift logic Right ]-------------------------------------------
    29         if (_param._have_shift_logic_right)
     29        if (_param->_have_shift_logic_right)
    3030          vhdl->set_body ("shift_logic_right_"+toString(i)+"       <= TO_STDLOGICVECTOR(TO_BITVECTOR(in_SHIFTER_"+toString(i)+"_DATA) srl CONV_INTEGER(shift_"+toString(i)+"));");
    3131        //-----[ Shift arithmetic Left ]---------------------------------------
    32         if (_param._have_shift_arithmetic_left)
     32        if (_param->_have_shift_arithmetic_left)
    3333          vhdl->set_body ("shift_arithmetic_left_"+toString(i)+"   <= TO_STDLOGICVECTOR(TO_BITVECTOR(in_SHIFTER_"+toString(i)+"_DATA) sla CONV_INTEGER(shift_"+toString(i)+"));");
    3434        //-----[ Shift arithmetic Right ]--------------------------------------
    35         if (_param._have_shift_arithmetic_right)
     35        if (_param->_have_shift_arithmetic_right)
    3636          vhdl->set_body ("shift_arithmetic_right_"+toString(i)+"  <= TO_STDLOGICVECTOR(TO_BITVECTOR(in_SHIFTER_"+toString(i)+"_DATA) sra CONV_INTEGER(shift_"+toString(i)+"));");
    3737        //-----[ Rotate Left ]-------------------------------------------------
    38         if (_param._have_rotate_left)
     38        if (_param->_have_rotate_left)
    3939          vhdl->set_body ("rotate_left_"+toString(i)+"             <= TO_STDLOGICVECTOR(TO_BITVECTOR(in_SHIFTER_"+toString(i)+"_DATA) rol CONV_INTEGER(shift_"+toString(i)+"));");
    4040        //-----[ Rotate Right ]------------------------------------------------
    41         if (_param._have_rotate_right)
     41        if (_param->_have_rotate_right)
    4242          vhdl->set_body ("rotate_right_"+toString(i)+"            <= TO_STDLOGICVECTOR(TO_BITVECTOR(in_SHIFTER_"+toString(i)+"_DATA) ror CONV_INTEGER(shift_"+toString(i)+"));");
    4343      }
    4444
    45     if (_param._size_data_completion > 0)
     45    if (_param->_size_data_completion > 0)
    4646      {
    4747        vhdl->set_body ("");
    4848        vhdl->set_body ("-- Mask");
    4949
    50         for (uint32_t i=0; i<_param._nb_port; i++)
     50        for (uint32_t i=0; i<_param->_nb_port; i++)
    5151          {
    5252            std::string print_shifter_completion;
    5353           
    54             if (_param._type_completion_bool == true)
     54            if (_param->_type_completion_bool == true)
    5555              print_shifter_completion = "in_SHIFTER_"+toString(i)+"_CARRY_IN";
    5656            else
    5757              print_shifter_completion = "in_SHIFTER_"+toString(i)+"_COMPLETION";
    5858
    59             if (_param._size_data == _param._size_data_completion)
     59            if (_param->_size_data == _param->_size_data_completion)
    6060              {
    6161                vhdl->set_body ("shifter_completion_left_"+toString(i)+"  <= "+print_shifter_completion+";");
     
    6464            else
    6565              {
    66                 vhdl->set_body ("shifter_completion_left_"+toString(i)+std_logic_range(_param._size_data-1,_param._size_data_completion)+"  <= "+std_logic_others(_param._size_data-_param._size_data_completion,0)+";");
    67                 vhdl->set_body ("shifter_completion_left_"+toString(i)+std_logic_range(_param._size_data_completion                    )+"  <= "+print_shifter_completion+";");
    68 
    69                 vhdl->set_body ("shifter_completion_right_"+toString(i)+std_logic_range(_param._size_data-1,_param._size_data-_param._size_data_completion)+" <= "+print_shifter_completion+";");
    70                 vhdl->set_body ("shifter_completion_right_"+toString(i)+std_logic_range(_param._size_data-_param._size_data_completion                    )+" <= "+std_logic_others(_param._size_data-_param._size_data_completion,0)+";");
     66                vhdl->set_body ("shifter_completion_left_"+toString(i)+std_logic_range(_param->_size_data-1,_param->_size_data_completion)+"  <= "+std_logic_others(_param->_size_data-_param->_size_data_completion,0)+";");
     67                vhdl->set_body ("shifter_completion_left_"+toString(i)+std_logic_range(_param->_size_data_completion                    )+"  <= "+print_shifter_completion+";");
     68
     69                vhdl->set_body ("shifter_completion_right_"+toString(i)+std_logic_range(_param->_size_data-1,_param->_size_data-_param->_size_data_completion)+" <= "+print_shifter_completion+";");
     70                vhdl->set_body ("shifter_completion_right_"+toString(i)+std_logic_range(_param->_size_data-_param->_size_data_completion                    )+" <= "+std_logic_others(_param->_size_data-_param->_size_data_completion,0)+";");
    7171              }
    7272           
     
    8080    vhdl->set_body ("-- Multiplexor");
    8181
    82     for (uint32_t i=0; i<_param._nb_port; i++)
     82    for (uint32_t i=0; i<_param->_nb_port; i++)
    8383      {
    8484        vhdl->set_body ("out_SHIFTER_"+toString(i)+"_DATA       <=");
     
    8686
    8787        //-----[ Shift arithmetic Left ]---------------------------------------
    88         if (_param._have_shift_arithmetic_left)
    89           {
    90             bool   have_when  = false;
    91             std::string print_when = "";
    92             std::string print_and  = "";
    93            
    94             if (_param._direction   == external_direction)
     88        if (_param->_have_shift_arithmetic_left)
     89          {
     90            bool   have_when  = false;
     91            std::string print_when = "";
     92            std::string print_and  = "";
     93           
     94            if (_param->_direction   == external_direction)
    9595              {
    9696                have_when = true;
     
    9898                print_and = " and ";
    9999              }
    100             if (_param._rotate      == external_rotate)
     100            if (_param->_rotate      == external_rotate)
    101101              {
    102102                have_when = true;
     
    104104                print_and = " and ";
    105105              }
    106             if (_param._carry       == external_carry)
     106            if (_param->_carry       == external_carry)
    107107              {
    108108                have_when = true;
     
    117117          }
    118118        //-----[ Shift arithmetic Right ]--------------------------------------
    119         if (_param._have_shift_arithmetic_right)
    120           {
    121             bool   have_when  = false;
    122             std::string print_when = "";
    123             std::string print_and  = "";
    124            
    125             if (_param._direction   == external_direction)
     119        if (_param->_have_shift_arithmetic_right)
     120          {
     121            bool   have_when  = false;
     122            std::string print_when = "";
     123            std::string print_and  = "";
     124           
     125            if (_param->_direction   == external_direction)
    126126              {
    127127                have_when = true;
     
    129129                print_and = " and ";
    130130              }
    131             if (_param._rotate      == external_rotate)
     131            if (_param->_rotate      == external_rotate)
    132132              {
    133133                have_when = true;
     
    135135                print_and = " and ";
    136136              }
    137             if (_param._carry       == external_carry)
     137            if (_param->_carry       == external_carry)
    138138              {
    139139                have_when = true;
     
    148148          }
    149149        //-----[ Shift logic Left ]--------------------------------------------
    150         if (_param._have_shift_logic_left)
    151           {
    152             bool   have_when  = false;
    153             std::string print_when = "";
    154             std::string print_and  = "";
    155            
    156             if (_param._direction   == external_direction)
     150        if (_param->_have_shift_logic_left)
     151          {
     152            bool   have_when  = false;
     153            std::string print_when = "";
     154            std::string print_and  = "";
     155           
     156            if (_param->_direction   == external_direction)
    157157              {
    158158                have_when = true;
     
    160160                print_and = " and ";
    161161              }
    162             if (_param._rotate      == external_rotate)
     162            if (_param->_rotate      == external_rotate)
    163163              {
    164164                have_when = true;
     
    166166                print_and = " and ";
    167167              }
    168             if (_param._carry       == external_carry)
     168            if (_param->_carry       == external_carry)
    169169              {
    170170                have_when = true;
     
    177177            std::string print_expr_completion;
    178178
    179             if (_param._size_data_completion == 0)
     179            if (_param->_size_data_completion == 0)
    180180              print_expr_completion = "shift_logic_left_"+toString(i)+" ";
    181181            else
     
    186186          }
    187187        //-----[ Shift logic Right ]-------------------------------------------
    188         if (_param._have_shift_logic_right)
    189           {
    190             bool   have_when  = false;
    191             std::string print_when = "";
    192             std::string print_and  = "";
    193            
    194             if (_param._direction   == external_direction)
     188        if (_param->_have_shift_logic_right)
     189          {
     190            bool   have_when  = false;
     191            std::string print_when = "";
     192            std::string print_and  = "";
     193           
     194            if (_param->_direction   == external_direction)
    195195              {
    196196                have_when = true;
     
    198198                print_and = " and ";
    199199              }
    200             if (_param._rotate      == external_rotate)
     200            if (_param->_rotate      == external_rotate)
    201201              {
    202202                have_when = true;
     
    204204                print_and = " and ";
    205205              }
    206             if (_param._carry       == external_carry)
     206            if (_param->_carry       == external_carry)
    207207              {
    208208                have_when = true;
     
    215215            std::string print_expr_completion;
    216216
    217             if (_param._size_data_completion == 0)
     217            if (_param->_size_data_completion == 0)
    218218              print_expr_completion = "shift_logic_right_"+toString(i);
    219219            else
     
    224224          }
    225225        //-----[ Rotate Left ]-------------------------------------------------
    226         if (_param._have_rotate_left)
    227           {
    228             bool   have_when  = false;
    229             std::string print_when = "";
    230             std::string print_and  = "";
    231            
    232             if (_param._direction   == external_direction)
     226        if (_param->_have_rotate_left)
     227          {
     228            bool   have_when  = false;
     229            std::string print_when = "";
     230            std::string print_and  = "";
     231           
     232            if (_param->_direction   == external_direction)
    233233              {
    234234                have_when = true;
     
    236236                print_and = " and ";
    237237              }
    238             if (_param._rotate      == external_rotate)
     238            if (_param->_rotate      == external_rotate)
    239239              {
    240240                have_when = true;
     
    250250          }
    251251        //-----[ Rotate Right ]------------------------------------------------
    252         if (_param._have_rotate_right)
    253           {
    254             bool   have_when  = false;
    255             std::string print_when = "";
    256             std::string print_and  = "";
    257            
    258             if (_param._direction   == external_direction)
     252        if (_param->_have_rotate_right)
     253          {
     254            bool   have_when  = false;
     255            std::string print_when = "";
     256            std::string print_and  = "";
     257           
     258            if (_param->_direction   == external_direction)
    259259              {
    260260                have_when = true;
     
    262262                print_and = " and ";
    263263              }
    264             if (_param._rotate      == external_rotate)
     264            if (_param->_rotate      == external_rotate)
    265265              {
    266266                have_when = true;
     
    281281  /*
    282282  //-----[ Shift logic Left ]--------------------------------------------
    283   if (_param._have_shift_logic_left)
     283  if (_param->_have_shift_logic_left)
    284284    {
    285285
     
    287287
    288288  //-----[ Shift logic Right ]-------------------------------------------
    289   if (_param._have_shift_logic_right)
     289  if (_param->_have_shift_logic_right)
    290290    {
    291291     
     
    293293
    294294  //-----[ Shift arithmetic Left ]---------------------------------------
    295   if (_param._have_shift_arithmetic_left)
     295  if (_param->_have_shift_arithmetic_left)
    296296    {
    297297
     
    299299
    300300  //-----[ Shift arithmetic Right ]--------------------------------------
    301   if (_param._have_shift_arithmetic_right)
     301  if (_param->_have_shift_arithmetic_right)
    302302    {
    303303     
     
    305305 
    306306  //-----[ Rotate Left ]-------------------------------------------------
    307   if (_param._have_rotate_left)
     307  if (_param->_have_rotate_left)
    308308    {
    309309     
     
    311311 
    312312  //-----[ Rotate Right ]------------------------------------------------
    313   if (_param._have_rotate_right)
     313  if (_param->_have_rotate_right)
    314314    {
    315315     
Note: See TracChangeset for help on using the changeset viewer.