http://php.net/generator in PHP >= 5.5.0, PHP 7

Add unit test where a generator function/method is invoked, then runkit_function_remove/redefine or runkit_method_remove/redefine is called, then the generator is resumed.

This bug is probably unlikely to happen accidentaly.

Follow up for https://github.com/runkit7/runkit7/pull/107/files

Continue forbidding it for classes which existed before the call to runkit_import

#30

https://www.appveyor.com/docs/build-configuration/#build-matrix

The binary APIs have changed in https://wiki.php.net/rfc/class_const_visibility

See https://wiki.php.net/rfc/class_const_visibility#patches_and_tests

If a extension accesses non-public structures (the now non-existent class_constants HashTable) there will be breakage

• New optional param types, optional return types (Probably not going to require changes)
• Closure::fromCallable - May require changes (e.g. Closure::fromCallable('foo') should be affected by runkit operations on 'foo')
• runkit_function_* and runkit_method_* where source is a Closure
• iterable type, nullable types,

The goal is to add integration tests for commits, and a build status in the README. The travis config would be similar to the travis config for the project phalcon/cphalcon

Travis's binaries are built with these config flags :
https://github.com/travis-ci/travis-cookbooks/blob/precise-stable/ci_environment/phpbuild/templates/default/default_configure_options.erb

Also useful to test with/without xdebug, without --enable-maintainer-zts

https://docs.travis-ci.com/user/languages/php#PHP-extensions

Haven't used phpdbg before, not sure how runkit works.

In the 32-bit build: https://travis-ci.org/runkit7/runkit7/jobs/181707446

TEST 79/155 [tests/runkit_function_rename_redefine_add_remove.phpt]
========DIFF========
002+ Illegal instruction (core dumped)
002- a%d
003- %d
004+ Termsig=4
005- %d
006- a%d
007- %d
========DONE========

Currently, the workaround is to remove leading backslashes (preg_replace('/^(\??)\\\\/', '\1', $returnTypeString);)

Follow up for #1

Both for methods built from closures and for methods built from strings.

Follow up for https://github.com/runkit7/runkit7/pull/107/files

The anonymous classes won't be referenced anywhere, so there's no reason to import those. https://secure.php.net/manual/en/language.oop5.anonymous.php

Verify memory is freed properly, classes are destroyed, import can be run multiple times.

Add unit tests.

New parameters will be added, e.g. for return types

Different methods will be added, e.g. for modifying (not adding/removing) default properties)

Document known bugs in methods that can't be fixed (E.g. aggressive php inlining of constants).

