1/*****************************************************************************
2
3  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4  more contributor license agreements.  See the NOTICE file distributed
5  with this work for additional information regarding copyright ownership.
6  Accellera licenses this file to you under the Apache License, Version 2.0
7  (the "License"); you may not use this file except in compliance with the
8  License.  You may obtain a copy of the License at
9
10    http://www.apache.org/licenses/LICENSE-2.0
11
12  Unless required by applicable law or agreed to in writing, software
13  distributed under the License is distributed on an "AS IS" BASIS,
14  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15  implied.  See the License for the specific language governing
16  permissions and limitations under the License.
17
18 *****************************************************************************/
19
20/*****************************************************************************
21
22  sc_signal_signed.cpp -- The sc_signal<sc_bigint<W> > implementations.
23
24  Original Author: Andy Goodrich, Forte Design Systems, 2002-10-22
25
26 *****************************************************************************/
27
28/*****************************************************************************
29
30  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
31  changes you are making here.
32
33      Name, Affiliation, Date:
34  Description of Modification:
35
36 *****************************************************************************/
37
38/*
39$Log: scx_signal_signed.h,v $
40Revision 1.1  2011/08/15 17:31:11  acg
41 Andy Goodrich: moved specialized signals from examples to this tree.
42
43Revision 1.2  2011/08/15 16:43:24  acg
44 Torsten Maehne: changes to remove unused argument warnings.
45
46Revision 1.1.1.1  2006/12/15 20:20:03  acg
47SystemC 2.3
48
49Revision 1.2  2005/12/26 20:11:14  acg
50Fixed up copyright.
51
52Revision 1.1.1.1  2005/12/19 23:16:42  acg
53First check in of SystemC 2.1 into its own archive.
54
55Revision 1.17  2005/09/15 23:01:52  acg
56Added std:: prefix to appropriate methods and types to get around
57issues with the Edison Front End.
58
59Revision 1.16  2005/05/03 19:52:26  acg
60Get proper header locations on includes.
61
62Revision 1.15  2005/05/03 19:50:20  acg
63Name space version.
64
65Revision 1.12  2005/04/11 19:05:36  acg
66Change to sc_clock for Microsoft VCC 6.0. Changes for namespaces
67
68Revision 1.11  2005/04/03 22:52:52  acg
69Namespace changes.
70
71Revision 1.10  2005/03/21 22:31:32  acg
72Changes to sc_core namespace.
73
74Revision 1.9  2004/09/27 21:01:59  acg
75Andy Goodrich - Forte Design Systems, Inc.
76   - This is specialized signal support that allows better use of signals
77     and ports whose target value is a SystemC native type.
78
79*/
80
81
82
83#include <systemc>
84
85using sc_dt::sc_bigint;
86using sc_dt::sc_bv_base;
87using sc_dt::sc_lv_base;
88using sc_dt::sc_concatref;
89using sc_dt::sc_signed;
90using sc_dt::sc_signed_subref_r;
91using sc_dt::sc_unsigned;
92using sc_dt::uint64;
93
94#include <typeinfo>
95
96/*****************************************************************************
97
98  sc_signal_signed.h -- The sc_signal<sc_dt::sc_bigint<W> > definitions.
99
100  Original Author: Andy Goodrich, Forte Design Systems, 2002-10-22
101
102 *****************************************************************************/
103
104/*****************************************************************************
105
106  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
107  changes you are making here.
108
109      Name, Affiliation, Date:
110  Description of Modification:
111
112 *****************************************************************************/
113
114/*
115$Log: scx_signal_signed.h,v $
116Revision 1.1  2011/08/15 17:31:11  acg
117 Andy Goodrich: moved specialized signals from examples to this tree.
118
119Revision 1.3  2011/08/15 16:43:24  acg
120 Torsten Maehne: changes to remove unused argument warnings.
121
122Revision 1.2  2011/06/28 21:23:02  acg
123 Andy Goodrich: merging of SCV tree.
124
125Revision 1.1.1.1  2006/12/15 20:20:03  acg
126SystemC 2.3
127
128Revision 1.4  2006/10/23 19:40:35  acg
129 Andy Goodrich: added an explicit dynamic cast to keep gcc 4.x happy.
130
131Revision 1.3  2006/03/21 01:31:48  acg
132 Andy Goodrich: changed over to sc_get_current_process_b() from
133 sc_get_current_process_base() since the function's name changed.
134
135Revision 1.2  2005/12/26 20:11:14  acg
136Fixed up copyright.
137
138Revision 1.1.1.1  2005/12/19 23:16:42  acg
139First check in of SystemC 2.1 into its own archive.
140
141Revision 1.29  2005/09/15 23:01:52  acg
142Added std:: prefix to appropriate methods and types to get around
143issues with the Edison Front End.
144
145Revision 1.28  2005/07/30 03:44:11  acg
146Changes from 2.1.
147
148Revision 1.27  2005/05/09 17:17:12  acg
149Changes from 2.1.
150
151Revision 1.26  2005/05/08 19:04:06  acg
152Fix bug in concat_set(int64,off). Other changes from 2.1 examples usage.
153
154Revision 1.25  2005/05/03 20:05:16  acg
155Prefixed with sc_dt some sc_signed instances that were missed.
156
157Revision 1.24  2005/05/03 19:50:20  acg
158Name space version.
159
160Revision 1.22  2005/03/21 22:31:32  acg
161Changes to sc_core namespace.
162
163Revision 1.21  2005/01/10 17:51:58  acg
164Improvements.
165
166Revision 1.20  2004/11/09 00:11:27  acg
167Added support for sc_generic_base<T> in place of sc_concatref. sc_concatref
168now is derived from sc_generic_base<sc_concatref>.
169
170Revision 1.19  2004/09/27 21:01:59  acg
171Andy Goodrich - Forte Design Systems, Inc.
172   - This is specialized signal support that allows better use of signals
173     and ports whose target value is a SystemC native type.
174
175*/
176
177
178#if !defined(SC_SIGNAL_SIGNED_H)
179#define SC_SIGNAL_SIGNED_H
180
181#if ( !defined(_MSC_VER) || _MSC_VER > 1200 )
182#    define SC_TEMPLATE template<int W>
183#else
184#    define SC_TEMPLATE template<> template<int W>
185#endif
186
187// FORWARD REFERENCES AND USINGS:
188
189using sc_dt::int64;
190
191namespace sc_core {
192
193class sc_signed_sigref;
194
195//==============================================================================
196// CLASS sc_signed_part_if
197//
198// This class provides generic access to part selections for signals whose
199// data type is sc_dt::sc_bigint<W>. This class serves as the base class for the
200// sc_dt::sc_bigint<W> specialization of the sc_signal_in_if<T> class. The methods
201// in this class may be over-ridden individually, those that are not overridden
202// will produce an error message when called. The methods are used by the
203// sc_bigint_sigref class.
204//
205// Notes:
206//   (1) Descriptions of the methods and operators in this class appear with
207//       their implementations in sc_signal<sc_dt::sc_bigint<W> >.
208//==============================================================================
209class sc_signed_part_if : virtual public sc_interface {
210  protected:
211	// constructor:
212  	sc_signed_part_if() {}
213
214  public:
215    // perform a part read.
216	virtual sc_dt::sc_signed* part_read_target();
217  	virtual sc_dt::sc_signed read_part( int left, int right ) const;
218
219    // perform a part write.
220	virtual sc_signed_sigref& select_part( int left, int right );
221    virtual void write_part( sc_dt::int64 v, int left, int right );
222    virtual void write_part( sc_dt::uint64 v, int left, int right );
223    virtual void write_part( const sc_dt::sc_signed& v, int left, int right );
224    virtual void write_part( const sc_dt::sc_unsigned& v, int left, int right );
225
226
227  private:
228  	sc_signed_part_if( const sc_signed_part_if& );
229  	sc_signed_part_if& operator = ( const sc_signed_part_if& );
230};
231
232
233//==============================================================================
234// CLASS sc_signal_in_if<sc_dt::sc_bigint<W> >
235//
236// This is the class specializations for the sc_signal_in_if<T> class to
237// provide additional features for sc_signal instances whose template is
238// sc_dt::sc_bigint<W>, including part access.
239//
240// Notes:
241//   (1) Descriptions of the methods and operators in this class appear with
242//       their implementations in sc_signal<sc_dt::sc_bigint<W> >.
243//==============================================================================
244template< int W >
245class sc_signal_in_if<sc_dt::sc_bigint<W> > : public sc_signed_part_if {
246	friend class sc_signed_sigref;
247  public:
248    typedef sc_signal_in_if<sc_dt::sc_bigint<W> > this_type;
249
250    // get the value changed event
251    virtual const sc_event& value_changed_event() const = 0;
252
253
254    // read the current value
255    virtual const sc_dt::sc_bigint<W>& read() const = 0;
256
257    // get a reference to the current value (for tracing)
258    virtual const sc_dt::sc_bigint<W>& get_data_ref() const = 0;
259
260
261    // was there a value changed event?
262    virtual bool event() const = 0;
263
264  protected:
265    // constructor
266    sc_signal_in_if()
267    {}
268
269  private: // disabled
270    sc_signal_in_if( const this_type& );
271    this_type& operator = ( const this_type& );
272};
273
274//=============================================================================
275//  CLASS : sc_signed_sigref
276//
277//  Proxy class for sc_signal_uint bit and part selection.
278//=============================================================================
279class sc_signed_sigref : public sc_dt::sc_signed_subref_r
280{
281  public:
282    sc_signed_sigref() : sc_dt::sc_signed_subref_r() {}
283    virtual ~sc_signed_sigref() {}
284    virtual void concat_set(sc_dt::int64 src, int low_i);
285    virtual void concat_set(const sc_dt::sc_signed& src, int low_i);
286    virtual void concat_set(const sc_dt::sc_unsigned& src, int low_i);
287    virtual void concat_set(const sc_dt::sc_lv_base& src, int low_i);
288    virtual void concat_set(sc_dt::uint64 src, int low_i);
289
290  public:
291    inline void initialize( sc_signed_part_if* if_p, int left_, int right_ );
292
293  public:
294    inline void operator = ( sc_dt::uint64 v );
295    inline void operator = ( const char* v );
296    inline void operator = ( unsigned long v );
297    inline void operator = ( long v );
298    inline void operator = ( unsigned int v );
299    inline void operator = ( int v );
300    inline void operator = ( sc_dt::int64 v );
301    inline void operator = ( double v );
302    inline void operator = ( const sc_signed_sigref& v );
303    template<typename T>
304    inline void operator = ( const sc_dt::sc_generic_base<T>& v );
305    inline void operator = ( const sc_dt::sc_signed& v );
306    inline void operator = ( const sc_dt::sc_unsigned& v );
307    inline void operator = ( const sc_dt::sc_bv_base& v );
308    inline void operator = ( const sc_dt::sc_lv_base& v );
309
310  public:
311    static sc_vpool<sc_signed_sigref> m_pool; // Pool of objects to use.
312
313  protected:
314    sc_signed_part_if*                m_if_p; // Target for selection.
315
316  private:
317
318    // disabled
319    sc_signed_sigref( const sc_signed_sigref& a );
320};
321
322
323//==============================================================================
324// CLASS sc_signal<sc_dt::sc_bigint<W> >
325//
326// This class implements a signal whose value acts like an sc_dt::sc_bigint<W> data
327// value. This class is a specialization of the generic sc_signal class to
328// implement tailored support for the sc_dt::sc_bigint<W> class.
329//
330// Notes:
331//   (1) Descriptions of the methods and operators in this class appear with
332//       their implementations.
333//==============================================================================
334SC_TEMPLATE
335class sc_signal<sc_dt::sc_bigint<W> > :
336    public sc_dt::sc_bigint<W>,
337	public sc_prim_channel,
338    public sc_signal_inout_if<sc_dt::sc_bigint<W> >
339{
340  public: // typedefs
341    typedef sc_signal<sc_dt::sc_bigint<W> > this_type;
342
343  public: // constructors and destructor:
344    inline sc_signal();
345    explicit inline sc_signal(const char* name_);
346    virtual inline ~sc_signal();
347
348  public: // base methods:
349    inline bool base_event() const;
350    inline const sc_dt::sc_bigint<W>& base_read() const;
351    inline const sc_event& base_value_changed_event() const;
352    inline void base_write( sc_dt::int64 value );
353    inline void base_write( sc_dt::uint64 value );
354    inline void base_write( const sc_dt::sc_signed& value );
355    inline void base_write( const sc_dt::sc_unsigned& value );
356
357  public: // sc_prim_channel virtual methods:
358    virtual inline const char* kind() const;
359    virtual inline void update();
360
361  public: // sc_interface virtual methods:
362    virtual inline const sc_event& default_event() const;
363    virtual inline void register_port(
364		sc_port_base& port_, const char* if_typename_ );
365
366  public: // sc_signed_part_if virtual methods:
367    virtual inline sc_dt::sc_signed* part_read_target();
368    virtual inline sc_dt::sc_signed read_part(int left, int right) const;
369	virtual sc_signed_sigref& select_part( int left, int right );
370	virtual inline void write_part( sc_dt::int64 v, int left, int right );
371	virtual inline void write_part( sc_dt::uint64 v, int left, int right );
372	virtual inline void write_part( const sc_dt::sc_signed& v, int left, int right );
373	virtual inline void write_part(const sc_dt::sc_unsigned& v, int left, int right);
374
375  public: // interface virtual methods:
376    virtual inline bool event() const;
377    virtual inline const sc_dt::sc_bigint<W>& get_data_ref() const;
378    virtual inline sc_signal<sc_dt::sc_bigint<W> >& get_signal();
379    virtual inline const sc_dt::sc_bigint<W>& read() const;
380    virtual inline const sc_event& value_changed_event() const;
381    virtual inline void write( const sc_in<sc_dt::sc_bigint<W> >& value );
382    virtual inline void write( const sc_inout<sc_dt::sc_bigint<W> >& value );
383    virtual inline void write( const sc_dt::sc_bigint<W>& value );
384
385  public: // part selections:
386  	inline sc_signed_sigref& operator () ( int left, int right );
387	// #### Need to add bit() and range()
388  	inline sc_signed_sigref& operator [] ( int bit );
389
390  public: // operators:
391    inline void operator = ( const this_type& new_val );
392    inline void operator = ( const char* new_val );
393    inline void operator = ( sc_dt::uint64 new_val );
394    inline void operator = ( sc_dt::int64 new_val );
395    inline void operator = ( int new_val );
396    inline void operator = ( long new_val );
397    inline void operator = ( short new_val );
398    inline void operator = ( unsigned int new_val );
399    inline void operator = ( unsigned long new_val );
400    inline void operator = ( unsigned short new_val );
401    template<typename T>
402    inline void operator = ( const sc_dt::sc_generic_base<T>& new_val );
403    inline void operator = ( const sc_dt::sc_signed& new_val );
404    inline void operator = ( const sc_dt::sc_unsigned& new_val );
405    inline void operator = ( const sc_dt::sc_bv_base& new_val );
406    inline void operator = ( const sc_dt::sc_lv_base& new_val );
407
408    // concatenation methods (we inherit length and gets from sc_dt::sc_bigint<W>):
409
410    virtual inline void concat_set(sc_dt::int64 src, int low_i);
411    virtual inline void concat_set(const sc_dt::sc_lv_base& src, int low_i);
412    virtual inline void concat_set(const sc_dt::sc_signed& src, int low_i);
413    virtual inline void concat_set(const sc_dt::sc_unsigned& src, int low_i);
414    virtual inline void concat_set(sc_dt::uint64 src, int low_i);
415
416  protected: // debugging methods:
417    // #### void check_port();
418	void check_writer();
419
420  private: // Disabled operations that sc_dt::sc_bigint<W> supports:
421    sc_dt::sc_signed& operator ++ ();          // prefix
422    const sc_dt::sc_signed& operator ++ (int); // postfix
423    sc_dt::sc_signed& operator -- ();          // prefix
424    const sc_dt::sc_signed& operator -- (int); // postfix
425    sc_dt::sc_signed& operator += (const sc_dt::sc_signed&    );
426    sc_dt::sc_signed& operator += (const sc_dt::sc_unsigned&  );
427    sc_dt::sc_signed& operator += (sc_dt::int64               );
428    sc_dt::sc_signed& operator += (sc_dt::uint64              );
429    sc_dt::sc_signed& operator += (long                );
430    sc_dt::sc_signed& operator += (unsigned long       );
431    sc_dt::sc_signed& operator += (int                 );
432    sc_dt::sc_signed& operator += (unsigned int        );
433    sc_dt::sc_signed& operator -= (const sc_dt::sc_signed&    );
434    sc_dt::sc_signed& operator -= (const sc_dt::sc_unsigned&  );
435    sc_dt::sc_signed& operator -= (sc_dt::int64               );
436    sc_dt::sc_signed& operator -= (sc_dt::uint64              );
437    sc_dt::sc_signed& operator -= (long                );
438    sc_dt::sc_signed& operator -= (unsigned long       );
439    sc_dt::sc_signed& operator -= (int                 );
440    sc_dt::sc_signed& operator -= (unsigned int        );
441    sc_dt::sc_signed& operator *= (const sc_dt::sc_signed&    );
442    sc_dt::sc_signed& operator *= (const sc_dt::sc_unsigned&  );
443    sc_dt::sc_signed& operator *= (sc_dt::int64               );
444    sc_dt::sc_signed& operator *= (sc_dt::uint64              );
445    sc_dt::sc_signed& operator *= (long                );
446    sc_dt::sc_signed& operator *= (unsigned long       );
447    sc_dt::sc_signed& operator *= (int                 );
448    sc_dt::sc_signed& operator *= (unsigned int        );
449    sc_dt::sc_signed& operator /= (const sc_dt::sc_signed&    );
450    sc_dt::sc_signed& operator /= (const sc_dt::sc_unsigned&  );
451    sc_dt::sc_signed& operator /= (sc_dt::int64               );
452    sc_dt::sc_signed& operator /= (sc_dt::uint64              );
453    sc_dt::sc_signed& operator /= (long                );
454    sc_dt::sc_signed& operator /= (unsigned long       );
455    sc_dt::sc_signed& operator /= (int                 );
456    sc_dt::sc_signed& operator /= (unsigned int        );
457    sc_dt::sc_signed& operator %= (const sc_dt::sc_signed&    );
458    sc_dt::sc_signed& operator %= (const sc_dt::sc_unsigned&  );
459    sc_dt::sc_signed& operator %= (sc_dt::int64               );
460    sc_dt::sc_signed& operator %= (sc_dt::uint64              );
461    sc_dt::sc_signed& operator %= (long                );
462    sc_dt::sc_signed& operator %= (unsigned long       );
463    sc_dt::sc_signed& operator %= (int                 );
464    sc_dt::sc_signed& operator %= (unsigned int        );
465    sc_dt::sc_signed& operator &= (const sc_dt::sc_signed&    );
466    sc_dt::sc_signed& operator &= (const sc_dt::sc_unsigned&  );
467    sc_dt::sc_signed& operator &= (sc_dt::int64               );
468    sc_dt::sc_signed& operator &= (sc_dt::uint64              );
469    sc_dt::sc_signed& operator &= (long                );
470    sc_dt::sc_signed& operator &= (unsigned long       );
471    sc_dt::sc_signed& operator &= (int                 );
472    sc_dt::sc_signed& operator &= (unsigned int        );
473    sc_dt::sc_signed& operator |= (const sc_dt::sc_signed&    );
474    sc_dt::sc_signed& operator |= (const sc_dt::sc_unsigned&  );
475    sc_dt::sc_signed& operator |= (sc_dt::int64               );
476    sc_dt::sc_signed& operator |= (sc_dt::uint64              );
477    sc_dt::sc_signed& operator |= (long                );
478    sc_dt::sc_signed& operator |= (unsigned long       );
479    sc_dt::sc_signed& operator |= (int                 );
480    sc_dt::sc_signed& operator |= (unsigned int        );
481    sc_dt::sc_signed& operator ^= (const sc_dt::sc_signed&    );
482    sc_dt::sc_signed& operator ^= (const sc_dt::sc_unsigned&  );
483    sc_dt::sc_signed& operator ^= (sc_dt::int64               );
484    sc_dt::sc_signed& operator ^= (sc_dt::uint64              );
485    sc_dt::sc_signed& operator ^= (long                );
486    sc_dt::sc_signed& operator ^= (unsigned long       );
487    sc_dt::sc_signed& operator ^= (int                 );
488    sc_dt::sc_signed& operator ^= (unsigned int        );
489
490  protected:
491    mutable sc_event*  m_changed_event_p; // Value changed event this object.
492    sc_dt::uint64      m_event_delta;     // Delta cycle of last event.
493    sc_dt::sc_signed   m_new_val;         // New value for this object instance.
494    sc_port_base*      m_output_p;        // Single write port verify field.
495    sc_process_b*   m_writer_p;        // Single writer verify field.
496};
497
498
499SC_TEMPLATE // Return true if a changed event happened in the last delta cycle.
500inline bool sc_signal<sc_dt::sc_bigint<W> >::base_event() const
501{
502    return simcontext()->delta_count() == m_event_delta + 1;
503}
504
505
506SC_TEMPLATE // Return this object's sc_dt::sc_bigint<W> object instance.
507inline const sc_dt::sc_bigint<W>& sc_signal<sc_dt::sc_bigint<W> >::base_read() const
508{
509	return *this;
510}
511
512
513SC_TEMPLATE // Return the value changed event, allocating it if necessary.
514inline const sc_event& sc_signal<sc_dt::sc_bigint<W> >::base_value_changed_event() const
515{
516    if ( !m_changed_event_p ) m_changed_event_p = new sc_event;
517    return *m_changed_event_p;
518}
519
520
521SC_TEMPLATE // Write a const sc_dt::sc_signed& value to this object instance.
522inline void sc_signal<sc_dt::sc_bigint<W> >::base_write( const sc_dt::sc_signed& value )
523{
524#   if defined(DEBUG_SYSTEMC)
525        check_writer();
526#   endif
527    m_new_val = value;
528    request_update();
529}
530
531SC_TEMPLATE // Write a const sc_dt::sc_unsigned& value to this object instance.
532inline void sc_signal<sc_dt::sc_bigint<W> >::base_write( const sc_dt::sc_unsigned& value )
533{
534#   if defined(DEBUG_SYSTEMC)
535        check_writer();
536#   endif
537    m_new_val = value;
538    request_update();
539}
540
541SC_TEMPLATE // Write a sc_dt::int64 value to this object instance.
542inline void sc_signal<sc_dt::sc_bigint<W> >::base_write( sc_dt::int64 value )
543{
544#   if defined(DEBUG_SYSTEMC)
545        check_writer();
546#   endif
547    m_new_val = value;
548    request_update();
549}
550
551
552SC_TEMPLATE // Write a sc_dt::uint64 value to this object instance.
553inline void sc_signal<sc_dt::sc_bigint<W> >::base_write( sc_dt::uint64 value )
554{
555#   if defined(DEBUG_SYSTEMC)
556        check_writer();
557#   endif
558    m_new_val = value;
559    request_update();
560}
561
562
563//------------------------------------------------------------------------------
564//"sc_signal<sc_dt::sc_bigint<W> >::check_writer"
565//
566// This method checks to see if there is more than one writer for this
567// object instance by keeping track of the process performing the write.
568//------------------------------------------------------------------------------
569SC_TEMPLATE
570inline void sc_signal<sc_dt::sc_bigint<W> >::check_writer()
571{
572    sc_process_b* writer_p = sc_get_current_process_b();
573    if( m_writer_p == 0 )
574    {
575        m_writer_p = writer_p;
576    }
577    else if( m_writer_p != writer_p )
578    {
579        sc_signal_invalid_writer( name(), kind(),
580                                  m_writer_p->name(), writer_p->name() );
581    }
582}
583
584
585//------------------------------------------------------------------------------
586//"sc_signal<sc_dt::sc_bigint<W> >::concat_set"
587//
588// These virtual methods allow value assignments to this object instance
589// from various sources. The position within the supplied source of the
590// low order bit for this object instance's value is low_i.
591//     src   = source value.
592//     low_i = bit within src to serve as low order bit of this object
593//             instance's value.
594//------------------------------------------------------------------------------
595SC_TEMPLATE
596inline void sc_signal<sc_dt::sc_bigint<W> >::concat_set(sc_dt::int64 src, int low_i)
597{
598    if ( low_i < 64 )
599    {
600        base_write(src >> low_i);
601    }
602    else
603    {
604        base_write( (sc_dt::int64)((src < 0 ) ?  -1 : 0 ));
605    }
606}
607
608SC_TEMPLATE
609inline void sc_signal<sc_dt::sc_bigint<W> >::concat_set(
610	const sc_dt::sc_lv_base& src, int low_i)
611{
612    sc_dt::sc_unsigned tmp(src.length());
613    tmp = src >> low_i;
614    base_write( tmp );
615}
616
617SC_TEMPLATE
618inline void sc_signal<sc_dt::sc_bigint<W> >::concat_set(
619	const sc_dt::sc_signed& src, int low_i)
620{
621    base_write( (src >> low_i) );
622}
623
624SC_TEMPLATE
625inline void sc_signal<sc_dt::sc_bigint<W> >::concat_set(
626	const sc_dt::sc_unsigned& src, int low_i)
627{
628    base_write( (src >> low_i) );
629}
630
631SC_TEMPLATE
632inline void sc_signal<sc_dt::sc_bigint<W> >::concat_set(sc_dt::uint64 src, int low_i)
633{
634	base_write( (sc_dt::uint64)(( low_i < 64 ) ? src >> low_i : 0));
635}
636
637
638
639SC_TEMPLATE // Return the default event for this object instance.
640inline const sc_event& sc_signal<sc_dt::sc_bigint<W> >::default_event() const
641	{ return base_value_changed_event(); }
642
643
644SC_TEMPLATE // Return true if a changed event happened in the last delta cycle.
645inline bool sc_signal<sc_dt::sc_bigint<W> >::event() const
646	{ return base_event(); }
647
648
649SC_TEMPLATE // Return a reference to the value of this object instance.
650inline const sc_dt::sc_bigint<W>& sc_signal<sc_dt::sc_bigint<W> >::get_data_ref() const
651	{ return *this; }
652
653
654SC_TEMPLATE // Return a pointer to this object instance.
655inline sc_signal<sc_dt::sc_bigint<W> >& sc_signal<sc_dt::sc_bigint<W> >::get_signal()
656	{ return *this; }
657
658
659SC_TEMPLATE // Return a kind value of "sc_signal".
660inline const char* sc_signal<sc_dt::sc_bigint<W> >::kind() const
661{
662	return "sc_signal";
663}
664
665
666//------------------------------------------------------------------------------
667//"sc_signal<sc_dt::sc_bigint<W> >::operator ()
668//
669// This operator returns a part selection of this object instance.
670//     left  = left-hand bit of the selection.
671//     right = right-hand bit of the selection.
672//------------------------------------------------------------------------------
673SC_TEMPLATE
674inline sc_signed_sigref& sc_signal<sc_dt::sc_bigint<W> >::operator () (int left, int right)
675{
676    sc_signed_sigref* result_p;   // Value to return.
677
678	result_p = sc_signed_sigref::m_pool.allocate();
679	result_p->initialize(this, left, right);
680	return *result_p;
681}
682
683
684//------------------------------------------------------------------------------
685//"sc_signal<sc_dt::sc_bigint<W> >::operator []"
686//
687// This operator returns a bit selection of this object instance.
688//     i = bit to be selected.
689//------------------------------------------------------------------------------
690SC_TEMPLATE
691inline sc_signed_sigref& sc_signal<sc_dt::sc_bigint<W> >::operator [] ( int bit )
692{
693    return operator () (bit,bit);
694}
695
696
697SC_TEMPLATE
698inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( const this_type& new_val )
699	{ base_write( new_val ); }
700
701SC_TEMPLATE
702inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( const char* new_val )
703	{ sc_dt::sc_bigint<W> tmp = new_val; m_new_val = tmp; request_update(); }
704
705
706SC_TEMPLATE
707inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( sc_dt::uint64 new_val )
708	{ base_write(new_val); }
709
710
711SC_TEMPLATE
712inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( sc_dt::int64 new_val )
713	{ base_write(new_val); }
714
715
716SC_TEMPLATE
717inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( int new_val )
718	{ base_write((sc_dt::int64)new_val); }
719
720
721SC_TEMPLATE
722inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( long new_val )
723	{ base_write((sc_dt::int64)new_val); }
724
725
726SC_TEMPLATE
727inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( short new_val )
728	{ base_write((sc_dt::int64)new_val); }
729
730
731SC_TEMPLATE
732inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( unsigned int new_val )
733	{ base_write((sc_dt::int64)new_val); }
734
735
736SC_TEMPLATE
737inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( unsigned long new_val )
738	{ base_write((sc_dt::int64)new_val); }
739
740
741SC_TEMPLATE
742inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( unsigned short new_val )
743	{ base_write((sc_dt::int64)new_val); }
744
745SC_TEMPLATE
746template<typename T>
747inline void sc_signal<sc_dt::sc_bigint<W> >::operator = (
748    const sc_dt::sc_generic_base<T>& new_val )
749{
750    sc_dt::sc_unsigned temp(W);
751    new_val->to_sc_unsigned(temp);
752    base_write(temp);
753}
754
755SC_TEMPLATE
756inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( const sc_dt::sc_unsigned& new_val )
757	{ base_write(new_val); }
758
759SC_TEMPLATE
760inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( const sc_dt::sc_bv_base& new_val )
761	{ base_write( (sc_dt::sc_bigint<W>)new_val ); }
762
763SC_TEMPLATE
764inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( const sc_dt::sc_lv_base& new_val )
765	{ base_write( (sc_dt::sc_bigint<W>)new_val ); }
766
767
768
769SC_TEMPLATE
770inline void sc_signal<sc_dt::sc_bigint<W> >::operator = ( const sc_dt::sc_signed& new_val )
771	{ base_write(new_val); }
772
773
774SC_TEMPLATE // Return a pointer to the read target for part selections.
775inline sc_dt::sc_signed* sc_signal<sc_dt::sc_bigint<W> >::part_read_target()
776	{ return this; }
777
778SC_TEMPLATE // Return this object's base value as a const reference.
779inline const sc_dt::sc_bigint<W>& sc_signal<sc_dt::sc_bigint<W> >::read() const
780	{ return *this; }
781
782
783SC_TEMPLATE // Read a portion of a value.
784inline sc_dt::sc_signed sc_signal<sc_dt::sc_bigint<W> >::read_part(
785	int left, int right ) const
786{
787    return (sc_dt::sc_signed)sc_dt::sc_signed::operator () (left, right);
788}
789
790SC_TEMPLATE // Register a port for write checking.
791inline void sc_signal<sc_dt::sc_bigint<W> >::register_port(
792	sc_port_base& port_, const char* if_typename_ )
793{
794#       ifdef DEBUG_SYSTEMC
795		std::string nm( if_typename_ );
796		if( nm == typeid( sc_signal_inout_if<sc_dt::sc_bigint<W> > ).name() )
797		{
798			if( m_output_p != 0 )
799			{
800				sc_signal_invalid_writer( name(), kind(),
801					 m_output_p->name(), port_.name() );
802			}
803			m_output_p = &port_;
804		}
805#       else
806            if ( &port_ && if_typename_ ) {} // Silence unused args warning.
807#       endif
808}
809
810
811SC_TEMPLATE // Autogenerated name object instance constructor.
812inline sc_signal<sc_dt::sc_bigint<W> >::sc_signal() :
813	sc_prim_channel(sc_gen_unique_name( "signal" )),
814	m_changed_event_p(0),
815	m_new_val(W),
816	m_output_p(0),
817	m_writer_p(0)
818{ }
819
820
821SC_TEMPLATE // Explicitly named object instance constructor.
822inline sc_signal<sc_dt::sc_bigint<W> >::sc_signal(const char* name_) :
823	sc_prim_channel(name_),
824	m_changed_event_p(0),
825	m_new_val(W),
826	m_output_p(0),
827	m_writer_p(0)
828{ }
829
830
831SC_TEMPLATE // Object instance destructor.
832inline sc_signal<sc_dt::sc_bigint<W> >::~sc_signal()
833{
834	if ( m_changed_event_p ) delete m_changed_event_p;
835}
836
837
838SC_TEMPLATE // Update the current value from new value.
839inline void sc_signal<sc_dt::sc_bigint<W> >::update()
840{
841    if ( m_changed_event_p )
842    {
843        if ( m_new_val != *this )
844        {
845            m_changed_event_p->notify_delayed();
846            m_event_delta = simcontext()->delta_count();
847        }
848    }
849	sc_dt::sc_signed::operator = (m_new_val);
850}
851
852
853SC_TEMPLATE // Return the value changed event.
854inline const sc_event& sc_signal<sc_dt::sc_bigint<W> >::value_changed_event() const
855	{ return base_value_changed_event(); }
856
857
858SC_TEMPLATE // Write a sc_in<sc_dt::sc_bigint<W> > value to this object instance.
859inline void sc_signal<sc_dt::sc_bigint<W> >::write( const sc_in<sc_dt::sc_bigint<W> >& value )
860	{ base_write( value ); }
861
862
863SC_TEMPLATE // Write a sc_inout<sc_dt::sc_bigint<W> > value to this object instance.
864inline void sc_signal<sc_dt::sc_bigint<W> >::write( const sc_inout<sc_dt::sc_bigint<W> >& value )
865	{ base_write( value ); }
866
867
868SC_TEMPLATE // Write a sc_dt::sc_bigint<W> value to this object instance.
869inline void sc_signal<sc_dt::sc_bigint<W> >::write( const sc_dt::sc_bigint<W>& value )
870	{ base_write( value); }
871
872
873SC_TEMPLATE // Select a portion of a value.
874inline sc_signed_sigref& sc_signal<sc_dt::sc_bigint<W> >::select_part(
875    int left, int right)
876{
877    sc_signed_sigref* result_p = sc_signed_sigref::m_pool.allocate();
878    result_p->initialize(dynamic_cast<sc_signed_part_if*>(this), left, right);
879    return *result_p;
880}
881
882
883SC_TEMPLATE // Write a portion of a value. If this is the first write in
884            // a delta cycle we copy the existing value before setting the bits.
885inline void sc_signal<sc_dt::sc_bigint<W> >::write_part(sc_dt::int64 v, int left, int right)
886{
887	m_new_val(left, right) = v;
888	request_update();
889}
890
891
892SC_TEMPLATE // Write a portion of a value. If this is the first write in
893            // a delta cycle we copy the existing value before setting the bits.
894inline void sc_signal<sc_dt::sc_bigint<W> >::write_part(sc_dt::uint64 v, int left, int right)
895{
896	m_new_val(left, right) = v;
897	request_update();
898}
899
900
901SC_TEMPLATE // Write a portion of a value. If this is the first write in
902            // a delta cycle we copy the existing value before setting the bits.
903inline void sc_signal<sc_dt::sc_bigint<W> >::write_part(
904	const sc_dt::sc_signed& v, int left, int right )
905{
906	m_new_val(left, right) = v;
907	request_update();
908}
909
910
911SC_TEMPLATE // Write a portion of a value. If this is the first write in
912            // a delta cycle we copy the existing value before setting the bits.
913inline void sc_signal<sc_dt::sc_bigint<W> >::write_part(
914	const sc_dt::sc_unsigned& v, int left, int right )
915{
916	m_new_val(left, right) = v;
917	request_update();
918}
919
920
921//==============================================================================
922// CLASS sc_in<sc_dt::sc_bigint<W> >
923//
924// This class implements an input port whose target acts like an sc_dt::sc_bigint<W> data
925// value. This class is a specialization of the generic sc_in class to
926// implement tailored support for the sc_dt::sc_bigint<W> class.
927//==============================================================================
928SC_TEMPLATE
929class sc_in<sc_dt::sc_bigint<W> > :
930    public sc_port<sc_signal_in_if<sc_dt::sc_bigint<W> >, 1,
931                   SC_ONE_OR_MORE_BOUND>,
932    public sc_dt::sc_value_base
933{
934  public:
935
936    // typedefs
937
938    typedef sc_dt::sc_bigint<W>                      data_type;
939    typedef sc_signal_in_if<sc_dt::sc_bigint<W> >    if_type;
940    typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND>  base_type;
941    typedef sc_in<sc_dt::sc_bigint<W> >              this_type;
942
943    typedef if_type                                  in_if_type;
944    typedef base_type                                in_port_type;
945    typedef sc_signal_inout_if<sc_dt::sc_bigint<W> > inout_if_type;
946    typedef sc_inout<sc_dt::sc_bigint<W> >           inout_port_type;
947
948  public:
949
950    // bind methods and operators:
951
952    void bind( const in_if_type& interface_ )
953        { sc_port_base::bind( const_cast<in_if_type&>( interface_) );}
954    void operator () ( const in_if_type& interface_ )
955        { sc_port_base::bind( const_cast<in_if_type&>( interface_) );}
956    void bind( in_port_type& parent_ )
957        { sc_port_base::bind(parent_);}
958    void operator () ( in_port_type& parent_ )
959        { sc_port_base::bind(parent_);}
960    void bind( inout_port_type& parent_ )
961        { sc_port_base::bind(parent_);}
962    void operator () ( inout_port_type& parent_ )
963        { sc_port_base::bind(parent_);}
964
965  protected:
966    // called by pbind (for internal use only)
967    virtual inline int vbind( sc_interface& interface_ )
968        {
969            return sc_port_b<if_type>::vbind( interface_ );
970        }
971    virtual inline int vbind( sc_port_base& parent_ )
972        {
973            in_port_type* in_parent = dynamic_cast<in_port_type*>( &parent_ );
974            if( in_parent != 0 ) {
975                sc_port_base::bind( *in_parent );
976                return 0;
977            }
978            inout_port_type* inout_parent = dynamic_cast<inout_port_type*>( &parent_ );
979            if( inout_parent != 0 ) {
980                sc_port_base::bind( *inout_parent );
981                return 0;
982            }
983            // type mismatch
984            return 2;
985        }
986
987
988    // constructors
989
990  public:
991    sc_in()
992        : base_type(), m_traces( 0 )
993        {}
994
995    explicit sc_in( const char* name_ )
996        : base_type( name_ ), m_traces( 0 )
997        {}
998
999    explicit sc_in( const in_if_type& interface_ )
1000        : base_type( const_cast<in_if_type&>( interface_ ) ), m_traces( 0 )
1001        {}
1002
1003    sc_in( const char* name_, const in_if_type& interface_ )
1004        : base_type( name_, const_cast<in_if_type&>( interface_ ) ), m_traces( 0 )
1005        {}
1006
1007    explicit sc_in( in_port_type& parent_ )
1008        : base_type( parent_ ), m_traces( 0 )
1009        {}
1010
1011    sc_in( const char* name_, in_port_type& parent_ )
1012        : base_type( name_, parent_ ), m_traces( 0 )
1013        {}
1014
1015    explicit sc_in( inout_port_type& parent_ )
1016        : base_type(), m_traces( 0 )
1017        { sc_port_base::bind( parent_ ); }
1018
1019    sc_in( const char* name_, inout_port_type& parent_ )
1020        : base_type( name_ ), m_traces( 0 )
1021        { sc_port_base::bind( parent_ ); }
1022
1023    sc_in( this_type& parent_ )
1024        : base_type( parent_ ), m_traces( 0 )
1025        {}
1026
1027    sc_in( const char* name_, this_type& parent_ )
1028        : base_type( name_, parent_ ), m_traces( 0 )
1029        {}
1030
1031
1032    // destructor
1033
1034    virtual inline ~sc_in()
1035        {
1036            remove_traces();
1037        }
1038
1039    // bit and part selection
1040
1041    sc_dt::sc_signed_bitref_r operator [] ( int i ) const
1042        { return (*this)->read()[i]; }
1043    sc_dt::sc_signed_bitref_r bit( int i ) const
1044        { return (*this)->read()[i]; }
1045    sc_dt::sc_signed_subref_r operator () ( int left, int right ) const
1046        { return (*this)->read()(left,right); }
1047    sc_dt::sc_signed_subref_r range( int left, int right ) const
1048        { return (*this)->read()(left,right); }
1049
1050
1051    // interface access shortcut methods
1052
1053    // get the default event
1054
1055    const sc_event& default_event() const
1056        { return (*this)->value_changed_event(); }
1057
1058
1059    // get the value changed event
1060
1061    const sc_event& value_changed_event() const
1062        { return (*this)->value_changed_event(); }
1063
1064
1065    // read the current value
1066
1067    const sc_dt::sc_bigint<W>& read() const
1068        { return (*this)->read(); }
1069
1070    operator const sc_dt::sc_bigint<W>& () const
1071        { return (*this)->read(); }
1072
1073    // was there a value changed event?
1074
1075    bool event() const
1076        { return (*this)->event(); }
1077
1078
1079    // (other) event finder method(s)
1080
1081    sc_event_finder& value_changed() const
1082        {
1083            return *new sc_event_finder_t<in_if_type>(
1084                *this, &in_if_type::value_changed_event );
1085        }
1086
1087
1088
1089    // reduction methods:
1090
1091    inline bool and_reduce() const
1092        { return (*this)->read().and_reduce(); }
1093    inline bool nand_reduce() const
1094        { return (*this)->read().nand_reduce(); }
1095    inline bool nor_reduce() const
1096        { return (*this)->read().nor_reduce(); }
1097    inline bool or_reduce() const
1098        { return (*this)->read().or_reduce(); }
1099    inline bool xnor_reduce() const
1100        { return (*this)->read().xnor_reduce(); }
1101    inline bool xor_reduce() const
1102        { return (*this)->read().xor_reduce(); }
1103
1104
1105    // called when elaboration is done
1106    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
1107    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
1108
1109    virtual inline void end_of_elaboration()
1110        {
1111            if( m_traces != 0 ) {
1112                for( unsigned int i = 0; i < m_traces->size(); ++ i ) {
1113                    sc_trace_params* p = (*m_traces)[i];
1114                    sc_trace( p->tf, read(), p->name );
1115                }
1116                remove_traces();
1117            }
1118        }
1119
1120    virtual inline const char* kind() const
1121        { return "sc_in"; }
1122
1123
1124    // called by sc_trace
1125    void add_trace( sc_trace_file* tf_, const std::string& name_ ) const
1126        {
1127            if( tf_ != 0 ) {
1128                if( m_traces == 0 ) {
1129                    m_traces = new sc_trace_params_vec;
1130                }
1131                m_traces->push_back( new sc_trace_params( tf_, name_ ) );
1132            }
1133        }
1134
1135
1136    // concatenation methods
1137
1138    virtual inline int concat_length(bool* xz_present_p) const
1139        { return (*this)->read().concat_length( xz_present_p ); }
1140    virtual inline sc_dt::uint64 concat_get_uint64() const
1141        { return (*this)->read().concat_get_uint64(); }
1142    virtual inline bool concat_get_ctrl( sc_dt::sc_digit* dst_p, int low_i ) const
1143        { return (*this)->read().concat_get_ctrl(dst_p, low_i); }
1144    virtual inline bool concat_get_data( sc_dt::sc_digit* dst_p, int low_i ) const
1145        { return (*this)->read().concat_get_data(dst_p, low_i); }
1146
1147  protected:
1148    void remove_traces() const
1149        {
1150            if( m_traces != 0 ) {
1151                for( int i = m_traces->size() - 1; i >= 0; -- i ) {
1152                    delete (*m_traces)[i];
1153                }
1154                delete m_traces;
1155                m_traces = 0;
1156            }
1157        }
1158
1159    mutable sc_trace_params_vec* m_traces;
1160
1161
1162  private:
1163
1164    // disabled
1165    sc_in( const sc_in<sc_dt::sc_bigint<W> >& );
1166    sc_in<sc_dt::sc_bigint<W> >& operator = ( const sc_in<sc_dt::sc_bigint<W> >& );
1167
1168#ifdef __GNUC__
1169    // Needed to circumvent a problem in the g++-2.95.2 compiler:
1170    // This unused variable forces the compiler to instantiate
1171    // an object of T template so an implicit conversion from
1172    // read() to a C++ intrinsic data type will work.
1173    static data_type dummy;
1174#endif
1175
1176};
1177
1178
1179
1180SC_TEMPLATE
1181inline std::ostream& operator << (
1182	std::ostream& os, const sc_in<sc_dt::sc_bigint<W> >& a )
1183{
1184    a.read().print( os );
1185    return os;
1186}
1187
1188
1189//==============================================================================
1190// CLASS sc_inout<sc_dt::sc_bigint<W> >
1191//
1192// This class implements an input/output port whose target acts like an
1193// sc_dt::sc_bigint<W> data value. It is derived from the sc_signed_in. This class is a
1194// specialization of the generic sc_inout class to implement tailored support
1195// for the sc_dt::sc_bigint<W> class.
1196//==============================================================================
1197SC_TEMPLATE
1198class sc_inout<sc_dt::sc_bigint<W> > :
1199    public sc_port<sc_signal_inout_if<sc_dt::sc_bigint<W> >, 1,
1200                   SC_ONE_OR_MORE_BOUND>,
1201    public sc_dt::sc_value_base
1202{
1203  public:
1204
1205    // typedefs
1206
1207    typedef sc_dt::sc_bigint<W>                      data_type;
1208    typedef sc_signal_inout_if<sc_dt::sc_bigint<W> > if_type;
1209    typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND>  base_type;
1210    typedef sc_inout<sc_dt::sc_bigint<W> >           this_type;
1211
1212    typedef if_type                                  inout_if_type;
1213    typedef base_type                                inout_port_type;
1214
1215  public:
1216
1217    // bind methods and operators:
1218
1219    void bind( const inout_if_type& interface_ )
1220        { sc_port_base::bind( const_cast<inout_if_type&>( interface_) ); }
1221    void operator () ( const inout_if_type& interface_ )
1222        { sc_port_base::bind( const_cast<inout_if_type&>( interface_) ); }
1223    void bind( inout_port_type& parent_ )
1224        { sc_port_base::bind(parent_); }
1225    void operator () ( inout_port_type& parent_ )
1226        { sc_port_base::bind(parent_); }
1227
1228  protected:
1229    // called by pbind (for internal use only)
1230    virtual inline int vbind( sc_interface& interface_ )
1231        {
1232            return sc_port_b<if_type>::vbind( interface_ );
1233        }
1234    virtual inline int vbind( sc_port_base& parent_ )
1235        {
1236            inout_port_type* inout_parent = dynamic_cast<inout_port_type*>( &parent_ );
1237            if( inout_parent != 0 ) {
1238                sc_port_base::bind( *inout_parent );
1239                return 0;
1240            }
1241            // type mismatch
1242            return 2;
1243        }
1244
1245
1246    // constructors
1247
1248  public:
1249    sc_inout()
1250        : base_type(), m_init_val_p(0), m_traces( 0 )
1251        {}
1252
1253    explicit sc_inout( const char* name_ )
1254        : base_type( name_ ), m_init_val_p(0), m_traces( 0 )
1255        {}
1256
1257    explicit sc_inout( inout_if_type& interface_ )
1258        : base_type( interface_ ), m_init_val_p(0), m_traces( 0 )
1259        {}
1260
1261    sc_inout( const char* name_, inout_if_type& interface_ )
1262        : base_type( name_, interface_ ), m_init_val_p(0), m_traces( 0 )
1263        {}
1264
1265    explicit sc_inout( inout_port_type& parent_ )
1266        : base_type( parent_ ), m_init_val_p(0), m_traces( 0 )
1267        {}
1268
1269    sc_inout( const char* name_, inout_port_type& parent_ )
1270        : base_type( name_, parent_ ), m_init_val_p(0), m_traces( 0 )
1271        {}
1272
1273    sc_inout( this_type& parent_ )
1274        : base_type( parent_ ), m_init_val_p(0), m_traces( 0 )
1275        {}
1276
1277    sc_inout( const char* name_, this_type& parent_ )
1278        : base_type( name_, parent_ ), m_init_val_p(0), m_traces( 0 )
1279        {}
1280
1281
1282    // destructor
1283
1284    virtual inline ~sc_inout()
1285        {
1286            remove_traces();
1287        }
1288
1289    // bit and part selection
1290
1291    sc_dt::sc_signed_bitref_r operator [] ( int i ) const
1292        { return (*this)->read()[i]; }
1293    sc_dt::sc_signed_bitref_r bit( int i ) const
1294        { return (*this)->read()[i]; }
1295    sc_signed_sigref& operator [] ( int i )
1296		{ return (*this)->select_part(i,i); }
1297    sc_signed_sigref& bit( int i )
1298		{ return (*this)->select_part(i,i); }
1299    sc_dt::sc_signed_subref_r operator () ( int left, int right ) const
1300        { return (*this)->read()(left,right); }
1301    sc_dt::sc_signed_subref_r range( int left, int right ) const
1302        { return (*this)->read()(left,right); }
1303    sc_signed_sigref& operator () ( int left, int right )
1304		{ return (*this)->select_part(left,right); }
1305    sc_signed_sigref& range( int left, int right )
1306		{ return (*this)->select_part(left,right); }
1307
1308
1309    // interface access shortcut methods
1310
1311    // get the default event
1312
1313    const sc_event& default_event() const
1314        { return (*this)->value_changed_event(); }
1315
1316
1317    // get the value changed event
1318
1319    const sc_event& value_changed_event() const
1320        { return (*this)->value_changed_event(); }
1321
1322
1323    // read the current value
1324
1325    const sc_dt::sc_bigint<W>& read() const
1326        { return (*this)->read(); }
1327
1328    operator const sc_dt::sc_bigint<W>& () const
1329        { return (*this)->read(); }
1330
1331    // was there a value changed event?
1332
1333    bool event() const
1334        { return (*this)->event(); }
1335
1336
1337    // (other) event finder method(s)
1338
1339    sc_event_finder& value_changed() const
1340        {
1341            return *new sc_event_finder_t<inout_if_type>(
1342                *this, &inout_if_type::value_changed_event );
1343        }
1344
1345
1346
1347    // reduction methods:
1348
1349    inline bool and_reduce() const
1350        { return (*this)->read().and_reduce(); }
1351    inline bool nand_reduce() const
1352        { return (*this)->read().nand_reduce(); }
1353    inline bool nor_reduce() const
1354        { return (*this)->read().nor_reduce(); }
1355    inline bool or_reduce() const
1356        { return (*this)->read().or_reduce(); }
1357    inline bool xnor_reduce() const
1358        { return (*this)->read().xnor_reduce(); }
1359    inline bool xor_reduce() const
1360        { return (*this)->read().xor_reduce(); }
1361
1362
1363    // called when elaboration is done
1364    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
1365    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
1366
1367    virtual inline void end_of_elaboration()
1368        {
1369            if( m_init_val_p != 0 ) {
1370                (*this)->write( *m_init_val_p );
1371                delete m_init_val_p;
1372                m_init_val_p = 0;
1373            }
1374            if( m_traces != 0 ) {
1375                for( unsigned int i = 0; i < m_traces->size(); ++ i ) {
1376                    sc_trace_params* p = (*m_traces)[i];
1377                    sc_trace( p->tf, read(), p->name );
1378                }
1379                remove_traces();
1380            }
1381        }
1382
1383    virtual inline const char* kind() const
1384        { return "sc_inout"; }
1385
1386    // value initialization
1387
1388    inline void initialize( const sc_dt::sc_bigint<W>& value_ )
1389    {
1390        inout_if_type* iface = dynamic_cast<inout_if_type*>( this->get_interface() );
1391        if( iface != 0 ) {
1392            iface->write( value_ );
1393        } else {
1394            if( m_init_val_p == 0 ) {
1395                m_init_val_p = new sc_dt::sc_bigint<W>;
1396            }
1397            *m_init_val_p = value_;
1398        }
1399    }
1400
1401
1402    // called by sc_trace
1403    void add_trace( sc_trace_file* tf_, const std::string& name_ ) const
1404        {
1405            if( tf_ != 0 ) {
1406                if( m_traces == 0 ) {
1407                    m_traces = new sc_trace_params_vec;
1408                }
1409                m_traces->push_back( new sc_trace_params( tf_, name_ ) );
1410            }
1411        }
1412
1413
1414    // concatenation methods
1415
1416    virtual inline int concat_length(bool* xz_present_p) const
1417        { return (*this)->read().concat_length( xz_present_p ); }
1418    virtual inline sc_dt::uint64 concat_get_uint64() const
1419        { return (*this)->read().concat_get_uint64(); }
1420    virtual inline bool concat_get_ctrl( sc_dt::sc_digit* dst_p, int low_i ) const
1421        { return (*this)->read().concat_get_ctrl(dst_p, low_i); }
1422    virtual inline bool concat_get_data( sc_dt::sc_digit* dst_p, int low_i ) const
1423        { return (*this)->read().concat_get_data(dst_p, low_i); }
1424    virtual inline void concat_set(sc_dt::int64 src, int low_i)
1425		{ *this = (src >> ((low_i < 64) ? low_i : 63)); }
1426#if 0 // ####
1427    virtual inline void concat_set(const sc_dt::sc_lv_base& src, int low_i)
1428        { *this = src >> low_i; }
1429#endif // 0 ####
1430    virtual inline void concat_set(const sc_dt::sc_signed& src, int low_i)
1431        { *this = (src >> low_i); }
1432    virtual inline void concat_set(const sc_dt::sc_unsigned& src, int low_i)
1433        { *this = (src >> low_i); }
1434    virtual inline void concat_set(sc_dt::uint64 src, int low_i)
1435        { *this = ((low_i < 64) ? (src >> low_i) : (sc_dt::uint64)0); }
1436
1437
1438  public: // assignment operators:
1439    inline void operator = ( const this_type& new_val )
1440        { (*this)->write( new_val.read() ); }
1441    inline void operator = ( const char* new_val )
1442        { sc_dt::sc_signed aa(W); aa = new_val; (*this)->write( aa ); }
1443    inline void operator = ( sc_dt::uint64 new_val )
1444        { (*this)->write(new_val); }
1445    inline void operator = ( sc_dt::int64 new_val )
1446        { (*this)->write(new_val); }
1447    inline void operator = ( int new_val )
1448        { (*this)->write((sc_dt::int64)new_val); }
1449    inline void operator = ( long new_val )
1450        { (*this)->write((sc_dt::int64)new_val); }
1451    inline void operator = ( short new_val )
1452        { (*this)->write((sc_dt::int64)new_val); }
1453    inline void operator = ( unsigned int new_val )
1454        { (*this)->write((sc_dt::uint64)new_val); }
1455    inline void operator = ( unsigned long new_val )
1456        { (*this)->write((sc_dt::uint64)new_val); }
1457    inline void operator = ( unsigned short new_val )
1458        { (*this)->write((sc_dt::uint64)new_val); }
1459    template<typename T>
1460    inline void operator = ( const sc_dt::sc_generic_base<T>& new_val )
1461        {
1462            sc_dt::sc_unsigned temp(W);
1463            new_val->to_sc_unsigned(temp);
1464            (*this)->write(temp);
1465        }
1466    inline void operator = ( const sc_dt::sc_signed& new_val )
1467        { (*this)->write(new_val); }
1468    inline void operator = ( const sc_dt::sc_unsigned& new_val )
1469        { (*this)->write(new_val); }
1470    inline void operator = ( const sc_dt::sc_bv_base& new_val )
1471        { (*this)->write((sc_dt::sc_bigint<W>)new_val); }
1472    inline void operator = ( const sc_dt::sc_lv_base& new_val )
1473        { (*this)->write((sc_dt::sc_bigint<W>)new_val); }
1474
1475    inline void write( const sc_in<sc_dt::sc_bigint<W> >& new_val )
1476        { (*this)->write( new_val.read() ); }
1477    inline void write( const sc_inout<sc_dt::sc_bigint<W> >& new_val )
1478        { (*this)->write( new_val.read() ); }
1479    inline void write( const sc_dt::sc_bigint<W>& new_val )
1480        { (*this)->write( new_val); }
1481
1482  protected:
1483    void remove_traces() const
1484        {
1485            if( m_traces != 0 ) {
1486                for( int i = m_traces->size() - 1; i >= 0; -- i ) {
1487                    delete (*m_traces)[i];
1488                }
1489                delete m_traces;
1490                m_traces = 0;
1491            }
1492        }
1493
1494    sc_dt::sc_bigint<W>*                m_init_val_p;
1495    mutable sc_trace_params_vec* m_traces;
1496
1497
1498  private:
1499
1500    // disabled
1501    sc_inout( const sc_inout<sc_dt::sc_bigint<W> >& );
1502
1503#ifdef __GNUC__
1504    // Needed to circumvent a problem in the g++-2.95.2 compiler:
1505    // This unused variable forces the compiler to instantiate
1506    // an object of T template so an implicit conversion from
1507    // read() to a C++ intrinsic data type will work.
1508    static data_type dummy;
1509#endif
1510
1511};
1512
1513
1514
1515SC_TEMPLATE
1516inline std::ostream& operator << (
1517	std::ostream& os, const sc_inout<sc_dt::sc_bigint<W> >& a )
1518{
1519    a.read().print( os );
1520    return os;
1521}
1522
1523
1524//==============================================================================
1525// CLASS sc_out<sc_dt::sc_bigint<W> >
1526//
1527// This class implements an output port whose target acts like an
1528// sc_dt::sc_bigint<W> data value. This class is a derivation of sc_inout, since
1529// output ports are really no different from input/output ports.
1530//==============================================================================
1531SC_TEMPLATE
1532class sc_out<sc_dt::sc_bigint<W> > : public sc_inout<sc_dt::sc_bigint<W> >
1533{
1534  public:
1535
1536    // typedefs
1537
1538    typedef sc_dt::sc_bigint<W>                          data_type;
1539
1540    typedef sc_out<data_type>                   this_type;
1541    typedef sc_inout<data_type>                 base_type;
1542
1543    typedef typename base_type::inout_if_type   inout_if_type;
1544    typedef typename base_type::inout_port_type inout_port_type;
1545
1546    // constructors
1547
1548    sc_out()
1549        : base_type()
1550        {}
1551
1552    explicit sc_out( const char* name_ )
1553        : base_type( name_ )
1554        {}
1555
1556    explicit sc_out( inout_if_type& interface_ )
1557        : base_type( interface_ )
1558        {}
1559
1560    sc_out( const char* name_, inout_if_type& interface_ )
1561        : base_type( name_, interface_ )
1562        {}
1563
1564    explicit sc_out( inout_port_type& parent_ )
1565        : base_type( parent_ )
1566        {}
1567
1568    sc_out( const char* name_, inout_port_type& parent_ )
1569        : base_type( name_, parent_ )
1570        {}
1571
1572    sc_out( this_type& parent_ )
1573        : base_type( parent_ )
1574        {}
1575
1576    sc_out( const char* name_, this_type& parent_ )
1577        : base_type( name_, parent_ )
1578        {}
1579
1580
1581    // destructor (does nothing)
1582
1583    virtual inline ~sc_out()
1584        {}
1585
1586
1587    // assignment operators:
1588
1589  public:
1590    inline void operator = ( const this_type& new_val )
1591        { (*this)->write( (const sc_dt::sc_signed&)new_val ); }
1592    inline void operator = ( const char* new_val )
1593        { sc_dt::sc_signed aa(W); aa = new_val; (*this)->write( aa ); }
1594    inline void operator = ( sc_dt::uint64 new_val )
1595        { (*this)->write(new_val); }
1596    inline void operator = ( sc_dt::int64 new_val )
1597        { (*this)->write((sc_dt::uint64)new_val); }
1598    inline void operator = ( int new_val )
1599        { (*this)->write((sc_dt::uint64)new_val); }
1600    inline void operator = ( long new_val )
1601        { (*this)->write((sc_dt::uint64)new_val); }
1602    inline void operator = ( short new_val )
1603        { (*this)->write((sc_dt::uint64)new_val); }
1604    inline void operator = ( unsigned int new_val )
1605        { (*this)->write((sc_dt::uint64)new_val); }
1606    inline void operator = ( unsigned long new_val )
1607        { (*this)->write((sc_dt::uint64)new_val); }
1608    inline void operator = ( unsigned short new_val )
1609        { (*this)->write((sc_dt::uint64)new_val); }
1610    template<typename T>
1611    inline void operator = ( const sc_dt::sc_generic_base<T>& new_val )
1612        {
1613            sc_dt::sc_unsigned temp(W);
1614            new_val->to_sc_unsigned(temp);
1615            (*this)->write(temp);
1616        }
1617    inline void operator = ( const sc_dt::sc_signed& new_val )
1618        { (*this)->write(new_val); }
1619    inline void operator = ( const sc_dt::sc_unsigned& new_val )
1620        { (*this)->write(new_val); }
1621    inline void operator = ( const sc_dt::sc_bv_base& new_val )
1622        { (*this)->write((sc_dt::sc_bigint<W>)new_val); }
1623    inline void operator = ( const sc_dt::sc_lv_base& new_val )
1624        { (*this)->write((sc_dt::sc_bigint<W>)new_val); }
1625
1626  private:
1627
1628    // disabled
1629    sc_out( const this_type& );
1630};
1631
1632
1633
1634//------------------------------------------------------------------------------
1635//"sc_signed_sigref::initialize"
1636//
1637// This method initializes an object instance from the supplied arguments.
1638//     if_p   -> target of this selection.
1639//     left_  =  left-most bit in selection.
1640//     right_ =  right-most bit in selection.
1641//------------------------------------------------------------------------------
1642inline void sc_signed_sigref::initialize(
1643	sc_signed_part_if* if_p, int left_, int right_ )
1644{
1645    m_if_p = if_p;
1646    m_left = left_;
1647    m_right = right_;
1648	m_obj_p = if_p->part_read_target();
1649}
1650
1651
1652//------------------------------------------------------------------------------
1653//"sc_signed_sigref::operator ="
1654//
1655// These operators assign a value to the bits associated with this object
1656// instance within this object instance's target signal.
1657//------------------------------------------------------------------------------
1658inline void sc_signed_sigref::operator = ( sc_dt::uint64 v )
1659{
1660	m_if_p->write_part( v, m_left, m_right );
1661}
1662
1663inline void sc_signed_sigref::operator = ( const char* v )
1664{
1665	sc_dt::sc_signed tmp(length()); tmp = v; *this = tmp;
1666}
1667
1668inline void sc_signed_sigref:: operator = ( sc_dt::int64 v )
1669{
1670    *this = (sc_dt::uint64)v;
1671}
1672
1673inline void sc_signed_sigref:: operator = ( int v )
1674{
1675    *this = (sc_dt::uint64)v;
1676}
1677
1678inline void sc_signed_sigref:: operator = ( long v )
1679{
1680    *this = (sc_dt::uint64)v;
1681}
1682
1683inline void sc_signed_sigref:: operator = ( unsigned int v )
1684{
1685    *this = (sc_dt::uint64)v;
1686}
1687
1688inline void sc_signed_sigref:: operator = ( unsigned long v )
1689{
1690    *this = (sc_dt::uint64)v;
1691}
1692
1693template<typename T>
1694inline void sc_signed_sigref:: operator = ( const sc_dt::sc_generic_base<T>& v )
1695{
1696    sc_dt::sc_unsigned temp(m_left-m_right+1);
1697    v->to_sc_unsigned(temp);
1698    m_if_p->write_part( temp, m_left, m_right );
1699}
1700
1701inline void sc_signed_sigref:: operator = ( const sc_dt::sc_signed& v )
1702{
1703    m_if_p->write_part( v, m_left, m_right );
1704}
1705
1706inline void sc_signed_sigref:: operator = ( const sc_dt::sc_unsigned& v )
1707{
1708    m_if_p->write_part( v, m_left, m_right );
1709}
1710
1711void sc_signed_sigref::operator = ( const sc_signed_sigref& v )
1712{
1713    *this = (sc_dt::sc_unsigned)v;
1714}
1715
1716
1717#undef SC_TEMPLATE
1718} // namespace sc_core
1719#endif // !defined(SC_SIGNAL_SIGNED_H)
1720
1721namespace sc_core {
1722
1723extern
1724void
1725sc_signal_invalid_writer( const char* name,
1726                          const char* kind,
1727                          const char* first_writer,
1728                          const char* second_writer );
1729
1730//------------------------------------------------------------------------------
1731// POOL OF TEMPORARY INSTANCES OF sc_signed_sigref
1732//
1733// This allows use to pass const references for part and bit selections
1734// on sc_signal_signed object instances.
1735//------------------------------------------------------------------------------
1736sc_vpool<sc_signed_sigref> sc_signed_sigref::m_pool(8);
1737
1738
1739//------------------------------------------------------------------------------
1740//"sc_signed_part_if::default methods"
1741//
1742// These versions just produce errors if they are not overloaded but used.
1743//------------------------------------------------------------------------------
1744
1745sc_signed* sc_signed_part_if::part_read_target()
1746{
1747    SC_REPORT_ERROR( SC_ID_OPERATION_ON_NON_SPECIALIZED_SIGNAL_, "int" );
1748    return 0;
1749}
1750sc_signed sc_signed_part_if::read_part( int /*left*/, int /*right*/ ) const
1751{
1752    SC_REPORT_ERROR( SC_ID_OPERATION_ON_NON_SPECIALIZED_SIGNAL_, "int" );
1753    return sc_signed(1);
1754}
1755sc_signed_sigref& sc_signed_part_if::select_part( int /*left*/, int /*right*/ )
1756{
1757    SC_REPORT_ERROR( SC_ID_OPERATION_ON_NON_SPECIALIZED_SIGNAL_, "int" );
1758    return *(sc_signed_sigref*)0;
1759}
1760void sc_signed_part_if::write_part( int64 v, int /*left*/, int /*right*/ )
1761{
1762    SC_REPORT_ERROR( SC_ID_OPERATION_ON_NON_SPECIALIZED_SIGNAL_, "int" );
1763}
1764void sc_signed_part_if::write_part( uint64 v, int /*left*/, int /*right*/ )
1765{
1766    SC_REPORT_ERROR( SC_ID_OPERATION_ON_NON_SPECIALIZED_SIGNAL_, "int" );
1767}
1768void sc_signed_part_if::write_part(
1769    const sc_signed& v, int /*left*/, int /*right*/ )
1770{
1771    SC_REPORT_ERROR( SC_ID_OPERATION_ON_NON_SPECIALIZED_SIGNAL_, "int" );
1772}
1773void sc_signed_part_if::write_part(
1774    const sc_unsigned& v, int /*left*/, int /*right*/ )
1775{
1776    SC_REPORT_ERROR( SC_ID_OPERATION_ON_NON_SPECIALIZED_SIGNAL_, "int" );
1777}
1778
1779
1780//------------------------------------------------------------------------------
1781//"sc_signed_sigref::concate_set"
1782//
1783// These methods assign this object instance's value from the supplied
1784// value starting at the supplied bit within that value.
1785//     src = value to use to set this object instance's value.
1786//     low_i = bit in src that is to be the low order bit of the value to set.
1787// #### OPTIMIZE
1788//------------------------------------------------------------------------------
1789void sc_signed_sigref::concat_set(sc_dt::int64 src, int low_i)
1790{
1791	int64 tmp;
1792	if ( low_i < 63 )
1793		tmp = src >> low_i;
1794	else
1795		tmp = (src < 0) ? -1 : 0;
1796	m_if_p->write_part( tmp, m_left, m_right );
1797}
1798
1799
1800void sc_signed_sigref::concat_set(const sc_signed& src, int low_i)
1801{
1802	m_if_p->write_part( src >> low_i, m_left, m_right );
1803}
1804
1805
1806void sc_signed_sigref::concat_set(const sc_lv_base& src, int low_i)
1807{
1808	sc_unsigned tmp(src.length());
1809	tmp = src;
1810	m_if_p->write_part( tmp >> low_i, m_left, m_right );
1811}
1812
1813
1814void sc_signed_sigref::concat_set(const sc_unsigned& src, int low_i)
1815{
1816	m_if_p->write_part( src >> low_i, m_left, m_right );
1817}
1818
1819
1820void sc_signed_sigref::concat_set(sc_dt::uint64 src, int low_i)
1821{
1822	uint64 tmp = (low_i < 63) ? (src >> low_i) : 0;
1823	m_if_p->write_part( tmp, m_left, m_right );
1824}
1825
1826} // namespace sc_core
1827