Hi all,
I've already canvassed Ilia and Stas - can anyone else think of anything
I've missed/mis-explained here?
Thanks guys/guyess,
- Steph
UPGRADE NOTES - PHP 5.1
1. Changes in reference handling
a. Overview
b. Code that worked under PHP 4.3, but now fails
c. Code that was valid under PHP 4.3, but now throws an error
d. Code that failed under PHP 4.3, but now works
e. Code that 'should have worked' under PHP 5.0
f. Warnings that came and went
2. Reading []
3. instanceof, is_a(), is_subclass_of(), catch
4. MySQL support
5. SQLite support
6. Further migration information
===============================================================================
1. Reference handling
Overview
========
>From the PHP script writer's point of view, the change most likely to impact
legacy code is in the way that references are handled in all PHP versions
post-dating the PHP 4.4.0 release.
Until and including PHP 4.3, it was possible to send, assign or return variables
by reference that should really be returned by value, such as a constant, a
temporary value (e.g. the result of an expression), or the result of a function
that had itself been returned by value, as here:
<?php
$foo = "123";
function return_value() {
global $foo;
return $foo;
}
$bar = &return_value();
?>
Although this code would usually work as expected under PHP 4.3, in the general
case the result is undefined. The Zend Engine could not act correctly on these
values as references. This bug could and did lead to various hard-to-reproduce
memory corruption problems, particularly where the code base was large.
In PHP 4.4.0, PHP 5.0.4 and all subsequent PHP releases, the Engine was fixed
to 'know' when the reference operation is being used on a value that should
not be referenced. The actual value is now used in such cases, and a warning
is emitted. The warning takes the form of an E_NOTICE in PHP 4.4.0 and up,
and E_STRICT in PHP 5.0.4 and up.
Code that could potentially produce memory corruption can no longer do so.
However, some legacy code might work differently as a result.
Code that worked under PHP 4.3, but now fails
=============================================
<?php
function func(&$arraykey) {
return $arraykey; // function returns by value!
}
$array = array('a', 'b', 'c');
foreach (array_keys($array) as $key) {
$y = &func($array[$key]);
$z[] =& $y;
}
var_dump($z);
?>
Running the above script under any version of PHP that pre-dates the reference
fix would produce this output:
array(3) {
[0]=>
&string(1) "a"
[1]=>
&string(1) "b"
[2]=>
&string(1) "c"
}
Following the reference fix, the same code would result in:
array(3) {
[0]=>
&string(1) "c"
[1]=>
&string(1) "c"
[2]=>
&string(1) "c"
}
This is because, following the changes, func() assigns by value. The value
of $y is re-assigned, and reference-binding is preserved from $z. Prior
to the fix, the value was assigned by reference, leading $y to be
re-bound on each assignment. The attempt to bind to a temporary value
by reference was the cause of the memory corruption.
Such code can be made to work identically in both the pre-fix and the
post-fix PHP versions. The signature of func() can be altered to return
by reference, or the reference assignment can be removed from the result
of func().
<?php
function func() {
return 'function return';
}
$x = 'original value';
$y =& $x;
$y = &func();
echo $x;
?>
In PHP 4.3 $x would be 'original value', whereas after the changes it would
be 'function return' - remember that where the function does not return by
reference, the reference assignment is converted to a regular assignment.
Again, this can be brought to a common base, either by forcing func() to
return by reference or by eliminating the by-reference assignment.
Code that was valid under PHP 4.3, but now throws an error
==========================================================
<?php
class Foo {
function getThis() {
return $this;
}
function destroyThis() {
$baz =& $this->getThis();
}
}
$bar = new Foo();
$bar->destroyThis();
var_dump($bar);
?>
In PHP 5.0.3, $bar evaluated to NULL instead of returning an object.
That happened because getThis() returns by value, but the value here
is assigned by reference. Although it now works in the expected way,
this is actually invalid code which will throw an E_NOTICE under
PHP 4.4 or an E_STRICT under PHP 5.0.4 and up.
Code that failed under PHP 4.3, but now works
=============================================
<?php
function &f() {
$x = "foo";
var_dump($x);
print "$x\n";
return($a);
}
for ($i = 0; $i < 3; $i++) {
$h = &f();
}
?>
In PHP 4.3 the third call to var_dump produces NULL, due to the memory
corruption caused by returning an uninitialized value by reference.
This is valid code in PHP 5.0.4 and up, but threw errors in earlier
releases of PHP.
<?php
$arr = array('a1' => array('alfa' => 'ok'));
$arr =& $arr['a1'];
echo '-'.$arr['alfa']."-\n";
?>
Until PHP 5.0.5, it wasn't possible to assign an array element by
reference in this way. It now is.
Code that 'should have worked' under PHP 5.0
============================================
There are a couple of instances of bugs reported under PHP 5.0 prior
to the reference fixes which now 'work'. However, in both cases errors
are thrown by PHP 5.1, because the code was invalid in the first place.
Returning values by reference using self:: now works in the general
case but throws an E_STRICT warning, and although your mileage may
vary when assigning by reference to an overloaded object, you will
still see an E_ERROR when you try it, even where the assignment
itself appears to work.
Warnings that came and went
===========================
<?php
function & foo() {
$var = 'ok';
return $var;
}
function & bar() {
return foo();
}
$a =& bar();
echo "$a\n";
?>
Nested calls to functions returning by reference are valid code under both
PHP 4.3 and PHP 5.1, but threw an unwarranted E_NOTICE or E_STRICT under
the intervening PHP releases.
2. Reading []
=============
<?php
class XmlTest {
function test_ref(&$test) {
$test = "ok";
}
function test($test) { }
function run() {
$ar = array();
$this->test_ref($ar[]);
var_dump($ar);
$this->test($ar[]);
}
}
$o = new XmlTest();
$o->run();
?>
This should always have thrown a fatal E_ERROR, because [] cannot be
used for reading. It is invalid code in PHP 4.4.2 and PHP 5.0.5 upward.
3. instanceof, is_a(), is_subclass_of(), catch
==============================================
In PHP 5.0, is_a() was deprecated and replaced by the "instanceof" operator.
There were some issues with the initial implementation of "instanceof", which
relied on __autoload() to search for missing classes. If the class was not
present, "instanceof" would throw a fatal E_ERROR due to the failure of
__autoload() to discover that class. The same behaviour occurred in the
"catch" operator and the is_subclass_of() function, for the same reason.
None of these functions or operators call __autoload() in PHP 5.1, and
the workarounds used in PHP 5.0 are no longer necessary.
4. MySQL support
================
In PHP 4, MySQL 3 support was built-in. With the release of PHP 5.0 there
were two MySQL extensions, named 'mysql' and 'mysqli', which were designed
to support MySQL < 4.1 and MySQL 4.1 and up, respectively. PHP 5.1 introduces
PHP Data Objects, or PDO, which provides a very fast interface to all the
database APIs supported by PHP. It is strongly recommended that you use PDO and
the PDO_MYSQL database driver, which can support any of the current versions
(MySQL 3, 4 or 5) in new PHP code, depending on the MySQL library version used
during compilation. The older extensions remain in place for reasons of back
compatibility, but are not enabled by default.
5. SQLite support
=================
In PHP 5.0, SQLite 2 support was built-in. Due to the advent of SQLite 3
and PHP Data Objects, the SQLite engine is no longer statically built into
PHP by default. The PDO_SQLITE driver communicates with the SQLite 3 engine,
and the sqlite extension remains in place only for reasons of back
compatibility.
Note that the sqlite extension is now reliant on PDO under win32. The intention
is to allow support for legacy SQLite 2 code alongside newly written SQLite 3
code; the PDO, sqlite and PDO_SQLITE extensions should all be enabled.
PDO_SQLITE
also supports SQLite 2, and can be used to communicate with either SQLite 2
and SQLite 3 via the DSN (Data Source Name) specified in PDO::__construct().
6. Further migration information
================================
For general information about migrating from PHP 4 to PHP 5, please refer to
the relevant section in the PHP manual at
http://www.php.net/manual/migration5.php.
--
PHP Internals - PHP Runtime Development Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
