1293 !LargeInteger methodsFor:'bit operators-32bit'!

  1294 

  1295 bitInvert32

  1296     "return the value of the receiver with all bits inverted in 32bit signed int space

  1297      (changes the sign)"

  1298 

  1299 %{  /* NOCONTEXT */

  1300     unsigned INT v;

  1301 

  1302     v = __unsignedLongIntVal(self);

  1303     v = ~v;

  1304 #if __POINTER_SIZE__ == 8

  1305     v &= 0xFFFFFFFFL;

  1306 #endif

  1307     RETURN ( __MKUINT(v) );

  1308 %}.

  1309     ^ self primitiveFailed

  1310 

  1311     "

  1312      16r80000000 bitInvert32 hexPrintString

  1313      16r7FFFFFFF bitInvert32 hexPrintString

  1314      16rFFFFFFFF bitInvert32 hexPrintString

  1315      0 bitInvert32 hexPrintString

  1316     "

  1317 !

  1318 

  1319 bitRotate32:shiftCount

  1320     "return the value of the receiver rotated by shiftCount bits,

  1321      but only within 32 bits, rotating left for positive, right for negative counts.

  1322      Rotates through the sign bit.

  1323      Useful for crypt algorithms, or to emulate C/Java semantics."

  1324 

  1325 %{  /* NOCONTEXT */

  1326 

  1327     unsigned INT bits;

  1328     int count;

  1329 

  1330     if (__isSmallInteger(shiftCount)) {

  1331         count = __intVal(shiftCount);

  1332         count = count % 32;

  1333 

  1334         bits = __unsignedLongIntVal(self);

  1335         if (count > 0) {

  1336             bits = (bits << count) | (bits >> (32-count));

  1337         } else {

  1338             bits = (bits >> (-count)) | (bits << (32-(-count)));

  1339         }

  1340 #if __POINTER_SIZE__ == 8

  1341         bits &= 0xFFFFFFFFL;

  1342 #endif

  1343         RETURN (__MKUINT(bits));

  1344     }

  1345 %}.

  1346     ^ self primitiveFailed

  1347 

  1348     "

  1349      (1 bitShift32:31) rotate32:0   

  1350      (1 bitShift32:31) rotate32:1   

  1351      (1 bitShift32:31) rotate32:-1   

  1352     "

  1353 !

  1354 

  1355 bitShift32:shiftCount

  1356     "return the value of the receiver shifted by shiftCount bits,

  1357      but only within 32 bits, shifting into/out-of the sign bit.

  1358      May be useful for communication interfaces, to create ST-numbers

  1359      from a signed 32bit int value given as individual bytes,

  1360      or to emulate C/Java semantics.

  1361      The shift is unsigned"

  1362 

  1363 %{  /* NOCONTEXT */

  1364 

  1365     unsigned INT bits;

  1366     int count;

  1367 

  1368     if (__isSmallInteger(shiftCount)) {

  1369         count = __intVal(shiftCount);

  1370         if (count >= 32) {

  1371             RETURN (__mkSmallInteger(0));

  1372         }

  1373 

  1374         bits = __unsignedLongIntVal(self);

  1375         if (count > 0) {

  1376             bits = bits << count;

  1377         } else {

  1378             bits = bits >> (-count);

  1379         }

  1380 #if __POINTER_SIZE__ == 8

  1381         bits &= 0xFFFFFFFFL;

  1382 #endif

  1383         RETURN (__MKUINT(bits));

  1384     }

  1385 %}.

  1386     ^ self primitiveFailed

  1387 

  1388     "

  1389      128 bitShift:24

  1390      128 bitShift32:24

  1391 

  1392      1 bitShift:31

  1393      1 bitShift32:31

  1394     "

  1395 !

  1396 

  1397 bitXor32:aNumber

  1398     "return the xor of the receiver and the argument.

  1399      The argument must be a SmallInteger or a 4-byte LargeInteger.

  1400      If the result overflows the 32 bit range, the value modulo 16rFFFFFFFF is returned.

  1401      This is of course not always correct, but allows for C/Java behavior to be emulated."

  1402 

  1403 %{  /* NOCONTEXT */

  1404     INT rslt;

  1405 

  1406     rslt =  __unsignedLongIntVal(self) ^ __unsignedLongIntVal(aNumber);

  1407 #if __POINTER_SIZE__ == 8

  1408     rslt &= 0xFFFFFFFFL;

  1409 #endif

  1410     RETURN ( __MKUINT(rslt));

  1411 %}.

  1412     self primitiveFailed

  1413 

  1414     "

  1415      16r7FFFFFFF bitXor: 16r80000000          4294967295

  1416      16r7FFFFFFF bitXor32: 16r80000000

  1417     "

  1418 ! !

  1419 

  1525 !

  1526 

  1527 asSigned32

  1528     "return a 32-bit integer with my bit-pattern. Receiver must be unsigned (i.e. positive).

  1529      May be required for bit operations on the sign-bit and/or to

  1530      convert C/Java numbers."

  1531 

  1532 %{  /* NOCONTEXT */

  1533     int rslt;

  1534 

  1535     rslt =  (int)(__unsignedLongIntVal(self));

  1536     RETURN ( __MKINT(rslt));

  1537 %}.

  1538     self primitiveFailed

  1539 

  1540     "

  1541      16r80000000 asSigned32

  1542      16r40000000 asSigned32

  1543     "

  1564 !

  1565 

  1566 asUnsigned32

  1567     "return a 32-bit integer with my bit-pattern. Receiver must be unsigned (i.e. positive).

  1568      May be required for bit operations on the sign-bit and/or to

  1569      convert C/Java numbers."

  1570 

  1571 %{  /* NOCONTEXT */

  1572     unsigned int rslt;

  1573 

  1574     rslt =  (int)(__unsignedLongIntVal(self));

  1575     RETURN ( __MKUINT(rslt));

  1576 %}.

  1577     self primitiveFailed

  1578 

  1579     "

  1580      16r80000000 asUnsigned32

  1581      16r40000000 asUnsigned32

  1582     "

  2457 !LargeInteger methodsFor:'modulu arithmetic'!

  2458 

  2459 plus32:aNumber

  2460     "return the sum of the receiver and the argument, as SmallInteger.

  2461      The argument must be another SmallInteger.

  2462      If the result overflows the 32 bit range, the value modulo 16rFFFFFFFF is returned.

  2463      This is of course not always correct, but allows for C/Java behavior to be emulated."

  2464 

  2465 %{  /* NOCONTEXT */

  2466     INT sum;

  2467 

  2468     sum =  __unsignedLongIntVal(self) + __unsignedLongIntVal(aNumber);

  2469 #if __POINTER_SIZE__ == 8

  2470     sum &= 0xFFFFFFFFL;

  2471 #endif

  2472     RETURN ( __MKUINT(sum));

  2473 %}.

  2474     self primitiveFailed

  2475 

  2476     "

  2477      16r7FFFFFFF + 1       ->  2147483648

  2478      16r7FFFFFFF plus32: 1 ->  -2147483648  

  2479     "

  2480 ! !

  2481 

  2563     	OBJ _digitByteArray = __INST(digitByteArray);

  5152