00001
00002 #include <string.h>
00003 #include <stdio.h>
00004
00005 #include <string>
00006 #include <iostream>
00007
00008 #include "l1394_quadlet.h"
00009 #include "l1394_message.h"
00010
00011
00012 using std::cout;
00013 using std::endl;
00014
00015
00016 namespace L1394{
00017 Quadlet::Quadlet()
00018 {
00019 memset( quadlet, 0, 4 );
00020 }
00021
00022 Quadlet::Quadlet( const char *quad_buf )
00023 {
00024 memcpy( quadlet, quad_buf, 4 );
00025 }
00026
00027 Quadlet::Quadlet( const u_int32_t quad_int )
00028 {
00029 for( int i = 0; i <= 3; i++ ) {
00030 quadlet[ i ] = ( quad_int >> ( ( 3 - i ) * 8 ) ) & 0xff;
00031 }
00032 }
00033
00034 Quadlet::Quadlet( const string& s )
00035 {
00036 memcpy( quadlet, s.c_str(), 4 );
00037 }
00038
00039 Quadlet::Quadlet( const Quadlet& q )
00040 {
00041 memcpy( quadlet, q.quadlet, 4 );
00042 }
00043
00044
00045 const Quadlet operator+(const Quadlet& q_1, const Quadlet& q_2)
00046 {
00047 return Quadlet( q_1.toInt() + q_2.toInt());
00048 }
00049
00050 const Quadlet operator+(const Quadlet& q_1, const unsigned int q_2)
00051 {
00052 return Quadlet ( q_1.toInt() + q_2);
00053 }
00054
00055 const Quadlet operator-(const Quadlet& q_1, const Quadlet& q_2)
00056 {
00057 return Quadlet( q_1.toInt() - q_2.toInt());
00058 }
00059
00060 const Quadlet operator-(const Quadlet& q_1, const unsigned int q_2)
00061 {
00062 return Quadlet ( q_1.toInt() - q_2);
00063 }
00064
00065 Quadlet&
00066 Quadlet::operator=(const Quadlet& q )
00067 {
00068 if( *this == q ) {
00069 return *this;
00070 }
00071 memcpy( quadlet, q.quadlet, 4 );
00072 return( *this );
00073 }
00074
00075 bool
00076 Quadlet::operator== (const Quadlet& q )
00077 {
00078 return( memcmp( quadlet, q.quadlet, 4 ) ? FALSE : TRUE );
00079 }
00080
00081 bool Quadlet::operator!= (const Quadlet &q)
00082 {
00083 return !(*this == q);
00084 }
00085
00086
00087
00088 u_int32_t
00089 Quadlet::getByte( const int byte ) const
00090 {
00091 if (byte < 0 || byte >3)
00092 {
00093 cout << "L1394 Quadlet: getByte> invalid range" << endl;
00094 return 0;
00095 }
00096 return( static_cast< unsigned int>( quadlet[ byte ] ) );
00097 }
00098
00099 void
00100 Quadlet::setByte( const int byte, const u_int32_t value )
00101 {
00102 if (byte < 0 || byte >3)
00103 {
00104 cout << "L1394 Quadlet: setByte> invalid range" << endl;
00105 return;
00106 }
00107
00108 if( value > 255 ) {
00109 internal::SMessage::getInstance()->errorStream() << "Quadlet > Value out of Range " << endl;
00110 }
00111
00112 quadlet[ byte ] = value;
00113 return;
00114 }
00115
00116 u_int32_t
00117 Quadlet::getBitRange( const int start, const int end ) const
00118 {
00119 if (start > 31 || start < 0)
00120 {
00121 cout << "L1394 Quadlet: getBitRange> invalid start value" << endl;
00122 return 0;
00123 }
00124
00125 if (end > 31 || end < 0)
00126 {
00127 cout << "L1394 Quadlet: getBitRange> invalid end value" << endl;
00128 return 0;
00129 }
00130
00131 if (start > end)
00132 {
00133 cout << "L1394 Quadlet: getBitRange> invalid range" << endl;
00134 return 0;
00135 }
00136
00137
00138 int range = end - start;
00139 unsigned int tmp = toInt();
00140 unsigned int mask = ( range == 31 ) ? 0xffffffff :
00141 ( ( 1 << ( range + 1 ) ) - 1 );
00142
00143 return( ( tmp >> start ) & mask );
00144 }
00145
00146 void
00147 Quadlet::setBitRange( const int start, const int end,
00148 const u_int32_t value )
00149 {
00150 if (start > 31 || start < 0)
00151 {
00152 cout << "L1394 Quadlet: setBitRange> invalid start value" << endl;
00153 return ;
00154 }
00155
00156 if (end > 31 || end < 0)
00157 {
00158 cout << "L1394 Quadlet: setBitRange> invalid end value" << endl;
00159 return ;
00160 }
00161
00162 if (start > end)
00163 {
00164 cout << "L1394 Quadlet: getBitRange> invalid range" << endl;
00165 return;
00166 }
00167
00168 int range = end - start;
00169 int tmpval = value;
00170
00171 u_int32_t mask1 = ( start + range == 31 ) ? 0x0 :
00172 ~( ( 1 << ( start + range + 1 ) ) - 1 );
00173
00174 u_int32_t mask2 = ( start == 31 ) ? mask2 = 0xffffffff :
00175 ( 1 << ( start ) ) - 1;
00176
00177
00178 tmpval &= ( ~( mask1 | mask2 ) >> start );
00179
00180 u_int32_t oldval = toInt();
00181 u_int32_t rs = oldval & mask2;
00182 u_int32_t ls = oldval & mask1;
00183
00184 tmpval <<= start;
00185 fromInt( tmpval | rs | ls );
00186 return;
00187 }
00188
00189 int
00190 Quadlet::getBit( const int location ) const
00191 {
00192 if (location > 31 || location < 0)
00193 {
00194 cout << "L1394 Quadlet: getBit> invalid range" << endl;
00195 return 0;
00196 }
00197 int byte = location / 8;
00198 int bit = location % 8;
00199
00200 return ( (quadlet[ 3 - byte ] & ( 1 << bit )) >> bit);
00201 }
00202
00203 void
00204 Quadlet::setBit( const int location, const int value )
00205 {
00206 if (location > 31 || location < 0)
00207 {
00208 cout << "L1394 Quadlet: setBit > invalid range" << endl;
00209 return;
00210 }
00211
00212 int byte = 3 - ( location / 8 );
00213 int bit = location % 8;
00214 int mask = 1 << bit;
00215
00216 if( value ) {
00217 quadlet[ byte ] |= mask;
00218 } else {
00219 quadlet[ byte ] &= ~mask;
00220 }
00221 return;
00222 }
00223
00224 u_int32_t
00225 Quadlet::toInt() const
00226 {
00227 u_int32_t result = 0;
00228
00229 for( int i = 0; i <= 3; i++ ) {
00230 result += quadlet[ 3 - i ] << ( i * 8 );
00231 }
00232 return( result );
00233 }
00234
00235 void
00236 Quadlet::fromInt( u_int32_t value )
00237 {
00238 for( int i = 0; i <= 3; i++ ) {
00239 quadlet[ 3 - i ] = ( value >> ( i * 8 ) ) & 0xff ;
00240 }
00241 return;
00242 }
00243
00244 string
00245 Quadlet::toString() const
00246 {
00247 char str_buf[ Quadlet_OUTPUTSIZE ];
00248
00249 if( !toCharArray( str_buf, Quadlet_OUTPUTSIZE ) ) {
00250
00251 }
00252 return string( str_buf );
00253 }
00254
00255 char *
00256 Quadlet::toCharArray( char *str_buf, int length ) const
00257 {
00258 snprintf( str_buf, length, "%02x:%02x:%02x:%02x",
00259 quadlet[ 0 ],
00260 quadlet[ 1 ],
00261 quadlet[ 2 ],
00262 quadlet[ 3 ] );
00263 return( str_buf );
00264 }
00265
00266
00267 ostream&
00268 operator<< ( ostream& s, const Quadlet& q)
00269 {
00270 s << q.toString();
00271 return s;
00272 }
00273
00274 istream&
00275 operator>> ( istream& s, Quadlet& q )
00276 {
00277 string str;
00278 const char *c_ptr;
00279
00280 s >> str;
00281
00282 c_ptr = str.c_str();
00283
00284 memcpy( q.quadlet, c_ptr, 4 );
00285 return s;
00286 }
00287
00288 }