Ignore:
Timestamp:
Jan 22, 2013, 4:23:22 PM (11 years ago)
Author:
meunier
Message:

Code formatting in all source files.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • sources/src/sc_port_ext.h

    r47 r52  
    1111|                                                             |
    1212\------------------------------------------------------------*/
     13
    1314#ifndef __SC_PORT_EXT_H__
    1415#define __SC_PORT_EXT_H__
    … …  
    3637//
    3738#if ((__GNUC__ < 3) || (__GNUC_MINOR__ < 4))
    38 #define INLINE __attribute__((always_inline))
     39    #define INLINE __attribute__((always_inline))
    3940#else
    40 /* gcc3.4 doesn't support */
    41 #define INLINE
     41    /* gcc3.4 doesn't support */
     42    #define INLINE
    4243#endif
    4344
    4445#include <list>
    4546
    46 //
     47
    4748namespace sc_core {
    48 //
    49 
    50   using namespace sc_dt;
    51 
    52 const char *get_name        (const tab_t *pointer);
     49
     50using namespace sc_dt;
     51
     52const char * get_name(const tab_t * pointer);
    5353
    5454#define READ_SIGNAL(value_type_,pointer_) \
    5555  ((value_type_&) (*((value_type_*) (pointer_))))
    5656
     57
    5758///////////////////// DEPRECATED
    5859// C ANSI-only since it is needed to link with extern "C"
    5960
    60 extern void bind (sc_port_base&,sc_port_base&);
    61 extern void bind (sc_port_base&,sc_signal_base&);
    62 extern void bind (sc_signal_base &x);
    63 extern void bind (sc_port_base   &x);
     61
     62extern void bind(sc_port_base &, sc_port_base&);
     63extern void bind(sc_port_base &, sc_signal_base&);
     64extern void bind(sc_signal_base & x);
     65extern void bind(sc_port_base & x);
    6466
    6567// KIND STRING
    … …  
    6870extern const char * const sc_out_string; 
    6971
    70 extern "C" void update (void);
    71 
    72 class sc_port_base : public sc_object, public sc_interface
     72extern "C" void update(void);
     73
     74class sc_port_base : public sc_object, public sc_interface {
     75
     76    protected:
     77    typedef sc_port_base base_type;
     78
     79    public:
     80    ///////////
     81    // Internal
     82    const sc_module & get_module() const;
     83    void init();
     84    void check_multiwriting2port() const;
     85    ///////////     
     86
     87    friend std::ostream & operator << (std::ostream &, const sc_port_base &);
     88
     89
     90    // LRM
     91    static const char * const kind_string;
     92    //
     93
     94    sc_port_base();
     95    sc_port_base(const char * name_);
     96    explicit sc_port_base(const sc_port_base & parent_);
     97    /*virtual */~sc_port_base() {};
     98    // bind to a handle
     99    void operator () (method_process_t & func) const;
     100};
     101
     102
     103template < typename T > class sc_port_b : public sc_port_base
    73104{
    74 protected:
    75   typedef sc_port_base                        base_type;
    76 public:
     105};
     106
     107
     108// ----------------------------------------------------------------------------
     109//  CLASS : sc_in< T >
     110//
     111// ----------------------------------------------------------------------------
     112
     113template < typename T >
     114class sc_in : public sc_port_base {
     115
     116    private:
     117    typedef T data_type;
     118    typedef sc_port_base base_type;
     119    typedef sc_in<data_type> this_type;
     120    typedef sc_signal<data_type> signal_type;
     121
     122
     123    ///////////
     124    // Internal
     125    void init();
     126    ///////////
     127
     128    public:
     129    // constructors
     130    sc_in() : base_type() { init(); }
     131
     132    explicit sc_in(const char * name_) : base_type(name_) { init(); }
     133
     134    explicit sc_in(const base_type & parent_) : base_type( parent_ ) { init(); }
     135
     136    /*
     137    // LRM error !
     138    //static const char *const kind_string; this is a template !
     139    */
     140    //  virtual const char *kind () const
     141    //  { return "sc_in"; };
     142
     143    sc_event neg() const { return sc_event(*this, sc_event::NEG); };
     144    sc_event pos() const { return sc_event(*this, sc_event::POS); };
     145
     146    // read the current value
     147    inline const T & read() const INLINE; 
     148    inline operator const T & () const INLINE;
     149
     150    // operateur ==
     151    inline bool operator == (const T & v) INLINE;
     152
     153    // bind to in interface
     154    void operator () (sc_signal<data_type> & s) {
     155        sc_core::bind(*this, s);
     156    }
     157
     158    // binding for hierarchical description
     159    void operator () (this_type & parent_) {
     160        sc_core::bind(*this, parent_);
     161    }
     162
     163    void operator () (sc_out<data_type> & o) {
     164        sc_core::bind(*this, o);
     165    }
     166
     167    /*virtual */~sc_in() {};
     168
     169};
     170
     171
     172template < typename T >
     173void sc_in< T >::init() {
     174    set_kind(sc_in_string);
     175    sc_interface::init(sizeof(data_type));
     176}
     177
     178
     179// read
     180template < typename T > inline
     181const T & sc_in< T >::read() const {
     182#ifdef DUMP_READ
     183    std::cerr << "read " << READ_SIGNAL(const T &, get_pointer())
     184     << " on signal " << name() << "\n";
     185#endif
     186    return READ_SIGNAL(const T, get_pointer());
     187}
     188 
     189
     190template < typename T > inline
     191sc_in< T >::operator const T & () const {
     192    return sc_in< T >::read();
     193}
     194
     195
     196template < typename T > inline
     197bool sc_in< T >::operator == (const T & v) {
     198    return sc_in< T >::read() == v;
     199}
     200
     201
     202
     203// ----------------------------------------------------------------------------
     204//  CLASS : sc_inout< T >
     205//
     206// ----------------------------------------------------------------------------
     207
     208template < typename  T >
     209class sc_inout : public sc_port_base {
     210
    77211  ///////////
    78212  // Internal
    79   const sc_module &get_module () const;
    80   void             init ();
    81   void             check_multiwriting2port () const;
    82   ///////////     
    83  
    84   friend std::ostream& operator << (std::ostream &, const sc_port_base &);
    85  
    86   // LRM
    87   //virtual const sc_event /*&*/ default_event () const;
    88   static const char* const kind_string;
    89 //  virtual const char *kind () const;
    90   //
    91   sc_port_base();
    92   sc_port_base(const char* name_);
    93   explicit sc_port_base(const sc_port_base& parent_);
    94   /*virtual */~sc_port_base () {};
    95   // bind to a handle
    96   void operator () (method_process_t &func) const;
     213    protected:
     214    void init();
     215    T val;
     216
     217    private:
     218    typedef T data_type;
     219
     220    typedef sc_inout<data_type> this_type;
     221    typedef sc_signal<data_type> signal_type;
     222
     223   
     224    public:
     225    // contructeurs
     226    sc_inout() : base_type() { init (); };
     227
     228    explicit sc_inout(const char * name_) : base_type(name_) { init(); };
     229
     230    /*
     231    // LRM error !
     232    //static const char *const kind_string; this is a template !
     233    */
     234
     235    // read the current value
     236    inline const T & read() const INLINE;
     237    // write the new value
     238    inline void write(const T &) INLINE;
     239    template < int W > inline void write(const sc_uint< W > & v) {
     240        sc_inout< T >::write(v.read());
     241    }
     242
     243    inline operator const T & () const INLINE;
     244
     245    inline sc_inout< T > & operator = (const T & a) INLINE;
     246    inline sc_inout< T > & operator = (const sc_signal< T > & a) INLINE;
     247
     248    // operateur ==
     249    inline bool operator == (const bool & v) INLINE;
     250
     251    // bind to in interface
     252    void operator () (sc_signal<data_type> & s) {
     253        bind(*this);
     254        bind(*this, s);
     255    }
     256
     257    void operator () (this_type & parent_) {
     258        bind(*this, parent_);
     259    }
     260
     261    /*virtual */~sc_inout() {};
    97262};
    98263
    99 template < typename T > class sc_port_b:public sc_port_base
    100 {
    101 };
    102 
    103 // ----------------------------------------------------------------------------
    104 //  CLASS : sc_in<T>
    105 //
    106 // ----------------------------------------------------------------------------
    107 
    108 template <typename T>
    109 class sc_in : public sc_port_base
    110 {
    111 private:
    112   typedef T  data_type;
    113   typedef sc_port_base                  base_type;
    114   typedef sc_in<data_type>              this_type;
    115   typedef sc_signal<data_type>          signal_type;
    116 
    117   ///////////
    118   // Internal
    119   void init ();
    120   /*
    121   public: virtual size_t data_size () const
    122   { return sizeof (data_type); }
    123   */
    124   ///////////
    125 public:
    126   // constructors
    127   sc_in(): base_type() { init (); }
    128 
    129   explicit sc_in(const char* name_): base_type(name_) { init (); }
    130 
    131   explicit sc_in(const base_type& parent_ ): base_type( parent_ ) { init (); }
    132 
    133   /*
    134   // LRM error !
    135   //static const char *const kind_string; this is a template !
    136   */
    137 //  virtual const char *kind () const
    138 //  { return "sc_in"; };
    139  
    140 #if 0
    141   // LRM
    142   sc_event_finder& neg () const { return *new sc_event_finder (*(sc_port_base*)this);};
    143   sc_event_finder& pos () const { return *new sc_event_finder (*(sc_port_base*)this);};
    144 #endif
    145 
    146   sc_event         neg () const { return sc_event (*this, sc_event::NEG);};
    147   sc_event         pos () const { return sc_event (*this, sc_event::POS);};
    148   // read the current value
    149   inline const T& read() const INLINE; 
    150   inline operator const T& () const INLINE;
    151 
    152   // operateur ==
    153   inline bool operator == (const T& v) INLINE;
    154 
    155   // bind to in interface
    156   void operator () (sc_signal<data_type> &s)
    157   { sc_core::bind (*this,s); }
    158  
    159   // binding for hierarchical description
    160   void operator () (this_type &parent_) 
    161   { sc_core::bind (*this,parent_); }
    162 
    163   void operator () (sc_out<data_type> &o)
    164   { sc_core::bind (*this,o); }
    165 
    166   /*virtual */~sc_in() {};
    167 
    168 };
    169 
    170 template <typename T>
    171 void
    172 sc_in<T>::init()
    173 {
    174   set_kind (sc_in_string);
    175   sc_interface::init (sizeof (data_type));
    176 }
    177 
    178 // read
    179 template <typename T> inline
    180 const T&
    181 sc_in<T>::read() const
    182 {
    183 #ifdef DUMP_READ
    184   std::cerr << "read " << READ_SIGNAL(const T&, get_pointer())
    185      << " on signal " << name () << "\n";
    186 #endif
    187   return READ_SIGNAL(const T, get_pointer());
    188 }
    189  
    190 template <typename T> inline
    191 sc_in<T>::operator const T& () const
    192 { return sc_in<T>::read (); }
    193 
    194 template <typename T> inline
    195 bool sc_in<T>::operator == (const T& v) {
    196   return sc_in<T>::read() == v;
    197 }
    198 
    199 // ----------------------------------------------------------------------------
    200 //  CLASS : sc_inout<T>
    201 //
    202 // ----------------------------------------------------------------------------
    203 
    204 template <typename T>
    205 class sc_inout : public sc_port_base
    206 {
    207   ///////////
    208   // Internal
    209 protected:
    210   void init ();
    211   T val;
    212 private:
    213   typedef T                                   data_type;
    214 
    215   typedef sc_inout<data_type>                 this_type;
    216   typedef sc_signal<data_type>                signal_type;
    217 
    218   /*
    219   public: virtual size_t data_size () const
    220   { return sizeof (data_type); }
    221   */
    222   ///////////
    223 public:
    224   // contructeurs
    225   sc_inout(): base_type() { init (); };
    226 
    227   explicit sc_inout(const char* name_): base_type(name_) { init (); };
    228 
    229   /*
    230   // LRM error !
    231   //static const char *const kind_string; this is a template !
    232   */
    233   //virtual const char *kind () const
    234   //{ return "sc_inout"; };
    235  
    236   // read the current value
    237   inline const T& read() const INLINE;
    238   // write the new value
    239   inline void write( const T& ) INLINE;
    240   template <int W> inline void write( const sc_uint<W>& v)
    241   { sc_inout<T>::write (v.read()); }
    242 
    243   inline operator const T& () const INLINE;
    244 
    245   inline sc_inout<T>& operator = ( const T& a ) INLINE;
    246  
    247   inline sc_inout<T>& operator = ( const sc_signal<T>& a ) INLINE;
    248 
    249 //  inline sc_inout<T>& operator = ( const sc_port_base& a ) INLINE;
    250 
    251   // operateur ==
    252   inline bool operator == (const bool& v) INLINE;
    253 
    254   // bind to in interface
    255   void operator () (sc_signal<data_type> &s)
    256   { bind (*this); bind (*this,s); }
    257  
    258   void operator () (this_type &parent_)
    259   { bind (*this,parent_); }
    260 
    261   /*virtual */~sc_inout() {};
    262 };
    263 
    264 template <typename T>
    265 void
    266 sc_inout<T>::init ()
    267 {
    268   set_pointer ((tab_t*)(void*)&val);
    269   sc_object::set_kind    (sc_inout_string);
    270   sc_interface::init (sizeof (data_type));
    271   /*ref*/ val = (0);
    272   //sc_inout::write (0);
     264
     265template < typename T >
     266void sc_inout< T >::init() {
     267    set_pointer((tab_t *) (void *) &val);
     268    sc_object::set_kind(sc_inout_string);
     269    sc_interface::init(sizeof(data_type));
     270    /*ref*/ val = (0);
     271    //sc_inout::write (0);
    273272    /* Fix :
    274273     * FSM checker generates an error at runtime
    … …  
    277276}
    278277
     278
    279279// read
    280 template <typename T>
    281 inline
    282 const T&
    283 sc_inout<T>::read() const
    284 {
     280template < typename T >
     281inline const T & sc_inout< T >::read() const {
    285282#ifdef DUMP_READ
    286   std::cerr << "read " << READ_SIGNAL(const T, get_pointer()) // val
    287      << " on signal " << name () << "\n";
    288 #endif
    289 //  return val;
    290   return READ_SIGNAL(const T, get_pointer());
    291 }
     283    std::cerr << "read " << READ_SIGNAL(const T, get_pointer()) // val
     284        << " on signal " << name () << "\n";
     285#endif
     286    //  return val;
     287    return READ_SIGNAL(const T, get_pointer());
     288}
     289
    292290
    293291// write the new value
    294 template <typename T>
    295 inline
    296 void
    297 sc_inout<T>::write( const T& value_ )
    298 {
     292template < typename T >
     293inline void sc_inout< T >::write(const T & value_) {
    299294#ifdef DUMP_WRITE
    300   std::cerr << "write " << value_
    301             << " on in/out port (writing into a signal) '" << name () << "'\n";
    302 #endif
    303 //  T& ref = *(T*)(get_pointer());
     295    std::cerr << "write " << value_ << " on in/out port (writing into a signal) '" << name() << "'\n";
     296#endif
     297    //  T& ref = *(T*)(get_pointer());
    304298#ifndef USE_PORT_DEPENDENCY
    305   unstable |= (value_) != val; //ref;
    306 #endif
    307   /*ref*/ val = (value_);
    308 }
    309 
    310 template <typename T>
    311 inline
    312 sc_inout<T>::operator const T& () const
    313 { return sc_inout<T>::read(); }
    314 
    315 template <typename T>
    316 inline sc_inout<T>& sc_inout<T>::operator = ( const T& a )
    317 { sc_inout<T>::write( a ); return *this; }
    318 
    319 template <typename T>
    320 inline
    321 sc_inout<T>& sc_inout<T>::operator = ( const sc_signal<T>& a )
    322 { sc_inout<T>::write( a.read() ); return *this; }
     299    unstable |= (value_) != val; //ref;
     300#endif
     301    /*ref*/ val = (value_);
     302}
     303
     304
     305template < typename T >
     306inline sc_inout< T >::operator const T & () const {
     307    return sc_inout< T >::read();
     308}
     309
     310
     311template < typename T >
     312inline sc_inout< T > & sc_inout< T >::operator = (const T & a) {
     313    sc_inout< T >::write(a);
     314    return *this;
     315}
     316
     317
     318template < typename T >
     319inline sc_inout< T > & sc_inout< T >::operator = (const sc_signal< T > & a) {
     320    sc_inout< T >::write(a.read());
     321    return *this;
     322}
     323
     324
    323325/*
    324 template <typename T>
    325 inline
    326 sc_inout<T>& sc_inout<T>::operator = ( const sc_port_base& a )
    327 { write( a.read() ); return *this; }
    328 */
    329 template <typename T>
    330 inline
    331 bool sc_inout<T>::operator == (const bool& v)
    332 { return sc_inout<T>::read() == v; }
     326   template <typename T>
     327   inline
     328   sc_inout<T>& sc_inout<T>::operator = ( const sc_port_base& a )
     329   { write( a.read() ); return *this; }
     330   */
     331
     332
     333template < typename T > inline
     334bool sc_inout< T >::operator == (const bool & v) {
     335    return sc_inout< T >::read() == v;
     336}
     337
    333338
    334339// ----------------------------------------------------------------------------
    … …  
    340345// For debugging reasons, a class is provided instead of a define."
    341346
    342 template <typename T>
    343 class sc_out : public sc_inout<T>
    344 {
    345   ///////////
    346   // Internal
    347   void init ();
    348   ///////////
    349 public:
    350   // typedefs
    351   typedef T data_type;
    352   typedef sc_inout<T> base_type;
    353   typedef sc_out<data_type>      this_type;
    354   typedef sc_signal<data_type>   signal_type;
    355 public:
    356   // constructors & destructor
    357   sc_out(): base_type() { init (); };
    358   explicit sc_out(const char* name_): base_type(name_) { init (); };
    359   sc_out (this_type & parent_);
    360   sc_out (const char *name_, this_type & parent_);
    361 
    362   /*
    363   // LRM error !
    364   //static const char *const kind_string; this is a template !
    365   */
    366   //virtual const char *kind () const
    367   //{ return "sc_out"; };
    368  
    369 
    370   inline this_type& operator = ( const data_type& a ) INLINE;
    371   inline bool operator == (const bool& v) INLINE;
    372 
    373   // bind to in interface
    374   void operator () (sc_signal<data_type> &s)
    375   { bind (*this,s); }
     347template < typename T >
     348class sc_out : public sc_inout< T > {
     349
     350    ///////////
     351    // Internal
     352    void init();
     353    ///////////
    376354 
    377   void operator () (this_type &parent_)
    378   { bind (*this,parent_); }
    379 
    380   //////////////////////
    381   // Systemcass specific
    382   void operator () (sc_port_base &o)
    383   { set_port_dependency (&o, (sc_port_base&)(*this)); }
    384 /*
    385   void operator () () // n'a pas de sens...
    386   { set_port_dependency (NULL, (sc_port_base&)(*this)); }
    387 */
    388   //////////////////////
    389 
    390 
    391   /*virtual */~ sc_out () {};
    392 
    393 private:
    394   // disabled
    395   sc_out (const this_type &);
     355    public:
     356    typedef T data_type;
     357    typedef sc_inout< T > base_type;
     358    typedef sc_out<data_type> this_type;
     359    typedef sc_signal<data_type> signal_type;
     360
     361
     362    // constructors & destructor
     363    sc_out() : base_type() {
     364        init();
     365    }
     366
     367    explicit sc_out(const char * name_) : base_type(name_) {
     368        init();
     369    }
     370
     371    sc_out(this_type & parent_);
     372    sc_out(const char * name_, this_type & parent_);
     373
     374    /*
     375    // LRM error !
     376    //static const char *const kind_string; this is a template !
     377    */
     378    //virtual const char *kind () const
     379    //{ return "sc_out"; };
     380
     381
     382    inline this_type & operator = (const data_type & a) INLINE;
     383    inline bool operator == (const bool & v) INLINE;
     384
     385    // bind to in interface
     386    void operator () (sc_signal<data_type> & s) {
     387        bind(*this, s);
     388    }
     389
     390    void operator () (this_type & parent_) {
     391        bind(*this, parent_);
     392    }
     393
     394    //////////////////////
     395    // Systemcass specific
     396    void operator () (sc_port_base & o) {
     397        set_port_dependency(&o, (sc_port_base &) (*this));
     398    }
     399    //////////////////////
     400
     401
     402    /*virtual */~sc_out() {};
     403
     404    private:
     405    // disabled
     406    sc_out(const this_type &);
     407
    396408};
    397409
    398 //
    399 template<typename T>
    400 void
    401 sc_out<T>::init ()
    402 {
    403   sc_inout<T>::init ();
    404 //  tab_t *t = &(sc_inout<T>::val);
    405 //  sc_interface::set_pointer (t);
    406   sc_object::set_kind (sc_out_string);
    407 //  sc_interface::init (sizeof (data_type));
    408 //  /*ref*/ sc_inout<T>::val = 0;
    409   //sc_inout<T>::write (0);
     410
     411
     412template< typename T >
     413void sc_out< T >::init() {
     414    sc_inout< T >::init();
     415    //  tab_t *t = &(sc_inout<T>::val);
     416    //  sc_interface::set_pointer (t);
     417    sc_object::set_kind(sc_out_string);
     418    //  sc_interface::init (sizeof (data_type));
     419    //  /*ref*/ sc_inout<T>::val = 0;
     420    //sc_inout<T>::write (0);
    410421    /* Fix :
    411422     * FSM checker generates an error at runtime
    … …  
    413424}
    414425
    415 template<typename T> inline
    416 sc_out<T>&
    417 sc_out<T>::operator = ( const data_type& a )
    418 { sc_out<T>::write( a ); return *this; }
    419 
    420 template<typename T> inline
    421 bool
    422 sc_out<T>::operator == (const bool& v)
    423 { return sc_out<T>::read() == v; }
     426
     427template< typename T >
     428inline sc_out< T > & sc_out< T >::operator = (const data_type & a) {
     429    sc_out< T >::write(a);
     430    return *this;
     431}
     432
     433
     434template< typename T >
     435inline bool sc_out< T >::operator == (const bool & v) {
     436    return sc_out< T >::read() == v;
     437}
     438
    424439
    425440// Dumps
    426 template<typename T> inline
    427 std::ostream& operator<<( std::ostream& os, const sc_in<T> &r)
    428 { return os << r.read (); }
     441template< typename T >
     442inline std::ostream & operator << ( std::ostream & os, const sc_in< T > & r) {
     443    return os << r.read();
     444}
     445
    429446
    430447// Add '&'
    431 template<class T> inline
    432 std::ostream& operator<<( std::ostream& os, const sc_inout<T> &r)
    433 { return os << r.read (); }
    434 
    435 template<class T> inline
    436 std::ostream& operator<<( std::ostream& os, const sc_signal<T> &r)
    437 { return os << r.read (); }
     448template< class T >
     449inline std::ostream & operator << ( std::ostream & os, const sc_inout< T > & r) {
     450    return os << r.read();
     451}
     452
     453
     454template< class T >
     455inline std::ostream & operator << ( std::ostream & os, const sc_signal< T > & r) {
     456    return os << r.read();
     457}
     458
    438459
    439460// Declarations
    … …  
    449470
    450471#endif /* __SC_PORT_EXT_H__ */
     472
     473/*
     474# Local Variables:
     475# tab-width: 4;
     476# c-basic-offset: 4;
     477# c-file-offsets:((innamespace . 0)(inline-open . 0));
     478# indent-tabs-mode: nil;
     479# End:
     480#
     481# vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
     482*/
     483
Note: See TracChangeset for help on using the changeset viewer.