Try something like this:

$var1 = 0x7FFFFFFF;
$var2 = 0xFFFFFFFF;
$var3 = 0x8FFFFFFF;
$var4 = 0x9FFFFFFF;
$var5 = 0x8FFFFFF1;
$var6 = 0x80000001;
$var7 = $var1 + 0x7FFFFFFF;
$var8 = (0x08FFFFFF << 4);
$var9 = intval("AFFFFFFF", 16);
echo $var1; echo "\n";
echo $var2; echo "\n";
echo $var3; echo "\n";
echo $var4; echo "\n";
echo $var5; echo "\n";
echo $var6; echo "\n";
echo $var7; echo "\n";
echo $var8; echo "\n";
echo $var9; echo "\n";

Results:

2147483647
0
0
0
0
0
4294967294
-1879048208
2147483647

("\n" is separated so we don't accidentally cause the interpreter to convert the vars to strings before printing them)

var1 prints out (correctly) 2147483647

var2 prints out 0, leading me to believe that PHP deals with integers as signed 32-bit, by default (even though FFFFFFFF should be -1, not 0).  However, if that's the case, var4 through var6 should print out some version of a negative number.  Instead they print out 0 as well.

Then, looking at var7, we see that you *can* assign and print a value greater than 7FFFFFFF in unsigned mode, *if* you add to it to increment the value to that size, as opposed to directly assigned it using the '0x' operator.  However, var8 shows that shifting left doesn't afford the same 'convenience'.

Using intval doesn't help either.  As you can see from var9, not only does intval not translate AFFFFFFF to the proper unsigned 32 bit integer, it doesn't even translate it to the proper signed 32 bit integer!  In fact, it's as if the 32nd bit is forcibly turned off - *any* hex number beyond 7FFFFFFF is returned by intval as 2147483647.

At the very least all of these operations should have consistent behavior.  Preferably there would be a way to specify signed or unsigned operations as well.  And it would be *really* nice to have an unsigned type.

./configure --with-apache=../apache_1.3.12i --enable-sysvsem --enable-sysvshm --enable-wddx --enable-xml --with-pgsql=/usr/local/postgres --enable-track-vars --enable-trans-sid --enable-session