sc_signed.h

system C源码 一种替代verilog的语言

    // explicit conversion to character string

    const std::string to_string( sc_numrep numrep = SC_DEC ) const;
    const std::string to_string( sc_numrep numrep, bool w_prefix ) const;


    // Print functions. dump prints the internals of the class.

    void print( ::std::ostream& os = ::std::cout ) const
	{ os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }

    void scan( ::std::istream& is = ::std::cin );

    void dump( ::std::ostream& os = ::std::cout ) const;


  // Functions to find various properties.
  int  length() const { return nbits; }  // Bit width.
  bool iszero() const;                   // Is the number zero?
  bool sign() const;                     // Sign.

   // reduce methods

    bool and_reduce() const;

    bool nand_reduce() const
        { return ( ! and_reduce() ); }

    bool or_reduce() const;

    bool nor_reduce() const
        { return ( ! or_reduce() ); }

    bool xor_reduce() const;

    bool xnor_reduce() const
        { return ( ! xor_reduce() ); }

  // Functions to access individual bits.
  bool test(int i) const;      // Is the ith bit 0 or 1?
  void set(int i);             // Set the ith bit to 1.
  void clear(int i);           // Set the ith bit to 0.
  void set(int i, bool v)      // Set the ith bit to v.
    { if (v) set(i); else clear(i);  }
  void invert(int i)           // Negate the ith bit.
    { if (test(i)) clear(i); else set(i);  }

  // Make the number equal to its mirror image.
  void reverse();

  // Get/set a packed bit representation of the number.
  void get_packed_rep(sc_digit *buf) const;
  void set_packed_rep(sc_digit *buf);

  /*
    The comparison of the old and new semantics are as follows:

    Let s = sc_signed,
        u = sc_unsigned,
        un = { uint64, unsigned long, unsigned int },
        sn = { int64, long, int, char* }, and
        OP = { +, -, *, /, % }.

    Old semantics:                     New semantics:
      u OP u -> u                        u OP u -> u
      s OP u -> u                        s OP u -> s
      u OP s -> u                        u OP s -> s
      s OP s -> s                        s OP s -> s

      u OP un = un OP u -> u             u OP un = un OP u -> u
      u OP sn = sn OP u -> u             u OP sn = sn OP u -> s

      s OP un = un OP s -> s             s OP un = un OP s -> s
      s OP sn = sn OP s -> s             s OP sn = sn OP s -> s

    In the new semantics, the result is u if both operands are u; the
    result is s otherwise. The only exception is subtraction. The result
    of a subtraction is always s.

    The old semantics is like C/C++ semantics on integer types; the
    new semantics is due to the VSIA C/C++ data types standard.
   */

  // ARITHMETIC OPERATORS:

  // ADDition operators:

  friend sc_signed operator + (const sc_unsigned&  u, const sc_signed&    v);
  friend sc_signed operator + (const sc_signed&    u, const sc_unsigned&  v);

  friend sc_signed operator + (const sc_unsigned&  u, int64               v);
  friend sc_signed operator + (const sc_unsigned&  u, long                v);
  friend sc_signed operator + (const sc_unsigned&  u, int                 v)
    { return operator+(u, (long) v); }

  friend sc_signed operator + (int64               u, const sc_unsigned&  v);
  friend sc_signed operator + (long                u, const sc_unsigned&  v);
  friend sc_signed operator + (int                 u, const sc_unsigned&  v)
    { return operator+((long) u, v); }

  friend sc_signed operator + (const sc_signed&    u, const sc_signed&    v);
  friend sc_signed operator + (const sc_signed&    u, int64               v);
  friend sc_signed operator + (const sc_signed&    u, uint64              v);
  friend sc_signed operator + (const sc_signed&    u, long                v);
  friend sc_signed operator + (const sc_signed&    u, unsigned long       v);
  friend sc_signed operator + (const sc_signed&    u, int                 v)
    { return operator+(u, (long) v); }
  friend sc_signed operator + (const sc_signed&    u, unsigned int        v)
    { return operator+(u, (unsigned long) v); }

  friend sc_signed operator + (int64               u, const sc_signed&    v);
  friend sc_signed operator + (uint64              u, const sc_signed&    v);
  friend sc_signed operator + (long                u, const sc_signed&    v);
  friend sc_signed operator + (unsigned long       u, const sc_signed&    v);
  friend sc_signed operator + (int                 u, const sc_signed&    v)
    { return operator+((long) u, v); }
  friend sc_signed operator + (unsigned int        u, const sc_signed&    v)
    { return operator+((unsigned long) u, v); }

  const sc_signed& operator += (const sc_signed&    v);
  const sc_signed& operator += (const sc_unsigned&  v);
  const sc_signed& operator += (int64               v);
  const sc_signed& operator += (uint64              v);
  const sc_signed& operator += (long                v);
  const sc_signed& operator += (unsigned long       v);
  const sc_signed& operator += (int                 v)
    { return operator+=((long) v); }
  const sc_signed& operator += (unsigned int        v)
    { return operator+=((unsigned long) v); }

  friend sc_signed operator + (const sc_unsigned&  u, const sc_int_base&  v);
  friend sc_signed operator + (const sc_int_base&  u, const sc_unsigned&  v);
  friend sc_signed operator + (const sc_signed&    u, const sc_int_base&  v);
  friend sc_signed operator + (const sc_signed&    u, const sc_uint_base& v);
  friend sc_signed operator + (const sc_int_base&  u, const sc_signed&    v);
  friend sc_signed operator + (const sc_uint_base& u, const sc_signed&    v);
  const sc_signed& operator += (const sc_int_base&  v);
  const sc_signed& operator += (const sc_uint_base& v);

  // SUBtraction operators:

  friend sc_signed operator - (const sc_unsigned&  u, const sc_signed&    v);
  friend sc_signed operator - (const sc_signed&    u, const sc_unsigned&  v);

  friend sc_signed operator - (const sc_unsigned&  u, const sc_unsigned&  v);
  friend sc_signed operator - (const sc_unsigned&  u, int64               v);
  friend sc_signed operator - (const sc_unsigned&  u, uint64              v);
  friend sc_signed operator - (const sc_unsigned&  u, long                v);
  friend sc_signed operator - (const sc_unsigned&  u, unsigned long       v);
  friend sc_signed operator - (const sc_unsigned&  u, int                v)
    { return operator-(u, (long) v); }
  friend sc_signed operator - (const sc_unsigned&  u, unsigned int       v)
    { return operator-(u, (unsigned long) v); }

  friend sc_signed operator - (int64               u, const sc_unsigned&  v);
  friend sc_signed operator - (uint64              u, const sc_unsigned&  v);
  friend sc_signed operator - (long                u, const sc_unsigned&  v);
  friend sc_signed operator - (unsigned long       u, const sc_unsigned&  v);
  friend sc_signed operator - (int                 u, const sc_unsigned&  v)
    { return operator-((long) u, v); }
  friend sc_signed operator - (unsigned int        u, const sc_unsigned& v)
    { return operator-((unsigned long) u, v); }

  friend sc_signed operator - (const sc_signed&    u, const sc_signed&    v);
  friend sc_signed operator - (const sc_signed&    u, int64               v);
  friend sc_signed operator - (const sc_signed&    u, uint64              v);
  friend sc_signed operator - (const sc_signed&    u, long                v);
  friend sc_signed operator - (const sc_signed&    u, unsigned long       v);
  friend sc_signed operator - (const sc_signed&    u, int                 v)
    { return operator-(u, (long) v); }
  friend sc_signed operator - (const sc_signed&    u, unsigned int        v)
    { return operator-(u, (unsigned long) v); }

  friend sc_signed operator - (int64               u, const sc_signed&    v);
  friend sc_signed operator - (uint64              u, const sc_signed&    v);
  friend sc_signed operator - (long                u, const sc_signed&    v);
  friend sc_signed operator - (unsigned long       u, const sc_signed&    v);
  friend sc_signed operator - (int                 u, const sc_signed&    v)
    { return operator-((long) u, v); }
  friend sc_signed operator - (unsigned int        u, const sc_signed&    v)
    { return operator-((unsigned long) u, v); }

  const sc_signed& operator -= (const sc_signed&    v);
  const sc_signed& operator -= (const sc_unsigned&  v);
  const sc_signed& operator -= (int64               v);
  const sc_signed& operator -= (uint64              v);
  const sc_signed& operator -= (long                v);
  const sc_signed& operator -= (unsigned long       v);
  const sc_signed& operator -= (int                 v)
    { return operator -= ((long) v); }
  const sc_signed& operator -= (unsigned int        v)
    { return operator -= ((unsigned long) v); }

  friend sc_signed operator - (const sc_unsigned&  u, const sc_int_base&  v);
  friend sc_signed operator - (const sc_unsigned&  u, const sc_uint_base& v);
  friend sc_signed operator - (const sc_int_base&  u, const sc_unsigned&  v);
  friend sc_signed operator - (const sc_uint_base& u, const sc_unsigned&  v);
  friend sc_signed operator - (const sc_signed&    u, const sc_int_base&  v);
  friend sc_signed operator - (const sc_signed&    u, const sc_uint_base& v);
  friend sc_signed operator - (const sc_int_base&  u, const sc_signed&    v);
  friend sc_signed operator - (const sc_uint_base& u, const sc_signed&    v);
  const sc_signed& operator -= (const sc_int_base&  v);
  const sc_signed& operator -= (const sc_uint_base& v);

  // MULtiplication operators:

  friend sc_signed operator * (const sc_unsigned&  u, const sc_signed&    v);
  friend sc_signed operator * (const sc_signed&    u, const sc_unsigned&  v);

  friend sc_signed operator * (const sc_unsigned&  u, int64               v);
  friend sc_signed operator * (const sc_unsigned&  u, long                v);
  friend sc_signed operator * (const sc_unsigned&  u, int                 v)
    { return operator*(u, (long) v); }

  friend sc_signed operator * (int64               u, const sc_unsigned&  v);
  friend sc_signed operator * (long                u, const sc_unsigned&  v);
  friend sc_signed operator * (int                 u, const sc_unsigned&  v)
    { return operator*((long) u, v); }

  friend sc_signed operator * (const sc_signed&  u, const sc_signed&  v);
  friend sc_signed operator * (const sc_signed&  u, int64             v);
  friend sc_signed operator * (const sc_signed&  u, uint64            v);
  friend sc_signed operator * (const sc_signed&  u, long              v);
  friend sc_signed operator * (const sc_signed&  u, unsigned long     v);
  friend sc_signed operator * (const sc_signed&  u, int               v)
    { return operator*(u, (long) v); }
  friend sc_signed operator * (const sc_signed&  u, unsigned int      v)
    { return operator*(u, (unsigned long) v); }

  friend sc_signed operator * (int64             u, const sc_signed&  v);
  friend sc_signed operator * (uint64            u, const sc_signed&  v);
  friend sc_signed operator * (long              u, const sc_signed&  v);
  friend sc_signed operator * (unsigned long     u, const sc_signed&  v);
  friend sc_signed operator * (int               u, const sc_signed&  v)
    { return operator*((long) u, v); }
  friend sc_signed operator * (unsigned int      u, const sc_signed&  v)
    { return operator*((unsigned long) u, v); }

  const sc_signed& operator *= (const sc_signed&    v);
  const sc_signed& operator *= (const sc_unsigned&  v);
  const sc_signed& operator *= (int64               v);
  const sc_signed& operator *= (uint64              v);
  const sc_signed& operator *= (long                v);
  const sc_signed& operator *= (unsigned long       v);
  const sc_signed& operator *= (int                 v)
    { return operator*=((long) v); }
  const sc_signed& operator *= (unsigned int        v)
    { return operator*=((unsigned long) v); }

  friend sc_signed operator * (const sc_unsigned&  u, const sc_int_base&  v);
  friend sc_signed operator * (const sc_int_base&  u, const sc_unsigned&  v);
  friend sc_signed operator * (const sc_signed&    u, const sc_int_base&  v);
  friend sc_signed operator * (const sc_signed&    u, const sc_uint_base& v);
  friend sc_signed operator * (const sc_int_base&  u, const sc_signed&    v);
  friend sc_signed operator * (const sc_uint_base& u, const sc_signed&    v);
  const sc_signed& operator *= (const sc_int_base&  v);
  const sc_signed& operator *= (const sc_uint_base& v);

  // DIVision operators:

  friend sc_signed operator / (const sc_unsigned&  u, const sc_signed&    v);
  friend sc_signed operator / (const sc_signed&    u, const sc_unsigned&  v);

  friend sc_signed operator / (const sc_unsigned&  u, int64               v);
  friend sc_signed operator / (const sc_unsigned&  u, long                v);
  friend sc_signed operator / (const sc_unsigned&  u, int                 v)
    { return operator/(u, (long) v); }

  friend sc_signed operator / (int64               u, const sc_unsigned&  v);
  friend sc_signed operator / (long                u, const sc_unsigned&  v);
  friend sc_signed operator / (int                 u, const sc_unsigned&  v)
    { return operator/((long) u, v); }

  friend sc_signed operator / (const sc_signed&    u, const sc_signed&    v);
  friend sc_signed operator / (const sc_signed&    u, int64               v);
  friend sc_signed operator / (const sc_signed&    u, uint64              v);
  friend sc_signed operator / (const sc_signed&    u, long                v);
  friend sc_signed operator / (const sc_signed&    u, unsigned long       v);
  friend sc_signed operator / (const sc_signed&    u, int                 v)
    { return operator/(u, (long) v); }
  friend sc_signed operator / (const sc_signed&    u, unsigned int        v)
    { return operator/(u, (unsigned long) v); }

  friend sc_signed operator / (int64               u, const sc_signed&    v);
  friend sc_signed operator / (uint64              u, const sc_signed&    v);
  friend sc_signed operator / (long                u, const sc_signed&    v);
  friend sc_signed operator / (unsigned long       u, const sc_signed&    v);
  friend sc_signed operator / (int                 u, const sc_signed&    v)
    { return operator/((long) u, v); }
  friend sc_signed operator / (unsigned int        u, const sc_signed&    v)
    { return operator/((unsigned long) u, v); }

  const sc_signed& operator /= (const sc_signed&    v);
  const sc_signed& operator /= (const sc_unsigned&  v);
  const sc_signed& operator /= (int64               v);
  const sc_signed& operator /= (uint64              v);
  const sc_signed& operator /= (long                v);
  const sc_signed& operator /= (unsigned long       v);
  const sc_signed& operator /= (int                 v)
    { return operator/=((long) v); }
  const sc_signed& operator /= (unsigned int        v)
    { return operator/=((unsigned long) v); }

  friend sc_signed operator / (const sc_unsigned&  u, const sc_int_base&  v);
  friend sc_signed operator / (const sc_int_base&  u, const sc_unsigned&  v);
  friend sc_signed operator / (const sc_signed&    u, const sc_int_base&  v);
  friend sc_signed operator / (const sc_signed&    u, const sc_uint_base& v);
  friend sc_signed operator / (const sc_int_base&  u, const sc_signed&    v);
  friend sc_signed operator / (const sc_uint_base& u, const sc_signed&    v);
  const sc_signed& operator /= (const sc_int_base&  v);
  const sc_signed& operator /= (const sc_uint_base& v);

  // MODulo operators:

  friend sc_signed operator % (const sc_unsigned&  u, const sc_signed&    v);
  friend sc_signed operator % (const sc_signed&    u, const sc_unsigned&  v);

  friend sc_signed operator % (const sc_unsigned&  u, int64               v);
  friend sc_signed operator % (const sc_unsigned&  u, long                v);
  friend sc_signed