This is uncommon, but has no tests (and I haven't used the static function syntax)

https://secure.php.net/manual/en/functions.anonymous.php#functions.anonymous-functions.static

• What happens if they are used to redefine an instance method? A static method? A function?

Currently, all redefined constants have the default public visibility.

For php 7.1 builds, add another parameter to runkit_constant_redefine/add after the rest of the parameters (int $visibility = RUNKIT_ACC_PUBLIC|RUNKIT_ACC_PROTECTED|RUNKIT_ACC_PRIVATE)

• runkit_constant_redefine should preserve existing visibility by default
• runkit_constant_add should make visibility public by default.

This was temporarily disabled because it depended on redefining properties of objects (instances), which was impractical in php 7.0+.
However, importing classes and functions which don't already exist should be possible. The code hasn't yet been ported to compile with the php 7.0 data structures and APIs, and may have to be restored from git.

If RUNKIT_IMPORT_OVERRIDE is enabled, then when combined with the below flags:

• RUNKIT_IMPORT_CLASS_PROPS - Likely not possible if instances already exist. (By extension, RUNKIT_IMPORT_CLASSES isn't possible)
• RUNKIT_IMPORT_CLASS_STATIC_PROPS - Have to investigate how the PHP interpreter handles accesses to static properties --- It's similar to instance properties. The property names are converted to indices, and C code knowing the index can quickly access those properties(for internal functions).
• RUNKIT_IMPORT_FUNCTIONS, RUNKIT_IMPORT_CLASS_METHODS, RUNKIT_IMPORT_CLASS_CONSTS: doable?

If RUNKIT_IMPORT_OVERRIDE is disabled, then any of the other flags can probably be used

• But in the case with no overrides, one may be able to do something similar using PHP-Parser and php-ast to extract only the top-level class/function definitions.

See #72

EDIT: earlier description mixed up constants.

Unlike other extensions, runkit's performance for runkit_*_add/redefine gets worse if there are a large number of objects in use.

Consider adding an option to automatically trigger garbage collection based on these factors, whenever runkit_*_add/redefine is called:

• runkit config settings
• Number of potential cycles http://php.net/manual/en/features.gc.collecting-cycles.php
• Total number of objects
• Number of cycles cleaned up the last time

Currently, runkit only supports arrays.

This bug affects upstream for 5.6 as well.

• Forbid class constants as resources but allow global constants - That's impossible for regular php code, so the interpreter may reject that now/in the future.
• Properly free resources when calling runkit_constant_remove.

This is done in runkit_constants.c, search for IS_RESOURCE

When adding/redefining a method with a string body.

Runkit defines functions by eval('function foo($args) { body}');

Possible solutions:

1. Instead of creating a temporary global function, create a temporary global method, and copy the byte code from that
2. Rename self to the class name in which the function is defined?

This encounters an assertion failure when --enable-debug is used.

PHP 7.2 supports the same features as PHP 7.1. However, php 8 may be different

Supposedly, a future release of PHP (8.0?) will have a JIT compiler. See http://news.php.net/php.internals/95531

• If function inlining within a file (e.g. for private or final methods) becomes part of a future release, then document this limitation.
• If a new opcode format is infeasible to work with (e.g. to clear cache), document this
• If it's possible to disable optimizations in order to make runkit7 continue working, document how this will be done

There is still more work to do on the following:

1. Deciding on API for specifying return types, error handling for the API, defining what is possible, specifying how subclasses should be affected, etc.
2. Writing test cases
3. implementing this

Clearing the runtime cache of all functions is slow. This can be sped up slightly by deferring cache clearing, if multiple functions are renamed, redefined, or removed in the same batch

Two ways of implementing this seem possible. The 2nd one avoids certain ways it could crash.

1. runkit_manipulate_batch(function() { runkit_method_rename..., runkit_method_add..., runkit_method_rename..., runkit_method_add...});
2. runkit_manipulate_batch([[['runkit_method_rename', ...$args], ['runkit_method_add', ...$args]], [['runkit_method_rename', ...$args], ['runkit_method_add', ...$args]]]
   (This would return an array of arrays, corresponding to whether or not each step succeeded.)
   (If one of the steps in a list failed (returned false), then don't execute the remaining ones (and treat those as having failed). Multiple lists can be provided.)

When PHP7 functions are called, there are three phases: 1. initializing, 2. passing arguments, and 3. calling the function.

During the initialization phase, the amount of stack space needed by the called function is determined and allocated

In PHP7, new opcodes were introduced, which would precalculate the amount of stack space needed, instead of calculating it every time. This makes the PHP VM faster, but causes runkit redefined functions to now sometimes not have enough stack space (Depends on the number of arguments being passed, and the number of temporary variables)

INIT_FCALL_SPEC_CONST_HANDLER will have the precomputed stack size in opline.op1.result

 /* FOR ZEND_INIT_FCALL_SPEC_CONST_HANDLER */
// Add a stack frame with opline->op1.num bytes of memory
call = zend_vm_stack_push_call_frame_ex(
               opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
               fbc, opline->extended_value, NULL, NULL);
       call->prev_execute_data = EX(call);
       EX(call) = call;
/* FOR ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER */
// Add a stack frame with a dynamically calculated number of bytes of memory.
call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
    fbc, opline->extended_value, NULL, NULL);
call->prev_execute_data = EX(call);
EX(call) = call; 


// FOR ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER
// NOTE: there are others as well.
// call_info has a collection of bit flags. The calculation of the stack frame size is based on fbc (zend_function*).
call = zend_vm_stack_push_call_frame(call_info,
        fbc, opline->extended_value, called_scope, object);
call->prev_execute_data = EX(call);
EX(call) = call;

Solutions:

1. Iterate through all method, function, closure definitions. Replace all opcodes of type ZEND_INIT_FCALL_SPEC_CONST_HANDLER (and the case insensitive modified function name) with the less optimized ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER (May be infeasible and possibly break with some opcache options), and so on
2. In runkit_function_redefine/add, create extremely simple methods which have no temporary variables and call the provided function definition with the expected func_num_args() (i.e. add a second stack frame)

Branch try-support-internal-functions-v2 contains notes on this (and work on fixing internal method modification)
tests/runkit_function_redefine_var_dump.phpt is failing because of this issue.

e.g. static variables in the renamed methods

Support nullable return types and parameters.

https://github.com/nikic/php-ast/blob/master/ast.c does that. The zend parse functions seem to be public.

This may or may not not have everything that php -l does - Not sure if the AST builder detects invalid method signatures

PHP engine optimizations made changing the total number of properties more problematic (Especially if there were objects that already existed).

• Can't do that without reallocating the zend_object, which may break other extensions.

https://github.com/TysonAndre/runkit7/pull/2

e.g.

class Foo {
   private string $_bar = 'baz';
}

throw TypeError if methodname isn't a string, etc.

Some of them would use varargs due to multiple signatures. (runkit_function_add(string $functionName, ...$args))?

Is there any other function that can replace 'runkit_import' in php7?Please tell us,thank you!

Saw this when configure flags included --enable-debug .

runkit_function_redefine doesn't affect internal functions.
the following code:

<?php
function testme() {
  echo strlen("Original Testme Implementation")."\n";
}
testme();
runkit_function_redefine('strlen','$string','return "5";');
testme();

Gives this result:

30
30

This is the result with internal_override off:

30
PHP Warning:  runkit_function_redefine(): strlen() is an internal function and runkit.internal_override is disabled in 2run.php on line 6
30

runkit_function_redefine doesn't work either (Except for other runkit related functions):

<?php
runkit_function_remove('strlen');
$var='some string to be measured';
echo "The length of '{$var}' is  ".strlen($var)."\n";

returns The length of 'some string to be measured' is 26

PHP version:

PHP 7.0.10-1~dotdeb+8.1 (cli) ( NTS )
Copyright (c) 1997-2016 The PHP Group
Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies

Regards.

7.1 RCs have more failures than 7.0 right now

And add tests to enforce this behavior

• Is it always going to be false? Investigate how the PHP engine know if a given zend_function is strict.
• Add an optional ?bool to the argument lists to add/redefine methods, make this set the strictness, if possible
• When eval()ing code to create a new zend_function, set this directive at the top.
• Also figure out how to handle copying the contents of a closure directly into a added function/method.

Run php-fpm under gdb, try to figure out why rtrim isn't available on fpm runs after the first one (String key being freed early? Function deleted by something else? Runkit shutdown running too late/early?)

Intermediate work is on the branch WIP-investigate-fpm-failure

https://travis-ci.org/runkit7/runkit7/jobs/181038599

Branch is in progress, at fix-superglobals-bugs

We're using a plugin-architecture here for a running php websocket server. Each plugin providing a small subset of features. However the lack of unloading our plugin classes, updating them, and reloading the updated ones is resulting in the silly requirement to halt the whole application to avoid "class already exists" errors, which causes all open connections to get closed. So in theory all we need is unset(MyClass::class); to let the autoloader re-do its magic. As this is the only functionality we need, we could accept if all other methods are disabled due to buggy behavior.

Related to #104

Update implementation as well as issue message: runkit_method_add(): Return type should match regex ^\??[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$

Official docker images exist for php, see https://hub.docker.com/r/library/php/tags/

I'm fairly sure this isn't done yet. user-defined replacements use aliases to user-defined functions, and those aliases aren't followed when clearing run time caches.

This affects php >= 7.0, only when runkit.internal_override=On