<?php
declare(strict_types=1);

use native_types;

function hallo() {
}

function simpleucall(int $n) {
  for ($i = 0; $i < $n; $i++)
    hallo();
}

function simpleudcall(int $n) {
  for ($i = 0; $i < $n; $i++)
    hallo2();
}

function hallo2() {
}

function simpleicall(int $n)
{
//    $array = [new ArrayObject()];
//    $o = $array[0];
    $o = new stdClass();
    for ($i = 0; $i < $n; $i++) {
//        $ret = function_exists('hallo');
//        $ret = class_exists('Foo2');
        $ret = get_class($o);
    }
}

class Foo {
    static int $a = 12;
    public int $b = 0;
    const TEST = 23;

    static function read_static(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $x = self::$a;
        }
    }

    static function write_static(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            self::$a = 0;
        }
    }

    static function isset_static(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $x = isset(self::$a);
        }
    }

    static function empty_static(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $x = empty(self::$a);
        }
    }

    static function f() {
    }

    static function call_static(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            self::f();
        }
    }

    function read_prop(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $x = $this->b;
        }
    }

    function write_prop(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $this->b = 0;
        }
    }

    function assign_add_prop(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $this->b += 2;
        }
    }

    function pre_inc_prop(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            ++$this->b;
        }
    }

    function pre_dec_prop(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            --$this->b;
        }
    }

    function post_inc_prop(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $this->b++;
        }
    }

    function post_dec_prop(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $this->b--;
        }
    }

    function isset_prop(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $x = isset($this->b);
        }
    }

    function empty_prop(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $x = empty($this->b);
        }
    }

    function g() {
    }

    function call(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $this->g();
        }
    }

    function read_const(int $n) {
        for ($i = 0; $i < $n; ++$i) {
            $x = $this::TEST;
        }
    }

}

function read_static(int $n) {
    for ($i = 0; $i < $n; ++$i) {
        $x = Foo::$a;
    }
}

function write_static(int $n) {
    for ($i = 0; $i < $n; ++$i) {
        Foo::$a = 0;
    }
}

function isset_static(int $n) {
    for ($i = 0; $i < $n; ++$i) {
        $x = isset(Foo::$a);
    }
}

function empty_static(int $n) {
    for ($i = 0; $i < $n; ++$i) {
        $x = empty(Foo::$a);
    }
}

function call_static(int $n) {
    for ($i = 0; $i < $n; ++$i) {
        Foo::f();
    }
}

function create_object(int $n) {
    for ($i = 0; $i < $n; ++$i) {
        $x = new Foo();
    }
}

function read_const(int $n) {
    for ($i = 0; $i < $n; ++$i) {
        $x = TEST_CONST_2;
    }
}

function read_auto_global(int $n) {
    for ($i = 0; $i < $n; ++$i) {
        $x = $_GET;
    }
}

function read_global_var(int $n) {
    for ($i = 0; $i < $n; ++$i) {
        $x = $GLOBALS['g_var'];
    }
}

function read_hash(int $n) {
    $hash = array('test' => 0);
    for ($i = 0; $i < $n; ++$i) {
        $x = $hash['test'];
    }
}

function read_str_offset(int $n) {
    $str = "test";
    for ($i = 0; $i < $n; ++$i) {
        $x = $str[1];
    }
}

function issetor(int $n)
{
    $val = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
    for ($i = 0; $i < $n; ++$i) {
        $x = $val ?: null;
    }
}

function issetor2(int $n) {
    $f = false; $j = 0;
    for ($i = 0; $i < $n; ++$i) {
        $x = $f ?: $j + 1;
    }
}

function ternary(int $n) {
    $val = array(0,1,2,3,4,5,6,7,8,9);
    $f = false;
    for ($i = 0; $i < $n; ++$i) {
        $x = $f ? null : $val;
    }
}

function ternary2(int $n) {
    $f = false; $j = 0;
    for ($i = 0; $i < $n; ++$i) {
        $x = $f ? $f : $j + 1;
    }
}

/*****/

function empty_loop(int $n) {
    for ($i = 0; $i < $n; ++$i) {
    }
}

function gethrtime()
{
    $hrtime = hrtime();
    return (($hrtime[0] * 1000000000.0 + $hrtime[1]) / 1000000000.0);
}

function start_test()
{
  ob_start();
  return gethrtime();
}

