with timing method that you used, you not calculated these levels but parsing.
when you use eval(), PHP will compile PHP code.

unfortunately, PHP is an slow scripting language and because of this, there are dozen’s of compiler extensions for PHP like APC, ionCube, eAccelerator, Zend, …

because of this problem, I have writen my own database, webserver and my blog and forums systems with C running on CentOS.
It’s about 25x faster (in average) in my tests. (in some cases, more than 70x)

Here it is:
Hi, i wanted to get rid off the parent::methodName(myVar1, myVar2, myVar3 etc…..) construction so i wrote a shortcut to this notation. The only thing you have to do is calling $this->inherited() (or parent::inherited()) to call the same function with the same parameters in the parent class. It is also possible to specify other parameters if you like (also by reference). You can also use this inside constructors/destructors. It is also possible (without rewriting an existing php4 ‘base’ class and it’s constructors/destructors) to use a php4 class as base class in php5, anyway look at the source code below.

IMPORTANT TO KNOW:
- $this->raise() is a custom error function, it displays trace info when called
- There are some defines used to display, these are not included in this demo (but doesn’t care)
- TObject is an custom base object that have the inherited() function as described below.

The function (used in base class of all objects):
public function inherited()
{
// Use DEBUG backtrace to trace caller function
$bt = debug_backtrace($this);
$bt = $bt[ 1 ]; // List is in reversed order, 0 reffers to this function so get previous one

if( !@count( $bt ))
{ $this->raise( ERR_DEBUGTRACE_INFO_INVALID ); }

$sFuncName = $bt["function"];
$sClassName = $bt["class"];
$sParentClassName = get_parent_class( $sClassName );

// check absurt situations to be sure
if( empty( $sClassName ) or empty( $sParentClassName ) or $sParentClassName == $sClassName )
{ $this->raise( str_replace( array( “%s1″, “%s2″ ), array( $sFuncName, $sClassName ), ERR_CANNOT_CALL_INHERITED )); }

// constructor or destructor called (or calls and old fashion way php 4 constructor or destructor)?
$bIsConstruct = false;
if( ( $bIsConstructor = ( $sFuncName == “__construct” ))
or ( $bIsDestructor = ( $sFuncName == “__destruct” ))
or ( $bIsConstruct = ( $sFuncName == $sClassName )) or ( $sFuncName == “_”.$sClassName ) )
{
// get parent constructor/destructor
$sFuncName = (( !$bIsConstructor and !$bIsConstruct ) ? “_” : “” ).$sParentClassName;

$bFunctionExist = method_exists( $sParentClassName, $sFuncName );
$bConstructorExist = ( $bIsConstructor or $bIsConstruct ) ? method_exists( $sParentClassName, “__construct” ) : false;
$bDestructorExist = ( !$bIsConstructor or !$bIsConstruct ) ? method_exists( $sParentClassName, “__destruct” ) : false;

if( $bConstructorExist or $bDestructorExist )
{
$sFuncName = ( $bConstructorExist ) ? “__construct” : “__destruct”; // preffer to call this
$bIsConstruct = !$bDestructorExist;
$bIsConstructor = false;
$bFunctionExist = true;
}
elseif( $bFunctionExist and !$bIsConstructor and !$bIsDestructor )
{ $bFunctionExist = ( $sFuncName != (( !$bIsConstruct ) ? “_” : “” ).$sClassName ); }

if( !$bFunctionExist )
{ $this->raise( str_replace( array( “%s1″, “%s2″ ), array( $sFuncName, $sParentClassName ), ( $bIsConstruct ) ? ERR_CANNOT_CALL_INHERITED_CONSTRUCTOR : ERR_CANNOT_CALL_INHERITED_DESTRUCTOR )); }
}
else { $bFunctionExist = method_exists( $sParentClassName, $sFuncName ); }

if( $bFunctionExist )
{
// If there are parameters specified, use these
$args = func_get_args();
if( ( $iCount = @count( $args )) 0 )
{
for( $i = 0; $i < $iCount; $i++ )
{ $sArgs.=”&$”.”args[$i]“.( $i raise( str_replace( array( “%s1″, “%s2″ ), array( $sFuncName, $sParentClassName ), ERR_CANNOT_CALL_INHERITED )); }
}

example (DEMO):
class TTest extends TObject
{
public function __construct()
{
$this->inherited();
}

public function __destruct()
{
print( “destructror called TTest\n” );
$this->inherited();
}

public function test(&$param1)
{
$param1 = $param1.” world”;
return $param1.” “.$this->className;
}
}

class TTest2 extends TTest
{
public function __construct()
{
$this->inherited();
}

public function __destruct()
{
print( “destructror called TTest2\n” );
$this->inherited();
}

public function test(&$param1)
{
return $this->inherited();
}
}

class TTest3 extends TTest2
{
public function __construct()
{
$this->inherited();
}

public function test(&$param1)
{
return $this->inherited();
}

public function __destruct()
{
print( “destructror called TTest3\n” );
$this->inherited();
}

}

$test = new TTest3();
$s = “hello”;
print( “\nOrginal reference string is : $s\n” );
print( “function result is : “.$test->test( $s ).”\n” );
print( “Modified reference string is: $s\n\n” );

So what do u think?

Eval: 1000000 times took 8.4494090080261
Same code not eval: 1000000 times took 0.83726000785828
Loop in eval took 1.0076489448547

You can see: executing code in eval is not the problem – envoking it so many times is.

Jorge