function end_test($start, $name, $overhead = null)
{
    global $total;
    global $last_time;
    $end = gethrtime();
    ob_end_clean();
    $last_time = $end - $start;
    $total += $last_time;
    $num = number_format($last_time, 3);
    $pad = str_repeat(" ", 24 - strlen($name) - strlen($num));
    if (is_null($overhead)) {
        echo $name . $pad . $num . "\n";
    } else {
        $num2 = number_format($last_time - $overhead, 3);
        echo $name . $pad . $num . "    " . $num2 . "\n";
    }
    ob_start();
    return gethrtime();
}

function total()
{
    global $total;
    $pad = str_repeat("-", 24);
    echo $pad . "\n";
    $num = number_format($total, 3);
    $pad = str_repeat(" ", 24 - strlen("Total") - strlen($num));
    echo "Total" . $pad . $num . "\n";
}

const N = 5000000;
const TEST = null;
const TEST_CONST_2 = 1999;

function main()
{
    global $total, $last_time, $g_var;
    $g_var = 0;
    $last_time = 0;
    $t0 = $t = start_test();
    empty_loop(N);
    $t = end_test($t, 'empty_loop');
    $overhead = $last_time;
    simpleucall(N);
    $t = end_test($t, 'func()', $overhead);
    simpleudcall(N);
    $t = end_test($t, 'undef_func()', $overhead);
    simpleicall(N);
    $t = end_test($t, 'int_func()', $overhead);
    Foo::read_static(N);
    $t = end_test($t, '$x = self::$x', $overhead);
    Foo::write_static(N);
    $t = end_test($t, 'self::$x = 0', $overhead);
    Foo::isset_static(N);
    $t = end_test($t, 'isset(self::$x)', $overhead);
    Foo::empty_static(N);
    $t = end_test($t, 'empty(self::$x)', $overhead);
    read_static(N);
    $t = end_test($t, '$x = Foo::$x', $overhead);
    write_static(N);
    $t = end_test($t, 'Foo::$x = 0', $overhead);
    isset_static(N);
    $t = end_test($t, 'isset(Foo::$x)', $overhead);
    empty_static(N);
    $t = end_test($t, 'empty(Foo::$x)', $overhead);
    Foo::call_static(N);
    $t = end_test($t, 'self::f()', $overhead);
    call_static(N);
    $t = end_test($t, 'Foo::f()', $overhead);
    $x = new Foo();
    $x->read_prop(N);
    $t = end_test($t, '$x = $this->x', $overhead);
    $x->write_prop(N);
    $t = end_test($t, '$this->x = 0', $overhead);
    $x->assign_add_prop(N);
    $t = end_test($t, '$this->x += 2', $overhead);
    $x->pre_inc_prop(N);
    $t = end_test($t, '++$this->x', $overhead);
    $x->pre_dec_prop(N);
    $t = end_test($t, '--$this->x', $overhead);
    $x->post_inc_prop(N);
    $t = end_test($t, '$this->x++', $overhead);
    $x->post_dec_prop(N);
    $t = end_test($t, '$this->x--', $overhead);
    $x->isset_prop(N);
    $t = end_test($t, 'isset($this->x)', $overhead);
    $x->empty_prop(N);
    $t = end_test($t, 'empty($this->x)', $overhead);
    $x->call(N);
    $t = end_test($t, '$this->f()', $overhead);
    $x->read_const(N);
    $t = end_test($t, '$x = $this::TEST', $overhead);
    create_object(N);
    $t = end_test($t, 'new Foo()', $overhead);
    read_const(N);
    $t = end_test($t, '$x = TEST', $overhead);
    read_auto_global(N);
    $t = end_test($t, '$x = $_GET', $overhead);
    read_global_var(N);
    $t = end_test($t, '$x = $GLOBALS[\'v\']', $overhead);
    read_hash(N);
    $t = end_test($t, '$x = $hash[\'v\']', $overhead);
    read_str_offset(N);
    $t = end_test($t, '$x = $str[0]', $overhead);
    issetor(N);
    $t = end_test($t, '$x = $a ?: null', $overhead);
    issetor2(N);
    $t = end_test($t, '$x = $f ?: tmp', $overhead);
    ternary(N);
    $t = end_test($t, '$x = $f ? $f : $a', $overhead);
    ternary2(N);
    $t = end_test($t, '$x = $f ? $f : tmp', $overhead);
    total();
}